mayutils 1.2.6__tar.gz → 1.2.8__tar.gz

{mayutils-1.2.6 → mayutils-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mayutils
-Version: 1.2.6
+Version: 1.2.8
 Summary: Utilities for Python from Mayuran Visakan
 Author: Mayuran Visakan
 Author-email: Mayuran Visakan <mayuran.k.v@gmail.com>

{mayutils-1.2.6 → mayutils-1.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mayutils"
-version = "1.2.6"
+version = "1.2.8"
 description = "Utilities for Python from Mayuran Visakan"
 authors = [
     { name = "Mayuran Visakan", email = "mayuran.k.v@gmail.com" }

{mayutils-1.2.6 → mayutils-1.2.8}/src/mayutils/data/queries/__init__.py

@@ -24,7 +24,7 @@ QUERIES_FOLDERS = get_queries_folders()
 
 def get_query(
     query_name: Path | str,
-    queries_folders: tuple[Path, ...],
+    queries_folders: tuple[Path, ...] = QUERIES_FOLDERS,
 ) -> str:
     path = Path(query_name)
     for queries_folder in queries_folders:
@@ -33,7 +33,12 @@ def get_query(
         except ValueError:
             continue
 
-    return read_file(path=path)
+    try:
+        return read_file(path=path)
+    except ValueError:
+        raise ValueError(
+            f"No such query {query_name} found in the query folders {', '.join(list(map(str, queries_folders)))} or at the path {path}"
+        )
 
 
 def get_formatted_query(

mayutils-1.2.8/src/mayutils/data/read.py

@@ -0,0 +1,86 @@
+from functools import _lru_cache_wrapper
+from pathlib import Path
+from typing import Literal, overload
+
+from pandas import DataFrame
+import polars as pl
+
+from mayutils.data import CACHE_FOLDER
+from mayutils.data.queries import QUERIES_FOLDERS, get_formatted_query
+from mayutils.environment.filesystem import encode_path
+from mayutils.environment.memoisation import DataframeBackends
+from mayutils.objects.dataframes import DataFrames, read_parquet, to_parquet
+from mayutils.objects.hashing import hash_inputs
+
+
+@overload
+def get_query_data(
+    query_name: Path | str,
+    read_query: _lru_cache_wrapper[DataFrames],
+    dataframe_backend: Literal["pandas"],
+    queries_folders: tuple[Path, ...] = QUERIES_FOLDERS,
+    cache: bool | Literal["persistent"] = True,
+    **format_kwargs,
+) -> DataFrame: ...
+
+
+@overload
+def get_query_data(
+    query_name: Path | str,
+    read_query: _lru_cache_wrapper[DataFrames],
+    dataframe_backend: Literal["polars"],
+    queries_folders: tuple[Path, ...] = QUERIES_FOLDERS,
+    cache: bool | Literal["persistent"] = True,
+    **format_kwargs,
+) -> pl.DataFrame: ...
+
+
+def get_query_data(
+    query_name: Path | str,
+    read_query: _lru_cache_wrapper[DataFrames],
+    dataframe_backend: DataframeBackends = "pandas",
+    queries_folders: tuple[Path, ...] = QUERIES_FOLDERS,
+    cache: bool | Literal["persistent"] = True,
+    **format_kwargs,
+) -> DataFrames:
+    if (
+        cache is False
+        and hasattr(read_query, "cache_clear")
+        and callable(getattr(read_query, "cache_clear"))
+    ):
+        read_query.cache_clear()
+
+    cache_name = f"{encode_path(path=query_name)}_data_{
+        hash_inputs(
+            query_name=query_name,
+            **format_kwargs,
+        )
+    }"
+    cache_file = CACHE_FOLDER / f"{cache_name}.parquet"
+
+    if cache != "persistent" or not cache_file.is_file():
+        query_string = get_formatted_query(
+            query_name=query_name,
+            queries_folders=queries_folders,
+            **format_kwargs,
+        )
+
+        query_data = read_query(
+            query_string=query_string,
+            dataframe_backend=dataframe_backend,
+        )
+
+        if cache == "persistent":
+            to_parquet(
+                df=query_data,
+                path=cache_file,
+                index=True,
+            )
+
+    else:
+        query_data = read_parquet(
+            path=cache_file,
+            dataframe_backend=dataframe_backend,
+        )
+
+    return query_data

{mayutils-1.2.6 → mayutils-1.2.8}/src/mayutils/environment/memoisation.py

@@ -15,6 +15,8 @@ from mayutils.objects.hashing import hash_inputs
 
 T = TypeVar("T", bound=Callable[..., Any])
 
+DataframeBackends = Literal["pandas", "polars"]
+
 
 @flexwrap
 class cache(object):
@@ -139,7 +141,7 @@ class cache_df(object):
         *,
         format: Literal["parquet", "csv", "feather", "xlsx"] = "parquet",
         cache_folder: Path | str = CACHE_FOLDER,
-        dataframe_backend: Literal["pandas", "polars"] = "pandas",
+        dataframe_backend: DataframeBackends = "pandas",
     ) -> None:
         if func is None:
             raise ValueError("No function provided")

{mayutils-1.2.6 → mayutils-1.2.8}/src/mayutils/objects/dataframes.py

@@ -1,8 +1,9 @@
 from pathlib import Path
-from typing import Callable, Literal, Optional, Self
+from typing import Callable, Literal, Optional, Self, TypeAlias, get_args
 
 from itables import show
 from great_tables import GT
+import pandas as pd
 from pandas import (
     DataFrame,
     ExcelWriter,
@@ -24,10 +25,14 @@ from dataframe_image._pandas_accessor import (
     prepare_converter,
     save_image,
 )
+import polars as pl
+from mayutils.environment.memoisation import DataframeBackends
 import numpy as np
 from mayutils.objects.colours import Colour
 from mayutils.export import OUTPUT_FOLDER
 
+DataFrames: TypeAlias = pd.DataFrame | pl.DataFrame
+
 DATA_FOLDER = OUTPUT_FOLDER / "Data"
 
 
@@ -524,6 +529,62 @@ class IndexUtilsAccessor(object):
 #         raise TypeError(f"Unsupported DataFrame type: {type(df)}")
 
 
+def to_parquet(
+    df: DataFrames,
+    path: Path | str,
+    dataframe_backend: Optional[DataframeBackends] = None,
+    **kwargs,
+) -> None:
+    path = Path(path)
+
+    if dataframe_backend is None:
+        module = type(df).__module__
+
+        if module not in get_args(DataframeBackends):
+            raise TypeError(f"Unsupported DataFrame type: {module}")
+
+        dataframe_backend = module  # type: ignore
+
+    if dataframe_backend == "pandas":
+        assert isinstance(df, pd.DataFrame)
+
+        df.to_parquet(
+            path=path,
+            index=kwargs.pop("index", True),
+            **kwargs,
+        )
+    elif dataframe_backend == "polars":
+        assert isinstance(df, pl.DataFrame)
+
+        df.write_parquet(
+            file=path,
+            **kwargs,
+        )
+
+    raise TypeError(f"Unsupported DataFrame backend: {dataframe_backend}")
+
+
+def read_parquet(
+    path: Path | str,
+    dataframe_backend: DataframeBackends = "pandas",
+    **kwargs,
+) -> DataFrames:
+    path = Path(path)
+
+    if dataframe_backend == "pandas":
+        return pd.read_parquet(
+            path=path,
+            **kwargs,
+        )
+    elif dataframe_backend == "polars":
+        return pl.read_parquet(
+            source=path,
+            **kwargs,
+        )
+
+    raise TypeError(f"Unsupported DataFrame backend: {dataframe_backend}")
+
+
 def setup_dataframes() -> None:
     register_dataframe_accessor(name="utils")(DataframeUtilsAccessor)
     register_series_accessor(name="utils")(SeriesUtilsAccessor)

{mayutils-1.2.6 → mayutils-1.2.8}/src/mayutils/objects/datetime.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from contextlib import _GeneratorContextManager
 from sqlite3 import register_adapter
-from typing import Any, Iterator, Optional, Self, Literal, overload
+from typing import Any, Iterator, Mapping, Optional, Self, Literal, overload
 import datetime as _datetime
 import numpy as np
 from pendulum import (
@@ -453,6 +453,16 @@ class Interval(BaseInterval):
             absolute=absolute,
         )
 
+    def __deepcopy__(
+        self,
+        _memo: Mapping,
+    ) -> Self:
+        return self.__class__(
+            start=self._start,
+            end=self._end,
+            absolute=self._absolute,
+        )
+
     @property
     def start(
         self,

mayutils-1.2.6/src/mayutils/data/read.py

@@ -1,61 +0,0 @@
-from functools import lru_cache
-from pathlib import Path
-from typing import Literal
-
-import pandas as pd
-from pandas import DataFrame
-
-from mayutils.data import CACHE_FOLDER
-from mayutils.data.queries import QUERIES_FOLDERS
-from mayutils.environment.filesystem import encode_path
-from mayutils.objects.hashing import hash_inputs
-
-
-def get_query_data(
-    query_name: str,
-    queries_folders: tuple[Path, ...] = QUERIES_FOLDERS,
-    date_columns: tuple[str, ...] = tuple(),
-    time_columns: tuple[str, ...] = tuple(),
-    numeric_columns: tuple[str, ...] = tuple(),
-    cache: bool | Literal["persistent"] = True,
-    reader=None,
-    backend: Literal["snowflake"] = "snowflake",
-    **format_kwargs,
-) -> DataFrame:
-    if cache is False:
-        _get_query_data.cache_clear()
-
-    cache_name = f"{encode_path(path=query_name)}_data_{
-        hash_inputs(
-            query_name=query_name,
-            date_columns=date_columns,
-            time_columns=time_columns,
-            numeric_columns=numeric_columns,
-            **format_kwargs,
-        )
-    }"
-    cache_file = CACHE_FOLDER / f"{cache_name}.parquet"
-    if cache != "persistent" or not cache_file.is_file():
-        query_data = _get_query_data(
-            query_name=query_name,
-            queries_folders=queries_folders,
-            reader=reader,
-            **format_kwargs,
-        )
-
-        if cache == "persistent":
-            query_data.to_parquet(
-                path=cache_file,
-                index=True,
-            )
-    else:
-        query_data = pd.read_parquet(
-            path=cache_file,
-        )
-
-    return query_data
-
-
-@lru_cache
-def _get_query_data() -> DataFrame:
-    return DataFrame()