pingram-python 0.1.0__py3-none-any.whl

pingram/models/get_email_components_response_inner.py

@@ -0,0 +1,120 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List
+from pingram.models.email_component_response_referenced_by_inner import EmailComponentResponseReferencedByInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetEmailComponentsResponseInner(BaseModel):
+    """
+    GetEmailComponentsResponseInner
+    """ # noqa: E501
+    env_id: StrictStr = Field(alias="envId")
+    component_id: StrictStr = Field(alias="componentId")
+    name: StrictStr
+    internal: StrictStr
+    internal_page: StrictStr = Field(alias="internalPage")
+    html: StrictStr
+    created_at: StrictStr = Field(alias="createdAt")
+    modified_at: StrictStr = Field(alias="modifiedAt")
+    referenced_by: List[EmailComponentResponseReferencedByInner] = Field(alias="referencedBy")
+    channel: StrictStr
+    __properties: ClassVar[List[str]] = ["envId", "componentId", "name", "internal", "internalPage", "html", "createdAt", "modifiedAt", "referencedBy", "channel"]
+
+    @field_validator('channel')
+    def channel_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['EMAIL']):
+            raise ValueError("must be one of enum values ('EMAIL')")
+        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 GetEmailComponentsResponseInner 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 referenced_by (list)
+        _items = []
+        if self.referenced_by:
+            for _item_referenced_by in self.referenced_by:
+                if _item_referenced_by:
+                    _items.append(_item_referenced_by.to_dict())
+            _dict['referencedBy'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetEmailComponentsResponseInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "envId": obj.get("envId"),
+            "componentId": obj.get("componentId"),
+            "name": obj.get("name"),
+            "internal": obj.get("internal"),
+            "internalPage": obj.get("internalPage"),
+            "html": obj.get("html"),
+            "createdAt": obj.get("createdAt"),
+            "modifiedAt": obj.get("modifiedAt"),
+            "referencedBy": [EmailComponentResponseReferencedByInner.from_dict(_item) for _item in obj["referencedBy"]] if obj.get("referencedBy") is not None else None,
+            "channel": obj.get("channel")
+        })
+        return _obj
+
+

pingram/models/get_environments_response_inner.py

@@ -0,0 +1,96 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List
+from pingram.models.channels_enum import ChannelsEnum
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetEnvironmentsResponseInner(BaseModel):
+    """
+    GetEnvironmentsResponseInner
+    """ # noqa: E501
+    client_id: StrictStr = Field(alias="clientId")
+    client_secret: StrictStr = Field(alias="clientSecret")
+    title: StrictStr
+    disable_sending: List[ChannelsEnum] = Field(alias="disableSending")
+    secure_mode: StrictBool = Field(alias="secureMode")
+    __properties: ClassVar[List[str]] = ["clientId", "clientSecret", "title", "disableSending", "secureMode"]
+
+    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 GetEnvironmentsResponseInner 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 GetEnvironmentsResponseInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "clientId": obj.get("clientId"),
+            "clientSecret": obj.get("clientSecret"),
+            "title": obj.get("title"),
+            "disableSending": obj.get("disableSending"),
+            "secureMode": obj.get("secureMode")
+        })
+        return _obj
+
+

pingram/models/get_inapp_notifications_response.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
+from typing import Any, ClassVar, Dict, List
+from pingram.models.get_inapp_notifications_response_notifications_inner import GetInappNotificationsResponseNotificationsInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetInappNotificationsResponse(BaseModel):
+    """
+    GetInappNotificationsResponse
+    """ # noqa: E501
+    notifications: List[GetInappNotificationsResponseNotificationsInner]
+    __properties: ClassVar[List[str]] = ["notifications"]
+
+    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 GetInappNotificationsResponse 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 notifications (list)
+        _items = []
+        if self.notifications:
+            for _item_notifications in self.notifications:
+                if _item_notifications:
+                    _items.append(_item_notifications.to_dict())
+            _dict['notifications'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetInappNotificationsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "notifications": [GetInappNotificationsResponseNotificationsInner.from_dict(_item) for _item in obj["notifications"]] if obj.get("notifications") is not None else None
+        })
+        return _obj
+
+

pingram/models/get_inapp_notifications_response_notifications_inner.py

