json-object-mapper 2.0.0__tar.gz → 2.1.0__tar.gz

{json_object_mapper-2.0.0/src/json_object_mapper.egg-info → json_object_mapper-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-object-mapper
-Version: 2.0.0
+Version: 2.1.0
 Summary: Attribute-style access wrapper for JSON-like data with dot-path set/delete and safe defaults
 Author-email: Kobby Owen <dev@kobbyowen.com>
 License-Expression: MIT
@@ -37,12 +37,41 @@ print(obj.to_json(indent=2))
 
 - Attribute-style access (`obj.key`) for dict keys
 - Recursive wrapping for nested dicts and lists
+- Query engine (`query`, `exists`, `count`, `compile`) with wildcard and filter support
+- ORM-like list helpers via `QueryableList` (`filter`, `get`, `first`, `last`, `count`)
 - Read-only mode (immutability enforced)
 - Dot/bracket path lookups (`obj.get_path("a.b[0].c")`)
 - **New:** `set_path()` / `del_path()` for dot paths
 - **New:** `default_factory` + `autocreate_missing` for safe defaults
 - Utility methods: `to_dict`, `to_json`, `from_json`, `merge`
 
+## Release Notes
+
+### v2.1.0
+
+- Renamed import path to `json_object_mapper` and aligned package metadata for the new distribution name.
+- Added JSONPath-like query API:
+  - `obj.query(expression, first=False, default=None)`
+  - `obj.exists(expression)`
+  - `obj.count(expression)`
+  - `obj.compile(expression)`
+- Implemented query features: property access, nested access, list indexing, wildcards, nested wildcard flattening, and basic filters (`==`, `!=`, `>`, `<`, `>=`, `<=`).
+- Isolated query implementation into a dedicated module for maintainability.
+- Added ORM-style list querying through `QueryableList`:
+  - `filter(...)`, `get(...)`, `first()`, `last()`, `count()`
+  - Supports nested field filters such as `profile__age__gt=20`.
+- Expanded test coverage significantly across mapper, query parser, query engine, and queryable list behavior (including deep nested JSON scenarios and edge cases).
+- Added strict type-checking support:
+  - mypy configuration in project metadata
+  - `py.typed` marker for typed package support
+  - type fixes in mapper and queryable helpers
+- CI improvements:
+  - Ruff linting
+  - mypy checks
+  - multi-version unit tests
+  - build and package validation
+- Publishing workflow configured for PyPI release automation.
+
 ## Install
 
 ```bash
@@ -102,6 +131,8 @@ except AttributeError:
 ```bash
 python -m pip install -e .
 python -m unittest discover -s tests -v
+venv/bin/ruff check .
+venv/bin/mypy .
 ```
 
 ## Publishing

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/README.md

@@ -22,12 +22,41 @@ print(obj.to_json(indent=2))
 
 - Attribute-style access (`obj.key`) for dict keys
 - Recursive wrapping for nested dicts and lists
+- Query engine (`query`, `exists`, `count`, `compile`) with wildcard and filter support
+- ORM-like list helpers via `QueryableList` (`filter`, `get`, `first`, `last`, `count`)
 - Read-only mode (immutability enforced)
 - Dot/bracket path lookups (`obj.get_path("a.b[0].c")`)
 - **New:** `set_path()` / `del_path()` for dot paths
 - **New:** `default_factory` + `autocreate_missing` for safe defaults
 - Utility methods: `to_dict`, `to_json`, `from_json`, `merge`
 
+## Release Notes
+
+### v2.1.0
+
+- Renamed import path to `json_object_mapper` and aligned package metadata for the new distribution name.
+- Added JSONPath-like query API:
+  - `obj.query(expression, first=False, default=None)`
+  - `obj.exists(expression)`
+  - `obj.count(expression)`
+  - `obj.compile(expression)`
+- Implemented query features: property access, nested access, list indexing, wildcards, nested wildcard flattening, and basic filters (`==`, `!=`, `>`, `<`, `>=`, `<=`).
+- Isolated query implementation into a dedicated module for maintainability.
+- Added ORM-style list querying through `QueryableList`:
+  - `filter(...)`, `get(...)`, `first()`, `last()`, `count()`
+  - Supports nested field filters such as `profile__age__gt=20`.
+- Expanded test coverage significantly across mapper, query parser, query engine, and queryable list behavior (including deep nested JSON scenarios and edge cases).
+- Added strict type-checking support:
+  - mypy configuration in project metadata
+  - `py.typed` marker for typed package support
+  - type fixes in mapper and queryable helpers
+- CI improvements:
+  - Ruff linting
+  - mypy checks
+  - multi-version unit tests
+  - build and package validation
+- Publishing workflow configured for PyPI release automation.
+
 ## Install
 
 ```bash
@@ -87,6 +116,8 @@ except AttributeError:
 ```bash
 python -m pip install -e .
 python -m unittest discover -s tests -v
+venv/bin/ruff check .
+venv/bin/mypy .
 ```
 
 ## Publishing

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "json-object-mapper"
-version = "2.0.0"
+version = "2.1.0"
 description = "Attribute-style access wrapper for JSON-like data with dot-path set/delete and safe defaults"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -27,6 +27,9 @@ include-package-data = true
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+json_object_mapper = ["py.typed"]
+
 [tool.pytest.ini_options]
 addopts = "-q"
 
@@ -45,4 +48,10 @@ per-file-ignores = { "tests/*" = ["PLR2004"] }  # allow magic numbers in tests
 [tool.ruff.format]  # only used if you run "ruff format"
 quote-style = "double"
 indent-style = "space"
-skip-magic-trailing-comma = false
+skip-magic-trailing-comma = false
+
+[tool.mypy]
+python_version = "3.9"
+files = ["src", "tests"]
+mypy_path = "src"
+exclude = '(^build/|^dist/|^venv/|^\.venv/|^\.mypy_cache/|^setup\.py$)'

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/src/json_object_mapper/__init__.py

@@ -2,5 +2,6 @@
 
 from .core import JSONObjectMapper
 from .exceptions import JSONAccessError
+from .queryable import QueryableList
 
-__all__ = ["JSONAccessError", "JSONObjectMapper"]
+__all__ = ["JSONAccessError", "JSONObjectMapper", "QueryableList"]

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/src/json_object_mapper/core.py

@@ -26,6 +26,7 @@ from .helpers import (
     traverse_parent,
     wrap_value,
 )
+from .query import evaluate_query, evaluate_tokens, tokenize
 
 JSONScalar = Union[str, int, float, bool, None]
 JSONType = Union[JSONScalar, "JSONObjectMapper", List["JSONObjectMapper"], Dict[str, Any]]
@@ -121,7 +122,10 @@ class JSONObjectMapper:
             raise AttributeError("Cannot set attributes on a list")
         if not is_identifier(attribute_name):
             raise AttributeError(f"'{attribute_name}' is not a valid attribute name")
-        self.__json[attribute_name] = value
+        data = self.__json
+        if not isinstance(data, dict):
+            raise AttributeError("Cannot set attributes on a non-dict root")
+        data[attribute_name] = value
 
     # ----------------------------- mapping access -----------------------------
 
@@ -135,7 +139,18 @@ class JSONObjectMapper:
     def __setitem__(self, key: Union[int, str], value: Any) -> None:
         if self.__readonly:
             raise AttributeError("Mapper is read-only")
-        self.__json[key] = value  # type: ignore[index]
+        data = self.__json
+        if isinstance(data, dict):
+            if not isinstance(key, str):
+                raise TypeError("Dict roots require string keys")
+            data[key] = value
+            return
+        if isinstance(data, list):
+            if not isinstance(key, int):
+                raise TypeError("List roots require integer indexes")
+            data[key] = value
+            return
+        raise TypeError("Unsupported root type for item assignment")
 
     def __iter__(self) -> Iterator:
         return iter(self.__json)
@@ -165,6 +180,39 @@ class JSONObjectMapper:
             return (self._wrap(value) for value in self.__json.values())
         raise TypeError("values() only valid for dict roots")
 
+    # -------------------------------- query ops --------------------------------
+
+    def query(self, expression: str, *, first: bool = False, default: Any = None) -> Any:
+        results = self._evaluate_query(expression)
+        if not results:
+            if default is not None:
+                return default
+            return None if first else []
+        return results[0] if first else results
+
+    def exists(self, expression: str) -> bool:
+        return bool(self._evaluate_query(expression))
+
+    def count(self, expression: str) -> int:
+        return len(self._evaluate_query(expression))
+
+    def compile(self, expression: str):
+        tokens = tokenize(expression)
+
+        def runner(obj: "JSONObjectMapper") -> List[Any]:
+            if not isinstance(obj, JSONObjectMapper):
+                raise TypeError("Compiled query expects a JSONObjectMapper instance")
+            raw_data = object.__getattribute__(obj, "_JSONObjectMapper__json")
+            return evaluate_tokens(raw_data, tokens, obj._wrap)
+
+        return runner
+
+    def _evaluate_query(self, expression: str) -> List[Any]:
+        return evaluate_query(self.__json, expression, self._wrap)
+
+    def _evaluate_tokens(self, tokens: List[Any]) -> List[Any]:
+        return evaluate_tokens(self.__json, tokens, self._wrap)
+
     # -------------------------------- path ops --------------------------------
 
     def get_path(self, path: str, default: Any = None) -> Any:

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/src/json_object_mapper/helpers.py

@@ -1,6 +1,8 @@
 import re
 from typing import Any, Callable, List, Optional
 
+from .queryable import QueryableList
+
 
 def is_identifier(key: str) -> bool:
     return bool(re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", key))
@@ -132,12 +134,14 @@ def wrap_value(
             _no_copy=True,
         )
     if isinstance(value, list):
-        return [
-            (
-                wrap_value(item, readonly, default_factory, autocreate_missing, factory_object)
-                if isinstance(item, (dict, list))
-                else item
-            )
-            for item in value
-        ]
+        return QueryableList(
+            [
+                (
+                    wrap_value(item, readonly, default_factory, autocreate_missing, factory_object)
+                    if isinstance(item, (dict, list))
+                    else item
+                )
+                for item in value
+            ]
+        )
     return value

json_object_mapper-2.1.0/src/json_object_mapper/query.py

@@ -0,0 +1,149 @@
+import re
+from typing import Any, Callable, List, Tuple
+
+QUERY_OPERATORS = ("==", "!=", ">=", "<=", ">", "<")
+
+
+def tokenize(expr: str) -> List[Any]:
+    tokens: List[Any] = []
+    index = 0
+    source = expr.strip()
+
+    while index < len(source):
+        char = source[index]
+        if char == ".":
+            index += 1
+            continue
+
+        if char == "[":
+            close = source.find("]", index)
+            if close == -1:
+                raise ValueError(f"Unclosed bracket in query expression: {expr!r}")
+            content = source[index + 1 : close].strip()
+            if content == "*":
+                tokens.append("*")
+            elif content.startswith("?"):
+                condition = content[1:].strip()
+                if not condition:
+                    raise ValueError(f"Empty filter condition in query expression: {expr!r}")
+                tokens.append({"filter": condition})
+            else:
+                try:
+                    tokens.append(int(content))
+                except ValueError as error:
+                    raise ValueError(
+                        f"Unsupported bracket token [{content}] in {expr!r}"
+                    ) from error
+            index = close + 1
+            continue
+
+        start = index
+        while index < len(source) and source[index] not in ".[":
+            index += 1
+        name = source[start:index].strip()
+        if name:
+            tokens.append(name)
+
+    return tokens
+
+
+def evaluate_query(root: Any, expression: str, wrap: Callable[[Any], Any]) -> List[Any]:
+    return evaluate_tokens(root, tokenize(expression), wrap)
+
+
+def evaluate_tokens(root: Any, tokens: List[Any], wrap: Callable[[Any], Any]) -> List[Any]:
+    results: List[Any] = [root]
+    for token in tokens:
+        next_results: List[Any] = []
+        for item in results:
+            if isinstance(token, str):
+                if token == "*":
+                    if isinstance(item, list):
+                        next_results.extend(item)
+                    elif isinstance(item, dict):
+                        next_results.extend(item.values())
+                    continue
+                if isinstance(item, dict) and token in item:
+                    next_results.append(item[token])
+                continue
+
+            if isinstance(token, int):
+                if isinstance(item, list) and 0 <= token < len(item):
+                    next_results.append(item[token])
+                continue
+
+            if isinstance(token, dict) and "filter" in token:
+                if isinstance(item, list):
+                    try:
+                        next_results.extend(apply_filter(item, token["filter"]))
+                    except ValueError:
+                        continue
+                continue
+        results = next_results
+
+    return [wrap(value) for value in results]
+
+
+def parse_condition(condition: str) -> Tuple[str, str, Any]:
+    text = condition.strip()
+    for operator in QUERY_OPERATORS:
+        if operator in text:
+            left, right = text.split(operator, 1)
+            field = left.strip()
+            value_text = right.strip()
+            if not field or not value_text:
+                raise ValueError(f"Invalid filter condition: {condition!r}")
+            return field, operator, coerce_condition_value(value_text)
+    raise ValueError(f"Unsupported filter condition: {condition!r}")
+
+
+def coerce_condition_value(value: str) -> Any:
+    result: Any = value
+    if (value.startswith('"') and value.endswith('"')) or (
+        value.startswith("'") and value.endswith("'")
+    ):
+        result = value[1:-1]
+    elif re.fullmatch(r"-?\d+", value):
+        result = int(value)
+    elif re.fullmatch(r"-?\d+\.\d+", value):
+        result = float(value)
+    else:
+        lowered = value.lower()
+        if lowered == "true":
+            result = True
+        elif lowered == "false":
+            result = False
+        elif lowered == "null":
+            result = None
+    return result
+
+
+def compare(left: Any, operator: str, right: Any) -> bool:
+    operations = {
+        "==": lambda a, b: a == b,
+        "!=": lambda a, b: a != b,
+        ">": lambda a, b: a > b,
+        "<": lambda a, b: a < b,
+        ">=": lambda a, b: a >= b,
+        "<=": lambda a, b: a <= b,
+    }
+    fn = operations.get(operator)
+    if fn is None:
+        return False
+    try:
+        return fn(left, right)
+    except TypeError:
+        return False
+
+
+def apply_filter(items: List[Any], condition: str) -> List[Any]:
+    field, operator, expected = parse_condition(condition)
+    matches: List[Any] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        if field not in item:
+            continue
+        if compare(item[field], operator, expected):
+            matches.append(item)
+    return matches

json_object_mapper-2.1.0/src/json_object_mapper/queryable.py

@@ -0,0 +1,80 @@
+from typing import Any, Dict, Iterable
+
+OPS = {"eq", "ne", "gt", "lt", "gte", "lte"}
+_COUNT_SENTINEL = object()
+
+
+class QueryableList(list):
+    """List wrapper with ORM-like helper methods."""
+
+    def __init__(self, data: Iterable[Any]):
+        super().__init__(data)
+
+    def filter(self, **conditions: Any) -> "QueryableList":
+        results = [item for item in self if _matches(item, conditions)]
+        return QueryableList(results)
+
+    def get(self, **conditions: Any) -> Any:
+        results = self.filter(**conditions)
+        if len(results) == 0:
+            raise ValueError("No matching item found")
+        if len(results) > 1:
+            raise ValueError("Multiple items found")
+        return results[0]
+
+    def first(self) -> Any:
+        return self[0] if self else None
+
+    def last(self) -> Any:
+        return self[-1] if self else None
+
+    def count(self, value: Any = _COUNT_SENTINEL, /) -> int:
+        if value is _COUNT_SENTINEL:
+            return len(self)
+        return super().count(value)
+
+
+def _matches(item: Any, conditions: Dict[str, Any]) -> bool:
+    for key, expected in conditions.items():
+        field_parts = key.split("__")
+        if len(field_parts) > 1 and field_parts[-1] in OPS:
+            op = field_parts[-1]
+            field_path = "__".join(field_parts[:-1])
+        else:
+            op = "eq"
+            field_path = key
+
+        actual = _get_nested_attr(item, field_path)
+        if not _compare(actual, op, expected):
+            return False
+    return True
+
+
+def _get_nested_attr(obj: Any, path: str) -> Any:
+    value = obj
+    for part in path.split("__"):
+        if value is None:
+            return None
+        if isinstance(value, dict):
+            value = value.get(part)
+            continue
+        value = getattr(value, part, None)
+    return value
+
+
+def _compare(a: Any, op: str, b: Any) -> bool:
+    operations = {
+        "eq": lambda left, right: left == right,
+        "ne": lambda left, right: left != right,
+        "gt": lambda left, right: left > right,
+        "lt": lambda left, right: left < right,
+        "gte": lambda left, right: left >= right,
+        "lte": lambda left, right: left <= right,
+    }
+    fn = operations.get(op)
+    if fn is None:
+        return False
+    try:
+        return fn(a, b)
+    except TypeError:
+        return False

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0/src/json_object_mapper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-object-mapper
-Version: 2.0.0
+Version: 2.1.0
 Summary: Attribute-style access wrapper for JSON-like data with dot-path set/delete and safe defaults
 Author-email: Kobby Owen <dev@kobbyowen.com>
 License-Expression: MIT
@@ -37,12 +37,41 @@ print(obj.to_json(indent=2))
 
 - Attribute-style access (`obj.key`) for dict keys
 - Recursive wrapping for nested dicts and lists
+- Query engine (`query`, `exists`, `count`, `compile`) with wildcard and filter support
+- ORM-like list helpers via `QueryableList` (`filter`, `get`, `first`, `last`, `count`)
 - Read-only mode (immutability enforced)
 - Dot/bracket path lookups (`obj.get_path("a.b[0].c")`)
 - **New:** `set_path()` / `del_path()` for dot paths
 - **New:** `default_factory` + `autocreate_missing` for safe defaults
 - Utility methods: `to_dict`, `to_json`, `from_json`, `merge`
 
+## Release Notes
+
+### v2.1.0
+
+- Renamed import path to `json_object_mapper` and aligned package metadata for the new distribution name.
+- Added JSONPath-like query API:
+  - `obj.query(expression, first=False, default=None)`
+  - `obj.exists(expression)`
+  - `obj.count(expression)`
+  - `obj.compile(expression)`
+- Implemented query features: property access, nested access, list indexing, wildcards, nested wildcard flattening, and basic filters (`==`, `!=`, `>`, `<`, `>=`, `<=`).
+- Isolated query implementation into a dedicated module for maintainability.
+- Added ORM-style list querying through `QueryableList`:
+  - `filter(...)`, `get(...)`, `first()`, `last()`, `count()`
+  - Supports nested field filters such as `profile__age__gt=20`.
+- Expanded test coverage significantly across mapper, query parser, query engine, and queryable list behavior (including deep nested JSON scenarios and edge cases).
+- Added strict type-checking support:
+  - mypy configuration in project metadata
+  - `py.typed` marker for typed package support
+  - type fixes in mapper and queryable helpers
+- CI improvements:
+  - Ruff linting
+  - mypy checks
+  - multi-version unit tests
+  - build and package validation
+- Publishing workflow configured for PyPI release automation.
+
 ## Install
 
 ```bash
@@ -102,6 +131,8 @@ except AttributeError:
 ```bash
 python -m pip install -e .
 python -m unittest discover -s tests -v
+venv/bin/ruff check .
+venv/bin/mypy .
 ```
 
 ## Publishing

{json_object_mapper-2.0.0 → json_object_mapper-2.1.0}/src/json_object_mapper.egg-info/SOURCES.txt

@@ -6,8 +6,14 @@ src/json_object_mapper/__init__.py
 src/json_object_mapper/core.py
 src/json_object_mapper/exceptions.py
 src/json_object_mapper/helpers.py
+src/json_object_mapper/py.typed
+src/json_object_mapper/query.py
+src/json_object_mapper/queryable.py
 src/json_object_mapper.egg-info/PKG-INFO
 src/json_object_mapper.egg-info/SOURCES.txt
 src/json_object_mapper.egg-info/dependency_links.txt
 src/json_object_mapper.egg-info/top_level.txt
-tests/test_json_object_mapper.py
+tests/test_json_object_mapper.py
+tests/test_query_engine.py
+tests/test_query_parser.py
+tests/test_queryable_list.py

json_object_mapper-2.1.0/tests/test_query_engine.py

@@ -0,0 +1,165 @@
+import unittest
+
+from json_object_mapper import JSONObjectMapper
+
+
+class TestQueryEngine(unittest.TestCase):
+    def setUp(self):
+        self.data = {
+            "users": [
+                {
+                    "name": "Kobby",
+                    "age": 29,
+                    "skills": ["python", "aws"],
+                    "score": 91.5,
+                    "active": True,
+                    "nickname": None,
+                    "profile": {
+                        "preferences": {
+                            "theme": "dark",
+                            "notifications": {"email": True, "sms": False},
+                        },
+                        "addresses": [
+                            {"city": "Accra", "geo": {"lat": 5.6037, "lng": -0.187}},
+                            {"city": "Kumasi", "geo": {"lat": 6.6885, "lng": -1.6244}},
+                        ],
+                    },
+                    "projects": [
+                        {
+                            "name": "atlas",
+                            "repos": [
+                                {"name": "api", "stars": 120},
+                                {"name": "worker", "stars": 55},
+                            ],
+                        },
+                        {
+                            "name": "pulse",
+                            "repos": [{"name": "dashboard", "stars": 80}],
+                        },
+                    ],
+                },
+                {
+                    "name": "Ama",
+                    "age": 22,
+                    "skills": ["design"],
+                    "score": 88.0,
+                    "active": False,
+                    "nickname": "A",
+                    "profile": {
+                        "preferences": {
+                            "theme": "light",
+                            "notifications": {"email": False, "sms": True},
+                        },
+                        "addresses": [{"city": "Tamale", "geo": {"lat": 9.4075, "lng": -0.8533}}],
+                    },
+                    "projects": [
+                        {
+                            "name": "canvas",
+                            "repos": [{"name": "ui-kit", "stars": 65}],
+                        }
+                    ],
+                },
+                {
+                    "name": "Jo",
+                    "skills": [],
+                    "active": True,
+                    "profile": {"preferences": {"theme": "dark"}},
+                    "projects": [],
+                },
+            ],
+            "teams": {
+                "backend": [{"name": "Kobby"}],
+                "design": [{"name": "Ama"}],
+            },
+        }
+        self.obj = JSONObjectMapper(self.data)
+
+    def test_query_wildcard_names(self):
+        self.assertEqual(self.obj.query("users[*].name"), ["Kobby", "Ama", "Jo"])
+
+    def test_query_filter(self):
+        self.assertEqual(self.obj.query("users[?age > 25].name"), ["Kobby"])
+
+    def test_query_nested_wildcard_flatten(self):
+        self.assertEqual(self.obj.query("users[*].skills[*]"), ["python", "aws", "design"])
+
+    def test_query_first(self):
+        self.assertEqual(self.obj.query("users[0].name", first=True), "Kobby")
+
+    def test_query_default(self):
+        self.assertEqual(self.obj.query("invalid.path", default=[]), [])
+
+    def test_exists(self):
+        self.assertTrue(self.obj.exists("users[0].name"))
+
+    def test_count(self):
+        self.assertEqual(self.obj.count("users[*]"), 3)
+
+    def test_compile(self):
+        compiled = self.obj.compile("users[*].name")
+        self.assertEqual(compiled(self.obj), ["Kobby", "Ama", "Jo"])
+
+    def test_query_safe_missing_branch(self):
+        self.assertEqual(self.obj.query("users[*].profile.preferences.locale.timezone"), [])
+
+    def test_query_out_of_range_index(self):
+        self.assertEqual(self.obj.query("users[99].name"), [])
+
+    def test_query_filter_string_equals(self):
+        self.assertEqual(self.obj.query("users[?name == 'Ama'].name"), ["Ama"])
+
+    def test_query_filter_not_equals(self):
+        self.assertEqual(self.obj.query("users[?name != 'Ama'].name"), ["Kobby", "Jo"])
+
+    def test_query_filter_boolean(self):
+        self.assertEqual(self.obj.query("users[?active == true].name"), ["Kobby", "Jo"])
+
+    def test_query_filter_null(self):
+        self.assertEqual(self.obj.query("users[?nickname == null].name"), ["Kobby"])
+
+    def test_query_filter_float(self):
+        self.assertEqual(self.obj.query("users[?score >= 90.0].name"), ["Kobby"])
+
+    def test_query_invalid_filter_is_safe(self):
+        self.assertEqual(self.obj.query("users[?age ~~ 10].name"), [])
+
+    def test_query_root_dict_wildcard(self):
+        self.assertEqual(self.obj.query("teams.*[*].name"), ["Kobby", "Ama"])
+
+    def test_query_first_without_default(self):
+        self.assertIsNone(self.obj.query("users[99].name", first=True))
+
+    def test_query_first_with_default(self):
+        self.assertEqual(self.obj.query("users[99].name", first=True, default="missing"), "missing")
+
+    def test_exists_false(self):
+        self.assertFalse(self.obj.exists("users[?age < 0].name"))
+
+    def test_compile_rejects_non_mapper(self):
+        compiled = self.obj.compile("users[*].name")
+        with self.assertRaises(TypeError):
+            compiled({"users": []})
+
+    def test_compile_reusable_on_another_mapper(self):
+        compiled = self.obj.compile("users[*].name")
+        another = JSONObjectMapper({"users": [{"name": "Esi"}]})
+        self.assertEqual(compiled(another), ["Esi"])
+
+    def test_query_deep_property_path(self):
+        self.assertEqual(self.obj.query("users[0].profile.preferences.theme"), ["dark"])
+
+    def test_query_deep_index_access(self):
+        self.assertEqual(self.obj.query("users[0].profile.addresses[1].geo.lat"), [6.6885])
+
+    def test_query_multi_wildcard_deep_flatten(self):
+        self.assertEqual(
+            self.obj.query("users[*].projects[*].repos[*].name"),
+            ["api", "worker", "dashboard", "ui-kit"],
+        )
+
+    def test_query_filter_then_deep_path(self):
+        self.assertEqual(self.obj.query("users[?age >= 25].profile.preferences.theme"), ["dark"])
+
+
+if __name__ == "__main__":
+    unittest.main()

json_object_mapper-2.1.0/tests/test_query_parser.py

@@ -0,0 +1,70 @@
+import unittest
+
+from json_object_mapper.query import (
+    apply_filter,
+    coerce_condition_value,
+    compare,
+    parse_condition,
+    tokenize,
+)
+
+
+class TestQueryParser(unittest.TestCase):
+    def test_tokenize_index_and_property(self):
+        self.assertEqual(tokenize("users[0].name"), ["users", 0, "name"])
+
+    def test_tokenize_wildcard(self):
+        self.assertEqual(tokenize("users[*].name"), ["users", "*", "name"])
+
+    def test_tokenize_filter(self):
+        self.assertEqual(tokenize("users[?age > 25]"), ["users", {"filter": "age > 25"}])
+
+    def test_parse_condition(self):
+        self.assertEqual(parse_condition("age >= 25"), ("age", ">=", 25))
+
+    def test_apply_filter(self):
+        items = [
+            {"name": "Kobby", "age": 29},
+            {"name": "Ama", "age": 22},
+        ]
+        self.assertEqual(apply_filter(items, "age > 25"), [{"name": "Kobby", "age": 29}])
+
+    def test_tokenize_unclosed_bracket_raises(self):
+        with self.assertRaises(ValueError):
+            tokenize("users[0")
+
+    def test_tokenize_empty_filter_raises(self):
+        with self.assertRaises(ValueError):
+            tokenize("users[?]")
+
+    def test_tokenize_unsupported_bracket_token_raises(self):
+        with self.assertRaises(ValueError):
+            tokenize("users[abc]")
+
+    def test_parse_condition_with_string_value(self):
+        self.assertEqual(parse_condition("name == 'Ama'"), ("name", "==", "Ama"))
+
+    def test_parse_condition_with_float_value(self):
+        self.assertEqual(parse_condition("score >= 91.5"), ("score", ">=", 91.5))
+
+    def test_parse_condition_with_bool_and_null(self):
+        self.assertEqual(parse_condition("active == true"), ("active", "==", True))
+        self.assertEqual(parse_condition("nickname == null"), ("nickname", "==", None))
+
+    def test_parse_condition_invalid_operator_raises(self):
+        with self.assertRaises(ValueError):
+            parse_condition("age ~~ 10")
+
+    def test_coerce_condition_value_negative_int(self):
+        self.assertEqual(coerce_condition_value("-42"), -42)
+
+    def test_compare_type_error_is_false(self):
+        self.assertFalse(compare("abc", ">", 10))
+
+    def test_apply_filter_skips_non_dict_items(self):
+        items = [{"age": 10}, "invalid", 2, {"age": 30}]
+        self.assertEqual(apply_filter(items, "age >= 20"), [{"age": 30}])
+
+
+if __name__ == "__main__":
+    unittest.main()

json_object_mapper-2.1.0/tests/test_queryable_list.py

@@ -0,0 +1,79 @@
+import unittest
+
+from json_object_mapper import JSONObjectMapper, QueryableList
+
+
+class TestQueryableList(unittest.TestCase):
+    def setUp(self):
+        self.data = {
+            "users": [
+                {"name": "Kobby", "age": 29, "profile": {"age": 29, "city": "Accra"}},
+                {"name": "Ama", "age": 22, "profile": {"age": 22, "city": "Tamale"}},
+                {"name": "Kobby", "age": 35, "profile": {"age": 35, "city": "Kumasi"}},
+            ]
+        }
+        self.obj = JSONObjectMapper(self.data)
+
+    def test_users_is_queryable_list(self):
+        self.assertIsInstance(self.obj.users, QueryableList)
+
+    def test_filter_eq(self):
+        results = self.obj.users.filter(name="Ama")
+        self.assertEqual(results.count(), 1)
+        self.assertEqual(results.first().name, "Ama")
+
+    def test_filter_operator_gt(self):
+        results = self.obj.users.filter(age__gt=25)
+        self.assertEqual([item.name for item in results], ["Kobby", "Kobby"])
+
+    def test_filter_operator_lte(self):
+        results = self.obj.users.filter(age__lte=29)
+        self.assertEqual([item.name for item in results], ["Kobby", "Ama"])
+
+    def test_filter_multiple_conditions(self):
+        results = self.obj.users.filter(name="Kobby", age__gte=30)
+        self.assertEqual(results.count(), 1)
+        self.assertEqual(results.first().age, 35)
+
+    def test_filter_chainable(self):
+        result = self.obj.users.filter(age__gt=20).filter(name="Kobby")
+        self.assertIsInstance(result, QueryableList)
+        self.assertEqual([item.age for item in result], [29, 35])
+
+    def test_get_single(self):
+        result = self.obj.users.get(name="Ama")
+        self.assertEqual(result.age, 22)
+
+    def test_get_no_match_raises(self):
+        with self.assertRaises(ValueError):
+            self.obj.users.get(name="Missing")
+
+    def test_get_multiple_match_raises(self):
+        with self.assertRaises(ValueError):
+            self.obj.users.get(name="Kobby")
+
+    def test_first_last(self):
+        self.assertEqual(self.obj.users.first().name, "Kobby")
+        self.assertEqual(self.obj.users.last().name, "Kobby")
+
+    def test_count(self):
+        self.assertEqual(self.obj.users.count(), 3)
+
+    def test_nested_field_support(self):
+        results = self.obj.users.filter(profile__age__gt=30)
+        self.assertEqual(results.count(), 1)
+        self.assertEqual(results.first().name, "Kobby")
+
+    def test_nested_field_missing_is_safe(self):
+        results = self.obj.users.filter(profile__country="GH")
+        self.assertEqual(results.count(), 0)
+
+    def test_queryable_list_on_nested_list(self):
+        mapped = JSONObjectMapper({"groups": [{"members": [{"name": "A"}, {"name": "B"}]}]})
+        members = mapped.groups[0].members
+        self.assertIsInstance(members, QueryableList)
+        self.assertEqual(members.filter(name="B").first().name, "B")
+
+
+if __name__ == "__main__":
+    unittest.main()