python-plugins 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

python_plugins/__about__.py

@@ -1 +1 @@
-__version__ = "1.0.2"
+__version__ = "1.0.3"

python_plugins/crypto/zip7mix.py

@@ -21,7 +21,7 @@ class Zip7Mix(MixByte):
     def compress(self, file_or_dir, archive_path=None, pwd=None, silent=True):
         """
         examples::
-        
+
             compress("myfile.txt")  # output to myfile.txt.7z
             compress("myfolder")  # output to myfolder.7z
             compress("myfile.txt", "archive.7z", pwd="mypassword")
@@ -70,7 +70,7 @@ class Zip7Mix(MixByte):
     ):
         """
         Examples::
-        
+
             uncompress("archive.7z")  # output to folder archive_extracted
             uncompress("archive.7z", "output_folder")  # output to output_folder
             uncompress("archive.7z", pwd="mypassword")
@@ -152,3 +152,13 @@ class Zip7Mix(MixByte):
             archive_path=archive_path, output_path=output_path, pwd=pwd
         )
         return result
+
+    def unpwd(self, archive_path):
+        file_size = op.getsize(archive_path)
+        with open(archive_path, "rb") as f:
+            if file_size > 1000:
+                f.seek(-1000, os.SEEK_END)
+            data = f.read()
+        parse_result = self.parse_tail_link_blocks(data)
+        pwd = parse_result["pwd"].decode("utf-8")
+        return pwd

python_plugins/sqla/__init__.py

@@ -0,0 +1,3 @@
+from .db import Db
+
+db = Db()

python_plugins/sqla/db.py

@@ -0,0 +1,96 @@
+from flask import Flask
+from flask import current_app
+from flask import g
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import scoped_session
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Db:
+    Model = None
+    engine = None
+    session = None
+    Session = None
+
+    def __init__(self, app: Flask | None = None):
+        self.Model = self._make_declarative_base()
+        if app is not None:
+            self.init_app(app)
+
+    def _make_declarative_base(self):
+        class Base(DeclarativeBase):
+            pass
+
+        return Base
+
+    def init_session(self, url=None, echo=False):
+        """Initialize the database engine and session factory.
+        This method is used in non-Flask environments.
+        Examples:
+            db = Db()
+            db.init_session(url="sqlite:///mydb.sqlite", echo=True)
+            db.create_all()
+            with db.Session() as session:
+                # use the session here
+                session.add(some_object)
+                session.commit()
+        """
+        options = {"url": url or "sqlite:///:memory:"}
+        if echo:
+            options["echo"] = True
+        self.engine = create_engine(**options)
+        self.Session = sessionmaker(self.engine)
+
+    def init_app(self, app: Flask) -> None:
+        if "sqlalchemy" in app.extensions:
+            raise RuntimeError("A 'SQLAlchemy' instance has already been registered.")
+        app.extensions["sqlalchemy"] = self
+
+        # engine
+        engine_options = {
+            "url": app.config.get("SQLALCHEMY_DATABASE_URI", "sqlite:///:memory:")
+        }
+        if app.config.get("SQLALCHEMY_ECHO"):
+            engine_options["echo"] = True
+        self.engine = self._make_engine(engine_options)
+
+        # session
+        session_options = {"bind": self.engine}
+        self.session = self._make_scoped_session(session_options)
+        app.teardown_appcontext(self._remove_session)
+
+        # cli
+        app.shell_context_processor(self._add_models_to_shell)
+
+    def _make_engine(self, options: dict):
+        return create_engine(**options)
+
+    def _make_scoped_session(self, options):
+        session_factory = sessionmaker(**options)
+        return scoped_session(session_factory, scopefunc=self._get_app_g_id)
+
+    def _get_app_g_id(self) -> int:
+        return id(g._get_current_object())
+
+    def _remove_session(self, exception=None):
+        """Remove the current session at the end of the request."""
+        self.session.remove()
+
+    def _add_models_to_shell(self):
+        """Registered with :meth:`~flask.Flask.shell_context_processor`.
+        Adds the ``db`` instance and all model classes to ``flask shell``.
+        """
+        db = current_app.extensions["sqlalchemy"]
+        out = {m.class_.__name__: m.class_ for m in db.Model.registry.mappers}
+        out["db"] = db
+        return out
+
+    def create_all(self, **kwargs):
+        if "bind" not in kwargs:
+            kwargs["bind"] = self.engine
+        self.Model.metadata.create_all(**kwargs)
+
+    def reset_models(self):
+        self.Model.metadata.drop_all(self.engine)
+        self.Model.metadata.create_all(self.engine)

python_plugins/sqla/models/association_proxy.py

@@ -0,0 +1,48 @@
+from typing import Final
+from typing import List
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+from ..orm import ForeignKey
+from ..orm import relationship
+from ..orm import Table
+from ..orm import Column
+from ..orm import Integer
+from ..orm import String
+from ..orm import association_proxy
+from ..orm import AssociationProxy
+
+
+class AssociationProxyChild(db.Model):
+    __tablename__ = "association_proxy_child"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(64))
+
+
+class AssociationProxyParent(db.Model):
+    __tablename__ = "association_proxy_parent"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(64))
+    children: Mapped[List[AssociationProxyChild]] = relationship(
+        secondary=lambda: association_proxy_parent_child_table
+    )
+    # proxy the 'name' attribute from the 'children' relationship
+    childrennames: AssociationProxy[List[str]] = association_proxy("children", "name")
+
+
+association_proxy_parent_child_table: Final[Table] = Table(
+    "association_proxy_parent_child",
+    db.Model.metadata,
+    Column(
+        "association_proxy_parent_id",
+        Integer,
+        ForeignKey("association_proxy_parent.id"),
+        primary_key=True,
+    ),
+    Column(
+        "association_proxy_child_id",
+        Integer,
+        ForeignKey("association_proxy_child.id"),
+        primary_key=True,
+    ),
+)

