valify 0.1.0__py3-none-any.whl

valify/__init__.py

@@ -0,0 +1,62 @@
+"""
+valify
+~~~~~~
+
+A composable, expressive data validation library for Python.
+
+Basic usage::
+
+    from valify import Schema, StringValidator, IntValidator
+
+    schema = Schema({
+        "name": StringValidator(min_length=2),
+        "age":  IntValidator(min_value=0, max_value=120),
+    })
+
+    result = schema.validate({"name": "Alice", "age": 30})
+"""
+
+from .exceptions import (
+    ValifyError, 
+    ValidationError, 
+    SchemaError,
+    RequiredFieldError
+)
+from .validators import (
+    Validator,
+    StringValidator,
+    IntValidator,
+    FloatValidator,
+    BoolValidator,
+    EmailValidator
+) 
+
+from .schema import Schema
+
+# __all__ defines the public API — what gets exported when someone writes
+# `from valify import *`. More importantly, it tells IDEs and documentation
+# tools exactly what your library exposes publicly.
+
+__all__ = [
+    
+    # Exceptions
+    "ValifyError",
+    "ValidationError",
+    "RequiredFieldError",
+    "SchemaError",
+    
+    # Validators
+    "Validator",
+    "StringValidator",
+    "IntValidator",
+    "FloatValidator",
+    "BoolValidator",
+    "EmailValidator",
+    
+    # Schema
+    "Schema",    
+]
+
+__version__ = "0.1.0"
+__author__ = "Darshan Bamankar"
+

valify/exceptions.py

@@ -0,0 +1,50 @@
+"""
+valify.exceptions
+~~~~~~~~~~~~~~~~~
+
+Custom exception hierarchy for the valify library.
+"""
+
+class ValifyError(Exception):
+    """ Base class for all valify exceptions  """
+    
+class ValidationError(ValifyError):
+    """
+    Raised when a value fails a validation rule.
+    
+    Attributes
+    ----------
+    message : str
+        Human-readable description of what failed.
+    field : str
+        The field name that failed. None if used outside a schema.
+    value : object
+        The actual value that was rejected.
+    """
+    
+    def __init__(self, message, *, field = None, value = None):
+        
+        self.message = message
+        self.field = field
+        self.value = value
+        
+        full_message = f"[{field}] {message}" if field else message
+        super().__init__(full_message)
+
+class RequiredFieldError(ValidationError):
+    """ Raised when a required field is missing from validation data. """
+    
+    def __init__(self, field):
+        super().__init__(
+            message="Required field is missing",
+            field=field,
+            value=None,
+        )
+
+class SchemaError(ValifyError):
+    """ Raised when the schema definition itself is inavlid.  """
+    
+    def __init__(self, message):
+        self.message = message
+        super().__init__(message)
+    

valify/schema.py

@@ -0,0 +1,126 @@
+"""
+valify.schema
+~~~~~~~~~~~~~
+
+The Schema class for validating dictionaries against a set of validators.
+
+A Schema maps field names to Validator instances. When validate() is called,
+each field in the data is run through its corresponding validator, and all
+errors are collected before raising — so you get all errors at once, not
+just the first one.
+"""
+
+from .exceptions import ValidationError, RequiredFieldError, SchemaError
+from .validators import Validator
+
+class Schema:
+    """ Validates a dictionary against a set of validators. 
+    
+    Parameters
+    ----------
+    fields : dict
+        A mapping of field names to Validator instances.
+    strict : bool
+        If True, raise ValidationError for keys in the data that are
+        not defined in the schema. Defaults to False.
+
+    Example
+    -------
+        schema = Schema({
+            "name": StringValidator(min_length=2),
+            "age":  IntValidator(min_value=0, max_value=120),
+        })
+
+        result = schema.validate({"name": "Alice", "age": 30})
+        print(result)  # {"name": "Alice", "age": 30}
+    """
+    
+    def __init__(self, fields, * , strict=False):
+        
+        # Validate the schema definition itself before storing it.
+        # This catches developer mistakes early, at schema creation time,
+        # rather than mysteriously failing later at validation time.
+        
+        if not isinstance(fields,dict):
+            raise SchemaError("Fields must be a dictionary")
+        
+        for key,val in fields.items():
+            if not isinstance(key,str):
+                raise SchemaError(
+                    f"Field names must be string, got {type(key).__name__!r}."
+                )
+            if not isinstance(val,Validator):
+                raise SchemaError(
+                    f"Field {key!r} must be a Validator instance, "
+                    f"got {type(val).__name__!r}."
+                )
+        
+        self.fields=fields
+        self.strict=strict
+        
+    def validate(self,data):
+        """ Validate a dictionary of data against the schema. 
+        
+        Parameters
+        ----------
+        data : dict
+            The raw data to validate.
+
+        Returns
+        -------
+        dict
+            A new dictionary containing only the validated (and possibly
+            coerced) values.
+
+        Raises
+        ------
+        ValidationError
+            If any field fails validation. Contains all errors at once.
+        RequiredFieldError
+            If a required field is missing from data.
+        SchemaError
+            If data is not a dictionary.
+        """
+        
+        if not isinstance(data,dict):
+            raise SchemaError(
+                f"Expected a dictionary, got {type(data).__name__!r}"
+            )
+        
+        errors = {}
+        result = {}
+        
+        if self.strict:
+            for key in data:
+                if key not in self.fields:
+                    errors[key] = f"Unknown field."
+        
+        for field_name,validator in self.fields.items():
+            if field_name not in data:
+                errors[field_name] = "Required field missing."
+                continue
+            
+            try:
+                result[field_name]=validator.validate(data[field_name])
+            except ValidationError as e:
+                errors[field_name]=e.message
+        
+        
+        if errors:
+            error_lines = "\n".join(
+                f" {field}: {msg}" for field,msg in errors.items()
+            )        
+            raise ValidationError(
+                f"Validation Failed:\n{error_lines}",
+            )
+        return result
+        
+        
+    
+    def __repr__(self):
+        field_reprs = ", ".join(
+            f"{k!r}: {v!r}" for k, v in self.fields.items()
+        )
+        return f"Schema({{{field_reprs}}}, strict={self.strict!r})"
+    
+    

