pyspecification 1.0.0__tar.gz → 2.0.0__tar.gz

{pyspecification-1.0.0 → pyspecification-2.0.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.3
 Name: pyspecification
-Version: 1.0.0
+Version: 2.0.0
 Summary: A lightweight, typed Python library for composing business rules as reusable, executable predicates.
 Author: aaltatan
 Author-email: aaltatan <a.altatan@gmail.com>
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
-Requires-Dist: pydantic==2.5.3
 Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/aaltatan/pyspecification
 Project-URL: Issues, https://github.com/aaltatan/pyspecification/issues
@@ -25,7 +24,7 @@ This project was inspired by the work and ideas shared by [ArjanCodes](https://g
 - predicates compose with `&`, `|`, and `~`
 - registry-based registration keeps rules organized
 - structured rule definitions can be compiled from dictionaries or JSON-like payloads
-- generated schemas make rule metadata portable and machine-readable
+- structured rule definitions make rule metadata portable and machine-readable
 
 It is especially useful for filtering, validation, authorization checks, and declarative rule engines without introducing a heavy framework.
 
@@ -68,7 +67,6 @@ This keeps your logic:
 - Registry pattern for rule registration and lookup
 - Custom argument processors for coercion and normalization
 - `PredicateCompiler` for compiling structured rule dictionaries into executable predicates
-- `RuleSchema` validation for declarative rule payloads
 - JSON schema generation for rule arguments and return types
 - Support for both logical and bitwise operator modes
 - Hidden rules and custom naming for internal/private rule registration
@@ -251,7 +249,7 @@ One of the strongest real-world use cases is turning rule definitions into SQLAl
 ```python
 from typing import Any
 
-from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 from sqlalchemy import ColumnElement, and_, create_engine, or_
 from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column, sessionmaker
 
@@ -336,11 +334,13 @@ filter_rule_data = {
     ],
 }
 
-predicate = compiler.compile(RuleSchema(**filter_rule_data).model_dump())
+predicate = compiler.compile(filter_rule_data)
+# is_admin() | age__ge(18)
+# User.is_admin | User.age >= 18
 
 with SessionLocal() as session:
     users = session.query(User).filter(predicate(User)).all()
-    print([user.name for user in users])
+    print([user.name for user in users])  # ['Abdullah', 'Bob', 'Charlie', 'Eve']
 ```
 
 This pattern is especially useful when you want:
@@ -407,7 +407,7 @@ If conversion fails, the library raises `ProcessArgumentError`.
 ```python
 from dataclasses import dataclass
 
-from pyspecification import Predicate, PredicateCompiler, RuleSchema, object_rule
+from pyspecification import Predicate, PredicateCompiler, object_rule
 
 
 @dataclass
@@ -462,7 +462,7 @@ rule_data = {
                     "inverse": False,
                 },
                 {
-                    "name": "rule_not_exists", 
+                    "name": "age__between", 
                     "args": [18, 30], 
                     "kwargs": {}, 
                     "inverse": False,
@@ -472,67 +472,16 @@ rule_data = {
     ],
 }
 
-predicate = compiler.compile(RuleSchema(**rule_data).model_dump())
-print(predicate(User("admin", 25, True)))  # True
-```
-
-### Predicate schema
-
-`PredicateCompiler.compile()` consumes the normalized dictionary produced by
-`RuleSchema(...).model_dump()`. A predicate schema always has four keys:
-
-```json
-{
-    "name": "<rule_name>",
-    "args": [],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-The `name` must be present in the dictionary of rules passed to the compiler.
-Use `args` for positional arguments and `kwargs` for keyword arguments. These
-examples assume the rules from the previous section:
-
-```json
-{
-    "name": "is_admin",
-    "args": [],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-```json
-{
-    "name": "name__istartswith",
-    "args": ["admin"],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-```json
-{
-    "name": "age__between",
-    "args": [],
-    "kwargs": {"min_age": 18, "max_age": 30},
-    "inverse": false
-}
-```
-
-Set `inverse` to `true` to negate one predicate:
+predicate = compiler.compile(rule_data)
+# is_admin() | (name__istartswith("admin") & age__between(18, 30))
 
-```json
-{
-    "name": "is_admin",
-    "args": [],
-    "kwargs": {},
-    "inverse": true
-}
+print(predicate(User("admin", 25, True)))  # True
 ```
 
-The normalized schema is convenient when rule definitions arrive as JSON:
+`PredicateCompiler.compile()` consumes a normalized dictionary. The `name`
+must be present in the dictionary of rules passed to the compiler. Use `args`
+for positional arguments, `kwargs` for keyword arguments, and `inverse` to
+negate one predicate:
 
 ```python
 import json
@@ -540,12 +489,12 @@ import json
 rule_json = '{"name": "age__between", "args": [18, 30], "kwargs": {}, "inverse": false}'
 rule_data = json.loads(rule_json)
 predicate = compiler.compile(rule_data)
-```
 
-### Expression wrapper schema
+print(repr(predicate))  # Predicate(age__between)
+```
 
-Use a wrapper to combine predicates. A wrapper has an `operator`, an
-`expressions` list, and an `inverse` flag:
+Use a wrapper to combine predicates. A wrapper has an `operator` and an
+`expressions` list:
 
 ```json
 {
@@ -563,9 +512,8 @@ Use a wrapper to combine predicates. A wrapper has an `operator`, an
             "kwargs": {},
             "inverse": false
         }
-    ],
-    "inverse": false
-}
+    ]
+} // is_admin() & age__between(18, 30)
 ```
 
 `operator` must be either `"all"` or `"any"`. Expressions can be nested to
@@ -596,88 +544,27 @@ represent more complex logic:
                     "kwargs": {"min_age": 18, "max_age": 30},
                     "inverse": false
                 }
-            ],
-            "inverse": false
-        }
-    ],
-    "inverse": false
-}
-```
-
-You can also invert a complete wrapper:
-
-```json
-{
-    "operator": "any",
-    "expressions": [
-        {
-            "name": "is_admin",
-            "args": [],
-            "kwargs": {},
-            "inverse": false
-        },
-        {
-            "name": "age__between",
-            "args": [18, 30],
-            "kwargs": {},
-            "inverse": false
+            ]
         }
-    ],
-    "inverse": true
-}
+    ]
+} // is_admin() | (name__istartswith("admin") & age__between(min_age=18, max_age=30))
 ```
 
 The compiler raises `RuleDoesNotExistError` when a predicate name is not in the
 compiler's rule mapping. If the dictionary passed directly to `compile()` does
-not match a predicate or wrapper schema, it raises `TypeError`. The error
-includes the location of the invalid expression, the expected schemas, and the
-received value. Validate external payloads with `RuleSchema` before compilation.
+not match a predicate or wrapper shape, it raises `TypeError`.
 
 ---
-
-## Rule schema validation
-
-`RuleSchema` validates declarative rule payloads.
-
-```python
-from pyspecification import RuleSchema
-
-rule_data = {
-    "operator": "all",
-    "expressions": [
-        {
-            "name": "name__startswith",
-            "args": ["admin"],
-            "kwargs": {},
-            "inverse": False,
-        },
-        {
-            "name": "age__gt",
-            "args": [18],
-            "kwargs": {},
-            "inverse": False,
-        }
-    ],
-}
-
-schema = RuleSchema(**rule_data)
-print(schema.model_dump())
-```
-
-This is useful when you want to validate incoming rule definitions before compile-time execution.
-
-You can also use `RuleSchema` to represent nested predicate trees as typed, portable data.
-
 ---
 
 ## JSON schema generation
 
-`get_json_schema` inspects a rule function and returns JSON-schema-like metadata for parameters and return value.
+`get_rule_json_schema` inspects a rule function and returns JSON-schema-like metadata for parameters and return value.
 
 ```python
 from dataclasses import dataclass
 
