python-plugins 1.0.2__tar.gz → 1.0.3__tar.gz

{python_plugins-1.0.2 → python_plugins-1.0.3}/CHANGES.rst

@@ -1,3 +1,9 @@
+v1.0.3
+------
+Released 2026-02-08
+
+- sqlalchemy inspect model
+
 v1.0.2
 ------
 

{python_plugins-1.0.2 → python_plugins-1.0.3}/PKG-INFO

@@ -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.2 → python_plugins-1.0.3}/docs/api/crypto.rst

@@ -11,8 +11,5 @@ crypto
 .. autoclass:: python_plugins.crypto.txtfile_cipher.TxtFileCipher
     :members:
 
-.. autoclass:: python_plugins.crypto.zip7mix.Zip7Mix
-    :members:
-
 .. autoclass:: python_plugins.crypto.tarmix.TarMix
     :members:

python_plugins-1.0.3/docs/api/sqlalchemy.rst

@@ -0,0 +1,13 @@
+============
+sqlalchemy
+============
+
+.. code-block:: python
+
+   from python_plugins.sqla import db
+   from python_plugins.sqla.mixins import PrimaryKeyMixin
+   from python_plugins.sqla.mixins import DataMixin
+   from python_plugins.sqla.mixins import TimestampMixin
+
+   class MyModel(db.Model,PrimaryKeyMixin, DataMixin, TimestampMixin):
+      __tablename__ = "my_model"

{python_plugins-1.0.2 → python_plugins-1.0.3}/pyproject.toml

@@ -24,16 +24,13 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-  "cryptography>=44.0",
+  "Flask>=3.1",
+  "WTForms>=3.2",
+  "SQLAlchemy>=2.0",
+  "requests>=2.32",
+  "cryptography>=46.0",
 ]
 
-[project.optional-dependencies]
-requests = ["requests"]
-sqlalchemy = ["SQLAlchemy"]
-pillow = ["pillow"]
-qrcode = ["qrcode"]
-jwt = ["PyJWT"]
-
 [project.urls]
 Documentation = "https://python-plugins.readthedocs.io"
 Source = "https://github.com/ojso/python-plugins"

python_plugins-1.0.3/requirements/develop.in

@@ -0,0 +1,2 @@
+pytest
+Faker

python_plugins-1.0.3/requirements/example.in

@@ -0,0 +1 @@
+PyJWT

python_plugins-1.0.3/src/python_plugins/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.0.3"

{python_plugins-1.0.2 → python_plugins-1.0.3}/src/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-1.0.3/src/python_plugins/sqla/__init__.py

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

python_plugins-1.0.3/src/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-1.0.3/src/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-1.0.3/src/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-1.0.3/src/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-1.0.3/src/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-1.0.3/src/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-1.0.3/src/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",
+    }