database-wrapper 0.1.44__py3-none-any.whl → 0.1.72__py3-none-any.whl

database_wrapper/serialization.py

@@ -0,0 +1,82 @@
+import datetime
+import json
+import re
+
+from decimal import Decimal
+from enum import Enum
+from typing import Any, Type
+
+
+class SerializeType(Enum):
+    DATETIME = "datetime"
+    JSON = "json"
+    ENUM = "enum"
+
+
+def jsonEncoder(obj: Any) -> Any:
+    if isinstance(obj, Decimal):
+        return float(obj)
+
+    if isinstance(obj, datetime.date) or isinstance(obj, datetime.datetime):
+        return obj.strftime("%Y-%m-%dT%H:%M:%S")
+
+    if isinstance(obj, Enum):
+        return obj.value
+
+    if isinstance(obj, int) or isinstance(obj, float) or isinstance(obj, str):
+        return obj
+
+    return str(obj)
+
+
+def serializeValue(value: Any, sType: SerializeType) -> Any:
+    if sType == SerializeType.DATETIME:
+        if not isinstance(value, datetime.datetime):
+            return value
+
+        return value.isoformat()
+
+    if sType == SerializeType.JSON:
+        return json.dumps(value, default=jsonEncoder)
+
+    if sType == SerializeType.ENUM:
+        return value.value
+    return value
+
+
+def deserializeValue(
+    value: Any,
+    sType: SerializeType,
+    enumClass: Type[Enum] | None = None,
+) -> Any:
+    if sType == SerializeType.DATETIME:
+        if isinstance(value, datetime.datetime):
+            return value
+
+        if value and isinstance(value, str):
+            pattern = r"^\d+(\.\d+)?$"
+            if re.match(pattern, value):
+                return datetime.datetime.fromtimestamp(float(value))
+
+            return datetime.datetime.fromisoformat(value)
+
+        return datetime.datetime.now(datetime.UTC)
+
+    if sType == SerializeType.JSON:
+        if isinstance(value, dict) or isinstance(value, list) or value is None:
+            return value  # type: ignore
+
+        return json.loads(value)
+
+    if sType == SerializeType.ENUM:
+        if enumClass is None:
+            raise ValueError(
+                "enumClass (enum_class) must be provided when deserializing Enum"
+            )
+
+        if isinstance(value, Enum) or value is None:
+            return value
+
+        return enumClass(value)
+
+    return value

database_wrapper/utils/__init__.py

@@ -1,7 +1,5 @@
-from .timer import Timer
 from .dataclass_addons import ignore_unknown_kwargs
 
 __all__ = [
-    "Timer",
     "ignore_unknown_kwargs",
 ]

database_wrapper/utils/dataclass_addons.py

@@ -12,7 +12,7 @@ def ignore_unknown_kwargs() -> Callable[[AnyDataType], AnyDataType]:
         originalInit = cls.__init__
 
         # @wraps(originalInit)
-        def newInit(self: Any, *args: Any, **kwargs: Any):
+        def newInit(self: Any, *args: Any, **kwargs: Any) -> None:
             # Filter out kwargs that are not properties of the class
             valid_kwargs = {k: v for k, v in kwargs.items() if hasattr(self, k)}
             originalInit(self, *args, **valid_kwargs)

