behaviorgpt 0.1.0__py3-none-any.whl

behaviorgpt/__init__.py

@@ -0,0 +1,29 @@
+from behaviorgpt._client import UnboxAIClient
+from behaviorgpt._exceptions import (
+    AuthenticationError,
+    BadRequestError,
+    RateLimitError,
+    UnboxAIError,
+)
+from behaviorgpt.resources.catalogs import ProgressPrinter
+from behaviorgpt.types.events import (
+    AddToCart,
+    Order,
+    RemoveFromCart,
+    Search,
+    View,
+)
+
+__all__ = [
+    "Search",
+    "AddToCart",
+    "View",
+    "RemoveFromCart",
+    "Order",
+    "UnboxAIClient",
+    "ProgressPrinter",
+    "UnboxAIError",
+    "AuthenticationError",
+    "BadRequestError",
+    "RateLimitError",
+]

behaviorgpt/_client.py

@@ -0,0 +1,275 @@
+import os
+import random
+import warnings
+from collections import defaultdict
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any, Callable, Optional, Sequence, cast
+from uuid import uuid4
+
+import httpx
+
+from behaviorgpt._exceptions import AuthenticationError
+from behaviorgpt.resources.catalogs import Catalogs
+from behaviorgpt.resources.recommendations import Recommender
+from behaviorgpt.resources.requests import UnboxAIRequester
+from behaviorgpt.resources.search import Searcher
+from behaviorgpt.types import (
+    AddToCart,
+    CartItem,
+    Domains,
+    EmbedJobDetails,
+    Item,
+    JobStatus,
+    Order,
+    Search,
+    SessionEvent,
+    UnboxAIResponse,
+    UserEvent,
+    UserHistoryInput,
+)
+
+# An embed upload streams the whole parquet, and the API answers only once the
+# file is stored and queued: httpx's 5 s default is too short for both.
+DEFAULT_HTTP_TIMEOUT = httpx.Timeout(120.0, connect=10.0, write=300.0)
+
+
+class UnboxAIClient:
+    def __init__(
+        self,
+        market: str,
+        *,
+        timezone: str = "UTC",
+        api_key: Optional[str] = None,
+        base_url: str = "https://behaviorgpt-northeurope.api.unboxai.com/v1",
+        default_catalog_id: str = "retail_catalog",
+        http_timeout: float | httpx.Timeout = DEFAULT_HTTP_TIMEOUT,
+    ):
+        self.api_key = api_key or os.environ.get("UNBOXAI_API_KEY")
+        if not self.api_key:
+            msg = "API key is missing. Pass it or set UNBOXAI_API_KEY."
+            raise AuthenticationError(msg)
+
+        self.base_url = base_url
+        self.default_catalog_id = default_catalog_id
+
+        headers = {"x-api-key": self.api_key}
+        self._http_client = httpx.Client(
+            base_url=self.base_url, headers=headers, timeout=http_timeout
+        )
+
+        self.domains = Domains(market=market)
+        self.timezone = timezone
+
+        self.requester = UnboxAIRequester(domains=self.domains, timezone=self.timezone)
+
+        self.recommendations = Recommender(self._http_client)
+        self.search = Searcher(self._http_client)
+        self.catalogs = Catalogs(self._http_client)
+
+    def complete(
+        self,
+        history: UserHistoryInput,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        catalog_id: Optional[str] = None,
+        filters: Optional[dict[str, Any]] = None,
+        register_event: bool = False,
+    ) -> UnboxAIResponse:
+        active_catalog: str = catalog_id or self.default_catalog_id
+        request_headers = {"x-catalog-id": active_catalog}
+
+        history_events = self.__from_sequence(active_catalog, history)
+        last_event = self._get_last_event(history)
+
+        if isinstance(last_event, Search):
+            req = self.requester.make(
+                query=last_event.query,
+                history=history_events[:-1],
+                catalog_id=active_catalog,
+                limit=limit,
+                offset=offset,
+                filters=filters,
+                register_event=register_event,
+            )
+            return self.search.create(payload=req, headers=request_headers)
+
+        req = self.requester.make(
+            history=history_events,
+            catalog_id=active_catalog,
+            limit=limit,
+            offset=offset,
+            filters=filters,
+            register_event=register_event,
+        )
+        return self.recommendations.create(payload=req, headers=request_headers)
+
+    def embed(
+        self,
+        path: Path | str,
+        wait: bool = False,
+        interval: float = 5.0,
+        timeout: float = 600.0,
+        on_progress: Optional[Callable[[JobStatus], None]] = None,
+        startup_grace: float = 120.0,
+        reference_time: Optional[datetime | str] = None,
+    ) -> EmbedJobDetails:
+        """Upload and embed a catalog parquet.
+
+        Pass `wait=True` to block until the embed job finishes. While waiting,
+        each new job state is printed once; pass `on_progress` to render
+        progress yourself, or `on_progress=lambda _: None` for silence.
+
+        `reference_time` is when item ages and sales are measured; the upload
+        time by default.
+        """
+        if isinstance(path, str):
+            path = Path(path)
+
+        return self.catalogs.embed(
+            path,
+            wait=wait,
+            interval=interval,
+            timeout=timeout,
+            on_progress=on_progress,
+            startup_grace=startup_grace,
+            reference_time=reference_time,
+        )
+
+    def job_status(self, job_id: str) -> JobStatus:
+        return self.catalogs.get_job_status(job_id)
+
+    def similar_items(
+        self,
+        item_id: str,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        catalog_id: Optional[str] = None,
+    ) -> UnboxAIResponse:
+        active_catalog: str = catalog_id or self.default_catalog_id
+        request_headers = {"x-catalog-id": active_catalog}
+
+        return self.catalogs.get_similar_items(
+            item_id,
+            catalog_id=active_catalog,
+            limit=limit,
+            offset=offset,
+            headers=request_headers,
+        )
+
+    def similar_products(
+        self, product_id: str, *args: Any, **kwargs: Any
+    ) -> UnboxAIResponse:
+        warnings.warn(
+            "`similar_products` is deprecated, use `similar_items`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.similar_items(product_id, *args, **kwargs)
+
+    def random_item(self, catalog_id: Optional[str] = None, window: int = 100) -> Item:
+        """One item from the embedded catalog, handy when
+        you have no item id at hand.
+        """
+        top = self.complete(history=[], catalog_id=catalog_id, limit=window)
+        if not top.items:
+            active = catalog_id or self.default_catalog_id
+            raise ValueError(f"catalog {active!r} returned no items")
+        return random.choice(top.items)
+
+    def random_product(self, *args: Any, **kwargs: Any) -> Item:
+        warnings.warn(
+            "`random_product` is deprecated, use `random_item`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.random_item(*args, **kwargs)
+
+    def __from_sequence(
+        self, catalog_id: str, context: UserHistoryInput
+    ) -> list[SessionEvent]:
+        events: list[SessionEvent] = []
+
+        if not context:
+            return events
+
+        # Track cart state within a single session
+        def _process_session_events(
+            session_events: Sequence[UserEvent], session_id: str, session_offset: int
+        ):
+            cart_state: dict[str, int] = defaultdict(int)
+            current_cart_id = str(uuid4())
+
+            # Base time for the start of the sequence
+            base_time = datetime.now(tz=UTC)
+
+            for i, ev in enumerate(session_events):
+                if isinstance(ev, AddToCart):
+                    cart_state[ev.item] += 1
+                elif isinstance(ev, Order):
+                    if not getattr(ev, "items", None):
+                        ev.cart_id = current_cart_id
+                        ev.items = [
+                            CartItem(item, qty) for item, qty in cart_state.items()
+                        ]
+                    cart_state.clear()
+                    current_cart_id = str(uuid4())
+
+                # Add 1 millisecond for each event to guarantee network-safe distinct
+                # ordering. Factors in a session offset just in case 2D arrays
+                # were passed
+                event_time = base_time + timedelta(
+                    milliseconds=(session_offset * 1000) + i
+                )
+
+                events.append(
+                    self.__to_session_evt(ev, session_id, catalog_id, event_time)
+                )
+
+        if isinstance(context[0], (list, tuple)):
+            context_2d = cast(Sequence[Sequence[UserEvent]], context)
+            for session_index, session_sequence in enumerate(context_2d):
+                _process_session_events(session_sequence, str(uuid4()), session_index)
+        else:
+            context_1d = cast(Sequence[UserEvent], context)
+            _process_session_events(context_1d, str(uuid4()), 0)
+
+        return events
+
+    def umap(self, *, catalog_id: Optional[str] = None):
+        """The catalog's UMAP, a 2D map of its items, as an HTML page.
+
+        Maps exist only for catalogs of up to 100,000 items, and appear within
+        about a minute after the catalog is ready: laying out more items than
+        that does not fit in the embedding worker's memory, so larger catalogs
+        (such as the shared `retail_catalog`) never get one. A missing map
+        raises `UnboxAIError` with status 404 and says which case applies.
+        """
+        active_catalog: str = catalog_id or self.default_catalog_id
+        return self.catalogs.get_umap(catalog_id=active_catalog)
+
+    def __to_session_evt(
+        self, event: UserEvent, session_id: str, catalog_id: str, timestamp: datetime
+    ) -> SessionEvent:
+        return SessionEvent(
+            store_id=catalog_id,
+            domains=self.domains,
+            timezone=self.timezone,
+            event=event,
+            session_id=session_id,
+            timestamp=timestamp,
+        )
+
+    def _get_last_event(self, history: UserHistoryInput) -> UserEvent | None:
+        if not history:
+            return None
+
+        if isinstance(history[0], (list, tuple)):
+            history_2d = cast(Sequence[Sequence[UserEvent]], history)
+            inner_seq = history_2d[-1]
+            return inner_seq[-1] if inner_seq else None
+        else:
+            history_1d = cast(Sequence[UserEvent], history)
+            return history_1d[-1]

behaviorgpt/_exceptions.py

@@ -0,0 +1,25 @@
+class UnboxAIError(Exception):
+    def __init__(
+        self, message: str, status_code: int | None = None, response: dict | None = None
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response or {}
+
+
+class AuthenticationError(UnboxAIError):
+    """Raised when the API key is missing, invalid, or revoked (HTTP 401)."""
+
+    pass
+
+
+class RateLimitError(UnboxAIError):
+    """Raised when the user has sent too many requests (HTTP 429)."""
+
+    pass
+
+
+class BadRequestError(UnboxAIError):
+    """Raised when the request is invalid or missing required parameters (HTTP 400)."""
+
+    pass

behaviorgpt/resources/_shared.py

@@ -0,0 +1,37 @@
+import httpx
+
+from behaviorgpt._exceptions import (
+    AuthenticationError,
+    BadRequestError,
+    RateLimitError,
+    UnboxAIError,
+)
+
+
+def handle_response(response: httpx.Response):
+    if response.status_code < 400:
+        if response.status_code == 204:  # No Content
+            return None
+        return response.json()
+
+    # the API answers {"detail": ...}; a proxy in front of it may answer plain
+    # text or JSON of any shape
+    try:
+        body = response.json()
+    except ValueError:
+        body = None
+    if isinstance(body, dict) and "detail" in body:
+        error_data = body["detail"]
+    else:
+        error_data = response.text or "Unknown Error"
+
+    if response.status_code == 401:
+        raise AuthenticationError(
+            f"Authentication failed: {error_data}", status_code=401
+        )
+    elif response.status_code == 429:
+        raise RateLimitError(f"Rate limit exceeded: {error_data}", status_code=429)
+    elif response.status_code == 400:
+        raise BadRequestError(f"Bad request: {error_data}", status_code=400)
+
+    raise UnboxAIError(f"API Error: {error_data}", status_code=response.status_code)

behaviorgpt/resources/catalogs.py

@@ -0,0 +1,293 @@
+import time
+import warnings
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import httpx
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from behaviorgpt._exceptions import UnboxAIError
+from behaviorgpt.resources._shared import handle_response
+from behaviorgpt.types import (
+    EmbedJobDetails,
+    JobStatus,
+    SimilarItemsRequest,
+    UnboxAIResponse,
+)
+
+# The three states the catalogs.status CHECK constraint allows, server-side.
+PENDING_STATUS = "pending"
+READY_STATUS = "ready"
+FAILED_STATUS = "failed"
+QUEUED_STATUS = "queued"
+
+# A status read that fails with one of these says nothing about the job.
+RETRYABLE_STATUS_CODES = frozenset({429, 500, 502, 503, 504})
+
+# Arrow type per column, see docs/catalog-format.md. The server checks column
+# names only; a wrong type fails or degrades the job later, so check it here.
+CATALOG_SCHEMA = {
+    "id": pa.string(),
+    "name": pa.string(),
+    "brand": pa.string(),
+    "categories": pa.string(),
+    "image_url": pa.string(),
+    "event_type": pa.string(),
+    "group": pa.string(),
+    "sales_since": pa.list_(pa.int64()),
+    "timestamp": pa.int64(),
+    "frequency": pa.int64(),
+    "market": pa.string(),
+    "price": pa.string(),
+    "currency": pa.string(),
+    "search_keywords": pa.list_(pa.string()),
+    "keywords": pa.list_(pa.string()),
+}
+
+
+def check_catalog_schema(path: Path) -> None:
+    """Raise `UnboxAIError` if the parquet's columns do not match `CATALOG_SCHEMA`.
+
+    An entirely null column has Arrow type `null` and is accepted.
+    """
+    try:
+        schema = pq.read_schema(path)
+    except (pa.ArrowException, OSError) as exc:
+        raise UnboxAIError(f"{path} is not a readable parquet file: {exc}") from exc
+    problems = []
+    for column, expected in CATALOG_SCHEMA.items():
+        if column not in schema.names:
+            problems.append(f"{column}: missing")
+            continue
+        actual = schema.field(column).type
+        if actual != expected and not pa.types.is_null(actual):
+            problems.append(f"{column}: expected {expected}, got {actual}")
+    if problems:
+        raise UnboxAIError(
+            f"{path} does not match the catalog format:\n  " + "\n  ".join(problems)
+        )
+
+
+def format_reference_time(reference_time: datetime | str) -> str:
+    """Format `reference_time` for the upload; a `datetime` must be timezone-aware."""
+    if isinstance(reference_time, str):
+        return reference_time
+    if reference_time.tzinfo is None:
+        raise ValueError("reference_time must be timezone-aware")
+    return reference_time.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+class ProgressPrinter:
+    """Default `on_progress` callback: print each new state once.
+
+    `wait_for_job` reads the status every few seconds; most reads repeat the
+    previous one, so printing every read would flood a notebook cell.
+    """
+
+    def __init__(self) -> None:
+        self.last: Optional[str] = None
+
+    def __call__(self, status: JobStatus) -> None:
+        line = status.describe()
+        if line != self.last:
+            print(line)
+            self.last = line
+
+
+class Catalogs:
+    """Upload a catalog parquet and embed it into the model's item space."""
+
+    def __init__(self, http_client: httpx.Client):
+        self._client = http_client
+
+    def embed(
+        self,
+        path: Path,
+        wait: bool = False,
+        interval: float = 5.0,
+        timeout: float = 600.0,
+        on_progress: Optional[Callable[[JobStatus], None]] = None,
+        startup_grace: float = 120.0,
+        reference_time: Optional[datetime | str] = None,
+    ) -> EmbedJobDetails:
+        """Upload the parquet at `path`.
+
+        The catalog id is minted server-side; `catalog_name` is the file's
+        stem and is for display only.
+
+        With `wait=True`, block until the job reaches a terminal state,
+        polling every `interval` seconds and giving up after `timeout`.
+        `on_progress` is called with each status read while waiting; by
+        default each new state is printed once (see `ProgressPrinter`).
+        """
+        check_catalog_schema(path)
+        form = (
+            {}
+            if reference_time is None
+            else {"reference_time": format_reference_time(reference_time)}
+        )
+
+        with open(path, "rb") as f:
+            response = self._client.post(
+                "/embed-catalog",
+                files={"file": (path.name, f, "application/octet-stream")},
+                data=form,
+            )
+
+        data = handle_response(response)
+
+        job = EmbedJobDetails(**data)
+
+        if wait:
+            self.wait_for_job(
+                job.job_id,
+                interval=interval,
+                timeout=timeout,
+                on_progress=on_progress,
+                startup_grace=startup_grace,
+            )
+
+        return job
+
+    def get_job_status(self, job_id: str) -> JobStatus:
+        """Read the job state once, without blocking."""
+        response = self._client.get(f"/embed-catalog/{job_id}")
+        data = handle_response(response)
+        return JobStatus(**data)
+
+    def wait_for_job(
+        self,
+        job_id: str,
+        interval: float = 5.0,
+        timeout: float = 600.0,
+        on_progress: Optional[Callable[[JobStatus], None]] = None,
+        startup_grace: float = 120.0,
+        failed_grace: float = 180.0,
+    ) -> JobStatus:
+        """Block until the job succeeds; raise on failure or timeout.
+
+        `on_progress` is called with every status read, terminal one included.
+        It defaults to a `ProgressPrinter`, which prints each new state once;
+        pass your own callable to render progress differently, or
+        `lambda _: None` for silence.
+
+        A job reads as 404 until a worker picks it up and writes its first
+        state, which can be seconds after the upload returns (or longer if the
+        GPU worker is busy). Within `startup_grace` seconds that 404 is
+        reported as status `queued` and polling continues; after it, the 404
+        is raised as it stands.
+
+        A job that fails for good says why in `error`. A `failed` status
+        without an error can be temporary, while the job is retried, so it is
+        only final once it has lasted `failed_grace` seconds.
+
+        A status read that fails with a 429, a 5xx or a network error says
+        nothing about the job, so polling continues until `timeout`.
+        """
+        if on_progress is None:
+            on_progress = ProgressPrinter()
+
+        started = time.monotonic()
+        deadline = started + timeout
+        seen = False
+        last_state = QUEUED_STATUS
+        failed_since: Optional[float] = None
+        read_error: Optional[Exception] = None
+
+        while True:
+            status: Optional[JobStatus] = None
+            try:
+                status = self.get_job_status(job_id)
+            except httpx.TransportError as exc:
+                read_error = exc
+            except UnboxAIError as exc:
+                not_started = (
+                    exc.status_code == 404
+                    and not seen
+                    and time.monotonic() - started < startup_grace
+                )
+                if not_started:
+                    status = JobStatus(job_id=job_id, status=QUEUED_STATUS)
+                elif exc.status_code in RETRYABLE_STATUS_CODES:
+                    read_error = exc
+                else:
+                    raise
+            else:
+                seen = True
+                read_error = None
+
+            if status is not None:
+                on_progress(status)
+                last_state = status.status.lower()
+
+                if last_state == READY_STATUS:
+                    return status
+
+                if last_state == FAILED_STATUS:
+                    now = time.monotonic()
+                    failed_since = now if failed_since is None else failed_since
+                    if status.error or now - failed_since >= failed_grace:
+                        reason = f": {status.error}" if status.error else ""
+                        raise UnboxAIError(
+                            f"Embed job {job_id} failed{reason}",
+                            response=status.model_dump(),
+                        )
+                else:
+                    failed_since = None
+
+            if time.monotonic() + interval > deadline:
+                message = f"Embed job {job_id} still '{last_state}' after {timeout:g}s"
+                if read_error:
+                    message += f"; last status read failed: {read_error}"
+                raise UnboxAIError(message)
+
+            time.sleep(interval)
+
+    def get_similar_items(
+        self,
+        item_id: str,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        catalog_id: str,
+        filters: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> UnboxAIResponse:
+        req = SimilarItemsRequest(
+            item_id=item_id,
+            store_id=catalog_id,
+            limit=limit,
+            offset=offset,
+            filters=filters or {},
+        )
+
+        response = self._client.post(
+            "/vector/similar_products",
+            json=req.model_dump(mode="json"),
+            headers=headers,
+        )
+
+        data = handle_response(response)
+
+        return UnboxAIResponse(**data)
+
+    def get_similar_products(
+        self, product_id: str, *args: Any, **kwargs: Any
+    ) -> UnboxAIResponse:
+        warnings.warn(
+            "`get_similar_products` is deprecated, use `get_similar_items`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.get_similar_items(product_id, *args, **kwargs)
+
+    def get_umap(self, *, catalog_id: str):
+        response = self._client.get(
+            f"/{catalog_id}/umap",
+        )
+
+        if response.is_error:
+            handle_response(response)
+        return response.text

behaviorgpt/resources/recommendations.py

@@ -0,0 +1,28 @@
+from typing import Optional, Union
+
+import httpx
+
+from behaviorgpt.resources._shared import handle_response
+from behaviorgpt.types import UnboxAIRequest, UnboxAIResponse
+
+
+class Recommender:
+    def __init__(self, http_client: httpx.Client):
+        self._client = http_client
+
+    def create(
+        self, payload: Union[UnboxAIRequest, dict], *, headers: Optional[dict] = None
+    ) -> UnboxAIResponse:
+        if isinstance(payload, dict):
+            payload = UnboxAIRequest(**payload)
+
+        response = self._client.post(
+            "/vector/recommendations",
+            json=payload.model_dump(mode="json", exclude_none=True),
+            headers=headers,
+        )
+
+        data = handle_response(response)
+        market_val = getattr(payload.domains, "market", None)
+
+        return UnboxAIResponse(**data, market=market_val)

behaviorgpt/resources/requests.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from typing import List, Optional
+
+from behaviorgpt.types import (
+    Domains,
+    SessionEvent,
+    UnboxAIRequest,
+)
+
+
+class UnboxAIRequester:
+    def __init__(self, domains: Domains, timezone: str = "UTC"):
+        self.domains = domains
+        self.timezone = timezone
+
+    def make(
+        self,
+        catalog_id: str,
+        query: str | None = None,
+        history: List[SessionEvent] | None = None,
+        domains: Optional[Domains] = None,
+        limit: int = 10,
+        offset: int = 0,
+        filters: Optional[dict] = None,
+        register_event: bool = False,
+        timestamp: Optional[datetime] = None,
+        num_candidates: Optional[int] = None,
+    ) -> UnboxAIRequest:
+        return UnboxAIRequest(
+            query=query,
+            history=history or [],
+            store_id=catalog_id,
+            domains=domains or self.domains,
+            timezone=self.timezone,
+            limit=limit,
+            offset=offset,
+            filters=filters or {},
+            register_event=register_event,
+            timestamp=timestamp,
+            num_candidates=num_candidates,
+        )

behaviorgpt/resources/search.py

@@ -0,0 +1,28 @@
+from typing import Union
+
+import httpx
+
+from behaviorgpt.resources._shared import handle_response
+from behaviorgpt.types import UnboxAIRequest, UnboxAIResponse
+
+
+class Searcher:
+    def __init__(self, http_client: httpx.Client):
+        self._client = http_client
+
+    def create(
+        self, payload: Union[UnboxAIRequest, dict], *, headers: dict | None = None
+    ) -> UnboxAIResponse:
+        if isinstance(payload, dict):
+            payload = UnboxAIRequest(**payload)
+
+        response = self._client.post(
+            "/vector/search",
+            json=payload.model_dump(mode="json", exclude_none=True),
+            headers=headers,
+        )
+
+        data = handle_response(response)
+        market_val = getattr(payload.domains, "market", None)
+
+        return UnboxAIResponse(**data, market=market_val)

behaviorgpt/types/__init__.py

@@ -0,0 +1,59 @@
+import warnings
+from typing import Any
+
+from behaviorgpt.types import http
+from behaviorgpt.types.domains import Domains
+from behaviorgpt.types.events import (
+    AddToCart,
+    CartItem,
+    Order,
+    RemoveFromCart,
+    Search,
+    SessionEvent,
+    UserEvent,
+    UserHistoryInput,
+    View,
+)
+from behaviorgpt.types.http import (
+    EmbedJobDetails,
+    Item,
+    ItemsPage,
+    ItemsRejected,
+    JobStatus,
+    RejectedItem,
+    SimilarItemsRequest,
+    UnboxAIRequest,
+    UnboxAIResponse,
+)
+
+__all__ = [
+    "UserEvent",
+    "SessionEvent",
+    "Search",
+    "AddToCart",
+    "View",
+    "RemoveFromCart",
+    "Order",
+    "UnboxAIResponse",
+    "UnboxAIRequest",
+    "Domains",
+    "UserHistoryInput",
+    "SimilarItemsRequest",
+    "EmbedJobDetails",
+    "JobStatus",
+    "ItemsRejected",
+    "RejectedItem",
+    "Item",
+    "ItemsPage",
+    "CartItem",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name in http.DEPRECATED_NAMES:
+        new = http.DEPRECATED_NAMES[name]
+        warnings.warn(
+            f"`{name}` is deprecated, use `{new}`", DeprecationWarning, stacklevel=2
+        )
+        return getattr(http, new)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

behaviorgpt/types/domains.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class Domains(BaseModel):
+    market: str
+    postal_code: str = "unk"
+    gender: str = "unk"
+    age_group: str = "unk"

behaviorgpt/types/events.py

@@ -0,0 +1,114 @@
+import warnings
+from datetime import UTC, datetime
+from typing import List, Literal, Optional, Sequence, Tuple, Union
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+from behaviorgpt.types.domains import Domains
+
+
+class _ItemEvent(BaseModel):
+    # the API calls the item "product"
+    model_config = ConfigDict(serialize_by_alias=True)
+
+    item: str = Field(
+        validation_alias=AliasChoices("item", "product"),
+        serialization_alias="product",
+    )
+
+    def __init__(self, item: Optional[str] = None, **data):
+        if "product" in data:
+            warnings.warn(
+                "`product=` is deprecated, use `item=`",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            product = data.pop("product")
+            item = product if item is None else item
+        if item is not None:
+            data["item"] = item
+        super().__init__(**data)
+
+    @property
+    def product(self) -> str:
+        warnings.warn(
+            "`.product` is deprecated, use `.item`", DeprecationWarning, stacklevel=2
+        )
+        return self.item
+
+
+class CartItem(_ItemEvent):
+    quantity: int
+
+    def __init__(
+        self, item: Optional[str] = None, quantity: Optional[int] = None, **data
+    ):
+        if quantity is not None:
+            data["quantity"] = quantity
+        super().__init__(item, **data)
+
+
+class Search(BaseModel):
+    type: Literal["search"] = "search"
+    query: str
+
+    def __init__(self, query: Optional[str] = None, **data):
+        if query is not None:
+            data["query"] = query
+        super().__init__(**data)
+
+
+class View(_ItemEvent):
+    type: Literal["viewItem"] = "viewItem"
+
+
+class AddToCart(_ItemEvent):
+    type: Literal["addToCart"] = "addToCart"
+
+
+class RemoveFromCart(_ItemEvent):
+    type: Literal["removeFromCart"] = "removeFromCart"
+
+
+class Order(BaseModel):
+    type: Literal["order"] = "order"
+
+    cart_id: Optional[str] = None
+    items: Optional[List[CartItem]] = None
+
+    def __init__(
+        self,
+        cart_id: Optional[str] = None,
+        items: Optional[List[Union[CartItem, Tuple[str, int]]]] = None,
+        **data,
+    ):
+        if cart_id is not None:
+            data["cart_id"] = cart_id
+
+        if items is not None:
+            parsed_items = []
+            for entry in items:
+                if isinstance(entry, tuple):
+                    item_id, quantity = entry
+                    parsed_items.append(CartItem(item_id, quantity))
+                else:
+                    parsed_items.append(entry)
+
+            data["items"] = parsed_items
+
+        super().__init__(**data)
+
+
+UserEvent = Union[Search, AddToCart, View, RemoveFromCart, Order]
+
+
+class SessionEvent(BaseModel):
+    store_id: str
+    domains: Domains
+    timezone: str
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(tz=UTC))
+    event: UserEvent
+    session_id: str
+
+
+UserHistoryInput = Union[Sequence[UserEvent], Sequence[Sequence[UserEvent]]]

behaviorgpt/types/http.py

@@ -0,0 +1,231 @@
+import warnings
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+from behaviorgpt.types.domains import Domains
+from behaviorgpt.types.events import SessionEvent
+
+
+class Item(BaseModel):
+    id: str
+    data: dict
+    score: float
+
+    def extract_price(self, market: str | None = None) -> Optional[float]:
+        if "price" in self.data:
+            return self.data["price"]
+
+        markets = self.data.get("markets", {})
+        if isinstance(markets, dict):
+            market_data = markets.get(market)
+            if isinstance(market_data, dict) and "price" in market_data:
+                return market_data["price"]
+        return None
+
+
+class ItemsPage(BaseModel):
+    items: List[Item]
+    offset: int
+    limit: int
+
+
+class UnboxAIRequest(BaseModel):
+    query: Optional[str] = Field(default=None)
+
+    history: List[SessionEvent] = Field(default_factory=list)
+    store_id: str
+    domains: Domains
+    timezone: str = "UTC"
+    limit: int = Field(default=10, ge=1, le=100)
+    offset: int = Field(default=0, ge=0)
+    filters: dict = Field(default_factory=dict)
+    register_event: bool = True
+    # The moment the prediction is made; the server uses the current time if unset.
+    timestamp: Optional[datetime] = None
+    # How many nearest-neighbour candidates the server explores.
+    num_candidates: Optional[int] = Field(default=None, gt=0, le=5_000)
+
+    @field_validator("timestamp")
+    @classmethod
+    def require_timezone(cls, timestamp: Optional[datetime]) -> Optional[datetime]:
+        if timestamp is not None and timestamp.tzinfo is None:
+            raise ValueError("timestamp must be timezone-aware")
+        return timestamp
+
+    @model_validator(mode="after")
+    def validate_pagination(self) -> "UnboxAIRequest":
+        if self.offset + self.limit > 10000:
+            raise ValueError("Offset + limit cannot exceed 10,000")
+        return self
+
+
+class UnboxAIResponse(BaseModel):
+    items: List[Item]
+    offset: int
+    limit: int
+
+    market: Optional[str] = Field(default=None, exclude=True)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _flatten_products(cls, data: Any) -> Any:
+        # the API nests the page under "products"
+        if isinstance(data, dict) and "products" in data:
+            data = dict(data)
+            products = data.pop("products")
+            if isinstance(products, ItemsPage):
+                products = products.model_dump()
+            data = {**products, **data}
+        return data
+
+    @property
+    def products(self) -> ItemsPage:
+        warnings.warn(
+            "`response.products` is deprecated; use `response.items`, "
+            "`response.offset` and `response.limit`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return ItemsPage(items=self.items, offset=self.offset, limit=self.limit)
+
+    @property
+    def names(self) -> List[str]:
+        return [item.data.get("name", "Unknown") for item in self.items]
+
+    @property
+    def mean_price(self) -> Optional[float]:
+        prices = []
+        for item in self.items:
+            price = item.extract_price(self.market)
+            if price is not None:
+                try:
+                    prices.append(float(price))
+                except (ValueError, TypeError):
+                    pass
+
+        return sum(prices) / len(prices) if prices else None
+
+    def to_pandas(self) -> "pd.DataFrame":
+        # pandas is optional: only this method needs it
+        try:
+            import pandas as pd
+        except ImportError:
+            raise ImportError(
+                "to_pandas() needs pandas; install it with `pip install pandas`"
+            ) from None
+
+        items_data = []
+        for item in self.items:
+            flat_item = {"id": item.id, "score": item.score, **item.data}
+            flat_item["price"] = item.extract_price(self.market)
+            items_data.append(flat_item)
+
+        return pd.DataFrame(items_data)
+
+
+class EmbedJobDetails(BaseModel):
+    job_id: str
+    catalog_id: str
+    # display label derived from the uploaded file name, server-side
+    catalog_name: str
+    uri: str
+
+
+class SimilarItemsRequest(BaseModel):
+    model_config = ConfigDict(serialize_by_alias=True)
+
+    item_id: str = Field(
+        validation_alias=AliasChoices("item_id", "product_id"),
+        serialization_alias="product_id",
+    )
+    store_id: str
+    limit: int = Field(default=10, ge=1, le=100)
+    offset: int = Field(default=0, ge=0)
+    filters: dict = Field(default_factory=dict)
+
+
+class RejectedItem(BaseModel):
+    id: str
+    # why the index refused it, e.g. "failed to parse field [stock] of type
+    # [long]"
+    reason: str
+
+
+class ItemsRejected(BaseModel):
+    """Items left out of a catalog that is otherwise ready: the index refused
+    them for their content. Fix those rows and re-upload to add them."""
+
+    count: int
+    total: int
+    # the first of them (at most 100); "products" on the wire
+    items: List[RejectedItem] = Field(
+        default_factory=list, validation_alias=AliasChoices("items", "products")
+    )
+
+    def describe(self) -> str:
+        ids = ", ".join(repr(i.id) for i in self.items[:3])
+        more = f" and {self.count - 3} more" if self.count > 3 else ""
+        return f"{self.count} of {self.total} items rejected: {ids}{more}"
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: str
+    stage: Optional[str] = None
+    stage_state: Optional[str] = None
+    phase: Optional[str] = None
+    done: Optional[int] = None
+    total: Optional[int] = None
+    # why the job failed, e.g. "catalog parquet is empty"; only set when
+    # status is "failed", and not for every failure
+    error: Optional[str] = None
+    # items left out of a ready catalog; the job still succeeded.
+    # "products_rejected" on the wire
+    items_rejected: Optional[ItemsRejected] = Field(
+        default=None,
+        validation_alias=AliasChoices("items_rejected", "products_rejected"),
+    )
+
+    def describe(self) -> str:
+        """One line for progress output: 'embed fetching 5000/20000',
+        'embed failed: <reason>', or 'ingest done (2 of 20000 items
+        rejected: ...)'."""
+        if self.stage is None:
+            return self.status
+        step = self.phase or self.stage_state or ""
+        if self.done is not None and self.total is not None:
+            step = f"{step} {self.done}/{self.total}"
+        line = f"{self.stage} {step}".strip()
+        if self.error:
+            line = f"{line}: {self.error}"
+        if self.items_rejected:
+            line = f"{line} ({self.items_rejected.describe()})"
+        return line
+
+
+DEPRECATED_NAMES = {
+    "ProductResponse": "ItemsPage",
+    "SimilarProductsRequest": "SimilarItemsRequest",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in DEPRECATED_NAMES:
+        new = DEPRECATED_NAMES[name]
+        warnings.warn(
+            f"`{name}` is deprecated, use `{new}`", DeprecationWarning, stacklevel=2
+        )
+        return globals()[new]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

behaviorgpt-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: behaviorgpt
+Version: 0.1.0
+Summary: Python client for BehaviorGPT, UnboxAI's Large Behavioral Model for search, recommendations and personalization
+Keywords: recommendations,personalization,search,behavioral model,unboxai
+Author: Unbox AI
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pyarrow>=25.0.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Python: >=3.11
+Project-URL: Homepage, https://unboxai.com/behaviorgpt
+Project-URL: Repository, https://github.com/Unbox-AI/behaviorgpt
+Project-URL: Demo, https://behaviorgpt.unboxai.com/
+Description-Content-Type: text/markdown
+
+# BehaviorGPT
+
+**The foundation model for behavior.**
+
+**BehaviorGPT** is UnboxAI's Large Behavioral Model. It is trained on long sequences of things people actually did (viewed this, added that, bought the other) and predicts what comes next, so search, recommendations and personalization are the same call with different histories. BehaviorGPT-v4 is a single 12.5B-parameter model pretrained on 150 billion user actions across retail, engagement and payments, and it ranks catalogs it has never seen with no training.
+
+[Website](https://unboxai.com/behaviorgpt) · [Live demo](https://behaviorgpt.unboxai.com/) · [Research](https://research.unboxai.com) · [Notebook](https://github.com/Unbox-AI/behaviorgpt/blob/main/notebooks/showcase.ipynb)
+
+This repository holds the Python client for the UnboxAI API and a notebook that walks through the model step by step.
+
+## Requirements
+
+- An UnboxAI API key. Create & copy the key at [unboxai.com/behaviorgpt](https://unboxai.com/behaviorgpt); the key also arrives by email.
+- Python 3.11 or newer.
+
+## Quick start
+
+```sh
+pip install behaviorgpt
+export UNBOXAI_API_KEY=...   # or pass api_key= to UnboxAIClient
+```
+
+```python
+from behaviorgpt import Search, UnboxAIClient, View
+
+client = UnboxAIClient(market="us")
+
+# a history of one search
+res = client.complete([Search("running shoes")], limit=5)
+print(res.names)
+
+# the same call, personalized: a viewed item (Nike pants), then a query
+res = client.complete([View("paB08NYK61PJ"), Search("shoes")], limit=5)
+print(res.names)
+
+# items close to one another in the model's space
+print(client.similar_items(res.items[0].id).names)
+```
+
+`complete` takes the history and returns the items most likely to come next. Each result in `res.items` has an `id`, a `score` and the catalog row in `data`; `res.to_pandas()` gives a DataFrame if pandas is installed.
+
+## How it works
+
+- **One call, many features.** Every request asks the same question: given what this person did, which items are they most likely to act on next? The history picks the feature. End it with a `Search` for search results, with a `View` for "more like this", with an `Order` for what is bought next; leave it empty for a cold start.
+- **The whole sequence counts.** The model reads the history in order, so the same query means different things after different actions: "gloves" after "golf clubs" returns golf gloves. `market` on the client says where the user is, which helps most when the history is short.
+- **Items are read from their content, not their ids.** Each item is embedded from its name, brand, categories, image and price. That is why the model can rank a catalog it has never seen as soon as it is uploaded, with no interaction data and no training, and why those columns decide how well it does ([catalog format](https://github.com/Unbox-AI/behaviorgpt/blob/main/docs/catalog-format.md)).
+- **One pass per request.** Item vectors are computed once when the catalog is embedded, so ranking the whole catalog costs one forward pass over the history rather than one per item: the model itself takes under a millisecond per query, and most of an API call's time is the network.
+
+## The notebook
+
+[`notebooks/showcase.ipynb`](https://github.com/Unbox-AI/behaviorgpt/blob/main/notebooks/showcase.ipynb) covers the model in eight steps: setup, a first query, one call for many features, how context changes the answer, then embedding your own catalog, inspecting the embedding space, querying it, and trying it in the demo.
+
+Needs [uv](https://github.com/astral-sh/uv). Clone, install, add your key, register the kernel, start JupyterLab:
+
+```sh
+git clone https://github.com/Unbox-AI/behaviorgpt.git
+cd behaviorgpt
+uv sync
+cp .env.example .env   # paste your key as UNBOXAI_API_KEY
+uv run ipython kernel install --user --env VIRTUAL_ENV $(pwd)/.venv --name=behaviorgpt-env
+uv run jupyter lab
+```
+
+JupyterLab opens in your browser. Open the notebook and pick the `behaviorgpt-env` kernel.
+
+## Your own catalog
+
+The model can only return items it knows about. Out of the box the client uses `retail_catalog`, a sample retail catalog. To use the model on your own data, upload your catalog as a parquet file. A catalog doesn't have to be products for sale: artworks, articles, listings or anything else people browse and pick from work the same way.
+
+- The required columns and types are described in [`docs/catalog-format.md`](https://github.com/Unbox-AI/behaviorgpt/blob/main/docs/catalog-format.md).
+- A catalog can hold at most 20 000 items.
+- Each API key can hold 2 catalogs. The file name is the catalog's name: uploading a file with the same name again refreshes that catalog and keeps its `catalog_id`, and a new name takes one of the 2 slots. A failed upload does not use up a slot. Once both slots are in use, an upload under a new name is refused; to remove a catalog or raise the limit, contact alexander@unboxai.com.
+- [`examples/sample_catalog.csv`](https://github.com/Unbox-AI/behaviorgpt/blob/main/examples/sample_catalog.csv) is an example only, showing what each column should contain. Your own file will look different depending on your catalog, and it has to be converted to the parquet structure described in the format doc before upload.
+
+```python
+job = client.embed("my_catalog.parquet", wait=True, timeout=1800.0)
+client.complete([Search("...")], catalog_id=job.catalog_id)
+```
+
+If mapping your data to the format is hard, open a coding agent in this directory and ask it to embed your catalog. The repo ships a skill at [`.claude/skills/embed-catalog/SKILL.md`](https://github.com/Unbox-AI/behaviorgpt/blob/main/.claude/skills/embed-catalog/SKILL.md) that walks the agent through mapping your columns, building and validating the parquet, checking image URLs, and uploading. Claude Code picks it up automatically; for other agents, point them at that file.
+
+### Events
+
+A history is a list of `Search`, `View`, `AddToCart`, `RemoveFromCart` and `Order` events. The names come from a store because that is what the API accepts, but they work for any catalog: map your users' actions by meaning. Curate my wall, below, sends "look closer" as `View`, "hang it on the wall" as `AddToCart` and "take it down" as `RemoveFromCart`.
+
+## Demo and examples
+
+Two apps built on this SDK, one on a store's catalog and one on a museum's:
+
+<table>
+  <tr>
+    <td width="50%"><a href="https://behaviorgpt.unboxai.com/"><img src="https://raw.githubusercontent.com/Unbox-AI/behaviorgpt/main/docs/images/storefront.png" alt="The storefront demo: after a search for golf clubs, a search for gloves returns golf gloves"></a></td>
+    <td width="50%"><a href="https://github.com/Unbox-AI/aic-artworks"><img src="https://raw.githubusercontent.com/Unbox-AI/behaviorgpt/main/docs/images/curate-my-wall.png" alt="Curate my wall: three Hokusai prints hung on the wall, and the fashion they lead to: printed scarves, a tiger-print tee and a kimono"></a></td>
+  </tr>
+  <tr>
+    <td><b>Storefront</b> (<a href="https://behaviorgpt.unboxai.com/">live demo</a>). "gloves" after "golf clubs" returns golf gloves; the panel shows the history the model read.</td>
+    <td><b>Curate my wall</b> (<a href="https://aic-artworks.streamlit.app/">live app</a>, <a href="https://github.com/Unbox-AI/aic-artworks">source</a>). Hang three Hokusai prints and the same clicks pick your clothes: scarves and kimonos from an art history alone.</td>
+  </tr>
+</table>
+
+- [behaviorgpt.unboxai.com](https://behaviorgpt.unboxai.com/): a storefront, with recommendations, personalized search and a cart driven by the shopper's clicks. To try it on your catalog once it is embedded, select the **BehaviorGPT V4.0-12.5B** model, choose **Bring your own catalog** and enter your API key. Images must be publicly reachable for the demo to display them.
+- [Curate my wall](https://github.com/Unbox-AI/aic-artworks) ([live app](https://aic-artworks.streamlit.app/)): an art recommender over 19 000 public-domain artworks from the Art Institute of Chicago. It shows the whole path for a catalog that isn't products: turning an open dataset into a catalog, embedding it, and driving recommendations, search, similar items and the embedding map from a visitor's clicks.
+  - **Art to fashion.** Its fashion pilot puts H&M clothing in the same catalog as the art, and the "Fashion for you" tab ranks it from the visitor's art clicks alone: kimonos for Japanese prints, beaded bracelets for ancient Egypt, statement earrings for portraits. No event in the history involves clothing. It works because both are in one catalog, so a history of art clicks ranks the clothing too; a `filters` query keeps the art grids art-only.

behaviorgpt-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+behaviorgpt/__init__.py,sha256=WuQvNsYB-9utGPSM5_JnThXDWadiUcFILLRjfUS3Sms,567
+behaviorgpt/_client.py,sha256=EyecH4skfmDJoZgK5-RvdOKGoU6bxG-8B6RycWBVheA,9704
+behaviorgpt/_exceptions.py,sha256=w6Pyv3OWZzjmWJE99_7qbsTeYDo9BmieDwDdFyRUodw,643
+behaviorgpt/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+behaviorgpt/resources/_shared.py,sha256=v9R5OSSvsZoKqnTG4TubR3hdTV5sehG3au3gTnp_Vvs,1151
+behaviorgpt/resources/catalogs.py,sha256=W6Y5fTT9G_5DTabACPONcZF3rXNPfI3vgPHdxgGBjig,9926
+behaviorgpt/resources/recommendations.py,sha256=Nfghb-Tn3KSecMADVgJr0ezi9fc1ZBHoh8winJ4UxGU,841
+behaviorgpt/resources/requests.py,sha256=C_Amb8Z2jJ10V_f2qqVLVIPafbn0HSw6eXt_d5o6kuE,1153
+behaviorgpt/resources/search.py,sha256=zPkAzuI4Wd5AWY__LtpOhCr2FjKIUoRqcGV1S0so6Ts,816
+behaviorgpt/types/__init__.py,sha256=IkNlI23w2eJ7PLgZtgQuoyAcAsmYB6UY0PtBfsm7cqA,1213
+behaviorgpt/types/domains.py,sha256=-5Icp5Ht6cjWEWMwaV_7bS_YogidWqPy6lduEQ9TB8k,155
+behaviorgpt/types/events.py,sha256=NoOvXaVM1qAWcxiT4AE9IzUhle94GnwXIPMWk5hosFU,2990
+behaviorgpt/types/http.py,sha256=jhUIxp7t4PUVT58CXvyu560coTIFOUiO20X8T3ejhbE,7252
+behaviorgpt-0.1.0.dist-info/licenses/LICENSE,sha256=KcHDCiQNYi6VcKVJ1WweRNLLZGhaurYfRDFtQsQLcUg,1065
+behaviorgpt-0.1.0.dist-info/WHEEL,sha256=xTCBFIZIIyRSxyowOv5Wqg_jFU6KsdIffuulBB09Ph8,80
+behaviorgpt-0.1.0.dist-info/METADATA,sha256=I6hebGae26y2wSh1TUk6NrVTwzm077sO9UzG9lSU9Bo,9303
+behaviorgpt-0.1.0.dist-info/RECORD,,

behaviorgpt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.0
+Root-Is-Purelib: true
+Tag: py3-none-any

behaviorgpt-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unbox AI
+
+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.