fastexec 0.1.0__tar.gz

fastexec-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AllenChou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastexec-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: fastexec
+Version: 0.1.0
+Summary: Execute function with FastAPI features.
+License: MIT
+Author: AllenChou
+Author-email: f1470891079@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: all
+Requires-Dist: fastapi[standard]
+Description-Content-Type: text/markdown
+
+# fastexec
+Execute function with FastAPI features.
+

fastexec-0.1.0/README.md

@@ -0,0 +1,2 @@
+# fastexec
+Execute function with FastAPI features.

fastexec-0.1.0/fastexec/VERSION

@@ -0,0 +1 @@
+0.1.0

fastexec-0.1.0/fastexec/__init__.py

@@ -0,0 +1,148 @@
+import asyncio
+import inspect
+import json
+import typing
+from contextlib import AsyncExitStack
+from urllib.parse import urlencode
+
+import fastapi
+import fastapi.dependencies.models
+import fastapi.dependencies.utils
+import fastapi.exceptions
+import pydantic
+import starlette.requests
+from starlette.concurrency import run_in_threadpool
+
+from fastexec.version import get_version
+
+T = typing.TypeVar("T")
+__version__ = get_version()
+
+
+def is_coroutine_callable(callable_obj):
+    return inspect.iscoroutinefunction(callable_obj)
+
+
+async def call_any_function(func, **kwargs):
+    if is_coroutine_callable(func):
+        # Async function, just await it
+        return await func(**kwargs)
+    else:
+        # Sync function, run in threadpool
+        return await run_in_threadpool(func, **kwargs)
+
+
+def dict_to_asgi_headers(
+    headers: typing.Mapping[typing.Text, typing.Text]
+) -> typing.List[typing.Tuple[bytes, bytes]]:
+    return [
+        (k.lower().encode("latin1"), v.encode("latin1")) for k, v in headers.items()
+    ]
+
+
+def get_dependant(
+    *, path: typing.Text = "/", call: typing.Callable
+) -> fastapi.dependencies.models.Dependant:
+    return fastapi.dependencies.utils.get_dependant(path=path, call=call)
+
+
+async def exec_with_dependant(
+    *,
+    dependant: fastapi.dependencies.models.Dependant,
+    query_params: typing.Optional[typing.Union[typing.Dict, pydantic.BaseModel]] = None,
+    headers: typing.Optional[
+        typing.Union[typing.Mapping[typing.Text, typing.Text], pydantic.BaseModel]
+    ] = None,
+    body: typing.Optional[typing.Union[typing.Any, pydantic.BaseModel]] = None,
+) -> typing.Any:
+
+    _query_params: typing.Dict = (
+        json.loads(query_params.model_dump_json())
+        if isinstance(query_params, pydantic.BaseModel)
+        else query_params
+    ) or {}
+    _headers: typing.Mapping[typing.Text, typing.Text] = (
+        json.loads(headers.model_dump_json())
+        if isinstance(headers, pydantic.BaseModel)
+        else headers
+    ) or {}
+    _body = (
+        json.loads(body.model_dump_json())
+        if isinstance(body, pydantic.BaseModel)
+        else body
+    ) or None
+    _body_bytes = json.dumps(_body).encode("utf-8") if _body else b""
+
+    request = starlette.requests.Request(
+        scope={
+            "type": "http",
+            "method": "POST",
+            "path": "/fastexec",
+            "query_string": urlencode(_query_params).encode("utf-8"),
+            "headers": dict_to_asgi_headers(_headers),
+            "client": ("127.0.0.1", 8000),
+            "content-length": str(len(_body_bytes)).encode("utf-8"),
+        },
+        receive=lambda: asyncio.Future(),
+    )
+
+    # Mock the receive function to return the body
+    async def mock_receive():
+        return {"type": "http.request", "body": _body_bytes, "more_body": False}
+
+    request._receive = mock_receive
+
+    async with AsyncExitStack() as stack:
+        solved = await fastapi.dependencies.utils.solve_dependencies(
+            request=request,
+            dependant=dependant,
+            body=_body if isinstance(_body, typing.Dict) else None,
+            async_exit_stack=stack,  # Required
+            embed_body_fields=(
+                False if isinstance(_body, typing.Dict) else True
+            ),  # Required (usually False for non-JSON bodies)
+        )
+
+    # If there were no errors, get the final function’s return by calling the function
+    # with the solved dependency values:
+    if solved.errors:
+        raise fastapi.exceptions.HTTPException(
+            status_code=fastapi.status.HTTP_400_BAD_REQUEST, detail=str(solved.errors)
+        )
+
+    # For async functions:
+    final_result = await call_any_function(dependant.call, **solved.values)
+    return final_result
+
+
+class FastExec(typing.Generic[T]):
+    def __init__(
+        self,
+        call: typing.Union[
+            typing.Callable[..., T],
+            typing.Callable[..., typing.Awaitable[T]],
+        ],
+        *args,
+        **kwargs,
+    ):
+        self.dependant = get_dependant(call=call)
+
+    async def exec(
+        self,
+        *,
+        query_params: typing.Optional[
+            typing.Union[typing.Dict, pydantic.BaseModel]
+        ] = None,
+        headers: typing.Optional[
+            typing.Union[typing.Mapping[typing.Text, typing.Text], pydantic.BaseModel]
+        ] = None,
+        body: typing.Optional[typing.Union[typing.Any, pydantic.BaseModel]] = None,
+        **kwargs,
+    ) -> T:
+        return await exec_with_dependant(
+            dependant=self.dependant,
+            query_params=query_params,
+            headers=headers,
+            body=body,
+            **kwargs,
+        )

fastexec-0.1.0/fastexec/version.py

@@ -0,0 +1,11 @@
+import functools
+import pathlib
+import typing
+
+
+@functools.lru_cache(maxsize=1)
+def get_version() -> typing.Text:
+    ver_txt_file = pathlib.Path(__file__).parent.joinpath("VERSION")
+    if not ver_txt_file.is_file():
+        raise FileNotFoundError(f"Version file not found: {ver_txt_file}")
+    return ver_txt_file.read_text().strip()

fastexec-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.poetry]
+authors = ["AllenChou <f1470891079@gmail.com>"]
+description = "Execute function with FastAPI features."
+license = "MIT"
+name = "fastexec"
+readme = "README.md"
+version = "0.1.0"
+
+[tool.poetry.dependencies]
+fastapi = { extras = ["standard"], version = "*" }
+python = ">=3.12,<4.0"
+
+[tool.poetry.extras]
+all = []
+
+[tool.poetry.group.dev.dependencies]
+black = { extras = ["jupyter"], version = "*" }
+faker = "*"
+isort = "*"
+poetry-plugin-export = "^1.6.0"
+pytest = "^8"
+pytest-asyncio = "*"
+pytest-cov = "^4"
+pytest-xdist = "^3"
+scipy = "*"
+setuptools = ">=69"
+
+[tool.isort]
+profile = "black"
+
+[tool.flake8]
+ignore = ["E203", "E704", "W503"]
+max-line-length = 88
+
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]