scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/db/_sqlite3/_SQLite3Mixins/_ConnectionMixin.py

@@ -5,13 +5,16 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 # Time-stamp: "2024-11-29 04:33:58 (ywatanabe)"
 
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_ConnectionMixin.py"
+THIS_FILE = (
+    "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_ConnectionMixin.py"
+)
 
 """
 1. Functionality:
@@ -54,9 +57,7 @@ class _ConnectionMixin:
     def _create_temp_copy(self, db_path: str) -> str:
         """Creates temporary copy of database."""
         temp_dir = tempfile.gettempdir()
-        self.temp_path = os.path.join(
-            temp_dir, f"temp_{os.path.basename(db_path)}"
-        )
+        self.temp_path = os.path.join(temp_dir, f"temp_{os.path.basename(db_path)}")
         shutil.copy2(db_path, self.temp_path)
         return self.temp_path
 
@@ -64,9 +65,7 @@ class _ConnectionMixin:
         if self.conn:
             self.close()
 
-        path_to_connect = (
-            self._create_temp_copy(db_path) if use_temp_db else db_path
-        )
+        path_to_connect = self._create_temp_copy(db_path) if use_temp_db else db_path
 
         self.conn = sqlite3.connect(path_to_connect, timeout=60.0)
         self.cursor = self.conn.cursor()
@@ -79,9 +78,7 @@ class _ConnectionMixin:
             self.cursor.execute("PRAGMA mmap_size = 30000000000")
             self.cursor.execute("PRAGMA temp_store = MEMORY")
             self.cursor.execute("PRAGMA cache_size = -2000")
-            self.cursor.execute(
-                "PRAGMA wal_autocheckpoint = 1000"
-            )  # Auto-checkpoint
+            self.cursor.execute("PRAGMA wal_autocheckpoint = 1000")  # Auto-checkpoint
             self.conn.commit()
 
     def close(self) -> None:
@@ -121,4 +118,5 @@ class _ConnectionMixin:
         if not self.cursor or not self.conn:
             self.reconnect()
 
+
 # EOF

scitex/db/_sqlite3/_SQLite3Mixins/_GitMixin.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -74,13 +75,9 @@ class _GitMixin:
         )
 
         # Initialize HEAD if not exists
-        if not self.execute(
-            "SELECT 1 FROM _git_refs WHERE name='HEAD'"
-        ).fetchone():
+        if not self.execute("SELECT 1 FROM _git_refs WHERE name='HEAD'").fetchone():
             self.execute("INSERT INTO _git_refs VALUES ('HEAD', NULL, 'HEAD')")
-            self.execute(
-                "INSERT INTO _git_refs VALUES ('main', NULL, 'branch')"
-            )
+            self.execute("INSERT INTO _git_refs VALUES ('main', NULL, 'branch')")
 
     def git_commit(self, message: str = "", author: str = "unknown") -> str:
         """Create a new commit with current database state.
@@ -109,9 +106,7 @@ class _GitMixin:
 
         # Generate commit hash
         tree_hash = self._git_calculate_tree_hash(changes)
-        commit_data = (
-            f"{parent_hash}:{message}:{author}:{time.time()}:{tree_hash}"
-        )
+        commit_data = f"{parent_hash}:{message}:{author}:{time.time()}:{tree_hash}"
         commit_hash = hashlib.sha256(commit_data.encode()).hexdigest()[:8]
 
         # Store commit
@@ -253,9 +248,7 @@ class _GitMixin:
             """
             ).fetchall()
 
-    def git_log(
-        self, limit: int = 10, oneline: bool = False
-    ) -> List[Dict[str, Any]]:
+    def git_log(self, limit: int = 10, oneline: bool = False) -> List[Dict[str, Any]]:
         """Show commit history.
 
         Parameters
@@ -450,9 +443,7 @@ class _GitMixin:
     def _git_resolve_ref(self, ref: str) -> Optional[str]:
         """Resolve a reference to a commit hash."""
         # Check if it's already a commit hash
-        if self.execute(
-            "SELECT 1 FROM _git_commits WHERE hash = ?", (ref,)
-        ).fetchone():
+        if self.execute("SELECT 1 FROM _git_commits WHERE hash = ?", (ref,)).fetchone():
             return ref
 
         # Check if it's a branch or tag
@@ -461,23 +452,17 @@ class _GitMixin:
         ).fetchone()
         return result[0] if result else None
 
-    def _git_calculate_changes(
-        self, since_commit: Optional[str]
-    ) -> List[Dict]:
+    def _git_calculate_changes(self, since_commit: Optional[str]) -> List[Dict]:
         """Calculate changes since a commit."""
         changes = []
 
         # Get all tracked tables (exclude git tables)
