customerio 3.0.0__py3-none-any.whl

customerio/__init__.py

@@ -0,0 +1,23 @@
+from customerio.api import (
+    APIClient,
+    SendEmailRequest,
+    SendInAppRequest,
+    SendInboxMessageRequest,
+    SendPushRequest,
+    SendSMSRequest,
+)
+from customerio.client_base import CustomerIOException
+from customerio.regions import Regions
+from customerio.track import CustomerIO
+
+__all__ = [
+    "APIClient",
+    "CustomerIO",
+    "CustomerIOException",
+    "Regions",
+    "SendEmailRequest",
+    "SendInAppRequest",
+    "SendInboxMessageRequest",
+    "SendPushRequest",
+    "SendSMSRequest",
+]

customerio/__version__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

customerio/api.py

@@ -0,0 +1,328 @@
+"""
+Implements the client that interacts with Customer.io's App API using app keys.
+"""
+
+import base64
+
+from .client_base import ClientBase, CustomerIOException
+from .regions import Region, Regions
+
+
+def _payload_from_fields(source, field_map):
+    return {
+        name: value
+        for field, name in field_map.items()
+        if (value := getattr(source, field, None)) is not None
+    }
+
+
+COMMON_MESSAGE_FIELD_MAP = {
+    "transactional_message_id": "transactional_message_id",
+    "identifiers": "identifiers",
+    "disable_message_retention": "disable_message_retention",
+    "queue_draft": "queue_draft",
+    "message_data": "message_data",
+    "send_at": "send_at",
+    "language": "language",
+}
+
+EMAIL_FIELD_MAP = COMMON_MESSAGE_FIELD_MAP | {
+    # from is a reserved keyword, so the object field is `_from`.
+    "_from": "from",
+    "to": "to",
+    "headers": "headers",
+    "reply_to": "reply_to",
+    "bcc": "bcc",
+    "subject": "subject",
+    "preheader": "preheader",
+    "body": "body",
+    "body_plain": "body_plain",
+    "body_amp": "body_amp",
+    "fake_bcc": "fake_bcc",
+    "send_to_unsubscribed": "send_to_unsubscribed",
+    "tracked": "tracked",
+    "attachments": "attachments",
+    "disable_css_preprocessing": "disable_css_preprocessing",
+}
+
+PUSH_FIELD_MAP = COMMON_MESSAGE_FIELD_MAP | {
+    "to": "to",
+    "send_to_unsubscribed": "send_to_unsubscribed",
+    "title": "title",
+    "message": "message",
+    "image_url": "image_url",
+    "link": "link",
+    "custom_data": "custom_data",
+    "custom_payload": "custom_payload",
+    "device": "custom_device",
+    "sound": "sound",
+}
+
+SMS_FIELD_MAP = COMMON_MESSAGE_FIELD_MAP | {
+    "to": "to",
+    "send_to_unsubscribed": "send_to_unsubscribed",
+}
+
+INBOX_FIELD_MAP = COMMON_MESSAGE_FIELD_MAP
+IN_APP_FIELD_MAP = COMMON_MESSAGE_FIELD_MAP
+
+
+class APIClient(ClientBase):
+    def __init__(
+        self,
+        key,
+        url=None,
+        region=Regions.US,
+        retries=3,
+        timeout=10,
+        backoff_factor=0.02,
+        use_connection_pooling=True,
+    ):
+        if not isinstance(region, Region):
+            raise CustomerIOException("invalid region provided")
+
+        self.key = key
+        self.url = url or f"https://{region.api_host}"
+        super().__init__(
+            retries=retries,
+            timeout=timeout,
+            backoff_factor=backoff_factor,
+            use_connection_pooling=use_connection_pooling,
+        )
+
+    def send_email(self, request):
+        if isinstance(request, SendEmailRequest):
+            request = request._to_dict()
+        resp = self.send_request("POST", self.url + "/v1/send/email", request)
+        return resp.json()
+
+    def send_push(self, request):
+        if isinstance(request, SendPushRequest):
+            request = request._to_dict()
+        resp = self.send_request("POST", self.url + "/v1/send/push", request)
+        return resp.json()
+
+    def send_sms(self, request):
+        if isinstance(request, SendSMSRequest):
+            request = request._to_dict()
+        resp = self.send_request("POST", self.url + "/v1/send/sms", request)
+        return resp.json()
+
+    def send_inbox_message(self, request):
+        if isinstance(request, SendInboxMessageRequest):
+            request = request._to_dict()
+        resp = self.send_request("POST", self.url + "/v1/send/inbox_message", request)
+        return resp.json()
+
+    def send_in_app(self, request):
+        if isinstance(request, SendInAppRequest):
+            request = request._to_dict()
+        resp = self.send_request("POST", self.url + "/v1/send/in_app", request)
+        return resp.json()
+
+    def _build_session(self):
+        session = super()._build_session()
+        session.headers["Authorization"] = f"Bearer {self.key}"
+
+        return session
+
+
+class SendEmailRequest:
+    """An object with all the options available for triggering a transactional email message."""
+
+    def __init__(
+        self,
+        transactional_message_id=None,
+        to=None,
+        identifiers=None,
+        _from=None,
+        headers=None,
+        reply_to=None,
+        bcc=None,
+        subject=None,
+        preheader=None,
+        body=None,
+        body_plain=None,
+        body_amp=None,
+        fake_bcc=None,
+        disable_message_retention=None,
+        send_to_unsubscribed=None,
+        tracked=None,
+        queue_draft=None,
+        message_data=None,
+        attachments=None,
+        disable_css_preprocessing=None,
+        send_at=None,
+        language=None,
+    ):
+        self.transactional_message_id = transactional_message_id
+        self.to = to
+        self.identifiers = identifiers
+        self._from = _from
+        self.headers = headers
+        self.reply_to = reply_to
+        self.bcc = bcc
+        self.subject = subject
+        self.preheader = preheader
+        self.body = body
+        self.body_plain = body_plain
+        self.body_amp = body_amp
+        self.fake_bcc = fake_bcc
+        self.disable_message_retention = disable_message_retention
+        self.send_to_unsubscribed = send_to_unsubscribed
+        self.tracked = tracked
+        self.queue_draft = queue_draft
+        self.message_data = message_data
+        self.attachments = attachments
+        self.disable_css_preprocessing = disable_css_preprocessing
+        self.send_at = send_at
+        self.language = language
+
+    def attach(self, name, content, encode=True):
+        """Helper method to add base64-encoded attachments."""
+        if not self.attachments:
+            self.attachments = {}
+
+        if name in self.attachments:
+            raise CustomerIOException(f"attachment {name} already exists")
+
+        if encode:
+            if isinstance(content, str):
+                content = base64.b64encode(content.encode("utf-8")).decode()
+            else:
+                content = base64.b64encode(content).decode()
+
+        self.attachments[name] = content
+
+    def _to_dict(self):
+        """Build a request payload from the object."""
+        return _payload_from_fields(self, EMAIL_FIELD_MAP)
+
+
+class SendPushRequest:
+    """An object with all the options available for triggering a transactional push message."""
+
+    def __init__(
+        self,
+        transactional_message_id=None,
+        to=None,
+        identifiers=None,
+        title=None,
+        message=None,
+        disable_message_retention=None,
+        send_to_unsubscribed=None,
+        queue_draft=None,
+        message_data=None,
+        send_at=None,
+        language=None,
+        image_url=None,
+        link=None,
+        custom_data=None,
+        custom_payload=None,
+        device=None,
+        sound=None,
+    ):
+        self.transactional_message_id = transactional_message_id
+        self.to = to
+        self.identifiers = identifiers
+        self.disable_message_retention = disable_message_retention
+        self.send_to_unsubscribed = send_to_unsubscribed
+        self.queue_draft = queue_draft
+        self.message_data = message_data
+        self.send_at = send_at
+        self.language = language
+
+        self.title = title
+        self.message = message
+        self.image_url = image_url
+        self.link = link
+        self.custom_data = custom_data
+        self.custom_payload = custom_payload
+        self.device = device
+        self.sound = sound
+
+    def _to_dict(self):
+        """Build a request payload from the object."""
+        return _payload_from_fields(self, PUSH_FIELD_MAP)
+
+
+class SendSMSRequest:
+    """An object with all the options available for triggering a transactional SMS message."""
+
+    def __init__(
+        self,
+        transactional_message_id=None,
+        to=None,
+        identifiers=None,
+        disable_message_retention=None,
+        send_to_unsubscribed=None,
+        queue_draft=None,
+        message_data=None,
+        send_at=None,
+        language=None,
+    ):
+        self.transactional_message_id = transactional_message_id
+        self.to = to
+        self.identifiers = identifiers
+        self.disable_message_retention = disable_message_retention
+        self.send_to_unsubscribed = send_to_unsubscribed
+        self.queue_draft = queue_draft
+        self.message_data = message_data
+        self.send_at = send_at
+        self.language = language
+
+    def _to_dict(self):
+        """Build a request payload from the object."""
+        return _payload_from_fields(self, SMS_FIELD_MAP)
+
+
+class SendInboxMessageRequest:
+    """An object with all the options available for triggering a transactional inbox message."""
+
+    def __init__(
+        self,
+        transactional_message_id=None,
+        identifiers=None,
+        disable_message_retention=None,
+        queue_draft=None,
+        message_data=None,
+        send_at=None,
+        language=None,
+    ):
+        self.transactional_message_id = transactional_message_id
+        self.identifiers = identifiers
+        self.disable_message_retention = disable_message_retention
+        self.queue_draft = queue_draft
+        self.message_data = message_data
+        self.send_at = send_at
+        self.language = language
+
+    def _to_dict(self):
+        """Build a request payload from the object."""
+        return _payload_from_fields(self, INBOX_FIELD_MAP)
+
+
+class SendInAppRequest:
+    """An object with all the options available for triggering a transactional in-app message."""
+
+    def __init__(
+        self,
+        transactional_message_id=None,
+        identifiers=None,
+        disable_message_retention=None,
+        queue_draft=None,
+        message_data=None,
+        send_at=None,
+        language=None,
+    ):
+        self.transactional_message_id = transactional_message_id
+        self.identifiers = identifiers
+        self.disable_message_retention = disable_message_retention
+        self.queue_draft = queue_draft
+        self.message_data = message_data
+        self.send_at = send_at
+        self.language = language
+
+    def _to_dict(self):
+        """Build a request payload from the object."""
+        return _payload_from_fields(self, IN_APP_FIELD_MAP)

