sibi-dst 0.3.63__py3-none-any.whl → 2025.1.1__py3-none-any.whl

{sibi_dst-0.3.63.dist-info → sibi_dst-2025.1.1.dist-info}/RECORD

@@ -1,31 +1,25 @@
 sibi_dst/__init__.py,sha256=3pbriM7Ym5f9gew7n9cO4G_p9n-0bnxdmQ0hwBdJjr4,253
 sibi_dst/df_helper/__init__.py,sha256=McYrw2N0MsMgtawLrONXTGdyHfQWVOBUvIDbklfjb54,342
 sibi_dst/df_helper/_artifact_updater_multi_wrapper.py,sha256=-Y4i5KAxKY2BNkmoVeMEZxjTFD7zaM9oQ0aRsvUbQrs,9340
-sibi_dst/df_helper/_df_helper.py,sha256=uKP6i-7dasZQ5zViD8-VJU0lNHumrdZG6IXvDFijZ18,31214
+sibi_dst/df_helper/_df_helper.py,sha256=DJRQWTihnEtgBm3X0ar9nH-xcE1PCkWmh1JgID3WDsY,10939
 sibi_dst/df_helper/_parquet_artifact.py,sha256=Nio5GSD6rTYl52nf_TSpQhYIF0hKqRrB3H3A4zYnaG8,14987
 sibi_dst/df_helper/_parquet_reader.py,sha256=L6mr2FeKtTeIn37G9EGpvOx8PwMqXb6qnEECqBaiwxo,3954
 sibi_dst/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sibi_dst/df_helper/backends/django/__init__.py,sha256=uWHi-DtQX5re7b2HcqoXUH3_FZWOw1VTmDf552FAkNs,256
-sibi_dst/df_helper/backends/django/_db_connection.py,sha256=AGbqCnmiX4toMaFPE5ne5h7QCkImjnBKvzGtUD6Ge8Q,3698
-sibi_dst/df_helper/backends/django/_io_dask.py,sha256=NjvJg6y9qKKCRiNrJL4f_A03iKDKEcjCi7LGbr9DgtM,19555
-sibi_dst/df_helper/backends/django/_load_from_db.py,sha256=htG9ec4ix371ClEHQVpx4r3mhBdQaSykeHUCCRhN7L4,10637
-sibi_dst/df_helper/backends/django/_sql_model_builder.py,sha256=at9J7ecGkZbOOYba85uofe9C-ic4wwOqVgJcHpQNiYQ,21449
 sibi_dst/df_helper/backends/http/__init__.py,sha256=d1pfgYxbiYg7E0Iw8RbJ7xfqIfJShqqTBQQGU_S6OOo,105
 sibi_dst/df_helper/backends/http/_http_config.py,sha256=eGPFdqZ5M3Tscqx2P93B6XoBEEzlmdt7yNg7PXUQnNQ,4726
 sibi_dst/df_helper/backends/parquet/__init__.py,sha256=esWJ9aSuYC26d-T01z9dPrJ1uqJzvdaPNTYRb5qXTlQ,182
 sibi_dst/df_helper/backends/parquet/_filter_handler.py,sha256=TvDf0RXta7mwJv11GNQttYJsXgFf2XDj4oLIjt4xTzA,5219
 sibi_dst/df_helper/backends/parquet/_parquet_options.py,sha256=TaU5_wG1Y3lQC8DVCItVvMnc6ZJmECLu3avssVEMbaM,10591
