scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/db/{_SQLite3Mixins → _sqlite3/_SQLite3Mixins}/_QueryMixin.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-29 04:31:43 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/_QueryMixin.py
-
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_QueryMixin.py"
+# Timestamp: "2025-09-11 05:49:14 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_SQLite3Mixins/_QueryMixin.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 
 import sqlite3
 from typing import List, Tuple
 
 import pandas as pd
-from .._BaseMixins._BaseQueryMixin import _BaseQueryMixin
 
 
 class _QueryMixin:
@@ -18,34 +21,58 @@ 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:
+        self.ensure_connection()
+        self._check_context_manager()
+
         if not self.cursor:
             raise ConnectionError("Database not connected")
 
         if any(
             keyword in query.upper()
-            for keyword in ["INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER"]
+            for keyword in [
+                "INSERT",
+                "UPDATE",
+                "DELETE",
+                "DROP",
+                "CREATE",
+                "ALTER",
+            ]
         ):
             self._check_writable()
 
         try:
             parameters = self._sanitize_parameters(parameters)
             self.cursor.execute(query, parameters)
-            self.conn.commit()
+            if self.autocommit:
+                self.conn.commit()
+                self.cursor.execute("PRAGMA wal_checkpoint(PASSIVE)")
+                # self.cursor.execute("PRAGMA wal_checkpoint(FULL)")
             return self.cursor
         except sqlite3.Error as err:
             raise sqlite3.Error(f"Query execution failed: {err}")
 
     def executemany(self, query: str, parameters: List[Tuple]) -> None:
+        self.ensure_connection()
         if not self.cursor:
             raise ConnectionError("Database not connected")
 
         if any(
             keyword in query.upper()
-            for keyword in ["INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER"]
+            for keyword in [
+                "INSERT",
+                "UPDATE",
+                "DELETE",
+                "DROP",
+                "CREATE",
+                "ALTER",
+            ]
         ):
             self._check_writable()
 
@@ -57,6 +84,7 @@ class _QueryMixin:
             raise sqlite3.Error(f"Batch query execution failed: {err}")
 
     def executescript(self, script: str) -> None:
+        self.ensure_connection()
         if not self.cursor:
             raise ConnectionError("Database not connected")
 
@@ -79,5 +107,4 @@ class _QueryMixin:
         except sqlite3.Error as err:
             raise sqlite3.Error(f"Script execution failed: {err}")
 
-
 # EOF

scitex/db/{_SQLite3Mixins → _sqlite3/_SQLite3Mixins}/_RowMixin.py

@@ -1,15 +1,26 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+# Timestamp: "2025-09-08 12:00:38 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_SQLite3Mixins/_RowMixin.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
 # Time-stamp: "2024-11-25 01:38:17 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/_RowMixin.py
+
+from typing import Union
 
 THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_RowMixin.py"
 
 import sqlite3
-from typing import List
-from typing import Optional
+from typing import List, Optional
+
 import pandas as pd
-from .._BaseMixins._BaseRowMixin import _BaseRowMixin
+
+from ..._BaseMixins._BaseRowMixin import _BaseRowMixin
 
 
 class _RowMixin:
@@ -19,12 +30,27 @@ class _RowMixin:
         self,
         table_name: str,
         columns: List[str] = None,
+        ids: Union[int, List[int], str] = "all",
         where: str = None,
         order_by: str = None,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         return_as: str = "dataframe",
+        include_blobs: bool = True,
     ):
+        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()
+            else:
+                schema = self.get_table_schema(table_name)
+                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:
             columns_str = "*"
         elif isinstance(columns, str):
@@ -32,6 +58,19 @@ class _RowMixin:
         else:
             columns_str = ", ".join(f'"{col}"' for col in columns)
 
+        # Handle ids parameter
+        if ids != "all":
+            if isinstance(ids, int):
+                id_where = f"id = {ids}"
+            else:
+                id_list = ",".join(map(str, ids))
+                id_where = f"id IN ({id_list})"
+
+            if where:
+                where = f"({where}) AND ({id_where})"
+            else:
+                where = id_where
+
         try:
             query_parts = [f"SELECT {columns_str} FROM {table_name}"]
 
@@ -47,7 +86,9 @@ 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":
@@ -71,5 +112,4 @@ class _RowMixin:
         self.cursor.execute(query)
         return self.cursor.fetchone()[0]
 
-
 # EOF

scitex/db/{_SQLite3Mixins → _sqlite3/_SQLite3Mixins}/_TableMixin.py

