tissuebox 2.0.1__py3-none-any.whl

tissuebox/__init__.py

@@ -0,0 +1,312 @@
+from tissuebox.basic import array, boolean, complex_number, dictionary, integer, null, numeric, string, required
+from tissuebox.helpers import exists, kgattr, sattr
+
+
+class SchemaError(BaseException):
+    pass
+
+
+def sort_unique(l):
+    l[:] = sorted(set(l))
+
+
+def normalise(schema, start=None):
+    if start is None:
+        start = []
+
+    if type(schema) in [list, tuple, set]:
+        for s in schema:
+            normalise(s, start + [s])
+
+    if type(schema) is dict:
+        if "*" in schema and len(schema) > 1:
+            raise SchemaError(
+                "Can't normalise {} as it contains more keys {} than expected".format(start + ["*"], [k for k in schema.keys() if k != "*"])
+            )
+
+        # Track array vs dict keys
+        array_keys = set()
+        dict_keys = set()
+
+        # First detect any conflicts
+        for k in schema.keys():
+            if "." not in k:
+                continue
+
+            parts = k.split(".")
+            base_key = parts[0]
+
+            if base_key.startswith("[") and base_key.endswith("]"):
+                array_keys.add(base_key[1:-1])  # Remove brackets
+            else:
+                dict_keys.add(base_key)
+
+        # Check for conflicts
+        conflicts = array_keys.intersection(dict_keys)
+        if conflicts:
+            raise SchemaError("Ambiguous schema: '{}' is used both as array and dict pattern".format(list(conflicts)[0]))
+
+        # First pass - identify array patterns and group their fields
+        array_fields = {}  # Will store array_key -> fields mapping
+
+        for k in list(schema.keys()):
+            if "." not in k:
+                continue
+
+            parts = k.split(".")
+            if not parts[0].startswith("["):
+                # Handle regular dot notation
+                try:
+                    sch = schema
+                    sofar = []
+                    for s in parts[:-1]:
+                        if s in sch:
+                            sch = sch[s]
+                        else:
+                            sch[s] = {}
+                            sch = sch[s]
+                        sofar.append(s)
+                    sch[parts[-1]] = schema[k]
+                    del schema[k]
+                except TypeError:
+                    raise SchemaError("Can't normalise {} as it conflicts with existing structure".format(k))
+                continue
+
+            # Get the first array key
+            array_key = parts[0][1:-1]  # Remove brackets
+
+            if array_key not in array_fields:
+                array_fields[array_key] = {}
+
+            # Remove the first array part and store remaining path
+            remaining_path = ".".join(parts[1:])
+            array_fields[array_key][remaining_path] = schema[k]
+            del schema[k]
+
+        # Second pass - process each array pattern
+        for array_key, fields in array_fields.items():
+            if array_key not in schema:
+                schema[array_key] = [{}]
+
+            # Group nested array fields
+            nested_arrays = {}
+            regular_fields = {}
+
+            for field_path, value in fields.items():
+                if "." not in field_path:
+                    regular_fields[field_path] = value
+                    continue
+
+                parts = field_path.split(".")
+                if parts[0].startswith("["):
+                    nested_key = parts[0][1:-1]
+                    if nested_key not in nested_arrays:
+                        nested_arrays[nested_key] = {}
+                    nested_arrays[nested_key][".".join(parts[1:])] = value
+                else:
+                    regular_fields[field_path] = value
+
+            # Add regular fields to array schema
+            for field, value in regular_fields.items():
+                if "." in field:
+                    parts = field.split(".")
+                    current = schema[array_key][0]
+                    for part in parts[:-1]:
+                        if part not in current:
+                            current[part] = {}
+                        current = current[part]
+                    current[parts[-1]] = value
+                else:
+                    schema[array_key][0][field] = value
+
+            # Process nested arrays recursively
+            for nested_key, nested_fields in nested_arrays.items():
+                nested_schema = {"[" + nested_key + "]." + k: v for k, v in nested_fields.items()}
+                normalised = normalise(nested_schema)
+                schema[array_key][0].update(normalised)
+
+    return schema
+
+
+primitives = {
+    int: integer,
+    str: string,
+    bool: boolean,
+    float: numeric,
+    list: array,
+    set: array,
+    tuple: array,
+    dict: dictionary,
+    None: null,
+    complex: complex_number,
+}
+
+
+def decorate(payload):
+    # Decorate the payload, i.e if string add quotations, if list add brackets
+    if type(payload) is str:
+        return "'{}'".format(payload)
+    return payload
+
+
+def msg(schema):
+    # Returns human-friendly validation error message for schema type using .msg attribute (e.g. "must be integer", "must be null", etc.)
+    if schema is None:
+        return "null"
+    if is_primitive_value(schema):
+        return str(schema)
+    if is_primitive_type(schema):
+        schema = primitives[schema]
+    return schema.msg
+
+
+def is_primitive_value(schema):
+    global primitives
+    return type(schema) in primitives
+
+
+def is_primitive_type(schema):
+    global primitives
+    return schema in primitives
+
+
+def is_valid_schema(schema):
+    global primitives
+
+    # Handle collections
+    if type(schema) in (set, list, tuple):
+        return all([is_valid_schema(s) for s in schema])
+
+    # Handle dictionaries
+    if type(schema) is dict:
+        # If dict has "*", it should be the only key
+        if "*" in schema and len(schema) > 1:
+            return False
+        # Recursively validate all values in dict
+        return all(is_valid_schema(v) for v in schema.values())
+
+    # Handle primitives and tissue functions
+    if type(schema) in primitives:
+        return True
+
+    if schema in primitives:
+        return True
+
+    if callable(schema) and getattr(schema, "msg", None):
+        return True
+
+    return False
+
+
+def validate(schema, payload, errors=None):
+    if errors is None:
+        errors = []
+
+    if not is_valid_schema(schema):
+        raise SchemaError("Schema is invalid, Use SchemaInspector to debug the schema")
+
+    normalise(schema)
+
+    if type(schema) is dict:
+        if type(payload) is not dict:
+            errors.append("must be dict")
+            return False
+
+        # Handle wildcard schema
+        if "*" in schema:
+            wildcard_schema = schema["*"]
+            for key, value in payload.items():
+                E = []
+                validate(wildcard_schema, value, E)
+                for e in E:
+                    errors.append("['{}']{}".format(key, e))
+            sort_unique(errors)
+            return not errors
+
+        # First check for required fields
+        for k, v in schema.items():
+            if type(k) is str:
+                validator = v[0] if type(v) is tuple else v
+                if validator == required and k not in payload:
+                    errors.append("['{}'] is required".format(k))
+
+        # Then validate present fields
+        for k in schema:
+            if type(k) is str and k in payload:
+                E = []
+                validator = schema[k]
+
+                # If it's a tuple of (required, type), use the type
+                if type(validator) is tuple and validator[0] == required:
+                    validator = validator[1]
+
+                # Skip validation if it's just required
+                if validator != required:
+                    validate(validator, payload.get(k), E)
+                    for e in E:
+                        errors.append("['{}']{}".format(k, e))
+
+        sort_unique(errors)
+        return not errors
+
+    elif type(schema) is list:
+        if type(payload) is not list:
+            errors.append("{} must be list".format(payload))
+            return False
+
+        if len(schema) > 1:
+            schema = [set(schema)]
+
+        for i, p in enumerate(payload):
+            E = []
+            validate(schema[0], p, E)
+            for e in E:
+                errors.append("[{}]{}".format(i, e))
+        return not errors
+
+    elif type(schema) is set:
+        schema = list(schema)
+        if not any([validate(s, payload) for s in schema]):
+            if len(schema) > 1:
+                labels = sorted([msg(s) for s in schema])
+                errors.append(" must be either {} or {} (but {})".format(", ".join(labels[:-1]), labels[-1], payload))
+            else:
+                errors.append("{} must be {}".format(payload, msg(schema[0])))
+        sort_unique(errors)
+        return not errors
+
+    elif type(schema) is tuple:
+        # If first element is required, validate rest
+        if len(schema) > 0 and schema[0] == required:
+            if len(schema) > 1:
+                return validate(schema[1], payload, errors)
+            return True
+
+        # Otherwise validate all
+        all_valid = True
+        for s in schema:
+            if not validate(s, payload):
+                errors.append("{} must be {}".format(payload, msg(s)))
+                all_valid = False
+        sort_unique(errors)
+        return all_valid
+
+    else:
+        if schema in primitives:
+            schema = primitives[schema]
+
+        # Just return True if schema is required
+        if schema == required:
+            return True
+
+        result = False
+        if callable(schema):
+            result = schema(payload)
+        elif is_primitive_value(schema):
+            result = schema == payload
+
+        if not result:
+            errors.append(" must be {} (but {})".format(msg(schema), decorate(payload)))
+
+    sort_unique(errors)
+    return not errors

