ul-db-utils 6.0.0.dev3__tar.gz → 6.0.2__tar.gz

{ul_db_utils-6.0.0.dev3/ul_db_utils.egg-info → ul_db_utils-6.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ul-db-utils
-Version: 6.0.0.dev3
+Version: 6.0.2
 Summary: UL db utils Python package
 Author: Unic-lab
 License: MIT
@@ -22,7 +22,7 @@ Requires-Dist: alembic>=1.18.4
 Requires-Dist: flask-mongoengine-3>=1.1.0
 Requires-Dist: redis>=7.4.0
 Requires-Dist: psycopg2-binary>=2.9.11
-Requires-Dist: ul-py-tool>=3.0.2.dev1
+Requires-Dist: ul-py-tool>=3.0.3
 Provides-Extra: dev
 Requires-Dist: uv-script>=0.1.9; extra == "dev"
 Dynamic: license-file

{ul_db_utils-6.0.0.dev3 → ul_db_utils-6.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ul-db-utils"
-version = "6.0.0.dev.3"
+version = "6.0.2"
 description = "UL db utils Python package"
 requires-python = ">=3.14"
 readme = "README.md"
@@ -24,7 +24,7 @@ dependencies = [
     "flask-mongoengine-3 >=1.1.0",
     "redis >=7.4.0",
     "psycopg2-binary >=2.9.11",
-    "ul-py-tool >=3.0.2.dev1",
+    "ul-py-tool >=3.0.3",
 ]
 
 [project.optional-dependencies]

ul_db_utils-6.0.2/tests/test_db_search_operators.py

@@ -0,0 +1,234 @@
+"""
+Tests for ul_db_utils.search.db_search operator introspection and filtering.
+
+Covers:
+- Python 3.14 compatibility (no inspect.getargspec usage)
+- Correct argument-count detection for 1-arg, 2-arg, and 3-arg operators
+- create_operation for operators: ==, in, like, has, any, is_null
+- Filter.from_dictionary with nested 'or' / 'and' structures
+- create_filter with DisjunctionFilter (or) and ConjunctionFilter (and)
+"""
+import inspect
+import sys
+import pytest
+from unittest.mock import MagicMock, PropertyMock
+
+from ul_db_utils.search.db_search import (
+    OPERATORS,
+    Filter,
+    ConjunctionFilter,
+    DisjunctionFilter,
+    create_operation,
+    create_filter,
+)
+from ul_db_utils.errors.compare_null_error import ComparisonToNullError
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_model(fields: dict):
+    """Return a simple mock that behaves like a SQLAlchemy model class."""
+    model = MagicMock()
+    for name, value in fields.items():
+        setattr(model, name, value)
+    model.__name__ = "FakeModel"
+    return model
+
+
+# ---------------------------------------------------------------------------
+# 1. Python 3.14 compatibility — getargspec must NOT be used
+# ---------------------------------------------------------------------------
+
+def test_no_getargspec_in_source():
+    """db_search.py must not call the removed inspect.getargspec."""
+    import ul_db_utils.search.db_search as module
+    source = inspect.getsource(module)
+    assert "getargspec(" not in source, (
+        "inspect.getargspec() call found in db_search.py — it is removed in Python 3.14"
+    )
+
+
+def test_python_version_at_least_3_14():
+    """This package targets Python >=3.14; confirm runtime version."""
+    assert sys.version_info >= (3, 14), (
+        f"Expected Python >=3.14, got {sys.version_info}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# 2. Operator argument-count introspection (the core fix)
+# ---------------------------------------------------------------------------
+
+class TestOperatorArgCounts:
+    """Ensure every OPERATORS entry is introspectable via inspect.signature."""
+
+    _one_arg_ops = ['is_null', 'is_not_null']
+    _two_arg_ops = [
+        '==', 'eq', 'equals', 'equal_to',
+        '!=', 'ne', 'neq', 'not_equal_to', 'does_not_equal',
+        '>', 'gt', '<', 'lt', '>=', 'ge', 'gte', 'geq',
+        '<=', 'le', 'lte', 'leq',
+        '<<', '<<=', '>>', '>>=', '<>', '&&',
+        'ilike', 'like', 'not_like', 'in', 'not_in',
+    ]
+    _three_arg_ops = ['has', 'any']
+
+    def test_one_arg_operators(self):
+        for op in self._one_arg_ops:
+            nargs = len(inspect.signature(OPERATORS[op]).parameters)
+            assert nargs == 1, f"Operator '{op}' should have 1 arg, got {nargs}"
+
+    def test_two_arg_operators(self):
+        for op in self._two_arg_ops:
+            nargs = len(inspect.signature(OPERATORS[op]).parameters)
+            assert nargs == 2, f"Operator '{op}' should have 2 args, got {nargs}"
+
+    def test_three_arg_operators(self):
+        for op in self._three_arg_ops:
+            nargs = len(inspect.signature(OPERATORS[op]).parameters)
+            assert nargs == 3, f"Operator '{op}' should have 3 args, got {nargs}"
+
+
+# ---------------------------------------------------------------------------
+# 3. create_operation — direct unit tests
+# ---------------------------------------------------------------------------
+
+class TestCreateOperation:
+
+    def test_is_null_operator(self):
+        field = MagicMock()
+        field.__eq__ = lambda self, other: other is None  # noqa: E731
+        model = _make_model({'status': field})
+        # Should not raise
+        result = create_operation(model, 'status', 'is_null', None)
+        # is_null uses `f == None`, result is a SQLAlchemy expression mock
+        assert result is not None
+
+    def test_eq_operator(self):
+        field = MagicMock()
+        model = _make_model({'id': field})
+        create_operation(model, 'id', '==', '629c46cc-c017-4a07-8445-4d2690119b69')
+        field.__eq__.assert_called_once_with('629c46cc-c017-4a07-8445-4d2690119b69')
+
+    def test_in_operator(self):
+        field = MagicMock()
+        model = _make_model({'status': field})
+        create_operation(model, 'status', 'in', ['a', 'b'])
+        field.in_.assert_called_once_with(['a', 'b'])
+
+    def test_like_operator(self):
+        field = MagicMock()
+        model = _make_model({'name': field})
+        create_operation(model, 'name', 'like', '%foo%')
+        field.like.assert_called_once_with('%foo%')
+
+    def test_comparison_to_null_raises(self):
+        field = MagicMock()
+        model = _make_model({'name': field})
+        with pytest.raises(ComparisonToNullError):
+            create_operation(model, 'name', '==', None)
+
+    def test_unknown_operator_raises_key_error(self):
+        model = _make_model({'name': MagicMock()})
+        with pytest.raises(KeyError):
+            create_operation(model, 'name', 'totally_unknown_op', 'x')
+
+
+# ---------------------------------------------------------------------------
+# 4. Filter.from_dictionary — or / and nesting
+# ---------------------------------------------------------------------------
+
+class TestFilterFromDictionary:
+
+    def _model_with_id(self):
+        model = MagicMock()
+        model.__name__ = "FakeModel"
+        model.id = MagicMock()
+        # hasattr must return True for 'id'
+        type(model).__contains__ = lambda s, k: k == 'id'
+        return model
+
+    def test_simple_filter(self):
+        model = self._model_with_id()
+        d = {'name': 'id', 'op': '==', 'val': '629c46cc-c017-4a07-8445-4d2690119b69'}
+        f = Filter.from_dictionary(model, d)
+        assert isinstance(f, Filter)
+        assert f.fieldname == 'id'
+        assert f.operator == '=='
+        assert f.argument == '629c46cc-c017-4a07-8445-4d2690119b69'
+
+    def test_or_filter_produces_disjunction(self):
+        model = self._model_with_id()
+        d = {
+            'or': [
+                {'name': 'id', 'op': '==', 'val': '629c46cc-c017-4a07-8445-4d2690119b69'},
+            ]
+        }
+        f = Filter.from_dictionary(model, d)
+        assert isinstance(f, DisjunctionFilter)
+        subfilters = list(f)
+        assert len(subfilters) == 1
+        assert subfilters[0].fieldname == 'id'
+
+    def test_and_filter_produces_conjunction(self):
+        model = self._model_with_id()
+        d = {
+            'and': [
+                {'name': 'id', 'op': '==', 'val': 'aaa'},
+                {'name': 'id', 'op': '!=', 'val': 'bbb'},
+            ]
+        }
+        f = Filter.from_dictionary(model, d)
+        assert isinstance(f, ConjunctionFilter)
+        assert len(list(f)) == 2
+
+    def test_nested_or_in_and(self):
+        model = self._model_with_id()
+        d = {
+            'or': [
+                {'name': 'id', 'op': '==', 'val': 'x'},
+                {'name': 'id', 'op': '==', 'val': 'y'},
+            ]
+        }
+        f = Filter.from_dictionary(model, d)
+        assert isinstance(f, DisjunctionFilter)
+        assert len(list(f)) == 2
+
+
+# ---------------------------------------------------------------------------
+# 5. create_filter — disjunction and conjunction are passed through SQLAlchemy
+# ---------------------------------------------------------------------------
+
+class TestCreateFilter:
+
+    def _model_with_field(self, field_name='id'):
+        model = MagicMock()
+        model.__name__ = "FakeModel"
+        field = MagicMock()
+        setattr(model, field_name, field)
+        return model, field
+
+    def test_create_filter_simple_eq(self):
+        model, field = self._model_with_field('id')
+        filt = Filter('id', '==', '629c46cc-c017-4a07-8445-4d2690119b69')
+        create_filter(model, filt)
+        field.__eq__.assert_called_once_with('629c46cc-c017-4a07-8445-4d2690119b69')
+
+    def test_create_filter_disjunction_does_not_raise(self):
+        model, field = self._model_with_field('id')
+        f1 = Filter('id', '==', 'aaa')
+        f2 = Filter('id', '==', 'bbb')
+        disj = DisjunctionFilter(f1, f2)
+        # Should not raise; SQLAlchemy or_() wraps the generator
+        result = create_filter(model, disj)
+        assert result is not None
+
+    def test_create_filter_conjunction_does_not_raise(self):
+        model, field = self._model_with_field('id')
+        f1 = Filter('id', '==', 'aaa')
+        f2 = Filter('id', 'is_null', None)
+        conj = ConjunctionFilter(f1, f2)
+        result = create_filter(model, conj)
+        assert result is not None

{ul_db_utils-6.0.0.dev3 → ul_db_utils-6.0.2}/ul_db_utils/search/db_search.py

@@ -147,9 +147,9 @@ def _sub_operator(model: Type[Model], argument: Dict[str, Any], fieldname: str)
 def create_operation(model: Type[Model], fieldname: str, operator: str, argument: Optional[Any]) -> bool:
     # raises KeyError if operator not in OPERATORS
     opfunc = OPERATORS[operator]
-    # In Python 3.0 or later, this should be `inspect.getfullargspec`
-    # because `inspect.getargspec` is deprecated.
-    numargs = len(inspect.getargspec(opfunc).args)
+    # Use inspect.signature for Python 3.14+ compatibility
+    # (inspect.getargspec was removed in Python 3.14).
+    numargs = len(inspect.signature(opfunc).parameters)
     # raises AttributeError if `fieldname` does not exist
     field = getattr(model, fieldname)
     # each of these will raise a TypeError if the wrong number of argments

{ul_db_utils-6.0.0.dev3 → ul_db_utils-6.0.2/ul_db_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ul-db-utils
-Version: 6.0.0.dev3
+Version: 6.0.2
 Summary: UL db utils Python package
 Author: Unic-lab
 License: MIT
@@ -22,7 +22,7 @@ Requires-Dist: alembic>=1.18.4
 Requires-Dist: flask-mongoengine-3>=1.1.0
 Requires-Dist: redis>=7.4.0
 Requires-Dist: psycopg2-binary>=2.9.11
-Requires-Dist: ul-py-tool>=3.0.2.dev1
+Requires-Dist: ul-py-tool>=3.0.3
 Provides-Extra: dev
 Requires-Dist: uv-script>=0.1.9; extra == "dev"
 Dynamic: license-file

{ul_db_utils-6.0.0.dev3 → ul_db_utils-6.0.2}/ul_db_utils.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_db_search_operators.py
 ul_db_utils/__init__.py
 ul_db_utils/conf.py
 ul_db_utils/main.py

{ul_db_utils-6.0.0.dev3 → ul_db_utils-6.0.2}/ul_db_utils.egg-info/requires.txt

@@ -8,7 +8,7 @@ alembic>=1.18.4
 flask-mongoengine-3>=1.1.0
 redis>=7.4.0
 psycopg2-binary>=2.9.11
-ul-py-tool>=3.0.2.dev1
+ul-py-tool>=3.0.3
 
 [dev]
 uv-script>=0.1.9