python_plugins/sqla/models/demo.py

@@ -0,0 +1,114 @@
+from typing import Optional, List
+from datetime import datetime
+from datetime import date
+from datetime import time
+import enum
+
+from .. import db
+from ..orm import Integer
+from ..orm import Boolean
+from ..orm import String
+from ..orm import Float
+from ..orm import DateTime
+from ..orm import Date
+from ..orm import Time
+from ..orm import LargeBinary
+from ..orm import Enum
+from ..orm import JSON
+from ..orm import Mapped
+from ..orm import mapped_column
+from ..orm import relationship
+from ..orm import composite
+from ..orm import synonym
+from ..orm import Table
+from ..orm import Column
+from ..orm import ForeignKey
+from ..orm import hybrid_property
+from ..orm import hybrid_method
+from ..orm import association_proxy
+from ..orm import AssociationProxy
+
+# see https://docs.sqlalchemy.org/en/20/orm/extensions/associationproxy.html
+
+class Point:
+    x: int
+    y: int
+
+
+# Status = Literal["pending", "received", "completed"]
+class Status(enum.Enum):
+    PENDING = "pending"
+    RECEIVED = "received"
+    COMPLETED = "completed"
+
+
+class Demo(db.Model):
+    __tablename__ = "demo"
+    
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(unique=True)
+    first_name: Mapped[str]
+    last_name: Mapped[str]
+    data: Mapped[dict] = mapped_column(JSON)
+    bool_field: Mapped[bool] = mapped_column(Boolean, nullable=True)
+    date_field: Mapped[date] = mapped_column(Date, nullable=True)
+    time_field: Mapped[time] = mapped_column(Time, nullable=True)
+    datetime_field: Mapped[datetime] = mapped_column(DateTime, nullable=True)
+    x: Mapped[int]
+    y: Mapped[int]
+    start: Mapped[int]
+    end: Mapped[int]
+    status: Mapped[Status]
+    created_at: Mapped[datetime] = mapped_column(default=datetime.now)
+    updated_at: Mapped[datetime] = mapped_column(
+        default=datetime.now, onupdate=datetime.now
+    )
+    point: Mapped[Point] = composite("x", "y")
+
+    syn_status = synonym("status")
+
+    @hybrid_property
+    def full_name(self) -> str:
+        return f"{self.first_name} {self.last_name}"
+
+    @hybrid_method
+    def contains(self, point: int) -> bool:
+        return (self.start <= point) & (point <= self.end)
+
+    tg: Mapped[List["Tag"]] = relationship(secondary=lambda: demo_tag_table)
+    # proxy the 'keyword' attribute from the 'kw' relationship
+    tags: AssociationProxy[List[str]] = association_proxy("tg", "tag")
+
+    addresses: Mapped[List["Address"]] = relationship(back_populates="demo")
+
+    def __init__(self, name: str):
+        self.name = name
+
+
+class Address(db.Model):
+    __tablename__ = "address"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    street: Mapped[str]
+    demo_id = mapped_column(ForeignKey("demo.id"))
+    demo: Mapped["Demo"] = relationship(back_populates="addresses")
+
+
+class Tag(db.Model):
+    __tablename__ = "tag"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tag: Mapped[str]
+
+    def __init__(self, tag: str):
+        self.tag = tag
+
+    def __repr__(self) -> str:
+        return f"Tag({self.tag!r})"
+
+
+demo_tag_table = Table(
+    "demo_tag",
+    db.Model.metadata,
+    Column("demo_id", ForeignKey("demo.id"), primary_key=True),
+    Column("tag_id", ForeignKey("tag.id"), primary_key=True),
+)

python_plugins/sqla/models/message.py

@@ -0,0 +1,19 @@
+import enum
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+
+
+class MyCat(enum.Enum):
+    CAT1 = "Category A"
+    CAT2 = "Category B"
+
+
+class Message(db.Model):
+    __table__tablename__ = "message"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    text: Mapped[str]
+    sender: Mapped[str]
+    recipient: Mapped[str]
+    category:Mapped[MyCat] = mapped_column(default=MyCat.CAT1,nullable=False)
+    

python_plugins/sqla/models/model1.py

