djresttoolkit 0.17.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

djresttoolkit/envconfig/__init__.py

@@ -1,3 +1,4 @@
-from ._env_settings import EnvBaseSettings
+from ._base_env_config import BaseEnvConfig
+from dotenv import load_dotenv
 
-__all__ = ["EnvBaseSettings"]
+__all__ = ["load_dotenv", "BaseEnvConfig"]

djresttoolkit/envconfig/_base_env_config.py

@@ -0,0 +1,84 @@
+import threading
+import json
+from os import getenv
+from typing import Any, Self, get_type_hints
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class BaseEnvConfig:
+    """Production-ready environment loader."""
+
+    _instance_lock = threading.Lock()
+    _instance = None
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if getattr(self, "_initialized", False):
+            return
+
+        self._env_cache: dict[str, Any] = {}
+        self._sync_env()
+        self._initialized = True
+
+    def _sync_env(self) -> None:
+        hints = get_type_hints(self.__class__)
+        for field, _ in hints.items():
+            raw = getenv(field)
+
+            if raw is None:
+                if hasattr(self, field):
+                    value = getattr(self, field)
+                    logger.info(f"{field} not set, using default: {value}")
+                else:
+                    raise EnvironmentError(
+                        f"Missing required environment variable: {field}"
+                    )
+            else:
+                if field in self._env_cache:
+                    value = self._env_cache[field]
+                else:
+                    value = self._parse_env_value(raw)
+                    self._env_cache[field] = value
+
+            setattr(self, field, value)
+
+    def _parse_env_value(self, raw: str) -> Any:
+        """Parse string from environment."""
+        lowered = raw.lower()
+
+        # Boolean parsing
+        if lowered == "true":
+            return True
+        if lowered == "false":
+            return False
+
+        # JSON parsing
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            pass
+
+        # Numeric parsing
+        if raw.isdigit():
+            return int(raw)
+        try:
+            return float(raw)
+        except ValueError:
+            pass
+
+        # Fallback: plain string
+        return raw
+
+    def reload(self) -> None:
+        """Reload environment variables at runtime."""
+        self._env_cache.clear()
+        self._sync_env()
+        logger.info("Environment variables reloaded.")

djresttoolkit/views/mixins/__init__.py

@@ -1,6 +1,3 @@
-from ._retrieve_object_mixin import RetrieveObjectMixin, QuerysetNotDefinedError
+from ._retrieve_object_mixin import RetrieveObjectMixin
 
-__all__ = [
-    "RetrieveObjectMixin",
-    "QuerysetNotDefinedError",
-]
+__all__ = ["RetrieveObjectMixin"]

djresttoolkit/views/mixins/_retrieve_object_mixin.py

@@ -1,19 +1,20 @@
 from typing import Any
-from django.db.models import Model, QuerySet
-
-
-class QuerysetNotDefinedError(Exception):
-    """Exception raised when the `queryset` attribute is not set in the class."""
 
