matrx-orm 3.0.30__tar.gz → 3.0.31__tar.gz

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.0.30
+Version: 3.0.31
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching. Works with any PostgreSQL database.
 Project-URL: Homepage, https://github.com/armanisadeghi/matrx-orm
 Project-URL: Repository, https://github.com/armanisadeghi/matrx-orm
@@ -1838,6 +1838,7 @@ When you run the schema builder against a database that has `vector(n)` columns,
 
 | Version | Highlights |
 |---|---|
+| **v3.0.31** | Patch release |
 | **v3.0.30** | Patch release |
 | **v3.0.29** | Patch release |
 | **v3.0.28** | Patch release |

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/README.md

@@ -1795,6 +1795,7 @@ When you run the schema builder against a database that has `vector(n)` columns,
 
 | Version | Highlights |
 |---|---|
+| **v3.0.31** | Patch release |
 | **v3.0.30** | Patch release |
 | **v3.0.29** | Patch release |
 | **v3.0.28** | Patch release |

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.0.30"
+version = "3.0.31"
 description = "Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching. Works with any PostgreSQL database."
 readme = "README.md"
 license = { text = "MIT" }

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/src/matrx_orm/schema_builder/columns.py

@@ -1266,7 +1266,7 @@ class Column:
         )
         return self.calc_max_length
 
-    def to_python_model_field(self):
+    def to_python_model_field(self, forward_ref_tables: set[str] | None = None):
         field_options = []
         if self.is_primary_key:
             field_options.append("primary_key=True")
@@ -1315,7 +1315,9 @@ class Column:
             to_schema_arg = ""
             if fk_schema and fk_schema != "public":
                 to_schema_arg = f", to_schema='{fk_schema}'"
-            if related_model == self.utils.to_pascal_case(self.table_name):
+            is_self_ref = related_model == self.utils.to_pascal_case(self.table_name)
+            is_forward_ref = forward_ref_tables is not None and related_model in forward_ref_tables
+            if is_self_ref or is_forward_ref:
                 field_def = f"{self.name} = ForeignKey(to_model='{related_model}', to_column='{self.foreign_key_reference['column']}'{to_schema_arg}, {options_str})"
             else:
                 field_def = f"{self.name} = ForeignKey(to_model={related_model}, to_column='{self.foreign_key_reference['column']}'{to_schema_arg}, {options_str})"

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/src/matrx_orm/schema_builder/diff_preview.py