{database_wrapper-0.1.44.dist-info → database_wrapper-0.1.72.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: database_wrapper
-Version: 0.1.44
+Version: 0.1.72
 Summary: A Different Approach to Database Wrappers in Python
 Author-email: Gints Murans <gm@gm.lv>
 License: GNU General Public License v3.0 (GPL-3.0)
@@ -32,27 +32,29 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: all
-Requires-Dist: database-wrapper[mssql,mysql,pgsql,sqlite] ; extra == 'all'
-Provides-Extra: dev
-Requires-Dist: ast-comments >=1.1.2 ; extra == 'dev'
-Requires-Dist: codespell >=2.2 ; extra == 'dev'
-Requires-Dist: build >=1.2.1 ; extra == 'dev'
-Requires-Dist: black >=24.1.0 ; extra == 'dev'
-Requires-Dist: types-setuptools >=61.0.0 ; extra == 'dev'
-Requires-Dist: types-pymssql >=2.1.0 ; extra == 'dev'
-Requires-Dist: psycopg[binary] >=3.2.0 ; extra == 'dev'
-Requires-Dist: psycopg[pool] >=3.2.0 ; extra == 'dev'
-Requires-Dist: mysqlclient >=2.2.2 ; extra == 'dev'
-Requires-Dist: pymssql >=2.2.10 ; extra == 'dev'
-Provides-Extra: mssql
-Requires-Dist: database-wrapper-mssql ==0.1.44 ; extra == 'mssql'
-Provides-Extra: mysql
-Requires-Dist: database-wrapper-mysql ==0.1.44 ; extra == 'mysql'
 Provides-Extra: pgsql
-Requires-Dist: database-wrapper-pgsql ==0.1.44 ; extra == 'pgsql'
+Requires-Dist: database_wrapper_pgsql==0.1.72; extra == "pgsql"
+Provides-Extra: mysql
+Requires-Dist: database_wrapper_mysql==0.1.72; extra == "mysql"
+Provides-Extra: mssql
+Requires-Dist: database_wrapper_mssql==0.1.72; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database-wrapper-sqlite ==0.1.44 ; extra == 'sqlite'
+Requires-Dist: database_wrapper_sqlite==0.1.72; extra == "sqlite"
+Provides-Extra: all
+Requires-Dist: database_wrapper[mssql,mysql,pgsql,sqlite]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: ast-comments>=1.1.2; extra == "dev"
+Requires-Dist: codespell>=2.2; extra == "dev"
+Requires-Dist: build>=1.2.1; extra == "dev"
+Requires-Dist: black>=24.1.0; extra == "dev"
+Requires-Dist: mypy>=1.9.0; extra == "dev"
+Requires-Dist: types-setuptools>=61.0.0; extra == "dev"
+Requires-Dist: types-pymssql>=2.1.0; extra == "dev"
+Requires-Dist: types-mysqlclient>=2.2.0; extra == "dev"
+Requires-Dist: psycopg[binary]>=3.2.0; extra == "dev"
+Requires-Dist: psycopg[pool]>=3.2.0; extra == "dev"
+Requires-Dist: mysqlclient>=2.2.2; extra == "dev"
+Requires-Dist: pymssql>=2.2.10; extra == "dev"
 
 # database_wrapper
 

database_wrapper-0.1.72.dist-info/RECORD

@@ -0,0 +1,17 @@
+database_wrapper/__init__.py,sha256=p-HLz9_zByIUeAS1tVxS7ZieslsryHSLw_IKZphqB7w,1200
+database_wrapper/abc.py,sha256=JiQo6Yfv7xALrrHeICJCSgmyP2gHrp16Ov83mPBTGbE,2058
+database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
+database_wrapper/config.py,sha256=r8H8ElFt2aifHOvuRwdfRu09_dCjrQe_zNEMLwDZtyY,334
+database_wrapper/db_backend.py,sha256=huueyQH_FW36qQIGx7dofFA2cTqwKZ2r7F2BTaF7K_o,7176
+database_wrapper/db_data_model.py,sha256=boLYcSJZhSUMeeUd21iEERIo5K-oERPG_gBAdfNOKDQ,14077
+database_wrapper/db_wrapper.py,sha256=vpRifOT7e9d6PmlXIQde-tZ4hEceSgzGFO2hwc4XsBI,14353
+database_wrapper/db_wrapper_async.py,sha256=iUcvRZ1L3wNBt0MCx6tSYbtcuN7Kzgq37HkShqnOoXA,14739
+database_wrapper/db_wrapper_mixin.py,sha256=GR6Zn-2GygzzSaFWPIqkiI6mZ8oWqKY_Sc-MeUp6SG8,9966
+database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+database_wrapper/serialization.py,sha256=_yA1srkS6Vec3TMOAYpsCAbJFuB6nrblt8uJrY-7s0E,2046
+database_wrapper/utils/__init__.py,sha256=uC8YaJqfyFIZIeNdTRTbZwcOUVhmnS5eyOG-9gMs70c,96
+database_wrapper/utils/dataclass_addons.py,sha256=r8DD40tXA_DLMQJx62UqVaRe4Gr9BSOmChLRhxawet4,770
+database_wrapper-0.1.72.dist-info/METADATA,sha256=bT8f7OJWnpD5I4CEntQMFaXFKUyxiHw4DeGOxABX9fA,3440
+database_wrapper-0.1.72.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+database_wrapper-0.1.72.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
+database_wrapper-0.1.72.dist-info/RECORD,,

{database_wrapper-0.1.44.dist-info → database_wrapper-0.1.72.dist-info}/WHEEL

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

database_wrapper/utils/timer.py

@@ -1,297 +0,0 @@
-import time
-import logging
-
-from typing import Any, TypedDict
-from contextlib import asynccontextmanager, contextmanager
-
-
-class TimerProperties(TypedDict):
-    level: int
-    total: float
-    runtimes: dict[int, float]
-
-
-class Timer:
-    name: str
-
-    startTimes: dict[str, float]
-    totalTimes: dict[str, TimerProperties]
-
-    timers: list[tuple[int, str]]
-    level: int
-    runIndex: int
-
-    def __init__(self, name: str):
-        self.name = name
-
-        self.startTimes = {}
-        self.totalTimes = {}
-        self.timers = []
-        self.level = 0
-        self.runIndex = 0
-
-    # * Class generator
-    @contextmanager
-    def enter(self, name: str):
-        self.level += 1
-        self.start(name=name)
-
-        try:
-            yield self
-        finally:
-            self.stop(name=name)
-            self.level -= 1
-
-    @asynccontextmanager
-    async def aenter(self, name: str):
-        self.level += 1
-        self.start(name=name)
-
-        try:
-            yield self
-        finally:
-            self.stop(name=name)
-            self.level -= 1
-
-    # * Class context manager
-    def __enter__(self) -> "Timer":
-        self.start()
-        return self
-
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self.stop()
-
-    async def __aenter__(self) -> "Timer":
-        self.start()
-        return self
-
-    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self.stop()
-
-    # * Start / stop
-    def start(self, name: str | None = None, skipAppend: bool = False):
-        if name is None:
-            name = self.name
-
-        if len(self.timers) > 0:
-            (
-                level,
-                prevTimerName,
-            ) = self.timers[-1]
-            if prevTimerName != name and level != self.level:
-                self.stop(name=prevTimerName, skipRemove=True)
-
-        self.startTimes[name] = time.perf_counter()
-
-        if not skipAppend:
-            self.timers.append(
-                (
-                    self.level,
-                    name,
-                )
-            )
-
-    def stop(
-        self,
-        name: str | None = None,
-        skipRemove: bool = False,
-    ):
-        if name is None:
-            name = self.name
-        endTime = time.perf_counter()
-
-        if not name in self.startTimes:
-            logging.getLogger().warning(f"Timer {name} stopped before it was started")
-            return
-
-        elapsed = endTime - self.startTimes[name]
-        if not name in self.totalTimes:
-            self.totalTimes[name] = TimerProperties(
-                level=self.level, total=0, runtimes={}
-            )
-
-        self.totalTimes[name]["runtimes"][self.runIndex] = elapsed
-        self.totalTimes[name]["total"] += elapsed
-
-        if not skipRemove:
-            # Remove current timer
-            self.timers.pop()
-
-            # Continue previous timer
-            if len(self.timers) > 0:
-                (
-                    level,
-                    prevTimerName,
-                ) = self.timers[-1]
-                if prevTimerName != name and level != self.level:
-                    self.start(name=prevTimerName, skipAppend=True)
-
-    # * Stats
-    def resetTimers(self):
-        """Resets the current timer. Call this at the start of an iteration."""
-        self.startTimes = {}
-        self.totalTimes = {}
-
-    # * Output
-    def printTimerStatsTable(self, returnData: bool = False) -> str | None:
-        """Prints the current timing information into a table."""
-        timerStats = "\n\n"
-
-        all_fn_names = [k for k in self.totalTimes.keys()]
-        if len(all_fn_names) == 0:
-            return
-
-        # Max width of level column
-        max_level_width = max([self.totalTimes[k].get("level") for k in all_fn_names])
-        if max_level_width % 2 == 1:
-            max_level_width += 1
-        max_level_width = max(max_level_width, 6)
-
-        # Max width of name column
-        max_name_width = max([len(k) for k in all_fn_names] + [4])
-        if max_name_width % 2 == 1:
-            max_name_width += 1
-
-        # Format string
-        format_str = (
-            "{:>%d} | {:>%d} | {:>10.4f} | {:>10.4f} | {:>10.4f} | {:>10.4f} | {:>5}"
-            % (
-                max_level_width,
-                max_name_width,
-            )
-        )
-
-        header = (
-            "{:>%d} | {:>%d} | {:^10} | {:^10} | {:^10} | {:^10} | {:^5}"
-            % (
-                max_level_width,
-                max_name_width,
-            )
-        ).format(
-            "Level", "Name", "Total (ms)", "Min (ms)", "Max (ms)", "Avg (ms)", "Count"
-        )
-        timerStats += f"{header}\n"
-
-        sepIdx = header.find("|")
-        sepText = ("-" * sepIdx) + "+" + ("-" * (len(header) - sepIdx - 1))
-        timerStats += f"{sepText}\n"
-
-        for name in all_fn_names:
-            runtimes = self.totalTimes[name].get("runtimes", {}).values()
-            total_time = self.totalTimes[name].get("total", 0) * 1000
-            min_time = min(runtimes) * 1000 if runtimes else 0
-            max_time = max(runtimes) * 1000 if runtimes else 0
-            avg_time = (sum(runtimes) / len(runtimes)) * 1000 if runtimes else 0
-            run_count = len(runtimes)
-
-            timerStats += format_str.format(
-                self.totalTimes[name].get("level"),
-                name,
-                total_time,
-                min_time,
-                max_time,
-                avg_time,
-                run_count,
-            )
-            timerStats += "\n"
-
-        totals_format_str = (
-            "{:>%d} | {:>%d} | {:>10.4f} | {:>10.4} | {:>10.4} | {:>10.4} | {:>10.4}"
-            % (
-                max_level_width,
-                max_name_width,
-            )
-        )
-        timerStats += f"{sepText}\n"
-        timerStats += totals_format_str.format(
-            "",
-            "Total",
-            self.totalTime(self.totalTimes) * 1000,
-            "",
-            "",
-            "",
-            "",
-        )
-        timerStats += "\n\n"
-
-        if returnData:
-            return timerStats
-
-        logging.getLogger().debug(timerStats)
-
-    def printTimerStatsJSON(self, returnData: bool = False) -> str | None:
-        """Prints the current timing information into a JSON string."""
-        pass
-
-    def printTimerStatsCSV(self, returnData: bool = False) -> str | None:
-        """Prints the current timing information into a CSV string."""
-        all_fn_names = list(self.totalTimes.keys())
-        if not all_fn_names:
-            return
-
-        # Prepare header
-        header = all_fn_names + ["Total"]
-
-        # Get all runtime indices and find the maximum index
-        all_indices: set[int] = set()
-        for name in all_fn_names:
-            all_indices.update(self.totalTimes[name].get("runtimes", {}).keys())
-        max_index = max(all_indices) if all_indices else 0
-
-        # Prepare data rows
-        data_rows: "list[list[str]]" = []
-        for i in range(max_index + 1):
-            row: "list[str]" = []
-            row_total = 0
-            for name in all_fn_names:
-                runtime = self.totalTimes[name].get("runtimes", {}).get(i)
-                if runtime is not None:
-                    value = runtime * 1000
-                    row.append(f"{value:.4f}")
-                    row_total += value
-                else:
-                    row.append("")
-            row.append(f"{row_total:.4f}")
-            data_rows.append(row)
-
-        # Prepare total row
-        total_row: "list[str]" = []
-        grand_total = 0
-        for name in all_fn_names:
-            total = sum(self.totalTimes[name].get("runtimes", {}).values()) * 1000
-            total_row.append(f"{total:.4f}")
-            grand_total += total
-        total_row.append(f"{grand_total:.4f}")
-
-        # Combine all rows
-        all_rows = [header] + data_rows + [total_row]
-
-        # Convert to CSV string
-        output = "\n".join([",".join(str(cell) for cell in row) for row in all_rows])
-
-        if returnData:
-            return output
-
-        logging.getLogger().info(f"\n{output}")
-
-    def printTimerStats(
-        self,
-        outputFormat: str = "table",
-        returnData: bool = False,
-    ) -> str | None:
-        """
-        Prints the current timing information into a table.
-
-        outputFormat: str - choices: ["table", "json", "csv"]
-        """
-
-        if outputFormat == "table":
-            return self.printTimerStatsTable(returnData=returnData)
-        elif outputFormat == "json":
-            return self.printTimerStatsJSON(returnData=returnData)
-        elif outputFormat == "csv":
-            return self.printTimerStatsCSV(returnData=returnData)
-
-    def totalTime(self, totalTimes: dict[str, TimerProperties]) -> float:
-        """Returns the total amount accumulated across all functions in seconds."""
-        return sum([timer.get("total") for _name, timer in totalTimes.items()])

database_wrapper-0.1.44.dist-info/RECORD

@@ -1,16 +0,0 @@
-database_wrapper/__init__.py,sha256=amoShlhRpOhrFbGeKbdq47H5omcVRd4xWG-RUX7bdIk,830
-database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
-database_wrapper/config.py,sha256=hFaefMZ_4XVacDd5n5tPNQVi_fEDbG3ZCB-awE9TPxc,334
-database_wrapper/db_backend.py,sha256=CNfkx-UKVmrR8dSXT5SYpPU3whCL61gxljNVpvcIKXc,5068
-database_wrapper/db_data_model.py,sha256=NV4wfbASIVoSLIXWlHAYxCpVN7-ADKfG6OtYEyTyd_w,12123
-database_wrapper/db_wrapper.py,sha256=O5H7Q8xvvzN4p7KL_NnHflY-EZCfw9TM5mYBzRuJfZA,16488
-database_wrapper/db_wrapper_async.py,sha256=4K-01_UtNxaRgN5qB3j1O2eBX2cOW0xi2ZJJimnqgYw,16714
-database_wrapper/db_wrapper_mixin.py,sha256=-k8Gna_iGE5Gz1gRsVP8sOkUbwX3djjCWeM3ZkGKT7E,10570
-database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-database_wrapper/utils/__init__.py,sha256=mnewmY38-837VAh4f42hvpMUBVUjOLoMtIfdZBxbkg0,134
-database_wrapper/utils/dataclass_addons.py,sha256=5_ZAj8h-4RtimEM-b9lo6TXi4qYVTf7KIjTtu0jzAS4,762
-database_wrapper/utils/timer.py,sha256=ZJpVMsQ7oHHgyuqMOxVee1fZD78kcDrP4c8gHug3xGU,8927
-database_wrapper-0.1.44.dist-info/METADATA,sha256=8ceRUd7R_lUMgLpnzdq78fntrH9BUo2Z-PuiAn_WzNg,3370
-database_wrapper-0.1.44.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-database_wrapper-0.1.44.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
-database_wrapper-0.1.44.dist-info/RECORD,,