-    pass
+from django.core.exceptions import ImproperlyConfigured
+from django.db.models import Model, QuerySet
+from django.http import Http404
 
 
 class RetrieveObjectMixin[T: Model]:
     """
-    Mixin to provide a method for retrieving a single model object by filters.
+    Retrieve a single model object by filters.
 
     Requires the `queryset` attribute to be set in the class that inherits this mixin.
 
+    Raises `Http404` when the object is missing.
+
+    This works in both Django views and DRF views.
+
     Example:
     ```
         class MyView(RetrieveModelMixin[Book], APIView):
@@ -27,15 +28,32 @@ class RetrieveObjectMixin[T: Model]:
 
     queryset: QuerySet[T] | None = None
 
-    def get_object(self, **filters: Any) -> T | None:
+    def get_object(self, **filters: Any) -> T:
         """Retrieve a model object based on provided filters."""
 
         if self.queryset is None:
-            raise QuerysetNotDefinedError(
+            raise ImproperlyConfigured(
                 "Queryset attribute is not set in the class.",
             )
 
         try:
             return self.queryset.get(**filters)
         except self.queryset.model.DoesNotExist:
-            return None
+            raise Http404(self.not_found_detail())
+
+    def not_found_detail(self) -> dict[str, str] | str:
+        """
+        Hook for customizing the 404 message.
+        Can be overridden per view.
+        """
+
+        if self.queryset is None:
+            raise ImproperlyConfigured(
+                "Queryset attribute is not set in the class.",
+            )
+
+        verbose_name = self.queryset.model._meta.verbose_name
+        model_name = (
+            verbose_name.title() if verbose_name else self.queryset.model.__name__
+        )
+        return f"The requested {model_name} was not found."

{djresttoolkit-0.17.5.dist-info → djresttoolkit-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djresttoolkit
-Version: 0.17.5
+Version: 1.1.0
 Summary: A collection of Django and DRF utilities to simplify API development.
 Project-URL: Homepage, https://github.com/shaileshpandit141/djresttoolkit
 Project-URL: Documentation, https://shaileshpandit141.github.io/djresttoolkit
@@ -47,9 +47,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.13
 Requires-Dist: faker>=37.5.3
-Requires-Dist: pydantic-settings>=2.10.1
 Requires-Dist: pydantic>=2.11.7
-Requires-Dist: pyyaml>=6.0.2
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
@@ -72,8 +70,8 @@ djresttoolkit is a collection of utilities and helpers for Django and Django RES
 - **DB Flush Command (`dbflush`)**
   Management command to flush all models or a specific model, resetting auto-increment IDs safely with transaction support.
 
-- **EnvBaseSettings**
-  Typed settings loader using **YAML + .env**, supports nested keys and overrides. Great for structured configuration management.
+- **BaseEnvConfig**
+  Singleton environment loader that reads and parses environment variables.
 
 - **EmailSender**
   Custom class to send templated emails (`text` and `html`) with context. Supports error handling and logging.
@@ -186,10 +184,6 @@ python manage.py dbseed --count 10
 python manage.py dbseed --model User --seed 42
 ```
 
-Here’s a **concise API reference** for your database flush management command for `djresttoolkit`:
-
----
-
 ### 2. DB Flush Command — API Reference
 
 ```python
@@ -246,77 +240,54 @@ or
 Flushed 120 records from all models and reset IDs.
 ```
 
-### 3. EnvBaseSettings — API Reference
+### 3. BaseEnvConfig — API Reference
 
 ```python
-from djresttoolkit.envconfig import EnvBaseSettings
+from djresttoolkit.envconfig import BaseEnvConfig
 ```
 
-#### `EnvBaseSettings`
-
-A **base settings class** for managing application configuration using:
-
-- YAML files (default `.environ.yaml`)
-- Environment variables (default `.env`)
-
-Supports **nested configuration** using double underscores (`__`) in environment variable names.
-
-#### Class Attributes
-
-- Attributes
-  - `env_file`
-    - Type: `str`
-    - Default: `.env`
-    - Description: Environment variable file path.
-  - `yaml_file`
-    - Type: `str`
-    - Default: `.environ.yaml`
-    - Description: YAML configuration file path.
-  - `model_config`
-    - Type: `SettingsConfigDict`
-    - Description: Pydantic settings configuration (file encoding, nested delimiter).
-
-#### Methods
+#### `BaseEnvConfig`
 
-#### `load(cls, *, env_file: str | None = None, ymal_file: str | None = None, warning: bool = True) -> EnvBaseSettings`
+Singleton environment loader that reads and parses environment variables with support for booleans, numbers, and JSON.
 
-Loads configuration from **YAML first**, then overrides with **environment variables**.
+> ⚠️ **Note:** Note: If you are using a .env file, load it first with python-dotenv:
+>
+> ```python
+> from dotenv import load_dotenv
+> load_dotenv()
+> ```
 
-#### Parameters
-
-- `env_file` — Optional custom `.env` file path.
-- `ymal_file` — Optional custom YAML file path.
-- `warning` — Emit a warning if YAML file is missing (default `True`).
-
-#### Returns
-
-- Instance of `EnvBaseSettings` (or subclass) with loaded configuration.
-
-#### Raises
-
-- `UserWarning` if YAML file not found and `warning=True`.
+or
+>
+> ```python
+> from djresttoolkit.envconfig import load_dotenv
+> load_dotenv()
+> ```
 
-### Usage Example
+#### Usage Example
 
 ```python
-from djresttoolkit.envconfig import EnvBaseSettings
+from djresttoolkit.envconfig import load_dotenv, BaseEnvConfig
 
-class EnvSettings(EnvBaseSettings["EnvSettings"]):
-    debug: bool = False
-    database_url: str
+load_dotenv()
 
-# Load settings
-settings = EnvSettings.load(warning=False)
+class EnvConfig(BaseEnvConfig):
+    DEBUG: bool = False
+    DATABASE_URL: str
 
-print(settings.debug)
-print(settings.database_url)
+config = EnvConfig()
+print(config.DEBUG)
+print(config.DATABASE_URL)
+
+config.reload()
 ```
 
 #### Features
 
-- Prioritizes `.env` variables over YAML.
-- Supports nested keys: `DATABASE__HOST`:- `settings.database.host`.
-- Designed to be subclassed for project-specific settings.
+- Thread-safe singleton.
+- Automatic type parsing for environment variables.
+- Supports default values and runtime reloading.
+- Designed for subclassing with project-specific settings.
 
 ### 4. EmailSender — API Reference
 
@@ -830,6 +801,7 @@ Retrieve a single model object using the provided filter criteria.
 
 ```python
 from rest_framework.views import APIView
+from rest_framework.response import Respone
 from django.http import JsonResponse
 from myapp.models import Book
 from djresttoolkit.mixins import RetrieveObjectMixin
@@ -837,17 +809,18 @@ from djresttoolkit.mixins import RetrieveObjectMixin
 class BookDetailView(RetrieveObjectMixin[Book], APIView):
     queryset = Book.objects.all()
 
-    def get(self, request, *args, **kwargs):
+    def not_found_detail(self) -> dict[str, str] | str:
+        return  "The requested Book was not found."
+
+    def get(self, request, *args, **kwargs) -> Respone:
         book = self.get_object(id=kwargs["id"])
-        if book:
-            return JsonResponse({"title": book.title, "author": book.author})
-        return JsonResponse({"detail": "Not found"}, status=404)
+        return Respone({"title": book.title, "author": book.author})
 ```
 
 #### Features of Retrieve Object Mixin
 
 - Simplifies object retrieval in class-based views or DRF views.
-- Returns `None` instead of raising `DoesNotExist`, making error handling easier.
+- Raise `http404` if requested resource does not extst.
 - Works with any Django model and queryset.
 
 ### 13. build_absolute_uri — API Reference

{djresttoolkit-0.17.5.dist-info → djresttoolkit-1.1.0.dist-info}/RECORD

@@ -14,8 +14,8 @@ djresttoolkit/dbseed/models/__init__.py,sha256=uuynQIcfVqEaZN9hF_caI24zm8az23JdX
 djresttoolkit/dbseed/models/_choice_field.py,sha256=T7LAzbyXqlYp2mtCAKL8E1Da_MEh9RzgLZrFJ7fa4gM,446
 djresttoolkit/dbseed/models/_gen.py,sha256=qBPQaLvh1rcEam0YmE4JBJqpa-Vv5IFlIIagkEMHDVw,206
 djresttoolkit/dbseed/models/_seed_model.py,sha256=0cmbi0VNKjmJbwhjeCFsvb3iKYjok6TJOk6Y2MF_3N4,2443
-djresttoolkit/envconfig/__init__.py,sha256=PcLaPaVfQmz3-4m6SwoOQF2W4U7F0agBGJ4Qjqbcyfw,74
-djresttoolkit/envconfig/_env_settings.py,sha256=X-pgHqNtUNQLBHiGpbYB4ViCuY14n6aff5HZqYL4Tlc,3236
+djresttoolkit/envconfig/__init__.py,sha256=ABYwK1rsH15txGsbh5myqerF_ls6RafUlGhLyvaF2t8,119
+djresttoolkit/envconfig/_base_env_config.py,sha256=7buy7khKDR1PLag9w4rtjRhk9EUtIQvqcyqn_LehuV4,2340
 djresttoolkit/mail/__init__.py,sha256=tB9SdMlhfWQ640q4aobZ0H1c7fTWalpDL2I-onkr2VI,268
 djresttoolkit/mail/_email_sender.py,sha256=nXnH1JSiiu51IFQSKw8W6pzaGjDPg2GUKEq0XQ2gSJM,3207
 djresttoolkit/mail/_models.py,sha256=of5KsLGvsN2OWgDYgdtLEijulg817TXgsLKuUdsnDQc,1447
@@ -48,10 +48,10 @@ djresttoolkit/views/_apiviews/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 djresttoolkit/views/_apiviews/_choice_fields_apiview.py,sha256=zABPgqxMVaWd814B_sC64bWL61fDJkyYQZmJXQCa6Xc,1395
 djresttoolkit/views/_exceptions/__init__.py,sha256=DrCUxuPNyBR4WhzNutn5HDxLa--q51ykIxSG7_bFsOI,83
 djresttoolkit/views/_exceptions/_exception_handler.py,sha256=_o7If47bzWLl57LeSXSWsIDsJGo2RIpwYAwNQ-hsHVY,2839
-djresttoolkit/views/mixins/__init__.py,sha256=K-1tk5d8tCVViMynw5DdffJ3Oo5uHpEx32E3_4X2UxM,154
-djresttoolkit/views/mixins/_retrieve_object_mixin.py,sha256=Q9znYPb07YXXUhsL7VIrk3BC-zDwjOhwLJKe2GPJ-k0,1155
-djresttoolkit-0.17.5.dist-info/METADATA,sha256=3sSysAflkxpff1N8jlZ7_5lv4CJSWZ9be8_6ZQFUp5w,32929
-djresttoolkit-0.17.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-djresttoolkit-0.17.5.dist-info/entry_points.txt,sha256=YMhfTF-7mYppO8QqqWnvR_hyMWvoYxD6XI94_ViFu3k,60
-djresttoolkit-0.17.5.dist-info/licenses/LICENSE,sha256=8-oZM3yuuTRjySMbVKX9YXYA7Y4M_KhQNBYXPFjeWUo,1074
-djresttoolkit-0.17.5.dist-info/RECORD,,
+djresttoolkit/views/mixins/__init__.py,sha256=mHD49OUxuJ9v81tGfM0hLnUJuJlYi7E-5cTVdplh-vs,91
+djresttoolkit/views/mixins/_retrieve_object_mixin.py,sha256=v7CQDUkRWjtevFZnAYRBdDl7wcfYWF3evWoKWHAcckA,1749
+djresttoolkit-1.1.0.dist-info/METADATA,sha256=0Ln7HqEDc0-fHHiJZhZv0uipTH5TC9IsoWH9dWCswvI,31878
+djresttoolkit-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+djresttoolkit-1.1.0.dist-info/entry_points.txt,sha256=YMhfTF-7mYppO8QqqWnvR_hyMWvoYxD6XI94_ViFu3k,60
+djresttoolkit-1.1.0.dist-info/licenses/LICENSE,sha256=8-oZM3yuuTRjySMbVKX9YXYA7Y4M_KhQNBYXPFjeWUo,1074
+djresttoolkit-1.1.0.dist-info/RECORD,,

djresttoolkit/envconfig/_env_settings.py

@@ -1,84 +0,0 @@
-import warnings
-from pathlib import Path
-from typing import Any, ClassVar
-
-import yaml
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class EnvBaseSettings[T: "EnvBaseSettings"](BaseSettings):
-    """ "
-    EnvBaseSettings is a base settings class for managing application configuration
-    using both YAML files and environment variables.
-    This class is designed to load configuration values from a YAML file first,
-    and then override those values with environment variables if present. It supports
-    nested configuration using a double underscore (`__`) as the delimiter in
-    environment variable names, allowing for hierarchical settings.
-
-    Class Attributes:
-        env_file (str): The default filename for the environment variables file (default: ".env").
-        yaml_file (str): The default filename for the YAML configuration file (default: ".environ.yaml").
-        model_config (SettingsConfigDict): Configuration for environment variable parsing, including file encoding and nested delimiter.
-
-    Methods:
-        load(cls, *, env_file: str | None = None, ymal_file: str | None = None, warning: bool = True) -> "EnvBaseSettings":
-            Loads configuration from a YAML file (if it exists), then overrides with environment variables.
-            - env_file: Optional custom path to the .env file.
-            - ymal_file: Optional custom path to the YAML file.
-            - warning: If True, emits a warning if the YAML file is not found.
-            Returns an instance of EnvBaseSettings with the loaded configuration.
-
-    Usage:
-        - Define your settings as subclasses of EnvBaseSettings.
-        - Call `YourSettingsClass.load()` to load configuration from files and environment variables.
-        - Supports nested configuration via double underscore in environment variable names (e.g., `DATABASE__HOST`).
-
-    Raises:
-        - UserWarning: If the YAML file is not found and `warning` is True.
-
-    Example:
-    ```python
-        from djresttoolkit.envconfig import EnvBaseSettings
-        
-        class EnvSettings(EnvBaseSettings):
-            debug: bool = False
-            database_url: str
-            
-        settings = EnvSettings.load(warning=False)
-    ```
-
-    """
-
-    env_file: ClassVar[str] = ".env"
-    yaml_file: ClassVar[str] = ".environ.yaml"
-
-    model_config = SettingsConfigDict(
-        env_file=env_file,
-        env_file_encoding="utf-8",
-        env_nested_delimiter="__",
-    )
-
-    @classmethod
-    def load(
-        cls: type[T],
-        *,
-        env_file: str | None = None,
-        ymal_file: str | None = None,
-        warning: bool = True,
-    ) -> T:
-        """Load from YAML first, then override with .env."""
-        if env_file:
-            cls.env_file = env_file
-        if ymal_file:
-            cls.yaml_file = ymal_file
-
-        config_file = Path(cls.yaml_file)
-        yaml_data: dict[str, Any] = {}
-        if config_file.exists():
-            with config_file.open("r") as f:
-                yaml_data = yaml.safe_load(f) or {}
-        elif warning:
-            msg: str = f"Config file {config_file} not found, using only env vars."
-            warnings.warn(msg, UserWarning, stacklevel=1)
-
-        return cls(**yaml_data)