simpro-py-sdk 0.1.0__py3-none-any.whl

simpro/__init__.py

@@ -0,0 +1,31 @@
+"""simpro-py: a thin Python client for the SimPro Cloud REST API (v1.0).
+
+Quickstart::
+
+    from simpro import SimproClient
+
+    client = SimproClient("https://yourtenant.simprosuite.com", "API_KEY")
+    for customer in client.customers.iter_all(0):
+        print(customer["ID"], customer.get("CompanyName"))
+"""
+
+from simpro.client import SimproClient
+from simpro.exceptions import (
+    SimproAuthError,
+    SimproError,
+    SimproNotFound,
+    SimproRateLimitError,
+    SimproValidationError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "SimproAuthError",
+    "SimproClient",
+    "SimproError",
+    "SimproNotFound",
+    "SimproRateLimitError",
+    "SimproValidationError",
+    "__version__",
+]

simpro/_util.py

@@ -0,0 +1,19 @@
+"""Internal helpers shared by the client and the resource modules."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from email.utils import format_datetime
+
+API_PREFIX = "/api/v1.0"
+MAX_PAGE_SIZE = 250
+
+
+def format_http_date(dt: datetime) -> str:
+    """Format ``dt`` as an RFC 1123 date string (UTC), for ``If-Modified-Since``.
+
+    Naive datetimes are treated as UTC.
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return format_datetime(dt.astimezone(UTC), usegmt=True)

simpro/client.py

@@ -0,0 +1,152 @@
+"""The SimPro Cloud REST API client.
+
+Every request URL is built in one place (``_request``) as
+``{base}/api/v1.0{path}``; if ``base_url`` already ends with ``/api/v1.0``
+the prefix is stripped first, so the well-known doubling trap (simPRO
+answers 404 ``Invalid route``) is impossible by construction.
+
+The client is intentionally thin: no retry, no rate limiting, no caching.
+SimPro allows roughly 10 requests/second per key — callers with bulk pulls
+should pace requests and retry 429s/transport errors themselves.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self
+
+import httpx
+
+from simpro._util import API_PREFIX
+from simpro.exceptions import (
+    SimproAuthError,
+    SimproError,
+    SimproNotFound,
+    SimproRateLimitError,
+    SimproValidationError,
+)
+from simpro.resources import Companies, Customers, Jobs, Sites
+
+DEFAULT_TIMEOUT = 30.0
+
+
+class SimproClient:
+    """Synchronous client for the SimPro Cloud REST API (v1.0).
+
+    Args:
+        base_url: Tenant root, e.g. ``https://yourtenant.simprosuite.com``.
+            A trailing ``/api/v1.0`` is tolerated and stripped.
+        api_key: API key bearer token (SimPro > Administration > API Keys).
+        timeout: Per-request timeout in seconds.
+        transport: Optional ``httpx`` transport override (testing/proxies).
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        base = base_url.rstrip("/").removesuffix(API_PREFIX)
+        self._base = base
+        self._http = httpx.Client(
+            timeout=timeout,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Accept": "application/json",
+            },
+            transport=transport,
+        )
+        # Resource namespaces.
+        self.companies = Companies(self)
+        self.customers = Customers(self)
+        self.sites = Sites(self)
+        self.jobs = Jobs(self)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """Close the underlying connection pool."""
+        self._http.close()
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> httpx.Response:
+        """Perform one API request and map failures to typed exceptions.
+
+        ``path`` is relative to the API prefix and starts with ``/``,
+        e.g. ``/companies/0/customers/``. A 304 (If-Modified-Since hit) is
+        returned to the caller as a normal response.
+        """
+        url = f"{self._base}{API_PREFIX}{path}"
+        try:
+            response = self._http.request(method, url, params=params, headers=headers)
+        except httpx.HTTPError as exc:
+            raise SimproError(f"SimPro request failed: {exc}") from exc
+        _raise_for_status(response)
+        return response
+
+
+def _raise_for_status(response: httpx.Response) -> None:
+    status = response.status_code
+    if status < 400 or status == 304:
+        return
+    if status in (401, 403):
+        raise SimproAuthError(
+            f"SimPro rejected the credentials (HTTP {status})", status_code=status
+        )
+    if status == 404:
+        raise SimproNotFound(f"SimPro resource not found: {response.url}", status_code=status)
+    if status == 429:
+        raise SimproRateLimitError(
+            "SimPro rate limit exceeded; retry after a pause", status_code=status
+        )
+    if status == 422:
+        message, details = _parse_validation_body(response)
+        raise SimproValidationError(message, details=details, status_code=status)
+    raise SimproError(
+        f"SimPro request failed with HTTP {status}: {response.text[:200]}",
+        status_code=status,
+    )
+
+
+def _parse_validation_body(
+    response: httpx.Response,
+) -> tuple[str, list[dict[str, Any]]]:
+    """Extract a message and error details from a 422 body.
+
+    SimPro 422 bodies are ``{"errors": [{"path", "message", "value"}, ...]}``
+    — but the ``errors`` key may be absent, and the body may not be JSON at
+    all. Both shapes degrade gracefully.
+    """
+    try:
+        body: Any = response.json()
+    except ValueError:
+        body = None
+    if isinstance(body, dict):
+        errors = body.get("errors")
+        details = [e for e in errors if isinstance(e, dict)] if isinstance(errors, list) else []
+        message = body.get("message") if isinstance(body.get("message"), str) else None
+        if message is None:
+            message = "SimPro rejected the request payload (HTTP 422)"
+        if details:
+            summary = "; ".join(
+                f"{d.get('path', '?')}: {d.get('message', '')}" for d in details[:5]
+            )
+            message = f"{message} — {summary}"
+        return message, details
+    if isinstance(body, list):
+        details = [e for e in body if isinstance(e, dict)]
+        return "SimPro rejected the request payload (HTTP 422)", details
+    return f"SimPro rejected the request payload (HTTP 422): {response.text[:200]}", []

