module-typica 0.2.2__py3-none-any.whl

module_typica-0.2.2.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: module-typica
+Version: 0.2.2
+Summary: Standard Pydantic usages & utilities
+Author: Oktapian
+Author-email: oktapian@jkt1.ebdesk.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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.
+
+
+## Contributors
+
+[//]: contributor-faces
+
+<a href="https://github.com/oktapiancaw"><img src="https://avatars.githubusercontent.com/u/48079010?v=4" title="Oktapian Candra" width="80" height="80" style="border-radius: 50%"></a>
+
+[//]: contributor-faces

module_typica-0.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+typica/__init__.py,sha256=vzdnhKeUul8ChMPhzOg9sftMxQu6DylYZUVWZXX1m5Y,90
+typica/base.py,sha256=qyHadRT3FfqDOxIqkRa4aad0MMd-78I_QOZ2ec1PTPk,2603
+typica/connection.py,sha256=C1JFNDRN2nQxgsktd9_28ZevqZ8y39aIZ7RMl0c4KB4,5365
+typica/metadata.py,sha256=k52ncZCUFZsBcYB7IcTOZE04uY2x5VCXvrmuLBaXsIA,2772
+typica/response.py,sha256=oI0bZ7QDgAnj6tsxEQyhv3TuGw3S-k8tFZM-Wx4Nfqk,9671
+typica/utils/__init__.py,sha256=4tXromir9E7pWB4ilY-ZicQkfii_xQEM17KrqCUWS1M,21
+typica/utils/enums.py,sha256=XD9FWwLjg1XHkWhpMeeBw9qG20uEQjyvPKATylyFG24,2527
+module_typica-0.2.2.dist-info/METADATA,sha256=zxfnVoQm-n1EOgE9wreEWzqt_qRvSD246eOEb5BD1EI,1568
+module_typica-0.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+module_typica-0.2.2.dist-info/RECORD,,

module_typica-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

typica/__init__.py

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

typica/base.py

@@ -0,0 +1,65 @@
+import uuid
+
+from typing import Optional
+from datetime import datetime
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class StringIdentifier(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()), description="Identifier of data with string uuidv4", examples=['f82192c2460965cd0a9ce68305c1969a4'])
+
+
+class StringIdentifier_(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()), alias='_id', description="Identifier of data with string uuidv4", examples=['f82192c2460965cd0a9ce68305c1969a4'])
+
+
+class UUIDIdentifier(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, description="Identifier of data with UUID format", examples=['f82192c2460965cd0a9ce68305c1969a4'])
+
+    @model_validator(mode="before")
+    def validate_uuid(cls, values):
+        """
+        Validate if id is str, then convert to uuid.UUID
+        """
+        
+        if isinstance(values.get("id"), str):
+            values["id"] = uuid.UUID(values["id"])
+        return values
+
+
+class UUIDIdentifier_(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, alias='_id', description='Identifier of data with UUID format', examples=['f82192c2460965cd0a9ce68305c1969a4'])
+
+    @model_validator(mode="before")
+    def validate_uuid(cls, values):
+        """
+        Validate if _id is str, then convert to uuid.UUID
+        """
+        if isinstance(values.get("_id"), str):
+            values["_id"] = uuid.UUID(values["_id"])
+        return values
+    
+
+class CreationMeta(BaseModel):
+    created_at: Optional[datetime] = Field(
+        default_factory=datetime.now, description="When data was created", examples=['2022-08-08T00:00:00.000000+00:00', 1661416000, 1661416000000]
+    )
+    created_by: Optional[str] = Field(None, description="Whos created the data")
+
+    @model_validator(mode="before")
+    def validate_created_at(cls, values):
+        """
+        Validate if created_at is str, then convert to datetime
+        If created_at is int, then convert to datetime using fromtimestamp
+        If created_at is int and length is more than 10, then divide by 1000 first
+        """
+        if isinstance(values.get("created_at"), str):
+            values["created_at"] = datetime.fromisoformat(values["created_at"])
+        if isinstance(values.get("created_at"), int):
+            if str(values["created_at"]).__len__() <= 10:
+                values["created_at"] = datetime.fromtimestamp(values["created_at"])
+            else:
+                values["created_at"] = datetime.fromtimestamp(int(values["created_at"] / 1000))
+        return values
+    

typica/connection.py

