py-prim 0.1.0__tar.gz

py_prim-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Salik
+
+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.

py_prim-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: py-prim
+Version: 0.1.0
+Summary: Enhanced and validated base primitive data types for Python.
+Author: Salik Tariq
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# py-prim
+A robust, validated, and state-aware base class architecture for standard Python primitive data types.
+
+In standard Python, primitives like int and str are loose and allow for silent state changes or type mixing. This package provides wrapper classes (Integer, String, etc.) that enforce strict type validation, provide standardized empty/null checks, and offer a consistent API across all basic data types.
+
+## Features
+Strict Type Validation: Fails fast if you try to assign a string to an integer, or mix up booleans and ints.
+
+Standardized API: Every type implements .is_empty(), .is_null(), and .reset().
+
+Magic Methods Support: Compares cleanly with standard Python types using == and integrates seamlessly with if statements.
+
+Zero Dependencies: Built entirely on the Python standard library.
+
+## Installation
+You can install this package directly from GitHub using either pip or uv.
+
+Using pip:
+
+pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+Using uv:
+
+uv pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+
+## Available Types
+All types inherit from the Primitive abstract base class:
+
+-   Integer
+-   Float
+-   String
+-   Boolean
+-   Bytes
+
+## Usage:
+
+Access and mutate the underlying data using the .value property.
+
+from primitives import Integer, String
+
+### Initialize with a value
+age = Integer(25)
+print(age.value)  # 25
+
+### Change the value
+age.value = 26
+Strict Type Validation
+The classes automatically validate types upon initialization and assignment, preventing accidental type mixing.
+
+from primitives import Integer
+
+score = Integer(100)
+
+#### This will raise a ValueError: "Invalid value for Integer: 100.5"
+score.value = 100.5 
+
+### This library strictly isolates Booleans from Integers.
+score.value = True # Raises ValueError
+State Checks and Resets
+Every type knows what its "empty" and "default" states are.
+
+from primitives import String, Float
+
+name = String("")
+print(name.is_empty())  # True
+
+name.value = "Alice"
+print(name.is_empty())  # False
+
+### Reset back to the type's default value
+name.reset()
+print(name.value)       # ""
+
+### Null checking
+balance = Float(None)
+print(balance.is_null()) # True
+
+## License
+MIT License

py_prim-0.1.0/README.md

@@ -0,0 +1,80 @@
+# py-prim
+A robust, validated, and state-aware base class architecture for standard Python primitive data types.
+
+In standard Python, primitives like int and str are loose and allow for silent state changes or type mixing. This package provides wrapper classes (Integer, String, etc.) that enforce strict type validation, provide standardized empty/null checks, and offer a consistent API across all basic data types.
+
+## Features
+Strict Type Validation: Fails fast if you try to assign a string to an integer, or mix up booleans and ints.
+
+Standardized API: Every type implements .is_empty(), .is_null(), and .reset().
+
+Magic Methods Support: Compares cleanly with standard Python types using == and integrates seamlessly with if statements.
+
+Zero Dependencies: Built entirely on the Python standard library.
+
+## Installation
+You can install this package directly from GitHub using either pip or uv.
+
+Using pip:
+
+pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+Using uv:
+
+uv pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+
+## Available Types
+All types inherit from the Primitive abstract base class:
+
+-   Integer
+-   Float
+-   String
+-   Boolean
+-   Bytes
+
+## Usage:
+
+Access and mutate the underlying data using the .value property.
+
+from primitives import Integer, String
+
+### Initialize with a value
+age = Integer(25)
+print(age.value)  # 25
+
+### Change the value
+age.value = 26
+Strict Type Validation
+The classes automatically validate types upon initialization and assignment, preventing accidental type mixing.
+
+from primitives import Integer
+
+score = Integer(100)
+
+#### This will raise a ValueError: "Invalid value for Integer: 100.5"
+score.value = 100.5 
+
+### This library strictly isolates Booleans from Integers.
+score.value = True # Raises ValueError
+State Checks and Resets
+Every type knows what its "empty" and "default" states are.
+
+from primitives import String, Float
+
+name = String("")
+print(name.is_empty())  # True
+
+name.value = "Alice"
+print(name.is_empty())  # False
+
+### Reset back to the type's default value
+name.reset()
+print(name.value)       # ""
+
+### Null checking
+balance = Float(None)
+print(balance.is_null()) # True
+
+## License
+MIT License

py_prim-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-prim"
+version = "0.1.0"
+description = "Enhanced and validated base primitive data types for Python."
+readme = "README.md"
+authors = [{ name="Salik Tariq" }]
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

py_prim-0.1.0/setup.cfg

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

py_prim-0.1.0/src/primitives/__init__.py

@@ -0,0 +1,10 @@
+from .core import Primitive, Integer, Float, String, Boolean, Bytes
+
+__all__ = [
+    "Primitive",
+    "Integer",
+    "Float",
+    "String",
+    "Boolean",
+    "Bytes"
+]

py_prim-0.1.0/src/primitives/core.py