@@ -0,0 +1,161 @@
+import enum
+from datetime import datetime, date, time
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+from ..orm import Enum
+from ..orm import hybrid_property
+from ..orm import cast
+
+
+class EnumChoices(enum.Enum):
+    first = 1
+    second = 2
+
+
+class Model1(db.Model):
+    id: Mapped[int] = mapped_column(primary_key=True)
+    test1:Mapped[str]
+    test2:Mapped[str]
+    test3:Mapped[str]
+    test4:Mapped[str]
+    bool_field: Mapped[bool]
+    date_field: Mapped[date]
+    time_field: Mapped[time]
+    datetime_field: Mapped[datetime]
+    email_field:Mapped[str]
+    enum_field: Mapped[str] = mapped_column(Enum("model1_v1", "model1_v2"), nullable=True)
+    enum_type_field = mapped_column(Enum(EnumChoices), nullable=True)
+    choice_field:Mapped[str]
+
+    def __init__(
+        self,
+        test1=None,
+        test2=None,
+        test3=None,
+        test4=None,
+        bool_field=False,
+        date_field=None,
+        time_field=None,
+        datetime_field=None,
+        choice_field=None,
+        enum_field=None,
+        enum_type_field=None,
+    ):
+        self.test1 = test1
+        self.test2 = test2
+        self.test3 = test3
+        self.test4 = test4
+        self.bool_field = bool_field
+        self.date_field = date_field
+        self.time_field = time_field
+        self.datetime_field = datetime_field
+        self.choice_field = choice_field
+        self.enum_field = enum_field
+        self.enum_type_field = enum_type_field
+
+    def __str__(self):
+        return str(self.test1)
+
+
+class Model2(db.Model):
+    id: Mapped[int] = mapped_column(primary_key=True)
+    string_field:Mapped[str]
+    string_field_default = db.Column(db.Text, nullable=False, default="")
+    string_field_empty_default = db.Column(db.Text, nullable=False, default="")
+    int_field = db.Column(db.Integer)
+    bool_field = db.Column(db.Boolean)
+    enum_field = db.Column(db.Enum("model2_v1", "model2_v2"), nullable=True)
+    float_field = db.Column(db.Float)
+
+    # Relation
+    model1_id = db.Column(db.Integer, db.ForeignKey(Model1.id))
+    model1 = db.relationship(lambda: Model1, backref="model2")
+
+    def __init__(
+        self,
+        string_field=None,
+        int_field=None,
+        bool_field=None,
+        model1=None,
+        float_field=None,
+        string_field_default=None,
+        string_field_empty_default=None,
+    ):
+        self.string_field = string_field
+        self.int_field = int_field
+        self.bool_field = bool_field
+        self.model1 = model1
+        self.float_field = float_field
+        self.string_field_default = string_field_default
+        self.string_field_empty_default = string_field_empty_default
+
+
+class Model3(db.Model):
+    def __init__(self, id=None, val1=None):
+        self.id = id
+        self.val1 = val1
+
+    id = db.Column(db.String(20), primary_key=True)
+    val1 = db.Column(db.String(20))
+
+
+class ModelHybrid(db.Model):
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name = db.Column(db.String)
+    width = db.Column(db.Integer)
+    height = db.Column(db.Integer)
+
+    firstname = db.Column(db.String)
+    lastname = db.Column(db.String)
+
+    @hybrid_property
+    def fullname(self):
+        return "{} {}".format(self.firstname, self.lastname)
+
+    @hybrid_property
+    def number_of_pixels(self):
+        return self.width * self.height
+
+    @hybrid_property
+    def number_of_pixels_str(self):
+        return str(self.number_of_pixels())
+
+    @number_of_pixels_str.expression
+    def number_of_pixels_str(cls):
+        return cast(cls.width * cls.height, db.String)
+
+
+class ModelHybrid2(db.Model):
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name = db.Column(db.String)
+    owner_id = db.Column(
+        db.Integer, db.ForeignKey("model_hybrid.id", ondelete="CASCADE")
+    )
+    owner = db.relationship("ModelHybrid", backref=db.backref("tiles"), uselist=False)
+
+
+class ModelNoint(db.Model):
+    id: Mapped[str] = mapped_column(primary_key=True)
+    test = db.Column(db.String)
+
+
+class ModelForm(db.Model):
+    id: Mapped[str] = mapped_column(primary_key=True)
+    int_field = db.Column(db.Integer)
+    datetime_field = db.Column(db.DateTime)
+    text_field = db.Column(db.UnicodeText)
+    excluded_column = db.Column(db.String)
+
+
+class ModelChild(db.Model):
+    id: Mapped[str] = mapped_column(primary_key=True)
+    model_id = db.Column(db.Integer, db.ForeignKey(ModelForm.id))
+    model = db.relationship(ModelForm, backref="backref")
+    enum_field = db.Column(db.Enum("model1_v1", "model1_v2"), nullable=True)
+    choice_field = db.Column(db.String, nullable=True)
+
+
+
+
+    

python_plugins/sqla/models/multpk.py

@@ -0,0 +1,16 @@
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+
+
+class Singlepk(db.Model):
+    __tablename__ = "singlepk"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    data: Mapped[str]
+
+
+class Multpk(db.Model):
+    __tablename__ = "multpk"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    id2: Mapped[int] = mapped_column(primary_key=True)
+    data: Mapped[str]

python_plugins/sqla/models/polymorphic.py

@@ -0,0 +1,35 @@
+from typing import Optional
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+
+# see https://docs.sqlalchemy.org/en/20/orm/inheritance.html#single-inheritance
+# see https://docs.sqlalchemy.org/en/20/orm/queryguide/_single_inheritance.html
+
+class Employee(db.Model):
+    __tablename__ = "employee"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    type: Mapped[str]
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name!r})"
+
+    __mapper_args__ = {
+        "polymorphic_identity": "employee",
+        "polymorphic_on": "type",
+    }
+
+
+class Manager(Employee):
+    manager_name: Mapped[str] = mapped_column(nullable=True)
+    __mapper_args__ = {
+        "polymorphic_identity": "manager",
+    }
+
+
+class Engineer(Employee):
+    engineer_info: Mapped[str] = mapped_column(nullable=True)
+    __mapper_args__ = {
+        "polymorphic_identity": "engineer",
+    }

python_plugins/sqla/models/relations.py