@@ -1,19 +1,26 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+# Timestamp: "2025-09-11 05:47:57 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_SQLite3Mixins/_TableMixin.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
 # Time-stamp: "2024-11-25 01:38:47 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/_TableMixin.py
 
 THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/db/_SQLite3Mixins/_TableMixin.py"
 
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-11 19:13:19 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/db/_BaseSQLiteDB_modules/_TableMixin.py
 
 import sqlite3
 from typing import Any, Dict, List, Union
+
 import pandas as pd
-from .._BaseMixins._BaseTableMixin import _BaseTableMixin
+
+from ..._BaseMixins._BaseTableMixin import _BaseTableMixin
 
 
 class _TableMixin:
@@ -38,6 +45,8 @@ class _TableMixin:
                             [
                                 f"{col_name}_dtype TEXT DEFAULT 'unknown'",
                                 f"{col_name}_shape TEXT DEFAULT 'unknown'",
+                                f"{col_name}_is_compressed BOOLEAN DEFAULT FALSE",
+                                f"{col_name}_hash TEXT DEFAULT NULL",
                             ]
                         )
 
@@ -101,9 +110,7 @@ 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)
@@ -121,6 +128,18 @@ class _TableMixin:
                         "TEXT",
                         default_value="'unknown'",
                     )
+                    self.add_column(
+                        table_name,
+                        f"{column_name}_is_compressed",
+                        "BOOLEAN",
+                        default_value="FALSE",
+                    )
+                    self.add_column(
+                        table_name,
+                        f"{column_name}_hash",
+                        "TEXT",
+                        default_value="NULL",
+                    )
 
             except sqlite3.OperationalError as err:
                 raise ValueError(f"Failed to add column: {err}")
@@ -131,6 +150,29 @@ class _TableMixin:
         columns: Union[str, List[str]],
         if_exists: bool = True,
     ) -> None:
+        """
+        DEPRECATED: Use the new drop_columns method from _DropMixin for better compatibility.
+        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
+        )
+        
+        # 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'):
+                # 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):
                 columns = [columns]
@@ -146,15 +188,19 @@ 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]:
+        self.ensure_connection()
         query = "SELECT name FROM sqlite_master WHERE type='table'"
         self.cursor.execute(query)
         return [table[0] for table in self.cursor.fetchall()]
 
     def get_table_schema(self, table_name: str) -> pd.DataFrame:
+        self.ensure_connection()
         query = f"PRAGMA table_info({table_name})"
         self.cursor.execute(query)
         columns = ["cid", "name", "type", "notnull", "dflt_value", "pk"]
@@ -166,6 +212,7 @@ class _TableMixin:
         return pk_col[0] if len(pk_col) > 0 else None
 
     def get_table_stats(self, table_name: str) -> Dict[str, int]:
+        self.ensure_connection()
         try:
             pages = self.cursor.execute(f"PRAGMA page_count").fetchone()[0]
             page_size = self.cursor.execute(f"PRAGMA page_size").fetchone()[0]
@@ -179,5 +226,4 @@ class _TableMixin:
         except sqlite3.Error as err:
             raise ValueError(f"Failed to get table size: {err}")
 
-
 # EOF

scitex/db/{_SQLite3Mixins → _sqlite3/_SQLite3Mixins}/_TransactionMixin.py

@@ -9,7 +9,7 @@ THIS_FILE = (
 
 import sqlite3
 import contextlib
-from .._BaseMixins._BaseTransactionMixin import _BaseTransactionMixin
+from ..._BaseMixins._BaseTransactionMixin import _BaseTransactionMixin
 
 
 class _TransactionMixin:

scitex/db/{_SQLite3Mixins → _sqlite3/_SQLite3Mixins}/__init__.py

@@ -1,11 +1,19 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+# Timestamp: "2025-07-16 09:46:33 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_SQLite3Mixins/__init__.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 # Time-stamp: "2024-11-12 09:29:50 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/db/_SQLite3Mixins/__init__.py
 
+from ._ArrayMixin import _ArrayMixin
 from ._BatchMixin import _BatchMixin
 from ._BlobMixin import _BlobMixin
 from ._ConnectionMixin import _ConnectionMixin
+from ._ColumnMixin import _ColumnMixin
 from ._ImportExportMixin import _ImportExportMixin
 from ._IndexMixin import _IndexMixin
 from ._MaintenanceMixin import _MaintenanceMixin
@@ -13,11 +21,14 @@ from ._QueryMixin import _QueryMixin
 from ._RowMixin import _RowMixin
 from ._TableMixin import _TableMixin
 from ._TransactionMixin import _TransactionMixin
+from ._GitMixin import _GitMixin
 
 __all__ = [
+    "_ArrayMixin",
     "_BatchMixin",
     "_BlobMixin",
     "_ConnectionMixin",
+    "_ColumnMixin",
     "_ImportExportMixin",
     "_IndexMixin",
     "_MaintenanceMixin",
@@ -25,6 +36,7 @@ __all__ = [
     "_RowMixin",
     "_TableMixin",
     "_TransactionMixin",
+    "_GitMixin",
 ]
 
-# EOF
+# EOF

scitex/db/_sqlite3/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""SQLite3 database module."""
+
+from ._SQLite3 import SQLite3
+from ._delete_duplicates import delete_sqlite3_duplicates
+
+__all__ = ["SQLite3", "delete_sqlite3_duplicates"]