@@ -0,0 +1,129 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class Primitive(ABC):
+    def __init__(self, value: Any = None):
+        self._value = value
+        # Run initial validation if a value is provided
+        if value is not None:
+            self.validate()
+
+    @property
+    def value(self) -> Any:
+        return self._value
+
+    @value.setter
+    def value(self, new_value: Any):
+        self._value = new_value
+        self.validate()
+
+    # --- Abstract Methods (Must be overridden) ---
+    
+    @abstractmethod
+    def default_value(self) -> Any:
+        """Return the default value for the type."""
+        pass
+
+    @abstractmethod
+    def is_empty(self) -> bool:
+        """Determine if the value is functionally empty."""
+        pass
+
+    @abstractmethod
+    def is_valid(self) -> bool:
+        """Return True if the value meets all type constraints."""
+        pass
+
+    # --- Generic Methods (Inherited by all) ---
+
+    def is_null(self) -> bool:
+        return self._value is None
+
+    def validate(self) -> None:
+        if not self.is_null() and not self.is_valid():
+            raise ValueError(f"Invalid value for {self.__class__.__name__}: {self._value}")
+
+    def reset(self) -> None:
+        self.value = self.default_value()
+
+    # --- Python Magic Methods ---
+
+    def __str__(self) -> str:
+        return str(self.default_value() if self.is_null() else self._value)
+
+    def __eq__(self, other: Any) -> bool:
+        # Allow comparison with raw primitive types or other Enhanced primitives
+        if isinstance(other, Primitive):
+            return self._value == other.value
+        return self._value == other
+
+    def __bool__(self) -> bool:
+        return not self.is_empty() and not self.is_null()
+
+
+# ==========================================
+# Derived Classes
+# ==========================================
+
+class Integer(Primitive):
+    def default_value(self) -> int:
+        return 0
+
+    def is_empty(self) -> bool:
+        return self._value == 0
+
+    def is_valid(self) -> bool:
+        # Explicitly exclude booleans since bool is a subclass of int in Python
+        return isinstance(self._value, int) and not isinstance(self._value, bool)
+
+
+class Float(Primitive):
+    def default_value(self) -> float:
+        return 0.0
+
+    def is_empty(self) -> bool:
+        return self._value == 0.0
+
+    def is_valid(self) -> bool:
+        return isinstance(self._value, (float, int)) and not isinstance(self._value, bool)
+
+    # Optional override: ensure the value is always stored as a float internally
+    @Primitive.value.setter
+    def value(self, new_value):
+        if isinstance(new_value, int) and not isinstance(new_value, bool):
+            new_value = float(new_value)
+        super(Float, type(self)).value.fset(self, new_value)
+
+
+class String(Primitive):
+    def default_value(self) -> str:
+        return ""
+
+    def is_empty(self) -> bool:
+        # Empty if it is length 0 or contains only whitespace
+        return self._value == "" or str(self._value).isspace()
+
+    def is_valid(self) -> bool:
+        return isinstance(self._value, str)
+
+
+class Boolean(Primitive):
+    def default_value(self) -> bool:
+        return False
+        
+    def is_empty(self) -> bool:
+        return self._value is False
+        
+    def is_valid(self) -> bool:
+        return isinstance(self._value, bool)
+
+
+class Bytes(Primitive):
+    def default_value(self) -> bytes:
+        return b""
+
+    def is_empty(self) -> bool:
+        return self._value == b""
+
+    def is_valid(self) -> bool:
+        return isinstance(self._value, bytes)

py_prim-0.1.0/src/py_prim.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: py-prim
+Version: 0.1.0
+Summary: Enhanced and validated base primitive data types for Python.
+Author: Salik Tariq
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# py-prim
+A robust, validated, and state-aware base class architecture for standard Python primitive data types.
+
+In standard Python, primitives like int and str are loose and allow for silent state changes or type mixing. This package provides wrapper classes (Integer, String, etc.) that enforce strict type validation, provide standardized empty/null checks, and offer a consistent API across all basic data types.
+
+## Features
+Strict Type Validation: Fails fast if you try to assign a string to an integer, or mix up booleans and ints.
+
+Standardized API: Every type implements .is_empty(), .is_null(), and .reset().
+
+Magic Methods Support: Compares cleanly with standard Python types using == and integrates seamlessly with if statements.
+
+Zero Dependencies: Built entirely on the Python standard library.
+
+## Installation
+You can install this package directly from GitHub using either pip or uv.
+
+Using pip:
+
+pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+Using uv:
+
+uv pip install git+[https://github.com/saliktariq/Py-Prim.git](https://github.com/saliktariq/Py-Prim.git)
+
+
+## Available Types
+All types inherit from the Primitive abstract base class:
+
+-   Integer
+-   Float
+-   String
+-   Boolean
+-   Bytes
+
+## Usage:
+
+Access and mutate the underlying data using the .value property.
+
+from primitives import Integer, String
+
+### Initialize with a value
+age = Integer(25)
+print(age.value)  # 25
+
+### Change the value
+age.value = 26
+Strict Type Validation
+The classes automatically validate types upon initialization and assignment, preventing accidental type mixing.
+
+from primitives import Integer
+
+score = Integer(100)
+
+#### This will raise a ValueError: "Invalid value for Integer: 100.5"
+score.value = 100.5 
+
+### This library strictly isolates Booleans from Integers.
+score.value = True # Raises ValueError
+State Checks and Resets
+Every type knows what its "empty" and "default" states are.
+
+from primitives import String, Float
+
+name = String("")
+print(name.is_empty())  # True
+
+name.value = "Alice"
+print(name.is_empty())  # False
+
+### Reset back to the type's default value
+name.reset()
+print(name.value)       # ""
+
+### Null checking
+balance = Float(None)
+print(balance.is_null()) # True
+
+## License
+MIT License

py_prim-0.1.0/src/py_prim.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/primitives/__init__.py
+src/primitives/core.py
+src/py_prim.egg-info/PKG-INFO
+src/py_prim.egg-info/SOURCES.txt
+src/py_prim.egg-info/dependency_links.txt
+src/py_prim.egg-info/top_level.txt

py_prim-0.1.0/src/py_prim.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_prim-0.1.0/src/py_prim.egg-info/top_level.txt

@@ -0,0 +1 @@
+primitives