api-sdk-py 1.11.66__py3-none-any.whl

api_sdk_py/models/managed_user_usage.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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
+from api_sdk_py.models.managed_user_operation_usage import ManagedUserOperationUsage
+from api_sdk_py.models.managed_user_usage_totals import ManagedUserUsageTotals
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagedUserUsage(BaseModel):
+    """
+    What a managed user's editor sessions spent over a period. Only credits taken through editor sessions are counted, from the day usage was first recorded: what you spend with your API key is not, and neither is anything from before. 
+    """ # noqa: E501
+    managed_user_id: StrictStr = Field(alias="managedUserId")
+    managed_user_external_id: StrictStr = Field(description="Your own identifier for the managed user", alias="managedUserExternalId")
+    var_from: datetime = Field(description="Start of the period, included", alias="from")
+    to: datetime = Field(description="End of the period, not included")
+    totals: ManagedUserUsageTotals
+    operations: List[ManagedUserOperationUsage] = Field(description="One entry for each operation that was paid for in the period, in alphabetical order")
+    __properties: ClassVar[List[str]] = ["managedUserId", "managedUserExternalId", "from", "to", "totals", "operations"]
+
+    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 ManagedUserUsage 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 totals
+        if self.totals:
+            _dict['totals'] = self.totals.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in operations (list)
+        _items = []
+        if self.operations:
+            for _item_operations in self.operations:
+                if _item_operations:
+                    _items.append(_item_operations.to_dict())
+            _dict['operations'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ManagedUserUsage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "managedUserId": obj.get("managedUserId"),
+            "managedUserExternalId": obj.get("managedUserExternalId"),
+            "from": obj.get("from"),
+            "to": obj.get("to"),
+            "totals": ManagedUserUsageTotals.from_dict(obj["totals"]) if obj.get("totals") is not None else None,
+            "operations": [ManagedUserOperationUsage.from_dict(_item) for _item in obj["operations"]] if obj.get("operations") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/managed_user_usage_response.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from api_sdk_py.models.managed_user_usage import ManagedUserUsage
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagedUserUsageResponse(BaseModel):
+    """
+    ManagedUserUsageResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: ManagedUserUsage
+    meta: Optional[ResponseMeta] = None
+    __properties: ClassVar[List[str]] = ["success", "data", "meta"]
+
+    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 ManagedUserUsageResponse 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ManagedUserUsageResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "success": obj.get("success"),
+            "data": ManagedUserUsage.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "meta": ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/managed_user_usage_totals.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagedUserUsageTotals(BaseModel):
+    """
+    All operations together
+    """ # noqa: E501
+    calls: StrictInt
+    credits: StrictInt
+    refunded_calls: StrictInt = Field(alias="refundedCalls")
+    refunded_credits: StrictInt = Field(alias="refundedCredits")
+    __properties: ClassVar[List[str]] = ["calls", "credits", "refundedCalls", "refundedCredits"]
+
+    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 ManagedUserUsageTotals 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 ManagedUserUsageTotals from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "calls": obj.get("calls"),
+            "credits": obj.get("credits"),
+            "refundedCalls": obj.get("refundedCalls"),
+            "refundedCredits": obj.get("refundedCredits")
+        })
+        return _obj
+
+

api_sdk_py/models/my_partner.py

@@ -0,0 +1,136 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MyPartner(BaseModel):
+    """
+    A partner as the person who administers it reads it: which partner it is, what standing it is in, and why it is paused when it is. The webhook address, its secret and the billing settings have their own routes and are not part of it. 
+    """ # noqa: E501
+    id: StrictStr = Field(description="The id every other partner route asks for (`/partners/{partnerId}/...`)")
+    name: StrictStr
+    status: StrictStr = Field(description="`active` while the partner is in force. `inactive` until Widgetic activates it (and after a deactivation). `suspended` while it is paused, which is done by hand and comes back when Widgetic resumes it. ")
+    contact_email: Optional[StrictStr] = Field(default=None, alias="contactEmail")
+    allowed_domains: List[StrictStr] = Field(description="The domains Widgetic added to the embeds of this partner's customers. The domains the person added themselves are on the domains route of the account. ", alias="allowedDomains")
+    platform_domain: Optional[StrictStr] = Field(description="The website where the partner integrates Widgetic, as a bare name. It and every subdomain of it (`app.acme.com`, `learn.eu.acme.com`) can always show the partner's widgets, the ones its customers make through it included, and send entries to them, whatever `allowedDomains` and the account's own domain list say, so a list can never lock the partner's own website out. It is not an entry of `allowedDomains`, and it does not turn an empty list into a restriction: a partner that lists nothing stays unrestricted for every website. Widgetic sets it when the partner is set up; contact Widgetic to change it. `null` when none has been set. ", alias="platformDomain")
+    suspended_at: Optional[datetime] = Field(description="When the partner was paused; null unless it is paused now", alias="suspendedAt")
+    suspension_reason: Optional[StrictStr] = Field(description="The reason given when the partner was paused, as the partner is told it; null unless it is paused now", alias="suspensionReason")
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    __properties: ClassVar[List[str]] = ["id", "name", "status", "contactEmail", "allowedDomains", "platformDomain", "suspendedAt", "suspensionReason", "createdAt"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['active', 'inactive', 'suspended']):
+            raise ValueError("must be one of enum values ('active', 'inactive', 'suspended')")
+        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 MyPartner 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,
+        )
+        # set to None if contact_email (nullable) is None
+        # and model_fields_set contains the field
+        if self.contact_email is None and "contact_email" in self.model_fields_set:
+            _dict['contactEmail'] = None
+
+        # set to None if platform_domain (nullable) is None
+        # and model_fields_set contains the field
+        if self.platform_domain is None and "platform_domain" in self.model_fields_set:
+            _dict['platformDomain'] = None
+
+        # set to None if suspended_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.suspended_at is None and "suspended_at" in self.model_fields_set:
+            _dict['suspendedAt'] = None
+
+        # set to None if suspension_reason (nullable) is None
+        # and model_fields_set contains the field
+        if self.suspension_reason is None and "suspension_reason" in self.model_fields_set:
+            _dict['suspensionReason'] = None
+
+        # set to None if created_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.created_at is None and "created_at" in self.model_fields_set:
+            _dict['createdAt'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MyPartner 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"),
+            "name": obj.get("name"),
+            "status": obj.get("status"),
+            "contactEmail": obj.get("contactEmail"),
+            "allowedDomains": obj.get("allowedDomains"),
+            "platformDomain": obj.get("platformDomain"),
+            "suspendedAt": obj.get("suspendedAt"),
+            "suspensionReason": obj.get("suspensionReason"),
+            "createdAt": obj.get("createdAt")
+        })
+        return _obj
+
+

api_sdk_py/models/my_partners.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from api_sdk_py.models.my_partner import MyPartner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MyPartners(BaseModel):
+    """
+    MyPartners
+    """ # noqa: E501
+    standing: StrictStr = Field(description="The standing of the account as a whole, the word every gate reads: `not_a_partner` when the account administers no partner; otherwise `active` when any of its partners is in force, else `payment_arrears` when the partners that are active each have a contract invoice that is past its due date and unpaid, else `suspended` when any is paused, else `inactive`. `payment_arrears` is not set by anybody: it stops the same things a pause stops (billing, invoices, credits and the other routes a partner needs to pay stay open) and ends by itself the moment the invoice is paid. ")
+    overdue_since: Optional[datetime] = Field(description="When the oldest overdue contract invoice was due; null unless `standing` is `payment_arrears`. Pay the invoices in the list of `GET /invoices/partner/{partnerId}` that are past their due date to end it. ", alias="overdueSince")
+    partners: List[MyPartner] = Field(description="The partners the account administers (nearly always one), the oldest first")
+    __properties: ClassVar[List[str]] = ["standing", "overdueSince", "partners"]
+
+    @field_validator('standing')
+    def standing_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['not_a_partner', 'inactive', 'active', 'suspended', 'payment_arrears']):
+            raise ValueError("must be one of enum values ('not_a_partner', 'inactive', 'active', 'suspended', 'payment_arrears')")
+        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 MyPartners 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 partners (list)
+        _items = []
+        if self.partners:
+            for _item_partners in self.partners:
+                if _item_partners:
+                    _items.append(_item_partners.to_dict())
+            _dict['partners'] = _items
+        # set to None if overdue_since (nullable) is None
+        # and model_fields_set contains the field
+        if self.overdue_since is None and "overdue_since" in self.model_fields_set:
+            _dict['overdueSince'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MyPartners from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "standing": obj.get("standing"),
+            "overdueSince": obj.get("overdueSince"),
+            "partners": [MyPartner.from_dict(_item) for _item in obj["partners"]] if obj.get("partners") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/my_partners_response.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from api_sdk_py.models.my_partners import MyPartners
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MyPartnersResponse(BaseModel):
+    """
+    MyPartnersResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: MyPartners
+    meta: Optional[ResponseMeta] = None
+    __properties: ClassVar[List[str]] = ["success", "data", "meta"]
+
+    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 MyPartnersResponse 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MyPartnersResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "success": obj.get("success"),
+            "data": MyPartners.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "meta": ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+