-        tables = [
-            t for t in self.get_table_names() if not t.startswith("_git_")
-        ]
+        tables = [t for t in self.get_table_names() if not t.startswith("_git_")]
 
         for table in tables:
             # This is simplified - real implementation would track actual changes
             # For now, we'll snapshot current state
-            current_data = self.execute(
-                f"SELECT rowid, * FROM {table}"
-            ).fetchall()
+            current_data = self.execute(f"SELECT rowid, * FROM {table}").fetchall()
 
             for row in current_data[:10]:  # Limit for demo
                 changes.append(
@@ -497,18 +482,14 @@ class _GitMixin:
         tree_data = json.dumps(changes, sort_keys=True, default=str)
         return hashlib.sha256(tree_data.encode()).hexdigest()[:8]
 
-    def _git_find_path(
-        self, from_hash: Optional[str], to_hash: str
-    ) -> List[str]:
+    def _git_find_path(self, from_hash: Optional[str], to_hash: str) -> List[str]:
         """Find path between two commits."""
         if not from_hash:
             return [to_hash]
 
         # Build commit graph
         commits = {}
-        for hash, parent in self.execute(
-            "SELECT hash, parent_hash FROM _git_commits"
-        ):
+        for hash, parent in self.execute("SELECT hash, parent_hash FROM _git_commits"):
             commits[hash] = parent
 
         # Find common ancestor and build path
@@ -528,9 +509,7 @@ class _GitMixin:
             current = result[0] if result else None
         return False
 
-    def _git_apply_changes(
-        self, commit_hash: str, reverse: bool = False
-    ) -> None:
+    def _git_apply_changes(self, commit_hash: str, reverse: bool = False) -> None:
         """Apply or reverse changes from a commit."""
         changes = self.execute(
             """
@@ -545,16 +524,12 @@ class _GitMixin:
             if reverse:
                 # Reverse the operation
                 if op == "INSERT":
-                    self.execute(
-                        f"DELETE FROM {table} WHERE rowid = ?", (row_id,)
-                    )
+                    self.execute(f"DELETE FROM {table} WHERE rowid = ?", (row_id,))
                 elif op == "DELETE" and old_data:
                     # Re-insert deleted data
                     data = pickle.loads(old_data)
                     placeholders = ",".join(["?" for _ in data])
-                    self.execute(
-                        f"INSERT INTO {table} VALUES ({placeholders})", data
-                    )
+                    self.execute(f"INSERT INTO {table} VALUES ({placeholders})", data)
                 elif op == "UPDATE" and old_data:
                     # Restore old data
                     data = pickle.loads(old_data)
@@ -564,13 +539,9 @@ class _GitMixin:
                 if op == "INSERT" and new_data:
                     data = pickle.loads(new_data)
                     placeholders = ",".join(["?" for _ in data])
-                    self.execute(
-                        f"INSERT INTO {table} VALUES ({placeholders})", data
-                    )
+                    self.execute(f"INSERT INTO {table} VALUES ({placeholders})", data)
                 elif op == "DELETE":
-                    self.execute(
-                        f"DELETE FROM {table} WHERE rowid = ?", (row_id,)
-                    )
+                    self.execute(f"DELETE FROM {table} WHERE rowid = ?", (row_id,))
                 # UPDATE handling would go here
 
     def _summarize_changes(self, changes: List[Dict]) -> Dict[str, int]:
@@ -580,4 +551,5 @@ class _GitMixin:
             summary[change["operation"]] += 1
         return summary
 
+
 # EOF

scitex/db/_sqlite3/_SQLite3Mixins/_ImportExportMixin.py

@@ -3,9 +3,7 @@
 # Time-stamp: "2024-11-25 01:36:18 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/_ImportExportMixin.py
 
-THIS_FILE = (
-    "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_ImportExportMixin.py"
-)
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_ImportExportMixin.py"
 
 from typing import List
 

scitex/db/_sqlite3/_SQLite3Mixins/_IndexMixin.py

@@ -3,7 +3,9 @@
 # Time-stamp: "2024-11-25 01:36:45 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/_IndexMixin.py
 
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_IndexMixin.py"
+THIS_FILE = (
+    "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_IndexMixin.py"
+)
 
 from typing import List
 from ..._BaseMixins._BaseIndexMixin import _BaseIndexMixin

scitex/db/_sqlite3/_SQLite3Mixins/_QueryMixin.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -21,10 +22,7 @@ class _QueryMixin:
     def _sanitize_parameters(self, parameters):
         """Convert pandas Timestamp objects to strings"""
         if isinstance(parameters, (list, tuple)):
-            return [
-                str(p) if isinstance(p, pd.Timestamp) else p
-                for p in parameters
-            ]
+            return [str(p) if isinstance(p, pd.Timestamp) else p for p in parameters]
         return parameters
 
     def execute(self, query: str, parameters: Tuple = ()) -> None:
@@ -107,4 +105,5 @@ class _QueryMixin:
         except sqlite3.Error as err:
             raise sqlite3.Error(f"Script execution failed: {err}")
 
+
 # EOF

scitex/db/_sqlite3/_SQLite3Mixins/_RowMixin.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -41,14 +42,14 @@ class _RowMixin:
         if not include_blobs:
             if columns is None:
                 schema = self.get_table_schema(table_name)
-                columns = schema[
-                    ~schema["type"].str.contains("BLOB", case=False)
-                ]["name"].tolist()
+                columns = schema[~schema["type"].str.contains("BLOB", case=False)][
+                    "name"
+                ].tolist()
             else:
                 schema = self.get_table_schema(table_name)
-                blob_columns = schema[
-                    schema["type"].str.contains("BLOB", case=False)
-                ]["name"].tolist()
+                blob_columns = schema[schema["type"].str.contains("BLOB", case=False)][
+                    "name"
+                ].tolist()
                 columns = [col for col in columns if col not in blob_columns]
 
         if columns is None:
@@ -86,9 +87,7 @@ class _RowMixin:
             query = " ".join(query_parts)
             self.cursor.execute(query)
 
-            column_names = [
-                description[0] for description in self.cursor.description
-            ]
+            column_names = [description[0] for description in self.cursor.description]
             data = self.cursor.fetchall()
 
             if return_as == "list":
@@ -112,4 +111,5 @@ class _RowMixin:
         self.cursor.execute(query)
         return self.cursor.fetchone()[0]
 
+
 # EOF

scitex/db/_sqlite3/_SQLite3Mixins/_TableMixin.py

@@ -5,13 +5,16 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 # Time-stamp: "2024-11-25 01:38:47 (ywatanabe)"
 
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_TableMixin.py"
+THIS_FILE = (
+    "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_TableMixin.py"
+)
 
 # Time-stamp: "2024-11-11 19:13:19 (ywatanabe)"
 
@@ -110,7 +113,9 @@ class _TableMixin:
                 return
 
             try:
-                query = f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}"
+                query = (
+                    f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}"
+                )
                 if default_value is not None:
                     query += f" DEFAULT {default_value}"
                 self.execute(query)
@@ -155,23 +160,26 @@ class _TableMixin:
         This method will be removed in a future version.
         """
         import warnings
+
         warnings.warn(
             "TableMixin.drop_columns is deprecated. Use the enhanced drop_columns method "
             "from DropMixin which handles SQLite version compatibility automatically.",
             DeprecationWarning,
-            stacklevel=2
+            stacklevel=2,
         )
-        
+
         # Delegate to the new implementation if available
         # Check all classes in MRO for the enhanced drop_columns method
         for cls in self.__class__.__mro__:
-            if (hasattr(cls, 'drop_columns') and 
-                hasattr(cls, '_supports_native_drop_column') and 
-                cls.__name__ == '_DropMixin'):
+            if (
+                hasattr(cls, "drop_columns")
+                and hasattr(cls, "_supports_native_drop_column")
+                and cls.__name__ == "_DropMixin"
+            ):
                 # Call DropMixin's drop_columns directly
                 cls.drop_columns(self, table_name, columns, if_exists)
                 return
-            
+
         # Fallback to original implementation for compatibility
         with self.transaction():
             if isinstance(columns, str):
@@ -188,9 +196,7 @@ class _TableMixin:
                 return
 
             # Drop multiple columns in a single ALTER TABLE statement
-            drop_clause = ", ".join(
-                f"DROP COLUMN {col}" for col in columns_to_drop
-            )
+            drop_clause = ", ".join(f"DROP COLUMN {col}" for col in columns_to_drop)
             self.execute(f"ALTER TABLE {table_name} {drop_clause}")
 
     def get_table_names(self) -> List[str]:
@@ -226,4 +232,5 @@ class _TableMixin:
         except sqlite3.Error as err:
             raise ValueError(f"Failed to get table size: {err}")
 
+
 # EOF

scitex/db/_sqlite3/_SQLite3Mixins/__init__.py

@@ -4,6 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_SQLite3Mixins/__init__.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------

scitex/db/_sqlite3/__init__.py

@@ -4,4 +4,4 @@
 from ._SQLite3 import SQLite3
 from ._delete_duplicates import delete_sqlite3_duplicates
 
-__all__ = ["SQLite3", "delete_sqlite3_duplicates"]
+__all__ = ["SQLite3", "delete_sqlite3_duplicates"]

scitex/db/_sqlite3/_delete_duplicates.py

@@ -4,6 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_delete_duplicates.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -29,9 +30,7 @@ Prerequisites:
 """
 
 
-def _sort_db(
-    cursor: sqlite3.Cursor, table_name: str, columns: List[str]
-) -> None:
+def _sort_db(cursor: sqlite3.Cursor, table_name: str, columns: List[str]) -> None:
     """
     Sorts the database table based on the specified columns.
 
@@ -91,6 +90,7 @@ def _sort_db(
 
 #     return columns
 
+
 def _determine_columns(
     cursor: sqlite3.Cursor,
     table_name: str,
@@ -117,6 +117,7 @@ def _determine_columns(
 
     return columns
 
+
 def _fetch_as_df(
     cursor: sqlite3.Cursor, columns: List[str], table_name: str
 ) -> pd.DataFrame:
@@ -131,9 +132,7 @@ def _fetch_as_df(
 def _find_duplicated(df: pd.DataFrame) -> pd.DataFrame:
     df_duplicated = df[df.duplicated(keep="first")].copy()
     duplication_rate = len(df_duplicated) / (len(df) - len(df_duplicated))
-    print(
-        f"\n{100*duplication_rate:.2f}% of data was duplicated. Cleaning up..."
-    )
+    print(f"\n{100 * duplication_rate:.2f}% of data was duplicated. Cleaning up...")
     print(f"\nOriginal entries:\n{df.head()}")
     print(f"\nDuplicated entries:\n{df_duplicated.head()}")
     return df_duplicated
@@ -185,9 +184,7 @@ def _delete_entry(
             cursor.execute(delete_query, tuple(duplicated_row))
             print(f"Deleted entry:\n{duplicated_row}")
     else:
-        print(
-            f"Skipping entry (not found or already deleted):\n{duplicated_row}"
-        )
+        print(f"Skipping entry (not found or already deleted):\n{duplicated_row}")
 
 
 def delete_sqlite3_duplicates(
@@ -221,7 +218,9 @@ def delete_sqlite3_duplicates(
         all_cols_str = ", ".join(all_cols)
 
         # Create temp table with same structure
-        cursor.execute(f"CREATE TABLE {temp_table} AS SELECT {all_cols_str} FROM {table_name} LIMIT 0")
+        cursor.execute(
+            f"CREATE TABLE {temp_table} AS SELECT {all_cols_str} FROM {table_name} LIMIT 0"
+        )
 
         # Get total row count
         total_rows = cursor.execute(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0]
@@ -245,7 +244,9 @@ def delete_sqlite3_duplicates(
             conn.commit()
 
         # Count unique rows
-        total_unique = cursor.execute(f"SELECT COUNT(*) FROM {temp_table}").fetchone()[0]
+        total_unique = cursor.execute(f"SELECT COUNT(*) FROM {temp_table}").fetchone()[
+            0
+        ]
         total_duplicates = total_rows - total_unique
 
         if not dry_run:
@@ -271,4 +272,5 @@ def delete_sqlite3_duplicates(
     finally:
         conn.close()
 
+
 # EOF

scitex/decorators/__init__.py

@@ -1,13 +1,35 @@
 #!/usr/bin/env python3
 """Scitex decorators module."""
 
-from ._auto_order import AutoOrderDecorator, batch_fn, disable_auto_order, enable_auto_order, numpy_fn, pandas_fn, torch_fn
+from ._auto_order import (
+    AutoOrderDecorator,
+    batch_fn,
+    disable_auto_order,
+    enable_auto_order,
+    numpy_fn,
+    pandas_fn,
+    torch_fn,
+)
 from ._batch_fn import batch_fn
 from ._cache_disk import cache_disk
 from ._cache_disk_async import cache_disk_async
 from ._cache_mem import cache_mem
-from ._combined import batch_numpy_fn, batch_pandas_fn, batch_torch_fn, numpy_batch_fn, pandas_batch_fn, torch_batch_fn
-from ._converters import ConversionWarning, is_cuda, is_nested_decorator, is_torch, to_numpy, to_torch
+from ._combined import (
+    batch_numpy_fn,
+    batch_pandas_fn,
+    batch_torch_fn,
+    numpy_batch_fn,
+    pandas_batch_fn,
+    torch_batch_fn,
+)
+from ._converters import (
+    ConversionWarning,
+    is_cuda,
+    is_nested_decorator,
+    is_torch,
+    to_numpy,
+    to_torch,
+)
 from ._deprecated import deprecated
 from ._not_implemented import not_implemented
 from ._numpy_fn import numpy_fn
@@ -19,14 +41,17 @@ from ._torch_fn import torch_fn
 from ._wrap import wrap
 from ._xarray_fn import xarray_fn
 
+
 # Lazy import session decorator to avoid circular imports
 def __getattr__(name):
-    if name == 'session':
+    if name == "session":
         # Import the parent scitex module to get the wrapper
         import scitex
+
         return scitex.session
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
+
 __all__ = [
     "AutoOrderDecorator",
     "ConversionWarning",