reyserver 1.1.93__py3-none-any.whl

reyserver/rbind.py

@@ -0,0 +1,335 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2025-10-21
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Dependency bind methods.
+"""
+
+
+from typing import overload, TYPE_CHECKING
+from fastapi import FastAPI, Request, UploadFile
+from fastapi.params import (
+    Depends,
+    Path,
+    Query,
+    Header,
+    Cookie,
+    Body,
+    Form,
+    File as Forms
+)
+from reydb.rconn import DatabaseConnectionAsync
+from reydb.rorm import DatabaseORMSessionAsync
+from reykit.rbase import StaticMeta, Singleton, throw
+
+from . import rserver
+from .rbase import ServerBase, depend_pass
+
+
+__all__ = (
+    'ServerBindInstanceDatabaseSuper',
+    'ServerBindInstanceDatabaseConnection',
+    'ServerBindInstanceDatabaseSession',
+    'ServerBindInstance',
+    'ServerBind',
+    'Bind'
+)
+
+
+class ServerBindInstanceDatabaseSuper(ServerBase):
+    """
+    Server API bind parameter build database instance super type.
+    """
+
+
+    def __getattr__(self, name: str) -> Depends:
+        """
+        Create dependencie instance of asynchronous database.
+
+        Parameters
+        ----------
+        name : Database engine name.
+        mode : Mode.
+            - `Literl['sess']`: Create ORM session instance.
+            - `Literl['conn']`: Create connection instance.
+
+        Returns
+        -------
+        Dependencie instance.
+        """
+
+
+        async def depend_func(server: Bind.Server = Bind.server):
+            """
+            Dependencie function of asynchronous database.
+            """
+
+            # Check.
+            if server.db is None:
+                throw(TypeError, server.db)
+
+            # Parameter.
+            engine = server.db[name]
+
+            # Context.
+            match self:
+                case ServerBindInstanceDatabaseConnection():
+                    async with engine.connect() as conn:
+                        yield conn
+                case ServerBindInstanceDatabaseSession():
+                    async with engine.orm.session() as sess:
+                        yield sess
+
+
+        # Create.
+        depend = Depends(depend_func)
+
+        return depend
+
+
+    @overload
+    def __getitem__(self, engine: str) -> DatabaseConnectionAsync: ...
+
+    __getitem__ = __getattr__
+
+
+class ServerBindInstanceDatabaseConnection(ServerBindInstanceDatabaseSuper, Singleton):
+    """
+    Server API bind parameter build database connection instance type, singleton mode.
+    """
+
+
+class ServerBindInstanceDatabaseSession(ServerBindInstanceDatabaseSuper, Singleton):
+    """
+    Server API bind parameter build database session instance type, singleton mode.
+    """
+
+
+class ServerBindInstance(ServerBase, Singleton):
+    """
+    Server API bind parameter build instance type.
+    """
+
+
+    @property
+    def path(self) -> Path:
+        """
+        Path instance.
+        """
+
+        # Build.
+        path = Path()
+
+        return path
+
+
+    @property
+    def query(self) -> Query:
+        """
+        Query instance.
+        """
+
+        # Build.
+        query = Query()
+
+        return query
+
+
+    @property
+    def header(self) -> Header:
+        """
+        Header instance.
+        """
+
+        # Build.
+        header = Header()
+
+        return header
+
+
+    @property
+    def cookie(self) -> Cookie:
+        """
+        Cookie instance.
+        """
+
+        # Build.
+        cookie = Cookie()
+
+        return cookie
+
+
+    @property
+    def body(self) -> Body:
+        """
+        Body instance.
+        """
+
+        # Build.
+        body = Body()
+
+        return body
+
+
+    @property
+    def form(self) -> Form:
+        """
+        Form instance.
+        """
+
+        # Build.
+        form = Form()
+
+        return form
+
+
+    @property
+    def forms(self) -> Forms:
+        """
+        Forms instance.
+        """
+
+        # Build.
+        forms = Forms()
+
+        return forms
+
+
+    @property
+    def query_n(self) -> Query:
+        """
+        Query instance, default `None`.
+        """
+
+        # Build.
+        query = Query(None)
+
+        return query
+
+
+    @property
+    def header_n(self) -> Header:
+        """
+        Header instance, default `None`.
+        """
+
+        # Build.
+        header = Header(None)
+
+        return header
+
+
+    @property
+    def cookie_n(self) -> Cookie:
+        """
+        Cookie instance, default `None`.
+        """
+
+        # Build.
+        cookie = Cookie(None)
+
+        return cookie
+
+
+    @property
+    def body_n(self) -> Body:
+        """
+        Body instance, default `None`.
+        """
+
+        # Build.
+        body = Body(None)
+
+        return body
+
+
+    @property
+    def form_n(self) -> Form:
+        """
+        Form instance, default `None`.
+        """
+
+        # Build.
+        form = Form(None)
+
+        return form
+
+
+    @property
+    def forms_n(self) -> Forms:
+        """
+        Forms instance, default `None`.
+        """
+
+        # Build.
+        forms = Forms(None)
+
+        return forms
+
+
+async def depend_server(request: Request) -> 'rserver.Server':
+    """
+    Dependencie function of now Server instance.
+
+    Parameters
+    ----------
+    request : Request.
+
+    Returns
+    -------
+    Server.
+    """
+
+    # Get.
+    app: FastAPI = request.app
+    server: rserver.Server = app.extra['server']
+
+    return server
+
+
+class ServerBind(ServerBase, metaclass=StaticMeta):
+    """
+    Server API bind parameter type.
+    """
+
+    Request = Request
+    'Reqeust instance dependency type.'
+    Path = Path
+    'URL source path dependency type.'
+    Query = Query
+    'URL query parameter dependency type.'
+    Header = Header
+    'Request header parameter dependency type.'
+    Cookie = Cookie
+    'Request header cookie parameter dependency type.'
+    Body = Body
+    'Request body JSON parameter dependency type.'
+    Form = Form
+    'Request body form parameter dependency type.'
+    Forms = Forms
+    'Request body multiple forms parameter dependency type.'
+    File = UploadFile
+    'Type hints file type.'
+    Depend = Depends
+    'Dependency type.'
+    Conn = DatabaseConnectionAsync
+    Sess = DatabaseORMSessionAsync
+    if TYPE_CHECKING:
+        Server = rserver.Server
+        'Server type.'
+    server: Depend = Depend(depend_server)
+    'Server instance dependency type.'
+    i = ServerBindInstance()
+    'Server API bind parameter build instance.'
+    conn = ServerBindInstanceDatabaseConnection()
+    'Server API bind parameter asynchronous database connection.'
+    sess = ServerBindInstanceDatabaseSession()
+    'Server API bind parameter asynchronous database session.'
+    token: Depend = depend_pass
+    'Server authentication token dependency type.'
+
+
+Bind = ServerBind

reyserver/rcache.py

@@ -0,0 +1,116 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2025-10-25
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Cache methods.
+"""
+
+
+from typing import Any
+from collections.abc import Callable
+from inspect import  iscoroutinefunction
+from fastapi import Request, Response
+from fastapi_cache import FastAPICache
+from fastapi_cache.coder import PickleCoder
+from fastapi_cache.backends.redis import RedisBackend
+from fastapi_cache.decorator import cache as fastapi_cache_cache
+from redis.asyncio import Redis
+from reykit.rbase import CallableT
+from reykit.ros import get_md5
+from reykit.rre import sub
+
+
+__all__ = (
+    'init_cache',
+    'wrap_cache'
+)
+
+
+def init_cache(redis: Redis, redis_expire: int | None = None) -> None:
+    """
+    Initialize cache based on Redis.
+
+    Parameters
+    ----------
+    redis : Asynchronous Redis
+    redis_expire : Redis cache expire seconds.
+    """
+
+
+    def key_builder(
+        func: Callable,
+        namespace: str,
+        request: Request | None,
+        response: Response | None,
+        args: tuple,
+        kwargs: dict[str, Any],
+    ) -> str:
+        """
+        Cache key builder.
+
+        Parameters
+        ----------
+        func : Decorated function.
+        namespace : Cache key prefix.
+        request : API Request.
+        response : API response.
+        args : Position arguments of decorated function.
+        kwargs : Keyword arguments of decorated function.
+        """
+
+        # Parameter.
+        data = f'{func.__module__}:{func.__name__}:{args}:{kwargs}'
+        pattern = r' object at 0x[0-9a-fA-F]+>'
+        data = sub(pattern, data, '>')
+
+        # Build.
+        key = get_md5(data)
+
+        return key
+
+
+    # Initialize.
+    backend = RedisBackend(redis)
+    FastAPICache.init(
+        backend,
+        expire=redis_expire,
+        coder=PickleCoder,
+        key_builder=key_builder
+    )
+
+
+def wrap_cache(func_or_expire: CallableT | int | None = None) -> CallableT | Callable[[CallableT], CallableT]:
+    """
+    Decorator, use Redis cache.
+    When Redis is not set, then skip.
+
+    Parameters
+    ----------
+    func_or_expire : Decorated function or Redis cache expire seconds.
+
+    Returns
+    -------
+    Decorated function or decorator.
+
+    Examples
+    --------
+    No parameter.
+    >>> @wrap_cache
+    >>> def foo(): ...
+
+    Set parameter.
+    >>> @wrap_cache(60)
+    >>> def foo(): ...
+    """
+
+    # Decorate.
+    if callable(func_or_expire):
+        decorator = fastapi_cache_cache()
+        func = decorator(func_or_expire)
+        return func
+    else:
+        decorator = fastapi_cache_cache(func_or_expire)
+        return decorator

