jqon 0.1.0__tar.gz

jqon-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.

jqon-0.1.0/MANIFEST.in

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

jqon-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: jqon
+Version: 0.1.0
+Summary: JSON expression language for querying Python objects.
+Home-page: https://github.com/xxao/jqon
+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
+
+#  JqON
+
+The *jqon* package was developed to provide a simple way to define queries in JSON format, which can later be run
+in Python. It can be utilized in testing automations, where expected output of a system can be submitted a 
+predefined set of tests.
+
+
+## Installation
+
+This package is fully implemented in Python. No additional compiler is necessary. After downloading the source
+code just run the following command from the *jexon* folder:
+
+`$ python setup.py install`
+
+or simply by using pip
+
+`$ pip install jqson`
+
+
+## Requirements
+
+- [Python 3.11+](https://www.python.org)
+
+
+## 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.

jqon-0.1.0/README.md

@@ -0,0 +1,28 @@
+#  JqON
+
+The *jqon* package was developed to provide a simple way to define queries in JSON format, which can later be run
+in Python. It can be utilized in testing automations, where expected output of a system can be submitted a 
+predefined set of tests.
+
+
+## Installation
+
+This package is fully implemented in Python. No additional compiler is necessary. After downloading the source
+code just run the following command from the *jexon* folder:
+
+`$ python setup.py install`
+
+or simply by using pip
+
+`$ pip install jqson`
+
+
+## Requirements
+
+- [Python 3.11+](https://www.python.org)
+
+
+## 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.

jqon-0.1.0/jqon/__init__.py

@@ -0,0 +1,32 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+version = (0, 1, 0)
+
+from .errors import *
+from .register import register
+from .query import Query
+from .value import Value
+from .variable import Variable
+from .path import Path
+from .getters import Attr, Item
+from .unary import Unary
+from .binary import Binary
+from .logical import AND, OR, NOT
+from .funcs import Bool, Len, Any, All, Min, Max, Sum, Avg
+from .enumerable import Take, Skip, Slice
+from .enumerable import Select, Many, Where, Distinct
+from .enumerable import Single, First, Last, Count
+
+
+# init shortcuts
+def from_text(text):
+    """Initialize query from text."""
+    
+    return Query.from_text(text)
+
+
+def from_json(data):
+    """Initialize query from JSON."""
+    
+    return Query.from_json(data)

jqon-0.1.0/jqon/binary.py

@@ -0,0 +1,111 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+from dataclasses import dataclass
+from .errors import *
+from .register import register
+from .query import Query
+from .path import Path
+
+
+@dataclass
+@register("=", "==", "!=", ">", "<", ">=", "<=")
+@register("eq", "ne", "gt", "lt", "ge", "gte", "le", "lte")
+@register("in", "not_in", "contains")
+class Binary(Query):
+    """Evaluates binary condition to boolean."""
+    
+    operand: str
+    left: Path | None = None
+    right: Path | None = None
+    
+    
+    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 = data
+        if isinstance(self.right, Query):
+            right = self.right(data, *args, **kwargs)
+        
+        # equals
+        if self.operand in ("=", "==", "eq"):
+            return left == right
+        
+        # not equals
+        if self.operand in ("!=", "ne"):
+            return left != right
+        
+        # greater than
+        if self.operand in (">", "gt"):
+            return left > right
+        
+        # less than
+        if self.operand in ("<", "lt"):
+            return left < right
+        
+        # greater than or equal
+        if self.operand in (">=", "ge", "gte"):
+            return left >= right
+        
+        # less than or equal
+        if self.operand in ("<=", "le", "lte"):
+            return left <= right
+        
+        # in
+        if self.operand == "in":
+            return left in right
+        
+        # not in
+        if self.operand == "not_in":
+            return left not in right
+        
+        # contains
+        if self.operand == "contains":
+            return right in left
+        
+        # unknown operand
+        raise QSyntaxError(f"Unrecognized unary condition operand '{self.operand}'.")
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get values
+        operand = next(iter(data))
+        values = next(iter(data.values()))
+        
+        # convert single value
+        if not isinstance(values, list):
+            values = [values]
+        
+        # check values
+        if not isinstance(values, list) or len(values) not in (1, 2):
+            raise QSyntaxError("Binary condition requires one or two values.")
+        
+        # get values
+        if len(values) == 1:
+            left = None
+            right = values[0]
+        else:
+            left = values[0]
+            right = values[1]
+        
+        # convert paths
+        if left is not None:
+            left = Path.from_json(left)
+        if right is not None:
+            right = Path.from_json(right)
+        
+        # init instance
+        return cls(
+            operand = operand,
+            left = left,
+            right = right
+        )

jqon-0.1.0/jqon/enumerable.py

@@ -0,0 +1,416 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+from dataclasses import dataclass
+from .errors import *
+from .register import register
+from .query import Query
+from .path import Path
+
+
+@dataclass
+@register("take")
+class Take(Query):
+    """Takes number of items from sequence."""
+    
+    count: int | Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get count
+        count = self.count
+        if isinstance(self.count, Query):
+            count = self.count(data, *args, **kwargs)
+        
+        # get slice
+        return data[:count]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        count = next(iter(data.values()))
+        
+        # convert to path
+        if not isinstance(count, (int, type(None))):
+            count = Path.from_json(count)
+        
+        # init instance
+        return cls(
+            count = count
+        )
+
+
+@dataclass
+@register("skip")
+class Skip(Query):
+    """Skips number of items from sequence."""
+    
+    count: int | Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get count
+        count = self.count
+        if isinstance(self.count, Query):
+            count = self.count(data, *args, **kwargs)
+        
+        # get slice
+        return data[count:]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        count = next(iter(data.values()))
+        
+        # convert to path
+        if not isinstance(count, (int, type(None))):
+            count = Path.from_json(count)
+        
+        # init instance
+        return cls(
+            count = count
+        )
+
+
+@dataclass
+@register("slice")
+class Slice(Query):
+    """Takes slice of items from sequence."""
+    
+    start: int | Path | None = None
+    end: int | Path | None = None
+    step: int | Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get start
+        start = self.start
+        if isinstance(self.start, Query):
+            start = self.start(data, *args, **kwargs)
+        
+        # get end
+        end = self.end
+        if isinstance(self.end, Query):
+            end = self.end(data, *args, **kwargs)
+        
+        # get step
+        step = self.step
+        if isinstance(self.step, Query):
+            step = self.step(data, *args, **kwargs)
+        
+        # get slice
+        return data[start:end:step]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get values
+        values = next(iter(data.values()))
+        
+        # check empty
+        if values is None:
+            return cls()
+        
+        # check values
+        if not isinstance(values, list) or len(values) > 3:
+            raise QSyntaxError("Slice definition must be a list of one, two or three values.")
+        
+        # get values
+        start = values[0]
+        end = values[1] if len(values) > 1 else None
+        step = values[2] if len(values) > 2 else None
+        
+        # convert to paths
+        if not isinstance(start, (int, type(None))):
+            start = Path.from_json(start)
+        if not isinstance(end, (int, type(None))):
+            end = Path.from_json(end)
+        if not isinstance(step, (int, type(None))):
+            step = Path.from_json(step)
+        
+        # init instance
+        return cls(
+            start = start,
+            end = end,
+            step = step
+        )
+
+
+@dataclass
+@register("select")
+class Select(Query):
+    """Selects value from every item in sequence."""
+    
+    path: Path
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # select values
+        return [self.path(item, *args, **kwargs) for item in data]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get values
+        value = next(iter(data.values()))
+        
+        # convert to path
+        if value is not None:
+            value = Path.from_json(value)
+        
+        # init instance
+        return cls(
+            path = value
+        )
+
+
+@dataclass
+@register("many")
+class Many(Query):
+    """Flattens value from every item in sequence."""
+    
+    path: Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get values
+        if isinstance(self.path, Query):
+            data = (self.path(item, *args, **kwargs) for item in data)
+        
+        # flatten lists
+        return [item for chain in data for item in chain]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get values
+        value = next(iter(data.values()))
+        
+        # convert to path
+        if value is not None:
+            value = Path.from_json(value)
+        
+        # init instance
+        return cls(
+            path = value
+        )
+
+
+@dataclass
+@register("where")
+class Where(Query):
+    """Gets items from sequence where condition met."""
+    
+    path: Path
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # filter items
+        return [item for item in data if self.path(item, *args, **kwargs)]
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        value = next(iter(data.values()))
+        
+        # init instance
+        return cls(
+            path = Path.from_json(value)
+        )
+
+
+@dataclass
+@register("distinct")
+class Distinct(Query):
+    """Gets distinct items from sequence."""
+    
+    path: Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # check selector
+        if not isinstance(self.path, Query):
+            return list(set(data))
+        
+        # find distinct
+        seen = set()
+        items = []
+        for item in data:
+            key = self.path(item, *args, **kwargs)
+            if key not in seen:
+                seen.add(key)
+                items.append(item)
+        
+        return items
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        value = next(iter(data.values()))
+        
+        # convert to path
+        if value is not None:
+            value = Path.from_json(value)
+        
+        # init instance
+        return cls(
+            path = value
+        )
+
+
+@dataclass
+@register("single")
+class Single(Query):
+    """Gets the single item from sequence where condition met."""
+    
+    path: Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get data
+        if isinstance(self.path, Query):
+            data = (item for item in data if self.path(item, *args, **kwargs))
+        
+        # use single
+        i = -1
+        item = None
+        for i, item in enumerate(data):
+            if i > 0:
+                raise QIterError("More then one item found.")
+        
+        # found
+        if i == 0:
+            return item
+        
+        # no item found
+        raise QIterError("No item found.")
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        value = next(iter(data.values()))
+        
+        # convert to path
+        if value is not None:
+            value = Path.from_json(value)
+        
+        # init instance
+        return cls(
+            path = value
+        )
+
+
+@dataclass
+@register("first")
+class First(Single):
+    """Gets the first item from sequence where condition met."""
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get data
+        if isinstance(self.path, Query):
+            data = (item for item in data if self.path(item, *args, **kwargs))
+        
+        # use first
+        for item in data:
+            return item
+        
+        # no item found
+        raise QIterError("No item found.")
+
+
+@dataclass
+@register("last")
+class Last(Single):
+    """Gets the last item from sequence where condition met."""
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # get data
+        data = reversed(data)
+        if isinstance(self.path, Query):
+            data = (item for item in data if self.path(item, *args, **kwargs))
+        
+        # use first
+        for item in data:
+            return item
+        
+        # no item found
+        raise QIterError("No item found.")
+
+
+@dataclass
+@register("count")
+class Count(Query):
+    """Gets count of items in sequence where condition met."""
+    
+    path: Path | None = None
+    
+    
+    def apply(self, data, *args, **kwargs):
+        """Applies query to data."""
+        
+        # check selector
+        if not isinstance(self.path, Query):
+            return len(data)
+        
+        # count true
+        return sum(1 for item in data if self.path(item, *args, **kwargs))
+    
+    
+    @classmethod
+    def from_json(cls, data):
+        """Initialize instance from JSON."""
+        
+        # get value
+        value = next(iter(data.values()))
+        
+        # convert to path
+        if value is not None:
+            value = Path.from_json(value)
+        
+        # init instance
+        return cls(
+            path = value
+        )

jqon-0.1.0/jqon/errors.py

@@ -0,0 +1,22 @@
+# Created byMartin.cz
+# Copyright (c) Martin Strohalm. All rights reserved.
+
+
+class QError(Exception):
+    """Represents a jqson exception base."""
+    pass
+
+
+class QSyntaxError(QError):
+    """Represents an incorrect syntax exception."""
+    pass
+
+
+class QUndefError(QError):
+    """Represents a missing definition exception."""
+    pass
+
+
+class QIterError(QError):
+    """Represents an iteration exception."""
+    pass