style: Enforce type annotations (#7)

Author: borchero

dataframely/_base_collection.py

@@ -79,7 +79,7 @@ class Metadata:
     members: dict[str, MemberInfo] = field(default_factory=dict)
     filters: dict[str, Filter] = field(default_factory=dict)
 
-    def update(self, other: Self):
+    def update(self, other: Self) -> None:
         self.members.update(other.members)
         self.filters.update(other.filters)
 
@@ -92,7 +92,7 @@ def __new__(
         namespace: dict[str, Any],
         *args: Any,
         **kwargs: Any,
-    ):
+    ) -> CollectionMeta:
         result = Metadata()
         for base in bases:
             result.update(mcs._get_metadata_recursively(base))

dataframely/_base_schema.py

@@ -58,7 +58,7 @@ class Metadata:
     columns: dict[str, Column] = field(default_factory=dict)
     rules: dict[str, Rule] = field(default_factory=dict)
 
-    def update(self, other: Self):
+    def update(self, other: Self) -> None:
         self.columns.update(other.columns)
         self.rules.update(other.rules)
 
@@ -71,7 +71,7 @@ def __new__(
         namespace: dict[str, Any],
         *args: Any,
         **kwargs: Any,
-    ):
+    ) -> SchemaMeta:
         result = Metadata()
         for base in bases:
             result.update(mcs._get_metadata_recursively(base))

dataframely/_compat.py

@@ -6,7 +6,7 @@
 
 
 class _DummyModule:  # pragma: no cover
-    def __init__(self, module: str):
+    def __init__(self, module: str) -> None:
         self.module = module
 
     def __getattr__(self, name: str) -> Any:

dataframely/_filter.py

@@ -12,7 +12,7 @@
 class Filter(Generic[C]):
     """Internal class representing logic for filtering members of a collection."""
 
-    def __init__(self, logic: Callable[[C], pl.LazyFrame]):
+    def __init__(self, logic: Callable[[C], pl.LazyFrame]) -> None:
         self.logic = logic
 
 

dataframely/_rule.py

@@ -12,14 +12,14 @@
 class Rule:
     """Internal class representing validation rules."""
 
-    def __init__(self, expr: pl.Expr):
+    def __init__(self, expr: pl.Expr) -> None:
         self.expr = expr
 
 
 class GroupRule(Rule):
     """Rule that is evaluated on a group of columns."""
 
-    def __init__(self, expr: pl.Expr, group_columns: list[str]):
+    def __init__(self, expr: pl.Expr, group_columns: list[str]) -> None:
         super().__init__(expr)
         self.group_columns = group_columns
 

dataframely/collection.py

@@ -498,7 +498,7 @@ def collect_all(self) -> Self:
 
     # ---------------------------------- PERSISTENCE --------------------------------- #
 