-from pyspecification import get_json_schema, object_rule
+from pyspecification import get_rule_json_schema, object_rule
 
 
 @dataclass
@@ -692,11 +579,8 @@ def name__istartswith(user: User, value: str) -> bool:
     return user.name.lower().startswith(value.lower())
 
 
-print(get_json_schema(name__istartswith))
-# {
-#   "value": {"type": "string"},
-#   "return": {"type": "boolean"},
-# }
+print(get_rule_json_schema(name__istartswith))
+# {'value': {'type': 'string'}, 'return': {'type': 'boolean'}}
 ```
 
 This is useful for:
@@ -755,7 +639,7 @@ filtered = [user for user in users if predicate(user)]
 This is one of the most useful real-world patterns for the package. You can define a reusable rule set and compile it into SQLAlchemy boolean expressions for database queries.
 
 ```python
-from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 from sqlalchemy import ColumnElement, and_, or_
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
@@ -812,7 +696,9 @@ filter_rule = {
     ],
 }
 
-query_predicate = compiler.compile(RuleSchema(**filter_rule).model_dump())
+query_predicate = compiler.compile(filter_rule)
+# is_admin() | age__ge(18)
+# User.is_admin | User.age >= 18
 ```
 
 This makes it easy to expose admin filters, user search rules, and role-based queries without manually stitching SQL conditions together.
@@ -829,7 +715,7 @@ This allows readable authorization checks without large condition trees.
 
 ### 3. Dynamic rule engines
 
-The compiler and schema APIs make it easy to store or receive rules as structured data.
+The compiler makes it easy to store or receive rules as structured data.
 
 Examples:
 
@@ -870,10 +756,6 @@ Rules should do one thing and avoid hidden side effects.
 
 If your project has many rules, registries provide structure and reduce duplication.
 
-### Validate schema before compile
-
-If you load rules from external sources, validate them via `RuleSchema` before compiling.
-
 ---
 
 ## Exceptions
@@ -904,7 +786,7 @@ rule. Its specialized exceptions describe the problem:
 `RuleDoesNotExistError` includes the missing name and the available rule names,
 which is useful when rules are dynamically loaded. Malformed normalized
 compiler payloads raise `TypeError`; its message identifies the JSON-like path
-of the invalid expression and shows the expected schemas.
+of the invalid expression and shows the expected shapes.
 
 ---
 
@@ -914,14 +796,13 @@ This project includes runnable examples under the `scripts/` directory:
 
 - `scripts/rules_example.py` — basic object-based rule composition
 - `scripts/reg_example.py` — registry usage and compiled rule predicate patterns
-- `scripts/json_schema_example.py` — JSON schema generation examples
 
 The test suite under `tests/` also demonstrates behavior for:
 
 - registry registration
 - predicate composition
 - compiler validation
-- schema serialization
+- structured rule compilation
 - filtering workflows
 
 ---
@@ -931,7 +812,7 @@ The test suite under `tests/` also demonstrates behavior for:
 ```python
 from dataclasses import dataclass
 