-sibi_dst/df_helper/backends/sqlalchemy/__init__.py,sha256=TuVp8Ce49dCIIxtyrtFGRblarQUl8QGcS-TDZd515IE,348
-sibi_dst/df_helper/backends/sqlalchemy/_db_connection.py,sha256=JID-urZLbWjMd2dXt7onp6cPxAWQ3jnsY88s_lCscn8,7980
-sibi_dst/df_helper/backends/sqlalchemy/_filter_handler.py,sha256=58RCda1Hg_nsuJw-2V36IstsT8O84IQFgsdE7FnqvMk,4655
-sibi_dst/df_helper/backends/sqlalchemy/_io_dask.py,sha256=BtiRSYA4kFIM-mBCdrwE20vzByfq8_Biv_jPLUCDv58,5466
-sibi_dst/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=ltqB5814PMecxwZgmsJL6nDhQf72V-w71YWFAf7aYZ8,6490
-sibi_dst/df_helper/backends/sqlalchemy/_sql_model_builder.py,sha256=ksvJ0EvktrVsoJ9DTMIQHzHe8ghw2mzDIBD_YgWytgw,8402
-sibi_dst/df_helper/core/__init__.py,sha256=o4zDwgVmaijde3oix0ezb6KLxI5QFy-SGUhFTDVFLT4,569
-sibi_dst/df_helper/core/_defaults.py,sha256=eNpHD2sZxir-2xO0b3_V16ryw8YP_5FfpIKK0HNuiN4,7011
+sibi_dst/df_helper/backends/sqlalchemy/__init__.py,sha256=LjWm9B7CweTvlvFOgB90XjSe0lVLILAIYMWKPkFXFm8,265
+sibi_dst/df_helper/backends/sqlalchemy/_db_connection.py,sha256=gppZrXLGK8U8xfkzRQPZCIFoWY-miP04nDNHpV8lXtU,10600
+sibi_dst/df_helper/backends/sqlalchemy/_io_dask.py,sha256=ph4w8Sd9eVr_jUIZuDhGyEwtDn0KQkb0lUkERrIXKGM,12852
+sibi_dst/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=NXVhtYF2mYsrW2fXBkL29VQ5gxAlOYPJkYa8HZKYUyM,2846
+sibi_dst/df_helper/backends/sqlalchemy/_sql_model_builder.py,sha256=Q93O_xqK0SdrS3IrijVcqky_Zf6xKjtPHdI3qnf1g8E,7457
+sibi_dst/df_helper/core/__init__.py,sha256=LfmTqFh6GUZup-g95bcXgAxX7J5Hkve7ftLE_CJg_AE,409
+sibi_dst/df_helper/core/_defaults.py,sha256=9UMEMu2wXznO5UzEhnQ82f_ZazZ20JRyRXIi3HP3gDw,4043
 sibi_dst/df_helper/core/_filter_handler.py,sha256=Pmbzygry2mpkNPVS7DBMulHpAb1yYZNFqUU0bJTWJF0,11214
 sibi_dst/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxRrQKE5FQRxcEWsac,6736
-sibi_dst/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
+sibi_dst/df_helper/core/_query_config.py,sha256=1ApqmuSGXTC3CdF-xMsSbCa3V2Z5hOP3Wq5huhzZwqY,439
 sibi_dst/df_helper/data_cleaner.py,sha256=lkxQoXLvGzXCicFUimnA5nen5qkrO1oxgl_p2Be2o8w,5183
 sibi_dst/geopy_helper/__init__.py,sha256=Q1RJiUZIOlV0QNNLjxZ_2IZS5LqIe5jRbeQkfD1Vm60,112
 sibi_dst/geopy_helper/geo_location_service.py,sha256=1ArI980QF_gRw096ZsABHwJt-m55jrfOlB8tPwL1BvY,2959
@@ -38,36 +32,35 @@ sibi_dst/osmnx_helper/basemaps/router_plotter.py,sha256=UAiijn-J-jjX4YnL0_P9SFqT
 sibi_dst/osmnx_helper/utils.py,sha256=BzuY8CtYnBAAO8UAr_M7EOk6CP1zcifNLs8pkdFZEFg,20577
 sibi_dst/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sibi_dst/tests/test_data_wrapper_class.py,sha256=6uFmZR2DxnxQz49L5jT2ehlKvlLnpUHMLFB_PqqUq7k,3336
-sibi_dst/utils/__init__.py,sha256=w0_q4rl3yD7x1Q5yWxH-GN_3Ju1XlebIzm3nJdrUeGE,1234
-sibi_dst/utils/airflow_manager.py,sha256=-d44EKUZNYJyp4wuNwRvilRQktunArPOB5fZuWdQv10,7526
+sibi_dst/utils/__init__.py,sha256=H0Yr_Xo4dBTf03_Si_cggmPNSv6cf8_BBetoHJ86Tiw,1162
 sibi_dst/utils/clickhouse_writer.py,sha256=iAUe4_Kn2WR1xZjpLW2FOWCWfOTw6fCGMTUcWxIQJ60,9877
 sibi_dst/utils/credentials.py,sha256=cHJPPsmVyijqbUQIq7WWPe-lIallA-mI5RAy3YUuRME,1724
 sibi_dst/utils/data_from_http_source.py,sha256=AcpKNsqTgN2ClNwuhgUpuNCx62r5_DdsAiKY8vcHEBA,1867
 sibi_dst/utils/data_utils.py,sha256=MqbwXk33BuANWeKKmsabHouhb8GZswSmbM-VetWWE-M,10357