simpro/exceptions.py

@@ -0,0 +1,49 @@
+"""Exception hierarchy for the simpro client.
+
+Every HTTP failure is mapped to one of these types in one place
+(``simpro.client``); transport-level failures raise ``SimproError``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class SimproError(Exception):
+    """Base error for all simpro failures (transport or HTTP)."""
+
+    def __init__(self, message: str, *, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class SimproAuthError(SimproError):
+    """SimPro rejected the request as unauthenticated or unauthorised (401/403)."""
+
+
+class SimproNotFound(SimproError):
+    """The requested SimPro resource does not exist (404)."""
+
+
+class SimproRateLimitError(SimproError):
+    """SimPro rate limit exceeded (429). Retry after a pause; the SDK does not retry."""
+
+
+class SimproValidationError(SimproError):
+    """SimPro rejected the request payload (422).
+
+    ``details`` carries the raw error list when the response body provides
+    one: SimPro returns ``{"errors": [{"path", "message", "value"}, ...]}``
+    but the ``errors`` key may be absent, in which case ``details`` is empty
+    and the message carries whatever the body offered.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        details: list[dict[str, Any]] | None = None,
+        status_code: int | None = None,
+    ) -> None:
+        super().__init__(message, status_code=status_code)
+        self.details = details if details is not None else []

simpro/resources/__init__.py

@@ -0,0 +1,8 @@
+"""Resource namespaces attached to :class:`~simpro.SimproClient`."""
+
+from simpro.resources.companies import Companies
+from simpro.resources.customers import Customers
+from simpro.resources.jobs import Jobs
+from simpro.resources.sites import Sites
+
+__all__ = ["Companies", "Customers", "Jobs", "Sites"]

simpro/resources/_base.py

