replace ssort with check-python-script

Author: pbizopoulos

latex/python/Makefile

@@ -22,7 +22,7 @@ main.py:
 	touch $@
 
 pyproject.toml:
-	printf '[project]\nname = "UNKNOWN"\nversion = "0.0.0"\n\n[project.optional-dependencies]\ndev = ["coverage","djlint","mypy","ruff","ssort","toml-sort"]' > $@
+	printf '[project]\nname = "UNKNOWN"\nversion = "0.0.0"\n\n[project.optional-dependencies]\ndev = ["coverage","djlint","mypy","ruff","check-python-script@https://api.github.com/repos/pbizopoulos/check-python-script/tarball#subdirectory=python","toml-sort"]' > $@
 
 tmp:
 	mkdir $@
@@ -51,7 +51,7 @@ tmp/check-done: .dockerignore .gitignore Dockerfile main.py pyproject.toml
 		--volume $$(pwd):/usr/src/app/ \
 		$$(docker image build --quiet .) /bin/sh -c '\
 		toml-sort --all --in-place pyproject.toml && \
-		ssort main.py && \
+		check-python-script main.py && \
 		ruff format --cache-dir tmp/ruff main.py && \
 		ruff check --cache-dir tmp/ruff --fix --select ALL --unsafe-fixes main.py && \
 		mypy --cache-dir tmp/mypy --ignore-missing-imports --install-types --non-interactive --strict main.py && \

latex/python/main.py

@@ -60,17 +60,6 @@ def forward(self: _Alexnet, signal: torch.Tensor) -> torch.Tensor:
         return output
 
 