@@ -0,0 +1,74 @@
+from typing import List
+from typing import Set
+from .. import db
+from ..orm import Mapped
+from ..orm import mapped_column
+from ..orm import ForeignKey
+from ..orm import relationship
+from ..orm import Table
+from ..orm import Column
+from ..orm import Integer
+
+
+class OneToManyParent(db.Model):
+    __tablename__ = "one_to_many_parent"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    children: Mapped[List["ManyToOneChild"]] = relationship()
+    children2: Mapped[List["ManyToOneChild2"]] = relationship(back_populates="parent2")
+    children3: Mapped[Set["ManyToOneChild3"]] = relationship(back_populates="parent3")
+
+
+class ManyToOneChild(db.Model):
+    __tablename__ = "many_to_one_child1"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id: Mapped[int] = mapped_column(ForeignKey("one_to_many_parent.id"))
+
+
+class ManyToOneChild2(db.Model):
+    __tablename__ = "many_to_one_child2"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id: Mapped[int] = mapped_column(ForeignKey("one_to_many_parent.id"))
+    parent2: Mapped["OneToManyParent"] = relationship(back_populates="children2")
+
+
+class ManyToOneChild3(db.Model):
+    __tablename__ = "many_to_one_child3"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id: Mapped[int] = mapped_column(ForeignKey("one_to_many_parent.id"))
+    parent3: Mapped["OneToManyParent"] = relationship(back_populates="children3")
+
+class OneToOneParent(db.Model):
+    __tablename__ = "one_to_one_parent"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    child: Mapped["OneToOneChild"] = relationship(back_populates="parent")
+
+
+class OneToOneChild(db.Model):
+    __tablename__ = "one_to_one_child"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id: Mapped[int] = mapped_column(ForeignKey("one_to_one_parent.id"))
+    parent: Mapped["OneToOneParent"] = relationship(back_populates="child")
+
+
+association_table = Table(
+    "many_to_many_association",
+    db.Model.metadata,
+    Column("left_id", Integer, ForeignKey("many_to_many_left.id"), primary_key=True),
+    Column("right_id", Integer, ForeignKey("many_to_many_right.id"), primary_key=True),
+)
+
+
+class ManyToManyLeft(db.Model):
+    __tablename__ = "many_to_many_left"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    rights: Mapped[List["ManyToManyRight"]] = relationship(
+        secondary=association_table, back_populates="lefts"
+    )
+
+
+class ManyToManyRight(db.Model):
+    __tablename__ = "many_to_many_right"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    lefts: Mapped[List["ManyToManyLeft"]] = relationship(
+        secondary=association_table, back_populates="rights"
+    )

python_plugins/sqla/models/tree_node.py

@@ -0,0 +1,17 @@
+from .. import db
+from ..orm import ForeignKey
+from ..orm import Mapped
+from ..orm import mapped_column
+from ..orm import relationship
+
+# Adjacency List Relationships
+# see https://docs.sqlalchemy.org/en/20/orm/self_referential.html
+
+
+class TreeNode(db.Model):
+    __tablename__ = "tree_node"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id = mapped_column(ForeignKey("tree_node.id"))
+    data: Mapped[str]
+    children = relationship("TreeNode", back_populates="parent")
+    parent = relationship("TreeNode", back_populates="children", remote_side=[id])

python_plugins/sqla/orm.py

@@ -0,0 +1,40 @@
+from sqlalchemy.types import Integer
+from sqlalchemy.types import Boolean
+from sqlalchemy.types import String
+from sqlalchemy.types import TEXT
+from sqlalchemy.types import Float
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import Date
+from sqlalchemy.types import Time
+from sqlalchemy.types import LargeBinary
+from sqlalchemy.types import JSON
+from sqlalchemy.types import Enum
+
+from sqlalchemy.sql import select
+from sqlalchemy.sql import delete
+from sqlalchemy.sql import func
+from sqlalchemy.sql import cast
+from sqlalchemy.sql import text
+from sqlalchemy.sql import and_
+from sqlalchemy.sql import or_
+from sqlalchemy.sql import not_
+
+from sqlalchemy import Column
+from sqlalchemy import Table
+from sqlalchemy import ForeignKey
+
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import composite
+from sqlalchemy.orm import synonym
+
+from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import selectinload
+
+from sqlalchemy.ext.associationproxy import association_proxy
+from sqlalchemy.ext.associationproxy import AssociationProxy
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.ext.hybrid import hybrid_method
+from sqlalchemy.ext.mutable import MutableDict
+from sqlalchemy.ext.mutable import MutableList

python_plugins/sqla/utils/__init__.py

@@ -0,0 +1,10 @@
+from .attr import is_column
+from .attr import is_relationship
+from .attr import is_hybrid
+from .attr import is_association_proxy
+from .attr import get_field_with_path
+from .expression import parse_like_term
+from .stmt import select_pk_values
+from .stmt import clear
+from .stmt import delete_by_pk_ids
+

python_plugins/sqla/utils/attr.py

