mobiska 0.1.0__py3-none-any.whl

mobiska/__init__.py

@@ -0,0 +1,95 @@
+"""Mobiska Python SDK.
+
+Public API::
+
+    from mobiska import InitSMS, InitPayment
+
+    sms     = InitSMS(username=…, password=…, service_id=…, sender_id=…)
+    payment = InitPayment(username=…, password=…, service_id=…)
+
+Both factories also accept ``timeout``, ``retry_count`` and ``retry_delay``
+keyword arguments.  When called with no arguments they read credentials from
+environment variables (``MOBISKA_USER_NAME``, ``MOBISKA_PASSWORD``,
+``MOBISKA_SERVICE_ID``, ``MOBISKA_SMS_SENDER_ID``, ``MOBISKA_API_URL``).
+"""
+
+from typing import Optional
+
+from .client import BaseClient
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    MobiskaError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+)
+from .resources import PaymentClient, SMSClient
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "InitSMS",
+    "InitPayment",
+    "SMSClient",
+    "PaymentClient",
+    "BaseClient",
+    "MobiskaError",
+    "AuthenticationError",
+    "NotFoundError",
+    "RateLimitError",
+    "ValidationError",
+    "APIError",
+]
+
+
+def InitSMS(
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    service_id: Optional[int] = None,
+    sender_id: Optional[str] = None,
+    api_url: Optional[str] = None,
+    timeout: int = 30,
+    retry_count: int = 0,
+    retry_delay: float = 0.5,
+) -> SMSClient:
+    """Create and return an :class:`SMSClient`.
+
+    All arguments are optional — when omitted the values are read from
+    environment variables.
+    """
+    return SMSClient(
+        username=username,
+        password=password,
+        service_id=service_id,
+        sender_id=sender_id,
+        api_url=api_url,
+        timeout=timeout,
+        retry_count=retry_count,
+        retry_delay=retry_delay,
+    )
+
+
+def InitPayment(
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    service_id: Optional[int] = None,
+    api_url: Optional[str] = None,
+    timeout: int = 30,
+    retry_count: int = 0,
+    retry_delay: float = 0.5,
+) -> PaymentClient:
+    """Create and return a :class:`PaymentClient`.
+
+    All arguments are optional — when omitted the values are read from
+    environment variables.
+    """
+    return PaymentClient(
+        username=username,
+        password=password,
+        service_id=service_id,
+        api_url=api_url,
+        timeout=timeout,
+        retry_count=retry_count,
+        retry_delay=retry_delay,
+    )

mobiska/auth.py