valify/validators.py

@@ -0,0 +1,324 @@
+import re
+from .exceptions import ValidationError
+
+"""
+valify.validators
+~~~~~~~~~~~~~~~~~
+
+Built-in validators for common Python types and patterns.
+
+Each validator is a class that accepts configuration on instantiation
+and exposes a single `validate(value)` method that either returns the
+(possibly coerced) value or raises ValidationError.
+"""
+
+
+class Validator:
+    """ Base class for all valify validators. 
+    
+    All built-in and custom validators inherit from this class.
+    Subclasses must implement the `validate` method.
+
+    Example
+    -------
+    Creating a custom validator::
+
+        class PositiveInt(Validator):
+            def validate(self, value):
+                if not isinstance(value, int) or value <= 0:
+                    raise ValidationError(
+                        "Value must be a positive integer.",
+                        value=value,
+                    )
+                return value
+    """
+    
+    def validate(self, value):
+        """ Validates a value and returns it, possibly coerced
+        
+        Parameters
+        ----------
+        value : object
+            The Validated (and possibly coerced) value.
+        
+        Raises
+        ------
+        ValidationError
+            If the value fails validation.
+            
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement validate()"
+        )
+        
+    def __repr__(self):
+        return f"{type(self).__name__}()"
+    
+class StringValidator(Validator):
+    """ Validates that a value is a string, with optional lenght constraints. 
+    
+    Parameters
+    ----------
+    min_length : int or None
+        Minimum allowed length. None means no minimum.
+    max_length : int or None
+        Maximum allowed length. None means no maximum.
+    strip : bool
+        If True, strip leading/trailing whitespace before validating.
+        Defaults to True.
+
+    Example
+    -------
+        v = StringValidator(min_length=2, max_length=50)
+        v.validate("Alice")   # returns "Alice"
+        v.validate("A")       # raises ValidationError
+    
+    """
+    def __init__(self, *, min_length=None, max_length=None, strip=True):
+        
+        self.min_length = min_length
+        self.max_length = max_length
+        self.strip = strip
+        
+    def validate(self, value):
+        if not isinstance(value, str):
+                raise ValidationError(
+                    f"Expected a string, got {type(value).__name__}",
+                    value=value
+                )
+        if self.strip:
+            value = value.strip()
+            
+        if self.min_length is not None and len(value) < self.min_length:
+            raise ValidationError(
+                f"Must be at least {self.min_length} characters long.",
+                value=value,
+            )
+        
+        if self.max_length is not None and len(value) > self.max_length:
+            raise ValidationError(
+                f"Must be at most {self.max_length} characters long.",
+                value=value,
+            )
+        
+        return value
+    
+    def __repr__(self):
+        return (
+            f"StringValidator("
+            f"min_length={self.min_length!r}, "
+            f"max_length={self.max_length!r}, "
+            f"strip={self.strip!r})"
+        )
+
+class IntValidator(Validator):
+    """Validates that a value is an integer, with optional range constraints.
+
+    Parameters
+    ----------
+    min_value : int or None
+        Minimum allowed value. None means no minimum.
+    max_value : int or None
+        Maximum allowed value. None means no maximum.
+    coerce : bool
+        If True, attempt to convert strings to int before validating.
+        Defaults to False.
+
+    Example
+    -------
+        v = IntValidator(min_value=0, max_value=120)
+        v.validate(25)    # returns 25
+        v.validate(-1)    # raises ValidationError
+    """
+    
+    def __init__(self, *, min_value=None, max_value=None, coerce=False):
+        self.min_value=min_value
+        self.max_value=max_value
+        self.coerce=coerce
+    
+    def validate(self, value):
+        if self.coerce and not isinstance(value,int):
+            try:
+                value = int(value)
+            except(ValueError, TypeError):
+                raise ValidationError(
+                    f"Could not convert {value!r} to int",
+                    value=value
+                )
+        if not isinstance(value, int) or isinstance(value,bool):
+            raise ValidationError(
+                f"Expected an integer, got {type(value).__name__}.",
+                value=value
+            )
+        if self.min_value is not None and value < self.min_value:
+            raise ValidationError(
+                f"Must be at least {self.min_value}.",
+                value=value,
+            )
+
+        if self.max_value is not None and value > self.max_value:
+            raise ValidationError(
+                f"Must be at most {self.max_value}.",
+                value=value,
+            )
+        return value
+    
+    def __repr__(self):
+        return (
+            f"IntValidator("
+            f"min_value={self.min_value!r}, "
+            f"max_value={self.max_value!r}, "
+            f"coerce={self.coerce!r})"
+        )
+
+class FloatValidator(Validator):
+    """ Validates that a value is float, with optional range values. 
+    
+    Parameters
+    ----------
+    min_value : float or None
+        Minimum allowed value. None means no minimum.
+    max_value : float or None
+        Maximum allowed value. None means no maximum.
+    coerce : bool
+        If True, attempt to convert strings and ints to float.
+        Defaults to False.
+
+    Example
+    -------
+        v = FloatValidator(min_value=0.0, max_value=1.0)
+        v.validate(0.5)   # returns 0.5
+        v.validate(1.5)   # raises ValidationError
+    """
+    
+    def __init__(self, *, min_value=None, max_value=None, coerce=False):
+        self.min_value=min_value
+        self.max_value=max_value
+        self.coerce=coerce
+        
+    def validate(self,value):
+        if self.coerce and not isinstance(value,float):
+            try:
+                value=float(value)
+            except(ValueError, TypeError):
+                raise ValidationError(
+                    f"Could not convert {value!r} to float",
+                    value=value
+                )    
+        
+        if not isinstance(value, (int,float)) or isinstance(value,bool):
+            raise ValidationError(
+                f"Expected a float, got {type(value).__name__}.",
+                value=value
+            )
+        
+        value= float(value)
+        
+        if self.min_value is not None and value<self.min_value:
+            raise ValidationError(
+                f"Must be at least {self.min_value}",
+                value=value,
+            )
+        
+        if self.max_value is not None and value>self.max_value:
+            raise ValidationError(
+                f"Must be at most {self.max_value}",
+                value=value
+            )
+        
+        return value
+    
+    def __repr__(self):
+        return (
+            f"FloatValidator("
+            f"min_value={self.min_value!r}, "
+            f"max_value={self.max_value!r}, "
+            f"coerce={self.coerce!r})"
+        )
+
+class BoolValidator(Validator):
+    """ Validates that a value is boolean. 
+    
+    Parameters
+    ----------
+    coerce : bool
+        If True, accept truthy strings like 'true', 'false', '1', '0'.
+        Defaults to False.
+
+    Example
+    -------
+        v = BoolValidator()
+        v.validate(True)     # returns True
+        v.validate("true")   # raises ValidationError unless coerce=True
+    
+    """
+    
+    # Accepted string values while coercing - 
+    _TRUTH_VALUES = {"true","1","yes"}
+    _FALSE_VALUES = {"false","0","no"}
+    
+    def __init__(self,*,coerce=False):
+        self.coerce= coerce
+
+    def validate(self, value):
+        if self.coerce and isinstance(value,str):
+            lowered = value.lower()
+            if lowered in self._TRUTH_VALUES:
+                return True
+            if lowered in self._FALSE_VALUES:
+                return False
+            raise ValidationError(
+                f"Cannot coerce {value!r} to boolean",
+                value=value,
+            )
+        
+        if not isinstance(value,bool):
+            raise ValidationError(
+                F"Expected a boolean, got {type(value).__name__}.",
+                value=value,
+            )
+            
+        return value
+    
+    def __repr__(self):
+        return f"BoolValidator(coerce={self.coerce!r})"
+
+class EmailValidator(Validator):
+    """ Validates that a value is valid email address. 
+    
+    This validator checks format only — it does not send a confirmation
+    email or verify the address exists. This is intentional: full email
+    verification requires network access, which a validator should never do.
+
+    Example
+    -------
+        v = EmailValidator()
+        v.validate("alice@example.com")   # returns "alice@example.com"
+        v.validate("not-an-email")        # raises ValidationError
+    """
+    
+    # Email regex - 
+    _EMAIL_REGEX = re.compile(
+        r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+    )
+    
+    def validate(self,value):
+        if not isinstance(value,str):
+            raise ValidationError(
+                f"Expected a string, got {type(value).__name__}",
+                value=value,
+            )
+        value = value.strip().lower()
+        
+        if not self._EMAIL_REGEX.match(value):
+            raise ValidationError(
+                f"{value!r} is not a valid email address",
+                value=value,
+            )
+        
+        return value
+    
+    def __repr__(self):
+        return "EmailValidator()"
+    
+    

valify-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: valify
+Version: 0.1.0
+Summary: A composable, expressive data validation library for python
+Author-email: Darshan Bamankar <darshanbamankar7@gmail.com>
+Keywords: validation,schema,data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# valify
+
+A composable, expressive data validation library for Python.
+
+## Installation
+
+```bash
+pip install valify
+```
+
+## Quick Start
+
+```python
+from valify import Schema, StringValidator, IntValidator, EmailValidator
+
+schema = Schema({
+    "name":  StringValidator(min_length=2, max_length=50),
+    "age":   IntValidator(min_value=0, max_value=120),
+    "email": EmailValidator(),
+})
+
+# Valid data — returns cleaned, validated dictionary
+result = schema.validate({
+    "name":  "Alice",
+    "age":   30,
+    "email": "alice@example.com",
+})
+print(result)
+# {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}
+
+# Invalid data — raises ValidationError with ALL errors at once
+schema.validate({
+    "name":  "A",
+    "age":   -5,
+    "email": "not-an-email",
+})
+# ValidationError: Validation failed:
+#   name: Must be at least 2 characters long.
+#   age: Must be at least 0.
+#   email: 'not-an-email' is not a valid email address.
+```
+
+## Validators
+
+| Validator | What it checks |
+|-----------|---------------|
+| `StringValidator` | Strings, with optional min/max length |
+| `IntValidator` | Integers, with optional min/max value |
+| `FloatValidator` | Floats, with optional min/max value |
+| `BoolValidator` | Booleans, with optional string coercion |
+| `EmailValidator` | Email address format |
+
+## Validators in Detail
+
+### StringValidator
+
+```python
+from valify import StringValidator
+
+v = StringValidator(
+    min_length=2,   # minimum character length
+    max_length=50,  # maximum character length
+    strip=True,     # strip whitespace before validating (default: True)
+)
+```
+
+### IntValidator
+
+```python
+from valify import IntValidator
+
+v = IntValidator(
+    min_value=0,    # minimum allowed value
+    max_value=120,  # maximum allowed value
+    coerce=False,   # if True, converts "42" -> 42 (default: False)
+)
+```
+
+### EmailValidator
+
+```python
+from valify import EmailValidator
+
+v = EmailValidator()
+v.validate("alice@example.com")  # returns "alice@example.com"
+```
+
+## Using Validators Standalone
+
+Validators work without a Schema too:
+
+```python
+from valify import IntValidator
+from valify.exceptions import ValidationError
+
+v = IntValidator(min_value=0)
+
+try:
+    v.validate(-1)
+except ValidationError as e:
+    print(e.message)  # Must be at least 0.
+    print(e.value)    # -1
+```
+
+## Error Handling
+
+```python
+from valify.exceptions import (
+    ValifyError,        # base — catches everything
+    ValidationError,    # a value failed validation
+    RequiredFieldError, # a required field was missing
+    SchemaError,        # the schema definition is invalid
+)
+```
+
+## License
+
+MIT

valify-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+valify/__init__.py,sha256=-Iyb_hy58FcbwMuN7UsWctgTwDpLHEgYEj0LB4SPLAg,1264
+valify/exceptions.py,sha256=dehW1gztmUInK5-DO369LK4B3RJvDoYLLypL5Wmj6_k,1355
+valify/schema.py,sha256=wPLNlNB474-B6Y3PaunY4vhobkrmoCj0dZpyEYuQiXg,4004
+valify/validators.py,sha256=KIpJ5HfMSIZWolNwEHlJ9yRIECxCs5jrWjGNCLp5KDw,10116
+valify-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valify-0.1.0.dist-info/METADATA,sha256=p8IekDMQ0Qa9qthoBoZ33M0fo8IgU8XlbD-YWMQKbfA,3332
+valify-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+valify-0.1.0.dist-info/top_level.txt,sha256=Ab4qZC-SoZbiGgMW5aXD9WjMBvu_oBEqgEmjwhu2h7o,7
+valify-0.1.0.dist-info/RECORD,,

valify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

valify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+valify