schemap 0.1.0__py3-none-any.whl

schemap/__init__.py

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

schemap/base.py

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

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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+schemap/__init__.py,sha256=rfKizb9zqsS03rwcjI_fmR7Hf_mGUAy45jYYitpQLYw,81
+schemap/base.py,sha256=AoLt4I4X6epfSA3oWvz39w39HAmiHFBfw4ui-UAbCQg,41
+schemap/builder.py,sha256=EHMjanCt2sDQlU0zY9Pd2U7mXCW1STZFkOCwC1Bfl14,1350
+schemap/types.py,sha256=mwvlg4bdBJq7INEMEVoSrvx_JbCUkJ6Z1L0orJHmrEk,2125
+schemap/utils/likeness.py,sha256=5LdSTtJzoZmzaKaAg7X1PN8mclbiumGtWrHkR1Hq17c,1134
+schemap/utils/mapping.py,sha256=YDG7MEOQ5GAW9B_LGQJocAtWkC9Wxs9AVFFr4X7P-No,1219
+schemap/utils/schema.py,sha256=uYmXPNkCYIciUBohuU7ZNVfzfRx49S_lVwexMbBperI,2527
+schemap-0.1.0.dist-info/METADATA,sha256=IAG3YeHHTSf_zSDr3Hi3HDPYcP8oxWfMkJ_GPGMA4oE,981
+schemap-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+schemap-0.1.0.dist-info/top_level.txt,sha256=5zq746A8UTvlSgJspE7jLl2gpcxWNmCaBK2J62m3M-Y,8
+schemap-0.1.0.dist-info/RECORD,,

schemap-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
+

schemap-0.1.0.dist-info/top_level.txt

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