@@ -0,0 +1,32 @@
+"""Basic Authentication helper for the Mobiska API.
+
+Mobiska uses HTTP Basic Auth: the client_key (username) and secret_key
+(password) are combined as ``username:password``, base64-encoded, and sent
+in the ``Authorization`` header prefixed with ``Basic``.
+"""
+
+import base64
+from typing import Dict
+
+
+class BasicAuth:
+    """Generates the Basic-auth Authorization header for API requests."""
+
+    def __init__(self, username: str, password: str):
+        if not username or not password:
+            raise ValueError("username and password must not be empty.")
+        self.username = username
+        self.password = password
+
+    @property
+    def _encoded(self) -> str:
+        raw = f"{self.username}:{self.password}".encode("utf-8")
+        return base64.b64encode(raw).decode("ascii")
+
+    def get_headers(self) -> Dict[str, str]:
+        """Return the auth headers to attach to every request."""
+        return {
+            "Authorization": f"Basic {self._encoded}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }

mobiska/client.py

@@ -0,0 +1,127 @@
+"""Base HTTP client for the Mobiska API.
+
+Provides the shared transport layer used by :class:`SMSClient` and
+:class:`PaymentClient`:
+
+* Configuration resolution (kwargs → environment variables)
+* Basic-auth header setup
+* Requests session with configurable timeout
+* Automatic retry on transient failures (network errors and 5xx)
+* Centralised response parsing and error mapping
+"""
+
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+import requests
+
+from .auth import BasicAuth
+from .config import Config
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+)
+
+DEFAULT_TIMEOUT = 30
+DEFAULT_RETRY_COUNT = 0
+DEFAULT_RETRY_DELAY = 0.5
+
+
+class BaseClient:
+    """Shared HTTP client for all Mobiska API resources."""
+
+    def __init__(
+        self,
+        *,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        service_id: Optional[int] = None,
+        sender_id: Optional[str] = None,
+        api_url: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        retry_count: int = DEFAULT_RETRY_COUNT,
+        retry_delay: float = DEFAULT_RETRY_DELAY,
+    ):
+        self.config = Config.resolve(
+            username=username,
+            password=password,
+            service_id=service_id,
+            sender_id=sender_id,
+            api_url=api_url,
+        )
+        self.auth = BasicAuth(self.config.username, self.config.password)
+        self.timeout = timeout
+        self.retry_count = retry_count
+        self.retry_delay = retry_delay
+
+        self._session = requests.Session()
+        self._session.headers.update(self.auth.get_headers())
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _request_time() -> str:
+        """Return the current UTC timestamp in ISO-8601 format."""
+        return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    def _build_payload(self, **extra: Any) -> Dict[str, Any]:
+        """Start every payload with the common fields, then merge extras."""
+        payload: Dict[str, Any] = {
+            "service_id": self.config.service_id,
+        }
+        payload.update(extra)
+        return payload
+
+    # ------------------------------------------------------------------
+    # HTTP
+    # ------------------------------------------------------------------
+
+    def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """POST *payload* to *path*, retrying on transient failures."""
+        url = f"{self.config.api_url}/{path.lstrip('/')}"
+        last_exc: Optional[Exception] = None
+
+        for attempt in range(self.retry_count + 1):
+            try:
+                response = self._session.post(url, json=payload, timeout=self.timeout)
+                return self._handle_response(response)
+            except (APIError, requests.RequestException) as exc:
+                last_exc = exc
+                if attempt < self.retry_count:
+                    time.sleep(self.retry_delay)
+                    continue
+                raise
+
+        # Should never reach here, but satisfy the type checker.
+        if last_exc:
+            raise last_exc
+        raise APIError("Request failed for an unknown reason.")
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """Map HTTP status codes to exceptions, otherwise return JSON."""
+        status = response.status_code
+
+        if status == 401:
+            raise AuthenticationError("Invalid or missing credentials.")
+        if status == 403:
+            raise AuthenticationError("Insufficient permissions.")
+        if status == 404:
+            raise NotFoundError(f"Resource not found: {response.url}")
+        if status == 429:
+            raise RateLimitError("API rate limit exceeded. Please slow down.")
+        if status >= 500:
+            raise APIError(
+                f"Server error ({status}): {response.text}",
+                status_code=status,
+            )
+
+        response.raise_for_status()
+
+        if response.content:
+            return response.json()
+        return {}

mobiska/config.py

