fix: Correctly set dunder name for schemas with at least one rule (#34)

Author: MoritzPotthoffQC

dataframely/_base_schema.py

@@ -98,15 +98,15 @@ def __new__(
             )
 
         # 2) Check that the columns referenced in the group rules exist.
-        for name, rule in result.rules.items():
+        for rule_name, rule in result.rules.items():
             if isinstance(rule, GroupRule):
                 missing_columns = set(rule.group_columns) - set(result.columns)
                 if len(missing_columns) > 0:
                     missing_list = ", ".join(
                         sorted(f"'{col}'" for col in missing_columns)
                     )
                     raise ImplementationError(
-                        f"Group validation rule '{name}' has been implemented "
+                        f"Group validation rule '{rule_name}' has been implemented "
                         f"incorrectly. It references {len(missing_columns)} columns "
                         f"which are not in the schema: {missing_list}."
                     )
@@ -116,16 +116,16 @@ def __new__(
         # empty data frame and checking for the evaluated dtypes.
         if len(result.rules) > 0:
             lf_empty = pl.LazyFrame(
-                schema={name: col.dtype for name, col in result.columns.items()}
+                schema={col_name: col.dtype for col_name, col in result.columns.items()}
             )
             # NOTE: For some reason, `polars` does not yield correct dtypes when calling
             #  `collect_schema()`
             schema = with_evaluation_rules(lf_empty, result.rules).collect().schema
-            for name, rule in result.rules.items():
-                dtype = schema[name]
+            for rule_name, rule in result.rules.items():
+                dtype = schema[rule_name]
                 if not isinstance(dtype, pl.Boolean):
                     raise RuleImplementationError(
-                        name, dtype, isinstance(rule, GroupRule)
+                        rule_name, dtype, isinstance(rule, GroupRule)
                     )
 
         return super().__new__(mcs, name, bases, namespace, *args, **kwargs)

tests/schema/test_base.py

@@ -18,6 +18,12 @@ class MySchema(dy.Schema):
     d = dy.Any(alias="e")
 
 
+class MySchemaWithRule(MySchema):
+    @dy.rule()
+    def a_greater_than_c() -> pl.Expr:
+        return pl.col("a") > pl.col("c")
+
+
 def test_column_names() -> None:
     assert MySchema.column_names() == ["a", "b", "c", "e"]
 
@@ -75,3 +81,11 @@ def test_col_in_polars_expression() -> None:
         .select(MySchema.a.col)
     )
     assert df.row(0) == (1,)
+
+
+def test_dunder_name() -> None:
+    assert MySchema.__name__ == "MySchema"
+
+
+def test_dunder_name_with_rule() -> None:
+    assert MySchemaWithRule.__name__ == "MySchemaWithRule"