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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: module-typica
-Version: 0.2.2
+Version: 0.2.3
 Summary: Standard Pydantic usages & utilities
 Author: Oktapian
 Author-email: oktapian@jkt1.ebdesk.com
@@ -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.3}/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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "module-typica"
-version = "0.2.2"
+version = "0.2.3"
 description = "Standard Pydantic usages & utilities"
 authors = ["Oktapian <oktapian@jkt1.ebdesk.com>"]
 readme = "Readme.md"
@@ -14,12 +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"
 
+
+[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"]
 build-backend = "poetry.core.masonry.api"

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

@@ -4,13 +4,11 @@ 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")
 
 
-
 class AuthMeta(BaseModel):
     username: Optional[str] = Field(None, description="Database username")
     password: Optional[str] = Field(None, description="Database password")
@@ -23,7 +21,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,7 +36,6 @@ class DBConnectionMeta(EndpointMeta, AuthMeta, URIConnectionMeta):
             return f"{base}://{meta}/{self.database if with_db else ''}"
         return ""
 
-
     @model_validator(mode="after")
     def extract_uri(self):
         if self.uri:
@@ -63,8 +59,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,7 +80,6 @@ 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):
@@ -103,7 +101,9 @@ class ClusterConnectionMeta(AuthMeta, URIConnectionMeta):
                     cluster_uri = []
                     for cluster in raw_clusters.split(","):
                         hostData = re.split(r"\:", cluster)
-                        cluster_uri.append(EndpointMeta(host=hostData[0], port=int(hostData[1])))
+                        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(
@@ -122,7 +122,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 +133,8 @@ 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")

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

@@ -1,4 +1,3 @@
-
 from typing import Optional
 
 from pydantic import BaseModel, Field
@@ -16,6 +15,17 @@ 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 SimplifieMetadata(BaseModel):
     id: str = Field(..., description="Identifier for the metadata")
 
@@ -32,7 +42,9 @@ class SimplifieMetadata(BaseModel):
     sub_category: Optional[str] = Field(None)
 
     # ? Schemas
-    schemas: list[SchemaMeta] = Field(..., description="Description of all fields in data")
+    schemas: list[SchemaMeta] = Field(
+        ..., description="Description of all fields in data"
+    )
 
     # ? Database
     database_access: DBConnectionMeta | ClusterConnectionMeta
@@ -65,10 +77,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.3/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.3/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, **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.3/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.3/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.3/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.3}/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")