module-typica 0.2.2__tar.gz → 0.2.4__tar.gz

{module_typica-0.2.2 → module_typica-0.2.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: module-typica
-Version: 0.2.2
+Version: 0.2.4
 Summary: Standard Pydantic usages & utilities
 Author: Oktapian
-Author-email: oktapian@jkt1.ebdesk.com
+Author-email: oktapian1998@gmail.com
 Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -12,15 +12,15 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: deprecated (>=1.2.14,<2.0.0)
 Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.6.1,<3.0.0)
-Requires-Dist: tomli (>=2.1.0,<3.0.0)
 Description-Content-Type: text/markdown
 
 # Description
-[![python: v^3.10](https://img.shields.io/badge/python-v^3.10-333A73.svg?logo=python&style=for-the-badge&logoColor=ffffff)](https://www.python.org/downloads/release/python-3100/)
-[![Pydantic: v^2.3.0](https://img.shields.io/badge/pydantic-v^2.3.0-e92063.svg?logo=pydantic&style=for-the-badge&logoColor=ffffff)](https://pydantic.dev)
-
 This is a standardized model library that uses the pydantic library, which is often used in work, especially in database connection, parameter, or response in service, and other utilities. This repository provides a standardized model that can be used in various scenarios. It aims to simplify the process of defining and validating models in Python applications.
 
+## Usages
+there are several use cases that can be implemented using this library, such as some of the examples below
+
+
 
 ## Contributors
 

{module_typica-0.2.2 → module_typica-0.2.4}/Readme.md

@@ -1,9 +1,10 @@
 # Description
-[![python: v^3.10](https://img.shields.io/badge/python-v^3.10-333A73.svg?logo=python&style=for-the-badge&logoColor=ffffff)](https://www.python.org/downloads/release/python-3100/)
-[![Pydantic: v^2.3.0](https://img.shields.io/badge/pydantic-v^2.3.0-e92063.svg?logo=pydantic&style=for-the-badge&logoColor=ffffff)](https://pydantic.dev)
-
 This is a standardized model library that uses the pydantic library, which is often used in work, especially in database connection, parameter, or response in service, and other utilities. This repository provides a standardized model that can be used in various scenarios. It aims to simplify the process of defining and validating models in Python applications.
 
+## Usages
+there are several use cases that can be implemented using this library, such as some of the examples below
+
+
 
 ## Contributors
 

{module_typica-0.2.2 → module_typica-0.2.4}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "module-typica"
-version = "0.2.2"
+version = "0.2.4"
 description = "Standard Pydantic usages & utilities"
-authors = ["Oktapian <oktapian@jkt1.ebdesk.com>"]
+authors = ["Oktapian <oktapian1998@gmail.com>"]
 readme = "Readme.md"
 packages = [{include = "typica"}]
 
@@ -14,11 +14,28 @@ venv = ".venv"
 python = "^3.10"
 pydantic = "^2.9.2"
 pydantic-settings = "^2.6.1"
-tomli = "^2.1.0"
 deprecated = "^1.2.14"
 
 [tool.poetry.group.dev.dependencies]
 faker = "^25.3.0"
+pytest = "^8.3.3"
+
+
+[tool.poetry.group.postgresql.dependencies]
+psycopg2-binary = "^2.9.10"
+sqlalchemy = "^2.0.36"
+
+
+[tool.poetry.group.mongo.dependencies]
+pymongo = "^4.10.1"
+
+
+[tool.poetry.group.clickhouse.dependencies]
+clickhouse-connect = "^0.8.7"
+
+
+[tool.poetry.group.redis.dependencies]
+redis = "^5.2.0"
 
 [build-system]
 requires = ["poetry-core"]

{module_typica-0.2.2 → module_typica-0.2.4}/typica/__init__.py

@@ -1,4 +1,5 @@
 from .base import *
 from .connection import *
 from .utils import *
-from .response import *
+from .response import *
+from .schema import *

{module_typica-0.2.2 → module_typica-0.2.4}/typica/connection.py

@@ -4,11 +4,15 @@ from typing import Optional
 from pydantic import BaseModel, Field, model_validator
 
 
-
 class EndpointMeta(BaseModel):
     host: Optional[str] = Field("localhost", description="Connection host")
     port: Optional[str | int] = Field(8000, description="Connection port")
 
+    @property
+    def port_int(self) -> int | None:
+        if isinstance(self.port, str):
+            return int(self.port)
+        return self.port
 
 
 class AuthMeta(BaseModel):
@@ -23,7 +27,6 @@ class URIConnectionMeta(BaseModel):
 class DBConnectionMeta(EndpointMeta, AuthMeta, URIConnectionMeta):
     database: Optional[str] = Field(None, description="Database name")
 
-
     def uri_string(self, base: str = "http", with_db: bool = True) -> str:
         """
         Return a URI string for the database connection.
@@ -39,9 +42,26 @@ class DBConnectionMeta(EndpointMeta, AuthMeta, URIConnectionMeta):
             return f"{base}://{meta}/{self.database if with_db else ''}"
         return ""
 
-
     @model_validator(mode="after")
     def extract_uri(self):
+        """
+        Extracts and parses the URI to populate the connection metadata fields.
+
+        This method processes the `uri` attribute to extract authentication and
+        connection details such as username, password, host, port, and database.
+        It modifies the respective attributes of the instance based on the parsed
+        URI components.
+
+        Steps involved:
+        - Strips the scheme from the URI.
+        - Splits the URI into metadata and additional query parameters.
+        - Extracts database name from query parameters if present.
+        - Parses authentication info and host details from the metadata.
+        - Converts the port to an integer.
+
+        Returns:
+            The instance with populated connection metadata fields.
+        """
         if self.uri:
             uri = re.sub(r"\w+:(//|/)", "", self.uri)
             metadata, others = (
@@ -63,8 +83,11 @@ class DBConnectionMeta(EndpointMeta, AuthMeta, URIConnectionMeta):
                 self.port = int(self.port)
         return self
 
+
 class ClusterConnectionMeta(AuthMeta, URIConnectionMeta):
-    cluster_uri: Optional[list[EndpointMeta]]  = Field([], description="List of clusters endpoint")
+    cluster_uri: Optional[list[EndpointMeta]] = Field(
+        [], description="List of clusters endpoint"
+    )
     database: Optional[str] = Field(None, description="Database name")
 
     def uri_string(self, base: str = "http", with_db: bool = True) -> str:
@@ -81,38 +104,42 @@ class ClusterConnectionMeta(AuthMeta, URIConnectionMeta):
                 return f"{base}://{self.username}:{self.password}@{meta}/{self.database if with_db else ''}"
             return f"{base}://{meta}/{self.database if with_db else ''}"
         return ""
-    
 
     @model_validator(mode="after")
     def extract_uri(self):
+        """
+        Extract URI from connection string and fill in the respective fields.
+
+        If the connection string is in the format of mongodb://user:password@host:port/database,
+        the respective fields will be filled in. If the connection string is in the format of
+        mongodb://host:port,host:port/database, the hosts will be split into a list of
+        EndpointMeta objects.
+
+        :return: The modified ClusterConnectionMeta object.
+        :rtype: ClusterConnectionMeta
+        """
         if self.uri:
             uri = re.sub(r"\w+:(//|/)", "", self.uri)
-            metadata, others = (
+            clean_meta, others = (
                 re.split(r"\/\?|\/", uri) if re.search(r"\/\?|\/", uri) else [uri, None]
             )
+            cluster_uri = []
             if others and "&" in others:
                 for other in others.split("&"):
                     if "=" in other and re.search(r"authSource", other):
                         self.database = other.split("=")[-1]
                     elif "=" not in other:
                         self.database = other
-            if "@" in metadata:
-                if "," in metadata:
-                    metadata, raw_clusters = re.split(r"\@", metadata)
-                    self.username, self.password = re.split(r"\:", metadata)
-                    cluster_uri = []
-                    for cluster in raw_clusters.split(","):
-                        hostData = re.split(r"\:", cluster)
-                        cluster_uri.append(EndpointMeta(host=hostData[0], port=int(hostData[1])))
-                    self.cluster_uri = cluster_uri
-                else:
-                    self.username, self.password, self.host, self.port = re.split(
-                        r"\@|\:", metadata
-                    )
-            else:
-                self.host, self.port = re.split(r"\:", metadata)
-            if self.port:
-                self.port = int(self.port)
+            if "@" in clean_meta:
+                auth_meta, clean_meta = re.split(r"\@", clean_meta)
+                self.username, self.password = re.split(r"\:", auth_meta)
+
+            for cluster in clean_meta.split(","):
+                hostData = re.split(r"\:", cluster)
+                cluster_uri.append(
+                    EndpointMeta(host=hostData[0], port=int(hostData[1]))
+                )
+            self.cluster_uri = cluster_uri
         return self
 
 
@@ -122,7 +149,6 @@ class S3ConnectionMeta(EndpointMeta):
     bucket: str = Field(..., description="S3 bucket name")
     base_path: Optional[str] = Field("/", description="S3 base path")
 
-
     @property
     def json_meta(self) -> dict:
         """
@@ -134,4 +160,12 @@ class S3ConnectionMeta(EndpointMeta):
             "endpoint_url": f"http://{self.host}:{self.port}",
             "key": self.access_key,
             "secret": self.secret_key,
-        }
+        }
+
+
+class RedisConnectionMeta(EndpointMeta, AuthMeta):
+    database: int = Field(..., description="Database name")
+
+
+class RMQConnectionMeta(EndpointMeta, AuthMeta):
+    vhost: Optional[str] = Field(None, description="Virtual host")

{module_typica-0.2.2 → module_typica-0.2.4}/typica/metadata.py

@@ -1,7 +1,6 @@
-
 from typing import Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, RootModel, Field
 
 from .utils import MedallionTypes, LocationLevel
 from .connection import DBConnectionMeta, S3ConnectionMeta, ClusterConnectionMeta
@@ -16,6 +15,30 @@ class SchemaMeta(BaseModel):
     field_hide: Optional[bool] = Field(False, description="Hide field")
 
 
+class SchemaRawMeta(SchemaMeta):
+    regional_field: Optional[str] = Field(None, description="Regional field")
+    none_percentage: Optional[float] = Field(
+        0.0, description="Percentage of null / none values"
+    )
+    unique_value: Optional[list[str]] = Field(
+        None, description="Unique values in field"
+    )
+    describe_field: Optional[str] = Field(None, description="Describe field")
+
+
+class Schemas(RootModel):
+    root: list[SchemaMeta]
+
+    def __iter__(self):  # type: ignore
+        return self.root.__iter__()
+
+    def __getitem__(self, item):
+        return self.root[item]
+
+    def __len__(self):
+        return self.root.__len__()
+
+
 class SimplifieMetadata(BaseModel):
     id: str = Field(..., description="Identifier for the metadata")
 
@@ -23,7 +46,7 @@ class SimplifieMetadata(BaseModel):
     title: str = Field(..., description="Title, name, or label for the metadata")
     source: str = Field(..., description="Source of the metadata, e.g. www.example.com")
     country: str = Field(..., description="Country of origin")
-    year: str = Field(..., description="Year of the metadata")
+    year: str | int = Field(..., description="Year of the metadata")
     range_data: str = Field(..., description="Range of data, eg. 2021-2022")
     description: Optional[str] = Field(None)
 
@@ -32,7 +55,7 @@ class SimplifieMetadata(BaseModel):
     sub_category: Optional[str] = Field(None)
 
     # ? Schemas
-    schemas: list[SchemaMeta] = Field(..., description="Description of all fields in data")
+    schemas: Schemas = Field(..., description="Description of all fields in data")
 
     # ? Database
     database_access: DBConnectionMeta | ClusterConnectionMeta
@@ -65,10 +88,9 @@ class FullMetadata(SimplifieMetadata):
 
     # ? Data lake
     # * Use case: bronze
-    lake_access: Optional[S3ConnectionMeta | DBConnectionMeta | ClusterConnectionMeta] = Field(
-        None, description="Data lake access"
-    )
+    lake_access: Optional[
+        S3ConnectionMeta | DBConnectionMeta | ClusterConnectionMeta
+    ] = Field(None, description="Data lake access")
     lake_meta_path: Optional[str] = Field(None, description="Data lake metadata path")
     lake_data_path: Optional[str] = Field(None, description="Data lake data path")
     lake_data_format: Optional[str] = Field(None, description="Data lake data format")
-

module_typica-0.2.4/typica/modules/cclickhouse.py

@@ -0,0 +1,67 @@
+from clickhouse_connect import get_client
+from clickhouse_connect.driver.client import Client
+
+from typica.connection import DBConnectionMeta
+
+
+class CHConnector:
+
+    _meta: DBConnectionMeta
+    _client: Client
+
+    def __init__(self, meta: DBConnectionMeta) -> None:
+        """
+        Initialize the ClickHouse connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: DBConnectionMeta
+        """
+        self._meta = meta
+
+    def __enter__(self) -> "CHConnector":
+        """
+        Connect to the ClickHouse server and return the connection object.
+
+        :return: The connection object.
+        :rtype: CHConnector
+        :raises ValueError: If the connection to the ClickHouse server fails.
+        """
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Close the connection to the ClickHouse server.
+
+        This method is called when the context manager exits its scope.
+        """
+        self.close()
+
+    def connect(self) -> None:
+        """
+        Establish a connection to the ClickHouse server.
+
+        :raises ValueError: If the connection to the ClickHouse server fails.
+        :raises Exception: If any other error occurs during the connection.
+        """
+        try:
+            self._client = get_client(
+                host=str(self._meta.host),
+                port=int(self._meta.port),  # type: ignore
+                user=self._meta.username,
+                password=self._meta.password
+                or "",  # cause get_client doesn't support empty password
+                database=str(self._meta.database),
+            )
+
+        except Exception as e:
+            raise e
+
+    def close(self) -> None:
+        """
+        Close the connection to the ClickHouse server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._client:
+            self._client.close()

module_typica-0.2.4/typica/modules/pmongo.py

@@ -0,0 +1,70 @@
+from pymongo import MongoClient
+from pymongo.database import Database
+from pymongo.errors import NetworkTimeout, ExecutionTimeout
+
+from typica.connection import DBConnectionMeta
+
+
+class MongoConnector:
+
+    _meta: DBConnectionMeta
+    _client: MongoClient
+    _db: Database
+
+    def __init__(self, meta: DBConnectionMeta) -> None:
+        """
+        Initialize the Mongo connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: DBConnectionMeta
+        """
+        self._meta = meta
+        if not self._meta.uri:
+            self._meta.uri = self._meta.uri_string(base="mongodb", with_db=False)
+
+    def __enter__(self):
+        """
+        Connect to the MongoDB server and return the connection object.
+
+        :return: The connection object.
+        :rtype: MongoConnector
+        :raises ValueError: If the connection to the MongoDB server fails.
+        """
+        self.connect()
+        if self._client is None:
+            raise ValueError("Mongo not connected.")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Close the connection to the MongoDB server.
+
+        This method is called when the context manager exits its scope.
+        """
+        self.close()
+
+    def connect(self, **kwargs) -> None:
+        """
+        Establish a connection to the MongoDB server.
+
+        :param kwargs: Additional keyword arguments for MongoClient.
+        :raises ValueError: If the connection to the MongoDB server fails.
+        :raises Exception: If any other error occurs during the connection.
+        """
+
+        try:
+            self._client = MongoClient(self._meta.uri, timeoutMS=20000, **kwargs)
+            self._db = self._client[str(self._meta.database)]
+        except (NetworkTimeout, ExecutionTimeout):
+            raise ValueError("Mongo connection timed out.")
+        except Exception as e:
+            raise e
+
+    def close(self) -> None:
+        """
+        Close the connection to the MongoDB server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._client:
+            self._client.close()

module_typica-0.2.4/typica/modules/psycopg.py

@@ -0,0 +1,76 @@
+import psycopg2
+
+from psycopg2.extensions import connection, cursor
+from psycopg2.errors import (
+    IdleSessionTimeout,
+    IdleInTransactionSessionTimeout,
+    ConnectionFailure,
+)
+
+from typica.connection import DBConnectionMeta
+
+
+class PostgreConnector:
+
+    _meta: DBConnectionMeta
+    _conn: connection
+    _cursor: cursor
+
+    def __init__(self, meta: DBConnectionMeta) -> None:
+        """
+        Initialize the Postgre connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: DBConnectionMeta
+        """
+        self._meta = meta
+
+    def __enter__(self) -> "PostgreConnector":
+        """
+        Connect to the PostgreSQL server and return the connection object.
+
+        :return: The connection object.
+        :rtype: PostgreConnector
+        :raises ValueError: If the connection to the PostgreSQL server fails.
+        """
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
+        self.close()
+
+    def connect(self, **kwargs) -> None:
+        """
+        Establish a connection to the PostgreSQL server.
+
+        :param kwargs: Additional keyword arguments for psycopg2.connect.
+        :raises ValueError: If the connection to the PostgreSQL server fails.
+        :raises Exception: If any other error occurs during the connection.
+        """
+        try:
+            self._conn = psycopg2.connect(
+                dbname=self._meta.database,
+                user=self._meta.username,
+                password=self._meta.password,
+                host=self._meta.host,
+                port=self._meta.port,
+                **kwargs
+            )
+            self._cursor = self._conn.cursor()
+        except ConnectionFailure:
+            raise ValueError("PostgreSQL connection failed.")
+        except (IdleInTransactionSessionTimeout, IdleSessionTimeout):
+            raise ValueError("Session timed out.")
+        except Exception as e:
+            raise e
+
+    def close(self) -> None:
+        """
+        Close the connection to the PostgreSQL server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._cursor:
+            self._cursor.close()
+        if self._conn:
+            self._conn.close()

module_typica-0.2.4/typica/modules/psycopg_alchemy.py

@@ -0,0 +1,83 @@
+from sqlalchemy import Engine, URL, Connection, create_engine, text, CursorResult
+from sqlalchemy.exc import TimeoutError
+
+from typica.connection import DBConnectionMeta
+
+
+class PostgreConnector:
+
+    _meta: DBConnectionMeta
+    _engine: Engine
+    _conn: Connection
+
+    def __init__(self, meta: DBConnectionMeta) -> None:
+        """
+        Initialize the Postgre connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: DBConnectionMeta
+        """
+        self._meta = meta
+
+    def __enter__(self) -> Connection:
+        """
+        Connect to the PostgreSQL server and return the connection object.
+
+        :return: The connection object.
+        :rtype: Connection
+        :raises ValueError: If the connection to the PostgreSQL server fails.
+        """
+        self.connect()
+        return self._conn
+
+    def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
+        """
+        Close the connection to the PostgreSQL server.
+
+        This method is called when the context manager exits its scope.
+        """
+        self.close()
+
+    def execute_text(self, sql: str) -> CursorResult:
+        try:
+            res = self._conn.execute(text(sql))
+            return res
+        except Exception as e:
+            raise e
+
+    def connect(self) -> Connection:
+        """
+        Establish a connection to the PostgreSQL server.
+
+        :return: The connection object.
+        :rtype: Connection
+        :raises ValueError: If the connection to the PostgreSQL server fails.
+        :raises Exception: If any other error occurs during the connection.
+        """
+        try:
+            self._engine = create_engine(
+                URL.create(
+                    drivername="postgresql",
+                    username=self._meta.username,
+                    password=self._meta.password,
+                    host=self._meta.host,
+                    port=int(self._meta.port),  # type: ignore
+                    database=self._meta.database,
+                )
+            )
+            self._conn = self._engine.connect()
+
+            return self._conn
+        except TimeoutError:
+            raise ValueError("PostgreSQL connection timed out.")
+        except Exception as e:
+            raise e
+
+    def close(self) -> None:
+        """
+        Close the connection to the PostgreSQL server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._conn:
+            self._conn.close()

module_typica-0.2.4/typica/modules/redis.py

@@ -0,0 +1,165 @@
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
+from redis.exceptions import TimeoutError
+
+from typica.connection import RedisConnectionMeta
+
+
+class RedisConnector:
+
+    _meta: RedisConnectionMeta
+    _client: Redis
+
+    def __init__(self, meta: RedisConnectionMeta) -> None:
+        """
+        Initialize the Redis connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: RedisConnectionMeta
+        """
+        self._meta = meta
+
+    def __enter__(self):
+        """
+        Connect to the Redis server and return the connection object.
+
+        :return: The connection object.
+        :rtype: RedisConnector
+        :raises ValueError: If the connection to the Redis server fails.
+        """
+        self.connect()
+        if self._client is None:
+            raise ValueError("Redis not connected.")
+        return self
+
+    def __call__(self, *args, **kwds) -> bool:
+        """
+        Check if the connection is already established.
+
+        :return: True if the connection is available, False otherwise.
+        :rtype: bool
+        """
+
+        if self._client is None:
+            raise ValueError("Redis not connected.")
+        return True
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Close the connection to the Redis server.
+
+        This method is called when the context manager exits its scope.
+        """
+        self.close()
+
+    def connect(self, other_database: int | None = None) -> None:
+        """
+        Establish a connection to the Redis server.
+
+        :param other_database: The ID of an alternative database to connect to.
+                               If not provided, the default database ID will be used.
+        :type other_database: int | None
+        :raises ValueError: If the connection to the Redis server fails.
+        """
+        try:
+
+            self._client = Redis(
+                host=str(self._meta.host),
+                port=int(self._meta.port),  # type: ignore
+                username=self._meta.username,
+                password=self._meta.password,
+                db=other_database if other_database else self._meta.database,
+            )
+
+        except TimeoutError:
+            raise ValueError("Redis connection timed out.")
+        except Exception as e:
+            raise e
+
+    def close(self) -> None:
+        """
+        Close the connection to the Redis server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._client:
+            self._client.close()
+
+
+class AsyncRedisConnector:
+
+    _meta: RedisConnectionMeta
+    _client: AsyncRedis
+
+    def __init__(self, meta: RedisConnectionMeta) -> None:
+        """
+        Initialize the Redis connector with the given connection metadata.
+
+        :param meta: The metadata of the database connection.
+        :type meta: RedisConnectionMeta
+        """
+        self._meta = meta
+
+    async def __enter__(self):
+        """
+        Connect to the Redis server and return the connection object.
+
+        :return: The connection object.
+        :rtype: RedisConnector
+        :raises ValueError: If the connection to the Redis server fails.
+        """
+        await self.connect()
+        if self._client is None:
+            raise ValueError("Redis not connected.")
+        return self
+
+    async def __call__(self, *args, **kwds) -> bool:
+        """
+        Check if the connection is already established.
+
+        :return: True if the connection is available, False otherwise.
+        :rtype: bool
+        """
+
+        if self._client is None:
+            raise ValueError("Redis not connected.")
+        return True
+
+    async def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Close the connection to the Redis server.
+
+        This method is called when the context manager exits its scope.
+        """
+        await self.close()
+
+    async def connect(self, other_database: int | None = None) -> None:
+        """
+        Establish a connection to the Redis server.
+
+        :param other_database: The alternative database name to connect to.
+        :raises ValueError: If the connection to the Redis server fails.
+        :raises Exception: If any other error occurs during the connection.
+        """
+        try:
+
+            self._client = AsyncRedis(
+                host=str(self._meta.host),
+                port=int(self._meta.port),  # type: ignore
+                username=self._meta.username,
+                password=self._meta.password,
+                db=other_database if other_database else self._meta.database,
+            )
+        except TimeoutError:
+            raise ValueError("Redis connection timed out.")
+        except Exception as e:
+            raise e
+
+    async def close(self) -> None:
+        """
+        Close the connection to the Redis server.
+
+        This method is a no-op if the connection is already closed.
+        """
+        if self._client:
+            await self._client.close()

{module_typica-0.2.2 → module_typica-0.2.4}/typica/response.py

@@ -7,6 +7,7 @@ class BaseResponseMeta(BaseModel):
     code: int
     message: str
 
+
 class PaginationResponseMeta(BaseResponseMeta):
     page: Optional[int] = Field(1, gt=0)
     size: Optional[int] = Field(10, ge=0)
@@ -19,7 +20,7 @@ class ServiceResponse:
         self.model = model
         self.auth = auth
 
-    def basic(self, route: str) -> dict:
+    def basic(self, route_name: str) -> dict:
         """
         Generate a basic response, which is a dictionary of common response codes and models.
 
@@ -27,27 +28,32 @@ class ServiceResponse:
         - 400 Bad Request
         - 500 Internal Server Error
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :return: A dictionary of common response codes and models
         """
         return {
             400: {
-                "model": create_model(
-                    route, code=(int, 400), message=(str, "Bad Request")
-                ),
+                "model": create_model(route_name, message=(str, "Bad Request")),
                 "description": "Occurs when the request you make does not match or is invalid",
             },
             500: {
                 "model": create_model(
-                    route,
-                    code=(int, 500),
+                    route_name,
                     message=(str, "Internal Server Error"),
                 ),
                 "description": "Occurs when there is an engine or lib error in the engine",
             },
         }
 
-    def get(self, route: str, model: Any = None, obj: str = "Data", auth: bool = False, exclude_codes: list = [], **kwargs) -> dict:
+    def get(
+        self,
+        route_name: str,
+        model: Any = None,
+        obj: str = "Data",
+        auth: bool = False,
+        exclude_codes: list = [],
+        **kwargs,
+    ) -> dict:
         """
         Generate a response for a get request, which is a dictionary of common response codes and models.
 
@@ -55,7 +61,7 @@ class ServiceResponse:
         - 200 Success
         - 404 Not Found
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :param model: The model to use for the response
         :param obj: The object name to use for the response
         :param auth: Whether or not the route requires authentication
@@ -65,39 +71,39 @@ class ServiceResponse:
         response: dict = {
             200: {
                 "model": create_model(
-                    route,
-                    code=(int, 200),
+                    route_name,
                     message=(str, "Success"),
                     data=(model if model else self.model, ...),
                 ),
                 "description": "Success get data",
             },
             404: {
-                "model": create_model(
-                    route, code=(int, 404), message=(str, f"{obj} not found")
-                ),
+                "model": create_model(route_name, message=(str, f"{obj} not found")),
             },
-            **self.basic(route),
-            **kwargs
+            **self.basic(route_name),
+            **kwargs,
         }
 
         if exclude_codes:
             for code in exclude_codes:
                 del response[code]
-            
 
         if auth or self.auth:
             response[401] = {
-                "model": create_model(
-                    route, code=(int, 401), message=(str, "Unauthorized")
-                )
+                "model": create_model(route_name, message=(str, "Unauthorized"))
             }
-        
-        return response
-
 
+        return response
 
-    def pagination(self, route: str, model: Any = None, obj: str = "Data", auth: bool = False, exclude_codes: list = [], **kwargs) -> dict:
+    def pagination(
+        self,
+        route_name: str,
+        model: Any = None,
+        obj: str = "Data",
+        auth: bool = False,
+        exclude_codes: list = [],
+        **kwargs,
+    ) -> dict:
         """
         Generate a pagination response, which is a dictionary of common response codes and models.
 
@@ -106,7 +112,7 @@ class ServiceResponse:
         - 404 Not Found
         - 401 Unauthorized (optional)
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :param model: The model to use for the response
         :param obj: The object to be gotten
         :param auth: Whether or not the route requires authentication
@@ -116,8 +122,7 @@ class ServiceResponse:
         response: dict = {
             200: {
                 "model": create_model(
-                    route,
-                    code=(int, 200),
+                    route_name,
                     message=(str, f"Success get all {obj}"),
                     data=(model if model else self.model, ...),
                     page=(int, 1),
@@ -126,29 +131,32 @@ class ServiceResponse:
                 ),
             },
             404: {
-                "model": create_model(
-                    route, code=(int, 404), message=(str, f"{obj} not found")
-                ),
+                "model": create_model(route_name, message=(str, f"{obj} not found")),
             },
-            **self.basic(route),
-            **kwargs
+            **self.basic(route_name),
+            **kwargs,
         }
 
         if exclude_codes:
             for code in exclude_codes:
                 del response[code]
-            
 
         if auth or self.auth:
             response[401] = {
-                "model": create_model(
-                    route, code=(int, 401), message=(str, "Unauthorized")
-                )
+                "model": create_model(route_name, message=(str, "Unauthorized"))
             }
-        
+
         return response
 
-    def creation(self, route: str, model: Any = None, obj: str = "Data", auth: bool = False, exclude_codes: list = [], **kwargs) -> dict:
+    def creation(
+        self,
+        route_name: str,
+        model: Any = None,
+        obj: str = "Data",
+        auth: bool = False,
+        exclude_codes: list = [],
+        **kwargs,
+    ) -> dict:
         """
         Generate a response for a create request, which is a dictionary of common response codes and models.
 
@@ -156,139 +164,126 @@ class ServiceResponse:
         - 201 Created
         - 401 Unauthorized
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :param model: The model to use for the response
         :param obj: The object name to use for the response
         :param auth: Whether or not the route requires authentication
         :param exclude_codes: A list of codes to exclude from the response
         :return: A dictionary of common response codes and models
         """
-        response: dict =  {
+        response: dict = {
             201: {
                 "model": create_model(
-                    route,
-                    code=(int, 201),
+                    route_name,
                     message=(str, f"{obj} created successfully"),
                     data=(model if model else self.model, ...),
                 ),
             },
-            **self.basic(route),
-            **kwargs
+            **self.basic(route_name),
+            **kwargs,
         }
 
         if exclude_codes:
             for code in exclude_codes:
                 del response[code]
-            
 
         if auth or self.auth:
             response[401] = {
-                "model": create_model(
-                    route, code=(int, 401), message=(str, "Unauthorized")
-                )
+                "model": create_model(route_name, message=(str, "Unauthorized"))
             }
-        
+
         return response
 
-    def update(self, route: str, model: Any = None, obj: str = "Data", auth: bool = False, exclude_codes: list = [], **kwargs) -> dict:
+    def update(
+        self,
+        route_name: str,
+        model: Any = None,
+        obj: str = "Data",
+        auth: bool = False,
+        exclude_codes: list = [],
+        **kwargs,
+    ) -> dict:
         """
         Generate a response for a update request, which is a dictionary of common response codes and models.
 
         Contains:
         - 200 OK
-        - 204 No Content
         - 401 Unauthorized (optional)
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :param model: The model to use for the response
         :param obj: The object name to use for the response
         :param auth: Whether or not the route requires authentication
         :param exclude_codes: A list of codes to exclude from the response
         :return: A dictionary of common response codes and models
         """
-        response: dict =  {
+        response: dict = {
             200: {
                 "model": create_model(
-                    route,
-                    code=(int, 200),
+                    route_name,
                     message=(str, f"{obj} updated successfully"),
                     data=(model if model else self.model, ...),
                 ),
             },
-            204: {
-                "model": create_model(
-                    route,
-                    code=(int, 204),
-                    message=(str, f"{obj} updated successfully"),
-                ),
-            },
-            **self.basic(route),
-            **kwargs
+            **self.basic(route_name),
+            **kwargs,
         }
 
         if exclude_codes:
             for code in exclude_codes:
                 del response[code]
-            
 
         if auth or self.auth:
             response[401] = {
-                "model": create_model(
-                    route, code=(int, 401), message=(str, "Unauthorized")
-                )
+                "model": create_model(route_name, message=(str, "Unauthorized"))
             }
-        
+
         return response
 
-    def delete(self, route: str, model: Any = None, obj: str = "Data", auth: bool = False, exclude_codes: list = [], **kwargs) -> dict:
+    def delete(
+        self,
+        route_name: str,
+        model: Any = None,
+        obj: str = "Data",
+        auth: bool = False,
+        exclude_codes: list = [],
+        **kwargs,
+    ) -> dict:
         """
         Generate a response for a delete request, which is a dictionary of common response codes and models.
 
         Contains:
         - 200 Success
-        - 204 Success
         - 400 Bad Request
         - 401 Unauthorized (optional)
         - 500 Internal Server Error
 
-        :param route: The path of the route
+        :param route_name: The name of model for response
         :param model: The model to use for the response
         :param obj: The object name to use for the response
         :param auth: Whether or not the route requires authentication
         :param exclude_codes: A list of codes to exclude from the response
         :return: A dictionary of common response codes and models
         """
-        response: dict =  {
+        response: dict = {
             200: {
                 "model": create_model(
-                    route,
-                    code=(int, 200),
+                    route_name,
                     message=(str, f"{obj} delete successfully"),
                     data=(model if model else self.model, ...),
                 ),
             },
-            204: {
-                "model": create_model(
-                    route,
-                    code=(int, 204),
-                    message=(str, f"{obj} delete successfully"),
-                ),
-            },
-            **self.basic(route),
-            **kwargs
+            **self.basic(route_name),
+            **kwargs,
         }
 
         if exclude_codes:
             for code in exclude_codes:
                 del response[code]
-            
 
         if auth or self.auth:
             response[401] = {
-                "model": create_model(
-                    route, code=(int, 401), message=(str, "Unauthorized")
-                )
+                "model": create_model(route_name, message=(str, "Unauthorized"))
             }
-        
+
         return response
-    

module_typica-0.2.4/typica/schema.py

@@ -0,0 +1,27 @@
+from typing import Optional, Any
+
+from pydantic import BaseModel, Field
+
+
+class PaginationSchema(BaseModel):
+    page: Optional[int] = Field(1, gt=0, description="Page number")
+    size: Optional[int] = Field(10, ge=0, description="Page size")
+
+
+class OrderSchema(BaseModel):
+    order_by: Optional[str] = Field(None, description="Order by field")
+    order_type: Optional[str | int] = Field(
+        None, description="Order type", examples=[1, "asc", "desc"]
+    )
+
+
+class FilterValueSchema(BaseModel):
+    filter_value: Optional[Any] = Field(None, description="Filter value")
+
+
+class FilterSchema(FilterValueSchema):
+    filter_by: Optional[str] = Field(None, description="Filter by field")
+
+
+class FilterOpsSchema(FilterSchema):
+    filter_op: Optional[str] = Field(None, description="Filter operation")

module_typica-0.2.4/typica/utils/__init__.py

@@ -0,0 +1,2 @@
+from .enums import *
+from .config import ProjectConfig

module_typica-0.2.4/typica/utils/config.py

@@ -0,0 +1,35 @@
+from typing import Tuple, Type
+
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+    PyprojectTomlConfigSettingsSource,
+    PydanticBaseSettingsSource,
+)
+
+
+class ProjectConfig(BaseSettings):
+
+    name: str
+    version: str = "0.1.0"
+    description: str = ""
+    authors: list[str] = []
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        return (PyprojectTomlConfigSettingsSource(settings_cls),)
+
+    model_config = SettingsConfigDict(
+        pyproject_toml_table_header=("tool", "poetry"), extra="ignore"
+    )
+
+    @property
+    def title(self) -> str:
+        return self.name.replace("-", " ").title()

{module_typica-0.2.2 → module_typica-0.2.4}/typica/utils/enums.py

@@ -42,6 +42,7 @@ class EnumV2(Enum):
         """
         return self._description_
 
+
 class Operator(EnumV2):
     equal = ("eq", "value is equals to")
     unequal = ("ne", "value isn't equals to")
@@ -61,9 +62,9 @@ class FilterOption(EnumV2):
     mustnt = ("mustnt", "List of filter mustn't exact")
     should = ("should", "List of filter should exact")
     shouldnt = ("shouldnt", "List of filter shouldn't exact")
-    
 
-class LocationLevel(str, EnumV2):
+
+class LocationLevel(EnumV2):
     CONTINENT = ("continent", "Continent level data")
     COUNTRY = ("country", "Country level data")
     PROVINCE = ("province", "Province level data")
@@ -72,9 +73,9 @@ class LocationLevel(str, EnumV2):
     SUBDISTRICT = ("subdistrict", "Subdistrict level data")
 
 
-class MedallionTypes(str, EnumV2):
-    LAKE = ("lake", 'Lake data')
-    BRONZE = ("bronze", 'bronze level Medallion')
-    SILVER = ("silver", 'silver level Medallion')
-    GOLD = ("gold", 'gold level Medallion')
-    OTHER = ("other", 'other than any level Medallion')
+class MedallionTypes(EnumV2):
+    LAKE = ("lake", "Lake data")
+    BRONZE = ("bronze", "bronze level Medallion")
+    SILVER = ("silver", "silver level Medallion")
+    GOLD = ("gold", "gold level Medallion")
+    OTHER = ("other", "other than any level Medallion")

module_typica-0.2.2/typica/utils/__init__.py

@@ -1 +0,0 @@
-from .enums import *