sqlalchemy-serializer-meta 0.3.0__tar.gz → 1.0.0__tar.gz

{sqlalchemy_serializer_meta-0.3.0/sqlalchemy_serializer_meta.egg-info → sqlalchemy_serializer_meta-1.0.0}/PKG-INFO

@@ -1,24 +1,39 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sqlalchemy_serializer_meta
-Version: 0.3.0
-Summary: A simple serializer for SQLAlchemy models and Flask Models
-Home-page: https://github.com/Wehda23/sqlalchemy_serializer_meta
-Author: Waheed Khaled Elhariri
-Author-email: waheedkhaled95@gmail.com
+Version: 1.0.0
+Summary: High-performance DRF-style serializer for SQLAlchemy and Flask models with Pydantic v2 validation
+Author-email: Waheed Khaled Elhariri <waheedkhaled95@gmail.com>
 License: MIT
-Keywords: sqlalchemy serializer pydantic flask
-Classifier: Development Status :: 4 - Beta
+Project-URL: Homepage, https://github.com/Wehda23/sqlalchemy_serializer_meta
+Project-URL: Repository, https://github.com/Wehda23/sqlalchemy_serializer_meta
+Project-URL: Issues, https://github.com/Wehda23/sqlalchemy_serializer_meta/issues
+Keywords: sqlalchemy,serializer,pydantic,flask,drf,rest,orm
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 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 :: Libraries :: Python Modules
+Classifier: Framework :: Flask
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlalchemy
-Requires-Dist: pydantic==2.7.4
-Requires-Dist: pydantic_core==2.18.4
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing_extensions>=4.6.0; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: Flask>=2.0.0; extra == "dev"
+Requires-Dist: Flask-SQLAlchemy>=3.0.0; extra == "dev"
+Dynamic: license-file
 
 # Serializer Module for Flask Application
 

sqlalchemy_serializer_meta-1.0.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlalchemy_serializer_meta"
+version = "1.0.0"
+description = "High-performance DRF-style serializer for SQLAlchemy and Flask models with Pydantic v2 validation"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Waheed Khaled Elhariri", email = "waheedkhaled95@gmail.com" }
+]
+requires-python = ">=3.9"
+keywords = ["sqlalchemy", "serializer", "pydantic", "flask", "drf", "rest", "orm"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Framework :: Flask",
+]
+dependencies = [
+    "sqlalchemy>=1.4.0",
+    "pydantic>=2.0.0",
+    "typing_extensions>=4.6.0; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+    "Flask>=2.0.0",
+    "Flask-SQLAlchemy>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Wehda23/sqlalchemy_serializer_meta"
+Repository = "https://github.com/Wehda23/sqlalchemy_serializer_meta"
+Issues = "https://github.com/Wehda23/sqlalchemy_serializer_meta/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sqlalchemy_serializer_meta*"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q --strict-markers"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+ignore = ["E501"]

sqlalchemy_serializer_meta-1.0.0/setup.cfg

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

sqlalchemy_serializer_meta-1.0.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

sqlalchemy_serializer_meta-1.0.0/sqlalchemy_serializer_meta/__init__.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+"""
+sqlalchemy_serializer_meta
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A fast, flexible DRF-style serializer for SQLAlchemy and Flask models with Pydantic v2 validation.
+"""
+
+from .compat import Self
+from .exceptions import SerializerError, ValidationError
+from .fields import Field, SerializerMethodField
+from .serializer import (
+    AbstractSerializer,
+    Creatable,
+    Deletable,
+    ExtendsPydantic,
+    ModelSerializer,
+    Representable,
+    Saveable,
+    Serializer,
+    SerializerInterface,
+    ToInstance,
+    Updatable,
+    Validatable,
+)
+from .transformers import to_jsonable_python
+from .validator import BaseValidator
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "AbstractSerializer",
+    "BaseValidator",
+    "Creatable",
+    "Deletable",
+    "ExtendsPydantic",
+    "Field",
+    "ModelSerializer",
+    "Representable",
+    "Saveable",
+    "Self",
+    "Serializer",
+    "SerializerError",
+    "SerializerInterface",
+    "SerializerMethodField",
+    "ToInstance",
+    "Updatable",
+    "Validatable",
+    "ValidationError",
+    "to_jsonable_python",
+]

