exdrf-dev 0.1.12__py3-none-any.whl

exdrf_dev/attr_gen/db/tags/api.py

@@ -0,0 +1,7 @@
+# This file was automatically generated using the exdrf_gen package.
+# Source: exdrf_gen_al2at.creator -> c/api.py.j2
+# Don't change it manually.
+
+# exdrf-keep-start more_content ------------------------------------------------
+
+# exdrf-keep-end more_content --------------------------------------------------

exdrf_dev/attr_gen/db/tags/tag.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from attrs import define, field
+
+# exdrf-keep-start other_imports ----------------------------------------------
+
+# exdrf-keep-end other_imports ------------------------------------------------
+
+# exdrf-keep-start other_globals ----------------------------------------------
+
+# exdrf-keep-end other_globals ------------------------------------------------
+
+
+@define
+class Tag:
+    # exdrf-keep-start other_attributes ---------------------------------------
+
+    # exdrf-keep-end other_attributes -----------------------------------------
+    name: Optional[str] = field(default=None)
+    parents: Optional[list[str]] = field(default=None)
+    id: Optional[int] = field(default=None)
+
+    # exdrf-keep-start extra_class_content -------------------------------------
+
+    # exdrf-keep-end extra_class_content ---------------------------------------
+
+
+# exdrf-keep-start more_content -----------------------------------------------
+
+# exdrf-keep-end more_content -------------------------------------------------

exdrf_dev/cli.py