@@ -0,0 +1,110 @@
+from typing import Tuple, List
+from sqlalchemy.orm import ColumnProperty
+from sqlalchemy.orm import RelationshipProperty
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.ext.associationproxy import AssociationProxy
+
+def is_instrumented_attribute(attr):
+    return isinstance(attr, InstrumentedAttribute)
+
+
+def is_column(attr):
+    return hasattr(attr, "property") and isinstance(attr.property, ColumnProperty)
+
+
+def is_relationship(attr):
+    return hasattr(attr, "property") and isinstance(attr.property, RelationshipProperty)
+
+
+def is_hybrid(attr):
+    return isinstance(attr, hybrid_property)
+
+def is_association_proxy(attr):
+    return isinstance(attr, AssociationProxy)
+
+
+def get_field_with_path(
+    model, path: str
+) -> Tuple[InstrumentedAttribute, List[InstrumentedAttribute]]:
+    """
+    Resolve a dot-separated field path (e.g., 'profile.contact.email')
+    starting from `model`, handling AssociationProxy and relationships.
+
+    Returns:
+        (final_attr, join_path)
+        - final_attr: The terminal InstrumentedAttribute (e.g., Contact.email)
+        - join_path: List of relationship attributes for explicit joins
+                     (e.g., [User.profile, Profile.contact])
+    """
+    print(model, path)
+    parts = path.split(".")
+    current_model = model
+    current_attr = None
+    join_path: List[InstrumentedAttribute] = []
+
+    for i, part in enumerate(parts):
+        attr = getattr(current_model, part)
+        # Case 1: Column (must be last)
+        if hasattr(attr, "property") and isinstance(attr.property, ColumnProperty):
+            if i != len(parts) - 1:
+                raise ValueError(
+                    f"Column '{part}' cannot be followed by further path segments."
+                )
+            current_attr = attr
+            break
+        # Case 2: Relationship
+        elif is_relationship(attr):
+            if i == len(parts) - 1:
+                raise ValueError(
+                    f"Cannot sort/filter on relationship '{path}' directly. "
+                    "Specify a column (e.g., '{path}.id')."
+                )
+            join_path.append(attr)
+            current_model = attr.property.mapper.class_
+        # Case 3: AssociationProxy
+        elif isinstance(attr, AssociationProxy):
+            # Step into the underlying relationship
+            local_rel_name = attr.local_attr  # str, e.g., 'profile'
+            local_rel = getattr(current_model, local_rel_name)
+
+            if not is_relationship(local_rel):
+                raise ValueError(
+                    f"AssociationProxy '{part}' is not backed by a relationship "
+                    f"(got {type(local_rel.property).__name__})."
+                )
+
+            join_path.append(local_rel)
+            target_model = local_rel.property.mapper.class_
+
+            # Get the remote attribute (should be InstrumentedAttribute in SA 2.0)
+            remote_attr = attr.remote_attr
+
+            # If there are more parts after this proxy, recurse
+            if i < len(parts) - 1:
+                remaining = ".".join(parts[i + 1 :])
+                final_attr, extra_joins = get_field_with_path(target_model, remaining)
+                join_path.extend(extra_joins)
+                return final_attr, join_path
+
+            # This is the last part — ensure remote_attr is usable
+            if isinstance(remote_attr, str):
+                # Fallback for older versions (not needed in SA 2.0+, but safe)
+                remote_attr = getattr(target_model, remote_attr)
+
+            if not hasattr(remote_attr, "property"):
+                raise ValueError(
+                    f"Remote attribute {remote_attr} is not a mapped ORM attribute."
+                )
+
+            current_attr = remote_attr
+            break
+        else:
+            raise ValueError(
+                f"Unsupported attribute type for '{model}':'{part}': {type(attr)}"
+            )
+
+    if current_attr is None:
+        raise RuntimeError("Failed to resolve path — no terminal attribute found.")
+
+    return current_attr, join_path

python_plugins/sqla/utils/expression.py

@@ -0,0 +1,9 @@
+def parse_like_term(term):
+    if term.startswith("^"):
+        stmt = "%s%%" % term[1:]
+    elif term.startswith("="):
+        stmt = term[1:]
+    else:
+        stmt = "%%%s%%" % term
+
+    return stmt

python_plugins/sqla/utils/instance.py

@@ -0,0 +1,12 @@
+from sqlalchemy import inspect
+
+
+def get_identity(instance):
+    """
+    Return primary key values from an instance.
+    """
+    identity = inspect(instance).identity
+    if len(identity) == 1:
+        return identity[0]
+    else:
+        return identity

python_plugins/sqla/utils/model.py

@@ -0,0 +1,31 @@
+from sqlalchemy import inspect
+
+
+def get_model_mapper(model):
+    """
+    Return the mapper for a given model
+    """
+    return inspect(model)
+
+
+def get_primary_key(model):
+    """
+    Return primary key name from a model. If the primary key consists of multiple columns,
+    return the corresponding tuple
+    """
+    mapper = inspect(model)
+    pks = [col.name for col in mapper.primary_key]
+    if len(pks) == 1:
+        return pks[0]
+    elif len(pks) > 1:
+        return tuple(pks)
+    else:
+        return None
+
+
+def get_model_tables(model):
+    """
+    Return a set of table names that the model is mapped to
+    """
+    mapper = inspect(model)
+    return mapper.tables

python_plugins/sqla/utils/stmt.py

@@ -0,0 +1,34 @@
+from sqlalchemy import inspect
+from sqlalchemy import select
+from sqlalchemy import delete
+from sqlalchemy import tuple_
+
+
+def select_pk_values(model):
+    """
+    Return a select statement that selects all primary key values from a model
+    """
+    mapper = inspect(model)
+    stmt = select(*mapper.primary_key)
+    return stmt
+
+def clear(model):
+    """
+    Return a delete statement that deletes all rows of the model
+    """
+    stmt = delete(model)
+    return stmt
+
+def delete_by_pk_ids(model, ids: list):
+    """
+    Return a delete statement that deletes all rows with primary key in ids
+    """
+    mapper = inspect(model)
+    primary_key = mapper.primary_key
+    if len(primary_key) == 1:
+        pk_col = primary_key[0]
+        stmt = delete(model).where(pk_col.in_(ids))
+    else:
+        stmt = delete(model).where(tuple_(*primary_key).in_(ids))
+    return stmt
+