-sibi_dst/utils/data_wrapper.py,sha256=Tb9bHIHI6qVsdH791BOFN1VrPb-7GS4fHhhHV8hktec,9641
+sibi_dst/utils/data_wrapper.py,sha256=69aPQFP178-QTJ_joJYqymP--wNxa1qzri_KkvvUTIw,9688
 sibi_dst/utils/date_utils.py,sha256=T3ij-WOQu3cIfmNAweSVMWWr-hVtuBcTGjEY-cMJIvU,18627
 sibi_dst/utils/df_utils.py,sha256=TzIAUCLbgOn3bvCFvzkc1S9YU-OlZTImdCj-88dtg8g,11401
 sibi_dst/utils/file_utils.py,sha256=Z99CZ_4nPDIaZqbCfzzUDfAYJjSudWDj-mwEO8grhbc,1253
 sibi_dst/utils/filepath_generator.py,sha256=-HHO0U-PR8fysDDFwnWdHRlgqksh_RkmgBZLWv9hM7s,6669
-sibi_dst/utils/log_utils.py,sha256=77xACRagKU83H9vn7aVeBzkQjxWlbe4dg4KuxPRCgvw,4635
+sibi_dst/utils/log_utils.py,sha256=C2wkbxGC2n6hZIEU-z8rHrunDcq95MHkf3B1zGynHnE,4904
 sibi_dst/utils/manifest_manager.py,sha256=eyk6Dvrn86gUpAaAsnQvNnEJn5-Tno-sDDJsDMfHtTA,18161
 sibi_dst/utils/parquet_saver.py,sha256=O62xwPfphOpKgEiHqnts20CPSU96pxs49Cg7PVetLK0,8193
 sibi_dst/utils/phone_formatter.py,sha256=tsVTDamuthFYgy4-5UwmQkPQ-FGTGH7MjZyH8utAkIY,4945
 sibi_dst/utils/storage_config.py,sha256=TE15H-7d0mqwYPSUgrdidK9U7N7p87Z8JfUQH4-jdPs,4123
 sibi_dst/utils/storage_manager.py,sha256=btecX7ggNb7rfu5EK9Xuu2q_FZA7r_rB_tfhQ8V96qc,6567
-sibi_dst/utils/update_planner.py,sha256=dJXLC-KdbWrCs-MFe7Xa8F-ZhlNJq8P1szjLAzMJZk0,9684
+sibi_dst/utils/update_planner.py,sha256=t9A5DLE9cDiYNO8ctQIWVyVWnkMSV0PfbBJ43A0bQv4,9742
 sibi_dst/utils/webdav_client.py,sha256=pYF1UsGOuxYeGLq7aBfwZFvkvD4meOcbbaiZ4d6GW9I,7107
 sibi_dst/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sibi_dst/v2/df_helper/__init__.py,sha256=XuH6jKYAPg2DdRbsxxBSxp9X3x-ARyaT0xe27uILrVo,99
 sibi_dst/v2/df_helper/_df_helper.py,sha256=9pED3bjQ2Z81zqzJrZ9e7SguoO4-hBmNTJK4WOKrr4M,9297
 sibi_dst/v2/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sibi_dst/v2/df_helper/backends/sqlalchemy/__init__.py,sha256=MOEedyWqcb1_RiRYKyyWX0uFNCfBgmyYbTjco8-GBxU,262
-sibi_dst/v2/df_helper/backends/sqlalchemy/_db_connection.py,sha256=8u3jdD0sR2fmm2H75GDdygoqiqDI6-N-azOJsLgUWFA,3189
-sibi_dst/v2/df_helper/backends/sqlalchemy/_io_dask.py,sha256=6V9DruwckEsonYW5YvBY93-NzXYHbTA7OsyMKMYIZEs,5472
+sibi_dst/v2/df_helper/backends/sqlalchemy/_db_connection.py,sha256=1xeMxPBpChXDMpmQmTYtta6y43ndU6x6szdon8KIj9g,15443
+sibi_dst/v2/df_helper/backends/sqlalchemy/_io_dask.py,sha256=LmUBK-HRrF-RncnZ2DsZSqxmTrAeQEyD8oqaBDfr518,5449
 sibi_dst/v2/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=jhgN0OO5Sk1zQFHrMUhJn2F_hHB5g3x3EJ8j5PXNb0U,6295
 sibi_dst/v2/df_helper/backends/sqlalchemy/_model_builder.py,sha256=jX_mQAzl_6xdh7CTYw4uvUIX2wMp3NzXMlfbC5alOzs,13632
 sibi_dst/v2/df_helper/backends/sqlmodel/__init__.py,sha256=LcwJjVVxxrnVZalWqnz5m7r77i9tmJR0-U2k8eSQ-m8,249
