🛠️added pre-commit and some formatting helpers params in pyproject.toml, sorting out some stricter mypy and linting.

Author: bloopy-code

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff-format
+        name: ruff format
+        entry: uv run ruff format .
+        language: system
+        pass_filenames: false
+
+      - id: ruff-check
+        name: ruff check
+        entry: uv run ruff check .
+        language: system
+        pass_filenames: false
+
+      - id: mypy
+        name: mypy
+        entry: uv run mypy .
+        language: system
+        pass_filenames: false

pyproject.toml

@@ -18,7 +18,26 @@ build-backend = "hatchling.build"
 [dependency-groups]
 dev = [
     "mypy>=1.19.1",
+    "pre-commit>=4.5.1",
     "pydocstyle>=6.3.0",
     "pytest>=9.0.2",
     "ruff>=0.14.9",
 ]
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+
+[tool.mypy]
+warn_unused_configs = true
+warn_return_any = true
+no_implicit_optional = true
+strict_equality = true
+disallow_untyped_defs = true
+check_untyped_defs = true
+pretty = true
+show_error_codes = true
+mypy_path = "src"
+

src/bseqgen/base.py

@@ -1,10 +1,13 @@
 """core representation for binary sequences"""
+
 from __future__ import annotations
-from collections.abc import Sequence
+
+import math
+from collections.abc import Iterator, Sequence
 from enum import StrEnum
 from itertools import groupby
-import math
-from typing import Iterator, TYPE_CHECKING, Any, Self
+from typing import TYPE_CHECKING, Any, Literal, Self
+
 __all__ = ("Direction", "BinarySequence")
 
 
@@ -25,19 +28,15 @@ def __init__(self, bits: Sequence[int | str] | str) -> None:
         self.bits: tuple[int, ...] = self._validate_bits(bits)
 
     @staticmethod
-    def _validate_bits(
-        input_bits: Sequence[int | str] | str
-    ) -> tuple[int, ...]:
+    def _validate_bits(input_bits: Sequence[int | str] | str) -> tuple[int, ...]:
         """Validate input bit sequences."""
         if (input_bits is None) or (not input_bits):
             raise ValueError("Input bits cannot be None or empty.")
 
         try:
             bits_list: tuple[int, ...] = tuple(int(bit) for bit in input_bits)
         except (TypeError, ValueError) as e:
-            raise TypeError(
-                "Bits must be an iterable of 0 and 1 values."
-            ) from e
+            raise TypeError("Bits must be an iterable of 0 and 1 values.") from e
 
         if any(bit not in (0, 1) for bit in bits_list):
             raise ValueError("Bit sequence must only contain 0 or 1.")
@@ -64,12 +63,7 @@ def __str__(self) -> str:
         return self.bit_string
 
     def __repr__(self) -> str:
-        return (
-            f"{type(self).__name__}("
-            f"length={self.length}, "
-            f"preview='{str(self)}'"
-            f")"
-        )
+        return f"{type(self).__name__}(length={self.length}, preview='{str(self)}')"
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, BinarySequence):
@@ -135,7 +129,7 @@ def as_bytes(self) -> bytes:
         zero_padding_len: int = (-len(bit_str)) % 8
         bit_str_padded: str = ("0" * zero_padding_len) + bit_str
         byte_conversion: bytes = int(bit_str_padded, 2).to_bytes(
-            len(bit_str_padded)//8, "big"
+            len(bit_str_padded) // 8, "big"
         )
 
         return byte_conversion
@@ -177,7 +171,7 @@ def entropy(self) -> float:
         if self.length == 0:
             return 0.0
 
-        p1 = self.ones/self.length
+        p1 = self.ones / self.length
         p0 = 1.0 - p1
 
         entropy = 0.0
@@ -188,7 +182,7 @@ def entropy(self) -> float:
         return round(entropy, 5)
 
     @property