-from pyspecification import ObjectRulesRegistry, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 
 
 @dataclass
@@ -988,9 +869,9 @@ rule_definition = {
     ],
 }
 
-schema = RuleSchema(**rule_definition)
 compiler = PredicateCompiler(registry.rules, lambda spec: Predicate(lambda _: True, operator="logical"))
-predicate = compiler.compile(schema.model_dump())
+predicate = compiler.compile(rule_definition)
+# is_admin() | (name__istartswith("admin") & age__between(18, 30))
 
 users = [
     User("Abdullah", 18, True),
@@ -998,20 +879,20 @@ users = [
     User("Charlie", 12, False),
 ]
 
-print([predicate(user) for user in users])
+print([predicate(user) for user in users])  # [True, True, False]
 ```
 
 ---
 
 ## Summary
 
-`pyspecification` brings together rule registration, predicate composition, schema validation, and runtime compilation in a compact library designed around functional and declarative rule authoring.
+`pyspecification` brings together rule registration, predicate composition, and runtime compilation in a compact library designed around functional and declarative rule authoring.
 
 It is a practical fit for projects that need to:
 
 - express business rules clearly
 - compose conditions without nested `if` chains
-- validate dynamic rule payloads
+- compile dynamic rule payloads
 - support filtering and policy evaluation
 - keep rule logic easy to test and maintain
 

{pyspecification-1.0.0 → pyspecification-2.0.0}/README.md

@@ -10,7 +10,7 @@ This project was inspired by the work and ideas shared by [ArjanCodes](https://g
 - predicates compose with `&`, `|`, and `~`
 - registry-based registration keeps rules organized
 - structured rule definitions can be compiled from dictionaries or JSON-like payloads
-- generated schemas make rule metadata portable and machine-readable
+- structured rule definitions make rule metadata portable and machine-readable
 
 It is especially useful for filtering, validation, authorization checks, and declarative rule engines without introducing a heavy framework.
 
@@ -53,7 +53,6 @@ This keeps your logic:
 - Registry pattern for rule registration and lookup
 - Custom argument processors for coercion and normalization
 - `PredicateCompiler` for compiling structured rule dictionaries into executable predicates
-- `RuleSchema` validation for declarative rule payloads
 - JSON schema generation for rule arguments and return types
 - Support for both logical and bitwise operator modes
 - Hidden rules and custom naming for internal/private rule registration
@@ -236,7 +235,7 @@ One of the strongest real-world use cases is turning rule definitions into SQLAl
 ```python
 from typing import Any
 
-from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 from sqlalchemy import ColumnElement, and_, create_engine, or_
 from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column, sessionmaker
 
@@ -321,11 +320,13 @@ filter_rule_data = {
     ],
 }
 
-predicate = compiler.compile(RuleSchema(**filter_rule_data).model_dump())
+predicate = compiler.compile(filter_rule_data)
+# is_admin() | age__ge(18)
+# User.is_admin | User.age >= 18
 
 with SessionLocal() as session:
     users = session.query(User).filter(predicate(User)).all()
-    print([user.name for user in users])
+    print([user.name for user in users])  # ['Abdullah', 'Bob', 'Charlie', 'Eve']
 ```
 
 This pattern is especially useful when you want:
@@ -392,7 +393,7 @@ If conversion fails, the library raises `ProcessArgumentError`.
 ```python
 from dataclasses import dataclass
 
-from pyspecification import Predicate, PredicateCompiler, RuleSchema, object_rule
+from pyspecification import Predicate, PredicateCompiler, object_rule
 
 
 @dataclass
@@ -447,7 +448,7 @@ rule_data = {
                     "inverse": False,
                 },
                 {
-                    "name": "rule_not_exists", 
+                    "name": "age__between", 
                     "args": [18, 30], 
                     "kwargs": {}, 
                     "inverse": False,
@@ -457,67 +458,16 @@ rule_data = {
     ],
 }
 
