restiny 0.2.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

restiny/data/repos.py

@@ -0,0 +1,351 @@
+import json
+import sys
+import traceback
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import UTC
+from enum import StrEnum
+from functools import wraps
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError, InterfaceError, OperationalError
+
+from restiny.data.db import DBManager
+from restiny.data.models import SQLFolder, SQLRequest, SQLSettings
+from restiny.entities import Folder, Request, Settings
+
+
+def safe_repo(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+
+        except (
+            InterfaceError,
+            OperationalError,
+        ):
+            traceback.print_exc(file=sys.stderr)
+            return RepoResp(status=RepoStatus.DB_ERROR)
+
+        except IntegrityError as error:
+            error_msg = str(error)
+            if 'UNIQUE' in str(error_msg):
+                return RepoResp(status=RepoStatus.DUPLICATED)
+
+            traceback.print_exc(file=sys.stderr)
+            return RepoResp(status=RepoStatus.DB_ERROR)
+
+    return wrapper
+
+
+class RepoStatus(StrEnum):
+    OK = 'ok'
+    NOT_FOUND = 'not_found'
+    DUPLICATED = 'duplicated'
+    DB_ERROR = 'db_error'
+
+
+@dataclass
+class RepoResp:
+    status: RepoStatus = RepoStatus.OK
+    data: Any = None
+
+    @property
+    def ok(self) -> bool:
+        return self.status == RepoStatus.OK
+
+
+class SQLRepoBase(ABC):
+    def __init__(self, db_manager: DBManager):
+        self.db_manager = db_manager
+
+    @property
+    @abstractmethod
+    def _updatable_sql_fields(self) -> list[str]:
+        pass
+
+
+class FoldersSQLRepo(SQLRepoBase):
+    @property
+    def _updatable_sql_fields(self) -> list[str]:
+        return [SQLFolder.parent_id.key, SQLFolder.name.key]
+
+    @safe_repo
+    def list_by_parent_id(self, parent_id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folders = session.scalars(
+                select(SQLFolder)
+                .where(SQLFolder.parent_id == parent_id)
+                .order_by(SQLFolder.name.asc())
+            ).all()
+            folders = [
+                self._sql_to_folder(sql_folder) for sql_folder in sql_folders
+            ]
+            return RepoResp(data=folders)
+
+    @safe_repo
+    def list_roots(self) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folders = session.scalars(
+                select(SQLFolder)
+                .where(SQLFolder.parent_id.is_(None))
+                .order_by(SQLFolder.name.asc())
+            ).all()
+            folders = [
+                self._sql_to_folder(sql_folder) for sql_folder in sql_folders
+            ]
+            return RepoResp(data=folders)
+
+    @safe_repo
+    def get_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folder = session.get(SQLFolder, id)
+            if not sql_folder:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            folder = self._sql_to_folder(sql_folder)
+            return RepoResp(data=folder)
+
+    @safe_repo
+    def create(self, folder: Folder) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folder = self._folder_to_sql(folder)
+            session.add(sql_folder)
+            session.flush()
+            new_folder = self._sql_to_folder(sql_folder)
+            return RepoResp(data=new_folder)
+
+    @safe_repo
+    def update(self, folder: Folder) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folder = session.get(SQLFolder, folder.id)
+            if not sql_folder:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            new_data = self._folder_to_sql(folder)
+            for field in self._updatable_sql_fields:
+                setattr(sql_folder, field, getattr(new_data, field))
+
+            session.flush()
+
+            new_folder = self._sql_to_folder(sql_folder)
+            return RepoResp(data=new_folder)
+
+    @safe_repo
+    def delete_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_folder = session.get(SQLFolder, id)
+            if not sql_folder:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            session.delete(sql_folder)
+            return RepoResp()
+
+    def _sql_to_folder(self, sql_folder: SQLFolder) -> Folder:
+        return Folder(
+            id=sql_folder.id,
+            parent_id=sql_folder.parent_id,
+            name=sql_folder.name,
+            created_at=sql_folder.created_at.replace(tzinfo=UTC),
+            updated_at=sql_folder.updated_at.replace(tzinfo=UTC),
+        )
+
+    def _folder_to_sql(self, folder: Folder) -> SQLFolder:
+        return SQLFolder(
+            id=folder.id,
+            parent_id=folder.parent_id,
+            name=folder.name,
+            created_at=folder.created_at,
+            updated_at=folder.updated_at,
+        )
+
+
+class RequestsSQLRepo(SQLRepoBase):
+    @safe_repo
+    def list_by_folder_id(self, folder_id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_requests = session.scalars(
+                select(SQLRequest)
+                .where(SQLRequest.folder_id == folder_id)
+                .order_by(SQLRequest.name.asc())
+            ).all()
+            requests = [
+                self._sql_to_request(sql_folder) for sql_folder in sql_requests
+            ]
+            return RepoResp(data=requests)
+
+    @safe_repo
+    def get_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_request = session.get(SQLRequest, id)
+
+            if not sql_request:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            request = self._sql_to_request(sql_request)
+            return RepoResp(data=request)
+
+    @safe_repo
+    def create(self, request: Request) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_request = self._request_to_sql(request)
+            session.add(sql_request)
+            session.flush()
+            new_request = self._sql_to_request(sql_request)
+            return RepoResp(data=new_request)
+
+    @safe_repo
+    def update(self, request: Request) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_request = session.get(SQLRequest, request.id)
+            if not sql_request:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            new_data = self._request_to_sql(request)
+            for field in self._updatable_sql_fields:
+                setattr(sql_request, field, getattr(new_data, field))
+
+            session.flush()
+
+            new_request = self._sql_to_request(sql_request)
+            return RepoResp(data=new_request)
+
+    @safe_repo
+    def delete_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_request = session.get(SQLRequest, id)
+            if not sql_request:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            session.delete(sql_request)
+            return RepoResp()
+
+    @property
+    def _updatable_sql_fields(self) -> list[str]:
+        return [
+            SQLRequest.folder_id.key,
+            SQLRequest.name.key,
+            SQLRequest.method.key,
+            SQLRequest.url.key,
+            SQLRequest.headers.key,
+            SQLRequest.params.key,
+            SQLRequest.body_enabled.key,
+            SQLRequest.body_mode.key,
+            SQLRequest.body.key,
+            SQLRequest.auth_enabled.key,
+            SQLRequest.auth_mode.key,
+            SQLRequest.auth.key,
+            SQLRequest.option_timeout.key,
+            SQLRequest.option_follow_redirects.key,
+            SQLRequest.option_verify_ssl.key,
+        ]
+
+    def _sql_to_request(self, sql_request: SQLRequest) -> Request:
+        return Request(
+            id=sql_request.id,
+            folder_id=sql_request.folder_id,
+            name=sql_request.name,
+            method=sql_request.method,
+            url=sql_request.url,
+            headers=json.loads(sql_request.headers),
+            params=json.loads(sql_request.params),
+            body_enabled=sql_request.body_enabled,
+            body_mode=sql_request.body_mode,
+            body=json.loads(sql_request.body) if sql_request.body else None,
+            auth_enabled=sql_request.auth_enabled,
+            auth_mode=sql_request.auth_mode,
+            auth=json.loads(sql_request.auth) if sql_request.auth else None,
+            options=Request.Options(
+                timeout=sql_request.option_timeout,
+                follow_redirects=sql_request.option_follow_redirects,
+                verify_ssl=sql_request.option_verify_ssl,
+            ),
+            created_at=sql_request.created_at.replace(tzinfo=UTC),
+            updated_at=sql_request.updated_at.replace(tzinfo=UTC),
+        )
+
+    def _request_to_sql(self, request: Request) -> SQLRequest:
+        return SQLRequest(
+            id=request.id,
+            folder_id=request.folder_id,
+            name=request.name,
+            method=request.method,
+            url=request.url,
+            headers=json.dumps(
+                [header.model_dump() for header in request.headers]
+            ),
+            params=json.dumps(
+                [param.model_dump() for param in request.params]
+            ),
+            body_enabled=request.body_enabled,
+            body_mode=request.body_mode,
+            body=json.dumps(request.body.model_dump(), default=str)
+            if request.body
+            else None,
+            auth_enabled=request.auth_enabled,
+            auth_mode=request.auth_mode,
+            auth=json.dumps(request.auth.model_dump(), default=str)
+            if request.auth
+            else None,
+            option_timeout=request.options.timeout,
+            option_follow_redirects=request.options.follow_redirects,
+            option_verify_ssl=request.options.verify_ssl,
+            created_at=request.created_at,
+            updated_at=request.updated_at,
+        )
+
+
+class SettingsSQLRepo(SQLRepoBase):
+    @safe_repo
+    def get(self) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_settings = session.scalar(select(SQLSettings).limit(1))
+
+            if not sql_settings:
+                return RepoResp(data=Settings())
+
+            settings = self._sql_to_settings(sql_settings)
+            return RepoResp(data=settings)
+
+    @safe_repo
+    def set(self, settings: Settings) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_settings = session.scalar(select(SQLSettings).limit(1))
+
+            if not sql_settings:
+                # create
+                sql_settings = self._settings_to_sql(settings=settings)
+                session.add(sql_settings)
+                session.flush()
+                new_settings = self._sql_to_settings(sql_settings=sql_settings)
+                return RepoResp(data=new_settings)
+            else:
+                # update
+                new_data = self._settings_to_sql(settings=settings)
+                for field in self._updatable_sql_fields:
+                    setattr(sql_settings, field, getattr(new_data, field))
+                session.flush()
+                new_settings = self._sql_to_settings(sql_settings=sql_settings)
+                return RepoResp(data=new_settings)
+
+    @property
+    def _updatable_sql_fields(self) -> list[str]:
+        return [SQLSettings.theme.key]
+
+    def _sql_to_settings(self, sql_settings: SQLSettings) -> Settings:
+        return Settings(
+            id=sql_settings.id,
+            theme=sql_settings.theme,
+            created_at=sql_settings.created_at.replace(tzinfo=UTC),
+            updated_at=sql_settings.updated_at.replace(tzinfo=UTC),
+        )
+
+    def _settings_to_sql(self, settings: Settings) -> SQLSettings:
+        return SQLSettings(
+            id=settings.id,
+            theme=settings.theme,
+            created_at=settings.created_at,
+            updated_at=settings.updated_at,
+        )

restiny/data/sql/__init__.py

@@ -0,0 +1,3 @@
+from restiny.consts import MODULE_DIR
+
+SQL_DIR = MODULE_DIR.joinpath('data/sql')

restiny/entities.py

@@ -0,0 +1,320 @@
+import json
+import mimetypes
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Literal
+
+import httpx
+from pydantic import BaseModel, field_validator
+from pydantic import Field as _Field
+from pydantic_core.core_schema import ValidationInfo
+
+from restiny import httpx_auths
+from restiny.enums import (
+    AuthMode,
+    BodyMode,
+    BodyRawLanguage,
+    ContentType,
+    CustomThemes,
+    HTTPMethod,
+)
+from restiny.utils import build_curl_cmd
+
+
+class Folder(BaseModel):
+    id: int | None = None
+
+    name: str
+    parent_id: int | None = None
+
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class Request(BaseModel):
+    class Header(BaseModel):
+        enabled: bool
+        key: str
+        value: str
+
+    class Param(BaseModel):
+        enabled: bool
+        key: str
+        value: str
+
+    class RawBody(BaseModel):
+        language: BodyRawLanguage
+        value: str
+
+    class FileBody(BaseModel):
+        file: Path | None
+
+    class UrlEncodedFormBody(BaseModel):
+        class Field(BaseModel):
+            enabled: bool
+            key: str
+            value: str
+
+        fields: list[Field]
+
+    class MultipartFormBody(BaseModel):
+        class Field(BaseModel):
+            value_kind: Literal['text', 'file']
+            enabled: bool
+            key: str
+            value: str | Path | None
+
+            @field_validator('value', mode='before')
+            @classmethod
+            def validate_value(cls, value: Any, info: ValidationInfo):
+                if value is None:
+                    return None
+
+                kind = info.data.get('value_kind')
+                if kind == 'file':
+                    return Path(value)
+                elif kind == 'text':
+                    return str(value)
+
+        fields: list[Field]
+
+    class BasicAuth(BaseModel):
+        username: str
+        password: str
+
+    class BearerAuth(BaseModel):
+        token: str
+
+    class ApiKeyAuth(BaseModel):
+        key: str
+        value: str
+        where: Literal['header', 'param']
+
+    class DigestAuth(BaseModel):
+        username: str
+        password: str
+
+    class Options(BaseModel):
+        timeout: float = 5.5
+        follow_redirects: bool = True
+        verify_ssl: bool = True
+
+    id: int | None = None
+
+    folder_id: int
+    name: str
+
+    method: HTTPMethod = HTTPMethod.GET
+    url: str = ''
+    headers: list[Header] = _Field(default_factory=list)
+    params: list[Param] = _Field(default_factory=list)
+
+    body_enabled: bool = False
+    body_mode: str = BodyMode.RAW
+    body: (
+        RawBody | FileBody | UrlEncodedFormBody | MultipartFormBody | None
+    ) = None
+
+    auth_enabled: bool = False
+    auth_mode: AuthMode = AuthMode.BASIC
+    auth: BasicAuth | BearerAuth | ApiKeyAuth | DigestAuth | None = None
+
+    options: Options = _Field(default_factory=Options)
+
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    def to_httpx_req(self) -> httpx.Request:
+        headers: dict[str, str] = {
+            header.key: header.value
+            for header in self.headers
+            if header.enabled
+        }
+        params: dict[str, str] = {
+            param.key: param.value for param in self.params if param.enabled
+        }
+
+        if not self.body_enabled:
+            return httpx.Request(
+                method=self.method,
+                url=self.url,
+                headers=headers,
+                params=params,
+            )
+
+        if self.body_mode == BodyMode.RAW:
+            raw_language_to_content_type = {
+                BodyRawLanguage.JSON: ContentType.JSON,
+                BodyRawLanguage.YAML: ContentType.YAML,
+                BodyRawLanguage.HTML: ContentType.HTML,
+                BodyRawLanguage.XML: ContentType.XML,
+                BodyRawLanguage.PLAIN: ContentType.TEXT,
+            }
+            headers['content-type'] = raw_language_to_content_type.get(
+                self.body.language, ContentType.TEXT
+            )
+
+            raw = self.body.value
+            if headers['content-type'] == ContentType.JSON:
+                try:
+                    raw = json.dumps(raw)
+                except Exception:
+                    pass
+
+            return httpx.Request(
+                method=self.method,
+                url=self.url,
+                headers=headers,
+                params=params,
+                content=raw,
+            )
+        elif self.body_mode == BodyMode.FILE:
+            file = self.body.file
+            if 'content-type' not in headers:
+                headers['content-type'] = (
+                    mimetypes.guess_type(file.name)[0]
+                    or 'application/octet-stream'
+                )
+            return httpx.Request(
+                method=self.method,
+                url=self.url,
+                headers=headers,
+                params=params,
+                content=file.read_bytes(),
+            )
+        elif self.body_mode == BodyMode.FORM_URLENCODED:
+            form_urlencoded = {
+                form_item.key: form_item.value
+                for form_item in self.body.fields
+                if form_item.enabled
+            }
+            return httpx.Request(
+                method=self.method,
+                url=self.url,
+                headers=headers,
+                params=params,
+                data=form_urlencoded,
+            )
+        elif self.body_mode == BodyMode.FORM_MULTIPART:
+            form_multipart_str = {
+                form_item.key: form_item.value
+                for form_item in self.body.fields
+                if form_item.enabled and isinstance(form_item.value, str)
+            }
+            form_multipart_files = {
+                form_item.key: (
+                    form_item.value.name,
+                    form_item.value.read_bytes(),
+                    mimetypes.guess_type(form_item.value.name)[0]
+                    or 'application/octet-stream',
+                )
+                for form_item in self.body.fields
+                if form_item.enabled and isinstance(form_item.value, Path)
+            }
+            return httpx.Request(
+                method=self.method,
+                url=self.url,
+                headers=headers,
+                params=params,
+                data=form_multipart_str,
+                files=form_multipart_files,
+            )
+
+    def to_httpx_auth(self) -> httpx.Auth | None:
+        if not self.auth_enabled:
+            return
+
+        if self.auth_mode == AuthMode.BASIC:
+            return httpx.BasicAuth(
+                username=self.auth.username, password=self.auth.password
+            )
+        elif self.auth_mode == AuthMode.BEARER:
+            return httpx_auths.BearerAuth(token=self.auth.token)
+        elif self.auth_mode == AuthMode.API_KEY:
+            if self.auth.where == 'header':
+                return httpx_auths.APIKeyHeaderAuth(
+                    key=self.auth.key, value=self.auth.value
+                )
+            elif self.auth.where == 'param':
+                return httpx_auths.APIKeyParamAuth(
+                    key=self.auth.key, value=self.auth.value
+                )
+        elif self.auth_mode == AuthMode.DIGEST:
+            return httpx.DigestAuth(
+                username=self.auth.username, password=self.auth.password
+            )
+
+    def to_curl(self) -> str:
+        headers: dict[str, str] = {
+            header.key: header.value
+            for header in self.headers
+            if header.enabled
+        }
+        params: dict[str, str] = {
+            param.key: param.value for param in self.params if param.enabled
+        }
+
+        body_raw = None
+        body_form_urlencoded = None
+        body_form_multipart = None
+        body_files = None
+        if self.body_enabled:
+            if self.body_mode == BodyMode.RAW:
+                body_raw = self.body
+            elif self.body_mode == BodyMode.FORM_URLENCODED:
+                body_form_urlencoded = {
+                    form_field.key: form_field.value
+                    for form_field in self.body.fields
+                    if form_field.enabled
+                }
+            elif self.body_mode == BodyMode.FORM_MULTIPART:
+                body_form_multipart = {
+                    form_field.key: form_field.value
+                    for form_field in self.body.fields
+                    if form_field.enabled
+                }
+            elif self.body_mode == BodyMode.FILE:
+                body_files = [self.body]
+
+        auth_basic = None
+        auth_bearer = None
+        auth_api_key_header = None
+        auth_api_key_param = None
+        auth_digest = None
+        if self.auth_enabled:
+            if self.auth_mode == AuthMode.BASIC:
+                auth_basic = (self.auth.username, self.auth.password)
+            elif self.auth_mode == AuthMode.BEARER:
+                auth_bearer = self.auth.token
+            elif self.auth_mode == AuthMode.API_KEY:
+                if self.auth.where == 'header':
+                    auth_api_key_header = (self.auth.key, self.auth.value)
+                elif self.auth.where == 'param':
+                    auth_api_key_param = (self.auth.key, self.auth.value)
+            elif self.auth_mode == AuthMode.DIGEST:
+                auth_digest = (self.auth.username, self.auth.password)
+
+        return build_curl_cmd(
+            method=self.method,
+            url=self.url,
+            headers=headers,
+            params=params,
+            body_raw=body_raw,
+            body_form_urlencoded=body_form_urlencoded,
+            body_form_multipart=body_form_multipart,
+            body_files=body_files,
+            auth_basic=auth_basic,
+            auth_bearer=auth_bearer,
+            auth_api_key_header=auth_api_key_header,
+            auth_api_key_param=auth_api_key_param,
+            auth_digest=auth_digest,
+        )
+
+
+class Settings(BaseModel):
+    id: int | None = None
+
+    theme: CustomThemes = CustomThemes.DARK
+
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

restiny/enums.py

@@ -6,17 +6,13 @@ class HTTPMethod(StrEnum):
     GET = 'GET'
     POST = 'POST'
     PUT = 'PUT'
+    PATCH = 'PATCH'
     DELETE = 'DELETE'
     HEAD = 'HEAD'
     OPTIONS = 'OPTIONS'
-    PATCH = 'PATCH'
     CONNECT = 'CONNECT'
     TRACE = 'TRACE'
 
-    @classmethod
-    def values(cls):
-        return [method.value for method in cls]
-
 
 class BodyMode(StrEnum):
     RAW = 'raw'
@@ -41,3 +37,16 @@ class ContentType(StrEnum):
     XML = 'application/xml'
     FORM_URLENCODED = 'application/x-www-form-urlencoded'
     FORM_MULTIPART = 'multipart/form-data'
+
+
+class AuthMode(StrEnum):
+    BASIC = 'basic'
+    BEARER = 'bearer'
+    API_KEY = 'api_key'
+    DIGEST = 'digest'
+
+
+class CustomThemes(StrEnum):
+    DARK = 'dark'
+    DRACULA = 'dracula'
+    FOREST = 'forest'