@@ -0,0 +1,137 @@
+import re
+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")
+
+
+class URIConnectionMeta(BaseModel):
+    uri: Optional[str] = Field("", description="Database connection URI")
+
+
+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.
+
+        :param base: The base of the URI (e.g. "http", "postgresql", etc.).
+        :param with_db: Whether to include the database name in the URI.
+        :return: A string representing the URI.
+        """
+        if self.host:
+            meta = f"{self.host}:{self.port}"
+            if self.username:
+                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):
+        if self.uri:
+            uri = re.sub(r"\w+:(//|/)", "", self.uri)
+            metadata, others = (
+                re.split(r"\/\?|\/", uri) if re.search(r"\/\?|\/", uri) else [uri, None]
+            )
+            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:
+                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)
+        return self
+
+class ClusterConnectionMeta(AuthMeta, URIConnectionMeta):
+    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:
+        """
+        Return a URI string for the database connection.
+
+        :param base: The base of the URI (e.g. "http", "postgresql", etc.).
+        :param with_db: Whether to include the database name in the URI.
+        :return: A string representing the URI.
+        """
+        if self.cluster_uri:
+            meta = ",".join([f"{c.host}:{c.port}" for c in self.cluster_uri])
+            if self.username:
+                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):
+        if self.uri:
+            uri = re.sub(r"\w+:(//|/)", "", self.uri)
+            metadata, others = (
+                re.split(r"\/\?|\/", uri) if re.search(r"\/\?|\/", uri) else [uri, None]
+            )
+            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)
+        return self
+
+
+class S3ConnectionMeta(EndpointMeta):
+    access_key: Optional[str] = Field(None, description="S3 access key")
+    secret_key: Optional[str] = Field(None, description="S3 secret key")
+    bucket: str = Field(..., description="S3 bucket name")
+    base_path: Optional[str] = Field("/", description="S3 base path")
+
+
+    @property
+    def json_meta(self) -> dict:
+        """
+        Return a dictionary of metadata for connecting to S3.
+
+        :return: A dictionary with the endpoint_url, access_key, and secret_key.
+        """
+        return {
+            "endpoint_url": f"http://{self.host}:{self.port}",
+            "key": self.access_key,
+            "secret": self.secret_key,
+        }

typica/metadata.py

@@ -0,0 +1,74 @@
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from .utils import MedallionTypes, LocationLevel
+from .connection import DBConnectionMeta, S3ConnectionMeta, ClusterConnectionMeta
+
+
+class SchemaMeta(BaseModel):
+    field_name: str
+    field_type: str
+    field_alias: Optional[str] = Field(None, description="Alias name field")
+    field_alias_type: Optional[str] = Field(None, description="Alias type field")
+    field_required: Optional[bool] = Field(False, description="Required field")
+    field_hide: Optional[bool] = Field(False, description="Hide field")
+
+
+class SimplifieMetadata(BaseModel):
+    id: str = Field(..., description="Identifier for the metadata")
+
+    # ? basic
+    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")
+    range_data: str = Field(..., description="Range of data, eg. 2021-2022")
+    description: Optional[str] = Field(None)
+
+    # ? Category
+    category: str = Field(..., description="Category of the metadata")
+    sub_category: Optional[str] = Field(None)
+
+    # ? Schemas
+    schemas: list[SchemaMeta] = Field(..., description="Description of all fields in data")
+
+    # ? Database
+    database_access: DBConnectionMeta | ClusterConnectionMeta
+    table_name: str = Field(..., description="Table name in database")
+
+
+class FullMetadata(SimplifieMetadata):
+    # ? Basic
+    sub_title: Optional[str] = Field(None)
+
+    # ? Detail data from source
+    # * Use case: bronze
+    source_desc: Optional[str] = Field(
+        None, description="Description from the source of data"
+    )
+    source_link: Optional[str] = Field(None, description="Link to the source of data")
+
+    # ? Medalion & Inheritance data
+    # * Use case: silver, gold
+    parents_id: Optional[list[str]] = Field([])
+    medalion_type: MedallionTypes = Field(
+        ..., description="Medalion type, e.g. BRONZE, SILVER, GOLD"
+    )
+    joined_by: Optional[str] = Field(None)
+
+    # ? Locational
+    # * Use case: if the table is a location table
+    location_level: Optional[LocationLevel] = Field(None)
+    location_field: Optional[str] = Field(None)
+
+    # ? Data lake
+    # * Use case: bronze
+    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")
+

typica/response.py

@@ -0,0 +1,294 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, create_model
+
+
+class BaseResponseMeta(BaseModel):
+    code: int
+    message: str
+
+class PaginationResponseMeta(BaseResponseMeta):
+    page: Optional[int] = Field(1, gt=0)
+    size: Optional[int] = Field(10, ge=0)
+    total: Optional[int] = Field(10, ge=0)
+
+
+class ServiceResponse:
+
+    def __init__(self, model: Any, auth: bool = False) -> None:
+        self.model = model
+        self.auth = auth
+
+    def basic(self, route: str) -> dict:
+        """
+        Generate a basic response, which is a dictionary of common response codes and models.
+
+        Contains:
+        - 400 Bad Request
+        - 500 Internal Server Error
+
+        :param route: The path of the route
+        :return: A dictionary of common response codes and models
+        """
+        return {
+            400: {
+                "model": create_model(
+                    route, code=(int, 400), 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),
+                    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:
+        """
+        Generate a response for a get request, which is a dictionary of common response codes and models.
+
+        Contains:
+        - 200 Success
+        - 404 Not Found
+
+        :param route: The path of the route
+        :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 = {
+            200: {
+                "model": create_model(
+                    route,
+                    code=(int, 200),
+                    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")
+                ),
+            },
+            **self.basic(route),
+            **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")
+                )
+            }
+        
+        return response
+
+
+
+    def pagination(self, route: 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.
+
+        Contains:
+        - 200 OK
+        - 404 Not Found
+        - 401 Unauthorized (optional)
+
+        :param route: The path of the route
+        :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
+        :param exclude_codes: A list of codes to exclude from the response
+        :return: A dictionary of common response codes and models
+        """
+        response: dict = {
+            200: {
+                "model": create_model(
+                    route,
+                    code=(int, 200),
+                    message=(str, f"Success get all {obj}"),
+                    data=(model if model else self.model, ...),
+                    page=(int, 1),
+                    size=(int, 10),
+                    total=(int, 10),
+                ),
+            },
+            404: {
+                "model": create_model(
+                    route, code=(int, 404), message=(str, f"{obj} not found")
+                ),
+            },
+            **self.basic(route),
+            **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")
+                )
+            }
+        
+        return response
+
+    def creation(self, route: 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.
+
+        Contains:
+        - 201 Created
+        - 401 Unauthorized
+
+        :param route: The path of the route
+        :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 =  {
+            201: {
+                "model": create_model(
+                    route,
+                    code=(int, 201),
+                    message=(str, f"{obj} created successfully"),
+                    data=(model if model else self.model, ...),
+                ),
+            },
+            **self.basic(route),
+            **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")
+                )
+            }
+        
+        return response
+
+    def update(self, route: 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 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 =  {
+            200: {
+                "model": create_model(
+                    route,
+                    code=(int, 200),
+                    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
+        }
+
+        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")
+                )
+            }
+        
+        return response
+
+    def delete(self, route: 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 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 =  {
+            200: {
+                "model": create_model(
+                    route,
+                    code=(int, 200),
+                    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
+        }
+
+        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")
+                )
+            }
+        
+        return response
+    

typica/utils/__init__.py

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

typica/utils/enums.py

@@ -0,0 +1,80 @@
+from enum import Enum
+
+
+class EnumV2(Enum):
+    @classmethod
+    def list(cls):
+        """
+        Return a list of all Enum values.
+
+        :return: A list of all Enum values.
+        """
+        return list(map(lambda c: c.value, cls))
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Create a new instance of the Enum.
+
+        :param args: The first argument will be used as the value for the Enum.
+        :param kwargs: The description keyword argument can be used to set a description for the Enum.
+        :return: The new Enum instance.
+        """
+        obj = object.__new__(cls)
+        obj._value_ = args[0]
+        return obj
+
+    def __init__(self, value, description: str | None = None):
+        """
+        Initialize an EnumV2 instance.
+
+        :param value: The value of the Enum.
+        :param description: The description of the Enum.
+        """
+        self._value_ = value
+        self._description_ = description
+
+    @property
+    def description(self):
+        """
+        Get the description of the Enum value.
+
+        :return: The description associated with the Enum value.
+        """
+        return self._description_
+
+class Operator(EnumV2):
+    equal = ("eq", "value is equals to")
+    unequal = ("ne", "value isn't equals to")
+    regex = ("re", "regex match")
+    gte = ("gte", "value is greater equals to")
+    gt = ("gt", "value is greater to")
+    lte = ("lte", "value is lower equals to")
+    lt = ("lt", "value is lower to")
+    include = ("in", "values that must exist")
+    exclude = ("nin", "values that don't exist")
+    exist = ("exist", "value is exist")
+    not_exist = ("exist", "value is exist")
+
+
+class FilterOption(EnumV2):
+    must = ("must", "List of filter must exact")
+    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):
+    CONTINENT = ("continent", "Continent level data")
+    COUNTRY = ("country", "Country level data")
+    PROVINCE = ("province", "Province level data")
+    CITY = ("city", "City level data")
+    DISTRICT = ("district", "District level data")
+    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')