pingram-python 0.1.0__py3-none-any.whl

pingram/models/user.py

@@ -0,0 +1,133 @@
+# 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_users_response_users_inner_email_suppression_status import GetUsersResponseUsersInnerEmailSuppressionStatus
+from pingram.models.get_users_response_users_inner_push_tokens_inner import GetUsersResponseUsersInnerPushTokensInner
+from pingram.models.get_users_response_users_inner_slack_token import GetUsersResponseUsersInnerSlackToken
+from pingram.models.get_users_response_users_inner_web_push_tokens_inner import GetUsersResponseUsersInnerWebPushTokensInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class User(BaseModel):
+    """
+    User
+    """ # noqa: E501
+    id: StrictStr
+    email: Optional[StrictStr] = None
+    number: Optional[StrictStr] = None
+    push_tokens: Optional[List[GetUsersResponseUsersInnerPushTokensInner]] = Field(default=None, alias="pushTokens")
+    web_push_tokens: Optional[List[GetUsersResponseUsersInnerWebPushTokensInner]] = Field(default=None, alias="webPushTokens")
+    timezone: Optional[StrictStr] = None
+    slack_channel: Optional[StrictStr] = Field(default=None, description="The destination channel of slack notifications sent to this user. Can be either of the following: - Channel name, e.g. \"test\" - Channel name with # prefix, e.g. \"#test\" - Channel ID, e.g. \"C1234567890\" - User ID for DM, e.g. \"U1234567890\" - Username with @ prefix, e.g. \"@test\"", alias="slackChannel")
+    slack_token: Optional[GetUsersResponseUsersInnerSlackToken] = Field(default=None, alias="slackToken")
+    last_seen_time: Optional[StrictStr] = Field(default=None, alias="lastSeenTime")
+    updated_at: Optional[StrictStr] = Field(default=None, alias="updatedAt")
+    created_at: Optional[StrictStr] = Field(default=None, alias="createdAt")
+    email_suppression_status: Optional[GetUsersResponseUsersInnerEmailSuppressionStatus] = Field(default=None, alias="emailSuppressionStatus")
+    __properties: ClassVar[List[str]] = ["id", "email", "number", "pushTokens", "webPushTokens", "timezone", "slackChannel", "slackToken", "lastSeenTime", "updatedAt", "createdAt", "emailSuppressionStatus"]
+
+    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 User 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 push_tokens (list)
+        _items = []
+        if self.push_tokens:
+            for _item_push_tokens in self.push_tokens:
+                if _item_push_tokens:
+                    _items.append(_item_push_tokens.to_dict())
+            _dict['pushTokens'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in web_push_tokens (list)
+        _items = []
+        if self.web_push_tokens:
+            for _item_web_push_tokens in self.web_push_tokens:
+                if _item_web_push_tokens:
+                    _items.append(_item_web_push_tokens.to_dict())
+            _dict['webPushTokens'] = _items
+        # override the default output from pydantic by calling `to_dict()` of slack_token
+        if self.slack_token:
+            _dict['slackToken'] = self.slack_token.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of email_suppression_status
+        if self.email_suppression_status:
+            _dict['emailSuppressionStatus'] = self.email_suppression_status.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of User 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"),
+            "email": obj.get("email"),
+            "number": obj.get("number"),
+            "pushTokens": [GetUsersResponseUsersInnerPushTokensInner.from_dict(_item) for _item in obj["pushTokens"]] if obj.get("pushTokens") is not None else None,
+            "webPushTokens": [GetUsersResponseUsersInnerWebPushTokensInner.from_dict(_item) for _item in obj["webPushTokens"]] if obj.get("webPushTokens") is not None else None,
+            "timezone": obj.get("timezone"),
+            "slackChannel": obj.get("slackChannel"),
+            "slackToken": GetUsersResponseUsersInnerSlackToken.from_dict(obj["slackToken"]) if obj.get("slackToken") is not None else None,
+            "lastSeenTime": obj.get("lastSeenTime"),
+            "updatedAt": obj.get("updatedAt"),
+            "createdAt": obj.get("createdAt"),
+            "emailSuppressionStatus": GetUsersResponseUsersInnerEmailSuppressionStatus.from_dict(obj["emailSuppressionStatus"]) if obj.get("emailSuppressionStatus") is not None else None
+        })
+        return _obj
+
+

pingram/models/user_suppression_delete_response.py

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

pingram/models/webhook_response.py

@@ -0,0 +1,104 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WebhookResponse(BaseModel):
+    """
+    WebhookResponse
+    """ # noqa: E501
+    success: StrictBool
+    message: Optional[StrictStr] = None
+    topic: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["success", "message", "topic"]
+
+    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 WebhookResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WebhookResponse 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"),
+            "message": obj.get("message"),
+            "topic": obj.get("topic")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

pingram/rest.py

