Dev (#291)

* Start work on HTTPX utils improvements (#290)

* Update demo().

Add vscode workspace.

Update httpx validators.

Move file_utils -> path_utils

Author: redjax

.vscode/red-utils.code-workspace

@@ -0,0 +1,12 @@
+{
+	"folders": [
+		{
+			"path": "..",
+			"name": "Git Root"
+		},
+		{
+			"path": "../red_utils/",
+			"name": "Red-Utils App"
+		}
+	]
+}

demo.py

@@ -1,4 +1,7 @@
 from __future__ import annotations
+import sys
+
+sys.path.append(".")
 
 import pkgutil
 import shutil
@@ -9,7 +12,7 @@
 from red_utils.std import (
     context_managers,
     dict_utils,
-    file_utils,
+    path_utils,
     hash_utils,
     time_utils,
     uuid_utils,
@@ -41,11 +44,12 @@
 from red_utils import CustomException
 from red_utils.ext.context_managers import cli_spinners
 
+
 def test_file_utils_list() -> list[Path]:
     cwd = Path.cwd()
     search_dir = f"{cwd}/red_utils"
 
-    list_files_test = file_utils.list_files(in_dir=search_dir, ext_filter=".py")
+    list_files_test = path_utils.list_files(in_dir=search_dir, ext_filter=".py")
     print(f".py files found in {search_dir}: {len(list_files_test)}")
 
     rand_index = random.randint(0, len(list_files_test) - 1)
@@ -410,68 +414,28 @@ def delete_test_remnants(delete_dirs=delete_dirs, delete_files=delete_files):
         for _d in delete_dirs:
             d_path: Path = Path(_d)
 
-            try:
-                if d_path.exists():
-                    print(f"Deleting directory: {str(d_path)}")
-                    shutil.rmtree(d_path, ignore_errors=True)
-
-            except FileNotFoundError as fnf:
-                print(
-                    FileNotFoundError(
-                        f"Could not find dir {str(d_path)}. Details: {fnf}"
-                    )
-                )
-            except PermissionError as perm:
-                print(
-                    PermissionError(
-                        f"Insufficient permissions to delete dir {str(d_path)}. Details: {perm}"
-                    )
-                )
-            except Exception as exc:
-                print(
-                    Exception(
-                        f"Unhandled exception deleting dir {str(d_path)}. Details: {exc}"
-                    )
-                )
+            path_utils.delete_path(_d)
 
         for _f in delete_files:
             f_path: Path = Path(_f)
 
-            try:
-                if f_path.exists():
-                    print(f"Deleting file {str(f_path)}")
-                    f_path.unlink()
-
-            except FileNotFoundError as fnf:
-                print(
-                    FileNotFoundError(
-                        f"Could not find file {str(f_path)}. Details: {fnf}"
-                    )
-                )
-            except PermissionError as perm:
-                print(
-                    PermissionError(
-                        f"Insufficient permissions to delete file {str(f_path)}. Details: {perm}"
-                    )
-                )
-            except Exception as exc:
-                print(
-                    Exception(
-                        f"Unhandled exception deleting file {str(f_path)}. Details: {exc}"
-                    )
-                )
+            path_utils.delete_path(f_path)
 
     delete_test_remnants()
 
 
+def test_ensuredirs(_dirs: list[Path] = [Path("test"), Path("test/testing")]):
+    path_utils.ensure_dirs_exist(ensure_dirs=_dirs)
+
+
 def main():
     """Main function to control flow of demo.
 
     Comment functions you don't want to execute.
     """
     ## Delete lists for cleanup function
     cleanup_dirs: list[str] = [".cache", ".db", ".serialize"]
-    cleanup_files: list[str] = ["test.db"]
+    cleanup_files: list[str] = ["test.db", "test"]
 
     print(test_file_utils_list())
 
@@ -496,6 +460,8 @@ def main():
 
     test_sqlalchemy_utils()
 
+    test_ensuredirs()
+
     with cli_spinners.SimpleSpinner("Cleaning up..."):
         post_test_cleanup(delete_files=cleanup_files, delete_dirs=cleanup_dirs)
         time.sleep(0.5)

red_utils/core/__init__.py

@@ -1,3 +1,5 @@
 from __future__ import annotations
 
-from . import dataclass_utils
+from . import dataclass_utils, constants
+
+from .constants import DATA_DIR, CACHE_DIR, SERIALIZE_DIR, JSON_DIR, ENSURE_EXIST_DIRS

red_utils/core/constants.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+DATA_DIR: Path = Path(".data")
+CACHE_DIR: Path = Path(".cache")
+SERIALIZE_DIR: Path = Path(".serialize")
+JSON_DIR: Path = Path(f"{DATA_DIR}/json")
+
+ENSURE_EXIST_DIRS: list[Path] = [DATA_DIR, CACHE_DIR, SERIALIZE_DIR]

red_utils/ext/httpx_utils/__init__.py

@@ -1,6 +1,15 @@
 from __future__ import annotations
 
+import sys
+
+sys.path.append(".")
+
 from . import constants, operations, validators
-from .constants import default_headers, valid_methods
+from .constants import default_headers
 from .operations import get_req_client, make_request, merge_headers, update_headers
-from .validators import validate_client, validate_headers, validate_method
+from .validators import (
+    validate_headers,
+    valid_methods,
+    validate_client,
+    validate_method,
+)

red_utils/ext/httpx_utils/classes.py

@@ -0,0 +1,41 @@
+from typing import Union
+
+from red_utils.core.dataclass_utils import DictMixin
+
+from red_utils.validators.ext.httpx_validators import (
+    valid_methods,
+    validate_client,
+    validate_headers,
+    validate_method,
+)
+from .constants import default_headers
+
+from dataclasses import dataclass, field
+
+import httpx
+
+
+@dataclass
+class SimpleHTTPXClientBase:
+    method: str | None = field(default="GET")
+    headers: dict | None = field(default=default_headers)
+    timeout: int | None = field(default=5)
+    data: Union[dict, str] | None = field(default=None)
+
+    def __post_init__(self):
+        self.method = self.method.upper()
+        validate_method(self.method)
+        validate_headers(self.headers)
+
+    def client(self) -> httpx.Client:
+        try:
+            _client = httpx.Client(headers=self.headers, timeout=self.timeout)
+
+            return _client
+        except Exception as exc:
+            raise Exception(f"Unhandled exception getting HTTPX Client. Details: {exc}")
+
+
+@dataclass
+class SimpleHTTPXClient(SimpleHTTPXClientBase):
+    pass

red_utils/ext/httpx_utils/constants.py

@@ -1,4 +1,3 @@
 from __future__ import annotations
 
-valid_methods: list[str] = ["GET", "POST", "PUT", "UPDATE", "DELETE"]
 default_headers: dict[str, str] = {"Content-Type": "application/json"}

red_utils/ext/httpx_utils/operations.py

@@ -2,14 +2,18 @@
 
 from .constants import (
     default_headers,
-    valid_methods,
 )
-from .validators import validate_client, validate_headers, validate_method
+from .validators import (
+    validate_client,
+    validate_headers,
+    validate_method,
+)
 
 import httpx
 
 from httpx import Client
 
+
 def merge_headers(
     original_headers: dict[str, str] = default_headers,
     update_vals: dict[str, str] = None,

red_utils/ext/httpx_utils/validators.py

@@ -1,14 +1,38 @@
-from __future__ import annotations
-
 from typing import Union
+from httpx import AsyncClient, Client
 
-from .constants import valid_methods
+valid_methods: list[str] = ["GET", "POST", "PUT", "UPDATE", "DELETE"]
+
+
+def validate_method(method: str = None) -> str:
+    """Validate an HTTPX request method.
+
+    Params:
+    -------
+    - method (str): The method to validate.
+    """
+    if method is None:
+        raise ValueError("Missing a method to validate")
+    if not isinstance(method, str):
+        try:
+            method: str = str(method).upper()
+        except Exception as exc:
+            raise Exception(
+                f"Unable to coerce method value to string: ({type(method)}) - {method}. Details: {exc}"
+            )
+    else:
+        method: str = method.upper()
+
+    if method not in valid_methods:
+        raise ValueError(f"Invalid method: {method}. Must be one of {valid_methods}")
+
+    return method
 
-from httpx import AsyncClient, Client
 
 def validate_client(
     client: Union[Client, AsyncClient] = None
 ) -> Union[Client, AsyncClient]:
+    """Validate HTTPX Client/AsyncClient object."""
     if not client:
         raise ValueError("Missing client to evaluate")
 
@@ -20,20 +44,10 @@ def validate_client(
     return client
 
 
-def validate_method(method: str = None) -> str:
-    """Validate HTTP method."""
-    if not method:
-        raise ValueError("Missing method to evaluate")
-
-    if method not in valid_methods:
-        raise TypeError(f"Invalid method: {method}. Must be one of {valid_methods}")
-
-    return method
-
-
 def validate_headers(headers: dict[str, str] = None) -> dict[str, str]:
     if not headers:
-        raise ValueError("Missing headers to evaluate")
+        # raise ValueError("Missing headers to evaluate")
+        return
 
     if not isinstance(headers, dict):
         raise TypeError(

red_utils/std/__init__.py

@@ -4,7 +4,7 @@
     context_managers,
     dataclass_mixins,
     dict_utils,
-    file_utils,
+    path_utils,
     hash_utils,
     time_utils,
     uuid_utils,