-predicate = compiler.compile(RuleSchema(**rule_data).model_dump())
-print(predicate(User("admin", 25, True)))  # True
-```
-
-### Predicate schema
-
-`PredicateCompiler.compile()` consumes the normalized dictionary produced by
-`RuleSchema(...).model_dump()`. A predicate schema always has four keys:
-
-```json
-{
-    "name": "<rule_name>",
-    "args": [],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-The `name` must be present in the dictionary of rules passed to the compiler.
-Use `args` for positional arguments and `kwargs` for keyword arguments. These
-examples assume the rules from the previous section:
-
-```json
-{
-    "name": "is_admin",
-    "args": [],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-```json
-{
-    "name": "name__istartswith",
-    "args": ["admin"],
-    "kwargs": {},
-    "inverse": false
-}
-```
-
-```json
-{
-    "name": "age__between",
-    "args": [],
-    "kwargs": {"min_age": 18, "max_age": 30},
-    "inverse": false
-}
-```
-
-Set `inverse` to `true` to negate one predicate:
+predicate = compiler.compile(rule_data)
+# is_admin() | (name__istartswith("admin") & age__between(18, 30))
 
-```json
-{
-    "name": "is_admin",
-    "args": [],
-    "kwargs": {},
-    "inverse": true
-}
+print(predicate(User("admin", 25, True)))  # True
 ```
 
-The normalized schema is convenient when rule definitions arrive as JSON:
+`PredicateCompiler.compile()` consumes a normalized dictionary. The `name`
+must be present in the dictionary of rules passed to the compiler. Use `args`
+for positional arguments, `kwargs` for keyword arguments, and `inverse` to
+negate one predicate:
 
 ```python
 import json
@@ -525,12 +475,12 @@ import json
 rule_json = '{"name": "age__between", "args": [18, 30], "kwargs": {}, "inverse": false}'
 rule_data = json.loads(rule_json)
 predicate = compiler.compile(rule_data)
-```
 
-### Expression wrapper schema
+print(repr(predicate))  # Predicate(age__between)
+```
 
-Use a wrapper to combine predicates. A wrapper has an `operator`, an
-`expressions` list, and an `inverse` flag:
+Use a wrapper to combine predicates. A wrapper has an `operator` and an
+`expressions` list:
 
 ```json
 {
@@ -548,9 +498,8 @@ Use a wrapper to combine predicates. A wrapper has an `operator`, an
             "kwargs": {},
             "inverse": false
         }
-    ],
-    "inverse": false
-}
+    ]
+} // is_admin() & age__between(18, 30)
 ```
 
 `operator` must be either `"all"` or `"any"`. Expressions can be nested to
@@ -581,88 +530,27 @@ represent more complex logic:
                     "kwargs": {"min_age": 18, "max_age": 30},
                     "inverse": false
                 }
-            ],
-            "inverse": false
-        }
-    ],
-    "inverse": false
-}
-```
-
-You can also invert a complete wrapper:
-
-```json
-{
-    "operator": "any",
-    "expressions": [
-        {
-            "name": "is_admin",
-            "args": [],
-            "kwargs": {},
-            "inverse": false
-        },
-        {
-            "name": "age__between",
-            "args": [18, 30],
-            "kwargs": {},
-            "inverse": false
+            ]
         }
-    ],
-    "inverse": true
-}
+    ]
+} // is_admin() | (name__istartswith("admin") & age__between(min_age=18, max_age=30))
 ```
 
 The compiler raises `RuleDoesNotExistError` when a predicate name is not in the
 compiler's rule mapping. If the dictionary passed directly to `compile()` does
-not match a predicate or wrapper schema, it raises `TypeError`. The error
-includes the location of the invalid expression, the expected schemas, and the
-received value. Validate external payloads with `RuleSchema` before compilation.
+not match a predicate or wrapper shape, it raises `TypeError`.
 
 ---
-
-## Rule schema validation
-
-`RuleSchema` validates declarative rule payloads.
-
-```python
-from pyspecification import RuleSchema
-
-rule_data = {
-    "operator": "all",
-    "expressions": [
-        {
-            "name": "name__startswith",
-            "args": ["admin"],
-            "kwargs": {},
-            "inverse": False,
-        },
-        {
-            "name": "age__gt",
-            "args": [18],
-            "kwargs": {},
-            "inverse": False,
-        }
-    ],
-}
-
-schema = RuleSchema(**rule_data)
-print(schema.model_dump())
-```
-
-This is useful when you want to validate incoming rule definitions before compile-time execution.
-
-You can also use `RuleSchema` to represent nested predicate trees as typed, portable data.
-
 ---
 
 ## JSON schema generation
 
-`get_json_schema` inspects a rule function and returns JSON-schema-like metadata for parameters and return value.
+`get_rule_json_schema` inspects a rule function and returns JSON-schema-like metadata for parameters and return value.
 
 ```python
 from dataclasses import dataclass
 
-from pyspecification import get_json_schema, object_rule
+from pyspecification import get_rule_json_schema, object_rule
 
 
 @dataclass
@@ -677,11 +565,8 @@ def name__istartswith(user: User, value: str) -> bool:
     return user.name.lower().startswith(value.lower())
 
 
-print(get_json_schema(name__istartswith))
-# {
-#   "value": {"type": "string"},
-#   "return": {"type": "boolean"},
-# }
+print(get_rule_json_schema(name__istartswith))
+# {'value': {'type': 'string'}, 'return': {'type': 'boolean'}}
 ```
 
 This is useful for:
@@ -740,7 +625,7 @@ filtered = [user for user in users if predicate(user)]
 This is one of the most useful real-world patterns for the package. You can define a reusable rule set and compile it into SQLAlchemy boolean expressions for database queries.
 
 ```python
-from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 from sqlalchemy import ColumnElement, and_, or_
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
@@ -797,7 +682,9 @@ filter_rule = {
     ],
 }
 
