supabase-functions 0.4.2__tar.gz

supabase_functions-0.4.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Joel Lee
+
+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.

supabase_functions-0.4.2/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: supabase_functions
+Version: 0.4.2
+Summary: Library for Supabase Functions
+Home-page: https://github.com/supabase-community/functions-py
+License: MIT
+Author: Joel Lee
+Author-email: joel@joellee.org
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: httpx (>=0.24,<0.28)
+Project-URL: Repository, https://github.com/supabase-community/functions-py
+Description-Content-Type: text/markdown
+
+# Functions-py
+
+
+## Installation
+
+`pip3 install supabase_functions`
+
+## Usage
+
+Deploy your function as per documentation.
+
+
+```python3
+import asyncio
+from supabase_functions import AsyncFunctionsClient
+async def run_func():
+    fc = AsyncFunctionsClient("https://<project_ref>.functions.supabase.co", {})
+    res = await fc.invoke("payment-sheet", {"responseType": "json"})
+
+if __name__ == "__main__":
+    asyncio.run(run_func())
+```
+

supabase_functions-0.4.2/README.md

@@ -0,0 +1,22 @@
+# Functions-py
+
+
+## Installation
+
+`pip3 install supabase_functions`
+
+## Usage
+
+Deploy your function as per documentation.
+
+
+```python3
+import asyncio
+from supabase_functions import AsyncFunctionsClient
+async def run_func():
+    fc = AsyncFunctionsClient("https://<project_ref>.functions.supabase.co", {})
+    res = await fc.invoke("payment-sheet", {"responseType": "json"})
+
+if __name__ == "__main__":
+    asyncio.run(run_func())
+```

supabase_functions-0.4.2/pyproject.toml

@@ -0,0 +1,44 @@
+[tool.poetry]
+name = "supabase_functions"
+version = "0.4.2"
+description = "Library for Supabase Functions"
+authors = [
+    "Joel Lee <joel@joellee.org>",
+    "Andrew Smith <a.smith@silentworks.co.uk>"
+]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/supabase-community/functions-py"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+httpx =  ">=0.24,<0.28"
+
+[tool.poetry.group.dev.dependencies]
+python-semantic-release = ">=8.1.1,<10.0.0"
+black = ">=23.9.1,<25.0.0"
+isort = "^5.12.0"
+pre-commit = "^3.4.0"
+pyjwt = "^2.8.0"
+pytest = ">=7.4.2,<9.0.0"
+pytest-cov = "^4.0.0"
+unasync-cli = "^0.0.9"
+pytest-asyncio = ">=0.21.1,<0.24.0"
+respx = ">=0.20.2,<0.22.0"
+
+[tool.semantic_release]
+version_variables = ["supabase_functions/utils.py:__version__"]
+version_toml = ["pyproject.toml:tool.poetry.version"]
+major_on_zero = false
+commit_message = "chore(release): bump version to v{version}"
+build_command = "curl -sSL https://install.python-poetry.org | python - && export PATH=\"/github/home/.local/bin:$PATH\" && poetry install && poetry build"
+upload_to_vcs_release = true
+branch = "main"
+changelog_components = "semantic_release.changelog.changelog_headers,semantic_release.changelog.compare_url"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

supabase_functions-0.4.2/supabase_functions/__init__.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Literal, Union, overload
+
+from ._async.functions_client import AsyncFunctionsClient
+from ._sync.functions_client import SyncFunctionsClient
+
+__all__ = ["create_client"]
+
+
+@overload
+def create_client(
+    url: str, headers: dict[str, str], *, is_async: Literal[True]
+) -> AsyncFunctionsClient:
+    ...
+
+
+@overload
+def create_client(
+    url: str, headers: dict[str, str], *, is_async: Literal[False]
+) -> SyncFunctionsClient:
+    ...
+
+
+def create_client(
+    url: str, headers: dict[str, str], *, is_async: bool
+) -> Union[AsyncFunctionsClient, SyncFunctionsClient]:
+    if is_async:
+        return AsyncFunctionsClient(url, headers)
+    else:
+        return SyncFunctionsClient(url, headers)

supabase_functions-0.4.2/supabase_functions/_async/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

