sqlalchemy-query-helpers 1.0.1__py3-none-any.whl

sqlalchemy-query-helpers/__init__.py

@@ -0,0 +1,3 @@
+from .main import DB
+
+__all__ = ['DB']

sqlalchemy-query-helpers/main.py

@@ -0,0 +1,277 @@
+from sqlalchemy import create_engine, MetaData, Table, select
+from sqlalchemy.orm import sessionmaker, Query, DeclarativeMeta
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.dialects.mysql import insert
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy import sql
+from typing import Iterable, Union, List, Sequence
+import sqlalchemyhelpers
+
+class DB:
+    is_updated = False
+    name: str
+    base: DeclarativeMeta = None
+
+    def __init__(self, db_name, base: DeclarativeMeta, use_os_env=False, echo=False):
+        self.base = base
+        engine_str = self.make_engine_str(use_os_env)
+        self.engine = create_engine(f'{engine_str}/{db_name}', echo=echo)
+        self.Session = sessionmaker(bind=self.engine)
+        self.session = self.Session()
+
+        base.metadata.create_all(self.engine)  # create tables and index if not exists
+        self.name = self.engine.url.database
+
+    def __del__(self):
+        self.session.close()
+
+    @staticmethod
+    def make_engine_str(use_os_env) -> str:
+        """
+        Create an engine string (schema + netloc), like "mysql+pymysql://USER:PASSWORD@HOST"
+        :param use_os_env: Use OS envs 'DB_USER', 'DB_PASSWORD', 'DB_HOST', instead the `cfg.py` file
+        """
+        if use_os_env:
+            import os
+            try:
+                user = os.environ['DB_USER']
+                password = os.environ['DB_PASSWORD']
+                host = os.environ['DB_HOST']
+            except KeyError:
+                raise RuntimeError("Set the 'DB_USER', 'DB_PASSWORD', 'DB_HOST' OS env variables")
+        else:
+            from cfg import user, password, host
+        engine_str = f'mysql+pymysql://{user}:{password}@{host}'
+        return engine_str
+
+    def get_predifined_table(self, table_name: str, base_metadata):
+        table = Table(table_name, base_metadata, autoload_with=self.engine)
+        return table
+
+    @staticmethod
+    def __check_modelkeys(row: dict, cause_dict: Iterable[InstrumentedAttribute]) -> (dict, dict):
+        """
+        :param row: from self.to_dict()
+        :param cause_dict: the model keys with values to search in database
+        :return:
+            cause_dict: the model keys with values to search in database
+            to_insert_dict: names of database's columns with new values to change
+        """
+        model_keys = [n.key for n in cause_dict]
+        cause_dict = {k: v for k, v in row.items() if k in model_keys}
+        to_insert_dict = {k: v for k, v in row.items() if k not in model_keys}
+        return cause_dict, to_insert_dict
+
+    def __to_dict(self, row: Union[dict, list], mfields: Sequence[InstrumentedAttribute] = None,
+                  use_mfield_keys=True, use_orm_keys=False) -> dict:
+        """ Convert to dict.
+
+        :param row: List values or dict with column name/values. Column names can be stings or model columns.
+        :param mfields: List of fields of table's model. As sqlalchemy Column, not strings.
+        :param use_mfield_keys: Leave mfields as model fields, without converting it to strings.
+        """
+        if isinstance(row, dict):
+            if [k for k, v in row.items() if isinstance(k, InstrumentedAttribute)]:
+                d = {k.key: v for k, v in row.items()} if use_orm_keys else {k.name: v for k, v in row.items()}
+            else:
+                d = row
+            d = self.clean_values(d)
+            return d
+        elif mfields:
+            assert isinstance(row, (list, tuple, str))
+            fields = [f.key for f in mfields] if use_mfield_keys else [f.name for f in mfields]
+            if isinstance(row, (list, tuple)):
+                assert len(mfields) == len(row), "len(mfields) != len(row)"
+            elif isinstance(row, str):
+                assert len(mfields) == 1, "len(mfields) != len(row)"
+                row = [row]
+            d = dict(zip(fields, row))
+            d = self.clean_values(d)
+            return d
+        raise RuntimeError("unknown type 'row'")
+
+    def clean_values(self, d: dict):
+        """ strip() for str values"""
+        d_new = {k: v.strip() or None if isinstance(v, str) else v for k, v in d.items()}
+        return d_new
+
+    def insert(self, t, row: Union[dict, list, tuple], mfields: Union[list, tuple] = None, do_commit=True):
+        """  todo: new_rowid is None. Function 'insert_many' doesn't return anything. But it can be used in some old scripts."""
+        new_rowid = self.insert_many(t, [row], mfields, do_commit)
+        return new_rowid
+
+    def insert_many(self, t, rows: Union[list, tuple], mfields: Union[list, tuple] = None, do_commit=True):
+        for row in rows:
+            row = self.__to_dict(row, mfields, use_orm_keys=True)
+            m = t(**row)
+            self.session.add(m)
+        if do_commit:
+            self.session.commit()
+
+    def insert_one(self, t, row: Union[list, tuple], mfields: Union[list, tuple] = None, ignore=False):
+        q = insert(t).values(self.__to_dict(row, mfields))
+        if ignore:
+            q = q.prefix_with('IGNORE', dialect='mysql')
+        r = self.session.execute(q)
+        self.session.commit()
+        return r.lastrowid
+
+    def insert_ignore(self, t, row: Union[dict, list, tuple], mfields: Iterable[InstrumentedAttribute] = None) -> bool:
+        is_inserted = self.insert_ignore_many(t, [row], mfields)
+        return is_inserted
+
+    def insert_ignore_many(self, t, rows: List[dict], mfields: Iterable[InstrumentedAttribute] = None) -> bool:
+        is_inserted = False
+        for row in rows:
+            row = self.__to_dict(row, mfields, use_orm_keys=True)
+            try:
+                with self.session.begin_nested():
+                    m = t(**row)
+                    self.session.add(m)
+                is_inserted = True
+            except IntegrityError:
+                # print(f'already in DB: {row}')
+                pass
+        self.session.commit()
+        return is_inserted
+
+    def insert_ignore_core(self, t, row: Union[dict, list, tuple], mfields: Union[list, tuple] = None) -> None:
+        """Core instead ORM. IGNORE can ignore don't only doubles. Many warnings."""
+        self.insert_ignore_many_core(t, [row], mfields)
+
+    def insert_ignore_many_core(self, t, rows: List[Union[dict, list, tuple]], mfields: Union[list, tuple] = None) -> None:
+        """Core instead ORM. IGNORE can ignore don't only doubles but other errors. Many warnings."""
+        # for row in rows:
+        #     row = self.to_dict(row, mfields)
+        #     # self.session.execute(insert(t, values=row, prefixes=['IGNORE']))
+        #     s = insert(t).values(row).prefix_with('IGNORE', dialect='mysql')
+        #     # self.session.execute(s)
+        rows_to_insert = [self.__to_dict(row, mfields) for row in rows]
+        q = insert(t).values(rows_to_insert).prefix_with('IGNORE', dialect='mysql')
+        self.session.execute(q)
+        self.session.commit()
+
+    def insert_ignore_instanses(self, instances):
+        if not isinstance(instances, Iterable): instances = (instances,)
+        for m in instances:
+            try:
+                with self.session.begin_nested():
+                    self.session.add(m)
+                    self.session.flush()
+                    # print(f'DB: added {m}')
+            except IntegrityError:
+                pass
+                # print(f'DB: already in {m}')
+        # self.session.commit()
+
+    def update(self, t, row: Union[dict, list, tuple], cause_keys: Union[list, tuple], mfields: Union[list, tuple] = None) -> (bool, bool):
+        row = self.__to_dict(row, mfields)
+        in_keys, not_in_keys = self.__check_modelkeys(row, cause_keys)  # get_check_args(row, keys)
+        rows_updates = Query(t, session=self.session).filter_by(**in_keys).update(not_in_keys)
+        # q = update(t).values(**not_in_keys).where(**in_keys)
+        # rows_updates = self.db.session.execute(q)
+        # self.db.session.commit()
+        return rows_updates
+
+    def update_with_select(self, t, row: Union[dict, list, tuple], cause_dict: Union[list, tuple], mfields: Union[list, tuple] = None) -> (
+            bool, bool):
+        """it dont works"""
+        row = self.__to_dict(row, mfields)
+        is_updated = exist = False
+        cause_dict, to_insert_dict = self.__check_modelkeys(row, cause_dict)
+        # r = Query(t, session=self.session).filter_by(**cause_dict).first()
+        q = select(t).where(**cause_dict).limit(1)
+        r = self.session.execute(q).first()
+        if r:
+            for k, v in to_insert_dict.items():
+                if vars(r)[k] != v:
+                    vars(r)[k] = v  # dont works
+                    is_updated = True
+            exist = True
+        return exist, is_updated
+
+    def upsert_with_select(self, t, row: Union[dict, list, tuple], cause_keys: Union[list, tuple],
+                           mfields: Union[list, tuple] = None) -> (bool, bool):
+        """ A use example
+
+        with dbhandle.atomic():
+            t = ProductsData
+            for date, fid, value in data:
+                is_updated, is_inserted = upsert(
+                    t,
+                    [date.date(), pid, flow_ids[fid], value],
+                    mfields=[t.Date, t.ProductID, t.FlowID, t.Value],
+                    cause_keys=[t.Date, t.ProductID, t.FlowID])
+
+
+        :param t: table model
+        :param row: data, dict, or given mfields then list
+        :param cause_keys: model keys for cause in update. Uniques keys for rows.
+        :param mfields: model keys, if row is list instead dict
+        :return: tuple(bool(is_updated), bool(is_inserted))
+        """
+        row = self.__to_dict(row, mfields)
+        is_updated = is_inserted = False
+        self.session.begin_nested()
+        exist, is_updated = self.update_with_select(t, row, cause_keys)
+        if not exist and not is_updated:
+            c = self.insert(t, row)
+            # if c and c > 0:
+            #     is_inserted = True
+            is_inserted = True
+        self.session.commit()
+        return is_updated, is_inserted
+
+    def upsert(self, t, rows: Union[list[dict], tuple[dict]], mfields=None):
+        rows_to_insert = [self.__to_dict(row, mfields) for row in rows]
+        stmt = insert(t).values(rows_to_insert)
+        update_dict = {x.name: x for x in stmt.inserted}
+        upsert_query = stmt.on_duplicate_key_update(update_dict)
+        self.session.execute(upsert_query)
+
+    # def upsert(self, t, row, mfields=None):
+    #     row = self.to_dict(row, mfields)
+    #     stmt = insert(t).values(row).on_duplicate_key_update(row)
+    #     self.session.execute(stmt)
+    #     # self.session.commit()
+
+    # def __upsert_with_get_all_in_db(self, t, rows: List[Union[dict, tuple]], cause_keys: list, mfields: list = None):
+    #     # all_in_db = self.session.query(t).all()
+    #     # in_keys, not_in_keys = self.get_check_modelkeys(row, cause_keys)  # get_check_args(row, keys)
+    #     all_in_db = self.session.query(*cause_keys).all()
+    #     while rows:
+    #         month, pid, fid, cid, v = rows.pop()
+    #         for row in all_in_db:
+    #             row = self.to_dict(row, mfields)
+    #             in_keys, not_in_keys = self.get_check_modelkeys(row, cause_keys)
+    #             if r.Month == month and r.id == pid and r.FlowID == fid and r.CountryID == cid:
+    #                 r.Value = v
+    #                 break
+    #         else:
+    #             m = t(month, pid, fid, cid, v)
+    #             self.session.add(m)
+    #     self.session.commit()
+
+    # def _upsert_with_get_all_in_db(self, t, rows: List[tuple], cause_keys, ):
+    #     in_keys, not_in_keys = self.get_check_modelkeys(row[], cause_keys)
+    #     row = dict(zip([f.key for f in cause_keys], row))
+    #
+    #     all_in_db = self.session.query(t).all()
+    #     while rows:
+    #         month, pid, fid, cid, v = rows.pop()
+    #         for r in all_in_db:
+    #             if r.Month == month and r.id == pid and r.FlowID == fid and r.CountryID == cid:
+    #                 r.Value = v
+    #                 break
+    #         else:
+    #             m = t(month, pid, fid, cid, v)
+    #             self.session.add(m)
+    #     self.session.commit()
+
+    def execute_sqls(self, sqls: Union[str, list, tuple]):
+        assert isinstance(sqls, (str, list, tuple))
+        if isinstance(sqls, str):
+            sqls = [sqls]
+        conn = self.engine.connect()
+        for s in sqls:
+            conn.execute(sql.text(s))

