matrx-orm 3.1.30__tar.gz → 3.1.32__tar.gz

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.1.30
+Version: 3.1.32
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/matrx_orm/core/expressions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import date, datetime
+from datetime import date, datetime, timedelta
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any
 from uuid import UUID
@@ -174,7 +174,7 @@ class OrderBy:
 
     def __init__(
         self,
-        expression: "str | F | Func",
+        expression: str | F | Func,
         *,
         descending: bool = False,
         nulls: str | None = None,
@@ -228,7 +228,7 @@ class Q:
     OR = "OR"
     NOT = "NOT"
 
-    def __init__(self, *args: "Q", **kwargs: Any) -> None:
+    def __init__(self, *args: Q, **kwargs: Any) -> None:
         self.connector: str = self.AND
         self.negated: bool = False
         # Children is a list of (Q | None) for compound nodes, or kwargs for leaf nodes.
@@ -237,19 +237,19 @@ class Q:
 
     # -- Boolean operators --------------------------------------------------
 
-    def __and__(self, other: "Q") -> "Q":
+    def __and__(self, other: Q) -> Q:
         node = Q()
         node.connector = self.AND
         node.children = [self, other]
         return node
 
-    def __or__(self, other: "Q") -> "Q":
+    def __or__(self, other: Q) -> Q:
         node = Q()
         node.connector = self.OR
         node.children = [self, other]
         return node
 
-    def __invert__(self) -> "Q":
+    def __invert__(self) -> Q:
         node = Q(**self.kwargs)
         node.connector = self.connector
         node.children = list(self.children)
@@ -697,7 +697,7 @@ class Interval:
     def __init__(self, **parts: int | float) -> None:
         if not parts or not set(parts).issubset(self._UNITS):
             raise ValueError("Interval received an unsupported or empty unit set")
-        self.value = " ".join(f"{amount} {unit}" for unit, amount in parts.items())
+        self.value = timedelta(**parts)
 
     def as_sql(self, params: list[Any]) -> str:
         params.append(self.value)
@@ -1776,7 +1776,7 @@ class Window:
 
     def __init__(
         self,
-        expression: "Func | Aggregate",
+        expression: Func | Aggregate,
         *,
         partition_by: str | list[str] | None = None,
         order_by: str | list[str] | None = None,

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/matrx_orm/operations/conflict.py

@@ -79,6 +79,7 @@ class ConflictTarget:
         *,
         coalesce: dict[str, Any] | None = None,
         lower: tuple[str, ...] = (),
+        md5: tuple[str, ...] = (),
         where_is_null: tuple[str, ...] = (),
         where_is_not_null: tuple[str, ...] = (),
         where_equals: dict[str, Any] | None = None,
@@ -93,6 +94,9 @@ class ConflictTarget:
         unknown_lower = set(lower) - set(columns)
         if unknown_lower:
             raise ValueError(f"lower columns are not in conflict target: {sorted(unknown_lower)}")
+        unknown_md5 = set(md5) - set(columns)
+        if unknown_md5:
+            raise ValueError(f"md5 columns are not in conflict target: {sorted(unknown_md5)}")
         expressions: list[str] = []
         for column in columns:
             rendered = _identifier(column)
@@ -100,6 +104,8 @@ class ConflictTarget:
                 rendered = f"COALESCE({rendered}, {_literal(coalesce[column])})"
             if column in lower:
                 rendered = f"lower({rendered})"
+            if column in md5:
+                rendered = f"md5({rendered})"
             expressions.append(rendered)
         predicates = [f"{_identifier(column)} IS NULL" for column in where_is_null]
         predicates.extend(f"{_identifier(column)} IS NOT NULL" for column in where_is_not_null)

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/matrx_orm/python_sql/table_detailed_relationships.py

@@ -147,150 +147,127 @@ def analyze_junction_tables(schema, database_project, additional_schemas=None):
         return cached
 
     query = """
-    WITH junction_candidates AS (
-        SELECT 
-            tc.table_schema,
-            tc.table_name,
-            COUNT(*) as fk_count
-        FROM 
-            information_schema.table_constraints tc
-        WHERE 
-            tc.table_schema = ANY(%s::text[])
-            AND tc.constraint_type = 'FOREIGN KEY'
-        GROUP BY 
-            tc.table_schema, tc.table_name
-        HAVING 
-            COUNT(*) >= 2
+    WITH junction_candidates AS MATERIALIZED (
+        SELECT
+            constraint_row.conrelid AS table_oid
+        FROM pg_catalog.pg_constraint constraint_row
+        JOIN pg_catalog.pg_class table_row
+            ON table_row.oid = constraint_row.conrelid
+        JOIN pg_catalog.pg_namespace table_schema
+            ON table_schema.oid = table_row.relnamespace
+        WHERE
+            constraint_row.contype = 'f'
+            AND table_schema.nspname = ANY(%s::text[])
+            AND table_row.relkind IN ('r', 'p')
+        GROUP BY constraint_row.conrelid
+        HAVING COUNT(*) >= 2
     ),
-    foreign_key_details AS (
-        SELECT DISTINCT
-            tc.table_schema,
-            tc.table_name,
-            kcu.column_name as fk_column,
-            ccu.table_schema as referenced_schema,
-            ccu.table_name as referenced_table,
-            ccu.column_name as referenced_column,
-            EXISTS (
-                SELECT 1 
-                FROM information_schema.table_constraints uc
-                JOIN information_schema.key_column_usage kcu2 
-                    ON uc.constraint_name = kcu2.constraint_name
-                WHERE uc.table_schema = tc.table_schema 
-                    AND uc.table_name = tc.table_name
-                    AND uc.constraint_type IN ('UNIQUE', 'PRIMARY KEY')
-                    AND kcu2.column_name = kcu.column_name
-            ) as has_unique_constraint,
-            EXISTS (
-                SELECT 1 
-                FROM information_schema.table_constraints uc
-                JOIN information_schema.key_column_usage kcu2 
-                    ON uc.constraint_name = kcu2.constraint_name
-                WHERE uc.table_schema = ccu.table_schema 
-                    AND uc.table_name = ccu.table_name
-                    AND uc.constraint_type IN ('UNIQUE', 'PRIMARY KEY')
-                    AND kcu2.column_name = ccu.column_name
-            ) as referenced_has_unique_constraint
-        FROM 
-            information_schema.table_constraints tc
-            JOIN information_schema.key_column_usage kcu 
-                ON tc.constraint_name = kcu.constraint_name
-                AND tc.table_schema = kcu.table_schema
-            JOIN information_schema.constraint_column_usage ccu
-                ON ccu.constraint_name = tc.constraint_name
-        WHERE 
-            tc.table_schema = ANY(%s::text[])
-            AND tc.constraint_type = 'FOREIGN KEY'
+    foreign_key_details AS MATERIALIZED (
+        SELECT
+            candidate.table_oid,
+            table_schema.nspname AS table_schema,
+            table_row.relname AS table_name,
+            constraint_row.oid AS constraint_oid,
+            key_pair.position,
+            local_column.attname AS fk_column,
+            referenced_table.oid AS referenced_table_oid,
+            referenced_schema.nspname AS referenced_schema,
+            referenced_table.relname AS referenced_table,
+            referenced_column.attname AS referenced_column
+        FROM junction_candidates candidate
+        JOIN pg_catalog.pg_constraint constraint_row
+            ON constraint_row.conrelid = candidate.table_oid
+            AND constraint_row.contype = 'f'
+        JOIN pg_catalog.pg_class table_row
+            ON table_row.oid = candidate.table_oid
+        JOIN pg_catalog.pg_namespace table_schema
+            ON table_schema.oid = table_row.relnamespace
+        JOIN pg_catalog.pg_class referenced_table
+            ON referenced_table.oid = constraint_row.confrelid
+        JOIN pg_catalog.pg_namespace referenced_schema
+            ON referenced_schema.oid = referenced_table.relnamespace
+        CROSS JOIN LATERAL unnest(
+            constraint_row.conkey,
+            constraint_row.confkey
+        ) WITH ORDINALITY AS key_pair(local_attnum, referenced_attnum, position)
+        JOIN pg_catalog.pg_attribute local_column
+            ON local_column.attrelid = candidate.table_oid
+            AND local_column.attnum = key_pair.local_attnum
+        JOIN pg_catalog.pg_attribute referenced_column
+            ON referenced_column.attrelid = referenced_table.oid
+            AND referenced_column.attnum = key_pair.referenced_attnum
     ),
-    primary_key_columns AS (
-        SELECT 
-            kcu.table_schema,
-            kcu.table_name,
-            kcu.column_name as pk_column
-        FROM 
-            information_schema.table_constraints tc
-            JOIN information_schema.key_column_usage kcu 
-                ON tc.constraint_name = kcu.constraint_name
-                AND tc.table_schema = kcu.table_schema
-        WHERE 
-            tc.table_schema = ANY(%s::text[])
-            AND tc.constraint_type = 'PRIMARY KEY'
+    primary_key_columns AS MATERIALIZED (
+        SELECT
+            constraint_row.conrelid AS table_oid,
+            array_agg(column_row.attname ORDER BY key_column.position) AS primary_keys
+        FROM pg_catalog.pg_constraint constraint_row
+        CROSS JOIN LATERAL unnest(constraint_row.conkey)
+            WITH ORDINALITY AS key_column(attnum, position)
+        JOIN pg_catalog.pg_attribute column_row
+            ON column_row.attrelid = constraint_row.conrelid
+            AND column_row.attnum = key_column.attnum
+        WHERE constraint_row.contype = 'p'
+        GROUP BY constraint_row.conrelid
     ),
-    additional_columns AS (
-        SELECT 
-            c.table_schema,
-            c.table_name,
-            array_agg(DISTINCT c.column_name ORDER BY c.column_name) as additional_fields
-        FROM 
-            information_schema.columns c
-            JOIN junction_candidates jc 
-                ON c.table_name = jc.table_name 
-                AND c.table_schema = jc.table_schema
-            LEFT JOIN foreign_key_details fkd 
-                ON c.table_name = fkd.table_name 
-                AND c.table_schema = fkd.table_schema
-                AND c.column_name = fkd.fk_column
-            LEFT JOIN primary_key_columns pkc
-                ON c.table_name = pkc.table_name
-                AND c.table_schema = pkc.table_schema
-                AND c.column_name = pkc.pk_column
-        WHERE 
-            c.table_schema = ANY(%s::text[])
-            AND fkd.fk_column IS NULL
-            AND pkc.pk_column IS NULL
-        GROUP BY 
-            c.table_schema, c.table_name
+    additional_columns AS MATERIALIZED (
+        SELECT
+            candidate.table_oid,
+            array_agg(column_row.attname ORDER BY column_row.attnum) AS additional_fields
+        FROM junction_candidates candidate
+        JOIN pg_catalog.pg_attribute column_row
+            ON column_row.attrelid = candidate.table_oid
+            AND column_row.attnum > 0
+            AND NOT column_row.attisdropped
+        WHERE NOT EXISTS (
+            SELECT 1
+            FROM pg_catalog.pg_constraint key_constraint
+            WHERE
+                key_constraint.conrelid = candidate.table_oid
+                AND key_constraint.contype IN ('f', 'p')
+                AND column_row.attnum = ANY(key_constraint.conkey)
+        )
+        GROUP BY candidate.table_oid
     )
-    SELECT 
-        jc.table_schema,
-        jc.table_name,
+    SELECT
+        foreign_key.table_schema,
+        foreign_key.table_name,
         json_agg(
             json_build_object(
-                'table', fkd.table_name,
-                'table_pks', (
-                    SELECT array_agg(DISTINCT pkc_table.pk_column)
-                    FROM primary_key_columns pkc_table
-                    WHERE pkc_table.table_schema = fkd.table_schema
-                    AND pkc_table.table_name = fkd.table_name
-                ),
-                'related_table', fkd.referenced_table,
-                'related_pks', (
-                    SELECT array_agg(DISTINCT pkc_related.pk_column)
-                    FROM primary_key_columns pkc_related
-                    WHERE pkc_related.table_schema = fkd.referenced_schema
-                    AND pkc_related.table_name = fkd.referenced_table
-                ),
-                'related_schema', fkd.referenced_schema,
-                'connecting_column', fkd.fk_column,
-                'referenced_column', fkd.referenced_column,
+                'table', foreign_key.table_name,
+                'table_pks', local_primary_key.primary_keys,
+                'related_table', foreign_key.referenced_table,
+                'related_pks', referenced_primary_key.primary_keys,
+                'related_schema', foreign_key.referenced_schema,
+                'connecting_column', foreign_key.fk_column,
+                'referenced_column', foreign_key.referenced_column,
                 'relationship_type',
-                CASE 
-                    WHEN fkd.referenced_table = fkd.table_name THEN 'self-referential'
-                    WHEN jc.fk_count >= 2 THEN 'many-to-many'
-                    WHEN fkd.has_unique_constraint AND fkd.referenced_has_unique_constraint THEN 'one-to-one'
-                    WHEN NOT fkd.has_unique_constraint THEN 'many-to-one'
-                    WHEN fkd.has_unique_constraint THEN 'one-to-many'
-                    ELSE 'undefined'
+                CASE
+                    WHEN foreign_key.referenced_table_oid = foreign_key.table_oid
+                        THEN 'self-referential'
+                    ELSE 'many-to-many'
                 END
             )
-        ) as connected_tables,
-        COALESCE(ac.additional_fields, ARRAY[]::text[]) as additional_fields,
-        array_agg(DISTINCT pkc.pk_column) FILTER (WHERE pkc.pk_column IS NOT NULL) as primary_keys
-    FROM 
-        junction_candidates jc
-        JOIN foreign_key_details fkd 
-            ON jc.table_name = fkd.table_name 
-            AND jc.table_schema = fkd.table_schema
-        LEFT JOIN additional_columns ac 
-            ON jc.table_name = ac.table_name 
-            AND jc.table_schema = ac.table_schema
-    LEFT JOIN primary_key_columns pkc
-            ON jc.table_name = pkc.table_name 
-            AND jc.table_schema = pkc.table_schema
-    GROUP BY 
-        jc.table_schema, jc.table_name, ac.additional_fields;
+            ORDER BY foreign_key.constraint_oid, foreign_key.position
+        ) AS connected_tables,
+        COALESCE(additional.additional_fields, ARRAY[]::text[]) AS additional_fields,
+        local_primary_key.primary_keys
+    FROM foreign_key_details foreign_key
+    LEFT JOIN primary_key_columns local_primary_key
+        ON local_primary_key.table_oid = foreign_key.table_oid
+    LEFT JOIN primary_key_columns referenced_primary_key
+        ON referenced_primary_key.table_oid = foreign_key.referenced_table_oid
+    LEFT JOIN additional_columns additional
+        ON additional.table_oid = foreign_key.table_oid
+    GROUP BY
+        foreign_key.table_oid,
+        foreign_key.table_schema,
+        foreign_key.table_name,
+        local_primary_key.primary_keys,
+        additional.additional_fields;
     """
 
-    results = execute_sql_query(query, (schemas, schemas, schemas, schemas), database_project)
+    results = execute_sql_query(query, (schemas,), database_project)
 
     # Transform the results into a more readable format
     analyzed_junctions = {}

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/pyproject.toml

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

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/tests/level1/test_case_when.py

@@ -13,8 +13,9 @@ style of test_expression_primitives.py / test_join_and_aggregate.py.
 """
 from __future__ import annotations
 
+from datetime import timedelta
+
 import pytest
-from matrx_orm import ColumnComparison, F
 from matrx_orm.core.base import Model, ModelMeta
 from matrx_orm.core.expressions import (
     ArrayAny,
@@ -162,8 +163,8 @@ def _make_order_model():
 
 
 def test_case_in_annotate():
-    O = _make_order_model()
-    qb = O.filter().annotate(
+    Order = _make_order_model()
+    qb = Order.filter().annotate(
         tier=Case(When(Compare(F("amount"), ">=", 1000), then=Value("gold")), default=Value("standard"))
     )
     sql, params = QueryExecutor(qb._build_query())._build_query()
@@ -174,8 +175,8 @@ def test_case_in_annotate():
 
 
 def test_case_in_order_by():
-    O = _make_order_model()
-    qb = O.filter().order_by(
+    Order = _make_order_model()
+    qb = Order.filter().order_by(
         OrderBy(Case(When(Compare(F("status"), "=", "paid"), then=0), default=1)),
         "-amount",
     )
@@ -187,8 +188,8 @@ def test_case_in_order_by():
 def test_case_in_order_by_with_nulls_last():
     """Mirrors the real _entity_recall Step-1 ORDER BY: exact-match-first
     tiebreak, then confidence_avg DESC NULLS LAST."""
-    O = _make_order_model()
-    qb = O.filter().order_by(
+    Order = _make_order_model()
+    qb = Order.filter().order_by(
         OrderBy(Case(When(Compare(Lower(F("status")), "=", "paid"), then=0), default=1)),
         OrderBy("amount", descending=True, nulls="last"),
     )
@@ -405,7 +406,7 @@ def test_expression_branch_anchors_the_case_so_literals_are_not_cast():
         "CASE WHEN (w IS NULL OR w < (NOW() - $1::interval)) "
         "THEN $2 ELSE (daily_auto_rag_cost_used_usd + $3) END"
     )
-    assert params == ["24 hours", 0.42, 0.42]
+    assert params == [timedelta(hours=24), 0.42, 0.42]
 
 
 def test_column_branch_anchors_the_case_so_literals_are_not_cast():

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/tests/level1/test_conflict_target.py

@@ -102,6 +102,16 @@ def test_typed_partial_target_rejects_non_identifier_columns() -> None:
         ConflictTarget.partial(["project_id; DROP TABLE x"])
 
 
+def test_typed_partial_target_renders_md5_expression() -> None:
+    target = ConflictTarget.partial(["source_id", "url"], md5=("url",))
+    assert target.expressions == ("source_id", "md5(url)")
+
+
+def test_typed_partial_target_rejects_unknown_md5_column() -> None:
+    with pytest.raises(ValueError, match="md5 columns are not in conflict target"):
+        ConflictTarget.partial(["source_id", "url"], md5=("missing",))
+
+
 # ── Executor SQL shape ───────────────────────────────────────────────────────
 
 

{matrx_orm-3.1.30 → matrx_orm-3.1.32}/tests/level1/test_typed_predicates.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import timedelta
 from typing import Any
 
 import pytest
@@ -193,6 +194,7 @@ def test_arrays_tuple_membership_constant_and_interval() -> None:
         ["a"],
         ["00000000-0000-0000-0000-000000000001"],
     ]
+    assert params[4] == timedelta(hours=24)
 
 
 def test_function_name_and_tuple_type_are_validated() -> None:

matrx_orm-3.1.32/tests/schema/test_junction_analysis.py

@@ -0,0 +1,55 @@
+from importlib import import_module
+
+import_module("matrx_orm.schema_builder")
+table_detailed_relationships = import_module("matrx_orm.python_sql.table_detailed_relationships")
+
+
+def test_junction_analysis_uses_oid_catalog_query(monkeypatch):
+    captured: dict[str, object] = {}
+    rows = [
+        {
+            "table_schema": "app",
+            "table_name": "membership",
+            "connected_tables": [
+                {
+                    "table": "membership",
+                    "table_pks": ["user_id", "team_id"],
+                    "related_table": "users",
+                    "related_pks": ["id"],
+                    "related_schema": "auth",
+                    "connecting_column": "user_id",
+                    "referenced_column": "id",
+                    "relationship_type": "many-to-many",
+                }
+            ],
+            "additional_fields": ["created_at"],
+            "primary_keys": ["user_id", "team_id"],
+        }
+    ]
+
+    def fake_execute_sql_query(query, params, database_project):
+        captured.update(query=query, params=params, database_project=database_project)
+        return rows
+
+    monkeypatch.setattr(
+        table_detailed_relationships,
+        "execute_sql_query",
+        fake_execute_sql_query,
+    )
+    table_detailed_relationships.clear_junction_analysis_cache()
+
+    junctions, relationships = table_detailed_relationships.analyze_junction_tables(
+        "app",
+        "main",
+        additional_schemas=["auth"],
+    )
+
+    query = captured["query"]
+    assert isinstance(query, str)
+    assert "pg_catalog.pg_constraint" in query
+    assert "WITH ORDINALITY" in query
+    assert "information_schema" not in query
+    assert captured["params"] == (["app", "auth"],)
+    assert captured["database_project"] == "main"
+    assert junctions["membership"]["primary_keys"] == ["user_id", "team_id"]
+    assert relationships[0]["table_additional_fields"] == ["created_at"]