-sibi_dst/v2/df_helper/backends/sqlmodel/_db_connection.py,sha256=b5xmxQr4a8fhE4qdCGJrNWjjX1NW5hrPNLmlfP20rIg,2897
+sibi_dst/v2/df_helper/backends/sqlmodel/_db_connection.py,sha256=n3CDbda0OY3X7eTeu_PR2KcZ5hYyEJL7Hroo8yQkjG8,15435
 sibi_dst/v2/df_helper/backends/sqlmodel/_io_dask.py,sha256=wVgNPo5V75aLtlZr_SIQ-yteyXq-Rg93eMfR8JCfkSo,5422
 sibi_dst/v2/df_helper/backends/sqlmodel/_load_from_db.py,sha256=FIs6UrNxdJ7eDHDvTv-cJuybIue2-oCRedhW-MNe7CU,6285
 sibi_dst/v2/df_helper/backends/sqlmodel/_model_builder.py,sha256=k0dnMLkLMMvkDYDYWkGFgibW5UD8pJgB3YrEg_R7pj8,13556
@@ -77,6 +70,10 @@ sibi_dst/v2/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxR
 sibi_dst/v2/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
 sibi_dst/v2/utils/__init__.py,sha256=6H4cvhqTiFufnFPETBF0f8beVVMpfJfvUs6Ne0TQZNY,58
 sibi_dst/v2/utils/log_utils.py,sha256=rfk5VsLAt-FKpv6aPTC1FToIPiyrnHAFFBAkHme24po,4123
-sibi_dst-0.3.63.dist-info/METADATA,sha256=ZsVn8AeFIUeVrb0Ybxmjk393FdUyn2j2fOnGQ8MXM1k,4292
-sibi_dst-0.3.63.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-sibi_dst-0.3.63.dist-info/RECORD,,
+sibi_dst/v3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/df_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/df_helper/_df_helper.py,sha256=NKIQ4Y-Tn-e841sbZxzLh3Q071_Zo9Vu4y3OAXcsO98,3900
+sibi_dst-2025.1.1.dist-info/METADATA,sha256=OBt3aCLjPtRPN-YxaKLvNL13_H5sRqjEo-NpDMK-nD0,2366
+sibi_dst-2025.1.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sibi_dst-2025.1.1.dist-info/RECORD,,

sibi_dst/df_helper/backends/django/__init__.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-from ._io_dask import ReadFrameDask
-from ._db_connection import DjangoConnectionConfig
-from ._load_from_db import DjangoLoadFromDb
-
-__all__ = [
-    "DjangoConnectionConfig",
-    "ReadFrameDask",
-    "DjangoLoadFromDb"
-]

sibi_dst/df_helper/backends/django/_db_connection.py

@@ -1,88 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel, model_validator
-
-from ._sql_model_builder import DjangoSqlModelBuilder
-
-
-class DjangoConnectionConfig(BaseModel):
-    """
-    Represents a configuration for establishing a Django database connection.
-
-    This class is used for defining the configurations necessary to establish a Django
-    database connection. It supports dynamic model generation if the model is not
-    provided explicitly. It also validates the connection configuration to ensure it
-    is properly set up before being used.
-
-    :ivar live: Indicates whether the connection is live. Automatically set to False if
-        a table is provided without a pre-built model.
-    :type live: bool
-    :ivar connection_name: The name of the database connection to use. This is a mandatory
-        parameter and must be provided.
-    :type connection_name: str
-    :ivar table: The name of the database table to use. Required for dynamic model
-        generation when no model is provided.
-    :type table: str
-    :ivar model: The Django model that represents the database table. If not provided,
-        this can be generated dynamically by using the table name.
-    :type model: Any
-    """
-    live: bool = False
-    connection_name: str = None
-    table: str = None
-    model: Any = None
-
-    @model_validator(mode="after")
-    def check_model(self):
-        """
-        Validates and modifies the instance based on the provided attributes and conditions.
-        This method ensures that all required parameters are populated and consistent, and it
-        dynamically builds a model if necessary. The method also ensures the connection is
-        validated after the model preparation process.
-
-        :raises ValueError: If `connection_name` is not provided.
-        :raises ValueError: If `table` name is not specified when building the model dynamically.
-        :raises ValueError: If there are errors during the dynamic model-building process.
-        :raises ValueError: If `validate_connection` fails due to invalid configuration.
-        :return: The validated and potentially mutated instance.
-        """
-        # connection_name is mandatory
-        if self.connection_name is None:
-            raise ValueError("Connection name must be specified")
-
-        # If table is provided, enforce live=False
-        if self.table:
-            self.live = False
-
-        # If model is not provided, build it dynamically
-        if not self.model:
-            if not self.table:
-                raise ValueError("Table name must be specified to build the model")
-            try:
-                self.model = DjangoSqlModelBuilder(
-                    connection_name=self.connection_name, table=self.table
-                ).build_model()
-            except Exception as e:
-                raise ValueError(f"Failed to build model: {e}")
-        else:
-            self.live = True
-        # Validate the connection after building the model
-        self.validate_connection()
-        return self
-
-    def validate_connection(self):
-        """
-        Ensures the database connection is valid by performing a simple
-        query. Raises a ValueError if the connection is broken or if any
-        other exception occurs during the query.
-
-        :raises ValueError: If the connection to the database cannot be
-            established or if the query fails.
-        """
-        try:
-            # Perform a simple query to test the connection
-            self.model.objects.using(self.connection_name).exists()
-        except Exception as e:
-            raise ValueError(
-                f"Failed to connect to the database '{self.connection_name}': {e}"
-            )