-query_predicate = compiler.compile(RuleSchema(**filter_rule).model_dump())
+query_predicate = compiler.compile(filter_rule)
+# is_admin() | age__ge(18)
+# User.is_admin | User.age >= 18
 ```
 
 This makes it easy to expose admin filters, user search rules, and role-based queries without manually stitching SQL conditions together.
@@ -814,7 +701,7 @@ This allows readable authorization checks without large condition trees.
 
 ### 3. Dynamic rule engines
 
-The compiler and schema APIs make it easy to store or receive rules as structured data.
+The compiler makes it easy to store or receive rules as structured data.
 
 Examples:
 
@@ -855,10 +742,6 @@ Rules should do one thing and avoid hidden side effects.
 
 If your project has many rules, registries provide structure and reduce duplication.
 
-### Validate schema before compile
-
-If you load rules from external sources, validate them via `RuleSchema` before compiling.
-
 ---
 
 ## Exceptions
@@ -889,7 +772,7 @@ rule. Its specialized exceptions describe the problem:
 `RuleDoesNotExistError` includes the missing name and the available rule names,
 which is useful when rules are dynamically loaded. Malformed normalized
 compiler payloads raise `TypeError`; its message identifies the JSON-like path
-of the invalid expression and shows the expected schemas.
+of the invalid expression and shows the expected shapes.
 
 ---
 
@@ -899,14 +782,13 @@ This project includes runnable examples under the `scripts/` directory:
 
 - `scripts/rules_example.py` — basic object-based rule composition
 - `scripts/reg_example.py` — registry usage and compiled rule predicate patterns
-- `scripts/json_schema_example.py` — JSON schema generation examples
 
 The test suite under `tests/` also demonstrates behavior for:
 
 - registry registration
 - predicate composition
 - compiler validation
-- schema serialization
+- structured rule compilation
 - filtering workflows
 
 ---
@@ -916,7 +798,7 @@ The test suite under `tests/` also demonstrates behavior for:
 ```python
 from dataclasses import dataclass
 
-from pyspecification import ObjectRulesRegistry, PredicateCompiler, RuleSchema
+from pyspecification import ObjectRulesRegistry, Predicate, PredicateCompiler
 
 
 @dataclass
@@ -973,9 +855,9 @@ rule_definition = {
     ],
 }
 
-schema = RuleSchema(**rule_definition)
 compiler = PredicateCompiler(registry.rules, lambda spec: Predicate(lambda _: True, operator="logical"))
