apexdevkit 0.2.1__py3-none-any.whl

apexdevkit/annotation/__init__.py

@@ -0,0 +1,3 @@
+from apexdevkit.annotation.deprecate import deprecated
+
+__all__ = ["deprecated"]

apexdevkit/annotation/deprecate.py

@@ -0,0 +1,48 @@
+import inspect
+from typing import Any, Callable, TypeVar, cast
+from warnings import warn
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def deprecated(warning: str) -> Callable[[F], F]:
+    """Marks a function, method, or class as deprecated.
+
+    Do not use this annotation inside dataclass annotation.
+    Use it in this order instead:
+
+    @deprecated("Replace this class with NewClass")
+    @dataclass\n
+    class OldClass:
+
+    Do not use this annotation around generic classes. For
+    example:
+
+    class GenericClass(Generic[T])"""
+
+    def decorator(obj: F) -> F:
+        if inspect.isfunction(obj) or inspect.ismethod(obj):
+            return cast(F, _wrap_function(obj, warning))
+        elif inspect.isclass(obj):
+            return cast(F, _deprecate_class(obj, warning))
+        else:
+            raise TypeError(f"Unsupported type for deprecation: {type(obj)}")
+
+    return decorator
+
+
+def _wrap_function(func: F, warning: str) -> F:
+    def wrapper(*args: Any, **kwargs: dict[str, Any]) -> Any:
+        warn(warning, category=DeprecationWarning, stacklevel=2)
+        return func(*args, **kwargs)
+
+    return cast(F, wrapper)
+
+
+def _deprecate_class(cls: type, warning: str) -> type:
+    class DeprecatedClass(cls):  # type: ignore
+        def __init__(self, *args: Any, **kwargs: dict[str, Any]) -> None:
+            warn(warning, category=DeprecationWarning, stacklevel=2)
+            super().__init__(*args, **kwargs)
+
+    return cast(type, DeprecatedClass)

apexdevkit/error.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Self
+
+Criteria = Callable[[Any], str]
+
+
+class UnknownItem:
+    @property
+    def id(self) -> str:
+        return "unknown"
+
+
+@dataclass
+class ExistsError(Exception):
+    item: Any = field(default_factory=UnknownItem)
+
+    _duplicates: list[Criteria] = field(init=False, default_factory=list)
+
+    @property
+    def id(self) -> Any:
+        return self.item.id
+
+    def with_duplicate(self, criteria: Criteria) -> Self:
+        self._duplicates.append(criteria)
+
+        return self
+
+    def __str__(self) -> str:
+        return ",".join([f"{criteria(self.item)}" for criteria in self._duplicates])
+
+    def fire(self) -> None:
+        if self._duplicates:
+            raise self
+
+
+@dataclass
+class DoesNotExistError(Exception):
+    id: Any = "unknown"

apexdevkit/fastapi/__init__.py

@@ -0,0 +1,26 @@
+from apexdevkit.fastapi.builder import FastApiBuilder
+from apexdevkit.fastapi.dependable import inject
+from apexdevkit.fastapi.docs import NoData, Response
+from apexdevkit.fastapi.response import (
+    BadRequest,
+    ErrorResponse,
+    ResourceCreated,
+    ResourceExists,
+    ResourceFound,
+    ResourceNotFound,
+    SuccessResponse,
+)
+
+__all__ = [
+    "FastApiBuilder",
+    "inject",
+    "NoData",
+    "Response",
+    "SuccessResponse",
+    "ResourceCreated",
+    "ResourceFound",
+    "ResourceExists",
+    "ResourceNotFound",
+    "ErrorResponse",
+    "BadRequest",
+]

apexdevkit/fastapi/builder.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+from typing import Any, Self
+
+from fastapi import APIRouter, FastAPI
+
+
+@dataclass
+class FastApiBuilder:
+    app: FastAPI = field(default_factory=FastAPI)
+
+    def build(self) -> FastAPI:
+        return self.app
+
+    def with_title(self, value: str) -> Self:
+        self.app.title = value
+
+        return self
+
+    def with_description(self, value: str) -> Self:
+        self.app.description = value
+
+        return self
+
+    def with_version(self, value: str) -> Self:
+        self.app.version = value
+
+        return self
+
+    def with_dependency(self, **values: Any) -> Self:
+        for key, value in values.items():
+            setattr(self.app.state, key, value)
+
+        return self
+
+    def with_route(self, **values: APIRouter) -> Self:
+        for key, value in values.items():
+            self.app.include_router(value, prefix=f"/{key}", tags=[key.title()])
+
+        return self