customerio/client_base.py

@@ -0,0 +1,151 @@
+"""
+Implements the base client that is used by other classes to make requests.
+"""
+
+import math
+import socket
+from datetime import datetime, timezone
+
+from requests import Session
+from requests.adapters import DEFAULT_POOLBLOCK, HTTPAdapter
+from urllib3.connection import HTTPConnection
+from urllib3.util.retry import Retry
+
+from .__version__ import __version__ as ClientVersion
+
+TCP_KEEPALIVE_IDLE_TIMEOUT = 300
+TCP_KEEPALIVE_INTERVAL = 60
+
+
+def _tcp_keepalive_socket_options():
+    tcp_protocol = getattr(socket, "SOL_TCP", socket.IPPROTO_TCP)
+    tcp_keepidle = getattr(socket, "TCP_KEEPIDLE", getattr(socket, "TCP_KEEPALIVE", None))
+
+    options = list(HTTPConnection.default_socket_options)
+    keepalive_options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)]
+    if tcp_keepidle is not None:
+        keepalive_options.append((tcp_protocol, tcp_keepidle, TCP_KEEPALIVE_IDLE_TIMEOUT))
+    if hasattr(socket, "TCP_KEEPINTVL"):
+        keepalive_options.append((tcp_protocol, socket.TCP_KEEPINTVL, TCP_KEEPALIVE_INTERVAL))
+
+    for option in keepalive_options:
+        if option not in options:
+            options.append(option)
+
+    return options
+
+
+class TCPKeepAliveHTTPAdapter(HTTPAdapter):
+    def init_poolmanager(self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs):
+        pool_kwargs.setdefault("socket_options", _tcp_keepalive_socket_options())
+        super().init_poolmanager(connections, maxsize, block=block, **pool_kwargs)
+
+    def proxy_manager_for(self, proxy, **proxy_kwargs):
+        proxy_kwargs.setdefault("socket_options", _tcp_keepalive_socket_options())
+        return super().proxy_manager_for(proxy, **proxy_kwargs)
+
+
+class CustomerIOException(Exception):
+    pass
+
+
+class ClientBase:
+    def __init__(self, retries=3, timeout=10, backoff_factor=0.02, use_connection_pooling=True):
+        self.timeout = timeout
+        self.retries = retries
+        self.backoff_factor = backoff_factor
+        self.use_connection_pooling = use_connection_pooling
+        self._current_session = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self):
+        if self._current_session is not None:
+            try:
+                self._current_session.close()
+            finally:
+                self._current_session = None
+
+    @property
+    def http(self):
+        if self._current_session is None:
+            self._current_session = self._build_session()
+
+        return self._current_session
+
+    def send_request(self, method, url, data):
+        """Dispatches the request and returns a response."""
+
+        try:
+            if self.use_connection_pooling:
+                response = self.http.request(
+                    method,
+                    url=url,
+                    json=self._sanitize(data),
+                    timeout=self.timeout,
+                )
+            else:
+                with self._build_session() as http:
+                    response = http.request(
+                        method,
+                        url=url,
+                        json=self._sanitize(data),
+                        timeout=self.timeout,
+                    )
+
+            result_status = response.status_code
+            if result_status < 200 or result_status >= 300:
+                raise CustomerIOException(f"{result_status}: {url} {data} {response.text}")
+            return response
+
+        except CustomerIOException:
+            raise
+        except Exception as e:
+            message = (
+                f"Failed to receive valid response after {self.retries} retries.\n"
+                f"Check system status at http://status.customer.io.\n"
+                f"Last caught exception -- {type(e)}: {e}"
+            )
+            raise CustomerIOException(message) from e
+
+    def _sanitize(self, data):
+        return {key: self._sanitize_value(value) for key, value in data.items()}
+
+    def _sanitize_value(self, value):
+        if isinstance(value, datetime):
+            return self._datetime_to_timestamp(value)
+        if isinstance(value, float) and math.isnan(value):
+            return None
+        return value
+
+    def _datetime_to_timestamp(self, dt):
+        return int(dt.replace(tzinfo=timezone.utc).timestamp())
+
+    def _stringify_list(self, customer_ids):
+        customer_string_ids = []
+        for v in customer_ids:
+            if isinstance(v, str):
+                customer_string_ids.append(v)
+            elif isinstance(v, int):
+                customer_string_ids.append(str(v))
+            else:
+                raise CustomerIOException(f"customer_ids cannot be {type(v)}")
+        return customer_string_ids
+
+    def _build_session(self):
+        session = Session()
+        session.headers["User-Agent"] = f"Customer.io Python Client/{ClientVersion}"
+
+        retry = Retry(
+            total=self.retries,
+            backoff_factor=self.backoff_factor,
+            allowed_methods=None,
+            status_forcelist=[500, 502, 503, 504],
+        )
+        session.mount("https://", TCPKeepAliveHTTPAdapter(max_retries=retry))
+
+        return session