@@ -0,0 +1,89 @@
+import logging
+import os
+import subprocess
+
+import click
+from dotenv import load_dotenv
+
+from exdrf_al.click_support.auto_db_migration import auto_db_migration
+from exdrf_al.click_support.downgrade_db import downgrade_db
+from exdrf_al.click_support.list_db_version import list_db_versions
+from exdrf_al.click_support.set_db_version import set_db_version
+from exdrf_al.click_support.upgrade_db import upgrade_db
+from exdrf_dev.__version__ import __version__
+
+
+@click.group()
+@click.option("--debug/--no-debug", default=False)
+@click.version_option(__version__, prog_name="exdrf-dev")
+def cli(debug: bool):
+    logging.basicConfig(
+        level=logging.DEBUG if debug else logging.INFO,
+        format="[%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    logging.debug("Debug mode is on")
+    os.environ["CURDIR"] = os.getcwd()
+
+    load_dotenv(override=True)
+    click.echo("=" * 80)
+    _print_env("Environment variables after .env")
+    click.echo("=" * 80)
+
+
+def _print_env(title: str = "Environment variables"):
+    click.echo(title)
+    for key in sorted(os.environ.keys()):
+        value = os.environ[key]
+        if len(value) > 50:
+            click.echo(f"{key}:")
+            for part in value.split(";"):
+                click.echo(f"  {part}")
+        else:
+            click.echo(f"{key}: {value}")
+
+
+@cli.command()
+def print_env():
+    """Print the environment variables."""
+    _print_env()
+
+
+@cli.command()
+@click.argument("args", nargs=-1)
+def run(args):
+    """Run the exdrf-dev application with provided arguments."""
+    click.echo(f"Running exdrf-dev with arguments: {args}")
+    try:
+        final_args = []
+        for a in args:
+            if a.startswith("env:"):
+                env_var = a[4:]
+                env_value = os.environ.get(env_var)
+                if env_value is None:
+                    click.echo(f"Env. variable '{env_var}' not found.", err=True)
+                    return
+                a = env_value
+            final_args.append(a)
+
+        result = subprocess.run(
+            final_args, check=True, text=True, capture_output=True, shell=True
+        )
+        click.echo(result.stdout)
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+    except subprocess.CalledProcessError as e:
+        click.echo(f"Command failed with exit code {e.returncode}", err=True)
+        click.echo(e.stderr, err=True)
+    except FileNotFoundError:
+        click.echo("Command not found", err=True)
+
+
+cli.add_command(auto_db_migration)
+cli.add_command(list_db_versions)
+cli.add_command(set_db_version)
+cli.add_command(upgrade_db)
+cli.add_command(downgrade_db)
+
+if __name__ == "__main__":
+    cli()

exdrf_dev/db/api.py

@@ -0,0 +1,10 @@
+from exdrf_dev.db.models import (  # noqa: F401
+    Child,
+    CompositeKeyModel,
+    Parent,
+    ParentTagAssociation,
+    Profile,
+    RelatedItem,
+    StatusEnum,
+    Tag,
+)

exdrf_dev/db/models.py

@@ -0,0 +1,504 @@
+import datetime
+import enum
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Date,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    ForeignKeyConstraint,
+    Integer,
+    LargeBinary,
+    PrimaryKeyConstraint,
+    String,
+    Time,
+    create_engine,
+)
+from sqlalchemy.orm import (
+    Mapped,
+    mapped_column,
+    relationship,
+    sessionmaker,
+)
+
+from exdrf_al.base import Base
+
+
+class StatusEnum(enum.Enum):
+    """Enumeration for various status values."""
+
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+# --- Association Table for Many-to-Many ---
+
+
+class ParentTagAssociation(Base):
+    """Association object for the many-to-many relationship between Parent and
+    Tag.
+    """
+
+    __tablename__ = "parent_tag_association"
+    __table_args__ = (
+        PrimaryKeyConstraint("parent_id", "tag_id"),
+        {"info": {"label": """(concat "Parent:" parent_id " Tag:" tag_id)"""}},
+    )
+
+    parent_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("parents.id"),
+        primary_key=True,
+        doc="Foreign key to the parents table.",
+    )
+    tag_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("tags.id"),
+        primary_key=True,
+        doc="Foreign key to the tags table.",
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<ParentTagAssociation(parent_id={self.parent_id}, tag_id={self.tag_id})>"
+        )
+
+
+# --- Model Definitions ---
+
+
+class Parent(Base):
+    """Represents a parent entity with various relationships."""
+
+    __tablename__ = "parents"
+    __table_args__ = {"info": {"label": """(concat "ID:" id " Name:" name)"""}}
+
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, doc="Primary key for the parent."
+    )
+    name: Mapped[str] = mapped_column(
+        String(100),
+        index=True,
+        doc="Name of the parent.",
+        info={
+            "min_length": 1,
+            "multiline": False,
+            "visible": True,
+            "sortable": True,
+            "filterable": True,
+        },
+    )
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime,
+        default=datetime.datetime.utcnow,
+        doc="Timestamp when the parent was created.",
+        info={
+            "min": datetime.datetime(2020, 1, 1, 0, 0),
+            "max": datetime.datetime(2030, 12, 31, 23, 59),
+        },
+    )
+    is_active: Mapped[bool] = mapped_column(
+        Boolean,
+        default=True,
+        doc="Flag indicating if the parent is active.",
+        info={
+            "true_str": "Active",
+            "false_str": "Inactive",
+        },
+    )
+
+    # One-to-Many relationship with Child
+    children: Mapped[List["Child"]] = relationship(
+        "Child",
+        back_populates="parent",
+        cascade="all, delete-orphan",
+        info={
+            "doc": "Children associated with this parent.",
+            "direction": "OneToMany",
+        },
+    )
+
+    # One-to-One relationship with Profile
+    profile: Mapped[Optional["Profile"]] = relationship(
+        "Profile",
+        back_populates="parent",
+        uselist=False,
+        cascade="all, delete-orphan",
+        info={
+            "doc": "Profile associated with this parent (one-to-one).",
+            "direction": "OneToOne",
+        },
+    )
+
+    # Many-to-Many relationship with Tag
+    tags: Mapped[List["Tag"]] = relationship(
+        "Tag",
+        secondary="parent_tag_association",
+        back_populates="parents",
+        info={
+            "doc": "Tags associated with this parent (many-to-many).",
+            "direction": "ManyToMany",
+        },
+    )
+
+    def __repr__(self) -> str:
+        return f"<Parent(id={self.id}, name='{self.name}')>"
+
+
+class Child(Base):
+    """Represents a child entity linked to a parent."""
+
+    __tablename__ = "children"
+    __table_args__ = {
+        "info": {
+            "label": """
+            (concat "ID:" id " Parent " parent.name " Data:" data)
+            """
+        }
+    }
+
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, doc="Primary key for the child."
+    )
+    data: Mapped[Optional[str]] = mapped_column(
+        String,
+        doc="Some data associated with the child.",
+        info={
+            "min_length": 1,
+            "max_length": 200,
+            "multiline": True,
+            "visible": True,
+            "sortable": True,
+            "filterable": True,
+        },
+    )
+    parent_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("parents.id"),
+        doc="Foreign key linking to the parent.",
+    )
+
+    # Many-to-One relationship with Parent
+    parent: Mapped["Parent"] = relationship(
+        "Parent",
+        back_populates="children",
+        info={
+            "doc": "The parent associated with this child.",
+            "direction": "ManyToOne",
+        },
+    )
+
+    def __repr__(self) -> str:
+        return f"<Child(id={self.id}, data='{self.data}', parent_id={self.parent_id})>"
+
+
+class Profile(Base):
+    """Represents a profile entity linked one-to-one with a parent."""
+
+    __tablename__ = "profiles"
+    __table_args__ = {"info": {"label": """(concat "ID:" id " Bio:" bio)"""}}
+
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, doc="Primary key for the profile."
+    )
+    bio: Mapped[Optional[str]] = mapped_column(
+        String, doc="Biography text for the profile."
+    )
+    parent_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("parents.id"),
+        unique=True,  # Ensures one-to-one relationship at the DB level
+        doc="Foreign key linking to the parent (must be unique).",
+    )
+
+    # One-to-One relationship back to Parent
+    parent: Mapped["Parent"] = relationship(
+        "Parent",
+        back_populates="profile",
+        info={
+            "doc": "The parent associated with this profile.",
+            "direction": "OneToOne",
+        },
+    )
+
+    def __repr__(self) -> str:
+        return f"<Profile(id={self.id}, parent_id={self.parent_id})>"
+
+
+class Tag(Base):
+    """Represents a tag entity for many-to-many relationships."""
+
+    __tablename__ = "tags"
+    __table_args__ = {"info": {"label": """(concat "ID:" id " Name:" name)"""}}
+
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, doc="Primary key for the tag."
+    )
+    name: Mapped[str] = mapped_column(
+        String(50), unique=True, index=True, doc="Unique name of the tag."
+    )
+
+    # Many-to-Many relationship back to Parent
+    parents: Mapped[List["Parent"]] = relationship(
+        "Parent",
+        secondary="parent_tag_association",
+        back_populates="tags",
+        info={
+            "doc": "Parents associated with this tag.",
+            "direction": "ManyToMany",
+        },
+    )
+
+    def __repr__(self) -> str:
+        return f"<Tag(id={self.id}, name='{self.name}')>"
+
+
+class CompositeKeyModel(Base):
+    """Demonstrates a model with a composite primary key and various data
+    types.
+    """
+
+    __tablename__ = "comp_key_models"
+
+    # Composite Primary Key
+    key_part1: Mapped[str] = mapped_column(
+        String(50),
+        primary_key=True,
+        doc="First part of the composite primary key (string).",
+    )
+    key_part2: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        doc="Second part of the composite primary key (integer).",
+    )
+
+    description: Mapped[Optional[str]] = mapped_column(
+        String,
+        doc="A description for this record.",
+        info={
+            "multiline": True,
+        },
+    )
+    some_float: Mapped[Optional[float]] = mapped_column(
+        Float,
+        doc="A floating-point number.",
+        info={
+            "min": 0.0,
+            "max": 100.0,
+            "precision": 2,
+            "scale": 2,
+            "unit": "units",
+            "unit_symbol": "u",
+        },
+    )
+    some_date: Mapped[Optional[datetime.date]] = mapped_column(
+        Date,
+        doc="A date value.",
+        info={
+            "min": datetime.date(2020, 1, 1),
+            "max": datetime.date(2030, 12, 31),
+        },
+    )
+    some_time: Mapped[Optional[datetime.time]] = mapped_column(
+        Time,
+        doc="A time value.",
+    )
+    some_enum: Mapped[Optional[StatusEnum]] = mapped_column(
+        Enum(StatusEnum), doc="An enum value representing status."
+    )
+    some_json: Mapped[Optional[Dict[str, Any]]] = mapped_column(
+        JSON, doc="A JSON object."
+    )
+    some_binary: Mapped[Optional[bytes]] = mapped_column(
+        LargeBinary,
+        doc="Binary data.",
+        info={
+            "visible": False,
+            "sortable": False,
+            "filterable": False,
+            "mime_type": "application/octet-stream",
+        },
+    )
+
+    # One-to-Many relationship with RelatedItem using composite foreign key
+    related_items: Mapped[List["RelatedItem"]] = relationship(
+        "RelatedItem",
+        back_populates="comp_key_owner",
+        cascade="all, delete-orphan",
+        foreign_keys="[RelatedItem.comp_key_part1, RelatedItem.comp_key_part2]",
+        info={
+            "doc": "Items related to this composite key model.",
+            "direction": "OneToMany",
+        },
+    )
+
+    __table_args__ = (
+        PrimaryKeyConstraint("key_part1", "key_part2", name="composite_pk"),
+        {"info": {"label": """(concat "Description:" description)"""}},
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<CompositeKeyModel(key_part1='{self.key_part1}', "
+            f"key_part2={self.key_part2})>"
+        )
+
+
+class RelatedItem(Base):
+    """Model related to CompositeKeyModel via its composite key."""
+
+    __tablename__ = "related_items"
+
+    id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, doc="Primary key for the related item."
+    )
+    item_data: Mapped[Optional[str]] = mapped_column(
+        String(200), doc="Data specific to the related item."
+    )
+    some_int: Mapped[Optional[int]] = mapped_column(
+        Integer,
+        doc="An integer value associated with the related item.",
+        info={
+            "min": 0,
+            "max": 1000,
+            "unit": "units",
+            "unit_symbol": "u",
+        },
+    )
+
+    # Composite Foreign Key parts
+    comp_key_part1: Mapped[str] = mapped_column(
+        String(50), doc="Foreign key part 1 referencing CompositeKeyModel."
+    )
+    comp_key_part2: Mapped[int] = mapped_column(
+        Integer, doc="Foreign key part 2 referencing CompositeKeyModel."
+    )
+
+    # Many-to-One relationship back to CompositeKeyModel
+    comp_key_owner: Mapped["CompositeKeyModel"] = relationship(
+        "CompositeKeyModel",
+        back_populates="related_items",
+        foreign_keys=[comp_key_part1, comp_key_part2],
+        info={
+            "doc": "The owner model with the composite key.",
+            "direction": "ManyToOne",
+        },
+    )
+
+    # Define the composite foreign key constraint
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["comp_key_part1", "comp_key_part2"],
+            ["comp_key_models.key_part1", "comp_key_models.key_part2"],
+            name="related_item_composite_fk",
+        ),
+        {"info": {"label": """(concat "ID:" id)"""}},
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<RelatedItem(id={self.id}, "
+            f"key1='{self.comp_key_part1}', key2={self.comp_key_part2})>"
+        )
+
+
+def get_dev_engine():
+    """Creates an in-memory SQLite database engine for development/testing."""
+    engine = create_engine("sqlite:///:memory:")
+    Base.metadata.create_all(engine)
+    return engine
+
+
+def get_populated_dev_engine(engine=None):
+    """Creates an in-memory SQLite database engine and populates it with
+    sample data.
+    """
+    if engine is None:
+        engine = get_dev_engine()
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+    with SessionLocal() as session:
+        # Create instances
+        tag1 = Tag(name="Urgent")
+        tag2 = Tag(name="Project Alpha")
+
+        parent1 = Parent(name="Parent One")
+        parent1.profile = Profile(bio="Profile for Parent One")
+        parent1.children.append(Child(data="Child A data"))
+        parent1.children.append(Child(data="Child B data"))
+        parent1.tags.extend([tag1, tag2])
+
+        parent2 = Parent(name="Parent Two", is_active=False)
+        parent2.children.append(Child(data="Child C data"))
+        parent2.tags.append(tag1)
+
+        comp_key_obj1 = CompositeKeyModel(
+            key_part1="ITEM_A",
+            key_part2=101,
+            description="First composite item",
+            some_float=3.14,
+            some_date=datetime.date(2023, 1, 15),
+            some_time=datetime.time(10, 30, 0),
+            some_enum=StatusEnum.PROCESSING,
+            some_json={"config": True, "values": [1, 2, 3]},
+            some_binary=b"\x01\x02\x03\x04",
+        )
+        comp_key_obj1.related_items.append(
+            RelatedItem(item_data="Related data 1", some_int=42)
+        )
+        comp_key_obj1.related_items.append(
+            RelatedItem(item_data="Related data 2", some_int=84)
+        )
+
+        comp_key_obj2 = CompositeKeyModel(
+            key_part1="ITEM_B",
+            key_part2=202,
+            description="Second composite item",
+            some_enum=StatusEnum.COMPLETED,
+        )
+
+        # Add to session and commit
+        session.add_all([parent1, parent2, comp_key_obj1, comp_key_obj2])
+        session.commit()
+
+    return engine
+
+
+def print_db_content(engine):
+    """Prints the content of all tables defined in Base.metadata."""
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    models_to_print = [
+        Parent,
+        Child,
+        Profile,
+        Tag,
+        CompositeKeyModel,
+        RelatedItem,
+    ]
+
+    with SessionLocal() as session:
+        for model_cls in models_to_print:
+            table_name = model_cls.__tablename__
+            print(f"\n--- Table: {table_name} ---")
+            try:
+                instances = session.query(model_cls).all()
+                if instances:
+                    for instance in instances:
+                        print(instance)
+                else:
+                    print("(empty)")
+            except Exception as e:
+                print(f"Error querying table {table_name}: {e}")
+
+
+if __name__ == "__main__":
+    # Example usage
+    engine = get_populated_dev_engine()
+    print_db_content(engine)
+    print("Database populated and printed successfully.")