-    def write_parquet(self, directory: Path):
+    def write_parquet(self, directory: Path) -> None:
         """Write the members of this collection to Parquet files in a directory.
 
         This method writes one Parquet file per member into the provided directory.
@@ -590,7 +590,7 @@ def _init(cls, data: Mapping[str, FrameType], /) -> Self:
         return out
 
     @classmethod
-    def _validate_input_keys(cls, data: Mapping[str, FrameType], /):
+    def _validate_input_keys(cls, data: Mapping[str, FrameType], /) -> None:
         actual = set(data)
 
         missing = cls.required_members() - actual

dataframely/columns/_mixins.py

@@ -83,7 +83,7 @@ def validation_rules(self, expr: pl.Expr) -> dict[str, pl.Expr]:
 class IsInMixin(Generic[U], Base):
     """Mixin to use for types implementing "is in"."""
 
-    def __init__(self, *, is_in: Sequence[U] | None = None, **kwargs: Any):
+    def __init__(self, *, is_in: Sequence[U] | None = None, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.is_in = is_in
 

dataframely/columns/decimal.py

@@ -148,7 +148,9 @@ def _sample_unchecked(self, generator: Generator, n: int) -> pl.Series:
 # --------------------------------------- UTILS -------------------------------------- #
 
 
-def _validate(value: decimal.Decimal, precision: int | None, scale: int, name: str):
+def _validate(
+    value: decimal.Decimal, precision: int | None, scale: int, name: str
+) -> None:
     exponent = value.as_tuple().exponent
     if not isinstance(exponent, int):
         raise ValueError(f"Encountered 'inf' or 'NaN' for `{name}`.")

dataframely/config.py

@@ -25,23 +25,23 @@ class Config(contextlib.ContextDecorator):
     #: Singleton stack to track where to go back after exiting a context.
     _stack: list[Options] = []
 
-    def __init__(self, **options: Unpack[Options]):
+    def __init__(self, **options: Unpack[Options]) -> None:
         self._local_options: Options = {**default_options(), **options}
 
     @staticmethod
-    def set_max_sampling_iterations(iterations: int):
+    def set_max_sampling_iterations(iterations: int) -> None:
         """Set the maximum number of sampling iterations to use on
         :meth:`Schema.sample`."""
         Config.options["max_sampling_iterations"] = iterations
 
     @staticmethod
-    def restore_defaults():
+    def restore_defaults() -> None:
         """Restore the defaults of the configuration."""
         Config.options = default_options()
 
     # ------------------------------------ CONTEXT ----------------------------------- #
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         Config._stack.append(Config.options)
         Config.options = self._local_options
 
@@ -50,5 +50,5 @@ def __exit__(
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ):
+    ) -> None:
         Config.options = Config._stack.pop()

dataframely/exc.py

@@ -11,7 +11,7 @@
 class ValidationError(Exception):
     """Error raised when :mod:`dataframely` validation encounters an issue."""
 
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         super().__init__()
         self.message = message
 
@@ -22,7 +22,9 @@ def __str__(self) -> str:
 class DtypeValidationError(ValidationError):
     """Validation error raised when column dtypes are wrong."""
 
-    def __init__(self, errors: dict[str, tuple[PolarsDataType, PolarsDataType]]):
+    def __init__(
+        self, errors: dict[str, tuple[PolarsDataType, PolarsDataType]]
+    ) -> None:
         super().__init__(f"{len(errors)} columns have an invalid dtype")
         self.errors = errors
 
@@ -37,7 +39,7 @@ def __str__(self) -> str:
 class RuleValidationError(ValidationError):
     """Complex validation error raised when rule validation fails."""
 
-    def __init__(self, errors: dict[str, int]):
+    def __init__(self, errors: dict[str, int]) -> None:
         super().__init__(f"{len(errors)} rules failed validation")
 
         # Split into schema errors and column errors
@@ -75,11 +77,11 @@ def __str__(self) -> str:
 class MemberValidationError(ValidationError):
     """Validation error raised when multiple members of a collection fail validation."""
 
-    def __init__(self, errors: dict[str, ValidationError]):
+    def __init__(self, errors: dict[str, ValidationError]) -> None:
         super().__init__(f"{len(errors)} members failed validation")
         self.errors = errors
 
-    def __str__(self):
+    def __str__(self) -> str:
         details = [
             f" > Member '{name}' failed validation:\n"
             + "\n".join("   " + line for line in str(error).split("\n"))
@@ -95,7 +97,7 @@ class ImplementationError(Exception):
 class AnnotationImplementationError(ImplementationError):
     """Error raised when the annotations of a collection are invalid."""
 
-    def __init__(self, attr: str, kls: type):
+    def __init__(self, attr: str, kls: type) -> None:
         message = (
             "Annotations of a 'dy.Collection' may only be an (optional) "
             f"'dy.LazyFrame', but \"{attr}\" has type '{kls}'."
@@ -106,7 +108,9 @@ def __init__(self, attr: str, kls: type):
 class RuleImplementationError(ImplementationError):
     """Error raised when a rule is implemented incorrectly."""
 
-    def __init__(self, name: str, return_dtype: pl.DataType, is_group_rule: bool):
+    def __init__(
+        self, name: str, return_dtype: pl.DataType, is_group_rule: bool
+    ) -> None:
         if is_group_rule:
             details = (
                 " When implementing a group rule (i.e. when using the `group_by` "