rulebricks 0.0.1__tar.gz

rulebricks-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: rulebricks
+Version: 0.0.1
+Summary: 
+Requires-Python: >=3.8,<4.0
+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
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Description-Content-Type: text/markdown
+
+# Rulebricks Python Library
+
+## Documentation
+
+API reference documentation is available [here](https://rulebricks.com/docs).
+
+## Installation
+
+Add this dependency to your project's build file:
+
+```bash
+pip install rulebricks
+# or
+poetry add rulebricks
+```
+
+## Usage
+
+```python
+from rulebricks.client import Rulebricks
+
+rulebricks_client = Rulebricks(
+    api_key="YOUR_API_KEY",
+    base_url="https://yourhost.com/path/to/api",
+)
+```
+
+## Async Client
+
+```python
+from rulebricks.client import AsyncFlatFile
+import flatfile
+
+import asyncio
+
+rulebricks_client = AsyncRulebricks(
+    api_key="YOUR_API_KEY",
+    base_url="https://yourhost.com/path/to/api",
+)
+```
+
+## Beta status
+
+This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning the package version to a specific version in your pyproject.toml file. This way, you can install the same version each time without breaking changes unless you are intentionally looking for the latest version.
+

rulebricks-0.0.1/README.md

@@ -0,0 +1,44 @@
+# Rulebricks Python Library
+
+## Documentation
+
+API reference documentation is available [here](https://rulebricks.com/docs).
+
+## Installation
+
+Add this dependency to your project's build file:
+
+```bash
+pip install rulebricks
+# or
+poetry add rulebricks
+```
+
+## Usage
+
+```python
+from rulebricks.client import Rulebricks
+
+rulebricks_client = Rulebricks(
+    api_key="YOUR_API_KEY",
+    base_url="https://yourhost.com/path/to/api",
+)
+```
+
+## Async Client
+
+```python
+from rulebricks.client import AsyncFlatFile
+import flatfile
+
+import asyncio
+
+rulebricks_client = AsyncRulebricks(
+    api_key="YOUR_API_KEY",
+    base_url="https://yourhost.com/path/to/api",
+)
+```
+
+## Beta status
+
+This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning the package version to a specific version in your pyproject.toml file. This way, you can install the same version each time without breaking changes unless you are intentionally looking for the latest version.

rulebricks-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "rulebricks"
+version = "0.0.1"
+description = ""
+readme = "README.md"
+authors = []
+packages = [
+    { include = "rulebricks", from = "src"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+httpx = ">=0.21.2"
+pydantic = ">= 1.9.2"
+typing_extensions = ">= 4.0.0"
+
+[tool.poetry.dev-dependencies]
+mypy = "^1.8.0"
+pytest = "^7.4.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

rulebricks-0.0.1/src/rulebricks/__init__.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .errors import BadRequestError, InternalServerError
+from .resources import (
+    ListResponseItem,
+    ListResponseItemRequestSchemaItem,
+    ListResponseItemResponseSchemaItem,
+    UsageResponse,
+    flows,
+    rules,
+)
+
+__all__ = [
+    "BadRequestError",
+    "InternalServerError",
+    "ListResponseItem",
+    "ListResponseItemRequestSchemaItem",
+    "ListResponseItemResponseSchemaItem",
+    "UsageResponse",
+    "flows",
+    "rules",
+]

rulebricks-0.0.1/src/rulebricks/client.py

@@ -0,0 +1,45 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .resources.flows.client import AsyncFlowsClient, FlowsClient
+from .resources.rules.client import AsyncRulesClient, RulesClient
+
+
+class RulebricksApi:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.Client] = None
+    ):
+        self._client_wrapper = SyncClientWrapper(
+            base_url=base_url,
+            api_key=api_key,
+            httpx_client=httpx.Client(timeout=timeout) if httpx_client is None else httpx_client,
+        )
+        self.rules = RulesClient(client_wrapper=self._client_wrapper)
+        self.flows = FlowsClient(client_wrapper=self._client_wrapper)
+
+
+class AsyncRulebricksApi:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None
+    ):
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=base_url,
+            api_key=api_key,
+            httpx_client=httpx.AsyncClient(timeout=timeout) if httpx_client is None else httpx_client,
+        )
+        self.rules = AsyncRulesClient(client_wrapper=self._client_wrapper)
+        self.flows = AsyncFlowsClient(client_wrapper=self._client_wrapper)

rulebricks-0.0.1/src/rulebricks/core/__init__.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .api_error import ApiError
+from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+from .datetime_utils import serialize_datetime
+from .jsonable_encoder import jsonable_encoder
+from .remove_none_from_dict import remove_none_from_dict
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "BaseClientWrapper",
+    "SyncClientWrapper",
+    "jsonable_encoder",
+    "remove_none_from_dict",
+    "serialize_datetime",
+]

