moolabs 0.3.0__py3-none-any.whl

moolabs/models/test_send_request.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TestSendRequest(BaseModel):
+    """
+    TestSendRequest
+    """ # noqa: E501
+    version_id: Annotated[str, Field(min_length=1, strict=True)]
+    mode: Optional[StrictStr] = None
+    case_id: Optional[Annotated[str, Field(min_length=1, strict=True)]] = None
+    recipient_email: Annotated[str, Field(min_length=3, strict=True, max_length=320)]
+    __properties: ClassVar[List[str]] = ["version_id", "mode", "case_id", "recipient_email"]
+
+    @field_validator('mode')
+    def mode_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['sample', 'real_case']):
+            raise ValueError("must be one of enum values ('sample', 'real_case')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TestSendRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TestSendRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "version_id": obj.get("version_id"),
+            "mode": obj.get("mode"),
+            "case_id": obj.get("case_id"),
+            "recipient_email": obj.get("recipient_email")
+        })
+        return _obj
+
+

moolabs/models/test_send_response.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TestSendResponse(BaseModel):
+    """
+    TestSendResponse
+    """ # noqa: E501
+    id: StrictStr
+    status: StrictStr
+    recipient_email: StrictStr
+    version_id: StrictStr
+    __properties: ClassVar[List[str]] = ["id", "status", "recipient_email", "version_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TestSendResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TestSendResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "status": obj.get("status"),
+            "recipient_email": obj.get("recipient_email"),
+            "version_id": obj.get("version_id")
+        })
+        return _obj
+
+

moolabs/models/tiered_price_mode.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class TieredPriceMode(str, Enum):
+    """
+    The mode of the tiered price.
+    """
+
+    """
+    allowed enum values
+    """
+    VOLUME = 'volume'
+    GRADUATED = 'graduated'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of TieredPriceMode from a JSON string"""
+        return cls(json.loads(json_str))
+
+

moolabs/models/tiered_price_with_commitments.py

@@ -0,0 +1,132 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from moolabs.models.price_tier import PriceTier
+from moolabs.models.tiered_price_mode import TieredPriceMode
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TieredPriceWithCommitments(BaseModel):
+    """
+    Tiered price with spend commitments.
+    """ # noqa: E501
+    type: StrictStr = Field(description="The type of the price.  One of: flat, unit, or tiered.")
+    mode: TieredPriceMode = Field(description="Defines if the tiering mode is volume-based or graduated: - In `volume`-based tiering, the maximum quantity within a period determines the per unit price. - In `graduated` tiering, pricing can change as the quantity grows.")
+    tiers: Annotated[List[PriceTier], Field(min_length=1)] = Field(description="The tiers of the tiered price. At least one price component is required in each tier.")
+    minimum_amount: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The customer is committed to spend at least the amount.", alias="minimumAmount")
+    maximum_amount: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The customer is limited to spend at most the amount.", alias="maximumAmount")
+    __properties: ClassVar[List[str]] = ["type", "mode", "tiers", "minimumAmount", "maximumAmount"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['tiered']):
+            raise ValueError("must be one of enum values ('tiered')")
+        return value
+
+    @field_validator('minimum_amount')
+    def minimum_amount_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^\-?[0-9]+(\.[0-9]+)?$", value):
+            raise ValueError(r"must validate the regular expression /^\-?[0-9]+(\.[0-9]+)?$/")
+        return value
+
+    @field_validator('maximum_amount')
+    def maximum_amount_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^\-?[0-9]+(\.[0-9]+)?$", value):
+            raise ValueError(r"must validate the regular expression /^\-?[0-9]+(\.[0-9]+)?$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TieredPriceWithCommitments from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in tiers (list)
+        _items = []
+        if self.tiers:
+            for _item_tiers in self.tiers:
+                if _item_tiers:
+                    _items.append(_item_tiers.to_dict())
+            _dict['tiers'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TieredPriceWithCommitments from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "mode": obj.get("mode"),
+            "tiers": [PriceTier.from_dict(_item) for _item in obj["tiers"]] if obj.get("tiers") is not None else None,
+            "minimumAmount": obj.get("minimumAmount"),
+            "maximumAmount": obj.get("maximumAmount")
+        })
+        return _obj
+
+

moolabs/models/tiered_pricing_payload.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from moolabs.models.price_tier_payload import PriceTierPayload
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TieredPricingPayload(BaseModel):
+    """
+    TieredPricingPayload
+    """ # noqa: E501
+    mode: StrictStr
+    tiers: List[PriceTierPayload]
+    __properties: ClassVar[List[str]] = ["mode", "tiers"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TieredPricingPayload from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in tiers (list)
+        _items = []
+        if self.tiers:
+            for _item_tiers in self.tiers:
+                if _item_tiers:
+                    _items.append(_item_tiers.to_dict())
+            _dict['tiers'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TieredPricingPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "mode": obj.get("mode"),
+            "tiers": [PriceTierPayload.from_dict(_item) for _item in obj["tiers"]] if obj.get("tiers") is not None else None
+        })
+        return _obj
+
+

moolabs/models/timestamp_window.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TimestampWindow(BaseModel):
+    """
+    TimestampWindow
+    """ # noqa: E501
+    start: datetime
+    end_exclusive: datetime
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["start", "end_exclusive"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TimestampWindow from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TimestampWindow from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "start": obj.get("start"),
+            "end_exclusive": obj.get("end_exclusive")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

moolabs/models/top_consumer.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Moolabs API
+
+    Unified Moolabs SDK. Capability-based public surface stitched from internal service specs: bff, meter, arc, acute. Customers see capability namespaces (usage, billing, collections, etc.); the SDK routes per-operation internally.
+
+    The version of the OpenAPI document: 0.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TopConsumer(BaseModel):
+    """
+    TopConsumer
+    """ # noqa: E501
+    customer_id: StrictStr
+    total_cost: Union[StrictFloat, StrictInt]
+    request_count: StrictInt
+    rank: StrictInt
+    __properties: ClassVar[List[str]] = ["customer_id", "total_cost", "request_count", "rank"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TopConsumer from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TopConsumer from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "customer_id": obj.get("customer_id"),
+            "total_cost": obj.get("total_cost"),
+            "request_count": obj.get("request_count"),
+            "rank": obj.get("rank")
+        })
+        return _obj
+
+