@@ -0,0 +1,155 @@
+"""Resource namespace base classes.
+
+``CompanyScopedResource`` implements the shared GET/list/iter_all shape for
+resources under ``/companies/{companyID}/<resource>/``. Pagination follows
+the SimPro convention: ``page`` + ``pageSize`` query params, list bodies are
+plain JSON arrays, and the continuation signal is the ``Result-Pages``
+response header (total page count). When the header is absent the walk falls
+back to stopping on a short page.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from simpro._util import MAX_PAGE_SIZE, format_http_date
+
+if TYPE_CHECKING:
+    from simpro.client import SimproClient
+
+
+class Resource:
+    """A resource namespace attached to a :class:`~simpro.SimproClient`."""
+
+    def __init__(self, client: SimproClient) -> None:
+        self._client = client
+
+
+class CompanyScopedResource(Resource):
+    """GET-only resource under ``/companies/{companyID}/``."""
+
+    _resource: str
+
+    def list(
+        self,
+        company_id: int,
+        *,
+        search: str | None = None,
+        page: int = 1,
+        per_page: int = 250,
+        modified_since: datetime | None = None,
+        **filters: Any,
+    ) -> list[dict[str, Any]]:
+        """Fetch one page of results.
+
+        Args:
+            company_id: SimPro company ID (0 unless multi-company).
+            search: Verbatim ``search`` query param — SimPro's documented
+                values are ``"all"``/``"any"`` (match mode for the field
+                filters passed via ``**filters``).
+            page: 1-based page number.
+            per_page: Page size, clamped to SimPro's max of 250.
+            modified_since: Watermark for list endpoints — sent as an
+                ``If-Modified-Since`` header; a 304 answer yields ``[]``.
+            **filters: Extra query params, passed through verbatim
+                (e.g. ``Name="Acme"``).
+        """
+        response = self._list_page(
+            company_id,
+            page=page,
+            per_page=per_page,
+            search=search,
+            modified_since=modified_since,
+            **filters,
+        )
+        if response.status_code == 304:
+            return []
+        data: Any = response.json()
+        return data if isinstance(data, list) else [data]
+
+    def get(self, company_id: int, resource_id: int) -> dict[str, Any]:
+        """Fetch one record by ID."""
+        response = self._client._request(
+            "GET", f"/companies/{company_id}/{self._resource}/{resource_id}"
+        )
+        data: Any = response.json()
+        return data
+
+    def iter_all(
+        self,
+        company_id: int,
+        *,
+        per_page: int = MAX_PAGE_SIZE,
+        modified_since: datetime | None = None,
+        **filters: Any,
+    ) -> Iterator[dict[str, Any]]:
+        """Yield every record, walking pages until exhausted.
+
+        Stops when the page number reaches the ``Result-Pages`` response
+        header, or — if that header is missing — when a page comes back
+        shorter than ``per_page``.
+        """
+        page_size = _clamp_page_size(per_page)
+        page = 1
+        while True:
+            response = self._list_page(
+                company_id,
+                page=page,
+                per_page=page_size,
+                search=None,
+                modified_since=modified_since,
+                **filters,
+            )
+            if response.status_code == 304:
+                return
+            data: Any = response.json()
+            items = data if isinstance(data, list) else [data]
+            yield from items
+            if not _has_more_pages(response, page, len(items), page_size):
+                return
+            page += 1
+
+    def _list_page(
+        self,
+        company_id: int,
+        *,
+        page: int,
+        per_page: int,
+        search: str | None,
+        modified_since: datetime | None,
+        **filters: Any,
+    ) -> Any:
+        params: dict[str, Any] = {
+            "page": page,
+            "pageSize": _clamp_page_size(per_page),
+        }
+        if search is not None:
+            params["search"] = search
+        params.update(filters)
+        headers: dict[str, str] | None = None
+        if modified_since is not None:
+            headers = {"If-Modified-Since": format_http_date(modified_since)}
+        return self._client._request(
+            "GET",
+            f"/companies/{company_id}/{self._resource}/",
+            params=params,
+            headers=headers,
+        )
+
+
+def _clamp_page_size(per_page: int) -> int:
+    return max(1, min(per_page, MAX_PAGE_SIZE))
+
+
+def _has_more_pages(response: Any, page: int, items_on_page: int, page_size: int) -> bool:
+    raw = response.headers.get("Result-Pages")
+    if raw is not None:
+        try:
+            total_pages = int(raw)
+        except ValueError:
+            total_pages = 0
+        if total_pages > 0:
+            return page < total_pages
+    return items_on_page >= page_size

simpro/resources/companies.py

@@ -0,0 +1,44 @@
+"""Companies endpoints: ``GET /api/v1.0/companies/``."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from simpro._util import format_http_date
+from simpro.resources._base import Resource
+
+
+class Companies(Resource):
+    """The companies the API key can see (usually exactly one)."""
+
+    def list(
+        self,
+        *,
+        search: str | None = None,
+        modified_since: datetime | None = None,
+        **filters: Any,
+    ) -> list[dict[str, Any]]:
+        """List companies.
+
+        SimPro does not document ``page``/``pageSize`` for this endpoint; the
+        response is a single unpaginated array. ``**filters`` and
+        ``modified_since`` behave as on other resources.
+        """
+        params: dict[str, Any] = dict(filters)
+        if search is not None:
+            params["search"] = search
+        headers: dict[str, str] | None = None
+        if modified_since is not None:
+            headers = {"If-Modified-Since": format_http_date(modified_since)}
+        response = self._client._request("GET", "/companies/", params=params, headers=headers)
+        if response.status_code == 304:
+            return []
+        data: Any = response.json()
+        return data if isinstance(data, list) else [data]
+
+    def get(self, company_id: int) -> dict[str, Any]:
+        """Fetch one company by ID."""
+        response = self._client._request("GET", f"/companies/{company_id}")
+        data: Any = response.json()
+        return data

simpro/resources/customers.py

