moolabs 0.3.0__py3-none-any.whl

moolabs/models/attribution_allocation_error_response.py

@@ -0,0 +1,91 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from moolabs.models.attribution_allocation_error_detail import AttributionAllocationErrorDetail
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionAllocationErrorResponse(BaseModel):
+    """
+    AttributionAllocationErrorResponse
+    """ # noqa: E501
+    detail: AttributionAllocationErrorDetail
+    __properties: ClassVar[List[str]] = ["detail"]
+
+    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 AttributionAllocationErrorResponse 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 detail
+        if self.detail:
+            _dict['detail'] = self.detail.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AttributionAllocationErrorResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "detail": AttributionAllocationErrorDetail.from_dict(obj["detail"]) if obj.get("detail") is not None else None
+        })
+        return _obj
+
+

moolabs/models/attribution_completeness_response.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, StrictBool, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionCompletenessResponse(BaseModel):
+    """
+    AttributionCompletenessResponse
+    """ # noqa: E501
+    total_cost_events: StrictInt
+    has_data: StrictBool
+    unreconciled_pct: Union[StrictFloat, StrictInt]
+    direct_pct: Union[StrictFloat, StrictInt]
+    derived_pct: Union[StrictFloat, StrictInt]
+    unattributed_pct: Union[StrictFloat, StrictInt]
+    __properties: ClassVar[List[str]] = ["total_cost_events", "has_data", "unreconciled_pct", "direct_pct", "derived_pct", "unattributed_pct"]
+
+    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 AttributionCompletenessResponse 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 AttributionCompletenessResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "total_cost_events": obj.get("total_cost_events"),
+            "has_data": obj.get("has_data"),
+            "unreconciled_pct": obj.get("unreconciled_pct"),
+            "direct_pct": obj.get("direct_pct"),
+            "derived_pct": obj.get("derived_pct"),
+            "unattributed_pct": obj.get("unattributed_pct")
+        })
+        return _obj
+
+

moolabs/models/attribution_signal_conflict_detail.py

@@ -0,0 +1,94 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionSignalConflictDetail(BaseModel):
+    """
+    AttributionSignalConflictDetail
+    """ # noqa: E501
+    code: StrictStr
+    __properties: ClassVar[List[str]] = ["code"]
+
+    @field_validator('code')
+    def code_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['duplicate_flush_sequence', 'daily_signal_capacity_exceeded']):
+            raise ValueError("must be one of enum values ('duplicate_flush_sequence', 'daily_signal_capacity_exceeded')")
+        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 AttributionSignalConflictDetail 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 AttributionSignalConflictDetail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "code": obj.get("code")
+        })
+        return _obj
+
+

moolabs/models/attribution_signal_conflict_response.py

@@ -0,0 +1,91 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from moolabs.models.attribution_signal_conflict_detail import AttributionSignalConflictDetail
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionSignalConflictResponse(BaseModel):
+    """
+    AttributionSignalConflictResponse
+    """ # noqa: E501
+    detail: AttributionSignalConflictDetail
+    __properties: ClassVar[List[str]] = ["detail"]
+
+    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 AttributionSignalConflictResponse 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 detail
+        if self.detail:
+            _dict['detail'] = self.detail.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AttributionSignalConflictResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "detail": AttributionSignalConflictDetail.from_dict(obj["detail"]) if obj.get("detail") is not None else None
+        })
+        return _obj
+
+

moolabs/models/attribution_signal_delta.py