-def _conv3x3(in_planes: int, out_planes: int, stride: int = 1) -> nn.Module:
-    return nn.Conv1d(
-        in_planes,
-        out_planes,
-        kernel_size=3,
-        stride=stride,
-        padding=1,
-        bias=False,
-    )
-
-
 class _BasicBlock(nn.Module):
     def __init__(
         self: _BasicBlock,
@@ -102,10 +91,6 @@ def forward(self: _BasicBlock, signal: torch.Tensor) -> torch.Tensor:
         return output
 
 
-def _conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Module:
-    return nn.Conv1d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
-
-
 class _Bottleneck(nn.Module):
     def __init__(
         self: _Bottleneck,
@@ -143,26 +128,6 @@ def forward(self: _Bottleneck, signal: torch.Tensor) -> torch.Tensor:
         return output
 
 
-def _replace_last_layer(
-    num_classes: int,
-    model_base: nn.Module,
-    model_file_name: str,
-) -> nn.Module:
-    if model_file_name.startswith(("alexnet", "vgg")):
-        model_base.classifier[-1] = nn.Linear(
-            model_base.classifier[-1].in_features,
-            num_classes,
-        )
-    elif model_file_name.startswith("resnet"):
-        model_base.fc = nn.Linear(model_base.fc.in_features, num_classes)
-    elif model_file_name.startswith("densenet"):
-        model_base.classifier = nn.Linear(
-            model_base.classifier.in_features,
-            num_classes,
-        )
-    return model_base
-
-
 class _CNNOneLayer(nn.Module):
     def __init__(
         self: _CNNOneLayer,
@@ -206,6 +171,24 @@ def forward(self: _CNNTwoLayers, signal: torch.Tensor) -> torch.Tensor:
         return output
 
 
+class _DenseBlock(nn.Sequential):
+    def __init__(
+        self: _DenseBlock,
+        bn_size: int,
+        growth_rate: int,
+        num_input_features: int,
+        num_layers: int,
+    ) -> None:
+        super().__init__()
+        for index in range(num_layers):
+            layer = _DenseLayer(
+                bn_size,
+                growth_rate,
+                num_input_features + index * growth_rate,
+            )
+            self.add_module("denselayer%d" % (index + 1), layer)
+
+
 class _DenseLayer(nn.Sequential):
     def __init__(
         self: _DenseLayer,
@@ -245,46 +228,6 @@ def forward(self: _DenseLayer, signal: torch.Tensor) -> torch.Tensor:
         return torch.cat([signal, new_features], 1)
 
 
-class _DenseBlock(nn.Sequential):
-    def __init__(
-        self: _DenseBlock,
-        bn_size: int,
-        growth_rate: int,
-        num_input_features: int,
-        num_layers: int,
-    ) -> None:
-        super().__init__()
-        for index in range(num_layers):
-            layer = _DenseLayer(
-                bn_size,
-                growth_rate,
-                num_input_features + index * growth_rate,
-            )
-            self.add_module("denselayer%d" % (index + 1), layer)
-
-
-class _Transition(nn.Sequential):
-    def __init__(
-        self: _Transition,
-        num_input_features: int,
-        num_output_features: int,
-    ) -> None:
-        super().__init__()
-        self.add_module("norm", nn.BatchNorm1d(num_input_features))
-        self.add_module("relu", nn.ReLU())
-        self.add_module(
-            "conv",
-            nn.Conv1d(
-                num_input_features,
-                num_output_features,
-                kernel_size=1,
-                stride=1,
-                bias=False,
-            ),
-        )
-        self.add_module("pool", nn.AvgPool1d(kernel_size=2, stride=2))
-
-
 class _DenseNet(nn.Module):
     def __init__(
         self: _DenseNet,
@@ -399,30 +342,7 @@ def forward(self: _Lenet, signal: torch.Tensor) -> torch.Tensor:
         return output
 
 
-M = TypeVar("M", _BasicBlock, _Bottleneck)
-
-
 class _ResNet(nn.Module):
-    def _make_layer(  # noqa: PLR0913
-        self: _ResNet,
-        block: type[M],
-        blocks: int,
-        expansion: int,
-        planes: int,
-        stride: int = 1,
-    ) -> nn.Module:
-        downsample = None
-        if stride != 1 or self.inplanes != planes * expansion:  # type: ignore[has-type]
-            downsample = nn.Sequential(
-                _conv1x1(self.inplanes, planes * expansion, stride),  # type: ignore[has-type]
-                nn.BatchNorm1d(planes * expansion),
-            )
-        layers = [block(downsample, self.inplanes, planes, stride)]  # type: ignore[has-type]
-        self.inplanes = planes * expansion
-        for _ in range(1, blocks):
-            layers.append(block(None, self.inplanes, planes))  # noqa: PERF401
-        return nn.Sequential(*layers)
-
     def __init__(
         self: _ResNet,
         block: type[M],
@@ -453,6 +373,26 @@ def __init__(
                 nn.init.constant_(module.weight, 1)
                 nn.init.constant_(module.bias, 0)
 
+    def _make_layer(  # noqa: PLR0913
+        self: _ResNet,
+        block: type[M],
+        blocks: int,
+        expansion: int,
+        planes: int,
+        stride: int = 1,
+    ) -> nn.Module:
+        downsample = None
+        if stride != 1 or self.inplanes != planes * expansion:
+            downsample = nn.Sequential(
+                _conv1x1(self.inplanes, planes * expansion, stride),
+                nn.BatchNorm1d(planes * expansion),
+            )
+        layers = [block(downsample, self.inplanes, planes, stride)]
+        self.inplanes = planes * expansion
+        for _ in range(1, blocks):
+            layers.append(block(None, self.inplanes, planes))  # noqa: PERF401
+        return nn.Sequential(*layers)
+
     def forward(self: _ResNet, signal: torch.Tensor) -> torch.Tensor:
         out = self.conv1(signal)
         out = self.bn1(out)
@@ -534,6 +474,28 @@ def forward(self: _Spectrogram, signal: torch.Tensor) -> torch.Tensor:
         return self.model_base(out)  # type: ignore[no-any-return]
 
 
+class _Transition(nn.Sequential):
+    def __init__(
+        self: _Transition,
+        num_input_features: int,
+        num_output_features: int,
+    ) -> None:
+        super().__init__()
+        self.add_module("norm", nn.BatchNorm1d(num_input_features))
+        self.add_module("relu", nn.ReLU())
+        self.add_module(
+            "conv",
+            nn.Conv1d(
+                num_input_features,
+                num_output_features,
+                kernel_size=1,
+                stride=1,
+                bias=False,
+            ),
+        )
+        self.add_module("pool", nn.AvgPool1d(kernel_size=2, stride=2))
+
+
 class _UCIEpilepsy(Dataset[tuple[torch.Tensor, torch.Tensor]]):
     def __init__(
         self: _UCIEpilepsy,
@@ -592,20 +554,6 @@ def __len__(self: _UCIEpilepsy) -> int:
 
 
 class _VGG(nn.Module):
-    def _initialize_weights(self: _VGG) -> None:
-        for module in self.modules():
-            if isinstance(module, nn.Conv1d):
-                nn.init.kaiming_normal_(
-                    module.weight,
-                    mode="fan_out",
-                    nonlinearity="relu",
-                )
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-            elif isinstance(module, nn.Linear):
-                nn.init.normal_(module.weight, 0, 0.01)
-                nn.init.constant_(module.bias, 0)
-
     def __init__(self: _VGG, num_classes: int, features: nn.Module) -> None:
         super().__init__()
         self.features = features
@@ -620,13 +568,42 @@ def __init__(self: _VGG, num_classes: int, features: nn.Module) -> None:
         )
         self._initialize_weights()
 
+    def _initialize_weights(self: _VGG) -> None:
+        for module in self.modules():
+            if isinstance(module, nn.Conv1d):
+                nn.init.kaiming_normal_(
+                    module.weight,
+                    mode="fan_out",
+                    nonlinearity="relu",
+                )
+                if module.bias is not None:
+                    nn.init.constant_(module.bias, 0)
+            elif isinstance(module, nn.Linear):
+                nn.init.normal_(module.weight, 0, 0.01)
+                nn.init.constant_(module.bias, 0)
+
     def forward(self: _VGG, signal: torch.Tensor) -> torch.Tensor:
         out = self.features(signal)
         out = out.view(out.size(0), -1)
         output: torch.Tensor = self.classifier(out)
         return output
 
 
+def _conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Module:
+    return nn.Conv1d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+def _conv3x3(in_planes: int, out_planes: int, stride: int = 1) -> nn.Module:
+    return nn.Conv1d(
+        in_planes,
+        out_planes,
+        kernel_size=3,
+        stride=stride,
+        padding=1,
+        bias=False,
+    )
+
+
 def _densenet121(num_classes: int) -> nn.Module:
     return _DenseNet(
         block_config=(6, 12, 24, 16),
@@ -676,6 +653,26 @@ def _make_layers(cfg: list) -> nn.Module:  # type: ignore[type-arg]
     return nn.Sequential(*layers)
 
 
+def _replace_last_layer(
+    num_classes: int,
+    model_base: nn.Module,
+    model_file_name: str,
+) -> nn.Module:
+    if model_file_name.startswith(("alexnet", "vgg")):
+        model_base.classifier[-1] = nn.Linear(
+            model_base.classifier[-1].in_features,
+            num_classes,
+        )
+    elif model_file_name.startswith("resnet"):
+        model_base.fc = nn.Linear(model_base.fc.in_features, num_classes)
+    elif model_file_name.startswith("densenet"):
+        model_base.classifier = nn.Linear(
+            model_base.classifier.in_features,
+            num_classes,
+        )
+    return model_base
+
+
 def _resnet101(num_classes: int) -> nn.Module:
     return _ResNet(_Bottleneck, num_classes, expansion=4, layers=[3, 4, 23, 3])
 
@@ -1007,5 +1004,8 @@ def _main() -> None:  # noqa: C901,PLR0912,PLR0915
         plt.close()
 
 
+M = TypeVar("M", _BasicBlock, _Bottleneck)
+
+
 if __name__ == "__main__":
     _main()

latex/python/pyproject.toml

@@ -11,10 +11,10 @@ version = "0.0.0"
 
 [project.optional-dependencies]
 dev = [
+  "check-python-script@https://api.github.com/repos/pbizopoulos/check-python-script/tarball/1c91a46#subdirectory=python",
   "coverage==7.5.3",
   "djlint==1.34.1",
   "mypy==1.10.0",
   "ruff==0.4.7",
-  "ssort==0.13.0",
   "toml-sort==0.23.1"
 ]