-    def run_lengths(self):
+    def run_lengths(self) -> list[tuple[int, int]]:
         """Return list of run lengths [(digit, run count)].
 
         E.g. 111001 >> [(1, 3), (0, 2), (1, 1)]
@@ -212,15 +206,15 @@ def to_length(self, n: int) -> BinarySequence:
         return BinarySequence(bits)
 
     def shift(
-            self,
-            n: int,
-            direction: Direction = Direction.LEFT
-    ) -> "BinarySequence":
-        """Shift sequence (circular)
+        self,
+        n: int,
+        direction: Direction | Literal["left", "right"] = Direction.LEFT,
+    ) -> BinarySequence:
+        """Shift sequence (circular).
 
         Args:
             n (int): How many bits to shift by.
-            direction (Direction, optional): 'left' or 'right'.
+            direction (Direction|Literal['left', 'right'], optional): 'left' or 'right'.
                 Defaults to Direction.LEFT.
 
         Returns:
@@ -236,8 +230,7 @@ def shift(
         if n < 0:
             n = -n
             direction = (
-                Direction.RIGHT if direction == Direction.LEFT
-                else Direction.LEFT
+                Direction.RIGHT if direction == Direction.LEFT else Direction.LEFT
             )
 
         match direction:
@@ -248,13 +241,13 @@ def shift(
 
         raise ValueError(f"{direction} not a valid direction; 'left', 'right'")
 
-    def autocorr(self):
+    def autocorr(self) -> Any:
         raise NotImplementedError("Auto-correlation coming soon.")
 
-    def crosscorr(self):
+    def crosscorr(self) -> Any:
         raise NotImplementedError("Cross-correlation coming soon.")
 
-    def to_numpy(self, dtype: "NpDTypeInt | None" = None) -> "NpNDArrayInt":
+    def to_numpy(self, dtype: NpDTypeInt | None = None) -> NpNDArrayInt:
         """Convert BinarySequence to 1D NumPy array.
 
         NumPy is an optional dependency, only required when calling the to_numpy
@@ -280,7 +273,7 @@ def to_numpy(self, dtype: "NpDTypeInt | None" = None) -> "NpNDArrayInt":
         return np.array(self.bits, dtype=out_dtype)
 
     @classmethod
-    def from_numpy(cls, np_array: "NpNDArrayInt") -> Self:
+    def from_numpy(cls, np_array: NpNDArrayInt) -> Self:
         """Convert 1D NumPy array to BinarySequence.
 
         Args:
@@ -329,7 +322,7 @@ def xor(self, other: BinarySequence) -> BinarySequence:
         """
         other_sequence = self._compatible_bits(other, "xor")
         return BinarySequence(
-            tuple(a ^ b for a, b in zip(self.bits, other_sequence))
+            tuple(a ^ b for a, b in zip(self.bits, other_sequence, strict=True))
         )
 
     def bitwise_and(self, other: BinarySequence) -> BinarySequence:
@@ -343,7 +336,7 @@ def bitwise_and(self, other: BinarySequence) -> BinarySequence:
         """
         other_sequence = self._compatible_bits(other, "and")
         return BinarySequence(
-            tuple(a & b for a, b in zip(self.bits, other_sequence))
+            tuple(a & b for a, b in zip(self.bits, other_sequence, strict=True))
         )
 
     def bitwise_or(self, other: BinarySequence) -> BinarySequence:
@@ -357,8 +350,8 @@ def bitwise_or(self, other: BinarySequence) -> BinarySequence:
         """
         other_sequence = self._compatible_bits(other, "or")
         return BinarySequence(
-            tuple(a | b for a, b in zip(self.bits, other_sequence))
+            tuple(a | b for a, b in zip(self.bits, other_sequence, strict=True))
         )
 
-    def hamming_distance(self):
+    def hamming_distance(self) -> Any:
         raise NotImplementedError("Hamming distance coming soon")

src/bseqgen/random_seq.py

@@ -1,7 +1,10 @@
 """Generate PRBS with Random Modules"""
-from .base import BinarySequence
+
 import random
 from typing import TypeAlias
+
+from .base import BinarySequence
+
 __all__ = ("random_sequence",)
 
 Seed: TypeAlias = None | int | float | str | bytes | bytearray