scitex/db/_sqlite3/_delete_duplicates.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-16 14:00:04 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_delete_duplicates.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+# Time-stamp: "2024-11-11 14:16:58 (ywatanabe)"
+
+import sqlite3
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import pandas as pd
+
+"""
+Functionality:
+    - Deletes duplicate entries from an SQLite database table
+Input:
+    - SQLite database file path, table name, columns to consider for duplicates
+Output:
+    - Updated SQLite database with duplicates removed
+Prerequisites:
+    - sqlite3, pandas, tqdm, scitex
+"""
+
+
+def _sort_db(
+    cursor: sqlite3.Cursor, table_name: str, columns: List[str]
+) -> None:
+    """
+    Sorts the database table based on the specified columns.
+
+    Parameters
+    ----------
+    cursor : sqlite3.Cursor
+        The cursor object for executing SQL commands.
+    table_name : str
+        The name of the table to be sorted.
+    columns : List[str]
+        The list of column names to sort by, in order of priority.
+
+    Example
+    -------
+    >>> conn = sqlite3.connect('example.db')
+    >>> cursor = conn.cursor()
+    >>> _sort_db(cursor, 'my_table', ['column1', 'column2'])
+    >>> conn.commit()
+    >>> conn.close()
+    """
+    columns_str = ", ".join(columns)
+    temp_table = f"{table_name}_temp"
+
+    cursor.execute(
+        f"CREATE TABLE {temp_table} AS SELECT * FROM {table_name} ORDER BY {columns_str}"
+    )
+    cursor.execute(f"DROP TABLE {table_name}")
+    cursor.execute(f"ALTER TABLE {temp_table} RENAME TO {table_name}")
+
+
+# def _determine_columns(
+#     cursor: sqlite3.Cursor,
+#     table_name: str,
+#     columns: Union[str, List[str]],
+#     include_blob: bool,
+# ) -> List[str]:
+#     cursor.execute(f"PRAGMA table_info({table_name})")
+#     table_info = cursor.fetchall()
+#     all_columns = [col[1] for col in table_info]
+#     column_types = {col[1]: col[2] for col in table_info}
+
+#     if columns == "all":
+#         columns = (
+#             all_columns
+#             if include_blob
+#             else [
+#                 col
+#                 for col in all_columns
+#                 if column_types[col].lower() != "blob"
+#             ]
+#         )
+#     elif isinstance(columns, str):
+#         columns = [columns]
+
+#     columns_str = ", ".join(columns)
+#     print(f"Columns considered for duplicates: {columns_str}")
+
+#     return columns
+
+def _determine_columns(
+    cursor: sqlite3.Cursor,
+    table_name: str,
+    columns: Union[str, List[str]],
+    include_blob: bool,
+) -> List[str]:
+    cursor.execute(f"PRAGMA table_info({table_name})")
+    table_info = cursor.fetchall()
+    all_columns = [col[1] for col in table_info]
+    column_types = {col[1]: col[2] for col in table_info}
+
+    if columns == "all":
+        columns = all_columns
+        # Exclude blob columns
+        if not include_blob:
+            columns = [col for col in columns if column_types[col].lower() != "blob"]
+        # Exclude timestamp columns
+        columns = [col for col in columns if not col.endswith("_at")]
+    elif isinstance(columns, str):
+        columns = [columns]
+
+    columns_str = ", ".join(columns)
+    print(f"Columns considered for duplicates: {columns_str}")
+
+    return columns
+
+def _fetch_as_df(
+    cursor: sqlite3.Cursor, columns: List[str], table_name: str
+) -> pd.DataFrame:
+    print("\nFetching all database entries...")
+    columns_str = ", ".join(columns)
+    query = f"SELECT {columns_str} FROM {table_name}"
+    cursor.execute(query)
+    df_entries = cursor.fetchall()
+    return pd.DataFrame(df_entries, columns=columns)
+
+
+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"\nOriginal entries:\n{df.head()}")
+    print(f"\nDuplicated entries:\n{df_duplicated.head()}")
+    return df_duplicated
+
+
+def verify_duplicated_index(
+    cursor: sqlite3.Cursor,
+    duplicated_row: pd.Series,
+    table_name: str,
+    dry_run: bool,
+) -> Tuple[str, bool]:
+    """Check if entry to delete is the one intended"""
+    columns = list(duplicated_row.index)
+    columns_str = ", ".join(columns)
+
+    where_conditions = " AND ".join([f"{col} = ?" for col in columns])
+    select_query = f"""
+        SELECT {columns_str}
+        FROM {table_name}
+        WHERE {where_conditions}
+    """
+    cursor.execute(select_query, tuple(duplicated_row))
+    entries = cursor.fetchall()
+
+    is_verified = len(entries) >= 1
+
+    if dry_run:
+        print(f"Expected duplicate entry: {tuple(duplicated_row)}")
+        print(f"Found entries: {entries}")
+        print(f"Verification {'succeeded' if is_verified else 'failed'}")
+
+    return select_query, is_verified
+
+
+def _delete_entry(
+    cursor: sqlite3.Cursor,
+    duplicated_row: pd.Series,
+    table_name: str,
+    dry_run: bool = True,
+) -> None:
+    select_query, is_verified = verify_duplicated_index(
+        cursor, duplicated_row, table_name, dry_run
+    )
+    if is_verified:
+        delete_query = select_query.replace("SELECT", "DELETE")
+        if dry_run:
+            print(f"[DRY RUN] Would delete entry:\n{duplicated_row}")
+        else:
+            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}"
+        )
+
+
+def delete_sqlite3_duplicates(
+    lpath_db: str,
+    table_name: str,
+    columns: Union[str, List[str]] = "all",
+    include_blob: bool = False,
+    chunk_size: int = 10_000,
+    dry_run: bool = True,
+) -> Tuple[Optional[int], Optional[int]]:
+    try:
+        conn = sqlite3.connect(lpath_db)
+        cursor = conn.cursor()
+
+        # Vacuum the database to free up space
+        if not dry_run:
+            cursor.execute("VACUUM")
+            conn.commit()
+
+        columns = _determine_columns(cursor, table_name, columns, include_blob)
+        columns_str = ", ".join(columns)
+
+        # Drop temp table if exists from previous run
+        temp_table = f"{table_name}_temp"
+        cursor.execute(f"DROP TABLE IF EXISTS {temp_table}")
+
+        # Get all columns for creating temp table with same structure
+        cursor.execute(f"PRAGMA table_info({table_name})")
+        all_cols_info = cursor.fetchall()
+        all_cols = [col[1] for col in all_cols_info]
+        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")
+
+        # Get total row count
+        total_rows = cursor.execute(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0]
+        print(f"Total rows in table: {total_rows}")
+
+        # Insert unique rows based on specified columns
+        insert_query = f"""
+            INSERT INTO {temp_table}
+            SELECT {all_cols_str}
+            FROM (
+                SELECT *, ROW_NUMBER() OVER (PARTITION BY {columns_str} ORDER BY rowid) as rn
+                FROM {table_name}
+            )
+            WHERE rn = 1
+        """
+
+        if dry_run:
+            print(f"[DRY RUN] Would execute deduplication based on: {columns_str}")
+        else:
+            cursor.execute(insert_query)
+            conn.commit()
+
+        # Count unique rows
+        total_unique = cursor.execute(f"SELECT COUNT(*) FROM {temp_table}").fetchone()[0]
+        total_duplicates = total_rows - total_unique
+
+        if not dry_run:
+            # Replace original table with deduplicated one
+            cursor.execute(f"DROP TABLE {table_name}")
+            cursor.execute(f"ALTER TABLE {temp_table} RENAME TO {table_name}")
+            cursor.execute("VACUUM")
+            conn.commit()
+        else:
+            # Clean up temp table in dry run
+            cursor.execute(f"DROP TABLE IF EXISTS {temp_table}")
+
+        print(f"Total rows processed: {total_rows}")
+        print(f"Total unique rows: {total_unique}")
+        print(f"Total duplicates removed: {total_duplicates}")
+
+        return total_rows, total_duplicates
+
+    except Exception as error:
+        print(f"An error occurred: {error}")
+        return None, None
+
+    finally:
+        conn.close()
+
+# EOF

scitex/decorators/__init__.py

@@ -4,6 +4,7 @@
 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
@@ -27,6 +28,7 @@ __all__ = [
     "batch_pandas_fn",
     "batch_torch_fn",
     "cache_disk",
+    "cache_disk_async",
     "cache_mem",
     "deprecated",
     "disable_auto_order",