schemap 0.1.0__tar.gz

schemap-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: schemap
+Version: 0.1.0
+Summary: Automatic Pydantic Schemas for SQLAlchemy models
+Author-email: Emiliano Gandini Outeda <emiliano.gandini@protonmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/emiliano-gandini-outeda/schemap
+Project-URL: Repository, https://github.com/emiliano-gandini-outeda/schemap
+Project-URL: Issues, https://github.com/emiliano-gandini-outeda/schemap/issues
+Keywords: python,schemas,models,orm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12.7
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: sqlalchemy>=2.0.49
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Provides-Extra: example
+Requires-Dist: fastapi>=0.100.0; extra == "example"
+Requires-Dist: uvicorn>=0.23.0; extra == "example"

schemap-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "schemap"
+version = "0.1.0"
+description = "Automatic Pydantic Schemas for SQLAlchemy models"
+readme = "README.md"
+requires-python = ">=3.12.7"
+authors = [
+    { name = "Emiliano Gandini Outeda", email = "emiliano.gandini@protonmail.com" }
+]
+license = "MIT"
+keywords = [
+  "python",
+  "schemas",
+  "models",
+  "orm"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "pydantic>=2.13.4",
+    "sqlalchemy>=2.0.49",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+example = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/emiliano-gandini-outeda/schemap"
+Repository = "https://github.com/emiliano-gandini-outeda/schemap"
+Issues = "https://github.com/emiliano-gandini-outeda/schemap/issues"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["tests*", "examples*"]

schemap-0.1.0/setup.cfg

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

schemap-0.1.0/src/schemap/__init__.py

@@ -0,0 +1,4 @@
+""" Automatic Pydantic schemas for SQLAlchemy models """
+
+__version__ = "0.1.0"
+

schemap-0.1.0/src/schemap/base.py

@@ -0,0 +1 @@
+"""Base classes for AutoSchema models."""

schemap-0.1.0/src/schemap/builder.py

@@ -0,0 +1,44 @@
+from typing import Type, Any, Optional
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy import inspect
+from pydantic import create_model, ConfigDict, Field
+
+from .types import extract_column_metadata
+from .utils.schema import should_include, transform_for_schema
+
+
+def build_schema(
+    model: Type[DeclarativeBase],
+    schema_type: str = "default",  # "default", "create", "update", "public"
+    config: Optional[Any] = None,  # SchemaConfig
+) -> Any:
+    """
+    Build a Pydantic schema class for a SQLAlchemy model.
+    
+    Args:
+        model: The SQLAlchemy model class (e.g., User)
+        schema_type: Which schema variant to build
+        config: Optional SchemaConfig for customization
+        
+    Returns:
+        A Pydantic model class
+    """
+    
+    inspector = inspect(model)
+
+    columns_meta = []
+
+    for col in inspector.columns:
+        meta = extract_column_metadata(col)
+        if should_include(schema_type, meta):
+            columns_meta.append(meta)
+
+    fields = {}
+    
+    for col_meta in columns_meta:
+        field_type, field_kwargs = transform_for_schema(col_meta, schema_type)
+        fields[col_meta["name"]] = (field_type, field_kwargs)
+
+    schema_name = f"{model.__name__}{schema_type.capitalize()}Schema"
+
+    return create_model(schema_name, __config__=ConfigDict(from_attributes=True), **fields)

schemap-0.1.0/src/schemap/types.py

@@ -0,0 +1,64 @@
+from .utils.mapping import TYPE_MAP
+from .utils.likeness import ColumnLike
+
+from sqlalchemy import types as sa_types, inspect
+from sqlalchemy.sql.schema import Column
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from typing import Union, Any
+
+
+def extract_python_type(column : ColumnLike) -> tuple[type, bool]:
+    """
+    Extract Python type and optional flag from a SQLAlchemy column.
+    
+    Args:
+        column: A SQLAlchemy Column or InstrumentedAttribute
+        
+    Returns:
+        tuple[type, bool]: (python_type, is_optional)
+        
+    Example:
+        >>> from sqlalchemy import Integer, String
+        >>> from sqlalchemy.orm import Mapped, mapped_column
+        >>> 
+        >>> # Simulating Mapped[int]
+        >>> extract_python_type(Integer()) 
+        (int, False)
+    """
+    # If passed a TypeEngine directly (like Integer()), use it as-is
+    if isinstance(column, sa_types.TypeEngine):
+        sql_type = type(column)
+        return TYPE_MAP.get(sql_type, (Any, False)), False
+    
+    sql_type = type(column.type)
+    return TYPE_MAP.get(sql_type, (Any, False)), False
+    
+def extract_column_metadata(column : ColumnLike) -> dict[str, Any]:
+    """
+    Extract all metadata from column for Pydantic Field construction.
+    
+    Returns dict with keys:
+        - "python_type": the Python type from extract_python_type
+        - "is_optional": boolean
+        - "max_length": int | None (from String, Text)
+        - "ge": int | None (minimum value for numeric)
+        - "le": int | None (maximum value for numeric)
+        - "default": Any | None (from column.default)
+        - "primary_key": bool
+        
+    Args:
+        column: SQLAlchemy Column object
+        
+    Returns:
+        dict with above keys
+    """
+
+    return{
+        "name": column.name,
+        "python_type": extract_python_type(column)[0],
+        "is_optional": column.nullable,
+        "primary_key": column.primary_key,
+        "max_length": getattr(column.type, 'length', None),
+        "default": column.default.arg if column.default else None,
+        "server_default" : column.server_default,
+    }

schemap-0.1.0/src/schemap/utils/likeness.py

@@ -0,0 +1,49 @@
+from typing import Protocol, Optional, Set, Any
+from sqlalchemy.sql.type_api import TypeEngine
+from sqlalchemy.sql.schema import (
+    ColumnDefault,
+    DefaultClause,
+    Identity,
+    Computed,
+    ForeignKey,
+    Constraint,
+    DialectKWArgs,
+)
+
+
+class ColumnLike(Protocol):
+    """Protocol for objects that behave like SQLAlchemy Column."""
+
+    # --- Identity ---
+    name: str
+    key: str
+
+    # --- Type ---
+    type: TypeEngine[Any]
+
+    # --- Nullability / defaults ---
+    nullable: bool
+    default: Optional[ColumnDefault]
+    server_default: Optional[DefaultClause]
+    autoincrement: Any  # SQLAlchemy uses bool | Literal["auto"] | etc
+
+    # --- Constraints / keys ---
+    primary_key: bool
+    unique: Optional[bool]
+    index: Optional[bool]
+    foreign_keys: Set[ForeignKey]
+    constraints: Set[Constraint]
+
+    # --- Generated / identity ---
+    identity: Optional[Identity]
+    computed: Optional[Computed]
+
+    # --- Docs / comments ---
+    comment: Optional[str]
+    doc: Optional[str]
+
+    # --- Misc ---
+    quote: Optional[bool]
+    system: bool
+    info: dict[str, Any]
+    dialect_options: DialectKWArgs

schemap-0.1.0/src/schemap/utils/mapping.py

@@ -0,0 +1,57 @@
+from sqlalchemy import types as sa_types
+from datetime import date, time, datetime
+from decimal import Decimal
+import uuid
+
+TYPE_MAP = {
+    # --- Strings ---
+    sa_types.String: str,
+    sa_types.Text: str,
+    sa_types.Unicode: str,
+    sa_types.UnicodeText: str,
+    sa_types.CHAR: str,
+    sa_types.VARCHAR: str,
+    sa_types.NCHAR: str,
+    sa_types.NVARCHAR: str,
+    sa_types.CLOB: str,
+
+    # --- Integers ---
+    sa_types.Integer: int,
+    sa_types.SmallInteger: int,
+    sa_types.BigInteger: int,
+
+    # --- Numeric ---
+    sa_types.Numeric: Decimal,
+    sa_types.DECIMAL: Decimal,
+
+    # --- Floating point ---
+    sa_types.Float: float,
+    sa_types.REAL: float,
+
+    # --- Boolean ---
+    sa_types.Boolean: bool,
+
+    # --- Date / Time ---
+    sa_types.Date: date,
+    sa_types.Time: time,
+    sa_types.DateTime: datetime,
+    sa_types.TIMESTAMP: datetime,
+
+    # --- Binary ---
+    sa_types.LargeBinary: bytes,
+    sa_types.BLOB: bytes,
+    sa_types.BINARY: bytes,
+    sa_types.VARBINARY: bytes,
+
+    # --- JSON ---
+    sa_types.JSON: dict,
+
+    # --- UUID ---
+    sa_types.UUID: uuid.UUID,
+
+    # --- Arrays ---
+    sa_types.ARRAY: list,
+
+    # --- Generic fallback ---
+    sa_types.NullType: object,
+}

schemap-0.1.0/src/schemap/utils/schema.py

@@ -0,0 +1,78 @@
+from typing import Any, Optional
+from pydantic import Field
+
+def should_include(schema_type : str, metadata : dict[str, Any]):
+    """Determine if a column should be included in the schema."""
+    
+    if schema_type == "default":
+        return True
+    
+    elif schema_type == "create":
+        # Exclude primary keys and server_default fields
+        if metadata["primary_key"]:
+            return False
+        
+        if metadata.get("server_default") is not None:
+            return False
+        
+        if metadata.get("default") is not None:
+            return False
+        
+        return True
+    
+    elif schema_type == "update":
+        # Exclude primary keys only
+        if metadata["primary_key"]:
+            return False
+        
+        return True
+    
+    elif schema_type == "public":
+        # Exclude fields starting with __ (private)
+        if metadata["name"].startswith("__"):
+            return False
+        
+        return True
+    
+    else:
+        raise ValueError(f"Unknown schema_type: {schema_type}")
+    
+def transform_for_schema(metadata: dict, schema_type: str) -> tuple[type, Any]:
+    """Transform column metadata into (field_type, Field(...)) for create_model."""
+    
+    python_type = metadata["python_type"]
+    
+    # Build Field kwargs from constraints
+    field_kwargs = {}
+    
+    # String length constraint
+    if metadata.get("max_length") is not None:
+        field_kwargs["max_length"] = metadata["max_length"]
+    
+    if schema_type == "update":
+        field_kwargs["default"] = None
+        return (Optional[python_type], Field(**field_kwargs))
+    
+    elif schema_type == "create":
+        if metadata.get("default") is not None:
+            field_kwargs["default"] = metadata["default"]
+            return (python_type, Field(**field_kwargs))
+        
+        elif metadata["is_optional"]:
+            field_kwargs["default"] = None
+            return (Optional[python_type], Field(**field_kwargs))
+        
+        else:
+            return (python_type, Field(**field_kwargs) if field_kwargs else ...)
+    
+    else:  # default or public
+        if metadata.get("default") is not None:
+            field_kwargs["default"] = metadata["default"]
+            return (python_type, Field(**field_kwargs))
+        
+        elif metadata["is_optional"]:
+            field_kwargs["default"] = None
+            return (Optional[python_type], Field(**field_kwargs))
+        
+        else:
+            return (python_type, Field(**field_kwargs) if field_kwargs else ...)

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

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: schemap
+Version: 0.1.0
+Summary: Automatic Pydantic Schemas for SQLAlchemy models
+Author-email: Emiliano Gandini Outeda <emiliano.gandini@protonmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/emiliano-gandini-outeda/schemap
+Project-URL: Repository, https://github.com/emiliano-gandini-outeda/schemap
+Project-URL: Issues, https://github.com/emiliano-gandini-outeda/schemap/issues
+Keywords: python,schemas,models,orm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12.7
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: sqlalchemy>=2.0.49
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Provides-Extra: example
+Requires-Dist: fastapi>=0.100.0; extra == "example"
+Requires-Dist: uvicorn>=0.23.0; extra == "example"

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

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/schemap/__init__.py
+src/schemap/base.py
+src/schemap/builder.py
+src/schemap/types.py
+src/schemap.egg-info/PKG-INFO
+src/schemap.egg-info/SOURCES.txt
+src/schemap.egg-info/dependency_links.txt
+src/schemap.egg-info/requires.txt
+src/schemap.egg-info/top_level.txt
+src/schemap/utils/likeness.py
+src/schemap/utils/mapping.py
+src/schemap/utils/schema.py
+tests/test_builder.py
+tests/test_types.py

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

@@ -0,0 +1 @@
+

schemap-0.1.0/src/schemap.egg-info/requires.txt

@@ -0,0 +1,10 @@
+pydantic>=2.13.4
+sqlalchemy>=2.0.49
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+
+[example]
+fastapi>=0.100.0
+uvicorn>=0.23.0

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

@@ -0,0 +1 @@
+schemap

schemap-0.1.0/tests/test_builder.py

@@ -0,0 +1,81 @@
+"""Tests for dynamic schema builder."""
+
+import pytest
+from datetime import datetime, timezone
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from typing import Optional, Union
+from autoschema.builder import build_schema
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id: Mapped[int] = mapped_column(primary_key=True)
+    username: Mapped[str] = mapped_column(nullable=False, unique=True)
+    email: Mapped[str] = mapped_column(nullable=False)
+    age: Mapped[int] = mapped_column(nullable=True)
+    created_at: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc))
+
+
+def test_build_full_schema():
+    """Test building complete schema with all fields."""
+    UserSchema = build_schema(User, "default")
+    
+    # Check schema has all expected fields
+    assert "id" in UserSchema.model_fields
+    assert "username" in UserSchema.model_fields
+    assert "email" in UserSchema.model_fields
+    assert "age" in UserSchema.model_fields
+    assert "created_at" in UserSchema.model_fields
+    
+    # Check types
+    assert UserSchema.model_fields["username"].annotation == str
+    assert UserSchema.model_fields["age"].annotation == Optional[int]
+    
+    # Check from_attributes is enabled
+    assert UserSchema.model_config["from_attributes"] is True
+
+
+def test_build_create_schema():
+    """Test create schema excludes auto-generated fields."""
+    UserCreateSchema = build_schema(User, "create")
+    
+    # id and created_at should be excluded (primary key and server_default)
+    assert "id" not in UserCreateSchema.model_fields
+    assert "created_at" not in UserCreateSchema.model_fields
+    
+    # Required fields should be required
+    assert UserCreateSchema.model_fields["username"].is_required() is True
+    assert UserCreateSchema.model_fields["email"].is_required() is True
+
+
+def test_build_update_schema():
+    """Test update schema makes all fields optional."""
+    UserUpdateSchema = build_schema(User, "update")
+    
+    # All fields should be Optional with default None
+    for field_name, field in UserUpdateSchema.model_fields.items():
+        # Check type is Optional (handles both Optional[X] and X | None)
+        is_optional = getattr(field.annotation, "__origin__", None) is Union and type(None) in getattr(field.annotation, "__args__", [])
+        assert is_optional or field.is_required() is False
+
+
+def test_can_create_instance():
+    """Test the generated schema can actually create instances."""
+    UserSchema = build_schema(User, "default")
+    
+    user = UserSchema(
+        id=1,
+        username="testuser",
+        email="test@example.com",
+        age=30,
+        created_at=datetime.now(timezone.utc)
+    )
+    
+    assert user.username == "testuser"
+    assert user.model_dump()["username"] == "testuser"