sibi_dst/df_helper/backends/django/_io_dask.py

@@ -1,450 +0,0 @@
-import itertools
-
-import dask.dataframe as dd
-import django
-import pandas as pd
-from django.core.cache import cache
-from django.core.exceptions import FieldDoesNotExist
-from django.db import models
-from django.db.models import Field
-from django.utils.encoding import force_str as force_text
-
-
-class ReadFrameDask:
-    """
-    Handles Django ORM QuerySet to Dask DataFrame conversion with support for field
-    type inference, chunked data retrieval, and verbose updates.
-
-    This class provides methods to efficiently convert a Django QuerySet into a
-    Dask DataFrame while preserving field types and incorporating additional
-    capabilities such as replacing fields with verbose choices or related object
-    information. The class design leverages static and class methods to maintain
-    flexibility and reusability for handling Django model fields and their data
-    types.
-
-    :ivar qs: The Django QuerySet to be converted into a Dask DataFrame.
-    :type qs: django.db.models.query.QuerySet
-    :ivar coerce_float: Whether to attempt to coerce numeric values to floats.
-    :type coerce_float: bool
-    :ivar chunk_size: The number of records to fetch and process per chunk from
-        the QuerySet.
-    :type chunk_size: int
-    :ivar verbose: If True, provides verbose updates during DataFrame creation
-        by replacing fields with readable representations (e.g., verbose names).
-    :type verbose: bool
-    """
-    FieldDoesNotExist = (
-        django.core.exceptions.FieldDoesNotExist
-        if django.VERSION < (1, 8)
-        else django.core.exceptions.FieldDoesNotExist
-    )
-
-    def __init__(
-            self,
-            qs,
-            **kwargs,
-    ):
-        """
-        An initialization method for a class that sets class attributes based on provided
-        arguments or default values using the keyword arguments. The method allows
-        customization of behaviors like coercing data types, handling chunked operations,
-        and verbosity level during execution.
-
-        :param qs: A data source or query set for processing; its type is dependent
-            on the expected data being handled.
-        :param kwargs: Additional keyword arguments that may include:
-            - coerce_float: A boolean indicating whether floats should be coerced
-              during handling. Default is False.
-            - chunk_size: An integer value representing the size of chunks for
-              data processing. Default is 1000.
-            - verbose: A boolean to specify if verbose logging or output
-              should occur during execution. Default is True.
-        """
-        self.qs = qs
-        self.coerce_float = kwargs.setdefault("coerce_float", False)
-        self.chunk_size = kwargs.setdefault("chunk_size", 1000)
-        self.verbose = kwargs.setdefault("verbose", True)
-
-    @staticmethod
-    def replace_from_choices(choices):
-        """
-        Provides a method to replace elements in a list of values based on a mapping of choices.
-
-        This static method generates a closure function that replaces items in a list by
-        looking up their corresponding values in a provided dictionary of choices. If an
-        item cannot be found in the dictionary, it is left unchanged.
-
-        :param choices:
-            Dictionary where keys are original values and values are their replacements.
-        :return:
-            A function that takes a list of values and replaces elements using the
-            provided choices dictionary.
-        """
-        def inner(values):
-            return [choices.get(v, v) for v in values]
-
-        return inner
-
-    @staticmethod
-    def get_model_name(model):
-        """
-        Retrieves the model name from a given Django model instance.
-
-        This method accesses the `_meta.model_name` attribute of the provided
-        model object to extract and return the model's name.
-
-        :param model: A Django model instance from which the model name is
-            derived.
-        :type model: object
-        :return: The name of the model as a string.
-        :rtype: str
-        """
-        return model._meta.model_name
-
-    @staticmethod
-    def get_related_model(field):
-        """
-        Retrieve the related model from the provided field.
-
-        This function determines the related model associated with the given field.
-        It checks various attributes commonly used to indicate relations in models and
-        retrieves the related model if present.
-
-        :param field: The field from which the related model is to be extracted.
-                      It must be an object that potentially contains attributes like
-                      `related_model` or `rel`.
-        :return: The related model associated with the provided field, or None if
-                 no such model is found.
-        """
-        model = None
-        if hasattr(field, "related_model") and field.related_model:
-            model = field.related_model
-        elif hasattr(field, "rel") and field.rel:
-            model = field.rel.to
-        return model
-
-    @classmethod
-    def get_base_cache_key(cls, model):
-        """
-        Generates a base cache key for caching purposes.
-
-        This method constructs a base cache key that can be used in conjunction with
-        Django models to uniquely identify cache entries. The key is formatted to
-        include the app label and model name, ensuring that cache entries are
-        namespaced accordingly.
-
-        :param model: A Django model instance for which the base cache key is generated.
-        :type model: Model
-        :return: The string template for the base cache key, where `%s` can be replaced
-                 with specific identifiers to create unique keys.
-        :rtype: str
-        """
-        return (
-            f"dask_{model._meta.app_label}_{cls.get_model_name(model)}_%s_rendering"
-        )
-
-    @classmethod
-    def replace_pk(cls, model):
-        """
-        Generates a function that replaces primary keys in a pandas Series with their
-        corresponding cached values or database-retrieved representations.
-
-        The function uses a cache mechanism to retrieve pre-stored values for primary
-        keys in the series. If some primary keys are not found in the cache, it queries
-        the database for their representations, updates the cache, and replaces the
-        primary keys in the series accordingly.
-
-        :param model: The Django model class associated with the primary keys to be
-            processed.
-        :type model: Type[Model]
-
-        :return: A function that takes a pandas Series of primary keys as input and
-            returns a Series with replaced values based on cache or database retrieval.
-        :rtype: callable
-        """
-        base_cache_key = cls.get_base_cache_key(model)
-
-        def get_cache_key_from_pk(pk):
-            return None if pk is None else base_cache_key % str(pk)
-
-        def inner(pk_series):
-            pk_series = pk_series.astype(object).where(pk_series.notnull(), None)
-            cache_keys = pk_series.apply(get_cache_key_from_pk, convert_dtype=False)
-            unique_cache_keys = list(filter(None, cache_keys.unique()))
-            if not unique_cache_keys:
-                return pk_series
-
-            out_dict = cache.get_many(unique_cache_keys)
-            if len(out_dict) < len(unique_cache_keys):
-                out_dict = dict(
-                    [
-                        (base_cache_key % obj.pk, force_text(obj))
-                        for obj in model.objects.filter(
-                        pk__in=list(filter(None, pk_series.unique()))
-                    )
-                    ]
-                )
-                cache.set_many(out_dict)
-            return list(map(out_dict.get, cache_keys))
-
-        return inner
-
-    @classmethod
-    def build_update_functions(cls, fieldnames, fields):
-        """
-        This method is responsible for building update functions based on the provided
-        fieldnames and fields. It performs validation for the field type, checks for
-        specific conditions such as `choices` or `ForeignKey` field types, and generates
-        a generator of update functions for the given fieldnames and fields.
-
-        :param fieldnames: A list of field names to be processed.
-        :type fieldnames: list[str]
-        :param fields: A list of field objects corresponding to the fieldnames.
-        :type fields: list[Field]
-        :return: A generator yielding tuples where the first element is a fieldname,
-                 and the second element is the corresponding update function or None.
-        :rtype: generator[tuple[str, Callable | None]]
-        """
-        for fieldname, field in zip(fieldnames, fields):
-            if not isinstance(field, Field):
-                yield fieldname, None
-            else:
-                if field.choices:
-                    choices = dict([(k, force_text(v)) for k, v in field.flatchoices])
-                    yield fieldname, cls.replace_from_choices(choices)
-                elif field.get_internal_type() == "ForeignKey":
-                    yield fieldname, cls.replace_pk(cls.get_related_model(field))
-
-    @classmethod
-    def update_with_verbose(cls, df, fieldnames, fields):
-        """
-        Updates the provided dataframe by applying transformation functions to specified fields.
-        The method iterates over the provided field names and their corresponding functions, applying
-        each transformation function to its related column in the dataframe.
-
-        :param df: The input dataframe to be updated.
-        :param fieldnames: A list of field names in the dataframe that need to be updated.
-        :param fields: A list of transformation functions or mappings corresponding to the field names.
-        :return: The dataframe with updated fields.
-        """
-        for fieldname, function in cls.build_update_functions(fieldnames, fields):
-            if function is not None:
-                df[fieldname] = df[fieldname].map_partitions(lambda x: function(x))
-
-    @classmethod
-    def to_fields(cls, qs, fieldnames):
-        """
-        Converts field names from a queryset into corresponding field objects, resolving relationships
-        and related objects if necessary. This method is typically used to yield fully-resolved field
-        objects for further interaction.
-
-        :param qs: A QuerySet object from which the fields are resolved. This object provides access
-                   to the model and its metadata from which the fields are retrieved.
-        :type qs: QuerySet
-
-        :param fieldnames: A list of field name strings. These can include nested fields separated by
-                           double underscores (__) to denote relationships or subfields.
-        :type fieldnames: List[str]
-
-        :return: A generator that yields resolved field objects corresponding to the provided field names.
-        :rtype: Generator[Field, None, None]
-        """
-        for fieldname in fieldnames:
-            model = qs.model
-            for fieldname_part in fieldname.split("__"):
-                try:
-                    field = model._meta.get_field(fieldname_part)
-                except cls.FieldDoesNotExist:
-                    try:
-                        rels = model._meta.get_all_related_objects_with_model()
-                    except AttributeError:
-                        field = fieldname
-                    else:
-                        for relobj, _ in rels:
-                            if relobj.get_accessor_name() == fieldname_part:
-                                field = relobj.field
-                                model = field.model
-                                break
-                else:
-                    model = cls.get_related_model(field)
-            yield field
-
-    @staticmethod
-    def is_values_queryset(qs):
-        """
-        Determines whether the provided queryset is a values queryset.
-
-        This method checks if the `_iterable_class` attribute of the queryset corresponds
-        to `django.db.models.query.ValuesIterable`. If an exception occurs during the check,
-        the method returns `False`.
-
-        :param qs: The queryset to be checked.
-        :type qs: django.db.models.query.QuerySet
-        :return: A boolean indicating whether the queryset is a values queryset.
-        :rtype: bool
-        """
-        try:
-            return qs._iterable_class == django.db.models.query.ValuesIterable
-        except:
-            return False
-
-    @staticmethod
-    def object_to_dict(obj, fields=None):
-        """
-        Converts an object to a dictionary representation.
-
-        This static method transforms an object's attributes into a dictionary.
-        If no specific fields are provided, all attribute key-value pairs are
-        included. The "_state" attribute, if present, is safely removed in this
-        case. When specific fields are supplied, only those fields are included
-        in the resulting dictionary.
-
-        :param obj: The object to be serialized into a dictionary. This object
-            must have the `__dict__` attribute available.
-        :param fields: A list of strings representing the attribute names to
-            include in the dictionary. If None or not provided, all attributes
-            are included except for "_state".
-        :return: A dictionary representation of the object's attributes. If the
-            provided object is None, an empty dictionary is returned.
-        :rtype: dict
-        """
-        if obj is None:
-            return {}  # Return an empty dictionary if obj is None
-        if not fields:
-            obj.__dict__.pop("_state", None)  # Remove _state safely
-            return obj.__dict__
-        return {field: obj.__dict__.get(field) for field in fields if field is not None}
-
-    @staticmethod
-    def infer_dtypes_from_django(qs):
-        """
-        Infer dtypes from a Django QuerySet model and annotated fields.
-
-        This method infers the appropriate data types (dtypes) for a given
-        Django QuerySet (`qs`) based on the fields defined in its model and
-        any annotated fields included in the QuerySet. The function maps
-        Django model field types to corresponding dtypes compatible with
-        Dask or Pandas dataframes.
-
-        - Fields in the model are identified through their metadata.
-        - Reverse relationships and non-concrete fields are ignored.
-        - Annotated fields are processed separately and default to object
-          dtype if their type cannot be determined.
-
-        :param qs: Django QuerySet whose model is used to infer dtypes.
-        :type qs: QuerySet
-        :return: A mapping of field names to inferred dtypes.
-        :rtype: dict
-        """
-        django_to_dask_dtype = {
-            'AutoField': 'Int64',  # Use nullable integer
-            'BigAutoField': 'Int64',
-            'BigIntegerField': 'Int64',
-            'BooleanField': 'bool',
-            'CharField': 'object',
-            'DateField': 'datetime64[ns]',
-            'DateTimeField': 'datetime64[ns]',
-            'DecimalField': 'float64',
-            'FloatField': 'float64',
-            'IntegerField': 'Int64',  # Use nullable integer
-            'PositiveIntegerField': 'Int64',
-            'SmallIntegerField': 'Int64',
-            'TextField': 'object',
-            'TimeField': 'object',
-            'UUIDField': 'object',
-            'ForeignKey': 'Int64',  # Use nullable integer for FK fields
-        }
-
-        dtypes = {}
-        # Handle model fields
-        for field in qs.model._meta.get_fields():
-            # Skip reverse relationships and non-concrete fields
-            if not getattr(field, 'concrete', False):
-                continue
-
-            # Check for AutoField or BigAutoField explicitly
-            if isinstance(field, (models.AutoField, models.BigAutoField)):
-                dtypes[field.name] = 'Int64'  # Nullable integer for autoincremented fields
-            else:
-                # Use field type to infer dtype
-                field_type = field.get_internal_type()
-                dtypes[field.name] = django_to_dask_dtype.get(field_type, 'object')
-
-        # Handle annotated fields
-        for annotation_name, annotation in qs.query.annotation_select.items():
-            if hasattr(annotation, 'output_field'):
-                field_type = annotation.output_field.get_internal_type()
-                dtype = django_to_dask_dtype.get(field_type, 'object')
-            else:
-                dtype = 'object'  # Default to object for untyped annotations
-            dtypes[annotation_name] = dtype
-
-        return dtypes
-
-    def read_frame(self, fillna_value=None):
-        """
-        Reads a Django QuerySet and returns a dask DataFrame by iterating over the QuerySet in chunks. It
-        handles data type inference, missing values, timezone awareness, and creates partitions to form a
-        single dask DataFrame efficiently.
-
-        This method includes functionality for managing missing values, inferring data types from Django fields,
-        and handling timezone-aware datetime objects. It processes data in chunks to optimize memory usage and
-        supports converting chunks into pandas DataFrames before combining them into a unified dask DataFrame.
-
-        :param fillna_value: The value to fill NaN values in the DataFrame. If None, NaNs are not filled.
-        :type fillna_value: Any
-        :return: A dask DataFrame constructed from the QuerySet after processing and combining all
-                 its partitions.
-        :rtype: dask.dataframe.DataFrame
-        """
-        qs = self.qs
-        coerce_float = self.coerce_float
-        verbose = self.verbose
-        chunk_size = self.chunk_size
-
-        fields = qs.model._meta.fields
-        fieldnames = [f.name for f in fields]
-        fieldnames += list(qs.query.annotation_select.keys())
-        fieldnames = tuple(fieldnames)
-        # Infer dtypes from Django fields
-        dtypes = self.infer_dtypes_from_django(qs)
-        if fieldnames:
-            dtypes = {field: dtype for field, dtype in dtypes.items() if field in fieldnames}
-
-        # Create partitions for Dask by iterating through chunks
-        partitions = []
-        iterator = iter(qs.iterator(chunk_size=chunk_size))
-
-        while True:
-            chunk = list(itertools.islice(iterator, chunk_size))
-            if not chunk:
-                break
-
-            # Convert chunk to DataFrame with inferred dtypes
-            df = pd.DataFrame.from_records(
-                [self.object_to_dict(obj, fieldnames) for obj in chunk],
-                columns=fieldnames,
-                coerce_float=coerce_float,
-            )
-            # Handle NaN values before casting, if specified
-            if fillna_value is not None:
-                df = df.fillna(fillna_value)
-
-            # Convert timezone-aware columns to timezone-naive if needed
-            for col in df.columns:
-                if isinstance(df[col].dtype, pd.DatetimeTZDtype):
-                    df[col] = df[col].dt.tz_localize(None)
-
-            # Convert to the appropriate data types
-            df = df.astype(dtypes)
-            partitions.append(dd.from_pandas(df, npartitions=1))
-
-        # Concatenate partitions into a single Dask DataFrame
-        # Ensure all partitions have the same columns
-
-        dask_df = dd.concat(partitions, axis=0, ignore_index=True)
-
-        if verbose:
-            self.update_with_verbose(dask_df, fieldnames, fields)
-
-        return dask_df