rulebricks-0.0.1/src/rulebricks/core/api_error.py

@@ -0,0 +1,15 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+
+class ApiError(Exception):
+    status_code: typing.Optional[int]
+    body: typing.Any
+
+    def __init__(self, *, status_code: typing.Optional[int] = None, body: typing.Any = None):
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"status_code: {self.status_code}, body: {self.body}"

rulebricks-0.0.1/src/rulebricks/core/client_wrapper.py

@@ -0,0 +1,31 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+
+class BaseClientWrapper:
+    def __init__(self, *, api_key: str, base_url: str):
+        self.api_key = api_key
+        self._base_url = base_url
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        headers: typing.Dict[str, str] = {"X-Fern-Language": "Python"}
+        headers["x-api-key"] = self.api_key
+        return headers
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(self, *, api_key: str, base_url: str, httpx_client: httpx.Client):
+        super().__init__(api_key=api_key, base_url=base_url)
+        self.httpx_client = httpx_client
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(self, *, api_key: str, base_url: str, httpx_client: httpx.AsyncClient):
+        super().__init__(api_key=api_key, base_url=base_url)
+        self.httpx_client = httpx_client

rulebricks-0.0.1/src/rulebricks/core/datetime_utils.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

rulebricks-0.0.1/src/rulebricks/core/jsonable_encoder.py