schemap-0.1.0/tests/test_types.py

@@ -0,0 +1,47 @@
+"""Tests for type resolution."""
+
+import pytest
+from datetime import datetime, date
+from sqlalchemy import Integer, String, Boolean, DateTime, Date, Float, Text, JSON
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import Column
+
+from autoschema.types import extract_python_type, extract_column_metadata
+
+
+def test_simple_type_mapping():
+    """Test that basic SQLAlchemy types map to correct Python types."""
+    assert extract_python_type(Integer()) == (int, False)
+    assert extract_python_type(String()) == (str, False)
+    assert extract_python_type(Boolean()) == (bool, False)
+    assert extract_python_type(Float()) == (float, False)
+    assert extract_python_type(DateTime()) == (datetime, False)
+    assert extract_python_type(Date()) == (date, False)
+    assert extract_python_type(Text()) == (str, False)
+
+
+def test_column_metadata_basics():
+    """Test extraction of column properties."""
+    
+    col = Column("id", Integer, primary_key=True, nullable=False)
+    metadata = extract_column_metadata(col)
+    
+    assert metadata["python_type"] == int
+    assert metadata["is_optional"] is False
+    assert metadata["primary_key"] is True
+
+
+def test_string_length():
+    """Test that String(100) captures max_length."""
+    col = Column("name", String(100), nullable=False)
+    metadata = extract_column_metadata(col)
+    
+    assert metadata["max_length"] == 100
+
+
+def test_nullable_column():
+    """Test that nullable=True sets is_optional=True."""
+    col = Column("bio", Text, nullable=True)
+    metadata = extract_column_metadata(col)
+    
+    assert metadata["is_optional"] is True