sqlalchemy_query_helpers-1.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 vladiscripts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlalchemy_query_helpers-1.0.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: sqlalchemy-query-helpers
+Version: 1.0.1
+Summary: Some helpers for SQLAlchemy
+Author-email: vladiscripts <blagopoluchie12@gmail.com>
+Project-URL: Homepage, https://github.com/vladiscripts/sqlalchemy-query-helpers
+Project-URL: Issues, https://github.com/vladiscripts/sqlalchemy-query-helpers/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy
+

sqlalchemy_query_helpers-1.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+sqlalchemy-query-helpers/__init__.py,sha256=xxmsXX2HKm1K8Ay9sy_tXGkPDWz3NXJI0s4xiwPckr0,39
+sqlalchemy-query-helpers/main.py,sha256=QKswZj-gHXAsDjdZbSAnv-vfkwjcfAP8JbN977fQfjs,12464
+sqlalchemy_query_helpers-1.0.1.dist-info/LICENSE,sha256=XUL1pa84eZAnKR9S2WnYrv2M523Oysejy3KPlVSyCks,1069
+sqlalchemy_query_helpers-1.0.1.dist-info/METADATA,sha256=GfG8LKFVMZUBeQXedKnXgulmlZnXuB4N_Kq6UYrWUs4,584
+sqlalchemy_query_helpers-1.0.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+sqlalchemy_query_helpers-1.0.1.dist-info/top_level.txt,sha256=p5rFZ5ojMfUwTxbf9vR_YhgNfg7Tj8HGHvACGlB_36c,25
+sqlalchemy_query_helpers-1.0.1.dist-info/RECORD,,

sqlalchemy_query_helpers-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sqlalchemy_query_helpers-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlalchemy-query-helpers