@@ -361,6 +361,7 @@ def parse_models_file(path: str | Path) -> tuple[dict[str, TableSnapshot], dict[
         m2m_config: dict[str, dict[str, str]] = {}
         database: str | None = None
         table_name_override: str | None = None
+        db_schema: str | None = None
 
         for item in node.body:
             if isinstance(item, (ast.Assign, ast.AnnAssign)):
@@ -395,6 +396,13 @@ def parse_models_file(path: str | Path) -> tuple[dict[str, TableSnapshot], dict[
                         pass
                     continue
 
+                if attr_name == "_db_schema":
+                    try:
+                        db_schema = ast.literal_eval(value)
+                    except (ValueError, TypeError):
+                        pass
+                    continue
+
                 if attr_name == "_inverse_foreign_keys":
                     try:
                         ifk_config = ast.literal_eval(value)
@@ -416,6 +424,12 @@ def parse_models_file(path: str | Path) -> tuple[dict[str, TableSnapshot], dict[
                     field_type, kwargs = _parse_field_call(value)
                     fields[attr_name] = _kwargs_to_field_snapshot(attr_name, field_type, kwargs)
 
+        # Skip cross-schema stub models (e.g. Users with _db_schema="auth").
+        # They are hardcoded in generate_models() and don't correspond to any
+        # introspected table in the target schema.
+        if db_schema is not None:
+            continue
+
         snake_name = table_name_override or _pascal_to_snake(class_name)
 
         snapshot = TableSnapshot(
@@ -451,6 +465,33 @@ def _pascal_to_snake(name: str) -> str:
 # Table-to-snapshot converter — extract TableSnapshot from a schema_builder Table
 # ---------------------------------------------------------------------------
 
+def _normalize_python_default(value: Any) -> Any:
+    """Apply the same default-value normalization as Column.to_python_model_field().
+
+    The generator converts raw ``clean_default["python"]`` values before writing
+    them into model source code (e.g. the string ``"false"`` becomes the Python
+    boolean ``False``).  This function mirrors that logic so the snapshot
+    produced from a Table object is directly comparable to what the AST parser
+    extracts from generated code.
+    """
+    if isinstance(value, (bool, int, float, dict, list)):
+        return value
+    if isinstance(value, str):
+        if value == "false":
+            return False
+        if value == "true":
+            return True
+        try:
+            import ast as _ast
+            parsed = _ast.literal_eval(value)
+            if isinstance(parsed, (bool, int, float, dict, list)):
+                return parsed
+            return value
+        except (ValueError, SyntaxError):
+            return value
+    return value
+
+
 def table_to_snapshot(table: Any) -> TableSnapshot:
     """Convert a schema_builder.tables.Table into a TableSnapshot."""
     from matrx_orm.schema_builder.common import dt_utils
@@ -496,7 +537,7 @@ def table_to_snapshot(table: Any) -> TableSnapshot:
         if column.clean_default is not None:
             py_default = column.clean_default.get("python")
             if py_default is not None and py_default != "":
-                default_val = repr(py_default)
+                default_val = repr(_normalize_python_default(py_default))
 
         fields[column.name] = FieldSnapshot(
             name=column.name,

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/src/matrx_orm/schema_builder/schema.py

@@ -842,9 +842,26 @@ class Schema:
         py_structure = [self.get_string_user_model()]
         all_field_types = {"UUIDField", "CharField", "Model"}
 
+        # Build a position map so each table knows which models are defined
+        # after it in the file.  FKs to those models must use string forward
+        # references to avoid NameError from circular dependencies.
+        _table_positions = {name: i for i, name in enumerate(sorted_tables)}
+
         for table_name in sorted_tables:
             table = self.tables[table_name]
-            py_table_entry = table.to_python_model()
+            my_pos = _table_positions[table_name]
+            forward_ref_tables: set[str] = set()
+            for col in table.columns:
+                if col.foreign_key_reference:
+                    target_snake = col.foreign_key_reference["table"]
+                    target_pos = _table_positions.get(target_snake)
+                    if target_pos is None or target_pos > my_pos:
+                        target_pascal = table.utils.to_pascal_case(target_snake)
+                        if target_pascal != "Users":
+                            forward_ref_tables.add(target_pascal)
+            py_table_entry = table.to_python_model(
+                forward_ref_tables=forward_ref_tables or None
+            )
             py_structure.append(py_table_entry)
             all_field_types.update(table.unique_field_types)
 

{matrx_orm-3.0.30 → matrx_orm-3.0.31}/src/matrx_orm/schema_builder/tables.py

@@ -1079,9 +1079,15 @@ class Table:
                 }
         return m2m_config
 
-    def to_python_model(self):
+    def to_python_model(self, forward_ref_tables: set[str] | None = None):
         """
         Builds the Python class model string with dynamic foreign keys.
+
+        *forward_ref_tables* is an optional set of PascalCase model names that
+        will be defined later in the file.  FKs targeting these models are
+        emitted as string forward references (``to_model='Foo'``) instead of
+        bare class references (``to_model=Foo``), avoiding ``NameError`` from
+        circular FK dependencies.
         """
         py_fields = []
         self.unique_field_types = set()
@@ -1090,7 +1096,7 @@ class Table:
 
         # Process regular fields for the model
         for column in self.columns:
-            py_field = column.to_python_model_field()
+            py_field = column.to_python_model_field(forward_ref_tables=forward_ref_tables)
             py_fields.append(py_field)
 
             if column.foreign_key_reference: