enforce-rules 1.0.0__tar.gz

enforce_rules-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Loepker-James
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

enforce_rules-1.0.0/PKG-INFO

@@ -0,0 +1,329 @@
+Metadata-Version: 2.4
+Name: enforce-rules
+Version: 1.0.0
+Summary: Runtime rule validation for Python using dictionary-based constraints.
+Author: Jake Loepker, Microsoft Copilot (AI Assistant)
+License: BSD 3-Clause License
+        
+        Copyright (c) 2026, Loepker-James
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/Loepker-James/enforce-rules
+Project-URL: Issues, https://github.com/Loepker-James/enforce-rules/issues
+Project-URL: Copilot, https://copilot.microsoft.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+Project Enforce Rules
+Project Enforce Rules (or PER for short) expands the Python type system to allow more constraints.
+
+Version #
+----------------
+MAJOR: 1
+MINOR: 0
+PATCH: 0
+
+If you need to catch up, you can see the full version history in the [CHANGELOG](CHANGELOG.md).
+
+It exists to let you use features Python doesn't already provide in the typing system — things you probably want, like min, max, length, all_same, and many more.
+
+PER now supports runtime validation anywhere using:
+
+```python
+validate(value: object, rules: Dict[str, typing.Any])
+```
+
+This enforces rule dictionaries and returns the original value if valid.
+If invalid, it raises a descriptive error.
+
+Why I Made It
+I wanted type‑hint features Python didn’t give me. I thought dictionaries would work until I learned... well...
+Python didn’t enforce them.
+
+So with the help of Microsoft Copilot and my dad, we designed a module that enforces this type of stuff. 
+Then I realized everyone in the Python community could use this, so it became a project. Hence, creating PER.
+
+PER uses rule dictionaries and validate() to enforce constraints at runtime.
+
+Install it with pip:
+
+```bash
+pip install enforce-rules
+```
+Then use it like:
+
+```python
+from enforce_rules import validate
+```
+Features
+1. Runtime enforcement of rule dictionaries
+2. Dictionary‑based rule definitions
+3. No extra objects required
+4. Works anywhere in your code
+5. Extensible via must_be_true
+
+How It Works
+PER validates values using:
+
+```python
+validate(value, rules)
+```
+If the value violates a rule, PER raises an error.
+If the value passes, PER returns the original value unchanged.
+
+This means validated values behave exactly like normal Python values.
+
+Keywords and Usage
+Below are all supported keywords.
+
+length
+The length of the object must be exactly this.
+
+```python
+lst = validate([1, 2, 3, 4, 5], {"length": 5})
+```
+
+min_length
+Minimum length (inclusive).
+
+```python
+lst = validate(['a', 'b', 'c', 'd', 'e'], {"min_length": 3})
+```
+max_length
+Maximum length (inclusive).
+
+```python
+lst = validate([1, 2, 3, 4, 5, 6], {"max_length": 7})
+```
+min
+Minimum numeric value (inclusive).
+
+```python
+number = validate(10, {"min": 0})
+```
+max
+Maximum numeric value (inclusive).
+
+```python
+number = validate(10, {"max": 20})
+```
+allowed_values
+Similar to Literal; value must be one of the allowed values.
+
+```python
+val = validate("a", {"allowed_values": ("a", "b", "c", "d")})
+```
+invariant
+Value must be truthy.
+
+```python
+val = validate((0 == 0), {"invariant": True})
+```
+all_same
+All values in the collection must be the same.
+
+```python
+numbers = validate([1, 1, 1], {"all_same": True})
+```
+all_unique
+All values in the collection must be unique.
+
+```python
+numbers = validate([1, 2, 3], {"all_unique": True})
+```
+non_empty
+Collection must not be empty.
+
+```python
+my_strings = validate(['a', 'b', 'c'], {"non_empty": True})
+```
+no_nulls
+Collection must not contain None.
+
+```python
+my_things = validate([1, 2, 3, "a", "b", "c"], {"no_nulls": True})
+```
+
+sorted
+List must be sorted (increasing or decreasing).
+
+```python
+numbers = validate([1, 5, 9], {"sorted": True})
+```
+
+increasing
+List must be strictly increasing.
+
+```python
+numbers = validate([1, 5, 9], {"increasing": True})
+```
+decreasing
+List must be strictly decreasing.
+
+```python
+numbers = validate([9, 5, 1], {"decreasing": True})
+```
+sum_min
+Minimum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_min": 50})
+```
+sum_max
+Maximum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_max": 70})
+```
+element_min
+Minimum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_min": 5})
+```
+element_max
+Maximum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_max": 40})
+```
+regex
+String must match the regex.
+
+```python
+cat_or_dog = validate("cat", {"regex": "cat|dog"})
+```
+
+
+must_be_true
+Custom rule: a function that returns True for allowed values.
+
+```python
+def is_even(x: int) -> bool:
+    return x % 2 == 0
+even_number = validate(8, {"must_be_true": is_even})
+```
+This calls:
+
+```python
+is_even(8)
+```
+If enough people use a must_be_true lambda, it may become an added keyword in a later version
+
+Contributing
+Contributions are welcome. Please open an issue or pull request.
+When contributing, ensure backwards compatibility (you cannot remove keywords and/or features).
+
+Please note, when using my module, that you will manually have to validate each time should you choose to mutate a variable.
+
+
+Versioning Policy
+-----------------
+
+This project guarantees full backwards compatibility. Existing rule files, keyword meanings, validator behaviors, and metadata formats will continue to work exactly as before. No update will ever break existing configurations.
+
+Version Numbering
+-----------------
+This project uses a non-breaking semantic versioning model:
+
+MAJOR.MINOR.PATCH
+
+MAJOR = large new feature families
+MINOR = small additive keywords or enhancements
+PATCH = bug fixes or internal improvements
+
+Major bumps do not imply breaking changes. They only indicate that a significant new capability has been added.
+
+Major bumps always reset MINOR and PATCH to 0. For example:
+1.7.3 -> 2.0.0
+1.12.0 -> 2.0.0
+1.0.0 -> 2.0.0
+
+Minor bumps always reset PATCH to 0. For example:
+1.7.3 -> 1.8.0
+1.12.9 -> 1.13.0
+1.0.4 -> 1.1.0
+
+Minor Version Bumps
+-------------------
+Minor bumps occur when adding small keywords. Examples include:
+
+min_inclusive
+max_inclusive
+trim_whitespace
+pattern_flags
+
+These additions do not change the meaning of existing keywords, do not require users to modify rule files, and do not alter validator behavior. They are classified as minor updates.
+
+Minor bumps always reset PATCH to 0
+
+Major Version Bumps
+-------------------
+Major bumps occur only when adding large new keyword families or entire new capability domains. Examples include:
+
+a full date-validation system
+a full numeric-range system
+a full conditional-rules system
+a full schema-level rule system
+
+These are major features, even though they remain fully backwards-compatible. Major bumps communicate that the release adds a significant new capability.
+
+Major bumps always reset MINOR and PATCH to 0.
+
+Patch Version Bumps
+-------------------
+Patch bumps occur when fixing bugs, improving internal logic, optimizing performance, correcting documentation, or adjusting error messages without changing meaning. Patch updates never add new keywords.
+
+Summary
+-------
+MAJOR: large new feature families, backwards-compatible, resets MINOR and PATCH to 0
+MINOR: small additive keywords, backwards-compatible
+PATCH: fixes only, backwards-compatible
+
+
+
+Credits
+Microsoft Copilot — for helping me code it. It did a TON of the coding, and to be honest, I couldn't have made this project without it. It did ~~some~~ a lot of readme, in addition to it writing most of CONTRIBUTING.md
+Dad — for helping me along the journey.
+
+License Type: BSD 3-clause

enforce_rules-1.0.0/README.md

@@ -0,0 +1,273 @@
+Project Enforce Rules
+Project Enforce Rules (or PER for short) expands the Python type system to allow more constraints.
+
+Version #
+----------------
+MAJOR: 1
+MINOR: 0
+PATCH: 0
+
+If you need to catch up, you can see the full version history in the [CHANGELOG](CHANGELOG.md).
+
+It exists to let you use features Python doesn't already provide in the typing system — things you probably want, like min, max, length, all_same, and many more.
+
+PER now supports runtime validation anywhere using:
+
+```python
+validate(value: object, rules: Dict[str, typing.Any])
+```
+
+This enforces rule dictionaries and returns the original value if valid.
+If invalid, it raises a descriptive error.
+
+Why I Made It
+I wanted type‑hint features Python didn’t give me. I thought dictionaries would work until I learned... well...
+Python didn’t enforce them.
+
+So with the help of Microsoft Copilot and my dad, we designed a module that enforces this type of stuff. 
+Then I realized everyone in the Python community could use this, so it became a project. Hence, creating PER.
+
+PER uses rule dictionaries and validate() to enforce constraints at runtime.
+
+Install it with pip:
+
+```bash
+pip install enforce-rules
+```
+Then use it like:
+
+```python
+from enforce_rules import validate
+```
+Features
+1. Runtime enforcement of rule dictionaries
+2. Dictionary‑based rule definitions
+3. No extra objects required
+4. Works anywhere in your code
+5. Extensible via must_be_true
+
+How It Works
+PER validates values using:
+
+```python
+validate(value, rules)
+```
+If the value violates a rule, PER raises an error.
+If the value passes, PER returns the original value unchanged.
+
+This means validated values behave exactly like normal Python values.
+
+Keywords and Usage
+Below are all supported keywords.
+
+length
+The length of the object must be exactly this.
+
+```python
+lst = validate([1, 2, 3, 4, 5], {"length": 5})
+```
+
+min_length
+Minimum length (inclusive).
+
+```python
+lst = validate(['a', 'b', 'c', 'd', 'e'], {"min_length": 3})
+```
+max_length
+Maximum length (inclusive).
+
+```python
+lst = validate([1, 2, 3, 4, 5, 6], {"max_length": 7})
+```
+min
+Minimum numeric value (inclusive).
+
+```python
+number = validate(10, {"min": 0})
+```
+max
+Maximum numeric value (inclusive).
+
+```python
+number = validate(10, {"max": 20})
+```
+allowed_values
+Similar to Literal; value must be one of the allowed values.
+
+```python
+val = validate("a", {"allowed_values": ("a", "b", "c", "d")})
+```
+invariant
+Value must be truthy.
+
+```python
+val = validate((0 == 0), {"invariant": True})
+```
+all_same
+All values in the collection must be the same.
+
+```python
+numbers = validate([1, 1, 1], {"all_same": True})
+```
+all_unique
+All values in the collection must be unique.
+
+```python
+numbers = validate([1, 2, 3], {"all_unique": True})
+```
+non_empty
+Collection must not be empty.
+
+```python
+my_strings = validate(['a', 'b', 'c'], {"non_empty": True})
+```
+no_nulls
+Collection must not contain None.
+
+```python
+my_things = validate([1, 2, 3, "a", "b", "c"], {"no_nulls": True})
+```
+
+sorted
+List must be sorted (increasing or decreasing).
+
+```python
+numbers = validate([1, 5, 9], {"sorted": True})
+```
+
+increasing
+List must be strictly increasing.
+
+```python
+numbers = validate([1, 5, 9], {"increasing": True})
+```
+decreasing
+List must be strictly decreasing.
+
+```python
+numbers = validate([9, 5, 1], {"decreasing": True})
+```
+sum_min
+Minimum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_min": 50})
+```
+sum_max
+Maximum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_max": 70})
+```
+element_min
+Minimum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_min": 5})
+```
+element_max
+Maximum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_max": 40})
+```
+regex
+String must match the regex.
+
+```python
+cat_or_dog = validate("cat", {"regex": "cat|dog"})
+```
+
+
+must_be_true
+Custom rule: a function that returns True for allowed values.
+
+```python
+def is_even(x: int) -> bool:
+    return x % 2 == 0
+even_number = validate(8, {"must_be_true": is_even})
+```
+This calls:
+
+```python
+is_even(8)
+```
+If enough people use a must_be_true lambda, it may become an added keyword in a later version
+
+Contributing
+Contributions are welcome. Please open an issue or pull request.
+When contributing, ensure backwards compatibility (you cannot remove keywords and/or features).
+
+Please note, when using my module, that you will manually have to validate each time should you choose to mutate a variable.
+
+
+Versioning Policy
+-----------------
+
+This project guarantees full backwards compatibility. Existing rule files, keyword meanings, validator behaviors, and metadata formats will continue to work exactly as before. No update will ever break existing configurations.
+
+Version Numbering
+-----------------
+This project uses a non-breaking semantic versioning model:
+
+MAJOR.MINOR.PATCH
+
+MAJOR = large new feature families
+MINOR = small additive keywords or enhancements
+PATCH = bug fixes or internal improvements
+
+Major bumps do not imply breaking changes. They only indicate that a significant new capability has been added.
+
+Major bumps always reset MINOR and PATCH to 0. For example:
+1.7.3 -> 2.0.0
+1.12.0 -> 2.0.0
+1.0.0 -> 2.0.0
+
+Minor bumps always reset PATCH to 0. For example:
+1.7.3 -> 1.8.0
+1.12.9 -> 1.13.0
+1.0.4 -> 1.1.0
+
+Minor Version Bumps
+-------------------
+Minor bumps occur when adding small keywords. Examples include:
+
+min_inclusive
+max_inclusive
+trim_whitespace
+pattern_flags
+
+These additions do not change the meaning of existing keywords, do not require users to modify rule files, and do not alter validator behavior. They are classified as minor updates.
+
+Minor bumps always reset PATCH to 0
+
+Major Version Bumps
+-------------------
+Major bumps occur only when adding large new keyword families or entire new capability domains. Examples include:
+
+a full date-validation system
+a full numeric-range system
+a full conditional-rules system
+a full schema-level rule system
+
+These are major features, even though they remain fully backwards-compatible. Major bumps communicate that the release adds a significant new capability.
+
+Major bumps always reset MINOR and PATCH to 0.
+
+Patch Version Bumps
+-------------------
+Patch bumps occur when fixing bugs, improving internal logic, optimizing performance, correcting documentation, or adjusting error messages without changing meaning. Patch updates never add new keywords.
+
+Summary
+-------
+MAJOR: large new feature families, backwards-compatible, resets MINOR and PATCH to 0
+MINOR: small additive keywords, backwards-compatible
+PATCH: fixes only, backwards-compatible
+
+
+
+Credits
+Microsoft Copilot — for helping me code it. It did a TON of the coding, and to be honest, I couldn't have made this project without it. It did ~~some~~ a lot of readme, in addition to it writing most of CONTRIBUTING.md
+Dad — for helping me along the journey.
+
+License Type: BSD 3-clause