apexdevkit/fastapi/dependable.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+from fastapi import Depends
+from fastapi.requests import Request
+
+
+def inject(dependency: str) -> Any:
+    def get(request: Request) -> Any:
+        return getattr(request.app.state, dependency)
+
+    return Depends(get)

apexdevkit/fastapi/docs.py

@@ -0,0 +1,15 @@
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+PayloadT = TypeVar("PayloadT")
+
+
+class Response(BaseModel, Generic[PayloadT]):
+    status: str
+    code: int
+    data: PayloadT
+
+
+class NoData(BaseModel):
+    pass

apexdevkit/fastapi/response.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import status
+from fastapi.responses import JSONResponse
+
+
+class SuccessResponse(dict[str, Any]):
+    def __init__(self, status_code: int, **kwargs: Any):
+        super().__init__(
+            {
+                "status": "success",
+                "code": status_code,
+                "data": {**kwargs},
+            }
+        )
+
+
+class ResourceFound(SuccessResponse):
+    def __init__(self, **kwargs: Any):
+        super().__init__(status_code=status.HTTP_200_OK, **kwargs)
+
+
+class ResourceCreated(SuccessResponse):
+    def __init__(self, **kwargs: Any):
+        super().__init__(status_code=status.HTTP_201_CREATED, **kwargs)
+
+
+class ErrorResponse(JSONResponse):
+    def __init__(self, status_code: int, message: str, **kwargs: Any):
+        content = {
+            "status": "fail",
+            "code": status_code,
+            "error": {"message": message},
+        }
+
+        if kwargs:
+            content["data"] = {**kwargs}
+
+        super().__init__(status_code=status_code, content=content)
+
+
+class BadRequest(ErrorResponse):
+    def __init__(self, message: str, **kwargs: Any) -> None:
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            message=message,
+            **kwargs,
+        )
+
+
+class ResourceNotFound(ErrorResponse):
+    def __init__(self, message: str):
+        super().__init__(status_code=status.HTTP_404_NOT_FOUND, message=message)
+
+
+class ResourceExists(ErrorResponse):
+    def __init__(self, message: str, **kwargs: Any):
+        super().__init__(
+            status_code=status.HTTP_409_CONFLICT,
+            message=message,
+            **kwargs,
+        )

apexdevkit/http/__init__.py

@@ -0,0 +1,18 @@
+from .fake import FakeHttp
+from .fluent import FluentHttp, FluentHttpRequest, FluentHttpResponse, Http, HttpMethod
+from .httpx import Httpx, HttpxConfig
+from .json import JsonDict
+from .url import HttpUrl
+
+__all__ = [
+    "FakeHttp",
+    "FluentHttp",
+    "FluentHttpRequest",
+    "FluentHttpResponse",
+    "Http",
+    "HttpMethod",
+    "Httpx",
+    "HttpxConfig",
+    "JsonDict",
+    "HttpUrl",
+]

apexdevkit/http/fake.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Self
+
+from apexdevkit.http.fluent import HttpMethod, HttpResponse
+from apexdevkit.http.json import JsonDict
+
+
+@dataclass
+class FakeResponse:
+    content: Any = field(default_factory=dict)
+    status_code: int = 200
+
+    def raw(self) -> Any:
+        return self.content
+
+    def code(self) -> int:
+        return self.status_code
+
+    def json(self) -> Any:
+        return JsonDict(self.content)
+
+    @classmethod
+    def bad_request(cls) -> FakeResponse:
+        return FakeResponse(status_code=400)
+
+    @classmethod
+    def conflict(cls) -> FakeResponse:
+        return FakeResponse(status_code=409)
+
+    @classmethod
+    def fail(cls) -> FakeResponse:
+        return FakeResponse(status_code=500)
+
+    @classmethod
+    def not_found(cls) -> FakeResponse:
+        return FakeResponse(status_code=404)
+
+
+@dataclass
+class FakeHttp:
+    response: FakeResponse = field(default_factory=FakeResponse)
+
+    headers: dict[str, str] = field(default_factory=dict)
+    params: dict[str, str] = field(default_factory=dict)
+    json: JsonDict = field(default_factory=JsonDict)
+
+    _request: InterceptedRequest = field(init=False)
+
+    def with_header(self, key: str, value: str) -> Self:
+        self.headers[key] = value
+
+        return self
+
+    def with_param(self, key: str, value: str) -> Self:
+        self.params[key] = value
+
+        return self
+
+    def with_json(self, value: JsonDict) -> Self:
+        self.json = value
+
+        return self
+
+    def request(self, method: HttpMethod, endpoint: str) -> HttpResponse:
+        self._request = InterceptedRequest(method, endpoint)
+
+        return self.response
+
+    def intercepted(self, method: HttpMethod) -> InterceptedRequest:
+        assert self._request.method == method
+
+        return self._request
+
+
+@dataclass
+class InterceptedRequest:
+    method: HttpMethod
+    endpoint: str
+
+    def on_endpoint(self, value: str) -> None:
+        assert self.endpoint == value