tissuebox/basic.py

@@ -0,0 +1,548 @@
+import re
+from datetime import datetime
+from decimal import Decimal
+from ipaddress import ip_address
+from urllib.parse import urlparse
+
+
+# Existing core type validators
+def integer(x):
+    if isinstance(x, bool):
+        return False
+    return isinstance(x, int)
+
+
+integer.msg = "integer"
+
+
+def numeric(x):
+    if isinstance(x, bool):
+        return False
+    return isinstance(x, (int, float, Decimal))
+
+
+numeric.msg = "numeric"
+
+
+def complex_number(x):
+    return isinstance(x, complex)
+
+
+complex_number.msg = "complex number"
+
+
+def string(x):
+    return isinstance(x, str)
+
+
+string.msg = "string"
+
+
+def array(x):
+    return isinstance(x, list)
+
+
+array.msg = "list"
+
+
+def dictionary(x):
+    return isinstance(x, dict)
+
+
+dictionary.msg = "dictionary"
+
+
+def boolean(x):
+    return isinstance(x, bool)
+
+
+boolean.msg = "boolean"
+
+
+def null(x):
+    return x is None
+
+
+null.msg = "null"
+
+
+# Enhanced string validators
+def length(min_len=None, max_len=None):
+    """Validate string length is within range"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        if min_len is not None and len(x) < min_len:
+            return False
+        if max_len is not None and len(x) > max_len:
+            return False
+        return True
+
+    msg_parts = []
+    if min_len is not None:
+        msg_parts.append(f"at least {min_len} characters")
+    if max_len is not None:
+        msg_parts.append(f"at most {max_len} characters")
+
+    validator.msg = f"string with {' and '.join(msg_parts)}"
+    return validator
+
+
+def pattern(regex, flags=0):
+    """Validate string matches regex pattern"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        return bool(re.match(regex, x, flags))
+
+    validator.msg = f"string matching pattern {regex}"
+    return validator
+
+
+def alpha():
+    """Validate string contains only letters"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        return x.isalpha()
+
+    validator.msg = "string containing only letters"
+    return validator
+
+
+def alphanumeric():
+    """Validate string contains only letters and numbers"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        return x.isalnum()
+
+    validator.msg = "string containing only letters and numbers"
+    return validator
+
+
+def lowercase():
+    """Validate string is lowercase"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        return x.islower()
+
+    validator.msg = "lowercase string"
+    return validator
+
+
+def uppercase():
+    """Validate string is uppercase"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        return x.isupper()
+
+    validator.msg = "uppercase string"
+    return validator
+
+
+# Number validators
+def positive(x):
+    """Validate number is positive"""
+    if not numeric(x):
+        return False
+    return x > 0
+
+
+positive.msg = "positive number"
+
+
+def negative(x):
+    """Validate number is negative"""
+    if not numeric(x):
+        return False
+    return x < 0
+
+
+negative.msg = "negative number"
+
+
+def between(min_val=None, max_val=None):
+    """Validate number is within range"""
+
+    def validator(x):
+        if not numeric(x):
+            return False
+        if min_val is not None and x < min_val:
+            return False
+        if max_val is not None and x > max_val:
+            return False
+        return True
+
+    msg_parts = []
+    if min_val is not None:
+        msg_parts.append(f"greater than or equal to {min_val}")
+    if max_val is not None:
+        msg_parts.append(f"less than or equal to {max_val}")
+
+    validator.msg = f"number {' and '.join(msg_parts)}"
+    return validator
+
+
+def even(x):
+    """Validate number is even"""
+    if not integer(x):
+        return False
+    return x % 2 == 0
+
+
+even.msg = "even number"
+
+
+def odd(x):
+    """Validate number is odd"""
+    if not integer(x):
+        return False
+    return x % 2 != 0
+
+
+odd.msg = "odd number"
+
+
+# Date and time validators
+def iso_date(x):
+    """Validate string is ISO format date"""
+    if not isinstance(x, str):
+        return False
+    try:
+        datetime.fromisoformat(x)
+        return True
+    except ValueError:
+        return False
+
+
+iso_date.msg = "ISO format date string (YYYY-MM-DD)"
+
+
+def future_date():
+    """Validate date is in the future"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        try:
+            date = datetime.fromisoformat(x)
+            return date > datetime.now()
+        except ValueError:
+            return False
+
+    validator.msg = "future date"
+    return validator
+
+
+def past_date():
+    """Validate date is in the past"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+        try:
+            date = datetime.fromisoformat(x)
+            return date < datetime.now()
+        except ValueError:
+            return False
+
+    validator.msg = "past date"
+    return validator
+
+
+# Array validators
+def min_length(min_len):
+    """Validate array has minimum length"""
+
+    def validator(x):
+        if not array(x):
+            return False
+        return len(x) >= min_len
+
+    validator.msg = f"array with at least {min_len} items"
+    return validator
+
+
+def max_length(max_len):
+    """Validate array has maximum length"""
+
+    def validator(x):
+        if not array(x):
+            return False
+        return len(x) <= max_len
+
+    validator.msg = f"array with at most {max_len} items"
+    return validator
+
+
+# Web-related validators
+def email(x):
+    """Validate email address"""
+    if not isinstance(x, str):
+        return False
+    pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+    return bool(re.match(pattern, x))
+
+
+email.msg = "valid email address"
+
+
+def url(x):
+    """Validate URL"""
+    if not isinstance(x, str):
+        return False
+    try:
+        result = urlparse(x)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+
+url.msg = "valid URL"
+
+
+def ip_address_str(x):
+    """Validate IP address (v4 or v6)"""
+    if not isinstance(x, str):
+        return False
+    try:
+        ip_address(x)
+        return True
+    except ValueError:
+        return False
+
+
+ip_address_str.msg = "valid IP address"
+
+
+def ipv4(x):
+    """Validate IPv4 address"""
+    if not isinstance(x, str):
+        return False
+    try:
+        addr = ip_address(x)
+        return addr.version == 4
+    except ValueError:
+        return False
+
+
+ipv4.msg = "valid IPv4 address"
+
+
+def ipv6(x):
+    """Validate IPv6 address"""
+    if not isinstance(x, str):
+        return False
+    try:
+        addr = ip_address(x)
+        return addr.version == 6
+    except ValueError:
+        return False
+
+
+ipv6.msg = "valid IPv6 address"
+
+
+def hostname(x):
+    """Validate hostname"""
+    if not isinstance(x, str):
+        return False
+    if len(x) > 255:
+        return False
+    pattern = r"^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
+    return bool(re.match(pattern, x))
+
+
+hostname.msg = "valid hostname"
+
+
+# Specialized string validators
+def uuid4(x):
+    """Validate UUID v4"""
+    if not isinstance(x, str):
+        return False
+    pattern = r"^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+    return bool(re.match(pattern, x, re.I))
+
+
+uuid4.msg = "valid UUID v4"
+
+
+def slug(x):
+    """Validate slug (URL-friendly string)"""
+    if not isinstance(x, str):
+        return False
+    pattern = r"^[a-z0-9]+(?:-[a-z0-9]+)*$"
+    return bool(re.match(pattern, x))
+
+
+slug.msg = "valid slug (lowercase letters, numbers, hyphens)"
+
+
+def hex_color(x):
+    """Validate hex color code"""
+    if not isinstance(x, str):
+        return False
+    pattern = r"^#(?:[0-9a-fA-F]{3}){1,2}$"
+    return bool(re.match(pattern, x))
+
+
+hex_color.msg = "valid hex color code"
+
+
+def credit_card(x):
+    """Validate credit card number using Luhn algorithm"""
+    if not isinstance(x, str):
+        return False
+
+    # Remove spaces and hyphens
+    x = x.replace(" ", "").replace("-", "")
+
+    if not x.isdigit():
+        return False
+
+    # Luhn algorithm
+    digits = [int(d) for d in x]
+    for i in range(len(digits) - 2, -1, -2):
+        digits[i] *= 2
+        if digits[i] > 9:
+            digits[i] -= 9
+
+    return sum(digits) % 10 == 0
+
+
+credit_card.msg = "valid credit card number"
+
+
+def phone(country_code=None):
+    """Validate phone number"""
+
+    def validator(x):
+        if not isinstance(x, str):
+            return False
+
+        # Remove common separators
+        x = re.sub(r"[\s\-\(\)]", "", x)
+
+        if country_code == "US":
+            pattern = r"^\+?1?\d{10}$"
+        else:
+            # Generic international format
+            pattern = r"^\+?[1-9]\d{1,14}$"
+
+        return bool(re.match(pattern, x))
+
+    validator.msg = "valid phone number"
+    if country_code:
+        validator.msg += f" ({country_code} format)"
+    return validator
+
+
+def strong_password(x):
+    min_length = 8
+
+    if not isinstance(x, str):
+        return False
+
+    if len(x) < min_length:
+        return False
+
+    # Check for at least one uppercase, lowercase, and digit
+    if not (any(c.isupper() for c in x) and any(c.islower() for c in x) and any(c.isdigit() for c in x)):
+        return False
+
+    return True
+
+
+strong_password.msg = "password with minimum length 8, mixed case, numbers and special characters"
+
+
+# Data format validators
+def json_string(x):
+    """Validate JSON string"""
+    if not isinstance(x, str):
+        return False
+    try:
+        import json
+
+        json.loads(x)
+        return True
+    except ValueError:
+        return False
+
+
+json_string.msg = "valid JSON string"
+
+
+def base64(x):
+    """Validate base64 string"""
+    if not isinstance(x, str):
+        return False
+    pattern = r"^[A-Za-z0-9+/]*={0,2}$"
+    return bool(re.match(pattern, x))
+
+
+base64.msg = "valid base64 string"
+
+
+# Geographic validators
+def latitude(x):
+    """Validate latitude"""
+    if not numeric(x):
+        return False
+    return -90 <= float(x) <= 90
+
+
+latitude.msg = "valid latitude (-90 to 90)"
+
+
+def longitude(x):
+    """Validate longitude"""
+    if not numeric(x):
+        return False
+    return -180 <= float(x) <= 180
+
+
+longitude.msg = "valid longitude (-180 to 180)"
+
+
+# Required field validator (existing)
+def required(x):
+    """Required field validator - always returns True as it just checks presence"""
+    return True
+
+
+required.msg = "required"
+
+
+def lt(n):
+    def lt(x):
+        return x < n
+
+    lt.msg = f"less than {n}"
+    return lt
+
+
+def gt(n):
+    def gt(x):
+        return x < n
+
+    gt.msg = f"greater than {n}"
+    return lt
+
+
+def divisible(n):
+    def divisible(x):
+        return numeric(x) and numeric(n) and x % n == 0
+
+    divisible.msg = f"multiple of {n}"
+    return divisible