@@ -0,0 +1,98 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionSignalDelta(BaseModel):
+    """
+    AttributionSignalDelta
+    """ # noqa: E501
+    customer_external_key: Annotated[str, Field(min_length=1, strict=True, max_length=256)]
+    feature_key: Annotated[str, Field(min_length=1, strict=True, max_length=256)]
+    route: Annotated[str, Field(min_length=1, strict=True, max_length=512)]
+    count: Annotated[int, Field(strict=True, ge=0)]
+    duration_ms_sum: Annotated[int, Field(strict=True, ge=0)]
+    bytes_out_sum: Annotated[int, Field(strict=True, ge=0)]
+    __properties: ClassVar[List[str]] = ["customer_external_key", "feature_key", "route", "count", "duration_ms_sum", "bytes_out_sum"]
+
+    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 AttributionSignalDelta 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 AttributionSignalDelta from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "customer_external_key": obj.get("customer_external_key"),
+            "feature_key": obj.get("feature_key"),
+            "route": obj.get("route"),
+            "count": obj.get("count"),
+            "duration_ms_sum": obj.get("duration_ms_sum"),
+            "bytes_out_sum": obj.get("bytes_out_sum")
+        })
+        return _obj
+
+

moolabs/models/attribution_signal_request.py

@@ -0,0 +1,123 @@
+# 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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from moolabs.models.attribution_signal_delta import AttributionSignalDelta
+from moolabs.models.sample_rate import SampleRate
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionSignalRequest(BaseModel):
+    """
+    AttributionSignalRequest
+    """ # noqa: E501
+    source: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=64)]] = 'http_request'
+    service: Annotated[str, Field(min_length=1, strict=True, max_length=128)]
+    pod_id: Annotated[str, Field(min_length=1, strict=True, max_length=128)]
+    pod_instance_id: StrictStr
+    flush_seq: Annotated[int, Field(le=-9223372036854775616, strict=True, ge=0)]
+    flush_id: StrictStr
+    window_start: datetime
+    window_seconds: Annotated[int, Field(le=86400, strict=True)]
+    sample_rate: SampleRate
+    attempted_count: Annotated[int, Field(le=-9223372036854775616, strict=True, ge=0)]
+    dropped_count: Annotated[int, Field(le=-9223372036854775616, strict=True, ge=0)]
+    deltas: Annotated[List[AttributionSignalDelta], Field(max_length=5000)]
+    __properties: ClassVar[List[str]] = ["source", "service", "pod_id", "pod_instance_id", "flush_seq", "flush_id", "window_start", "window_seconds", "sample_rate", "attempted_count", "dropped_count", "deltas"]
+
+    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 AttributionSignalRequest 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 sample_rate
+        if self.sample_rate:
+            _dict['sample_rate'] = self.sample_rate.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in deltas (list)
+        _items = []
+        if self.deltas:
+            for _item_deltas in self.deltas:
+                if _item_deltas:
+                    _items.append(_item_deltas.to_dict())
+            _dict['deltas'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AttributionSignalRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "source": obj.get("source") if obj.get("source") is not None else 'http_request',
+            "service": obj.get("service"),
+            "pod_id": obj.get("pod_id"),
+            "pod_instance_id": obj.get("pod_instance_id"),
+            "flush_seq": obj.get("flush_seq"),
+            "flush_id": obj.get("flush_id"),
+            "window_start": obj.get("window_start"),
+            "window_seconds": obj.get("window_seconds"),
+            "sample_rate": SampleRate.from_dict(obj["sample_rate"]) if obj.get("sample_rate") is not None else None,
+            "attempted_count": obj.get("attempted_count"),
+            "dropped_count": obj.get("dropped_count"),
+            "deltas": [AttributionSignalDelta.from_dict(_item) for _item in obj["deltas"]] if obj.get("deltas") is not None else None
+        })
+        return _obj
+
+

moolabs/models/attribution_signal_response.py

@@ -0,0 +1,96 @@
+# 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, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AttributionSignalResponse(BaseModel):
+    """
+    AttributionSignalResponse
+    """ # noqa: E501
+    status: StrictStr
+    duplicate: StrictBool
+    __properties: ClassVar[List[str]] = ["status", "duplicate"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['accepted', 'late']):
+            raise ValueError("must be one of enum values ('accepted', 'late')")
+        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 AttributionSignalResponse 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 AttributionSignalResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "status": obj.get("status"),
+            "duplicate": obj.get("duplicate")
+        })
+        return _obj
+
+