apexdevkit/http/fluent.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any, Protocol, Type
+
+from apexdevkit.http.json import JsonDict
+
+
+class Http(Protocol):  # pragma: no cover
+    def with_header(self, key: str, value: str) -> Http:
+        pass
+
+    def with_param(self, key: str, value: str) -> Http:
+        pass
+
+    def with_json(self, value: JsonDict) -> Http:
+        pass
+
+    def request(self, method: HttpMethod, endpoint: str) -> HttpResponse:
+        pass
+
+
+class HttpMethod(Enum):
+    post = auto()
+    get = auto()
+    patch = auto()
+    delete = auto()
+
+
+class HttpResponse(Protocol):  # pragma: no cover
+    def code(self) -> int:
+        pass
+
+    def raw(self) -> Any:
+        pass
+
+    def json(self) -> JsonDict:
+        pass
+
+
+@dataclass(frozen=True)
+class FluentHttp:
+    http: Http
+
+    def and_header(self, key: str, value: str) -> FluentHttp:
+        return self.with_header(key, value)
+
+    def with_header(self, key: str, value: str) -> FluentHttp:
+        return FluentHttp(self.http.with_header(key, value))
+
+    def and_param(self, key: str, value: str) -> FluentHttp:
+        return self.with_param(key, value)
+
+    def with_param(self, key: str, value: str) -> FluentHttp:
+        return FluentHttp(self.http.with_param(key, value))
+
+    def and_json(self, value: JsonDict) -> FluentHttp:
+        return self.with_json(value)
+
+    def with_json(self, value: JsonDict) -> FluentHttp:
+        return FluentHttp(self.http.with_json(value))
+
+    def post(self) -> FluentHttpRequest:
+        return FluentHttpRequest(HttpMethod.post, self.http)
+
+    def get(self) -> FluentHttpRequest:
+        return FluentHttpRequest(HttpMethod.get, self.http)
+
+    def patch(self) -> FluentHttpRequest:
+        return FluentHttpRequest(HttpMethod.patch, self.http)
+
+    def delete(self) -> FluentHttpRequest:
+        return FluentHttpRequest(HttpMethod.delete, self.http)
+
+
+@dataclass(frozen=True)
+class FluentHttpRequest:
+    method: HttpMethod
+    http: Http
+
+    def on_endpoint(self, value: str) -> FluentHttpResponse:
+        return FluentHttpResponse(self.http.request(self.method, value))
+
+
+@dataclass(frozen=True)
+class FluentHttpResponse:
+    response: HttpResponse
+
+    def on_bad_request(self, raises: Exception | Type[Exception]) -> FluentHttpResponse:
+        if self.response.code() == 400:
+            raise raises
+
+        return self
+
+    def on_conflict(self, raises: Exception | Type[Exception]) -> FluentHttpResponse:
+        if self.response.code() == 409:
+            raise raises
+
+        return self
+
+    def on_not_found(self, raises: Exception | Type[Exception]) -> FluentHttpResponse:
+        if self.response.code() == 404:
+            raise raises
+
+        return self
+
+    def on_failure(self, raises: Type[Exception]) -> FluentHttpResponse:
+        if self.response.code() < 200 or self.response.code() > 299:
+            raise raises(self.response.raw(), self.response.code())
+
+        return self
+
+    def json(self) -> JsonDict:
+        return self.response.json()