@@ -0,0 +1,34 @@
+"""Customers endpoints: ``GET /api/v1.0/companies/{companyID}/customers/``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from simpro.exceptions import SimproNotFound
+from simpro.resources._base import CompanyScopedResource
+
+
+class Customers(CompanyScopedResource):
+    """Customers (company and individual)."""
+
+    _resource = "customers"
+
+    def get(self, company_id: int, customer_id: int) -> dict[str, Any]:
+        """Fetch one customer by ID.
+
+        SimPro splits single-customer GETs by type: company customers live at
+        ``/customers/companies/{ID}`` and individuals at
+        ``/customers/individuals/{ID}``. This method tries the company path
+        first and falls back to individuals, so callers need not know the
+        type up front.
+        """
+        try:
+            response = self._client._request(
+                "GET", f"/companies/{company_id}/customers/companies/{customer_id}"
+            )
+        except SimproNotFound:
+            response = self._client._request(
+                "GET", f"/companies/{company_id}/customers/individuals/{customer_id}"
+            )
+        data: Any = response.json()
+        return data

simpro/resources/jobs.py

@@ -0,0 +1,11 @@
+"""Jobs endpoints: ``GET /api/v1.0/companies/{companyID}/jobs/``."""
+
+from __future__ import annotations
+
+from simpro.resources._base import CompanyScopedResource
+
+
+class Jobs(CompanyScopedResource):
+    """Jobs (work orders / projects)."""
+
+    _resource = "jobs"

simpro/resources/sites.py

@@ -0,0 +1,11 @@
+"""Sites endpoints: ``GET /api/v1.0/companies/{companyID}/sites/``."""
+
+from __future__ import annotations
+
+from simpro.resources._base import CompanyScopedResource
+
+
+class Sites(CompanyScopedResource):
+    """Sites (addresses where work is performed)."""
+
+    _resource = "sites"

simpro_py_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.5
+Name: simpro-py-sdk
+Version: 0.1.0
+Summary: Python client for the SimPro Cloud REST API (v1.0).
+Project-URL: Homepage, https://github.com/xuanpablo/simpro-py
+Project-URL: Changelog, https://github.com/xuanpablo/simpro-py/releases
+Author: Paul Millar
+License: MIT License
+        
+        Copyright (c) 2016 Bradley McElroy
+        
+        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.
+License-File: LICENCE.txt
+Keywords: api,client,construction,simpro,simprosuite
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# simpro-py
+
+A thin Python client for the [SimPro Cloud REST API (v1.0)](https://www.simprogroup.com).
+
+```python
+from simpro import SimproClient
+
+client = SimproClient("https://yourtenant.simprosuite.com", "YOUR_API_KEY")
+
+for customer in client.customers.iter_all(0):
+    print(customer["ID"], customer.get("CompanyName") or customer.get("FamilyName"))
+```
+
+The distribution is `simpro-py-sdk`; the import name is `simpro`.
+
+## Install
+
+```bash
+pip install simpro-py-sdk
+```
+
+Requires Python 3.12+. The only runtime dependency is `httpx`.
+
+## Authentication
+
+SimPro API keys are bearer tokens — create one in SimPro under
+**Administration > API Keys** and pass it with your tenant base URL:
+
+```python
+client = SimproClient("https://yourtenant.simprosuite.com", "YOUR_API_KEY")
+```
+
+Every request is sent to `{base_url}/api/v1.0/...`. If your `base_url` already
+ends with `/api/v1.0` it is stripped automatically, so the well-known
+doubled-prefix 404 (`Invalid route`) cannot happen.
+
+## Resources
+
+0.1.x ships read-only access to the first-slice resources, one namespace per
+resource, hung off the client:
+
+| Namespace | Endpoints |
+|---|---|
+| `client.companies` | `list(*, search=None, modified_since=None, **filters)`, `get(company_id)` |
+| `client.customers` | `list(company_id, ...)`, `get(company_id, customer_id)`, `iter_all(company_id, **filters)` |
+| `client.sites` | `list(company_id, ...)`, `get(company_id, site_id)`, `iter_all(company_id, **filters)` |
+| `client.jobs` | `list(company_id, ...)`, `get(company_id, job_id)`, `iter_all(company_id, **filters)` |
+
+`company_id` is `0` unless your build uses SimPro multi-company.
+
+Notes:
+
+- **Single-customer GETs are type-split in SimPro** (company vs individual).
+  `client.customers.get(company_id, customer_id)` tries the company path first
+  and falls back to individuals, so callers never need the type up front.
+- **`search`** is SimPro's documented match-mode param (`"all"`/`"any"`) that
+  combines with field filters. Field filters themselves are passed verbatim as
+  extra keyword arguments, e.g. `client.customers.list(0, Name="Acme")`.
+- All methods return plain dicts/lists — no DTO layer by design.
+
+## Pagination
+
+`list()` fetches a single page (`page`, `per_page`, capped at SimPro's maximum
+of 250). `iter_all()` walks every page for you:
+
+```python
+for job in client.jobs.iter_all(0):
+    ...
+```
+
+Page continuation follows the SimPro convention: the `Result-Pages` response
+header carries the total page count; if it is absent, the walk stops on a
+short page.
+
+## Incremental pulls
+
+List endpoints honour the `If-Modified-Since` watermark. Pass
+`modified_since=<datetime>` and the client formats the header (RFC 1123, UTC)
+and maps a `304 Not Modified` answer to an empty result:
+
+```python
+since = last_sync_run_at  # aware datetime; naive values are treated as UTC
+new_customers = client.customers.list(0, modified_since=since)
+```
+
+## Errors
+
+All failures raise a subclass of `SimproError`:
+
+| Exception | HTTP status |
+|---|---|
+| `SimproAuthError` | 401, 403 |
+| `SimproNotFound` | 404 |
+| `SimproValidationError` | 422 (`.details` holds the raw error list) |
+| `SimproRateLimitError` | 429 |
+| `SimproError` | anything else, including transport failures |
+
+SimPro 422 bodies are normally `{"errors": [{"path", "message", "value"}, ...]}`
+but the `errors` key may be absent — both shapes are handled, and
+`SimproValidationError.details` is always a list.
+
+## Deliberate omissions
+
+- **No retry, no rate limiting, no caching.** SimPro allows roughly 10
+  requests/second per key; callers doing bulk pulls should pace requests and
+  retry 429s/transport errors themselves.
+- **No write endpoints** in 0.1.x — read-only first.
+- **No DTO layer** — responses are plain JSON dicts, so SDK releases never
+  lag the API.
+
+## Lineage
+
+This package is a clean rewrite of [`limx0/simpro-py`](https://github.com/limx0/simpro-py)
+(MIT), which wrapped SimPro's legacy on-prem JSON-RPC API. The rewrite targets
+the SimPro Cloud REST API and shares no code with the original; the MIT
+licence and lineage are retained with thanks.
+
+## Development
+
+```bash
+uv sync
+uv run pytest -q
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```
+
+## Licence
+
+MIT — see [LICENCE.txt](LICENCE.txt).

simpro_py_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+simpro/__init__.py,sha256=jOr3e-5Q90xcnnbCT5VlYWW0-WNzSsrRofFEIJhbRdc,696
+simpro/_util.py,sha256=w8YSQqZG69ZjRDoSW3oDPepMP3mhA-lou6vnN1FzznM,526
+simpro/client.py,sha256=3s6UeJXH_B4QO8i5qoeZvhz3CLB4MjAb2FMapOi0scw,5261
+simpro/exceptions.py,sha256=EIDWEPFB_E_t8h5VVTT5QSXkmA2P13iPqm5N6C07OGI,1531
+simpro/resources/__init__.py,sha256=VxSftq5kuRFaC3q8cAw5pUVT7BXRk1qetsGXgfviKKE,303
+simpro/resources/_base.py,sha256=NR8WlxYJXlKzwUG6FoaxFCVDGsDamu8srOf46limgUU,5007
+simpro/resources/companies.py,sha256=YW4VH-pKmYb8dNVPwvLtkEe978QmTg_UXBs6R6kEmxA,1505
+simpro/resources/customers.py,sha256=n18GrpSE7yBvimXU-oe2uQcmUlnJP9onU2xyOaGL3uM,1180
+simpro/resources/jobs.py,sha256=FfSZ6x0j0D9mblSuF_OptdTy7Mn6hxT57Y8qUnvV_1s,265
+simpro/resources/sites.py,sha256=G5MSuSkRs1y9duOisEmNNyN6m3S2UbefaLykeWq6X4o,281
+simpro_py_sdk-0.1.0.dist-info/METADATA,sha256=0UO-vXMjjGm37h3G03UjM7izPgvtRj57jFweqAoJCjQ,6378
+simpro_py_sdk-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+simpro_py_sdk-0.1.0.dist-info/licenses/LICENCE.txt,sha256=XnrdgBHxcaM6KE4rdWQb-3oJH2_I2OlEsi1s66bfkT4,1071
+simpro_py_sdk-0.1.0.dist-info/RECORD,,

simpro_py_sdk-0.1.0.dist-info/WHEEL

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

simpro_py_sdk-0.1.0.dist-info/licenses/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Bradley McElroy
+
+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.