@@ -0,0 +1,103 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import dataclasses
+import datetime as dt
+from collections import defaultdict
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+from .datetime_utils import serialize_datetime
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]]
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic.json.ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, pydantic.BaseModel):
+        encoder = getattr(obj.__config__, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dt.date):
+        return str(obj)
+    if isinstance(obj, dt.datetime):
+        return serialize_datetime(obj)
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        for key, value in obj.items():
+            if key in allowed_keys:
+                encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
+                encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
+        return encoded_list
+
+    if type(obj) in pydantic.json.ENCODERS_BY_TYPE:
+        return pydantic.json.ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: List[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(data, custom_encoder=custom_encoder)

rulebricks-0.0.1/src/rulebricks/core/remove_none_from_dict.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Optional
+
+
+def remove_none_from_dict(original: Dict[str, Optional[Any]]) -> Dict[str, Any]:
+    new: Dict[str, Any] = {}
+    for key, value in original.items():
+        if value is not None:
+            new[key] = value
+    return new

rulebricks-0.0.1/src/rulebricks/errors/__init__.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .bad_request_error import BadRequestError
+from .internal_server_error import InternalServerError
+
+__all__ = ["BadRequestError", "InternalServerError"]

rulebricks-0.0.1/src/rulebricks/errors/bad_request_error.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.api_error import ApiError
+
+
+class BadRequestError(ApiError):
+    def __init__(self, body: typing.Any):
+        super().__init__(status_code=400, body=body)

rulebricks-0.0.1/src/rulebricks/errors/internal_server_error.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.api_error import ApiError
+
+
+class InternalServerError(ApiError):
+    def __init__(self, body: typing.Any):
+        super().__init__(status_code=500, body=body)

rulebricks-0.0.1/src/rulebricks/resources/__init__.py

@@ -0,0 +1,18 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from . import flows, rules
+from .rules import (
+    ListResponseItem,
+    ListResponseItemRequestSchemaItem,
+    ListResponseItemResponseSchemaItem,
+    UsageResponse,
+)
+
+__all__ = [
+    "ListResponseItem",
+    "ListResponseItemRequestSchemaItem",
+    "ListResponseItemResponseSchemaItem",
+    "UsageResponse",
+    "flows",
+    "rules",
+]

rulebricks-0.0.1/src/rulebricks/resources/flows/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+

rulebricks-0.0.1/src/rulebricks/resources/flows/client.py

@@ -0,0 +1,107 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.jsonable_encoder import jsonable_encoder
+from ...errors.bad_request_error import BadRequestError
+from ...errors.internal_server_error import InternalServerError
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class FlowsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def execute(self, slug: str, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Execute a flow by its slug.
+
+        Parameters:
+            - slug: str. The unique identifier for the flow.
+
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.flows.execute(
+            slug="slug",
+            request={"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/flow/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncFlowsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def execute(self, slug: str, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Execute a flow by its slug.
+
+        Parameters:
+            - slug: str. The unique identifier for the flow.
+
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.flows.execute(
+            slug="slug",
+            request={"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/flow/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

rulebricks-0.0.1/src/rulebricks/resources/rules/__init__.py

@@ -0,0 +1,15 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .types import (
+    ListResponseItem,
+    ListResponseItemRequestSchemaItem,
+    ListResponseItemResponseSchemaItem,
+    UsageResponse,
+)
+
+__all__ = [
+    "ListResponseItem",
+    "ListResponseItemRequestSchemaItem",
+    "ListResponseItemResponseSchemaItem",
+    "UsageResponse",
+]

rulebricks-0.0.1/src/rulebricks/resources/rules/client.py

@@ -0,0 +1,403 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.jsonable_encoder import jsonable_encoder
+from ...errors.bad_request_error import BadRequestError
+from ...errors.internal_server_error import InternalServerError
+from .types.list_response_item import ListResponseItem
+from .types.usage_response import UsageResponse
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RulesClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def solve(self, slug: str, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Executes a single rule identified by a unique slug. The request and response formats are dynamic, dependent on the rule configuration.
+
+        Parameters:
+            - slug: str. The unique identifier for the rule.
+
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.rules.solve(
+            slug="slug",
+            request={"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/solve/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def bulk_solve(
+        self, slug: str, *, request: typing.List[typing.Dict[str, typing.Any]]
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """
+        Executes a particular rule against multiple request data payloads provided in a list.
+
+        Parameters:
+            - slug: str. The unique identifier of the rule to execute against all payloads.
+
+            - request: typing.List[typing.Dict[str, typing.Any]].
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.rules.bulk_solve(
+            slug="slug",
+            request=[
+                {"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+                {"name": "Jane Doe", "age": 28, "email": "jane@example.com"},
+            ],
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/bulk-solve/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[typing.Dict[str, typing.Any]], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def parallel_solve(self, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Executes multiple rules in parallel based on a provided mapping of rule slugs to payloads.
+
+        Parameters:
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.rules.parallel_solve(
+            request={
+                "eligibility": {
+                    "rule": "1ef03ms",
+                    "name": "John Doe",
+                    "age": 30,
+                    "email": "jdoe@acme.co",
+                },
+                "offers": {
+                    "rule": "OvmsYwn",
+                    "customer_id": "12345",
+                    "last_purchase_days_ago": 30,
+                    "selected_plan": "premium",
+                },
+            },
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/parallel-solve"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def list(self) -> typing.List[ListResponseItem]:
+        """
+        List all rules in the organization.
+
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.rules.list()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/list"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[ListResponseItem], _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def usage(self) -> UsageResponse:
+        """
+        Get the rule execution usage of your organization.
+
+        ---
+        from rulebricks.client import RulebricksApi
+
+        client = RulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        client.rules.usage()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/usage"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UsageResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncRulesClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def solve(self, slug: str, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Executes a single rule identified by a unique slug. The request and response formats are dynamic, dependent on the rule configuration.
+
+        Parameters:
+            - slug: str. The unique identifier for the rule.
+
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.rules.solve(
+            slug="slug",
+            request={"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/solve/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def bulk_solve(
+        self, slug: str, *, request: typing.List[typing.Dict[str, typing.Any]]
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """
+        Executes a particular rule against multiple request data payloads provided in a list.
+
+        Parameters:
+            - slug: str. The unique identifier of the rule to execute against all payloads.
+
+            - request: typing.List[typing.Dict[str, typing.Any]].
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.rules.bulk_solve(
+            slug="slug",
+            request=[
+                {"name": "John Doe", "age": 30, "email": "jdoe@acme.co"},
+                {"name": "Jane Doe", "age": 28, "email": "jane@example.com"},
+            ],
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"api/v1/bulk-solve/{slug}"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[typing.Dict[str, typing.Any]], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def parallel_solve(self, *, request: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Executes multiple rules in parallel based on a provided mapping of rule slugs to payloads.
+
+        Parameters:
+            - request: typing.Dict[str, typing.Any].
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.rules.parallel_solve(
+            request={
+                "eligibility": {
+                    "rule": "1ef03ms",
+                    "name": "John Doe",
+                    "age": 30,
+                    "email": "jdoe@acme.co",
+                },
+                "offers": {
+                    "rule": "OvmsYwn",
+                    "customer_id": "12345",
+                    "last_purchase_days_ago": 30,
+                    "selected_plan": "premium",
+                },
+            },
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/parallel-solve"),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Dict[str, typing.Any], _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def list(self) -> typing.List[ListResponseItem]:
+        """
+        List all rules in the organization.
+
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.rules.list()
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/list"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[ListResponseItem], _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def usage(self) -> UsageResponse:
+        """
+        Get the rule execution usage of your organization.
+
+        ---
+        from rulebricks.client import AsyncRulebricksApi
+
+        client = AsyncRulebricksApi(
+            api_key="YOUR_API_KEY",
+            base_url="https://yourhost.com/path/to/api",
+        )
+        await client.rules.usage()
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v1/usage"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UsageResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

rulebricks-0.0.1/src/rulebricks/resources/rules/types/__init__.py

@@ -0,0 +1,13 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .list_response_item import ListResponseItem
+from .list_response_item_request_schema_item import ListResponseItemRequestSchemaItem
+from .list_response_item_response_schema_item import ListResponseItemResponseSchemaItem
+from .usage_response import UsageResponse
+
+__all__ = [
+    "ListResponseItem",
+    "ListResponseItemRequestSchemaItem",
+    "ListResponseItemResponseSchemaItem",
+    "UsageResponse",
+]

rulebricks-0.0.1/src/rulebricks/resources/rules/types/list_response_item.py

@@ -0,0 +1,36 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ....core.datetime_utils import serialize_datetime
+from .list_response_item_request_schema_item import ListResponseItemRequestSchemaItem
+from .list_response_item_response_schema_item import ListResponseItemResponseSchemaItem
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class ListResponseItem(pydantic.BaseModel):
+    id: typing.Optional[str] = pydantic.Field(description="The unique identifier for the rule.")
+    name: typing.Optional[str] = pydantic.Field(description="The name of the rule.")
+    description: typing.Optional[str] = pydantic.Field(description="The description of the rule.")
+    created_at: typing.Optional[str] = pydantic.Field(description="The creation date of the rule.")
+    slug: typing.Optional[str] = pydantic.Field(description="The unique slug for the rule used in API requests.")
+    request_schema: typing.Optional[typing.List[ListResponseItemRequestSchemaItem]]
+    response_schema: typing.Optional[typing.List[ListResponseItemResponseSchemaItem]]
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        json_encoders = {dt.datetime: serialize_datetime}

rulebricks-0.0.1/src/rulebricks/resources/rules/types/list_response_item_request_schema_item.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ....core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class ListResponseItemRequestSchemaItem(pydantic.BaseModel):
+    key: typing.Optional[str] = pydantic.Field(description="The key for the request field.")
+    show: typing.Optional[bool] = pydantic.Field(description="Whether the field is visible in the rule editor.")
+    name: typing.Optional[str] = pydantic.Field(description="The name of the request field.")
+    description: typing.Optional[str] = pydantic.Field(description="The description of the request field.")
+    type: typing.Optional[str] = pydantic.Field(description="The data type of the request field.")
+    default_value: typing.Optional[str] = pydantic.Field(
+        alias="defaultValue", description="The default value of the request field."
+    )
+    default_computed_value: typing.Optional[str] = pydantic.Field(
+        alias="defaultComputedValue", description="The computed default value of the request field."
+    )
+    transform: typing.Optional[str] = pydantic.Field(description="The transformation applied to the request field.")
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        allow_population_by_field_name = True
+        json_encoders = {dt.datetime: serialize_datetime}

rulebricks-0.0.1/src/rulebricks/resources/rules/types/list_response_item_response_schema_item.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ....core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class ListResponseItemResponseSchemaItem(pydantic.BaseModel):
+    key: typing.Optional[str] = pydantic.Field(description="The key for the response field.")
+    show: typing.Optional[bool] = pydantic.Field(description="Whether the field is visible in the rule editor.")
+    name: typing.Optional[str] = pydantic.Field(description="The name of the response field.")
+    description: typing.Optional[str] = pydantic.Field(description="The description of the response field.")
+    type: typing.Optional[str] = pydantic.Field(description="The data type of the response field.")
+    default_value: typing.Optional[str] = pydantic.Field(
+        alias="defaultValue", description="The default value of the response field."
+    )
+    default_computed_value: typing.Optional[str] = pydantic.Field(
+        alias="defaultComputedValue", description="The computed default value of the response field."
+    )
+    transform: typing.Optional[str] = pydantic.Field(description="The transformation applied to the response field.")
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        allow_population_by_field_name = True
+        json_encoders = {dt.datetime: serialize_datetime}

rulebricks-0.0.1/src/rulebricks/resources/rules/types/usage_response.py

@@ -0,0 +1,41 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ....core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class UsageResponse(pydantic.BaseModel):
+    plan: typing.Optional[str] = pydantic.Field(description="The current plan of the organization.")
+    monthly_period_start: typing.Optional[str] = pydantic.Field(
+        description="The start date of the current monthly period."
+    )
+    monthly_period_end: typing.Optional[str] = pydantic.Field(description="The end date of the current monthly period.")
+    monthly_executions_usage: typing.Optional[float] = pydantic.Field(
+        description="The number of rule executions used this month."
+    )
+    monthly_executions_limit: typing.Optional[float] = pydantic.Field(
+        description="The total number of rule executions allowed this month."
+    )
+    monthly_executions_remaining: typing.Optional[float] = pydantic.Field(
+        description="The number of rule executions remaining this month."
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        json_encoders = {dt.datetime: serialize_datetime}