apexdevkit/http/httpx.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterator, Mapping, Self
+
+import httpx
+
+from apexdevkit.http.fluent import HttpMethod, HttpResponse
+from apexdevkit.http.json import JsonDict
+from apexdevkit.http.url import HttpUrl
+
+
+@dataclass(frozen=True)
+class Httpx:
+    url: HttpUrl
+    config: HttpxConfig
+
+    @classmethod
+    def create_for(cls, url: str) -> Self:
+        return cls(HttpUrl(url), HttpxConfig())
+
+    def with_header(self, key: str, value: str) -> Httpx:
+        return Httpx(self.url, self.config.with_header(key, value))
+
+    def with_param(self, key: str, value: str) -> Httpx:
+        return Httpx(self.url, self.config.with_param(key, value))
+
+    def with_json(self, value: JsonDict) -> Httpx:
+        return Httpx(self.url, self.config.with_json(value))
+
+    def request(self, method: HttpMethod, endpoint: str) -> HttpResponse:
+        return _HttpxResponse(
+            httpx.request(method.name, self.url + endpoint, **self.config)
+        )
+
+
+@dataclass
+class _HttpxResponse:
+    inner: httpx.Response
+
+    def code(self) -> int:
+        return self.inner.status_code
+
+    def raw(self) -> bytes:
+        return self.inner.content
+
+    def json(self) -> JsonDict:
+        return JsonDict(self.inner.json())
+
+
+@dataclass(frozen=True)
+class HttpxConfig(Mapping[str, Any]):
+    timeout_s: int = 30
+    headers: JsonDict = field(default_factory=JsonDict)
+    params: JsonDict = field(default_factory=JsonDict)
+    json: JsonDict = field(default_factory=JsonDict)
+
+    def with_header(self, key: str, value: str) -> HttpxConfig:
+        return HttpxConfig(
+            timeout_s=self.timeout_s,
+            headers=self.headers.merge(JsonDict({key: value})),
+            params=self.params,
+            json=self.json,
+        )
+
+    def with_param(self, key: str, value: str) -> HttpxConfig:
+        return HttpxConfig(
+            timeout_s=self.timeout_s,
+            headers=self.headers,
+            params=self.params.merge(JsonDict({key: value})),
+            json=self.json,
+        )
+
+    def with_json(self, value: JsonDict) -> HttpxConfig:
+        return HttpxConfig(
+            timeout_s=self.timeout_s,
+            headers=self.headers,
+            params=self.params,
+            json=value,
+        )
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "timeout": self.timeout_s,
+            "headers": dict(self.headers),
+            "params": dict(self.params),
+            "json": dict(self.json),
+        }
+
+    def __len__(self) -> int:
+        return len(self.as_dict())
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.as_dict())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.as_dict().__getitem__(key)

apexdevkit/http/json.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, TypeVar
+
+
+class JsonDict(dict[str, Any]):
+    def value_of(self, key: str) -> FluentElement:
+        return FluentElement(self[key])
+
+    def and_a(self, **fields: Any) -> JsonDict:
+        return self.with_a(**fields)
+
+    def with_a(self, **fields: Any) -> JsonDict:
+        return self.merge(JsonDict(fields))
+
+    def merge(self, other: JsonDict) -> JsonDict:
+        return JsonDict({**self, **other})
+
+    def drop(self, *keys: str) -> JsonDict:
+        return self.select(*set(self.keys()).difference(keys))
+
+    def select(self, *keys: str) -> JsonDict:
+        return JsonDict({k: v for k, v in self.items() if k in keys})
+
+
+@dataclass
+class FluentElement:
+    value: Any
+
+    def to(self, a_type: Callable[[Any], ConvertedT]) -> ConvertedT:
+        return a_type(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+ConvertedT = TypeVar("ConvertedT")

apexdevkit/http/url.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class HttpUrl:
+    value: str
+
+    def __add__(self, endpoint: str) -> str:
+        return self.value.strip("/") + "/" + endpoint.strip("/")

apexdevkit/repository/__init__.py

@@ -0,0 +1,17 @@
+from apexdevkit.repository.database import (
+    Connection,
+    Connector,
+    Cursor,
+    Database,
+    DatabaseCommand,
+)
+from apexdevkit.repository.in_memory import InMemoryRepository
+
+__all__ = [
+    "Connection",
+    "Connector",
+    "Cursor",
+    "Database",
+    "DatabaseCommand",
+    "InMemoryRepository",
+]

apexdevkit/repository/connector.py

@@ -0,0 +1,32 @@
+import sqlite3
+from dataclasses import dataclass
+from functools import cached_property
+from typing import ContextManager
+
+from apexdevkit.repository import Connection
+
+
+@dataclass
+class SqliteFileConnector:
+    dsn: str
+
+    def connect(self) -> ContextManager[Connection]:
+        connection = sqlite3.connect(self.dsn)
+        connection.row_factory = sqlite3.Row
+
+        return connection
+
+
+@dataclass
+class SqliteInMemoryConnector:
+    dsn: str = ":memory:"
+
+    def connect(self) -> ContextManager[Connection]:
+        return self._connection
+
+    @cached_property
+    def _connection(self) -> ContextManager[Connection]:
+        connection = sqlite3.connect(self.dsn, check_same_thread=False)
+        connection.row_factory = sqlite3.Row
+
+        return connection