softsolz 0.1.0__py3-none-any.whl

softsolz/__init__.py

@@ -0,0 +1,35 @@
+from . import webhooks
+from ._client import SoftSolz
+from ._http import DEFAULT_BASE_URL
+from ._version import __version__
+from .errors import (
+    APIConnectionError,
+    AuthenticationError,
+    ConflictError,
+    InvalidRequestError,
+    NotFoundError,
+    PaymentRequiredError,
+    PermissionDeniedError,
+    RateLimitError,
+    SoftSolzError,
+    WebhookSignatureError,
+)
+from .pagination import Page
+
+__all__ = [
+    "SoftSolz",
+    "Page",
+    "webhooks",
+    "DEFAULT_BASE_URL",
+    "SoftSolzError",
+    "InvalidRequestError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "PaymentRequiredError",
+    "NotFoundError",
+    "ConflictError",
+    "RateLimitError",
+    "APIConnectionError",
+    "WebhookSignatureError",
+    "__version__",
+]

softsolz/_client.py

@@ -0,0 +1,60 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ._http import DEFAULT_BASE_URL, HttpClient
+from .resources import build_resources
+
+
+class SoftSolz:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        self._http = HttpClient(
+            api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            transport=transport,
+        )
+        for name, resource in build_resources(self._http).items():
+            setattr(self, name, resource)
+
+    def whoami(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/whoami", options=options or None)
+
+    def services(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services", options=options or None)
+
+    def service_health(self, service_id: str, **options: Any) -> Any:
+        from ._http import _q
+
+        return self._http.request(
+            "GET", f"/api/v1/services/{_q(service_id)}/health", options=options or None
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        **options: Any,
+    ) -> Any:
+        return self._http.request(method, path, query=query, body=body, options=options or None)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "SoftSolz":
+        return self
+
+    def __exit__(self, *exc_info: Any) -> None:
+        self.close()

softsolz/_http.py

@@ -0,0 +1,153 @@
+import random
+import time
+import uuid
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+import httpx
+
+from ._version import __version__
+from .errors import APIConnectionError, error_from_response
+from .pagination import Page
+
+DEFAULT_BASE_URL = "https://app.softsolz.uk"
+
+_MUTATING_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+
+
+def _q(value: Any) -> str:
+    return quote(str(value), safe="")
+
+
+def _backoff_seconds(attempt: int) -> float:
+    return min(8.0, 0.5 * (2**attempt)) + random.random() * 0.25
+
+
+class HttpClient:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        if not api_key or not isinstance(api_key, str):
+            raise ValueError('SoftSolz: api_key is required, e.g. SoftSolz(api_key="sk_test_...")')
+        self._max_retries = max_retries
+        self._client = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            timeout=timeout,
+            transport=transport,
+            headers={
+                "authorization": f"Bearer {api_key}",
+                "accept": "application/json",
+                "user-agent": f"softsolz-python/{__version__}",
+            },
+        )
+
+    def envelope(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        response_kind: str = "json",
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        options = options or {}
+        method = method.upper()
+        headers: Dict[str, str] = {}
+        if options.get("request_id"):
+            headers["x-request-id"] = str(options["request_id"])
+        if method in _MUTATING_METHODS:
+            headers["idempotency-key"] = str(options.get("idempotency_key") or uuid.uuid4())
+        params = {k: v for k, v in (query or {}).items() if v is not None}
+        max_retries = int(options.get("max_retries", self._max_retries))
+        timeout = options.get("timeout")
+        attempt = 0
+        while True:
+            try:
+                response = self._client.request(
+                    method,
+                    path,
+                    params=params,
+                    json=body,
+                    headers=headers,
+                    timeout=timeout if timeout is not None else httpx.USE_CLIENT_DEFAULT,
+                )
+            except httpx.HTTPError as exc:
+                if attempt < max_retries:
+                    time.sleep(_backoff_seconds(attempt))
+                    attempt += 1
+                    continue
+                raise APIConnectionError(str(exc)) from exc
+            request_id = response.headers.get("softsolz-request-id")
+            if response.is_success:
+                if response_kind == "none" or response.status_code == 204:
+                    return {"data": None, "meta": None, "request_id": request_id}
+                if response_kind == "text":
+                    return {"data": response.text, "meta": None, "request_id": request_id}
+                if response_kind == "binary":
+                    return {"data": response.content, "meta": None, "request_id": request_id}
+                payload = self._safe_json(response)
+                if isinstance(payload, dict) and "data" in payload:
+                    data = payload.get("data")
+                    meta = payload.get("meta") if isinstance(payload.get("meta"), dict) else None
+                else:
+                    data = payload
+                    meta = None
+                return {"data": data, "meta": meta, "request_id": request_id}
+            retryable = response.status_code == 429 or response.status_code >= 500
+            if retryable and attempt < max_retries:
+                retry_after = response.headers.get("retry-after")
+                if retry_after and retry_after.isdigit() and int(retry_after) > 0:
+                    delay = float(retry_after)
+                else:
+                    delay = _backoff_seconds(attempt)
+                time.sleep(delay)
+                attempt += 1
+                continue
+            raise error_from_response(response.status_code, self._safe_json(response), request_id)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        response_kind: str = "json",
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        return self.envelope(
+            method, path, query=query, body=body, response_kind=response_kind, options=options
+        )["data"]
+
+    def page(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Dict[str, Any]] = None,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Page:
+        def fetch_page(offset: Optional[int]) -> Dict[str, Any]:
+            merged = dict(query or {})
+            if offset is not None:
+                merged["offset"] = offset
+            return self.envelope(method, path, query=merged, options=options)
+
+        return Page.create(fetch_page)
+
+    @staticmethod
+    def _safe_json(response: httpx.Response) -> Any:
+        try:
+            return response.json()
+        except ValueError:
+            return None
+
+    def close(self) -> None:
+        self._client.close()

softsolz/_version.py

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

softsolz/errors.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict, Optional
+
+
+class SoftSolzError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int = 0,
+        code: str = "unknown_error",
+        details: Optional[Dict[str, Any]] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.details = details
+        self.request_id = request_id
+
+
+class InvalidRequestError(SoftSolzError):
+    pass
+
+
+class AuthenticationError(SoftSolzError):
+    pass
+
+
+class PermissionDeniedError(SoftSolzError):
+    pass
+
+
+class PaymentRequiredError(SoftSolzError):
+    pass
+
+
+class NotFoundError(SoftSolzError):
+    pass
+
+
+class ConflictError(SoftSolzError):
+    pass
+
+
+class RateLimitError(SoftSolzError):
+    def __init__(self, message: str, *, retry_after_seconds: Optional[int] = None, **kwargs: Any) -> None:
+        super().__init__(message, **kwargs)
+        self.retry_after_seconds = retry_after_seconds
+
+
+class APIConnectionError(SoftSolzError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, status=0, code="connection_error")
+
+
+class WebhookSignatureError(Exception):
+    def __init__(self, reason: str) -> None:
+        super().__init__(f"Webhook signature verification failed: {reason}")
+        self.reason = reason
+
+
+_STATUS_TO_ERROR = {
+    400: InvalidRequestError,
+    401: AuthenticationError,
+    402: PaymentRequiredError,
+    403: PermissionDeniedError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: InvalidRequestError,
+}
+
+
+def error_from_response(status: int, body: Any, request_id: Optional[str] = None) -> SoftSolzError:
+    err = body.get("error") if isinstance(body, dict) else None
+    err = err if isinstance(err, dict) else {}
+    code = err.get("code") if isinstance(err.get("code"), str) else "unknown_error"
+    message = err.get("message") if isinstance(err.get("message"), str) else f"HTTP {status}"
+    details = err.get("details") if isinstance(err.get("details"), dict) else None
+    if status == 429:
+        retry_after = details.get("retry_after_seconds") if details else None
+        return RateLimitError(
+            message,
+            status=status,
+            code=code,
+            details=details,
+            request_id=request_id,
+            retry_after_seconds=retry_after if isinstance(retry_after, int) else None,
+        )
+    error_class = _STATUS_TO_ERROR.get(status, SoftSolzError)
+    return error_class(message, status=status, code=code, details=details, request_id=request_id)

softsolz/pagination.py

@@ -0,0 +1,39 @@
+from typing import Any, Callable, Dict, Iterator, List, Optional
+
+
+class Page:
+    def __init__(
+        self,
+        data: List[Any],
+        meta: Optional[Dict[str, Any]],
+        fetch_page: Callable[[Optional[int]], Dict[str, Any]],
+    ) -> None:
+        self.data = data
+        self.meta = meta
+        self._fetch_page = fetch_page
+
+    @classmethod
+    def create(cls, fetch_page: Callable[[Optional[int]], Dict[str, Any]]) -> "Page":
+        envelope = fetch_page(None)
+        return cls(envelope.get("data") or [], envelope.get("meta"), fetch_page)
+
+    @property
+    def has_more(self) -> bool:
+        return bool(self.meta) and self.meta.get("has_more") is True
+
+    def next_page(self) -> Optional["Page"]:
+        if not self.has_more or not self.meta:
+            return None
+        offset = int(self.meta.get("offset", 0)) + int(self.meta.get("limit", len(self.data)))
+        envelope = self._fetch_page(offset)
+        return Page(envelope.get("data") or [], envelope.get("meta"), self._fetch_page)
+
+    def __iter__(self) -> Iterator[Any]:
+        page: Optional[Page] = self
+        while page is not None:
+            for item in page.data:
+                yield item
+            page = page.next_page()
+
+    def auto_paging_iter(self) -> Iterator[Any]:
+        return iter(self)

softsolz/resources/__init__.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict
+
+from .._http import HttpClient
+from .blogs import BlogsResource
+from .customer_auth import CustomerAuthResource
+from .forms import FormsResource
+from .invoicing import InvoicingResource
+from .payments import PaymentsResource
+from .smart_chat import SmartChatResource
+from .social import SocialResource
+from .workflows import WorkflowsResource
+
+
+def build_resources(http: HttpClient) -> Dict[str, Any]:
+    return {
+        "blogs": BlogsResource(http),
+        "customer_auth": CustomerAuthResource(http),
+        "forms": FormsResource(http),
+        "invoicing": InvoicingResource(http),
+        "payments": PaymentsResource(http),
+        "smart_chat": SmartChatResource(http),
+        "social": SocialResource(http),
+        "workflows": WorkflowsResource(http),
+    }
+
+
+__all__ = [
+    "build_resources",
+    "BlogsResource",
+    "CustomerAuthResource",
+    "FormsResource",
+    "InvoicingResource",
+    "PaymentsResource",
+    "SmartChatResource",
+    "SocialResource",
+    "WorkflowsResource",
+]

softsolz/resources/blogs.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+
+
+class BlogsResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_published_posts(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/blogs/posts/published", options=options or None)
+
+    def get_published_post_by_slug(self, slug: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/blogs/posts/published/{_q(slug)}", options=options or None)
+
+    def get_posts(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/blogs/posts", options=options or None)
+
+    def get_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/blogs/posts/{_q(id)}", options=options or None)
+
+    def create_post(self, **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/blogs/posts", options=options or None)
+
+    def update_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/blogs/posts/{_q(id)}", options=options or None)
+
+    def update_post_status(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/blogs/posts/{_q(id)}/status", options=options or None)
+
+    def delete_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("DELETE", f"/api/v1/services/blogs/posts/{_q(id)}", options=options or None)
+
+    def get_categories(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/blogs/categories", options=options or None)
+
+    def get_analytics(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/blogs/analytics", options=options or None)
+
+    def get_subscribers(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/blogs/subscribers", options=options or None)
+
+    def create_subscriber(self, **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/blogs/subscribers", options=options or None)
+
+    def update_subscriber(self, id: Any, **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/blogs/subscribers/{_q(id)}", options=options or None)
+
+    def delete_subscriber(self, id: Any, **options: Any) -> Any:
+        return self._http.request("DELETE", f"/api/v1/services/blogs/subscribers/{_q(id)}", options=options or None)

softsolz/resources/customer_auth.py

@@ -0,0 +1,69 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class CustomerAuthResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_users(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/customer-auth/users", query=query, options=options or None)
+
+    def get_user(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/customer-auth/users/{_q(id)}", options=options or None)
+
+    def list_user_sessions(self, id: Any, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", f"/api/v1/services/customer-auth/users/{_q(id)}/sessions", query=query, options=options or None)
+
+    def create_user(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/users", body=body, options=options or None)
+
+    def update_user(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/customer-auth/users/{_q(id)}", body=body, options=options or None)
+
+    def delete_user(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/customer-auth/users/{_q(id)}", response_kind="none", options=options or None)
+
+    def logout_user(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/logout", options=options or None)
+
+    def verify_session(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/sessions/verify", body=body, options=options or None)
+
+    def update_user_profile(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/customer-auth/users/{_q(id)}/profile", body=body, options=options or None)
+
+    def create_user_email_verification(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/email-verifications", body=body, options=options or None)
+
+    def complete_email_verification(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/email-verifications/complete", body=body, options=options or None)
+
+    def change_user_password(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/password", body=body, options=options or None)
+
+    def create_password_reset(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/password-resets", body=body, options=options or None)
+
+    def complete_password_reset(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/password-resets/complete", body=body, options=options or None)
+
+    def enrol_user_mfa(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/mfa/enrol", options=options or None)
+
+    def confirm_user_mfa_enrol(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/mfa/enrol/confirm", body=body, options=options or None)
+
+    def disable_user_mfa(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/customer-auth/users/{_q(id)}/mfa/disable", options=options or None)
+
+    def create_session(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/sessions", body=body, options=options or None)
+
+    def complete_session_mfa(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/sessions/mfa", body=body, options=options or None)
+
+    def revoke_session(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/customer-auth/sessions/revoke", body=body, options=options or None)

softsolz/resources/forms.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class FormsResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_forms(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/forms/forms", query=query, options=options or None)
+
+    def get_form_by_slug(self, slug: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/forms/forms/by-slug/{_q(slug)}", options=options or None)
+
+    def get_form(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/forms/forms/{_q(id)}", options=options or None)
+
+    def create_form(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/forms/forms", body=body, options=options or None)
+
+    def update_form(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/forms/forms/{_q(id)}", body=body, options=options or None)
+
+    def delete_form(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/forms/forms/{_q(id)}", response_kind="none", options=options or None)
+
+    def list_form_submissions(self, id: Any, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", f"/api/v1/services/forms/forms/{_q(id)}/submissions", query=query, options=options or None)
+
+    def get_form_submission(self, id: Any, sub_id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/forms/forms/{_q(id)}/submissions/{_q(sub_id)}", options=options or None)
+
+    def update_form_submission(self, id: Any, sub_id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/forms/forms/{_q(id)}/submissions/{_q(sub_id)}", body=body, options=options or None)
+
+    def delete_form_submission(self, id: Any, sub_id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/forms/forms/{_q(id)}/submissions/{_q(sub_id)}", response_kind="none", options=options or None)
+
+    def download_form_submissions_csv(self, id: Any, **options: Any) -> str:
+        return self._http.request("GET", f"/api/v1/services/forms/forms/{_q(id)}/submissions.csv", response_kind="text", options=options or None)
+
+    def submit_form(self, slug: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/forms/forms/{_q(slug)}/submit", body=body, options=options or None)

softsolz/resources/invoicing.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class InvoicingResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_customers(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/invoicing/customers", query=query, options=options or None)
+
+    def get_customer(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/invoicing/customers/{_q(id)}", options=options or None)
+
+    def create_customer(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/invoicing/customers", body=body, options=options or None)
+
+    def update_customer(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PUT", f"/api/v1/services/invoicing/customers/{_q(id)}", body=body, options=options or None)
+
+    def delete_customer(self, id: Any, **options: Any) -> Any:
+        return self._http.request("DELETE", f"/api/v1/services/invoicing/customers/{_q(id)}", options=options or None)
+
+    def create_customer_portal_token(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/customers/{_q(id)}/portal-token", options=options or None)
+
+    def list_invoices(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/invoicing/invoices", query=query, options=options or None)
+
+    def get_invoice(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/invoicing/invoices/{_q(id)}", options=options or None)
+
+    def create_invoice(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/invoicing/invoices", body=body, options=options or None)
+
+    def update_invoice(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PUT", f"/api/v1/services/invoicing/invoices/{_q(id)}", body=body, options=options or None)
+
+    def post_invoice(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/invoices/{_q(id)}/post", options=options or None)
+
+    def send_invoice(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/invoices/{_q(id)}/send", options=options or None)
+
+    def void_invoice(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/invoices/{_q(id)}/void", body=body, options=options or None)
+
+    def mark_invoice_paid(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/invoices/{_q(id)}/mark-paid", body=body, options=options or None)
+
+    def remind_invoice(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/invoicing/invoices/{_q(id)}/remind", options=options or None)
+
+    def download_invoice_pdf(self, id: Any, **options: Any) -> bytes:
+        return self._http.request("GET", f"/api/v1/services/invoicing/invoices/{_q(id)}/pdf", response_kind="binary", options=options or None)
+
+    def list_recurring(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/invoicing/recurring", query=query, options=options or None)
+
+    def create_recurring(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/invoicing/recurring", body=body, options=options or None)
+
+    def create_credit_note(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/invoicing/credit-notes", body=body, options=options or None)
+
+    def create_refund(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/invoicing/refunds", body=body, options=options or None)
+
+    def get_approval(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/invoicing/approvals/{_q(id)}", options=options or None)
+
+    def get_ar_aging_report(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/invoicing/reports/ar-aging", query=query, options=options or None)

softsolz/resources/payments.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class PaymentsResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def create_checkout_session(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/payments/checkout-sessions", body=body, options=options or None)
+
+    def list_payment_links(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/payments/payment-links", query=query, options=options or None)
+
+    def get_payment_link(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/payments/payment-links/{_q(id)}", options=options or None)
+
+    def create_payment_link(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/payments/payment-links", body=body, options=options or None)
+
+    def update_payment_link(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/payments/payment-links/{_q(id)}", body=body, options=options or None)
+
+    def delete_payment_link(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/payments/payment-links/{_q(id)}", response_kind="none", options=options or None)

softsolz/resources/smart_chat.py

@@ -0,0 +1,87 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class SmartChatResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_threads(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/smart-chat/threads", query=query, options=options or None)
+
+    def create_thread(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/threads", body=body, options=options or None)
+
+    def get_thread(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/smart-chat/threads/{_q(id)}", options=options or None)
+
+    def update_thread(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/smart-chat/threads/{_q(id)}", body=body, options=options or None)
+
+    def delete_thread(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/smart-chat/threads/{_q(id)}", response_kind="none", options=options or None)
+
+    def list_thread_messages(self, id: Any, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", f"/api/v1/services/smart-chat/threads/{_q(id)}/messages", query=query, options=options or None)
+
+    def create_message(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/messages", body=body, options=options or None)
+
+    def list_agents(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/smart-chat/agents", query=query, options=options or None)
+
+    def get_agent(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/smart-chat/agents/{_q(id)}", options=options or None)
+
+    def create_agent(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/agents", body=body, options=options or None)
+
+    def update_agent(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PUT", f"/api/v1/services/smart-chat/agents/{_q(id)}", body=body, options=options or None)
+
+    def delete_agent(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/smart-chat/agents/{_q(id)}", response_kind="none", options=options or None)
+
+    def search_kb(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/kb/search", body=body, options=options or None)
+
+    def list_kb_documents(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/smart-chat/kb/documents", query=query, options=options or None)
+
+    def get_kb_document(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/smart-chat/kb/documents/{_q(id)}", options=options or None)
+
+    def delete_kb_document(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/smart-chat/kb/documents/{_q(id)}", response_kind="none", options=options or None)
+
+    def import_kb_document(self, **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/kb/documents/import", options=options or None)
+
+    def create_kb_documents_import_batch(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/kb/documents/import/batch", body=body, options=options or None)
+
+    def init_kb_documents_import(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/kb/documents/import/init", body=body, options=options or None)
+
+    def complete_kb_documents_import(self, task_id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/smart-chat/kb/documents/import/{_q(task_id)}/complete", options=options or None)
+
+    def list_kb_collections(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/smart-chat/kb/collections", query=query, options=options or None)
+
+    def create_kb_collection(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/smart-chat/kb/collections", body=body, options=options or None)
+
+    def get_task(self, task_id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/smart-chat/tasks/{_q(task_id)}", options=options or None)
+
+    def list_tasks(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/smart-chat/tasks", query=query, options=options or None)
+
+    def cancel_task(self, task_id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/smart-chat/tasks/{_q(task_id)}/cancel", options=options or None)
+
+    def replay_task(self, task_id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/smart-chat/tasks/{_q(task_id)}/replay", options=options or None)

softsolz/resources/social.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+
+
+class SocialResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def get_accounts(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/social/accounts", options=options or None)
+
+    def get_posts(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/social/posts", options=options or None)
+
+    def get_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/social/posts/{_q(id)}", options=options or None)
+
+    def get_post_targets(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/social/posts/{_q(id)}/targets", options=options or None)
+
+    def create_post(self, **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/social/posts", options=options or None)
+
+    def update_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("PATCH", f"/api/v1/services/social/posts/{_q(id)}", options=options or None)
+
+    def delete_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("DELETE", f"/api/v1/services/social/posts/{_q(id)}", options=options or None)
+
+    def publish_post(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/social/posts/{_q(id)}/publish", options=options or None)

softsolz/resources/workflows.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Optional
+
+from .._http import HttpClient, _q
+from ..pagination import Page
+
+
+class WorkflowsResource:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list_workflows(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/workflows/workflows", query=query, options=options or None)
+
+    def get_workflow(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/workflows/workflows/{_q(id)}", options=options or None)
+
+    def create_workflow(self, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("POST", "/api/v1/services/workflows/workflows", body=body, options=options or None)
+
+    def update_workflow(self, id: Any, body: Dict[str, Any], **options: Any) -> Any:
+        return self._http.request("PUT", f"/api/v1/services/workflows/workflows/{_q(id)}", body=body, options=options or None)
+
+    def delete_workflow(self, id: Any, **options: Any) -> None:
+        self._http.request("DELETE", f"/api/v1/services/workflows/workflows/{_q(id)}", response_kind="none", options=options or None)
+
+    def pause_workflow(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/workflows/workflows/{_q(id)}/pause", options=options or None)
+
+    def resume_workflow(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/workflows/workflows/{_q(id)}/resume", options=options or None)
+
+    def run_workflow(self, id: Any, **options: Any) -> Any:
+        return self._http.request("POST", f"/api/v1/services/workflows/workflows/{_q(id)}/run", options=options or None)
+
+    def get_run(self, id: Any, **options: Any) -> Any:
+        return self._http.request("GET", f"/api/v1/services/workflows/runs/{_q(id)}", options=options or None)
+
+    def list_runs(self, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", "/api/v1/services/workflows/runs", query=query, options=options or None)
+
+    def list_workflow_runs(self, id: Any, query: Optional[Dict[str, Any]] = None, **options: Any) -> Page:
+        return self._http.page("GET", f"/api/v1/services/workflows/workflows/{_q(id)}/runs", query=query, options=options or None)
+
+    def get_action_catalog(self, **options: Any) -> Any:
+        return self._http.request("GET", "/api/v1/services/workflows/action-catalog", options=options or None)

softsolz/webhooks.py

@@ -0,0 +1,75 @@
+import hashlib
+import hmac
+import time
+from typing import Any, Dict, List, Optional, Union
+
+from .errors import WebhookSignatureError
+
+DEFAULT_TOLERANCE_SECONDS = 300
+_SIGNATURE_VERSION = "v1"
+
+
+def _parse_signature_header(header: Optional[str]) -> Optional[Dict[str, Any]]:
+    if not isinstance(header, str) or not header:
+        return None
+    timestamp: Optional[int] = None
+    signatures: List[str] = []
+    for part in header.split(","):
+        if "=" not in part:
+            continue
+        key, _, value = part.partition("=")
+        key = key.strip()
+        value = value.strip()
+        if key == "t":
+            try:
+                timestamp = int(value)
+            except ValueError:
+                return None
+        elif key == _SIGNATURE_VERSION:
+            signatures.append(value)
+    if timestamp is None:
+        return None
+    return {"t": timestamp, "signatures": signatures}
+
+
+def compute_signature(timestamp: int, raw_body: Union[str, bytes], secret: str) -> str:
+    body_text = raw_body.decode("utf-8") if isinstance(raw_body, bytes) else raw_body
+    payload = f"{timestamp}.{body_text}".encode("utf-8")
+    return hmac.new(secret.encode("utf-8"), payload, hashlib.sha256).hexdigest()
+
+
+def verify(
+    raw_body: Union[str, bytes],
+    header_value: Optional[str],
+    secret: str,
+    *,
+    tolerance_seconds: int = DEFAULT_TOLERANCE_SECONDS,
+    now: Optional[int] = None,
+) -> Dict[str, Any]:
+    if not secret:
+        return {"valid": False, "reason": "missing_secret"}
+    parsed = _parse_signature_header(header_value)
+    if parsed is None:
+        return {"valid": False, "reason": "malformed_header"}
+    if not parsed["signatures"]:
+        return {"valid": False, "reason": "no_signatures"}
+    current = now if now is not None else int(time.time())
+    if abs(current - parsed["t"]) > tolerance_seconds:
+        return {"valid": False, "reason": "timestamp_outside_tolerance", "t": parsed["t"]}
+    expected = compute_signature(parsed["t"], raw_body, secret)
+    if any(hmac.compare_digest(sig, expected) for sig in parsed["signatures"]):
+        return {"valid": True, "t": parsed["t"]}
+    return {"valid": False, "reason": "signature_mismatch", "t": parsed["t"]}
+
+
+def assert_valid(
+    raw_body: Union[str, bytes],
+    header_value: Optional[str],
+    secret: str,
+    *,
+    tolerance_seconds: int = DEFAULT_TOLERANCE_SECONDS,
+    now: Optional[int] = None,
+) -> None:
+    result = verify(raw_body, header_value, secret, tolerance_seconds=tolerance_seconds, now=now)
+    if not result["valid"]:
+        raise WebhookSignatureError(result.get("reason", "invalid"))

softsolz-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: softsolz
+Version: 0.1.0
+Summary: Official Python SDK for the SoftSolz platform API.
+Project-URL: Homepage, https://developer.softsolz.uk
+Project-URL: Documentation, https://developer.softsolz.uk
+Project-URL: Repository, https://github.com/soft-solz/sdk
+Author: SoftSolz
+License-Expression: MIT
+Keywords: api,forms,invoicing,payments,sdk,softsolz,webhooks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.26
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# softsolz
+
+Official Python SDK for the [SoftSolz platform API](https://developer.softsolz.uk).
+
+```bash
+pip install softsolz
+```
+
+Requires Python 3.9 or later. Fully type-annotated (`py.typed`).
+
+## Usage
+
+```python
+import os
+from softsolz import SoftSolz
+
+client = SoftSolz(api_key=os.environ["SOFTSOLZ_API_KEY"])
+
+me = client.whoami()
+
+form = client.forms.create_form({"name": "Contact Us", "status": "published"})
+client.forms.submit_form(form["slug"], {"data": {"full_name": "Jane Doe", "email": "jane@example.com"}})
+
+invoice = client.invoicing.create_invoice({
+    "customer_id": 42,
+    "lines": [{"description": "Design work", "quantity": 1, "unit_price_cents": 50000}],
+})
+client.invoicing.send_invoice(invoice["id"])
+```
+
+Use an `sk_test_*` key to run against your sandbox workspace; swap to `sk_live_*` in production. No other configuration changes.
+
+### Services
+
+`client.blogs`, `client.customer_auth`, `client.forms`, `client.invoicing`, `client.payments`, `client.smart_chat`, `client.social`, `client.workflows` - one method per API operation, generated from the platform's service manifests.
+
+### Pagination
+
+List methods return a `Page` you can iterate; extra pages are fetched automatically:
+
+```python
+for invoice in client.invoicing.list_invoices({"status": "overdue"}):
+    print(invoice["invoice_number"])
+```
+
+Or page manually with `page.data`, `page.has_more`, and `page.next_page()`.
+
+### Errors
+
+All API failures raise a typed subclass of `SoftSolzError` carrying `status`, `code`, `message`, `details`, and `request_id`:
+
+```python
+from softsolz import NotFoundError
+
+try:
+    client.forms.get_form(999)
+except NotFoundError as err:
+    print(err.code, err.request_id)
+```
+
+Classes: `InvalidRequestError` (400/422), `AuthenticationError` (401), `PaymentRequiredError` (402), `PermissionDeniedError` (403), `NotFoundError` (404), `ConflictError` (409), `RateLimitError` (429, with `retry_after_seconds`), `APIConnectionError` (network).
+
+### Retries and idempotency
+
+429 and 5xx responses are retried automatically with exponential backoff (default 2 retries), honouring `Retry-After`. Every mutating request carries an auto-generated `Idempotency-Key`, so retries are always safe. Pass your own to control replays:
+
+```python
+client.invoicing.create_invoice(body, idempotency_key="order-1234")
+```
+
+Configure per client: `SoftSolz(api_key=..., max_retries=3, timeout=60.0)`.
+
+### Webhooks
+
+Verify the `Softsolz-Signature` header on incoming webhooks using the raw request body:
+
+```python
+from softsolz import webhooks
+
+webhooks.assert_valid(
+    raw_body=request.get_data(),
+    header_value=request.headers.get("Softsolz-Signature"),
+    secret=os.environ["SOFTSOLZ_WEBHOOK_SECRET"],
+)
+```
+
+`webhooks.verify(...)` returns `{"valid": False, "reason": ...}` if you prefer not to raise.
+
+### Escape hatch
+
+Call any endpoint directly while keeping auth, retries, and errors:
+
+```python
+client.request("GET", "/api/v1/services/forms/forms", query={"limit": 10})
+```
+
+## Documentation
+
+- API reference: https://developer.softsolz.uk/api-reference.html
+- Webhooks: https://developer.softsolz.uk/webhooks.html
+- Playground: https://playground.softsolz.uk
+
+## License
+
+MIT

softsolz-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+softsolz/__init__.py,sha256=YD1NEWZcJ5JtPZn5wfwCiF0ylQlNbt7X_InW89s9t3g,760
+softsolz/_client.py,sha256=6vKYq4gopvVnQm0BvvJcxDbvdhRBSWxHMLGRJHsvxvg,1701
+softsolz/_http.py,sha256=ZjcH823skUgASN06uvniBXGb0_2zK3P4xm0N_BAW-QQ,5496
+softsolz/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+softsolz/errors.py,sha256=D-L-5edehexpqx-6DdRzpijc5NUFWftYuov2JpYghfw,2622
+softsolz/pagination.py,sha256=5NdpIiiR1hF7TpTmnbK33Zpku50G9GdmD94bDFFR9uI,1307
+softsolz/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+softsolz/webhooks.py,sha256=mvIOiE4ZXAHZe4xY6F2FYZoRxVQT0O1baeAMdegqSuQ,2623
+softsolz/resources/__init__.py,sha256=oP11j7mNJPyMYxXy4Nyc0Aa_Z3GzS4BAHloNfwAaW_A,1033
+softsolz/resources/blogs.py,sha256=aCGdPPk5wklzq22Jji_SzFIS5_P75mDbDkHz22M_oU4,2523
+softsolz/resources/customer_auth.py,sha256=ohf9TfNGnR7svoS212NH_piDu07dmJlD9tzYaN3Q4AQ,4417
+softsolz/resources/forms.py,sha256=FLKHwoTp4vd_CCY17isc1JZJnlUeg6_JxSA180FE-qw,2706
+softsolz/resources/invoicing.py,sha256=iofUCXkJYdt2_MRx_YmqyrM6O_RH3BnkSkTGLcTuxcw,4587
+softsolz/resources/payments.py,sha256=xpM50hCrtUjCUS6xrzMmJeZfYW-A9uWZvfnL8EzCsKs,1449
+softsolz/resources/smart_chat.py,sha256=1xd68cZpdlAlAD99JTEK7vQqhYJ1-5qwo07xKbNXzSI,5439
+softsolz/resources/social.py,sha256=7gvlYRsKFJi6rhkJX_G_j2zKIfOq-gd6x-ZfCcop1Jo,1498
+softsolz/resources/workflows.py,sha256=ZH7D2e0SgaSykaWBPdLbgAdwJx4q2PM4wKuQXYXTlbU,2535
+softsolz-0.1.0.dist-info/METADATA,sha256=A64Bv1rZWCb8MXONUosVrBViOWkykv6XfBt5DlHBF8k,4169
+softsolz-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+softsolz-0.1.0.dist-info/RECORD,,

softsolz-0.1.0.dist-info/WHEEL

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