supabase_functions-0.4.2/supabase_functions/_async/functions_client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, Literal, Optional, Union
+
+from httpx import HTTPError, Response
+
+from ..errors import FunctionsHttpError, FunctionsRelayError
+from ..utils import AsyncClient, __version__
+
+
+class AsyncFunctionsClient:
+    def __init__(self, url: str, headers: Dict):
+        self.url = url
+        self.headers = {
+            "User-Agent": f"supabase-py/functions-py v{__version__}",
+            **headers,
+        }
+        self._client = AsyncClient(base_url=self.url, headers=self.headers)
+
+    async def _request(
+        self,
+        method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
+        url: str,
+        headers: Union[Dict[str, str], None] = None,
+        json: Optional[Dict[Any, Any]] = None,
+    ) -> Response:
+        response = await self._client.request(method, url, json=json, headers=headers)
+        try:
+            response.raise_for_status()
+        except HTTPError as exc:
+            raise FunctionsHttpError(
+                response.json().get("error")
+                or f"An error occurred while requesting your edge function at {exc.request.url!r}."
+            ) from exc
+
+        return response
+
+    def set_auth(self, token: str) -> None:
+        """Updates the authorization header
+
+        Parameters
+        ----------
+        token : str
+            the new jwt token sent in the authorization header
+        """
+
+        self.headers["Authorization"] = f"Bearer {token}"
+
+    async def invoke(
+        self, function_name: str, invoke_options: Optional[Dict] = None
+    ) -> Union[Dict, bytes]:
+        """Invokes a function
+
+        Parameters
+        ----------
+        function_name : the name of the function to invoke
+        invoke_options : object with the following properties
+            `headers`: object representing the headers to send with the request
+            `body`: the body of the request
+            `responseType`: how the response should be parsed. The default is `json`
+        """
+        headers = self.headers
+        if invoke_options is not None:
+            headers.update(invoke_options.get("headers", {}))
+
+        body = invoke_options.get("body") if invoke_options else None
+        response_type = (
+            invoke_options.get("responseType") if invoke_options else "text/plain"
+        )
+
+        if type(body) == str:
+            headers["Content-Type"] = "text/plain"
+        elif type(body) == dict:
+            headers["Content-Type"] = "application/json"
+
+        response = await self._request(
+            "POST", f"{self.url}/{function_name}", headers=headers, json=body
+        )
+        is_relay_error = response.headers.get("x-relay-header")
+
+        if is_relay_error and is_relay_error == "true":
+            raise FunctionsRelayError(response.json().get("error"))
+
+        if response_type == "json":
+            data = response.json()
+        else:
+            data = response.content
+        return data

supabase_functions-0.4.2/supabase_functions/_sync/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

supabase_functions-0.4.2/supabase_functions/_sync/functions_client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, Literal, Optional, Union
+
+from httpx import HTTPError, Response
+
+from ..errors import FunctionsHttpError, FunctionsRelayError
+from ..utils import SyncClient, __version__
+
+
+class SyncFunctionsClient:
+    def __init__(self, url: str, headers: Dict):
+        self.url = url
+        self.headers = {
+            "User-Agent": f"supabase-py/functions-py v{__version__}",
+            **headers,
+        }
+        self._client = SyncClient(base_url=self.url, headers=self.headers)
+
+    def _request(
+        self,
+        method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
+        url: str,
+        headers: Union[Dict[str, str], None] = None,
+        json: Optional[Dict[Any, Any]] = None,
+    ) -> Response:
+        response = self._client.request(method, url, json=json, headers=headers)
+        try:
+            response.raise_for_status()
+        except HTTPError as exc:
+            raise FunctionsHttpError(
+                response.json().get("error")
+                or f"An error occurred while requesting your edge function at {exc.request.url!r}."
+            ) from exc
+
+        return response
+
+    def set_auth(self, token: str) -> None:
+        """Updates the authorization header
+
+        Parameters
+        ----------
+        token : str
+            the new jwt token sent in the authorization header
+        """
+
+        self.headers["Authorization"] = f"Bearer {token}"
+
+    def invoke(
+        self, function_name: str, invoke_options: Optional[Dict] = None
+    ) -> Union[Dict, bytes]:
+        """Invokes a function
+
+        Parameters
+        ----------
+        function_name : the name of the function to invoke
+        invoke_options : object with the following properties
+            `headers`: object representing the headers to send with the request
+            `body`: the body of the request
+            `responseType`: how the response should be parsed. The default is `json`
+        """
+        headers = self.headers
+        if invoke_options is not None:
+            headers.update(invoke_options.get("headers", {}))
+
+        body = invoke_options.get("body") if invoke_options else None
+        response_type = (
+            invoke_options.get("responseType") if invoke_options else "text/plain"
+        )
+
+        if type(body) == str:
+            headers["Content-Type"] = "text/plain"
+        elif type(body) == dict:
+            headers["Content-Type"] = "application/json"
+
+        response = self._request(
+            "POST", f"{self.url}/{function_name}", headers=headers, json=body
+        )
+        is_relay_error = response.headers.get("x-relay-header")
+
+        if is_relay_error and is_relay_error == "true":
+            raise FunctionsRelayError(response.json().get("error"))
+
+        if response_type == "json":
+            data = response.json()
+        else:
+            data = response.content
+        return data

supabase_functions-0.4.2/supabase_functions/errors.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class FunctionsApiErrorDict(TypedDict):
+    name: str
+    message: str
+    status: int
+
+
+class FunctionsError(Exception):
+    def __init__(self, message: str, name: str, status: int) -> None:
+        super().__init__(message)
+        self.message = message
+        self.name = name
+        self.status = status
+
+    def to_dict(self) -> FunctionsApiErrorDict:
+        return {
+            "name": self.name,
+            "message": self.message,
+            "status": self.status,
+        }
+
+
+class FunctionsHttpError(FunctionsError):
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message,
+            "FunctionsHttpError",
+            400,
+        )
+
+
+class FunctionsRelayError(FunctionsError):
+    """Base exception for relay errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message,
+            "FunctionsRelayError",
+            400,
+        )

supabase_functions-0.4.2/supabase_functions/utils.py

@@ -0,0 +1,9 @@
+from httpx import AsyncClient as AsyncClient  # noqa: F401
+from httpx import Client as BaseClient
+
+__version__ = "0.4.2"
+
+
+class SyncClient(BaseClient):
+    def aclose(self) -> None:
+        self.close()