enforce_rules-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "enforce-rules"
+version = "1.0.0"
+description = "Runtime rule validation for Python using dictionary-based constraints."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Jake Loepker" },
+    { name = "Microsoft Copilot (AI Assistant)" }
+]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "Typing :: Typed"
+]
+
+[project.urls]
+Homepage = "https://github.com/Loepker-James/enforce-rules"
+Issues = "https://github.com/Loepker-James/enforce-rules/issues"
+Copilot = "https://copilot.microsoft.com"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+

enforce_rules-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enforce_rules-1.0.0/src/enforce_rules/__init__.py

@@ -0,0 +1 @@
+from . import enforce_rules

enforce_rules-1.0.0/src/enforce_rules/enforce_rules.py

@@ -0,0 +1,171 @@
+from typing import Any, Dict, Iterable, Callable, Sequence
+import re
+
+
+# -----------------------------
+# VALIDATOR FUNCTIONS (DEFINED FIRST)
+# -----------------------------
+
+def _validate_length(value: Sequence[Any], expected: int) -> None:
+    if len(value) != expected:
+        raise ValueError(f"Expected length {expected}, got {len(value)}")
+
+
+def _validate_min_length(value: Sequence[Any], expected: int) -> None:
+    if len(value) < expected:
+        raise ValueError(f"Expected min length {expected}, got {len(value)}")
+
+
+def _validate_max_length(value: Sequence[Any], expected: int) -> None:
+    if len(value) > expected:
+        raise ValueError(f"Expected max length {expected}, got {len(value)}")
+
+
+def _validate_min(value: float | int, expected: float | int) -> None:
+    if value < expected:
+        raise ValueError(f"Expected value >= {expected}, got {value}")
+
+
+def _validate_max(value: float | int, expected: float | int) -> None:
+    if value > expected:
+        raise ValueError(f"Expected value <= {expected}, got {value}")
+
+
+def _validate_allowed_values(value: Any, allowed: Iterable[Any]) -> None:
+    if value not in allowed:
+        raise ValueError(f"Value {value} not in allowed values {allowed}")
+
+
+def _validate_invariant(value: Any, expected: bool) -> None:
+    if expected and not value:
+        raise ValueError("Invariant rule failed: value must be truthy")
+
+
+def _validate_all_same(value: Sequence[Any], expected: bool) -> None:
+    if expected and len(set(value)) != 1:
+        raise ValueError("All elements must be the same")
+
+
+def _validate_all_unique(value: Sequence[Any], expected: bool) -> None:
+    if expected and len(set(value)) != len(value):
+        raise ValueError("All elements must be unique")
+
+
+def _validate_non_empty(value: Sequence[Any], expected: bool) -> None:
+    if expected and len(value) == 0:
+        raise ValueError("Collection must not be empty")
+
+
+def _validate_no_nulls(value: Iterable[Any], expected: bool) -> None:
+    if expected and any(v is None for v in value):
+        raise ValueError("Collection must not contain None")
+
+
+def _validate_sorted(value: Sequence[Any], expected: bool) -> None:
+    if expected:
+        if value != sorted(value) and value != sorted(value, reverse=True):
+            raise ValueError("List must be sorted increasing or decreasing")
+
+
+def _validate_increasing(value: Sequence[Any], expected: bool) -> None:
+    if expected:
+        for a, b in zip(value, value[1:]):
+            if not (b > a):
+                raise ValueError("List must be strictly increasing")
+
+
+def _validate_decreasing(value: Sequence[Any], expected: bool) -> None:
+    if expected:
+        for a, b in zip(value, value[1:]):
+            if not (b < a):
+                raise ValueError("List must be strictly decreasing")
+
+
+def _validate_sum_min(value: Iterable[float | int], expected: float | int) -> None:
+    total = sum(value)
+    if total < expected:
+        raise ValueError(f"Sum must be >= {expected}, got {total}")
+
+
+def _validate_sum_max(value: Iterable[float | int], expected: float | int) -> None:
+    total = sum(value)
+    if total > expected:
+        raise ValueError(f"Sum must be <= {expected}, got {total}")
+
+
+def _validate_element_min(value: Iterable[float | int], expected: float | int) -> None:
+    if min(value) < expected:
+        raise ValueError(f"Elements must be >= {expected}")
+
+
+def _validate_element_max(value: Iterable[float | int], expected: float | int) -> None:
+    if max(value) > expected:
+        raise ValueError(f"Elements must be <= {expected}")
+
+
+def _validate_regex(value: str, pattern: str, flags: Any) -> None:
+    compiled = re.compile(pattern, flags or 0)
+    if not compiled.fullmatch(value):
+        raise ValueError(f"Value '{value}' does not match regex '{pattern}'")
+
+
+def _validate_must_be_true(value: Any, func: Callable[[Any], bool]) -> None:
+    if not func(value):
+        raise ValueError("must_be_true rule failed")
+
+
+# -----------------------------
+# VALIDATE() — DEFINED LAST
+# -----------------------------
+
+def validate(value: Any, rules: Dict[str, Any]) -> Any:
+    """
+    Validate a value against a dictionary of rules.
+    Returns the original value if valid, otherwise raises ValueError.
+    """
+    for key, rule in rules.items():
+        match key:
+            case "length":
+                _validate_length(value, int(rule))
+            case "min_length":
+                _validate_min_length(value, int(rule))
+            case "max_length":
+                _validate_max_length(value, int(rule))
+            case "min":
+                _validate_min(value, rule)
+            case "max":
+                _validate_max(value, rule)
+            case "allowed_values":
+                _validate_allowed_values(value, rule)
+            case "invariant":
+                _validate_invariant(value, bool(rule))
+            case "all_same":
+                _validate_all_same(value, bool(rule))
+            case "all_unique":
+                _validate_all_unique(value, bool(rule))
+            case "non_empty":
+                _validate_non_empty(value, bool(rule))
+            case "no_nulls":
+                _validate_no_nulls(value, bool(rule))
+            case "sorted":
+                _validate_sorted(value, bool(rule))
+            case "increasing":
+                _validate_increasing(value, bool(rule))
+            case "decreasing":
+                _validate_decreasing(value, bool(rule))
+            case "sum_min":
+                _validate_sum_min(value, rule)
+            case "sum_max":
+                _validate_sum_max(value, rule)
+            case "element_min":
+                _validate_element_min(value, rule)
+            case "element_max":
+                _validate_element_max(value, rule)
+            case "regex":
+                _validate_regex(value, str(rule), rules.get("regex_flags"))
+            case "must_be_true":
+                _validate_must_be_true(value, rule)
+            case _:
+                raise ValueError(f"Unknown rule: {key}")
+
+    return value

