pingram-python 0.1.0__py3-none-any.whl

pingram/models/get_logs_response.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.get_logs_response_messages_inner import GetLogsResponseMessagesInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetLogsResponse(BaseModel):
+    """
+    GetLogsResponse
+    """ # noqa: E501
+    messages: List[GetLogsResponseMessagesInner]
+    next_cursor: Optional[StrictStr] = Field(default=None, alias="nextCursor")
+    __properties: ClassVar[List[str]] = ["messages", "nextCursor"]
+
+    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 GetLogsResponse 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 messages (list)
+        _items = []
+        if self.messages:
+            for _item_messages in self.messages:
+                if _item_messages:
+                    _items.append(_item_messages.to_dict())
+            _dict['messages'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetLogsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "messages": [GetLogsResponseMessagesInner.from_dict(_item) for _item in obj["messages"]] if obj.get("messages") is not None else None,
+            "nextCursor": obj.get("nextCursor")
+        })
+        return _obj
+
+

pingram/models/get_logs_response_messages_inner.py

@@ -0,0 +1,141 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from pingram.models.get_logs_response_messages_inner_attachments_inner import GetLogsResponseMessagesInnerAttachmentsInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetLogsResponseMessagesInner(BaseModel):
+    """
+    GetLogsResponseMessagesInner
+    """ # noqa: E501
+    tracking_id: StrictStr = Field(alias="trackingId")
+    event_type: StrictStr = Field(alias="eventType")
+    timestamp: StrictStr
+    epoch_ms: Union[StrictFloat, StrictInt] = Field(alias="epochMs")
+    inbox: Optional[StrictStr] = None
+    var_from: Optional[StrictStr] = Field(default=None, alias="from")
+    from_name: Optional[StrictStr] = Field(default=None, alias="fromName")
+    subject: Optional[StrictStr] = None
+    to: Optional[List[StrictStr]] = None
+    cc: Optional[List[StrictStr]] = None
+    bcc: Optional[List[StrictStr]] = None
+    reply_to: Optional[StrictStr] = Field(default=None, alias="replyTo")
+    body_text: Optional[StrictStr] = Field(default=None, alias="bodyText")
+    body_html: Optional[StrictStr] = Field(default=None, alias="bodyHtml")
+    attachments: Optional[List[GetLogsResponseMessagesInnerAttachmentsInner]] = None
+    message_id: Optional[StrictStr] = Field(default=None, alias="messageId")
+    in_reply_to: Optional[StrictStr] = Field(default=None, alias="inReplyTo")
+    references: Optional[StrictStr] = None
+    resolution_type: Optional[StrictStr] = Field(default=None, alias="resolutionType")
+    __properties: ClassVar[List[str]] = ["trackingId", "eventType", "timestamp", "epochMs", "inbox", "from", "fromName", "subject", "to", "cc", "bcc", "replyTo", "bodyText", "bodyHtml", "attachments", "messageId", "inReplyTo", "references", "resolutionType"]
+
+    @field_validator('resolution_type')
+    def resolution_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['reply', 'builtin', 'custom']):
+            raise ValueError("must be one of enum values ('reply', 'builtin', 'custom')")
+        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 GetLogsResponseMessagesInner 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 attachments (list)
+        _items = []
+        if self.attachments:
+            for _item_attachments in self.attachments:
+                if _item_attachments:
+                    _items.append(_item_attachments.to_dict())
+            _dict['attachments'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetLogsResponseMessagesInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "trackingId": obj.get("trackingId"),
+            "eventType": obj.get("eventType"),
+            "timestamp": obj.get("timestamp"),
+            "epochMs": obj.get("epochMs"),
+            "inbox": obj.get("inbox"),
+            "from": obj.get("from"),
+            "fromName": obj.get("fromName"),
+            "subject": obj.get("subject"),
+            "to": obj.get("to"),
+            "cc": obj.get("cc"),
+            "bcc": obj.get("bcc"),
+            "replyTo": obj.get("replyTo"),
+            "bodyText": obj.get("bodyText"),
+            "bodyHtml": obj.get("bodyHtml"),
+            "attachments": [GetLogsResponseMessagesInnerAttachmentsInner.from_dict(_item) for _item in obj["attachments"]] if obj.get("attachments") is not None else None,
+            "messageId": obj.get("messageId"),
+            "inReplyTo": obj.get("inReplyTo"),
+            "references": obj.get("references"),
+            "resolutionType": obj.get("resolutionType")
+        })
+        return _obj
+
+

