jqson 0.1.0__tar.gz

jqson-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Martin Strohalm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jqson-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

jqson-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: jqson
+Version: 0.1.0
+Summary: Define and run test queries from JSON.
+Home-page: https://github.com/xxao/jqson
+Author: Martin Strohalm
+Author-email: 
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+#  JqSON
+
+The *JqSON* library was developed to provide a simple way to define queries in JSON format, which can later be run
+in Python.
+
+```python
+from dataclasses import dataclass
+from jqson import Query
+
+@dataclass
+class Person(object):
+    name: str = ""
+    age: int = 0
+    children: list[Person] = ()
+
+P1 = Person(name="P1", age=10)
+P2 = Person(name="P2", age=7)
+P3 = Person(name="P3", age=50, children=[P1, P2])
+P4 = Person(name="P4", age=77, children=[P3])
+
+text = """
+[
+    {"query": "where", "key": [
+        {"query": "not_empty", "left": "children"}
+    ]},
+    {"query": "all", "key": [
+        {"query": "attr", "name":"age"},
+        {"query": "and", "conditions": [
+            {"query": "not_null"},
+            {"query": ">", "value": 20},
+            {"query": "<", "value": 100}
+        ]}
+    ]}
+]
+"""
+
+data = [P1, P2, P3, P4]
+query = Query.from_text(text)
+print(query(data))
+
+# equivalent of
+print(all((p.age is not None and 20 < p.age < 100) for p in data if p.children))
+```
+
+## Installation
+
+The *JqSON* library is fully implemented in Python. No additional compiler is necessary. After downloading the source
+code just run the following command from the *jqson* folder:
+
+```$ python setup.py install```
+
+or simply by using pip
+
+```$ pip install jqson```
+
+## Requirements
+
+- [Python 3.14+](https://www.python.org)
+
+## Selector Queries
+
+- **Path**: *{"query": "path", "path": "PATH"}*
+- **Attr**: *{"query": "attr", "name": "NAME"}*
+- **Item**: *{"query": "item", "key": "KEY"}*
+- **Bool**: *{"query": "bool"}*
+- **Len**: *{"query": "len"}*
+- **Variable**: *{"query": "var", "name": "NAME", "value": "VALUE", "path": "PATH"}*
+
+## Collections Queries
+
+- **Select**: *{"query": "select", "path": "PATH"}*
+- **Many**: *{"query": "many", "path": "PATH"}*
+- **Sum**: *{"query": "sum", "path": "PATH"}*
+- **Mean**: *{"query": "mean", "path": "PATH"}*
+
+- **Where**: *{"query": "where", "key": "KEY"}*
+- **First**: *{"query": "first", "key": "KEY"}*
+- **Last**: *{"query": "last", "key": "KEY"}*
+- **Single**: *{"query": "single", "key": "KEY"}*
+- **Distinct**: *{"query": "distinct", "key": "KEY"}*
+- **Any**: *{"query": "any", "key": "KEY"}*
+- **All**: *{"query": "all", "key": "KEY"}*
+- **Noone**: *{"query": "none", "key": "KEY"}*
+- **Count**: *{"query": "count", "key": "KEY"}*
+- **Min**: *{"query": "min", "key": "KEY"}*
+- **Max**: *{"query": "max", "key": "KEY"}*
+
+- **Sort**: *{"query": "sort", "key": "KEY", "reverse": "REVERSE"}*
+
+## Slicing Queries
+
+- **Take**: *{"query": "take", "count": "COUNT"}*
+- **Skip**: *{"query": "skip", "count": "COUNT"}*
+- **Slice**: *{"query": "slice", "start": "START", "end": "END", "step": "STEP"}*
+
+## Conditions Queries
+
+- **AND**: *{"query": "and", "conditions": "CONDITIONS"}*
+- **OR**: *{"query": "or", "conditions": "CONDITIONS"}*
+
+- **==**: *{"query": "==", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **!=**: *{"query": "!=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **>**: *{"query": ">", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **<**: *{"query": "<", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **>=**: *{"query": ">=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **<=**: *{"query": "<=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+
+- **in**: *{"query": "in", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **contains**: *{"query": "contains", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **has**: *{"query": "has", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+
+- **true**: *{"query": "true"}*
+- **false**: *{"query": "false"}*
+- **null**: *{"query": "null"}*
+- **empty**: *{"query": "empty"}*
+
+## Disclaimer
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

jqson-0.1.0/README.md

@@ -0,0 +1,120 @@
+#  JqSON
+
+The *JqSON* library was developed to provide a simple way to define queries in JSON format, which can later be run
+in Python.
+
+```python
+from dataclasses import dataclass
+from jqson import Query
+
+@dataclass
+class Person(object):
+    name: str = ""
+    age: int = 0
+    children: list[Person] = ()
+
+P1 = Person(name="P1", age=10)
+P2 = Person(name="P2", age=7)
+P3 = Person(name="P3", age=50, children=[P1, P2])
+P4 = Person(name="P4", age=77, children=[P3])
+
+text = """
+[
+    {"query": "where", "key": [
+        {"query": "not_empty", "left": "children"}
+    ]},
+    {"query": "all", "key": [
+        {"query": "attr", "name":"age"},
+        {"query": "and", "conditions": [
+            {"query": "not_null"},
+            {"query": ">", "value": 20},
+            {"query": "<", "value": 100}
+        ]}
+    ]}
+]
+"""
+
+data = [P1, P2, P3, P4]
+query = Query.from_text(text)
+print(query(data))
+
+# equivalent of
+print(all((p.age is not None and 20 < p.age < 100) for p in data if p.children))
+```
+
+## Installation
+
+The *JqSON* library is fully implemented in Python. No additional compiler is necessary. After downloading the source
+code just run the following command from the *jqson* folder:
+
+```$ python setup.py install```
+
+or simply by using pip
+
+```$ pip install jqson```
+
+## Requirements
+
+- [Python 3.14+](https://www.python.org)
+
+## Selector Queries
+
+- **Path**: *{"query": "path", "path": "PATH"}*
+- **Attr**: *{"query": "attr", "name": "NAME"}*
+- **Item**: *{"query": "item", "key": "KEY"}*
+- **Bool**: *{"query": "bool"}*
+- **Len**: *{"query": "len"}*
+- **Variable**: *{"query": "var", "name": "NAME", "value": "VALUE", "path": "PATH"}*
+
+## Collections Queries
+
+- **Select**: *{"query": "select", "path": "PATH"}*
+- **Many**: *{"query": "many", "path": "PATH"}*
+- **Sum**: *{"query": "sum", "path": "PATH"}*
+- **Mean**: *{"query": "mean", "path": "PATH"}*
+
+- **Where**: *{"query": "where", "key": "KEY"}*
+- **First**: *{"query": "first", "key": "KEY"}*
+- **Last**: *{"query": "last", "key": "KEY"}*
+- **Single**: *{"query": "single", "key": "KEY"}*
+- **Distinct**: *{"query": "distinct", "key": "KEY"}*
+- **Any**: *{"query": "any", "key": "KEY"}*
+- **All**: *{"query": "all", "key": "KEY"}*
+- **Noone**: *{"query": "none", "key": "KEY"}*
+- **Count**: *{"query": "count", "key": "KEY"}*
+- **Min**: *{"query": "min", "key": "KEY"}*
+- **Max**: *{"query": "max", "key": "KEY"}*
+
+- **Sort**: *{"query": "sort", "key": "KEY", "reverse": "REVERSE"}*
+
+## Slicing Queries
+
+- **Take**: *{"query": "take", "count": "COUNT"}*
+- **Skip**: *{"query": "skip", "count": "COUNT"}*
+- **Slice**: *{"query": "slice", "start": "START", "end": "END", "step": "STEP"}*
+
+## Conditions Queries
+
+- **AND**: *{"query": "and", "conditions": "CONDITIONS"}*
+- **OR**: *{"query": "or", "conditions": "CONDITIONS"}*
+
+- **==**: *{"query": "==", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **!=**: *{"query": "!=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **>**: *{"query": ">", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **<**: *{"query": "<", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **>=**: *{"query": ">=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **<=**: *{"query": "<=", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+
+- **in**: *{"query": "in", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **contains**: *{"query": "contains", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+- **has**: *{"query": "has", "value": "VALUE", "left": "LEFT", "right": "RIGHT"}*
+
+- **true**: *{"query": "true"}*
+- **false**: *{"query": "false"}*
+- **null**: *{"query": "null"}*
+- **empty**: *{"query": "empty"}*
+
+## Disclaimer
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

jqson-0.1.0/jqson/__init__.py

@@ -0,0 +1,15 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+version = (0, 1, 0)
+
+from .errors import QueryError, QuerySyntaxError, IterationError
+from .undefined import UNDEF
+from .query import Query
+from .variable import Variable
+from .path import Path
+from .getters import Attr, Item, Bool, Len
+from .conditions import Condition, AND, OR
+from .take import Take, Skip, Slice
+from .select import Select, Many, Sum, Mean
+from .where import Where, First, Last, Single, Distinct, Any, All, Noone, Count, Min, Max, Sort

jqson-0.1.0/jqson/conditions.py

@@ -0,0 +1,176 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+from dataclasses import dataclass
+from typing import Any
+from .errors import QuerySyntaxError
+from .undefined import UNDEF
+from .register import register
+from .query import Query
+from .path import Path
+
+
+@dataclass
+@register("=", "==", "!=", ">", "<", ">=", "<=")
+@register("in", "contains", "has")
+@register("is_true", "true", True, "is_false", "false", False)
+@register("is_null", "null", None, "not_null")
+@register("is_empty", "empty", "not_empty")
+class Condition(Query):
+    """Evaluates condition."""
+    
+    operand: str
+    left: Path | None = None
+    right: Path | None = None
+    value: Any = UNDEF
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get left value
+        left = data
+        if isinstance(self.left, Query):
+            left = self.left(data, *args, **kwargs)
+        
+        # get right value
+        right = self.value
+        if isinstance(self.right, Query):
+            right = self.right(data, *args, **kwargs)
+        
+        # equals
+        if self.operand in ("=", "=="):
+            return left == right
+        
+        # not equals
+        if self.operand == "!=":
+            return left != right
+        
+        # greater than
+        if self.operand == ">":
+            return left > right
+        
+        # less than
+        if self.operand == "<":
+            return left < right
+        
+        # greater than or equal
+        if self.operand == ">=":
+            return left >= right
+        
+        # less than or equal
+        if self.operand == "<=":
+            return left <= right
+        
+        # in
+        if self.operand == "in":
+            return left in right
+        
+        # contains
+        if self.operand == "contains":
+            return right in left
+        
+        # has
+        if self.operand == "has":
+            return hasattr(left, right)
+        
+        # is true
+        if self.operand in ("is_true", "true", True):
+            return bool(left)
+        
+        # is false
+        if self.operand in ("is_false", "false", False):
+            return not bool(left)
+        
+        # is null
+        if self.operand in ("is_null", "null", None):
+            return left is None
+        
+        # is not null
+        if self.operand == "not_null":
+            return left is not None
+        
+        # is empty
+        if self.operand in ("is_empty", "empty"):
+            return left is None or left == "" or left == [] or left == () or left == {}
+        
+        # is not empty
+        if self.operand == "not_empty":
+            return not (left is None or left == "" or left == [] or left == () or left == {})
+        
+        # unknown condition type
+        raise QuerySyntaxError(f"Unrecognized condition operand '{self.operand}'.")
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        left = data.get("left", None)
+        if left is not None:
+            left = Path.from_json(left)
+        
+        right = data.get("right", None)
+        if right is not None:
+            right = Path.from_json(right)
+        
+        return cls(
+            operand = data.get("query"),
+            left = left,
+            right = right,
+            value = data.get("value", UNDEF)
+        )
+
+
+@dataclass
+@register("AND", "and")
+class AND(Query):
+    """Evaluates sequence of conditions with AND."""
+    
+    conditions: list[Query] = ()
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        passed = True
+        for query in self.conditions:
+            passed = passed and query(data, *args, **kwargs)
+        
+        return passed
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls(
+            conditions = [Query.from_json(item) for item in data.get("conditions", [])]
+        )
+
+
+@dataclass
+@register("OR", "or")
+class OR(Query):
+    """Evaluates sequence of conditions with OR."""
+    
+    conditions: list[Query] = ()
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        for query in self.conditions:
+            if query(data, *args, **kwargs):
+                return True
+        
+        return False
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls(
+            conditions = [Query.from_json(item) for item in data.get("conditions", [])]
+        )

jqson-0.1.0/jqson/errors.py

@@ -0,0 +1,22 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+
+class QueryError(Exception):
+    """Represents a query exception base."""
+    pass
+
+
+class QuerySyntaxError(QueryError):
+    """Represents a missing definition exception."""
+    pass
+
+
+class UndefinedError(QueryError):
+    """Represents a missing definition exception."""
+    pass
+
+
+class IterationError(QueryError):
+    """Represents a selector exception."""
+    pass

jqson-0.1.0/jqson/getters.py

@@ -0,0 +1,114 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+from dataclasses import dataclass
+from .errors import UndefinedError
+from .register import register
+from .undefined import UNDEF
+from .query import Query
+
+
+@dataclass
+@register("property", "prop", "attr")
+class Attr(Query):
+    """Gets property by name."""
+    
+    name: str = UNDEF
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get variables
+        variables = kwargs.get("variables", {})
+        
+        # no name defined
+        if self.name is UNDEF:
+            raise UndefinedError("Attribute 'name' is not defined.")
+        
+        # get value
+        for part in self.name.split("."):
+            
+            # get from variables
+            if self.name in variables:
+                data = variables[self.name]
+            
+            # get from data
+            else:
+                data = getattr(data, part)
+        
+        return data
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls(
+            name = data.get("name")
+        )
+
+
+@dataclass
+@register("item")
+class Item(Query):
+    """Gets item by key."""
+    
+    key: str | int = UNDEF
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # no key defined
+        if self.key is UNDEF:
+            raise UndefinedError("Attribute 'key' is not defined.")
+        
+        return data[self.key]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls(
+            key = data.get("key")
+        )
+
+
+@dataclass
+@register("bool")
+class Bool(Query):
+    """Gets boolean value."""
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        return bool(data)
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls()
+
+
+@dataclass
+@register("len")
+class Len(Query):
+    """Gets sequence length."""
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        return len(data)
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON dict."""
+        
+        return cls()