sqlalchemy_serializer_meta-1.0.0/sqlalchemy_serializer_meta/compat.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+"""
+Compatibility helpers across Python and dependency versions.
+"""
+
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+__all__ = ["Self"]

sqlalchemy_serializer_meta-1.0.0/sqlalchemy_serializer_meta/exceptions.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+"""
+Custom exception hierarchy for serializers and validation.
+"""
+
+from typing import Any, Optional
+
+
+class SerializerError(Exception):
+    """
+    Standard serializer exception.
+
+    Supports both conventional exception signatures and legacy two-argument signatures:
+    - raise SerializerError("Error message")
+    - raise SerializerError(ValueError, "Error message")
+    - raise SerializerError("Error message", field="email", code="invalid")
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        field: Optional[str] = None,
+        code: str = "invalid",
+    ) -> None:
+        super().__init__(*args)
+        self.field = field
+        self.code = code
+        self.exception_class: Optional[type] = None
+
+        if len(args) == 1:
+            self.message = str(args[0])
+            self.exception_class = self.__class__
+        elif len(args) >= 2:
+            first, second = args[0], args[1]
+            if isinstance(first, type) and issubclass(first, BaseException):
+                self.exception_class = first
+                self.message = str(second)
+            else:
+                self.message = str(second)
+                self.exception_class = self.__class__
+        else:
+            self.message = "Serializer error"
+            self.exception_class = self.__class__
+
+    def to_dict(self) -> dict:
+        type_name = self.exception_class.__name__ if self.exception_class else self.__class__.__name__
+        res = {
+            "msg": self.message,
+            "type": type_name,
+            "code": self.code,
+        }
+        if self.field:
+            res["field"] = self.field
+        return res
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class ValidationError(SerializerError):
+    """
+    Validation error raised when data fails schema or field-level constraints.
+    """
+
+    def __init__(
+        self,
+        detail: Any,
+        field: Optional[str] = None,
+        code: str = "invalid",
+    ) -> None:
+        if isinstance(detail, (dict, list)):
+            self.detail = detail
+            super().__init__(str(detail), field=field, code=code)
+        else:
+            self.detail = str(detail)
+            super().__init__(str(detail), field=field, code=code)

sqlalchemy_serializer_meta-1.0.0/sqlalchemy_serializer_meta/fields.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+"""
+Field definitions and special serializer descriptors.
+"""
+
+from typing import Any, Callable, Optional
+
+
+class Field:
+    """
+    Base representation of a serializer field.
+    """
+
+    def __init__(
+        self,
+        source: Optional[str] = None,
+        read_only: bool = False,
+        write_only: bool = False,
+        required: bool = True,
+        default: Any = None,
+    ) -> None:
+        self.source = source
+        self.read_only = read_only
+        self.write_only = write_only
+        self.required = required
+        self.default = default
+        self.field_name: Optional[str] = None
+
+    def bind(self, field_name: str) -> None:
+        self.field_name = field_name
+        if self.source is None:
+            self.source = field_name
+
+    def get_attribute(self, instance: Any) -> Any:
+        if self.source:
+            return getattr(instance, self.source, self.default)
+        return self.default
+
+
+class SerializerMethodField(Field):
+    """
+    Read-only field that gets its value by calling a method on the serializer class.
+    Method defaults to `get_<field_name>(instance)`.
+    """
+
+    def __init__(self, method_name: Optional[str] = None) -> None:
+        super().__init__(read_only=True, required=False)
+        self.method_name = method_name
+
+    def bind(self, field_name: str) -> None:
+        super().bind(field_name)
+        if self.method_name is None:
+            self.method_name = f"get_{field_name}"
+
+    def to_representation(self, serializer: Any, instance: Any) -> Any:
+        method: Optional[Callable] = getattr(serializer, self.method_name, None)
+        if method is None or not callable(method):
+            raise AttributeError(
+                f"Serializer '{serializer.__class__.__name__}' is missing method '{self.method_name}'"
+            )
+        return method(instance)