python_plugins/sqla/utils/update.py

@@ -0,0 +1,23 @@
+def update_obj(session, Model, obj, data: dict):
+    """insert or update object
+
+    :param session: sqlalchemy session
+    :param Model: object Model
+    :param obj: object of Model
+    :param data: data dict
+    """
+
+    if obj is None:
+        new_obj = Model()
+        for k in data:
+            if hasattr(new_obj, k):
+                setattr(new_obj, k, data.get(k))
+        session.add(new_obj)
+        session.commit()
+        print(f"{new_obj} inserted")
+    else:
+        for k in data:
+            if hasattr(obj, k):
+                setattr(obj, k, data.get(k))
+        session.commit()
+        print(f"{obj} updated")

{python_plugins-1.0.2.dist-info → python_plugins-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-plugins
-Version: 1.0.2
+Version: 1.0.3
 Summary: A collection of Python functions and classes.
 Project-URL: Documentation, https://python-plugins.readthedocs.io
 Project-URL: Source, https://github.com/ojso/python-plugins
@@ -38,17 +38,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
-Requires-Dist: cryptography>=44.0
-Provides-Extra: jwt
-Requires-Dist: pyjwt; extra == 'jwt'
-Provides-Extra: pillow
-Requires-Dist: pillow; extra == 'pillow'
-Provides-Extra: qrcode
-Requires-Dist: qrcode; extra == 'qrcode'
-Provides-Extra: requests
-Requires-Dist: requests; extra == 'requests'
-Provides-Extra: sqlalchemy
-Requires-Dist: sqlalchemy; extra == 'sqlalchemy'
+Requires-Dist: cryptography>=46.0
+Requires-Dist: flask>=3.1
+Requires-Dist: requests>=2.32
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: wtforms>=3.2
 Description-Content-Type: text/x-rst
 
 python-plugins

python_plugins-1.0.3.dist-info/RECORD

@@ -0,0 +1,53 @@
+python_plugins/__about__.py,sha256=2plzdEEb24FLjE2I2XyBBcJEPYWHccNL4SgtLC_6erg,22
+python_plugins/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+python_plugins/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_plugins/crypto/aes_cipher.py,sha256=7lTvA01h3Z56riv7sB7CrZRh_OO66m21wVTVizU9PYg,1946
+python_plugins/crypto/mixbyte.py,sha256=5re7W0-UuOjnnWW9HK50t6akLAbOtPmz9SQ3nq5w3hk,6649
+python_plugins/crypto/pbkdf_fernet.py,sha256=8CGU4ddco6369NaoXodMKz_h8JMetHrZmMVt30XAICM,2049
+python_plugins/crypto/simple_fernet.py,sha256=Yg5OXiXNcbyQ4EC31c58Vn00pbloGjJpscfbxn2L7YQ,1759
+python_plugins/crypto/tarmix.py,sha256=DmTV-vNLTokUQJWn2H4QUSzfFjMQVrX2MiMpMd_BL0g,4874
+python_plugins/crypto/txtfile_cipher.py,sha256=-mTkvQgtNYLUvrQLKTnepBBdkf-T0w-DnMfZ5wnbklU,4852
+python_plugins/crypto/zip7mix.py,sha256=tQMmX_6ax99LXNfY8HBbu9EXSwQSgGOF3EwWEcrtdUo,5272
+python_plugins/email/__init__.py,sha256=HubZT2h3m5WEjic3NZ0H7gYp-9tUgZaDkAE9O-Tm7hM,26
+python_plugins/email/smtp.py,sha256=CY1fWxdBDqqGZ22R8yqEvFZvMeEsMnqTb4h5IZ8WAVU,1641
+python_plugins/examples/datetime.py,sha256=bmC9d1W7XKA1ED9XO9reUiUyfQcM_BqGoGyOF21RW9A,282
+python_plugins/examples/hashes.py,sha256=uSF3ohZRD7b2VAIvjjpTWC0SlY7QsFhsFZUejINrRGU,640
+python_plugins/examples/higher_order_functions.py,sha256=vTfT3OEfuKkIW7UMD3JtreVDMeRbXHbjlz3G-j-J4x4,4574
+python_plugins/examples/postgresql_dump.py,sha256=zN5aLYLxpon2y9_5gKizRjlrRUlkAO-dG-BuKpJ4F3U,1030
+python_plugins/examples/pretty.py,sha256=igN4uq67AADcPOiy_h3_M-oEwgc1i3gJScbKtkf6d-k,211
+python_plugins/examples/random_string.py,sha256=U7B-bAa4zEpewkd4_8KIPZ0XsPdbGlJ_FEj0FnTGdms,2210
+python_plugins/examples/run_jwt.py,sha256=ZwjUXg5PKeophiXqwSaMlHrhwVKhHTsRb68HtkRLX8k,1485
+python_plugins/examples/run_process.py,sha256=I_wjCqzWI6d39ebL-YArQ8LiXFQ3bwEoCnxJTZK1Zbc,780
+python_plugins/examples/xml2dict.py,sha256=RUxqDt6NKzwbuodTxKVoiR4dP-vNbmL77dztLx_9UzY,164
+python_plugins/examples/tkinter/calculate.py,sha256=M1b-w7-pVe-7FS3erBJxgFNfmm4lzP3zlK41glyhWx8,1142
+python_plugins/ospath/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_plugins/ospath/walk_remove.py,sha256=rnDHr1wGSxufo2YV9_EXeVNEAnT4LGjG7-5dOI2gWY0,494
+python_plugins/sqla/__init__.py,sha256=dJyZS1js_pdpAgLnsqfRFPQBFeZ8PdssdPfTzgie5c8,30
+python_plugins/sqla/db.py,sha256=fA601WJ3QiUyXAQGwS72wa9S1b973T-HK1ZsE6OL0c0,3179
+python_plugins/sqla/orm.py,sha256=7h0oY4TGfdrvAFKedVbKdWTvWHq_Sc-ycd2VvWiZJyo,1331
+python_plugins/sqla/mixins/__init__.py,sha256=l4dJVgUFI7aISA7X-CcVBOp19rXBgqyyhHwtuQnSgR0,241
+python_plugins/sqla/mixins/data_mixin.py,sha256=HCc1uvF6_O4yjK38uWAsqysEedLWgc7wtds3NjQTMZ8,366
+python_plugins/sqla/mixins/primary_key_mixin.py,sha256=QUO-7ZmYtAMMi7ReRQDYV0uwQCnU9dvl6g6GHitYtlA,154
+python_plugins/sqla/mixins/timestamp_mixin.py,sha256=u9rIu0IrzdCRRbnMk4IN4nTlNNiVPB8yPnTcHjQC1KU,547
+python_plugins/sqla/mixins/token_minxin.py,sha256=SxNftZXS-hCwqxov7whF_tBtlayuoi3LUPtu-ofMmdg,276
+python_plugins/sqla/mixins/user_minxin.py,sha256=D-N45bunicBuuwKs--s_tyDxxLC3mkxV9Tva8JAhsko,579
+python_plugins/sqla/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_plugins/sqla/models/association_proxy.py,sha256=a3_ffi4gyXMuDV9NtlCo2POoBxwFCKCA2fSJlfft1Ow,1454
+python_plugins/sqla/models/demo.py,sha256=UbibjsBvm542Gyx8t8qf8Izqs47K88v9BN0Pc2RPAJc,3218
+python_plugins/sqla/models/message.py,sha256=NDxcN8mWnWFTTunf5dz-Tb5FmHv8HHzppsZ8IVHmpAw,435
+python_plugins/sqla/models/model1.py,sha256=NxOsygCCt9q1hpt2QmGsuCs6yl1Kn5tv5HGuhHaPCRQ,4596
+python_plugins/sqla/models/multpk.py,sha256=pexTSm7CzXpf0pD_ECfHraM0QlZcMAYf9Qv_KPijvUA,396
+python_plugins/sqla/models/polymorphic.py,sha256=-nwEoKkAZL97mnykisZ1VkntyeqNLmfEbd7tXxAYnuY,938
+python_plugins/sqla/models/relations.py,sha256=zjbZrhW9pv8Tpnu6zApdO-rhwjbFF3Vv1r_xp5DCKWc,2669
+python_plugins/sqla/models/tree_node.py,sha256=VGGdIGhfDe_0BUp3UpxEjexMSirwezOUXGv-fKiBXvk,575
+python_plugins/sqla/utils/__init__.py,sha256=lq6KaQfwmnobgas87D26ijnaCfDau3H7ZkmozBYWzk0,302
+python_plugins/sqla/utils/attr.py,sha256=IdWj17GXKk4tk-dQROWZh7ZyPPlO4--YaoeZp0EWgUQ,4119
+python_plugins/sqla/utils/expression.py,sha256=_9P59Elc3jqdXFiXxkrRY9gsaUSum-chNMPbiqQcC58,202
+python_plugins/sqla/utils/instance.py,sha256=EbcI3pQhsRj-mPW9ZHs0yQ4zMGVMHw-HtmmXHY15kK0,255
+python_plugins/sqla/utils/model.py,sha256=R9ObqEMDOaYKLv8pcoDHoV7m4mxWHgEDiZ74NokMMjA,678
+python_plugins/sqla/utils/stmt.py,sha256=3GzzEvi0RmvE3q-zBweol9LmsEQ0UPkn9G6P0epNwWw,876
+python_plugins/sqla/utils/update.py,sha256=jsTgivwzIeFSpbpFwb48_pTUNT-KM6TYnGv3wKH98HM,631
+python_plugins-1.0.3.dist-info/METADATA,sha256=1ImRtLGKGW7nNd06mtiLso56_D3ZxVPBy4soald9ghs,2624
+python_plugins-1.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_plugins-1.0.3.dist-info/licenses/LICENSE.rst,sha256=X5eLIsAn1yAKd88LWTYkXUe0PmVK_Z5SD7_5NheGR-s,1104
+python_plugins-1.0.3.dist-info/RECORD,,

{python_plugins-1.0.2.dist-info → python_plugins-1.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

python_plugins/models/update.py

@@ -1,33 +0,0 @@
-def update_obj(db, old_obj, new_data: dict, NewClass, force=None):
-    """insert or update object
-
-    :param db: sqlalchemy db
-    :param old_obj: old object
-    :param new_data: new dict
-    :param NewClass: object class
-    :param force: update= update old object with new attribute
-    """
-    # 1. old is not exist
-    if old_obj is None:
-        new_obj = NewClass()
-        for k in new_data:
-            if hasattr(new_obj, k):
-                setattr(new_obj, k, new_data.get(k))
-        db.session.add(new_obj)
-        db.session.commit()
-        print(f"{new_obj} inserted")
-        return
-
-    # 2. old is exist
-    match force:
-        case None:
-            print(f"{old_obj} exists")
-        case "update":
-            # update old
-            for k in new_data:
-                if hasattr(old_obj, k):
-                    setattr(old_obj, k, new_data.get(k))
-            db.session.commit()
-            print(f"{old_obj} updated")
-        case _:
-            raise Exception

python_plugins-1.0.2.dist-info/RECORD

@@ -1,36 +0,0 @@
-python_plugins/__about__.py,sha256=Y3LSfRioSl2xch70pq_ULlvyECXyEtN3krVaWeGyaxk,22
-python_plugins/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-python_plugins/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_plugins/crypto/aes_cipher.py,sha256=7lTvA01h3Z56riv7sB7CrZRh_OO66m21wVTVizU9PYg,1946
-python_plugins/crypto/mixbyte.py,sha256=5re7W0-UuOjnnWW9HK50t6akLAbOtPmz9SQ3nq5w3hk,6649
-python_plugins/crypto/pbkdf_fernet.py,sha256=8CGU4ddco6369NaoXodMKz_h8JMetHrZmMVt30XAICM,2049
-python_plugins/crypto/simple_fernet.py,sha256=Yg5OXiXNcbyQ4EC31c58Vn00pbloGjJpscfbxn2L7YQ,1759
-python_plugins/crypto/tarmix.py,sha256=DmTV-vNLTokUQJWn2H4QUSzfFjMQVrX2MiMpMd_BL0g,4874
-python_plugins/crypto/txtfile_cipher.py,sha256=-mTkvQgtNYLUvrQLKTnepBBdkf-T0w-DnMfZ5wnbklU,4852
-python_plugins/crypto/zip7mix.py,sha256=x5_N3k6Wr-71Z3cqmPIWqVmzikR7O65xeSr-A42w_Y0,4933
-python_plugins/email/__init__.py,sha256=HubZT2h3m5WEjic3NZ0H7gYp-9tUgZaDkAE9O-Tm7hM,26
-python_plugins/email/smtp.py,sha256=CY1fWxdBDqqGZ22R8yqEvFZvMeEsMnqTb4h5IZ8WAVU,1641
-python_plugins/examples/datetime.py,sha256=bmC9d1W7XKA1ED9XO9reUiUyfQcM_BqGoGyOF21RW9A,282
-python_plugins/examples/hashes.py,sha256=uSF3ohZRD7b2VAIvjjpTWC0SlY7QsFhsFZUejINrRGU,640
-python_plugins/examples/higher_order_functions.py,sha256=vTfT3OEfuKkIW7UMD3JtreVDMeRbXHbjlz3G-j-J4x4,4574
-python_plugins/examples/postgresql_dump.py,sha256=zN5aLYLxpon2y9_5gKizRjlrRUlkAO-dG-BuKpJ4F3U,1030
-python_plugins/examples/pretty.py,sha256=igN4uq67AADcPOiy_h3_M-oEwgc1i3gJScbKtkf6d-k,211
-python_plugins/examples/random_string.py,sha256=U7B-bAa4zEpewkd4_8KIPZ0XsPdbGlJ_FEj0FnTGdms,2210
-python_plugins/examples/run_jwt.py,sha256=ZwjUXg5PKeophiXqwSaMlHrhwVKhHTsRb68HtkRLX8k,1485
-python_plugins/examples/run_process.py,sha256=I_wjCqzWI6d39ebL-YArQ8LiXFQ3bwEoCnxJTZK1Zbc,780
-python_plugins/examples/xml2dict.py,sha256=RUxqDt6NKzwbuodTxKVoiR4dP-vNbmL77dztLx_9UzY,164
-python_plugins/examples/tkinter/calculate.py,sha256=M1b-w7-pVe-7FS3erBJxgFNfmm4lzP3zlK41glyhWx8,1142
-python_plugins/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_plugins/models/update.py,sha256=cIwhR0iKkB7cVx7km_oA9ya97MSkJlLPb8pZWaEePmE,991
-python_plugins/models/mixins/__init__.py,sha256=l4dJVgUFI7aISA7X-CcVBOp19rXBgqyyhHwtuQnSgR0,241
-python_plugins/models/mixins/data_mixin.py,sha256=HCc1uvF6_O4yjK38uWAsqysEedLWgc7wtds3NjQTMZ8,366
-python_plugins/models/mixins/primary_key_mixin.py,sha256=QUO-7ZmYtAMMi7ReRQDYV0uwQCnU9dvl6g6GHitYtlA,154
-python_plugins/models/mixins/timestamp_mixin.py,sha256=u9rIu0IrzdCRRbnMk4IN4nTlNNiVPB8yPnTcHjQC1KU,547
-python_plugins/models/mixins/token_minxin.py,sha256=SxNftZXS-hCwqxov7whF_tBtlayuoi3LUPtu-ofMmdg,276
-python_plugins/models/mixins/user_minxin.py,sha256=D-N45bunicBuuwKs--s_tyDxxLC3mkxV9Tva8JAhsko,579
-python_plugins/ospath/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_plugins/ospath/walk_remove.py,sha256=rnDHr1wGSxufo2YV9_EXeVNEAnT4LGjG7-5dOI2gWY0,494
-python_plugins-1.0.2.dist-info/METADATA,sha256=KusHRGLBBQ9p_y9Ttu9q9Y1p_8WM_kBuPc1bSP8QgQk,2840
-python_plugins-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_plugins-1.0.2.dist-info/licenses/LICENSE.rst,sha256=X5eLIsAn1yAKd88LWTYkXUe0PmVK_Z5SD7_5NheGR-s,1104
-python_plugins-1.0.2.dist-info/RECORD,,