enforce_rules-1.0.0/src/enforce_rules.egg-info/PKG-INFO

@@ -0,0 +1,329 @@
+Metadata-Version: 2.4
+Name: enforce-rules
+Version: 1.0.0
+Summary: Runtime rule validation for Python using dictionary-based constraints.
+Author: Jake Loepker, Microsoft Copilot (AI Assistant)
+License: BSD 3-Clause License
+        
+        Copyright (c) 2026, Loepker-James
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/Loepker-James/enforce-rules
+Project-URL: Issues, https://github.com/Loepker-James/enforce-rules/issues
+Project-URL: Copilot, https://copilot.microsoft.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+Project Enforce Rules
+Project Enforce Rules (or PER for short) expands the Python type system to allow more constraints.
+
+Version #
+----------------
+MAJOR: 1
+MINOR: 0
+PATCH: 0
+
+If you need to catch up, you can see the full version history in the [CHANGELOG](CHANGELOG.md).
+
+It exists to let you use features Python doesn't already provide in the typing system — things you probably want, like min, max, length, all_same, and many more.
+
+PER now supports runtime validation anywhere using:
+
+```python
+validate(value: object, rules: Dict[str, typing.Any])
+```
+
+This enforces rule dictionaries and returns the original value if valid.
+If invalid, it raises a descriptive error.
+
+Why I Made It
+I wanted type‑hint features Python didn’t give me. I thought dictionaries would work until I learned... well...
+Python didn’t enforce them.
+
+So with the help of Microsoft Copilot and my dad, we designed a module that enforces this type of stuff. 
+Then I realized everyone in the Python community could use this, so it became a project. Hence, creating PER.
+
+PER uses rule dictionaries and validate() to enforce constraints at runtime.
+
+Install it with pip:
+
+```bash
+pip install enforce-rules
+```
+Then use it like:
+
+```python
+from enforce_rules import validate
+```
+Features
+1. Runtime enforcement of rule dictionaries
+2. Dictionary‑based rule definitions
+3. No extra objects required
+4. Works anywhere in your code
+5. Extensible via must_be_true
+
+How It Works
+PER validates values using:
+
+```python
+validate(value, rules)
+```
+If the value violates a rule, PER raises an error.
+If the value passes, PER returns the original value unchanged.
+
+This means validated values behave exactly like normal Python values.
+
+Keywords and Usage
+Below are all supported keywords.
+
+length
+The length of the object must be exactly this.
+
+```python
+lst = validate([1, 2, 3, 4, 5], {"length": 5})
+```
+
+min_length
+Minimum length (inclusive).
+
+```python
+lst = validate(['a', 'b', 'c', 'd', 'e'], {"min_length": 3})
+```
+max_length
+Maximum length (inclusive).
+
+```python
+lst = validate([1, 2, 3, 4, 5, 6], {"max_length": 7})
+```
+min
+Minimum numeric value (inclusive).
+
+```python
+number = validate(10, {"min": 0})
+```
+max
+Maximum numeric value (inclusive).
+
+```python
+number = validate(10, {"max": 20})
+```
+allowed_values
+Similar to Literal; value must be one of the allowed values.
+
+```python
+val = validate("a", {"allowed_values": ("a", "b", "c", "d")})
+```
+invariant
+Value must be truthy.
+
+```python
+val = validate((0 == 0), {"invariant": True})
+```
+all_same
+All values in the collection must be the same.
+
+```python
+numbers = validate([1, 1, 1], {"all_same": True})
+```
+all_unique
+All values in the collection must be unique.
+
+```python
+numbers = validate([1, 2, 3], {"all_unique": True})
+```
+non_empty
+Collection must not be empty.
+
+```python
+my_strings = validate(['a', 'b', 'c'], {"non_empty": True})
+```
+no_nulls
+Collection must not contain None.
+
+```python
+my_things = validate([1, 2, 3, "a", "b", "c"], {"no_nulls": True})
+```
+
+sorted
+List must be sorted (increasing or decreasing).
+
+```python
+numbers = validate([1, 5, 9], {"sorted": True})
+```
+
+increasing
+List must be strictly increasing.
+
+```python
+numbers = validate([1, 5, 9], {"increasing": True})
+```
+decreasing
+List must be strictly decreasing.
+
+```python
+numbers = validate([9, 5, 1], {"decreasing": True})
+```
+sum_min
+Minimum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_min": 50})
+```
+sum_max
+Maximum sum of the collection (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"sum_max": 70})
+```
+element_min
+Minimum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_min": 5})
+```
+element_max
+Maximum value for any element (inclusive).
+
+```python
+numbers = validate([10, 20, 30], {"element_max": 40})
+```
+regex
+String must match the regex.
+
+```python
+cat_or_dog = validate("cat", {"regex": "cat|dog"})
+```
+
+
+must_be_true
+Custom rule: a function that returns True for allowed values.
+
+```python
+def is_even(x: int) -> bool:
+    return x % 2 == 0
+even_number = validate(8, {"must_be_true": is_even})
+```
+This calls:
+
+```python
+is_even(8)
+```
+If enough people use a must_be_true lambda, it may become an added keyword in a later version
+
+Contributing
+Contributions are welcome. Please open an issue or pull request.
+When contributing, ensure backwards compatibility (you cannot remove keywords and/or features).
+
+Please note, when using my module, that you will manually have to validate each time should you choose to mutate a variable.
+
+
+Versioning Policy
+-----------------
+
+This project guarantees full backwards compatibility. Existing rule files, keyword meanings, validator behaviors, and metadata formats will continue to work exactly as before. No update will ever break existing configurations.
+
+Version Numbering
+-----------------
+This project uses a non-breaking semantic versioning model:
+
+MAJOR.MINOR.PATCH
+
+MAJOR = large new feature families
+MINOR = small additive keywords or enhancements
+PATCH = bug fixes or internal improvements
+
+Major bumps do not imply breaking changes. They only indicate that a significant new capability has been added.
+
+Major bumps always reset MINOR and PATCH to 0. For example:
+1.7.3 -> 2.0.0
+1.12.0 -> 2.0.0
+1.0.0 -> 2.0.0
+
+Minor bumps always reset PATCH to 0. For example:
+1.7.3 -> 1.8.0
+1.12.9 -> 1.13.0
+1.0.4 -> 1.1.0
+
+Minor Version Bumps
+-------------------
+Minor bumps occur when adding small keywords. Examples include:
+
+min_inclusive
+max_inclusive
+trim_whitespace
+pattern_flags
+
+These additions do not change the meaning of existing keywords, do not require users to modify rule files, and do not alter validator behavior. They are classified as minor updates.
+
+Minor bumps always reset PATCH to 0
+
+Major Version Bumps
+-------------------
+Major bumps occur only when adding large new keyword families or entire new capability domains. Examples include:
+
+a full date-validation system
+a full numeric-range system
+a full conditional-rules system
+a full schema-level rule system
+
+These are major features, even though they remain fully backwards-compatible. Major bumps communicate that the release adds a significant new capability.
+
+Major bumps always reset MINOR and PATCH to 0.
+
+Patch Version Bumps
+-------------------
+Patch bumps occur when fixing bugs, improving internal logic, optimizing performance, correcting documentation, or adjusting error messages without changing meaning. Patch updates never add new keywords.
+
+Summary
+-------
+MAJOR: large new feature families, backwards-compatible, resets MINOR and PATCH to 0
+MINOR: small additive keywords, backwards-compatible
+PATCH: fixes only, backwards-compatible
+
+
+
+Credits
+Microsoft Copilot — for helping me code it. It did a TON of the coding, and to be honest, I couldn't have made this project without it. It did ~~some~~ a lot of readme, in addition to it writing most of CONTRIBUTING.md
+Dad — for helping me along the journey.
+
+License Type: BSD 3-clause

enforce_rules-1.0.0/src/enforce_rules.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/enforce_rules/__init__.py
+src/enforce_rules/enforce_rules.py
+src/enforce_rules.egg-info/PKG-INFO
+src/enforce_rules.egg-info/SOURCES.txt
+src/enforce_rules.egg-info/dependency_links.txt
+src/enforce_rules.egg-info/top_level.txt
+tests/test_enforce_rules.py

enforce_rules-1.0.0/src/enforce_rules.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

enforce_rules-1.0.0/src/enforce_rules.egg-info/top_level.txt

@@ -0,0 +1 @@
+enforce_rules

enforce_rules-1.0.0/tests/test_enforce_rules.py

@@ -0,0 +1,190 @@
+import unittest
+from typing import Any, Dict
+from enforce_rules import validate
+
+
+class TestValidate(unittest.TestCase):
+
+    # -----------------------------
+    # LENGTH RULES
+    # -----------------------------
+    def test_length_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"length": 3}), [1, 2, 3])
+
+    def test_length_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 2], {"length": 3})
+
+    def test_min_length_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"min_length": 2}), [1, 2, 3])
+
+    def test_min_length_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1], {"min_length": 2})
+
+    def test_max_length_valid(self):
+        self.assertEqual(validate([1, 2], {"max_length": 3}), [1, 2])
+
+    def test_max_length_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 2, 3, 4], {"max_length": 3})
+
+    # -----------------------------
+    # MIN / MAX
+    # -----------------------------
+    def test_min_valid(self):
+        self.assertEqual(validate(5, {"min": 3}), 5)
+
+    def test_min_invalid(self):
+        with self.assertRaises(ValueError):
+            validate(2, {"min": 3})
+
+    def test_max_valid(self):
+        self.assertEqual(validate(5, {"max": 10}), 5)
+
+    def test_max_invalid(self):
+        with self.assertRaises(ValueError):
+            validate(20, {"max": 10})
+
+    # -----------------------------
+    # ALLOWED VALUES
+    # -----------------------------
+    def test_allowed_values_valid(self):
+        self.assertEqual(validate("b", {"allowed_values": ("a", "b", "c")}), "b")
+
+    def test_allowed_values_invalid(self):
+        with self.assertRaises(ValueError):
+            validate("x", {"allowed_values": ("a", "b", "c")})
+
+    # -----------------------------
+    # INVARIANT
+    # -----------------------------
+    def test_invariant_valid(self):
+        self.assertTrue(validate(True, {"invariant": True}))
+
+    def test_invariant_invalid(self):
+        with self.assertRaises(ValueError):
+            validate(False, {"invariant": True})
+
+    # -----------------------------
+    # ALL SAME / ALL UNIQUE
+    # -----------------------------
+    def test_all_same_valid(self):
+        self.assertEqual(validate([1, 1, 1], {"all_same": True}), [1, 1, 1])
+
+    def test_all_same_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 2, 1], {"all_same": True})
+
+    def test_all_unique_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"all_unique": True}), [1, 2, 3])
+
+    def test_all_unique_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 2, 2], {"all_unique": True})
+
+    # -----------------------------
+    # NON EMPTY / NO NULLS
+    # -----------------------------
+    def test_non_empty_valid(self):
+        self.assertEqual(validate([1], {"non_empty": True}), [1])
+
+    def test_non_empty_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([], {"non_empty": True})
+
+    def test_no_nulls_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"no_nulls": True}), [1, 2, 3])
+
+    def test_no_nulls_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, None, 3], {"no_nulls": True})
+
+    # -----------------------------
+    # SORTED / INCREASING / DECREASING
+    # -----------------------------
+    def test_sorted_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"sorted": True}), [1, 2, 3])
+
+    def test_sorted_reverse_valid(self):
+        self.assertEqual(validate([3, 2, 1], {"sorted": True}), [3, 2, 1])
+
+    def test_sorted_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 3, 2], {"sorted": True})
+
+    def test_increasing_valid(self):
+        self.assertEqual(validate([1, 2, 3], {"increasing": True}), [1, 2, 3])
+
+    def test_increasing_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 3, 2], {"increasing": True})
+
+    def test_decreasing_valid(self):
+        self.assertEqual(validate([3, 2, 1], {"decreasing": True}), [3, 2, 1])
+
+    def test_decreasing_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([3, 1, 2], {"decreasing": True})
+
+    # -----------------------------
+    # SUM MIN / SUM MAX
+    # -----------------------------
+    def test_sum_min_valid(self):
+        self.assertEqual(validate([10, 20, 30], {"sum_min": 50}), [10, 20, 30])
+
+    def test_sum_min_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([10, 20], {"sum_min": 50})
+
+    def test_sum_max_valid(self):
+        self.assertEqual(validate([10, 20, 30], {"sum_max": 70}), [10, 20, 30])
+
+    def test_sum_max_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([50, 50], {"sum_max": 70})
+
+    # -----------------------------
+    # ELEMENT MIN / ELEMENT MAX
+    # -----------------------------
+    def test_element_min_valid(self):
+        self.assertEqual(validate([10, 20, 30], {"element_min": 5}), [10, 20, 30])
+
+    def test_element_min_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([1, 20, 30], {"element_min": 5})
+
+    def test_element_max_valid(self):
+        self.assertEqual(validate([10, 20, 30], {"element_max": 40}), [10, 20, 30])
+
+    def test_element_max_invalid(self):
+        with self.assertRaises(ValueError):
+            validate([10, 20, 100], {"element_max": 40})
+
+    # -----------------------------
+    # REGEX
+    # -----------------------------
+    def test_regex_valid(self):
+        self.assertEqual(validate("cat", {"regex": "cat|dog"}), "cat")
+
+    def test_regex_invalid(self):
+        with self.assertRaises(ValueError):
+            validate("bird", {"regex": "cat|dog"})
+
+    # -----------------------------
+    # MUST BE TRUE
+    # -----------------------------
+    def test_must_be_true_valid(self):
+        def is_even(x: int) -> bool:
+            return x % 2 == 0
+        self.assertEqual(validate(8, {"must_be_true": is_even}), 8)
+
+    def test_must_be_true_invalid(self):
+        def is_even(x: int) -> bool:
+            return x % 2 == 0
+        with self.assertRaises(ValueError):
+            validate(7, {"must_be_true": is_even})
+
+
+if __name__ == "__main__":
+    unittest.main()