pingram/models/get_logs_response_messages_inner_attachments_inner.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetLogsResponseMessagesInnerAttachmentsInner(BaseModel):
+    """
+    GetLogsResponseMessagesInnerAttachmentsInner
+    """ # noqa: E501
+    filename: StrictStr
+    content_type: StrictStr = Field(alias="contentType")
+    size: Union[StrictFloat, StrictInt]
+    content_id: Optional[StrictStr] = Field(default=None, alias="contentId")
+    __properties: ClassVar[List[str]] = ["filename", "contentType", "size", "contentId"]
+
+    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 GetLogsResponseMessagesInnerAttachmentsInner 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 GetLogsResponseMessagesInnerAttachmentsInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "filename": obj.get("filename"),
+            "contentType": obj.get("contentType"),
+            "size": obj.get("size"),
+            "contentId": obj.get("contentId")
+        })
+        return _obj
+
+

pingram/models/get_members_response_inner.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetMembersResponseInner(BaseModel):
+    """
+    GetMembersResponseInner
+    """ # noqa: E501
+    account_id: StrictStr = Field(alias="accountId")
+    user_id: StrictStr = Field(alias="userId")
+    created_at: StrictStr = Field(alias="createdAt")
+    email: Optional[StrictStr] = None
+    groups: Optional[List[StrictStr]] = None
+    __properties: ClassVar[List[str]] = ["accountId", "userId", "createdAt", "email", "groups"]
+
+    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 GetMembersResponseInner 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 GetMembersResponseInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "accountId": obj.get("accountId"),
+            "userId": obj.get("userId"),
+            "createdAt": obj.get("createdAt"),
+            "email": obj.get("email"),
+            "groups": obj.get("groups")
+        })
+        return _obj
+
+

pingram/models/get_metrics_response_inner.py

@@ -0,0 +1,116 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from pingram.models.get_metrics_response_inner_messages_inner import GetMetricsResponseInnerMessagesInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetMetricsResponseInner(BaseModel):
+    """
+    <p>A <code>GetMetricData</code> call returns an array of <code>MetricDataResult</code>             structures. Each of these structures includes the data points for that metric, along             with the timestamps of those data points and other identifying information.</p>
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="<p>The short name you specified to represent this metric.</p>", alias="Id")
+    label: Optional[StrictStr] = Field(default=None, description="<p>The human-readable label associated with the data.</p>", alias="Label")
+    timestamps: Optional[List[datetime]] = Field(default=None, description="<p>The timestamps for the data points, formatted in Unix timestamp format. The number of             timestamps always matches the number of values and the value for Timestamps[x] is             Values[x].</p>", alias="Timestamps")
+    values: Optional[List[Union[StrictFloat, StrictInt]]] = Field(default=None, description="<p>The data points for the metric corresponding to <code>Timestamps</code>. The number of             values always matches the number of timestamps and the timestamp for Values[x] is             Timestamps[x].</p>", alias="Values")
+    status_code: Optional[StrictStr] = Field(default=None, alias="StatusCode")
+    messages: Optional[List[GetMetricsResponseInnerMessagesInner]] = Field(default=None, description="<p>A list of messages with additional information about the data returned.</p>", alias="Messages")
+    __properties: ClassVar[List[str]] = ["Id", "Label", "Timestamps", "Values", "StatusCode", "Messages"]
+
+    @field_validator('status_code')
+    def status_code_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['Complete', 'Forbidden', 'InternalError', 'PartialData']):
+            raise ValueError("must be one of enum values ('Complete', 'Forbidden', 'InternalError', 'PartialData')")
+        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 GetMetricsResponseInner 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 messages (list)
+        _items = []
+        if self.messages:
+            for _item_messages in self.messages:
+                if _item_messages:
+                    _items.append(_item_messages.to_dict())
+            _dict['Messages'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetMetricsResponseInner 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"),
+            "Label": obj.get("Label"),
+            "Timestamps": obj.get("Timestamps"),
+            "Values": obj.get("Values"),
+            "StatusCode": obj.get("StatusCode"),
+            "Messages": [GetMetricsResponseInnerMessagesInner.from_dict(_item) for _item in obj["Messages"]] if obj.get("Messages") is not None else None
+        })
+        return _obj
+
+

pingram/models/get_metrics_response_inner_messages_inner.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetMetricsResponseInnerMessagesInner(BaseModel):
+    """
+    <p>A message returned by the <code>GetMetricData</code>API, including a code and a             description.</p>          <p>If a cross-Region <code>GetMetricData</code> operation fails with a code of             <code>Forbidden</code> and a value of <code>Authentication too complex to retrieve                 cross region data</code>, you can correct the problem by running the             <code>GetMetricData</code> operation in the same Region where the metric data             is.</p>
+    """ # noqa: E501
+    code: Optional[StrictStr] = Field(default=None, description="<p>The error code or status code associated with the message.</p>", alias="Code")
+    value: Optional[StrictStr] = Field(default=None, description="<p>The message text.</p>", alias="Value")
+    __properties: ClassVar[List[str]] = ["Code", "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 GetMetricsResponseInnerMessagesInner 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 GetMetricsResponseInnerMessagesInner 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"),
+            "Value": obj.get("Value")
+        })
+        return _obj
+
+