@@ -0,0 +1,137 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.get_inapp_notifications_response_notifications_inner_delivery_options import GetInappNotificationsResponseNotificationsInnerDeliveryOptions
+from pingram.models.get_inapp_notifications_response_notifications_inner_replies_inner import GetInappNotificationsResponseNotificationsInnerRepliesInner
+from pingram.models.get_inapp_notifications_response_notifications_inner_template import GetInappNotificationsResponseNotificationsInnerTemplate
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetInappNotificationsResponseNotificationsInner(BaseModel):
+    """
+    GetInappNotificationsResponseNotificationsInner
+    """ # noqa: E501
+    id: StrictStr
+    notification_id: StrictStr = Field(alias="notificationId")
+    sub_notification_id: Optional[StrictStr] = Field(default=None, alias="subNotificationId")
+    seen: StrictBool
+    title: StrictStr
+    redirect_url: Optional[StrictStr] = Field(default=None, alias="redirectURL")
+    image_url: Optional[StrictStr] = Field(default=None, alias="imageURL")
+    delivery_options: Optional[GetInappNotificationsResponseNotificationsInnerDeliveryOptions] = Field(default=None, alias="deliveryOptions")
+    template: Optional[GetInappNotificationsResponseNotificationsInnerTemplate] = None
+    parameters: Optional[Dict[str, Any]] = None
+    var_date: StrictStr = Field(alias="date")
+    opened: Optional[StrictStr] = None
+    clicked: Optional[StrictStr] = None
+    archived: Optional[StrictStr] = None
+    actioned1: Optional[StrictStr] = None
+    actioned2: Optional[StrictStr] = None
+    replies: Optional[List[GetInappNotificationsResponseNotificationsInnerRepliesInner]] = None
+    exp_date: Optional[StrictStr] = Field(default=None, alias="expDate")
+    __properties: ClassVar[List[str]] = ["id", "notificationId", "subNotificationId", "seen", "title", "redirectURL", "imageURL", "deliveryOptions", "template", "parameters", "date", "opened", "clicked", "archived", "actioned1", "actioned2", "replies", "expDate"]
+
+    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 GetInappNotificationsResponseNotificationsInner 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 delivery_options
+        if self.delivery_options:
+            _dict['deliveryOptions'] = self.delivery_options.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of template
+        if self.template:
+            _dict['template'] = self.template.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in replies (list)
+        _items = []
+        if self.replies:
+            for _item_replies in self.replies:
+                if _item_replies:
+                    _items.append(_item_replies.to_dict())
+            _dict['replies'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetInappNotificationsResponseNotificationsInner 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"),
+            "notificationId": obj.get("notificationId"),
+            "subNotificationId": obj.get("subNotificationId"),
+            "seen": obj.get("seen"),
+            "title": obj.get("title"),
+            "redirectURL": obj.get("redirectURL"),
+            "imageURL": obj.get("imageURL"),
+            "deliveryOptions": GetInappNotificationsResponseNotificationsInnerDeliveryOptions.from_dict(obj["deliveryOptions"]) if obj.get("deliveryOptions") is not None else None,
+            "template": GetInappNotificationsResponseNotificationsInnerTemplate.from_dict(obj["template"]) if obj.get("template") is not None else None,
+            "parameters": obj.get("parameters"),
+            "date": obj.get("date"),
+            "opened": obj.get("opened"),
+            "clicked": obj.get("clicked"),
+            "archived": obj.get("archived"),
+            "actioned1": obj.get("actioned1"),
+            "actioned2": obj.get("actioned2"),
+            "replies": [GetInappNotificationsResponseNotificationsInnerRepliesInner.from_dict(_item) for _item in obj["replies"]] if obj.get("replies") is not None else None,
+            "expDate": obj.get("expDate")
+        })
+        return _obj
+
+

pingram/models/get_inapp_notifications_response_notifications_inner_delivery_options.py

@@ -0,0 +1,106 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.get_inapp_notifications_response_notifications_inner_delivery_options_instant import GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant
+from pingram.models.get_inapp_notifications_response_notifications_inner_delivery_options_off import GetInappNotificationsResponseNotificationsInnerDeliveryOptionsOff
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetInappNotificationsResponseNotificationsInnerDeliveryOptions(BaseModel):
+    """
+    GetInappNotificationsResponseNotificationsInnerDeliveryOptions
+    """ # noqa: E501
+    default_delivery_option: StrictStr = Field(alias="defaultDeliveryOption")
+    off: Optional[GetInappNotificationsResponseNotificationsInnerDeliveryOptionsOff] = None
+    instant: Optional[GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant] = None
+    __properties: ClassVar[List[str]] = ["defaultDeliveryOption", "off", "instant"]
+
+    @field_validator('default_delivery_option')
+    def default_delivery_option_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['off', 'instant']):
+            raise ValueError("must be one of enum values ('off', 'instant')")
+        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 GetInappNotificationsResponseNotificationsInnerDeliveryOptions 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 off
+        if self.off:
+            _dict['off'] = self.off.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of instant
+        if self.instant:
+            _dict['instant'] = self.instant.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetInappNotificationsResponseNotificationsInnerDeliveryOptions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "defaultDeliveryOption": obj.get("defaultDeliveryOption"),
+            "off": GetInappNotificationsResponseNotificationsInnerDeliveryOptionsOff.from_dict(obj["off"]) if obj.get("off") is not None else None,
+            "instant": GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant.from_dict(obj["instant"]) if obj.get("instant") is not None else None
+        })
+        return _obj
+
+

pingram/models/get_inapp_notifications_response_notifications_inner_delivery_options_instant.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, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant(BaseModel):
+    """
+    GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant
+    """ # noqa: E501
+    enabled: StrictBool
+    batching: Optional[StrictBool] = None
+    batching_key: Optional[StrictStr] = Field(default=None, alias="batchingKey")
+    batching_window: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="batchingWindow")
+    __properties: ClassVar[List[str]] = ["enabled", "batching", "batchingKey", "batchingWindow"]
+
+    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 GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant 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 GetInappNotificationsResponseNotificationsInnerDeliveryOptionsInstant from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "enabled": obj.get("enabled"),
+            "batching": obj.get("batching"),
+            "batchingKey": obj.get("batchingKey"),
+            "batchingWindow": obj.get("batchingWindow")
+        })
+        return _obj
+
+