tissuebox/helpers.py

@@ -0,0 +1,33 @@
+import re
+
+
+def exists(d, attrs):
+    try:
+        for at in attrs:
+            d = d[at]
+        return True
+    except (KeyError, TypeError):
+        return False
+
+
+def sattr(d, *attrs):
+    try:
+        for attr in attrs[:-2]:
+            if type(d.get(attr)) is not dict:
+                d[attr] = {}
+                # raise Exception("Overriding Attempt")
+            d = d[attr]
+        d[attrs[-2]] = attrs[-1]
+    except IndexError:
+        print()
+
+
+def kgattr(d, sofar, *attrs):
+    # gattr but very strict, tries to go nested, upon KeyError return the sofar list.
+    for at in attrs:
+        sofar.append(at)
+        d = d[at]
+
+
+def regex_in(r, l):
+    return bool(list(filter(re.compile(r).match, l)))

tissuebox-2.0.1.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: tissuebox
+Version: 2.0.1
+Summary: Tissuebox :: Pythonic payload validator
+Home-page: https://github.com/n3h3m/tissuebox.git
+Author: nehemiah
+Author-email: nehemiah.jacob@gmail.com
+Description-Content-Type: text/x-rst

tissuebox-2.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+tissuebox/__init__.py,sha256=_J6gsxKl4FOdkVBx7uL-4BcobprQAJSgMRMgUIuki3Q,9868
+tissuebox/basic.py,sha256=cSjEe212tFP9tmnr8Tofy5y1aY0Bo_lQhtaYYtl98Ks,10883
+tissuebox/helpers.py,sha256=uxy4lXYgnsgUD6MbfSvPMuf0VgDuzbnPk91f3MdbxuU,715
+tissuebox-2.0.1.dist-info/METADATA,sha256=FW61bfyNjLRMTo56S18vzlwj7UrAlAaZ88-CpyRgewg,245
+tissuebox-2.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+tissuebox-2.0.1.dist-info/top_level.txt,sha256=5jrIChUwF7yCKAWFnbzybiDZD8HRXPKPMK84p14aj_4,10
+tissuebox-2.0.1.dist-info/RECORD,,

tissuebox-2.0.1.dist-info/WHEEL

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

tissuebox-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tissuebox