reyserver/rclient.py

@@ -0,0 +1,267 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2025-10-09
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Client methods.
+"""
+
+
+from typing import TypedDict
+from datetime import datetime as Datetime
+from requests import Response
+from reykit.rbase import copy_type_hints
+from reykit.ros import File, Folder, overload
+from reykit.rnet import join_url, request, get_response_file_name
+
+from .rbase import ServerBase
+
+
+__all__ = (
+    'ServerClient',
+)
+
+
+FileInfo = TypedDict('FileInfo', {'create_time': Datetime, 'md5': str, 'name': str | None, 'size': int, 'note': str | None})
+
+
+class ServerClient(ServerBase):
+    """
+    Server client type.
+    """
+
+
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        url: str = 'http://127.0.0.1:8000',
+    ) -> None:
+        """
+        Build instance attributes.
+
+        Parameters
+        ----------
+        username: User name.
+        password: User password.
+        url : Server url.
+        """
+
+        # Build.
+        self.username = username
+        self.password = password
+        self.url = url
+        self.token = self.get_token(username, password)
+        self.request = copy_type_hints(self._request, request)
+
+
+    def get_token(
+        self,
+        username: str,
+        password: str
+    ) -> str:
+        """
+        Get token.
+
+        Parameters
+        ----------
+        username : User name.
+        password : User password.
+
+        Returns
+        -------
+        Token.
+        """
+
+        # Parameter.
+        url = join_url(self.url, 'token')
+        data = {
+            'username': username,
+            'password': password
+        }
+
+        # Request.
+        response = request(url, data=data, check=True)
+        response_dict = response.json()
+        token = response_dict['access_token']
+
+        return token
+
+
+    def _request(self, *args, **kwargs) -> Response:
+        """
+        Send request.
+
+        Parameters
+        ----------
+        args : Position arguments.
+        kwargs : Keyword arguments.
+
+        Returns
+        -------
+        Response.
+        """
+
+        # Parameter.
+        headers = kwargs.setdefault('headers', {})
+        headers['Authorization'] = f'Bearer {self.token}'
+        kwargs['check'] = list(range(200, 400))
+        kwargs['check'].append(401)
+
+        # Request.
+        response = request(*args, **kwargs)
+
+        # Check.
+        if response.status_code != 401:
+            return response
+
+        # Try request.
+        self.token = self.get_token(self.username, self.password)
+        headers['Authorization'] = f'Bearer {self.token}'
+        kwargs['check'] = True
+        response = request(*args, **kwargs)
+
+        return response
+
+
+    def upload_file(
+        self,
+        source: str | bytes,
+        name: str | None = None,
+        note: str | None = None
+    ) -> int:
+        """
+        Upload file.
+
+        Parameters
+        ----------
+        source : File path or file bytes.
+        name : File name.
+            - `None`: Automatic set.
+                `parameter 'file' is 'str'`: Use path file name.
+                `parameter 'file' is 'bytes'`: No name.
+            - `str`: Use this name.
+        note : File note.
+
+        Returns
+        -------
+        File ID.
+        """
+
+        # Parameter.
+        url = join_url(self.url, 'files')
+        match source:
+
+            ## File path.
+            case str():
+                file = File(source)
+                file_bytes = file.bytes
+                file_name = file.name_suffix
+
+            ## File bytes.
+            case bytes() | bytearray():
+                if type(source) == bytearray:
+                    source = bytes(source)
+                file_bytes = source
+                file_name = None
+
+        ## File name.
+        if name is not None:
+            file_name = name
+
+        # Request.
+        data = {'name': file_name, 'note': note}
+        files = {'file': file_bytes}
+        response = self.request(url, data=data, files=files, check=True)
+
+        ## Extract.
+        response_json = response.json()
+        file_id = response_json['file_id']
+
+        return file_id
+
+
+    @overload
+    def download_file(
+        self,
+        file_id: int,
+        path: None = None
+    ) -> bytes: ...
+
+    @overload
+    def download_file(
+        self,
+        file_id: int,
+        path: str
+    ) -> str: ...
+
+    def download_file(
+        self,
+        file_id: int,
+        path: str | None = None
+    ) -> bytes | str:
+        """
+        Download file.
+
+        Parameters
+        ----------
+        file_id : File ID.
+        path : File save path.
+            - `None`: Not save and return file bytes.
+            - `str`: Save and return file path.
+                `File path`: Use this file path.
+                `Folder path`: Use this folder path and original name.
+
+        Returns
+        -------
+        File bytes or file path.
+        """
+
+        # Parameter.
+        url = join_url(self.url, 'files', file_id, 'download')
+
+        # Request.
+        response = self.request(url, check=True)
+        file_bytes = response.content
+
+        # Not save.
+        if path is None:
+            return file_bytes
+
+        # Save.
+        else:
+            folder = Folder(path)
+            if folder:
+                file_name = get_response_file_name(response)
+                path = folder + file_name
+            file = File(path)
+            file(file_bytes)
+            return file.path
+
+
+    def get_file_info(
+        self,
+        file_id: int
+    ) -> FileInfo:
+        """
+        Query file information.
+
+        Parameters
+        ----------
+        file_id : File ID.
+
+        Returns
+        -------
+        File information.
+        """
+
+        # Parameter.
+        url = join_url(self.url, 'files', file_id)
+
+        # Request.
+        response = self.request(url, check=True)
+        response_dict = response.json()
+
+        return response_dict