@@ -0,0 +1,73 @@
+"""Configuration management for the Mobiska SDK.
+
+Supports two configuration strategies:
+  1. Environment variables (MOBISKA_USER_NAME, MOBISKA_PASSWORD, …)
+  2. Explicit keyword arguments passed to the client constructor.
+
+Keyword arguments always take precedence; any missing value falls back to
+the corresponding environment variable.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+DEFAULT_API_URL = "https://api.mobiska.com"
+
+# Environment-variable names
+ENV_USERNAME = "MOBISKA_USER_NAME"
+ENV_PASSWORD = "MOBISKA_PASSWORD"
+ENV_SERVICE_ID = "MOBISKA_SERVICE_ID"
+ENV_SENDER_ID = "MOBISKA_SMS_SENDER_ID"
+ENV_API_URL = "MOBISKA_API_URL"
+
+_REQUIRED_MSG = (
+    "Missing required configuration: username, password, and service_id. "
+    "Pass them as keyword arguments or set the environment variables "
+    f"{ENV_USERNAME}, {ENV_PASSWORD}, {ENV_SERVICE_ID}."
+)
+
+
+@dataclass
+class Config:
+    """Resolved SDK configuration."""
+
+    username: str
+    password: str
+    service_id: int
+    sender_id: Optional[str] = None
+    api_url: str = DEFAULT_API_URL
+
+    @classmethod
+    def resolve(
+        cls,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        service_id: Optional[int] = None,
+        sender_id: Optional[str] = None,
+        api_url: Optional[str] = None,
+    ) -> "Config":
+        """Build a Config from kwargs, falling back to env vars.
+
+        Raises ValueError if any required value is missing.
+        """
+        username = username or os.environ.get(ENV_USERNAME)
+        password = password or os.environ.get(ENV_PASSWORD)
+
+        if service_id is None:
+            service_id_str = os.environ.get(ENV_SERVICE_ID)
+            service_id = int(service_id_str) if service_id_str else None
+
+        sender_id = sender_id or os.environ.get(ENV_SENDER_ID)
+        api_url = api_url or os.environ.get(ENV_API_URL, DEFAULT_API_URL)
+
+        if not username or not password or service_id is None:
+            raise ValueError(_REQUIRED_MSG)
+
+        return cls(
+            username=username,
+            password=password,
+            service_id=service_id,
+            sender_id=sender_id,
+            api_url=api_url.rstrip("/"),
+        )

mobiska/exceptions/__init__.py

@@ -0,0 +1,39 @@
+"""Exception hierarchy for the Mobiska SDK."""
+
+
+class MobiskaError(Exception):
+    """Base exception for all Mobiska SDK errors."""
+
+    pass
+
+
+class AuthenticationError(MobiskaError):
+    """Raised when API authentication fails (401/403)."""
+
+    pass
+
+
+class NotFoundError(MobiskaError):
+    """Raised when a resource is not found (404)."""
+
+    pass
+
+
+class RateLimitError(MobiskaError):
+    """Raised when the API rate limit is exceeded (429)."""
+
+    pass
+
+
+class ValidationError(MobiskaError):
+    """Raised when input validation fails before the request is sent."""
+
+    pass
+
+
+class APIError(MobiskaError):
+    """Raised for unexpected API errors (5xx or non-standard responses)."""
+
+    def __init__(self, message: str, status_code: int = None):
+        super().__init__(message)
+        self.status_code = status_code

mobiska/resources/__init__.py

@@ -0,0 +1,6 @@
+"""API resource clients for Mobiska."""
+
+from .payment import PaymentClient
+from .sms import SMSClient
+
+__all__ = ["SMSClient", "PaymentClient"]

mobiska/resources/payment.py

@@ -0,0 +1,139 @@
+"""Payment resource — make payments, check status, and look up accounts."""
+
+from typing import Any, Dict, List, Optional
+
+from ..client import BaseClient
+from ..exceptions import ValidationError
+
+# Allowed enum-like values (kept as plain sets for zero-overhead validation)
+_NETWORKS = {"MTN", "VOD", "AIR", "VIS", "MAS"}
+_PAYMENT_OPTIONS = {"MOM", "CRD", "CRM"}
+
+
+class PaymentClient(BaseClient):
+    """Client for Mobiska Payment endpoints."""
+
+    # ------------------------------------------------------------------
+    # make_payment  →  POST /make_payment
+    # ------------------------------------------------------------------
+
+    def make_payment(
+        self,
+        *,
+        reference: str,
+        nickname: str,
+        transaction_id: str,
+        trans_type: str,
+        customer_number: str,
+        nw: str,
+        amount: float,
+        payment_option: str,
+        callback_url: str,
+        currency_code: str,
+        landing_page: Optional[str] = None,
+        currency_val: float = 1,
+    ) -> Dict[str, str]:
+        """Initiate a payment transaction.
+
+        :returns: The raw API response dict
+                  (``response_code`` / ``response_message``).
+        """
+        if nw not in _NETWORKS:
+            raise ValidationError(f"nw must be one of {sorted(_NETWORKS)}, got '{nw}'.")
+        if payment_option not in _PAYMENT_OPTIONS:
+            raise ValidationError(
+                f"payment_option must be one of {sorted(_PAYMENT_OPTIONS)}, "
+                f"got '{payment_option}'."
+            )
+        if amount <= 0:
+            raise ValidationError("amount must be greater than zero.")
+
+        extra: Dict[str, Any] = dict(
+            reference=reference,
+            nickname=nickname,
+            transaction_id=transaction_id,
+            trans_type=trans_type,
+            customer_number=customer_number,
+            nw=nw,
+            amount=amount,
+            payment_option=payment_option,
+            callback_url=callback_url,
+            currency_code=currency_code,
+            currency_val=currency_val,
+            request_time=self._request_time(),
+        )
+        if landing_page:
+            extra["landing_page"] = landing_page
+
+        payload = self._build_payload(**extra)
+        return self._post("make_payment", payload)
+
+    # ------------------------------------------------------------------
+    # check_transaction_status  →  POST /check_transaction_status
+    # ------------------------------------------------------------------
+
+    def check_transaction_status(self, transaction_id: str) -> Dict[str, Any]:
+        """Check the status of a payment transaction.
+
+        :returns: The raw API response dict
+                  (``response_data`` contains ``transaction_id``,
+                  ``status_desc``, ``status``).
+        """
+        if not transaction_id:
+            raise ValidationError("transaction_id must not be empty.")
+
+        payload = self._build_payload(transaction_id=transaction_id)
+        return self._post("check_transaction_status", payload)
+
+    # ------------------------------------------------------------------
+    # payment_account_lookup  →  POST /payment_account_lookup
+    # ------------------------------------------------------------------
+
+    def payment_account_lookup(
+        self,
+        pan: Optional[str] = None,
+        nw: Optional[str] = None,
+        accounts: Optional[List[Dict[str, str]]] = None,
+    ) -> Dict[str, Any]:
+        """Look up payment account details (single or multiple).
+
+        Pass ``pan`` + ``nw`` for a single lookup, or ``accounts`` (a list
+        of ``{"pan": …, "nw": …}`` dicts) for a batch lookup.
+
+        :returns: The raw API response dict.
+        """
+        if accounts is not None:
+            return self._lookup_multiple(accounts)
+
+        if not pan or not nw:
+            raise ValidationError(
+                "Provide pan + nw for a single lookup, or accounts for a "
+                "batch lookup."
+            )
+        if nw not in _NETWORKS:
+            raise ValidationError(f"nw must be one of {sorted(_NETWORKS)}, got '{nw}'.")
+        return self._lookup_single(pan, nw)
+
+    # -- private helpers ----------------------------------------------
+
+    def _lookup_single(self, pan: str, nw: str) -> Dict[str, Any]:
+        payload = self._build_payload(pan=pan, nw=nw)
+        return self._post("payment_account_lookup", payload)
+
+    def _lookup_multiple(self, accounts: List[Dict[str, str]]) -> Dict[str, Any]:
+        if not accounts:
+            raise ValidationError("accounts list must not be empty.")
+
+        for idx, acct in enumerate(accounts):
+            if not acct.get("pan") or not acct.get("nw"):
+                raise ValidationError(
+                    f"accounts[{idx}] must contain both 'pan' and 'nw'."
+                )
+            if acct["nw"] not in _NETWORKS:
+                raise ValidationError(
+                    f"accounts[{idx}].nw must be one of "
+                    f"{sorted(_NETWORKS)}, got '{acct['nw']}'."
+                )
+
+        payload = self._build_payload(accounts=accounts)
+        return self._post("payment_account_lookup", payload)

mobiska/resources/sms.py

@@ -0,0 +1,68 @@
+"""SMS resource — send messages and check balance."""
+
+import uuid
+from datetime import datetime
+from typing import Dict, List, Union
+
+from ..client import BaseClient
+from ..exceptions import ValidationError
+
+
+class SMSClient(BaseClient):
+    """Client for Mobiska SMS endpoints."""
+
+    # ------------------------------------------------------------------
+    # send_sms  →  POST /send_sms
+    # ------------------------------------------------------------------
+
+    def send_sms(
+        self,
+        phone: Union[str, List[str]],
+        message: str,
+    ) -> Dict[str, str]:
+        """Send an SMS to one or many recipients.
+
+        :param phone: A single phone number or a list of phone numbers.
+        :param message: The body of the SMS message.
+        :returns: The raw API response dict
+                  (``response_code`` / ``response_message``).
+        """
+        if not phone:
+            raise ValidationError("phone must not be empty.")
+        if not message:
+            raise ValidationError("message must not be empty.")
+
+        if not self.config.sender_id:
+            raise ValidationError(
+                "sender_id is required. Set MOBISKA_SMS_SENDER_ID or pass "
+                "sender_id when initializing the client."
+            )
+
+        recipients = [phone] if isinstance(phone, str) else list(phone)
+
+        payload = self._build_payload(
+            sender_id=self.config.sender_id,
+            msg_body=message,
+            recipient_number=recipients,
+            unique_id=str(uuid.uuid4()),
+        )
+        return self._post("send_sms", payload)
+
+    # ------------------------------------------------------------------
+    # check_balance  →  POST /check_sms_balance
+    # ------------------------------------------------------------------
+
+    def check_balance(self, date: datetime = None) -> Dict[str, object]:
+        """Retrieve the current SMS balance.
+
+        :param date: Optional datetime used to generate ``request_time``.
+                     Defaults to the current UTC time.
+        :returns: The raw API response dict
+                  (``response_code`` / ``response_message`` /
+                  ``response_data`` with ``sms_balance`` and ``service_id``).
+        """
+        request_time = (
+            date.strftime("%Y-%m-%dT%H:%M:%SZ") if date else self._request_time()
+        )
+        payload = self._build_payload(request_time=request_time)
+        return self._post("check_sms_balance", payload)

mobiska-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: mobiska
+Version: 0.1.0
+Summary: Python SDK for the Mobiska REST API
+Author-email: Mobiska <dev@mobiska.com>
+License: MIT License
+        
+        Copyright (c) 2026 Your Name
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/mobiska/mobiska-py
+Project-URL: Documentation, https://github.com/mobiska/mobiska-py#readme
+Project-URL: Issues, https://github.com/mobiska/mobiska-py/issues
+Keywords: mobiska,sdk,api,client
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: responses; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# Mobiska Python SDK
+
+The official Python SDK for the Mobiska REST API — payments and SMS for businesses across Africa.
+
+## Installation
+
+```bash
+pip install mobiska
+```
+
+## Quick Start
+
+### Configuration
+
+Credentials can be provided via keyword arguments **or** environment variables:
+
+```bash
+MOBISKA_USER_NAME=your_client_key
+MOBISKA_PASSWORD=your_secret_key
+MOBISKA_SERVICE_ID=1
+MOBISKA_SMS_SENDER_ID=YourSender      # SMS only
+MOBISKA_API_URL=https://api.mobiska.com  # optional, this is the default
+```
+
+### SMS
+
+```python
+from mobiska import InitSMS
+
+# Uses env vars when no arguments are passed
+sms = InitSMS()
+
+# Or pass credentials explicitly
+sms = InitSMS(
+    username="your_client_key",
+    password="your_secret_key",
+    service_id=1,
+    sender_id="YourSender",
+)
+
+# Send a message
+response = sms.send_sms("0540000000", "Welcome to Mobiska!")
+print(response["response_code"])
+
+# Send to multiple recipients
+sms.send_sms(["0540000000", "0200000000"], "Batch message")
+
+# Check balance
+balance = sms.check_balance()
+print(balance["response_data"]["sms_balance"])
+```
+
+### Payments
+
+```python
+from mobiska import InitPayment
+
+payment = InitPayment(
+    username="your_client_key",
+    password="your_secret_key",
+    service_id=2,
+)
+
+# Make a payment
+result = payment.make_payment(
+    reference="Order #123",
+    nickname="MyShop",
+    transaction_id="txn_001",
+    trans_type="CTM",
+    customer_number="0541840988",
+    nw="MTN",
+    amount=100,
+    payment_option="MOM",
+    callback_url="https://example.com/webhook",
+    currency_code="GHS",
+)
+
+# Check transaction status
+status = payment.check_transaction_status("txn_001")
+print(status["response_data"]["status"])
+
+# Account lookup (single)
+info = payment.payment_account_lookup(pan="0541840988", nw="MTN")
+print(info["response_data"]["name"])
+
+# Account lookup (batch)
+accounts = payment.payment_account_lookup(accounts=[
+    {"pan": "0541840988", "nw": "MTN"},
+    {"pan": "0201234567", "nw": "VOD"},
+])
+```
+
+### Advanced options
+
+Both `InitSMS` and `InitPayment` accept `timeout`, `retry_count`, and `retry_delay`:
+
+```python
+sms = InitSMS(timeout=10, retry_count=3, retry_delay=0.5)
+```
+
+## Error Handling
+
+```python
+from mobiska import (
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+    APIError,
+)
+
+try:
+    payment.make_payment(...)
+except ValidationError as e:
+    print(f"Invalid input: {e}")
+except AuthenticationError:
+    print("Check your credentials.")
+except RateLimitError:
+    print("Slow down — rate limit hit.")
+except APIError as e:
+    print(f"Server error ({e.status_code}): {e}")
+```
+
+## Development
+
+```bash
+# Create a virtual environment and install
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black mobiska tests
+
+# Lint
+ruff check mobiska tests
+```
+
+## License
+
+MIT
+
+# Mobiska Python SDK
+
+The official Python SDK for the Mobiska REST API.
+
+## Installation
+
+```bash
+pip install mobiska
+```
+
+## Quick Start
+
+```python
+from mobiska import MobiskaClient
+
+client = MobiskaClient(api_key="your-api-key")
+
+# GET request
+users = client.get("/users")
+
+# POST request
+new_user = client.post("/users", json={"name": "Alice"})
+
+# PATCH request
+client.patch(f"/users/{new_user['id']}", json={"name": "Alice Updated"})
+
+# DELETE request
+client.delete(f"/users/{new_user['id']}")
+```
+
+## Error Handling
+
+```python
+from mobiska import MobiskaClient, AuthenticationError, NotFoundError, RateLimitError
+
+try:
+    client.get("/users/999")
+except AuthenticationError:
+    print("Check your API key.")
+except NotFoundError:
+    print("Resource not found.")
+except RateLimitError:
+    print("Slow down — rate limit hit.")
+```
+
+## Development
+
+```bash
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black mobiska tests
+
+# Lint
+ruff check mobiska tests
+```
+
+## License
+
+MIT

mobiska-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+mobiska/__init__.py,sha256=BFHHkfFvKuzto3eFdCflC9W5DK3xe0x7vglquWXTAVw,2408
+mobiska/auth.py,sha256=nD-lN7S1BsbTYzEu-LxE2MJHWg5EwThZzDYeZ1bGon8,1075
+mobiska/client.py,sha256=s-FHhHWnrvvz8RcBmkFze0sU8GGfWw0tp4UYF-i7bBU,4250
+mobiska/config.py,sha256=a17isBrBH6MWDH6yyzghBp4arnP9kMevTcy_oN9sJq8,2228
+mobiska/exceptions/__init__.py,sha256=KHrcKeZE6e2UR19bmgK3Bxtyqa6sZxJD09IN9PDqHZM,829
+mobiska/resources/__init__.py,sha256=VXwQazZx-4Bdob8-59ZU11iRuFHgE581loXGwLT2UCo,145
+mobiska/resources/payment.py,sha256=F-FgM_aTiHbesrjro0AQNjAnqyht5I79t6wPe6gKzMo,5183
+mobiska/resources/sms.py,sha256=99X67DTK071bMHbf2fJMgXa_Q4NRFUZNaYuZY9ypaqM,2481
+mobiska-0.1.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+mobiska-0.1.0.dist-info/METADATA,sha256=CIAcQkTE_p38p4_fRs_-Ow13Uls5eoHSBG-KCSci0aI,6134
+mobiska-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mobiska-0.1.0.dist-info/top_level.txt,sha256=47440n5ee_9T0Xgot0DuzYlR-JtLfS01mFs11gEJCPo,8
+mobiska-0.1.0.dist-info/RECORD,,

mobiska-0.1.0.dist-info/WHEEL

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

mobiska-0.1.0.dist-info/licenses/LICENSE

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

mobiska-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mobiska