@@ -0,0 +1,199 @@
+# 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
+
+
+import io
+import json
+import re
+import ssl
+from typing import Optional, Union
+
+import httpx
+
+from pingram.exceptions import ApiException, ApiValueError
+
+RESTResponseType = httpx.Response
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status_code
+        self.reason = resp.reason_phrase
+        self.data = None
+
+    async def read(self):
+        if self.data is None:
+            self.data = await self.response.aread()
+        return self.data
+
+    @property
+    def headers(self):
+        """Returns a CIMultiDictProxy of response headers."""
+        return self.response.headers
+
+    def getheaders(self):
+        """Returns a CIMultiDictProxy of the response headers; use ``headers`` instead."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header; use ``headers`` instead."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+    def __init__(self, configuration) -> None:
+
+        # maxsize is number of requests to host that are allowed in parallel
+        self.maxsize = configuration.connection_pool_maxsize
+
+        self.ssl_context = ssl.create_default_context(
+            cafile=configuration.ssl_ca_cert,
+            cadata=configuration.ca_cert_data,
+        )
+        if configuration.cert_file:
+            self.ssl_context.load_cert_chain(
+                configuration.cert_file, keyfile=configuration.key_file
+            )
+
+        if not configuration.verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+        self.proxy = configuration.proxy
+        self.proxy_headers = configuration.proxy_headers
+
+        self.pool_manager: Optional[httpx.AsyncClient] = None
+
+    async def close(self):
+        if self.pool_manager is not None:
+            await self.pool_manager.aclose()
+
+    async def request(
+            self,
+            method,
+            url,
+            headers=None,
+            body=None,
+            post_params=None,
+            _request_timeout=None):
+        """Execute request
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        """
+        method = method.upper()
+        assert method in [
+            'GET',
+            'HEAD',
+            'DELETE',
+            'POST',
+            'PUT',
+            'PATCH',
+            'OPTIONS'
+        ]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter."
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+        timeout = _request_timeout or 5 * 60
+
+        if 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/json'
+
+        args = {
+            "method": method,
+            "url": url,
+            "timeout": timeout,
+            "headers": headers
+        }
+
+        # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+        if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+            if re.search('json', headers['Content-Type'], re.IGNORECASE):
+                if body is not None:
+                    args["json"] = body
+            elif headers['Content-Type'] == 'application/x-www-form-urlencoded':  # noqa: E501
+                args["data"] = dict(post_params)
+            elif headers['Content-Type'] == 'multipart/form-data':
+                # must del headers['Content-Type'], or the correct
+                # Content-Type which generated by httpx
+                del headers['Content-Type']
+
+                files = []
+                data = {}
+                for param in post_params:
+                    k, v = param
+                    if isinstance(v, tuple) and len(v) == 3:
+                        files.append((k, v))
+                    else:
+                        # Ensures that dict objects are serialized
+                        if isinstance(v, dict):
+                            v = json.dumps(v)
+                        elif isinstance(v, int):
+                            v = str(v)
+                        data[k] = v
+
+                if files:
+                    args["files"] = files
+                if data:
+                    args["data"] = data
+
+            # Pass a `bytes` parameter directly in the body to support
+            # other content types than Json when `body` argument is provided
+            # in serialized form
+            elif isinstance(body, str) or isinstance(body, bytes):
+                args["data"] = body
+            else:
+                # Cannot generate the request from given parameters
+                msg = """Cannot prepare a request message for provided
+                         arguments. Please check that your arguments match
+                         declared content type."""
+                raise ApiException(status=0, reason=msg)
+
+        if self.pool_manager is None:
+            self.pool_manager = self._create_pool_manager()
+
+        r = await self.pool_manager.request(**args)
+        return RESTResponse(r)
+
+    def _create_pool_manager(self) -> httpx.AsyncClient:
+        limits = httpx.Limits(max_connections=self.maxsize)
+
+        proxy = None
+        if self.proxy:
+            proxy = httpx.Proxy(
+                url=self.proxy,
+                headers=self.proxy_headers
+            )
+
+        return httpx.AsyncClient(
+            limits=limits,
+            proxy=proxy,
+            verify=self.ssl_context,
+            trust_env=True
+        )

pingram_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: pingram-python
+Version: 0.1.0
+Summary: Official Python SDK for Pingram - Send notifications via Email, SMS, Push, In-App, and more
+Author: Pingram
+License: MIT
+Project-URL: Repository, https://github.com/notificationapi-com/serverless
+Keywords: pingram,notificationapi,notification,sdk,email,sms,push,in-app
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.7.1
+Dynamic: license-file
+
+# Pingram Python SDK
+
+Official Python SDK for Pingram. Send notifications via Email, SMS, Push, In-App, and more from your server-side Python code.
+
+## Requirements
+
+- Python 3.9+
+- Dependencies: `httpx`, `pydantic`, `python-dateutil`, `typing-extensions` (installed automatically)
+
+## Installation
+
+```bash
+pip install pingram-python
+```
+
+To install from source (e.g. from the [GitHub repo](https://github.com/notificationapi-com/serverless)):
+
+```bash
+pip install -e sdks/python
+```
+
+## Quick start
+
+Use the **Pingram** client with your **API key**, then call `send()` or the namespaced APIs (`user`, `users`, `logs`, etc.).
+
+```python
+import asyncio
+from pingram import Pingram, SenderPostBody, SenderPostBodyTo
+
+async def main():
+    # API key (e.g. pingram_sk_...) or JWT; optional region ("us" | "eu" | "ca")
+    async with Pingram(api_key="pingram_sk_...") as client:
+        # Send a notification
+        body = SenderPostBody(
+            notification_id="your_notification_id",
+            to=SenderPostBodyTo(id="user_123"),
+        )
+        response = await client.send(sender_post_body=body)
+        print(response)
+
+        # Or use namespaced APIs (same as Node: client.user, client.users, client.logs, ...)
+        # user = await client.user.user_get_user(account_id="...", user_id="...")
+        # logs = await client.logs.logs_query_logs(...)
+
+asyncio.run(main())
+```
+
+You can also pass a config dict: `Pingram({"api_key": "pingram_sk_...", "region": "eu"})`. For full API coverage, use `client.send`, `client.user`, `client.users`, `client.logs`, `client.templates`, `client.environments`, and the other APIs.
+
+## Links
+
+- [Documentation](https://www.pingram.io/docs/)