-predicate = compiler.compile(schema.model_dump())
+predicate = compiler.compile(rule_definition)
+# is_admin() | (name__istartswith("admin") & age__between(18, 30))
 
 users = [
     User("Abdullah", 18, True),
@@ -983,20 +865,20 @@ users = [
     User("Charlie", 12, False),
 ]
 
-print([predicate(user) for user in users])
+print([predicate(user) for user in users])  # [True, True, False]
 ```
 
 ---
 
 ## Summary
 
-`pyspecification` brings together rule registration, predicate composition, schema validation, and runtime compilation in a compact library designed around functional and declarative rule authoring.
+`pyspecification` brings together rule registration, predicate composition, and runtime compilation in a compact library designed around functional and declarative rule authoring.
 
 It is a practical fit for projects that need to:
 
 - express business rules clearly
 - compose conditions without nested `if` chains
-- validate dynamic rule payloads
+- compile dynamic rule payloads
 - support filtering and policy evaluation
 - keep rule logic easy to test and maintain
 

{pyspecification-1.0.0 → pyspecification-2.0.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "pyspecification"
-version = "1.0.0"
+version = "2.0.0"
 description = "A lightweight, typed Python library for composing business rules as reusable, executable predicates."
 readme = "README.md"
 requires-python = ">=3.12"
-dependencies = ["pydantic==2.5.3"]
+dependencies = []
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",

{pyspecification-1.0.0 → pyspecification-2.0.0}/pyproject.toml.orig

@@ -1,11 +1,11 @@
 [project]
 name = "pyspecification"
-version = "1.0.0"
+version = "2.0.0"
 description = "A lightweight, typed Python library for composing business rules as reusable, executable predicates."
 readme = "README.md"
 authors = [{ name = "aaltatan", email = "a.altatan@gmail.com" }]
 requires-python = ">=3.12"
-dependencies = ["pydantic==2.5.3"]
+dependencies = []
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",

{pyspecification-1.0.0 → pyspecification-2.0.0}/src/pyspecification/__init__.py

@@ -16,11 +16,10 @@ from .exceptions import (
     TooManyArgumentsError,
     UnexpectedKeywordArgumentError,
 )
-from .json_schema import get_json_schema
+from .json_schema import get_rule_json_schema
 from .predicate import OperatorType, Predicate
 from .registry import ObjectRulesRegistry, SubscriptableRulesRegistry
 from .rules import object_rule, subscriptable_rule
-from .schemas import RuleSchema
 
 __all__ = [
     "ArgumentError",
@@ -36,11 +35,10 @@ __all__ = [
     "RuleAlreadyRegisteredError",
     "RuleDoesNotExistError",
     "RuleKeyDoesNotExistError",
-    "RuleSchema",
     "SubscriptableRulesRegistry",
     "TooManyArgumentsError",
     "UnexpectedKeywordArgumentError",
-    "get_json_schema",
+    "get_rule_json_schema",
     "object_rule",
     "subscriptable_rule",
 ]

{pyspecification-1.0.0 → pyspecification-2.0.0}/src/pyspecification/compilers.py

@@ -3,16 +3,15 @@ from collections.abc import Callable
 from pprint import pformat
 from typing import Any, Literal, TypedDict, TypeGuard
 
-from pydantic import TypeAdapter
-
 from .exceptions import MissingArgumentError, RuleDoesNotExistError, is_missing_argument_exception
+from .json_schema import get_json_schema
 from .predicate import Predicate, ReturnType
 
 type ExpressionDict = ExpressionWrapperDict | PredicateDict
 
 
 PREDICATE_DICT_KEYS = {"name", "args", "kwargs", "inverse"}
-EXPRESSION_WRAPPER_DICT_KEYS = {"operator", "expressions", "inverse"}
+EXPRESSION_WRAPPER_DICT_KEYS = {"operator", "expressions"}
 
 
 class PredicateDict(TypedDict):
@@ -29,7 +28,6 @@ class ExpressionWrapperDict(TypedDict):
 
     operator: Literal["all", "any"]
     expressions: list["ExpressionWrapperDict | PredicateDict"]
-    inverse: bool
 
 
 def is_predicate_dict(d: Any) -> TypeGuard[PredicateDict]:
@@ -40,9 +38,7 @@ def is_predicate_dict(d: Any) -> TypeGuard[PredicateDict]:
     )
 
 
-def is_expression_wrapper_dict(
-    d: Any,
-) -> TypeGuard[ExpressionWrapperDict]:
+def is_expression_wrapper_dict(d: Any) -> TypeGuard[ExpressionWrapperDict]:
     return (
         isinstance(d, dict)
         and all(key in d for key in EXPRESSION_WRAPPER_DICT_KEYS)
@@ -89,7 +85,6 @@ class PredicateCompiler[T, R: ReturnType]:
 
         rule_data = {
             "operator": "any",
-            "inverse": False,
             "expressions": [
                 {
                     "name": "is_admin",
@@ -99,7 +94,6 @@ class PredicateCompiler[T, R: ReturnType]:
                 },
                 {
                     "operator": "all",
-                    "inverse": False,
                     "expressions": [
                         {
                             "name": "name__istartswith",
@@ -120,7 +114,8 @@ class PredicateCompiler[T, R: ReturnType]:
 
         rule = compiler.compile(rule_data)
 
-        assert all(rule(user) for user in users)
+        print(rule(User("admin", 25, True)))  # True
+        assert rule(User("admin", 25, True))
 
 
     if __name__ == "__main__":
@@ -177,9 +172,6 @@ class PredicateCompiler[T, R: ReturnType]:
             else:
                 predicate |= compiled_predicate
 
-        if wrapper["inverse"]:
-            predicate = ~predicate
-
         return predicate
 
 
@@ -190,10 +182,10 @@ def _invalid_expression_message(expression: Any, path: str) -> str:
             "Expected an expression matching one of these schemas:",
             "",
             "Predicate:",
-            json.dumps(TypeAdapter(PredicateDict).json_schema(), indent=2),
+            json.dumps(get_json_schema(PredicateDict), indent=2),
             "",
             "Expression wrapper:",
-            json.dumps(TypeAdapter(ExpressionWrapperDict).json_schema(), indent=2),
+            json.dumps(get_json_schema(ExpressionWrapperDict), indent=2),
             "",
             "Received:",
             pformat(expression, sort_dicts=False, width=88),

pyspecification-2.0.0/src/pyspecification/json_schema.py

@@ -0,0 +1,116 @@
+from collections.abc import Callable
+from datetime import date, datetime, time
+from inspect import get_annotations, signature
+from types import UnionType
+from typing import Any, Literal, Union, get_args, get_origin, is_typeddict
+from uuid import UUID
+
+
+def get_json_schema(annotation: Any) -> dict[str, Any]:
+    if is_typeddict(annotation):
+        annotations = get_annotations(annotation)
+        return {
+            "type": "object",
+            "properties": {name: get_json_schema(typ) for name, typ in annotations.items()},
+            "required": [name for name in annotations if name in annotation.__required_keys__],
+        }
+
+    origin = get_origin(annotation)
+
+    if origin is Literal:
+        values = list(get_args(annotation))
+        schema: dict[str, Any] = {"enum": values}
+        if values and all(isinstance(value, str) for value in values):
+            schema["type"] = "string"
+        return schema
+
+    if origin in (Union, UnionType):
+        return {"anyOf": [get_json_schema(arg) for arg in get_args(annotation)]}
+
+    if origin is not None or annotation in (list, set, frozenset, tuple, dict):
+        origin = annotation if origin is None else origin
+        if origin in (list, set, frozenset, tuple):
+            args = get_args(annotation)
+            item_schema = get_json_schema(args[0]) if args else {}
+            return {"type": "array", "items": item_schema}
+        if origin is dict:
+            args = get_args(annotation)
+            value_schema = get_json_schema(args[1]) if len(args) > 1 else {}
+            return {"type": "object", "additionalProperties": value_schema}
+
+    schemas = {
+        str: {"type": "string"},
+        int: {"type": "integer"},
+        float: {"type": "number"},
+        bool: {"type": "boolean"},
+        None: {"type": "null"},
+        type(None): {"type": "null"},
+        datetime: {"type": "string", "format": "date-time"},
+        date: {"type": "string", "format": "date"},
+        time: {"type": "string", "format": "time"},
+        UUID: {"type": "string", "format": "uuid"},
+        Any: {},
+    }
+    return schemas.get(annotation, {})
+
+
+def get_rule_json_schema(rule: Callable[..., Any]) -> dict[str, Any]:
+    """Get the JSON schema for a rule.
+
+    Args:
+        rule (Callable): The rule to get the JSON schema for.
+
+    Returns:
+        dict[str, Any]: The JSON schema for the rule.
+
+    Example:
+    ```python
+    from pyspecification import get_rule_json_schema, object_rule
+
+
+    @object_rule()
+    def is_admin(user: User) -> bool:
+        return user.is_admin
+
+
+    @object_rule()
+    def name__istartswith(user: User, value: str) -> bool:
+        return user.name.lower().startswith(value.lower())
+
+
+    @object_rule()
+    def age__between(user: User, min_age: int, max_age: int) -> bool:
+        return user.age >= min_age and user.age <= max_age
+
+
+    def main() -> None:
+        schema = get_rule_json_schema(is_admin)
+        print(schema)  # {'return': {'type': 'boolean'}}
+
+        schema = get_rule_json_schema(name__istartswith)
+        print(schema)  # {'value': {'type': 'string'}, 'return': {'type': 'boolean'}}
+
+        schema = get_rule_json_schema(age__between)
+        print(
+            schema
+        )  # {'min_age': {'type': 'integer'}, 'max_age': {'type': 'integer'}, 'return': {'type': 'boolean'}}
+
+
+    if __name__ == "__main__":
+        main()
+    ```
+
+    """  # noqa: E501
+    annotations = get_annotations(rule)
+    parameters = list(signature(rule).parameters)
+    schema: dict[str, Any] = {}
+
+    for index, name in enumerate(parameters):
+        if index == 0:
+            continue
+        schema[name] = get_json_schema(annotations.get(name, Any))
+
+    if "return" in annotations:
+        schema["return"] = get_json_schema(annotations["return"])
+
+    return schema

{pyspecification-1.0.0 → pyspecification-2.0.0}/src/pyspecification/predicate.py

@@ -59,7 +59,11 @@ class Predicate[T, R: ReturnType]:
         assert rule(User(name="Abdullah", age=16, is_admin=True))
         assert rule(User(name="admin", age=20, is_admin=False))
 
-        assert repr(rule) == "Predicate(is_admin OR (name__istartswith AND age__between))"
+        print(rule(User(name="Abdullah", age=18, is_admin=True)))
+        # True
+
+        print(repr(rule))
+        # Predicate((is_admin OR (name__istartswith AND age__between)))
 
 
     if __name__ == "__main__":

{pyspecification-1.0.0 → pyspecification-2.0.0}/src/pyspecification/registry.py

@@ -3,7 +3,6 @@ from collections.abc import Callable
 from functools import wraps
 from typing import Any, Concatenate
 
-from .constants import RESERVED_WORDS
 from .exceptions import RuleAlreadyRegisteredError, RuleDoesNotExistError
 from .predicate import OperatorType, Predicate, ReturnType
 from .processors import DEFAULT_PROCESSORS, ProcessFn, process_arguments
@@ -70,12 +69,7 @@ class ObjectRulesRegistry[T, R: ReturnType]:
         ]
 
         print([e for e in EMPLOYEES if rule(e)])
-
-        # [
-        #     User(name="Alice", age=18, is_admin=True),
-        #     User(name="Admin", age=18, is_admin=False),
-        #     User(name="Eve", age=8, is_admin=True),
-        # ]
+        # [User(name='Alice', age=18, is_admin=True), User(name='Admin', age=18, is_admin=False), User(name='Eve', age=8, is_admin=True)]
 
 
     if __name__ == "__main__":
@@ -230,8 +224,8 @@ class SubscriptableRulesRegistry[T, K, R: ReturnType]:
 
 
     def main() -> None:
-        # Manual composition: name == "abdullah" AND age >= 18
-        rule = reg["string__ieq"]("name", "a") | reg["int__ge"]("age", 18)
+        # Manual composition: name == "alice" OR age >= 18
+        rule = reg["string__ieq"]("name", "alice") | reg["int__ge"]("age", 18)
 
         EMPLOYEES = [
             {"name": "Alice", "age": 5},
@@ -243,13 +237,7 @@ class SubscriptableRulesRegistry[T, K, R: ReturnType]:
         ]
 
         print([e for e in EMPLOYEES if rule(e)])
-
-        # [
-        #     {"name": "Alice", "age": 5},
-        #     {"name": "Admin", "age": 6},
-        #     {"name": "David", "age": 25},
-        #     {"name": "Eve", "age": 30},
-        # ]
+        # [{'name': 'Alice', 'age': 5}, {'name': 'David', 'age': 25}, {'name': 'Eve', 'age': 30}]
 
 
     if __name__ == "__main__":
@@ -414,10 +402,6 @@ def _process_rule_name(fn: Callable[..., Any], name: str | None = None) -> str:
         msg = "You must provide a name for the rule when using a lambda function"
         raise ValueError(msg)
 
-    if rule_name.lower() in RESERVED_WORDS:
-        msg = f"Rule name '{rule_name}' is reserved"
-        raise ValueError(msg)
-
     validate_python_vars_fn_naming_convention(rule_name)
 
     return rule_name

{pyspecification-1.0.0 → pyspecification-2.0.0}/src/pyspecification/rules.py

@@ -69,12 +69,7 @@ def object_rule[T, R: ReturnType, **P](
         ]
 
         print([e for e in EMPLOYEES if rule(e)])
-
-        # [
-        #     User(name="Alice", age=18, is_admin=True),
-        #     User(name="Admin", age=18, is_admin=False),
-        #     User(name="Eve", age=8, is_admin=True),
-        # ]
+        # [User(name='Alice', age=18, is_admin=True), User(name='Admin', age=18, is_admin=False), User(name='Eve', age=8, is_admin=True)]
 
 
     if __name__ == "__main__":
@@ -137,7 +132,7 @@ def subscriptable_rule[T, K, R: ReturnType, **P](
 
 
     def main() -> None:
-        rule = string__ieq("name", "a") | int__ge("age", 18)
+        rule = string__ieq("name", "alice") | int__ge("age", 18)
 
         EMPLOYEES = [
             {"name": "Alice", "age": 5},
@@ -149,13 +144,7 @@ def subscriptable_rule[T, K, R: ReturnType, **P](
         ]
 
         print([e for e in EMPLOYEES if rule(e)])
-
-        # [
-        #     {"name": "Alice", "age": 5},
-        #     {"name": "Admin", "age": 6},
-        #     {"name": "David", "age": 25},
-        #     {"name": "Eve", "age": 30},
-        # ]
+        # [{'name': 'Alice', 'age': 5}, {'name': 'David', 'age': 25}, {'name': 'Eve', 'age': 30}]
 
 
     if __name__ == "__main__":

pyspecification-1.0.0/src/pyspecification/constants.py

@@ -1 +0,0 @@
-RESERVED_WORDS = ("name", "expressions", "operator", "inverse", "args", "kwargs")

pyspecification-1.0.0/src/pyspecification/json_schema.py

@@ -1,64 +0,0 @@
-from collections.abc import Callable
-from inspect import get_annotations
-from typing import Any
-
-from pydantic import TypeAdapter
-
-
-def get_json_schema(rule: Callable[..., Any]) -> dict[str, Any]:
-    """Get the JSON schema for a rule.
-
-    Args:
-        rule (Callable): The rule to get the JSON schema for.
-
-    Returns:
-        dict[str, Any]: The JSON schema for the rule.
-
-    Example:
-    ```python
-    from pyspecification import get_json_schema, object_rule
-
-
-    @object_rule()
-    def is_admin(user: User) -> bool:
-        return user.is_admin
-
-
-    @object_rule()
-    def name__istartswith(user: User, value: str) -> bool:
-        return user.name.lower().startswith(value.lower())
-
-
-    @object_rule()
-    def age__between(user: User, min_age: int, max_age: int) -> bool:
-        return user.age >= min_age and user.age <= max_age
-
-
-    def main() -> None:
-        schema = get_json_schema(is_admin)
-        print(schema)
-        # {"return": {"type": "boolean"}}
-
-        schema = get_json_schema(name__istartswith)
-        print(schema)
-        # {"value": {"type": "string"}, "return": {"type": "boolean"}}
-
-        schema = get_json_schema(age__between)
-        print(schema)
-        # {
-        #     "min_age": {"type": "integer"},
-        #     "max_age": {"type": "integer"},
-        #     "return": {"type": "boolean"},
-        # }
-
-
-    if __name__ == "__main__":
-        main()
-    ```
-
-    """
-    return {
-        arg: TypeAdapter(typ).json_schema()
-        for idx, (arg, typ) in enumerate(get_annotations(rule).items())
-        if idx > 0
-    }

pyspecification-1.0.0/src/pyspecification/schemas.py

@@ -1,39 +0,0 @@
-from typing import Annotated, Any, Literal
-
-from pydantic import AfterValidator, BaseModel, Field, RootModel, field_validator
-
-from .validators import validate_python_vars_fn_naming_convention
-
-
-class PredicateSchema(BaseModel):
-    """A schema for a predicate."""
-
-    name: Annotated[str, AfterValidator(validate_python_vars_fn_naming_convention)]
-    inverse: bool
-    args: list[Any]
-    kwargs: dict[str, Any]
-
-    @field_validator("kwargs", mode="after")
-    @classmethod
-    def _validate_kwargs(cls, v: dict[str, Any]) -> dict[str, Any]:
-        for key in v:
-            validate_python_vars_fn_naming_convention(key)
-
-        return v
-
-
-class ExpressionsWrapperSchema(BaseModel):
-    """A schema for an expression."""
-
-    operator: Literal["all", "any"]
-    inverse: bool
-    expressions: list["ExpressionType"] = Field(min_length=1)
-
-
-ExpressionType = Annotated[
-    ExpressionsWrapperSchema | PredicateSchema, Field(union_mode="left_to_right")
-]
-
-
-class RuleSchema(RootModel[ExpressionType]):
-    """A schema for a rule."""