customerio/constants.py

@@ -0,0 +1,5 @@
+## Identifier types
+
+ID = "id"
+EMAIL = "email"
+CIOID = "cio_id"

customerio/regions.py

@@ -0,0 +1,8 @@
+from collections import namedtuple
+
+Region = namedtuple("Region", ["name", "track_host", "api_host"])
+
+
+class Regions:
+    US = Region("us", "track.customer.io", "api.customer.io")
+    EU = Region("eu", "track-eu.customer.io", "api-eu.customer.io")

customerio/track.py

@@ -0,0 +1,271 @@
+"""
+Implements the client that interacts with Customer.io's Track API using Site ID and API Keys.
+"""
+
+import warnings
+from datetime import datetime
+from urllib.parse import quote
+
+from customerio.constants import CIOID, EMAIL, ID
+
+from .client_base import ClientBase, CustomerIOException
+from .regions import Region, Regions
+
+
+class CustomerIO(ClientBase):
+    def __init__(
+        self,
+        site_id=None,
+        api_key=None,
+        host=None,
+        region=Regions.US,
+        port=None,
+        url_prefix=None,
+        json_encoder=None,
+        retries=3,
+        timeout=10,
+        backoff_factor=0.02,
+        use_connection_pooling=True,
+    ):
+        if not isinstance(region, Region):
+            raise CustomerIOException("invalid region provided")
+
+        self.host = host or region.track_host
+        self.port = port or 443
+        self.url_prefix = url_prefix or "/api/v1"
+        self.api_key = api_key
+        self.site_id = site_id
+
+        if json_encoder is not None:
+            warnings.warn(
+                "With the switch to using requests library the `json_encoder` param is no longer used.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        self.setup_base_url()
+        super().__init__(
+            retries=retries,
+            timeout=timeout,
+            backoff_factor=backoff_factor,
+            use_connection_pooling=use_connection_pooling,
+        )
+
+    def _url_encode(self, id):
+        return quote(str(id), safe="")
+
+    def setup_base_url(self):
+        template = "https://{host}:{port}/{prefix}"
+        if self.port == 443:
+            template = "https://{host}/{prefix}"
+
+        if "://" in self.host:
+            self.host = self.host.split("://")[1]
+
+        self.base_url = template.format(
+            host=self.host.strip("/"),
+            port=self.port,
+            prefix=self.url_prefix.strip("/"),
+        )
+
+    def get_customer_query_string(self, customer_id):
+        """Generates a customer API path."""
+        return f"{self.base_url}/customers/{self._url_encode(customer_id)}"
+
+    def get_event_query_string(self, customer_id):
+        """Generates an event API path."""
+        return f"{self.base_url}/customers/{self._url_encode(customer_id)}/events"
+
+    def get_events_query_string(self):
+        """Returns the events API path."""
+        return f"{self.base_url}/events"
+
+    def get_device_query_string(self, customer_id):
+        """Generates a device API path."""
+        return f"{self.base_url}/customers/{self._url_encode(customer_id)}/devices"
+
+    def identify(self, id, **kwargs):
+        """Identify a single customer by their unique id, and optionally add attributes."""
+        if not id:
+            raise CustomerIOException("id cannot be blank in identify")
+        url = self.get_customer_query_string(id)
+        return self.send_request("PUT", url, kwargs)
+
+    def track(self, customer_id, name, data=None, id=None, timestamp=None):
+        """Track an event for a given customer_id."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in track")
+        url = self.get_event_query_string(customer_id)
+        post_data = self._build_event(name, data, id=id, timestamp=timestamp)
+        return self.send_request("POST", url, post_data)
+
+    def track_anonymous(self, anonymous_id, name, data=None, id=None, timestamp=None):
+        """Track an event for a given anonymous_id."""
+        url = self.get_events_query_string()
+        post_data = self._build_event(name, data, id=id, timestamp=timestamp)
+        if anonymous_id:
+            post_data["anonymous_id"] = anonymous_id
+
+        return self.send_request("POST", url, post_data)
+
+    def pageview(self, customer_id, page, **data):
+        """Track a pageview for a given customer_id."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in pageview")
+        url = self.get_event_query_string(customer_id)
+        post_data = {
+            "type": "page",
+            "name": page,
+            "data": self._sanitize(data),
+        }
+        return self.send_request("POST", url, post_data)
+
+    def backfill(self, customer_id, name, timestamp, **data):
+        """Backfill an event (track with timestamp) for a given customer_id."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in backfill")
+
+        url = self.get_event_query_string(customer_id)
+
+        if isinstance(timestamp, datetime):
+            timestamp = self._datetime_to_timestamp(timestamp)
+        elif not isinstance(timestamp, int):
+            try:
+                timestamp = int(timestamp)
+            except Exception as e:
+                raise CustomerIOException(f"{timestamp} is not a valid timestamp ({e})") from e
+
+        post_data = {
+            "name": name,
+            "data": self._sanitize(data),
+            "timestamp": timestamp,
+        }
+
+        return self.send_request("POST", url, post_data)
+
+    def _build_event(self, name, data=None, id=None, timestamp=None):
+        post_data = {
+            "name": name,
+            "data": self._sanitize(data or {}),
+        }
+        if id is not None:
+            post_data["id"] = id
+        if timestamp is not None:
+            if isinstance(timestamp, datetime):
+                timestamp = self._datetime_to_timestamp(timestamp)
+            elif isinstance(timestamp, int):
+                pass
+            else:
+                try:
+                    timestamp = int(timestamp)
+                except (ValueError, TypeError, OverflowError):
+                    timestamp = None
+            if timestamp is not None:
+                post_data["timestamp"] = timestamp
+        return post_data
+
+    def delete(self, customer_id):
+        """Delete a customer profile."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in delete")
+
+        url = self.get_customer_query_string(customer_id)
+        return self.send_request("DELETE", url, {})
+
+    def add_device(self, customer_id, device_id, platform, **data):
+        """Add a device to a customer profile."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in add_device")
+
+        if not device_id:
+            raise CustomerIOException("device_id cannot be blank in add_device")
+
+        if not platform:
+            raise CustomerIOException("platform cannot be blank in add_device")
+
+        data.update(
+            {
+                "id": device_id,
+                "platform": platform,
+            }
+        )
+        payload = {"device": data}
+        url = self.get_device_query_string(customer_id)
+        return self.send_request("PUT", url, payload)
+
+    def delete_device(self, customer_id, device_id):
+        """Delete a device from a customer profile."""
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in delete_device")
+
+        if not device_id:
+            raise CustomerIOException("device_id cannot be blank in delete_device")
+
+        url = self.get_device_query_string(customer_id)
+        delete_url = f"{url}/{self._url_encode(device_id)}"
+        return self.send_request("DELETE", delete_url, {})
+
+    def suppress(self, customer_id):
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in suppress")
+
+        return self.send_request(
+            "POST",
+            f"{self.base_url}/customers/{self._url_encode(customer_id)}/suppress",
+            {},
+        )
+
+    def unsuppress(self, customer_id):
+        if not customer_id:
+            raise CustomerIOException("customer_id cannot be blank in unsuppress")
+
+        return self.send_request(
+            "POST",
+            f"{self.base_url}/customers/{self._url_encode(customer_id)}/unsuppress",
+            {},
+        )
+
+    def is_valid_id_type(self, id_type):
+        return id_type in {ID, EMAIL, CIOID}
+
+    def merge_customers(self, primary_id_type, primary_id, secondary_id_type, secondary_id):
+        """Merge secondary profile into primary profile."""
+        if not self.is_valid_id_type(primary_id_type):
+            raise CustomerIOException("invalid primary id type")
+
+        if not self.is_valid_id_type(secondary_id_type):
+            raise CustomerIOException("invalid secondary id type")
+
+        if not primary_id:
+            raise CustomerIOException("primary customer_id cannot be blank")
+
+        if not secondary_id:
+            raise CustomerIOException("secondary customer_id cannot be blank")
+
+        url = f"{self.base_url}/merge_customers"
+        post_data = {
+            "primary": {primary_id_type: primary_id},
+            "secondary": {secondary_id_type: secondary_id},
+        }
+        return self.send_request("POST", url, post_data)
+
+    def batch(self, operations):
+        """Send multiple operations in a single request.
+
+        Each operation is a dict with at minimum 'type' and 'action' keys.
+        See https://customer.io/docs/api/track/#operation/batch
+        """
+        if not operations:
+            raise CustomerIOException("operations cannot be empty in batch")
+
+        if self.port == 443:
+            url = f"https://{self.host}/api/v2/batch"
+        else:
+            url = f"https://{self.host}:{self.port}/api/v2/batch"
+        return self.send_request("POST", url, {"batch": operations})
+
+    def _build_session(self):
+        session = super()._build_session()
+        session.auth = (self.site_id, self.api_key)
+
+        return session

customerio-3.0.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: customerio
+Version: 3.0.0
+Summary: Customer.io Python bindings.
+Author-email: "Peaberry Software Inc." <support@customerio.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/customerio/customerio-python
+Project-URL: Changelog, https://github.com/customerio/customerio-python/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/customerio/customerio-python/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: urllib3>=2.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: ruff>=0.15.12; extra == "dev"
+Requires-Dist: twine>=6.1.0; extra == "dev"
+Dynamic: license-file
+
+<p align=center>
+  <a href="https://customer.io">
+    <img src="https://avatars.githubusercontent.com/u/1152079?s=200&v=4" height="60">
+  </a>
+</p>
+
+[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blueviolet?logo=gitpod)](https://gitpod.io/#https://github.com/customerio/customerio-python/)
+![PyPI](https://img.shields.io/pypi/v/customerio)
+![Software License](https://img.shields.io/github/license/customerio/customerio-python)
+[![Build status](https://github.com/customerio/customerio-python/actions/workflows/main.yml/badge.svg)](https://github.com/customerio/customerio-python/actions/workflows/main.yml)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/customerio)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/customerio)
+
+# Customer.io Python
+
+This module is tested with Python 3.10 through 3.14. If you're new to Customer.io, we recommend that you integrate with our [Data Pipelines Python library](https://github.com/customerio/cdp-analytics-python) instead.
+
+## Installing
+
+```bash
+pip install customerio
+```
+
+## Usage
+
+```python
+from customerio import CustomerIO, Regions
+cio = CustomerIO(site_id, api_key, region=Regions.US)
+cio.identify(id="5", email='customer@example.com', name='Bob', plan='premium')
+cio.track(customer_id="5", name='purchased')
+cio.track(customer_id="5", name='purchased', data={"price": 23.45})
+```
+
+### Instantiating customer.io object
+
+Create an instance of the client with your [Customer.io credentials](https://fly.customer.io/settings/api_credentials).
+
+```python
+from customerio import CustomerIO, Regions
+cio = CustomerIO(site_id, api_key, region=Regions.US)
+```
+`region` is optional and takes one of two values—`Regions.US` or `Regions.EU`. If you do not specify your region, we assume that your account is based in the US (`Regions.US`). If your account is based in the EU and you do not provide the correct region (`Regions.EU`), we'll route requests to our EU data centers accordingly, however this may cause data to be logged in the US. 
+
+### Create or update a Customer.io customer profile
+
+```python
+cio.identify(id="5", email='customer@example.com', name='Bob', plan='premium')
+```
+
+Only the id field is used to identify the customer here.  Using an existing id with
+a different email (or any other attribute) will update/overwrite any pre-existing
+values for that field.
+
+You can pass any keyword arguments to the `identify` method. These kwargs will be converted to custom attributes.
+
+See original REST documentation [here](http://customer.io/docs/api/track/#operation/identify)
+
+### Track a custom event
+
+```python
+cio.track(customer_id="5", name='purchased')
+```
+
+### Track a custom event with custom data values
+
+```python
+cio.track(customer_id="5", name='purchased', data={"price": 23.45, "product": "widget"})
+```
+
+Pass custom event attributes to `track` in the `data` dict.
+
+See original REST documentation [here](http://customer.io/docs/api/track/#operation/track)
+
+### Track a custom event with an event id or timestamp
+
+```python
+cio.track(
+  customer_id="5",
+  name='purchased',
+  data={"price": 23.45, "product": "widget"},
+  id="01HB4HBDKTFWYZCK01DMRSWRFD",
+  timestamp=1561231234
+)
+```
+
+Pass `id` to provide a unique event identifier for deduplication. Pass `timestamp` to set the event time. These fields are sent as top-level event fields, not as custom attributes in `data`.
+
+### Backfill a custom event
+
+```python
+from datetime import datetime, timedelta
+
+customer_id = "5"
+event_type = "purchase"
+
+# Backfill an event one hour in the past
+event_date = datetime.utcnow() - timedelta(hours=1)
+cio.backfill(customer_id, event_type, event_date, price=23.45, coupon=True)
+
+event_timestamp = 1408482633
+cio.backfill(customer_id, event_type, event_timestamp, price=34.56)
+
+event_timestamp = "1408482680"
+cio.backfill(customer_id, event_type, event_timestamp, price=45.67)
+```
+
+Event timestamp may be passed as a ```datetime.datetime``` object, an integer or a string UNIX timestamp
+
+Keyword arguments to backfill are converted to custom event attributes.
+
+See original REST documentation [here](http://customer.io/docs/api/track/#operation/track)
+
+### Track an anonymous event
+
+```python
+cio.track_anonymous(
+  anonymous_id="anon-event",
+  name="purchased",
+  data={"price": 23.45, "product": "widget"}
+)
+```
+
+An anonymous event is an event associated with a person you haven't identified. The event requires an `anonymous_id` representing the unknown person and an event `name`. When you identify a person, you can set their `anonymous_id` attribute. If [event merging](https://customer.io/docs/anonymous-events/#turn-on-merging) is turned on in your workspace, and the attribute matches the `anonymous_id` in one or more events that were logged within the last 30 days, we associate those events with the person.
+
+Like `track`, `track_anonymous` accepts custom event attributes in `data` and optional top-level `id` and `timestamp` fields.
+
+#### Anonymous invite events
+
+If you previously sent [invite events](https://customer.io/docs/journeys/anonymous-invite-emails/), you can achieve the same functionality by sending an anonymous event with the anonymous identifier set to `None`. To send anonymous invites, your event *must* include a `recipient` attribute. 
+
+```python
+cio.track_anonymous(
+  anonymous_id=None,
+  name="invite",
+  data={"first_name": "alex", "recipient": "alex.person@example.com"}
+)
+```
+
+### Delete a customer profile
+```python
+cio.delete(customer_id="5")
+```
+
+Deletes the customer profile for a specified customer.
+
+This method returns nothing.  Attempts to delete non-existent customers will not raise any errors.
+
+See original REST documentation [here](https://customer.io/docs/api/track/#operation/delete)
+
+
+You can pass any keyword arguments to the `identify` method. These kwargs will be converted to custom attributes.
+
+### Merge duplicate customer profiles
+
+When you merge two people, you pick a primary person and merge a secondary, duplicate person into it. The primary person remains after the merge and the secondary is deleted. This process is permanent: you cannot recover the secondary person.
+
+For each person, you'll set the type of identifier you want to use to identify a person—one of `id`, `email`, or `cio_id`—and then you'll provide the corresponding identifier.
+
+```python
+## Please import identifier types
+cio.merge_customers(primary_id_type=ID,
+  primary_id="cool.person@company.com", 
+  secondary_id_type=EMAIL, 
+  secondary_id="cperson@gmail.com"
+)
+```
+
+### Add a device
+```python
+cio.add_device(customer_id="1", device_id='device_hash', platform='ios')
+```
+
+Adds the device `device_hash` with the platform `ios` for a specified customer.
+
+Supported platforms are `ios` and `android`. 
+
+Optionally, `last_used` can be passed in to specify the last touch of the device. Otherwise, this attribute is set by the API.
+
+```python
+cio.add_device(customer_id="1", device_id='device_hash', platform='ios', last_used=1514764800})
+```
+
+This method returns nothing.
+
+### Delete a device
+```python
+cio.delete_device(customer_id="1", device_id='device_hash')
+```
+
+Deletes the specified device for a specified customer.
+
+This method returns nothing. Attempts to delete non-existent devices will not raise any errors.
+
+### Suppress a customer
+```python
+cio.suppress(customer_id="1")
+```
+
+Suppresses the specified customer. They will be deleted from Customer.io, and we will ignore all further attempts to identify or track activity for the suppressed customer ID
+
+See REST documentation [here](https://customer.io/docs/api/track/#operation/suppress)
+
+### Unsuppress a customer
+```python
+cio.unsuppress(customer_id="1")
+```
+
+Unsuppresses the specified customer. We will remove the supplied id from our suppression list and start accepting new identify and track calls for the customer as normal
+
+See REST documentation [here](https://customer.io/docs/api/track/#operation/unsuppress)
+
+### Send Transactional Messages
+
+To use the [Transactional API](https://customer.io/docs/journeys/transactional-api), instantiate the Customer.io object using an [app key](https://customer.io/docs/managing-credentials#app-api-keys) and create a request object for your message type.
+
+## Email
+
+SendEmailRequest requires:
+* `transactional_message_id`: the ID of the transactional message you want to send, or the `body`, `_from`, and `subject` of a new message.
+* `to`: the email address of your recipients 
+* an `identifiers` object containing the `email` and/or `id` of your recipient. If the person you reference by email or ID does not exist, Customer.io creates them.
+* a `message_data` object containing properties that you want reference in your message using Liquid.
+* You can also send attachments with your message. Use `attach` to encode attachments.
+
+Use `send_email` referencing your request to send a transactional message. [Learn more about transactional messages and `SendEmailRequest` properties](https://customer.io/docs/journeys/transactional-api).
+
+```python
+from customerio import APIClient, Regions, SendEmailRequest
+client = APIClient("your API key", region=Regions.US)
+
+request = SendEmailRequest(
+  to="person@example.com",
+  _from="override.sender@example.com",
+  transactional_message_id="3",
+  message_data={
+    "name": "person",
+    "items": [
+      {
+        "name": "shoes",
+        "price": "59.99",
+      },
+    ]
+  },
+  identifiers={
+    "email": "person@example.com",
+  }
+)
+
+with open("receipt.pdf", "rb") as f:
+  request.attach('receipt.pdf', f.read())
+
+response = client.send_email(request)
+print(response)
+```
+
+## Push
+
+SendPushRequest requires:
+* `transactional_message_id`: the ID of the transactional push message you want to send.
+* an `identifiers` object containing the `id` or `email` of your recipient. If the profile does not exist, Customer.io will create it.
+
+Use `send_push` referencing your request to send a transactional message. [Learn more about transactional messages and `SendPushRequest` properties](https://customer.io/docs/journeys/transactional-api).
+
+```python
+from customerio import APIClient, Regions, SendPushRequest
+client = APIClient("your API key", region=Regions.US)
+
+request = SendPushRequest(
+  transactional_message_id="3",
+  message_data={
+    "name": "person",
+    "items": [
+      {
+        "name": "shoes",
+        "price": "59.99",
+      },
+    ]
+  },
+  identifiers={
+    "id": "2",
+  }
+)
+
+response = client.send_push(request)
+print(response)
+```
+
+## Notes
+- The Customer.io Python SDK depends on the [`Requests`](https://pypi.org/project/requests/) library which includes [`urllib3`](https://pypi.org/project/urllib3/) as a transitive dependency.  The [`Requests`](https://pypi.org/project/requests/) library leverages connection pooling defined in [`urllib3`](https://pypi.org/project/urllib3/).  [`urllib3`](https://pypi.org/project/urllib3/) only attempts to retry invocations of `HTTP` methods which are understood to be idempotent (See: [`Retry.DEFAULT_ALLOWED_METHODS`](https://github.com/urllib3/urllib3/blob/main/src/urllib3/util/retry.py#L184)).  Since the `POST` method is not considered to be idempotent, any invocations which require `POST` are not retried.
+
+- It is possible to have the Customer.io Python SDK effectively *disable* connection pooling by passing a named initialization parameter `use_connection_pooling` to either the `APIClient` class or `CustomerIO` class.  Setting this parameter to `False` (default: `True`) causes the [`Session`](https://github.com/psf/requests/blob/main/requests/sessions.py#L355) to be initialized and discarded after each request.  If you are experiencing integration issues where the cause is reported as `Connection Reset by Peer`, this may correct the problem.  It will, however, impose a slight performance penalty as the TCP connection set-up and tear-down will now occur for each request.
+
+### Usage Example Disabling Connection Pooling
+```python
+from customerio import CustomerIO, Regions
+cio = CustomerIO(site_id, api_key, region=Regions.US, use_connection_pooling=False)
+```
+
+## Running tests
+
+Changes to the library can be tested by running `make test` from the parent directory.
+
+## Thanks!
+
+* [Dimitriy Narkevich](https://github.com/dimier) for creating the library.
+* [EZL](https://github.com/ezl) for contributing customer deletes and improving README
+* [Noemi Millman](https://github.com/sbnoemi) for adding custom JSON encoder
+* [Jason Kraus](https://github.com/zbyte64) for event backfilling
+* [Nicolas Paris](https://github.com/niparis) for better handling of NaN values

customerio-3.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+customerio/__init__.py,sha256=UjqelCLS-5mfclsHMSx9dka4901x8Xzh8VoEi9uywrA,510
+customerio/__version__.py,sha256=EPmgXOdWKks5S__ZMH7Nu6xpAeVrZpfxaFy4pykuyeI,22
+customerio/api.py,sha256=elGH8ih6VInumMQdIxziYK2YeKGxe3GtgqMmTKKEVZw,10008
+customerio/client_base.py,sha256=t3YigWTA0fV9Nr0H7sqO-s2_6Vp6LprOg-tXNZtfg90,5113
+customerio/constants.py,sha256=KgYkS-ywruXlzGyErGcweJsHwfMjTVyk9JLKi-1Od1c,64
+customerio/regions.py,sha256=5EEXQyLoxSvrXoDeeXt6Asr-DXN6nNMNyh9CGbF-hn0,249
+customerio/track.py,sha256=-jYn0-7JVMoSIxqn3dd1dU43JBEYVW7MO7-jGdg7mPM,9622
+customerio-3.0.0.dist-info/licenses/LICENSE,sha256=DrMr_uGUjC4xPmcqLmymvDoh1OoAAV7rfc9s1nlr9xc,1067
+customerio-3.0.0.dist-info/METADATA,sha256=bk7Z20mdeL8bkqnByex_IgIjDuisC_06fqtv8h9qamw,13899
+customerio-3.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+customerio-3.0.0.dist-info/top_level.txt,sha256=d3H1hFIU5Igty-2IkC7fQoeLlaNAzjn8s-9iOjKRzvA,11
+customerio-3.0.0.dist-info/RECORD,,

customerio-3.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

customerio-3.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 Customer.io
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

customerio-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+customerio