smsgora 1.0.0__tar.gz

smsgora-1.0.0/LICENSE

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

smsgora-1.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: smsgora
+Version: 1.0.0
+Summary: Official Python client for the SMS Gora SMS Gateway: send and receive SMS through your own Android phones, with delivery reports and signed webhooks.
+Author-email: Tekservix <support@tekservix.com>
+License-Expression: MIT
+Project-URL: Homepage, https://tekservix.com/smsgora/
+Project-URL: Documentation, https://tekservix.com/smsgora/docs/
+Project-URL: Source, https://github.com/ellyj164/smsgora-python
+Project-URL: Issues, https://github.com/ellyj164/smsgora-python/issues
+Keywords: sms,sms-gateway,sms-api,bulk-sms,send-sms,android-sms-gateway,otp,textbee,smsgora,tekservix
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# smsgora
+
+Python client for the [SMS Gora SMS Gateway](https://tekservix.com/smsgora/) API.
+
+SMS Gora turns Android phones with ordinary SIM cards into an SMS gateway. Your server calls the API, a linked phone sends the text, and replies and delivery reports come back to you. There's no sender ID registration and no per-message fee from us: your mobile operator bills the texts like any SMS.
+
+- Zero dependencies (standard library only), Python 3.8+
+- Works in Django, Flask, FastAPI, scripts and cron jobs
+- Webhook signature check built in
+
+## Install
+
+```bash
+pip install smsgora
+```
+
+## Quick start
+
+Create an API key in the SMS Gora dashboard (SMS Gora -> API keys) and keep it on your server.
+
+```python
+import os
+from smsgora import SmsGora
+
+sms = SmsGora(api_key=os.environ["SMSGORA_KEY"])
+
+result = sms.send_sms(to="+15551234567", message="Your verification code is 482913")
+print(result["message_ids"])  # [1873]
+```
+
+## Sending
+
+```python
+from datetime import datetime, timezone
+
+# Several recipients (up to 1,000 per call)
+sms.send_sms(to=["+15551234567", "+447700900123"], message="Your order has shipped")
+
+# From a chosen phone and SIM, scheduled for later
+sms.send_sms(
+    to="+15551234567",
+    message="Reminder: your appointment is tomorrow at 10:00",
+    device_id=42,
+    sim_slot=1,  # 0 = SIM 1, 1 = SIM 2
+    schedule_at=datetime(2026, 12, 1, 8, 0, tzinfo=timezone.utc),
+)
+
+# Different texts for different people in one call (up to 5,000 recipients)
+sms.send_bulk_sms(
+    42,
+    message_template="Hello, your parcel is ready for pickup.",
+    messages=[
+        {"recipients": ["+15551234567"], "message": "Hi Aline, parcel #1042 is ready."},
+        {"recipients": ["+15557654321"]},
+    ],
+)
+```
+
+## Delivery status and incoming SMS
+
+```python
+msg = sms.get_message(1873)
+print(msg["status"])  # queued -> dispatched -> sent -> delivered (or failed)
+
+sms.cancel_message(1874)  # works while queued or scheduled
+
+inbox = sms.list_received_sms(since="2026-11-01", limit=50)
+phones = sms.list_devices()
+account = sms.get_account()
+```
+
+Anything else in the [API reference](https://tekservix.com/smsgora/docs/) is one call away:
+
+```python
+batch = sms.request("GET", "/batches/311")
+```
+
+## Webhooks
+
+Add your HTTPS URL in SMS Gora -> Webhooks (or with `create_webhook`) and keep the secret. Each request carries `X-SmsGora-Signature: sha256=...`, an HMAC-SHA256 of the raw body. Check it before trusting the request. Flask example:
+
+```python
+import json, os
+from flask import Flask, request, abort
+from smsgora import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/sms/webhook")
+def sms_webhook():
+    if not verify_webhook(request.get_data(), request.headers.get("X-SmsGora-Signature"),
+                          os.environ["SMSGORA_WEBHOOK_SECRET"]):
+        abort(401)
+    event = json.loads(request.get_data())
+    if event["event"] == "sms.received":
+        print(event["data"]["from"], event["data"]["message"])
+    return "", 200  # answer within 10 seconds; queue slow work
+```
+
+In Django use `request.body`; in FastAPI use `await request.body()`. Always pass the raw bytes, not re-encoded JSON.
+
+## Errors
+
+Failed calls raise `SmsGoraError` with `status`, `message`, field `errors` and, on 429, `retry_after` in seconds.
+
+```python
+from smsgora import SmsGoraError
+
+try:
+    sms.send_sms(to="+15551234567", message="Hi")
+except SmsGoraError as err:
+    if err.status == 429:
+        pass  # rate limit (300 requests/minute per key) or plan limit reached
+```
+
+Never ship the key inside a browser or mobile app: anyone could read it. Call the API from your server.
+
+## Migrating from TextBee
+
+SMS Gora accepts TextBee-style requests, so most integrations switch by changing the base URL and key. See the [compatibility notes](https://tekservix.com/smsgora/docs/).
+
+## Good to know
+
+A phone-based gateway suits OTPs, order alerts, reminders and two-way conversations at moderate volume. It isn't meant for mass marketing blasts, and in the US high-volume business texting belongs on registered 10DLC or toll-free numbers.
+
+## More from Tekservix
+
+- [WAservix WhatsApp API Gateway](https://tekservix.com/waservix/): send WhatsApp messages from your own number (`pip install waservix`)
+- [AI Sales Agent](https://tekservix.com/ai-sales-agent): answers customers on WhatsApp and SMS using your website's content
+- [Website to App](https://tekservix.com/mobile-apps): turn your website into Android and iOS apps
+- Also on npm: `npm install smsgora`
+
+## License
+
+MIT

smsgora-1.0.0/README.md

@@ -0,0 +1,135 @@
+# smsgora
+
+Python client for the [SMS Gora SMS Gateway](https://tekservix.com/smsgora/) API.
+
+SMS Gora turns Android phones with ordinary SIM cards into an SMS gateway. Your server calls the API, a linked phone sends the text, and replies and delivery reports come back to you. There's no sender ID registration and no per-message fee from us: your mobile operator bills the texts like any SMS.
+
+- Zero dependencies (standard library only), Python 3.8+
+- Works in Django, Flask, FastAPI, scripts and cron jobs
+- Webhook signature check built in
+
+## Install
+
+```bash
+pip install smsgora
+```
+
+## Quick start
+
+Create an API key in the SMS Gora dashboard (SMS Gora -> API keys) and keep it on your server.
+
+```python
+import os
+from smsgora import SmsGora
+
+sms = SmsGora(api_key=os.environ["SMSGORA_KEY"])
+
+result = sms.send_sms(to="+15551234567", message="Your verification code is 482913")
+print(result["message_ids"])  # [1873]
+```
+
+## Sending
+
+```python
+from datetime import datetime, timezone
+
+# Several recipients (up to 1,000 per call)
+sms.send_sms(to=["+15551234567", "+447700900123"], message="Your order has shipped")
+
+# From a chosen phone and SIM, scheduled for later
+sms.send_sms(
+    to="+15551234567",
+    message="Reminder: your appointment is tomorrow at 10:00",
+    device_id=42,
+    sim_slot=1,  # 0 = SIM 1, 1 = SIM 2
+    schedule_at=datetime(2026, 12, 1, 8, 0, tzinfo=timezone.utc),
+)
+
+# Different texts for different people in one call (up to 5,000 recipients)
+sms.send_bulk_sms(
+    42,
+    message_template="Hello, your parcel is ready for pickup.",
+    messages=[
+        {"recipients": ["+15551234567"], "message": "Hi Aline, parcel #1042 is ready."},
+        {"recipients": ["+15557654321"]},
+    ],
+)
+```
+
+## Delivery status and incoming SMS
+
+```python
+msg = sms.get_message(1873)
+print(msg["status"])  # queued -> dispatched -> sent -> delivered (or failed)
+
+sms.cancel_message(1874)  # works while queued or scheduled
+
+inbox = sms.list_received_sms(since="2026-11-01", limit=50)
+phones = sms.list_devices()
+account = sms.get_account()
+```
+
+Anything else in the [API reference](https://tekservix.com/smsgora/docs/) is one call away:
+
+```python
+batch = sms.request("GET", "/batches/311")
+```
+
+## Webhooks
+
+Add your HTTPS URL in SMS Gora -> Webhooks (or with `create_webhook`) and keep the secret. Each request carries `X-SmsGora-Signature: sha256=...`, an HMAC-SHA256 of the raw body. Check it before trusting the request. Flask example:
+
+```python
+import json, os
+from flask import Flask, request, abort
+from smsgora import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/sms/webhook")
+def sms_webhook():
+    if not verify_webhook(request.get_data(), request.headers.get("X-SmsGora-Signature"),
+                          os.environ["SMSGORA_WEBHOOK_SECRET"]):
+        abort(401)
+    event = json.loads(request.get_data())
+    if event["event"] == "sms.received":
+        print(event["data"]["from"], event["data"]["message"])
+    return "", 200  # answer within 10 seconds; queue slow work
+```
+
+In Django use `request.body`; in FastAPI use `await request.body()`. Always pass the raw bytes, not re-encoded JSON.
+
+## Errors
+
+Failed calls raise `SmsGoraError` with `status`, `message`, field `errors` and, on 429, `retry_after` in seconds.
+
+```python
+from smsgora import SmsGoraError
+
+try:
+    sms.send_sms(to="+15551234567", message="Hi")
+except SmsGoraError as err:
+    if err.status == 429:
+        pass  # rate limit (300 requests/minute per key) or plan limit reached
+```
+
+Never ship the key inside a browser or mobile app: anyone could read it. Call the API from your server.
+
+## Migrating from TextBee
+
+SMS Gora accepts TextBee-style requests, so most integrations switch by changing the base URL and key. See the [compatibility notes](https://tekservix.com/smsgora/docs/).
+
+## Good to know
+
+A phone-based gateway suits OTPs, order alerts, reminders and two-way conversations at moderate volume. It isn't meant for mass marketing blasts, and in the US high-volume business texting belongs on registered 10DLC or toll-free numbers.
+
+## More from Tekservix
+
+- [WAservix WhatsApp API Gateway](https://tekservix.com/waservix/): send WhatsApp messages from your own number (`pip install waservix`)
+- [AI Sales Agent](https://tekservix.com/ai-sales-agent): answers customers on WhatsApp and SMS using your website's content
+- [Website to App](https://tekservix.com/mobile-apps): turn your website into Android and iOS apps
+- Also on npm: `npm install smsgora`
+
+## License
+
+MIT

smsgora-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smsgora"
+version = "1.0.0"
+description = "Official Python client for the SMS Gora SMS Gateway: send and receive SMS through your own Android phones, with delivery reports and signed webhooks."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Tekservix", email = "support@tekservix.com" }]
+requires-python = ">=3.8"
+keywords = ["sms", "sms-gateway", "sms-api", "bulk-sms", "send-sms", "android-sms-gateway", "otp", "textbee", "smsgora", "tekservix"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Topic :: Communications :: Telephony",
+  "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://tekservix.com/smsgora/"
+Documentation = "https://tekservix.com/smsgora/docs/"
+Source = "https://github.com/ellyj164/smsgora-python"
+Issues = "https://github.com/ellyj164/smsgora-python/issues"

smsgora-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smsgora-1.0.0/src/smsgora/__init__.py

@@ -0,0 +1,175 @@
+"""Python client for the SMS Gora SMS Gateway API.
+
+Docs: https://tekservix.com/smsgora/docs/
+"""
+
+import datetime as _dt
+import hashlib
+import hmac
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+
+__all__ = ["SmsGora", "SmsGoraError", "verify_webhook"]
+__version__ = "1.0.0"
+
+DEFAULT_BASE_URL = "https://tekservix.com/smsgora/api/v1"
+
+
+class SmsGoraError(Exception):
+    """Raised when the API answers with an error.
+
+    Attributes: status (HTTP code), errors (field errors), body (parsed answer)
+    and retry_after (seconds, on 429).
+    """
+
+    def __init__(self, message, status=None, errors=None, body=None, retry_after=None):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.errors = errors
+        self.body = body
+        self.retry_after = retry_after
+
+
+def _q(value):
+    return urllib.parse.quote(str(value), safe="")
+
+
+def _query(params):
+    if not params:
+        return ""
+    clean = {k: v for k, v in params.items() if v is not None and v != ""}
+    return "?" + urllib.parse.urlencode(clean) if clean else ""
+
+
+class SmsGora:
+    """Client for the SMS Gora SMS Gateway.
+
+    >>> sms = SmsGora(api_key="sgk_...")
+    >>> sms.send_sms(to="+15551234567", message="Your code is 482913")
+    """
+
+    def __init__(self, api_key, base_url=DEFAULT_BASE_URL, timeout=30):
+        if not api_key:
+            raise ValueError("SmsGora: api_key is required (create one in SMS Gora -> API keys)")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def request(self, method, path, body=None):
+        """Call any documented endpoint, e.g. request("GET", "/devices"). Returns the `data` field."""
+        headers = {
+            "x-api-key": self.api_key,
+            "Accept": "application/json",
+            "User-Agent": "smsgora-python/" + __version__,
+        }
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        req = urllib.request.Request(self.base_url + path, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                status, text, retry = res.status, res.read().decode("utf-8"), None
+        except urllib.error.HTTPError as err:
+            status, text = err.code, err.read().decode("utf-8", "replace")
+            retry = err.headers.get("Retry-After") if err.headers else None
+        try:
+            parsed = json.loads(text) if text else None
+        except ValueError:
+            parsed = None
+        failed = status >= 400 or (isinstance(parsed, dict) and parsed.get("success") is False)
+        if failed:
+            msg = parsed.get("message") if isinstance(parsed, dict) else None
+            raise SmsGoraError(
+                msg or "HTTP %d" % status,
+                status=status,
+                errors=parsed.get("errors") if isinstance(parsed, dict) else None,
+                body=parsed if parsed is not None else text,
+                retry_after=float(retry) if retry else None,
+            )
+        if isinstance(parsed, dict) and "data" in parsed:
+            return parsed["data"]
+        return parsed
+
+    def send_sms(self, to, message, device_id=None, sim_slot=None, schedule_at=None):
+        """Send an SMS to one number or a list (up to 1,000). Picks your best online phone unless device_id is given.
+
+        sim_slot: 0 = SIM 1, 1 = SIM 2. schedule_at: datetime or ISO string.
+        """
+        recipients = [to] if isinstance(to, str) else list(to)
+        body = {"recipients": recipients, "message": message}
+        if sim_slot is not None:
+            body["sim_slot"] = sim_slot
+        if schedule_at:
+            if isinstance(schedule_at, _dt.datetime):
+                schedule_at = schedule_at.isoformat()
+            body["schedule_at"] = schedule_at
+        path = "/devices/%s/send-sms" % _q(device_id) if device_id else "/send-sms"
+        return self.request("POST", path, body)
+
+    def send_bulk_sms(self, device_id, messages, message_template=None):
+        """Different texts for different people in one call (up to 5,000 recipients).
+
+        messages: [{"recipients": ["+1555..."], "message": "optional own text"}, ...]
+        """
+        body = {"messages": messages}
+        if message_template is not None:
+            body["messageTemplate"] = message_template
+        return self.request("POST", "/devices/%s/send-bulk-sms" % _q(device_id), body)
+
+    def get_message(self, message_id):
+        """Status is queued, dispatched, sent, delivered, failed or cancelled."""
+        return self.request("GET", "/messages/%s" % _q(message_id))
+
+    def cancel_message(self, message_id):
+        """Cancel a queued or scheduled message."""
+        return self.request("POST", "/messages/%s/cancel" % _q(message_id))
+
+    def list_messages(self, **filters):
+        """Filters: direction (in/out), status, device_id, phone, since, after_id, page, limit."""
+        return self.request("GET", "/messages" + _query(filters))
+
+    def list_received_sms(self, device_id=None, **filters):
+        """Incoming SMS for all phones, or one phone with device_id."""
+        path = "/devices/%s/get-received-sms" % _q(device_id) if device_id else "/received-sms"
+        return self.request("GET", path + _query(filters))
+
+    def get_batch(self, batch_id):
+        return self.request("GET", "/batches/%s" % _q(batch_id))
+
+    def list_devices(self):
+        """Your linked Android phones."""
+        return self.request("GET", "/devices")
+
+    def get_device(self, device_id):
+        return self.request("GET", "/devices/%s" % _q(device_id))
+
+    def get_account(self):
+        """Account, plan and usage."""
+        return self.request("GET", "/account")
+
+    def list_webhooks(self):
+        return self.request("GET", "/webhooks")
+
+    def create_webhook(self, url, events=("sms.received",), device_id=None):
+        """Register a webhook. The answer includes the secret (only returned once)."""
+        return self.request("POST", "/webhooks", {"url": url, "events": list(events), "device_id": device_id})
+
+    def delete_webhook(self, webhook_id):
+        return self.request("DELETE", "/webhooks/%s" % _q(webhook_id))
+
+
+def verify_webhook(raw_body, signature, secret):
+    """Check the X-SmsGora-Signature header (sha256=<hex HMAC-SHA256 of the raw body>).
+
+    raw_body: bytes or str exactly as received, before JSON parsing.
+    """
+    if not raw_body or not signature or not secret:
+        return False
+    if isinstance(raw_body, str):
+        raw_body = raw_body.encode("utf-8")
+    expected = "sha256=" + hmac.new(secret.encode("utf-8"), raw_body, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(str(signature).encode("utf-8"), expected.encode("utf-8"))

smsgora-1.0.0/src/smsgora.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: smsgora
+Version: 1.0.0
+Summary: Official Python client for the SMS Gora SMS Gateway: send and receive SMS through your own Android phones, with delivery reports and signed webhooks.
+Author-email: Tekservix <support@tekservix.com>
+License-Expression: MIT
+Project-URL: Homepage, https://tekservix.com/smsgora/
+Project-URL: Documentation, https://tekservix.com/smsgora/docs/
+Project-URL: Source, https://github.com/ellyj164/smsgora-python
+Project-URL: Issues, https://github.com/ellyj164/smsgora-python/issues
+Keywords: sms,sms-gateway,sms-api,bulk-sms,send-sms,android-sms-gateway,otp,textbee,smsgora,tekservix
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# smsgora
+
+Python client for the [SMS Gora SMS Gateway](https://tekservix.com/smsgora/) API.
+
+SMS Gora turns Android phones with ordinary SIM cards into an SMS gateway. Your server calls the API, a linked phone sends the text, and replies and delivery reports come back to you. There's no sender ID registration and no per-message fee from us: your mobile operator bills the texts like any SMS.
+
+- Zero dependencies (standard library only), Python 3.8+
+- Works in Django, Flask, FastAPI, scripts and cron jobs
+- Webhook signature check built in
+
+## Install
+
+```bash
+pip install smsgora
+```
+
+## Quick start
+
+Create an API key in the SMS Gora dashboard (SMS Gora -> API keys) and keep it on your server.
+
+```python
+import os
+from smsgora import SmsGora
+
+sms = SmsGora(api_key=os.environ["SMSGORA_KEY"])
+
+result = sms.send_sms(to="+15551234567", message="Your verification code is 482913")
+print(result["message_ids"])  # [1873]
+```
+
+## Sending
+
+```python
+from datetime import datetime, timezone
+
+# Several recipients (up to 1,000 per call)
+sms.send_sms(to=["+15551234567", "+447700900123"], message="Your order has shipped")
+
+# From a chosen phone and SIM, scheduled for later
+sms.send_sms(
+    to="+15551234567",
+    message="Reminder: your appointment is tomorrow at 10:00",
+    device_id=42,
+    sim_slot=1,  # 0 = SIM 1, 1 = SIM 2
+    schedule_at=datetime(2026, 12, 1, 8, 0, tzinfo=timezone.utc),
+)
+
+# Different texts for different people in one call (up to 5,000 recipients)
+sms.send_bulk_sms(
+    42,
+    message_template="Hello, your parcel is ready for pickup.",
+    messages=[
+        {"recipients": ["+15551234567"], "message": "Hi Aline, parcel #1042 is ready."},
+        {"recipients": ["+15557654321"]},
+    ],
+)
+```
+
+## Delivery status and incoming SMS
+
+```python
+msg = sms.get_message(1873)
+print(msg["status"])  # queued -> dispatched -> sent -> delivered (or failed)
+
+sms.cancel_message(1874)  # works while queued or scheduled
+
+inbox = sms.list_received_sms(since="2026-11-01", limit=50)
+phones = sms.list_devices()
+account = sms.get_account()
+```
+
+Anything else in the [API reference](https://tekservix.com/smsgora/docs/) is one call away:
+
+```python
+batch = sms.request("GET", "/batches/311")
+```
+
+## Webhooks
+
+Add your HTTPS URL in SMS Gora -> Webhooks (or with `create_webhook`) and keep the secret. Each request carries `X-SmsGora-Signature: sha256=...`, an HMAC-SHA256 of the raw body. Check it before trusting the request. Flask example:
+
+```python
+import json, os
+from flask import Flask, request, abort
+from smsgora import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/sms/webhook")
+def sms_webhook():
+    if not verify_webhook(request.get_data(), request.headers.get("X-SmsGora-Signature"),
+                          os.environ["SMSGORA_WEBHOOK_SECRET"]):
+        abort(401)
+    event = json.loads(request.get_data())
+    if event["event"] == "sms.received":
+        print(event["data"]["from"], event["data"]["message"])
+    return "", 200  # answer within 10 seconds; queue slow work
+```
+
+In Django use `request.body`; in FastAPI use `await request.body()`. Always pass the raw bytes, not re-encoded JSON.
+
+## Errors
+
+Failed calls raise `SmsGoraError` with `status`, `message`, field `errors` and, on 429, `retry_after` in seconds.
+
+```python
+from smsgora import SmsGoraError
+
+try:
+    sms.send_sms(to="+15551234567", message="Hi")
+except SmsGoraError as err:
+    if err.status == 429:
+        pass  # rate limit (300 requests/minute per key) or plan limit reached
+```
+
+Never ship the key inside a browser or mobile app: anyone could read it. Call the API from your server.
+
+## Migrating from TextBee
+
+SMS Gora accepts TextBee-style requests, so most integrations switch by changing the base URL and key. See the [compatibility notes](https://tekservix.com/smsgora/docs/).
+
+## Good to know
+
+A phone-based gateway suits OTPs, order alerts, reminders and two-way conversations at moderate volume. It isn't meant for mass marketing blasts, and in the US high-volume business texting belongs on registered 10DLC or toll-free numbers.
+
+## More from Tekservix
+
+- [WAservix WhatsApp API Gateway](https://tekservix.com/waservix/): send WhatsApp messages from your own number (`pip install waservix`)
+- [AI Sales Agent](https://tekservix.com/ai-sales-agent): answers customers on WhatsApp and SMS using your website's content
+- [Website to App](https://tekservix.com/mobile-apps): turn your website into Android and iOS apps
+- Also on npm: `npm install smsgora`
+
+## License
+
+MIT

smsgora-1.0.0/src/smsgora.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/smsgora/__init__.py
+src/smsgora.egg-info/PKG-INFO
+src/smsgora.egg-info/SOURCES.txt
+src/smsgora.egg-info/dependency_links.txt
+src/smsgora.egg-info/top_level.txt
+tests/test_smsgora.py

smsgora-1.0.0/src/smsgora.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smsgora-1.0.0/src/smsgora.egg-info/top_level.txt

@@ -0,0 +1 @@
+smsgora

smsgora-1.0.0/tests/test_smsgora.py

@@ -0,0 +1,81 @@
+import hashlib, hmac, json, threading, unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from smsgora import SmsGora, SmsGoraError, verify_webhook
+
+CALLS = []
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _go(self):
+        n = int(self.headers.get("Content-Length") or 0)
+        body = json.loads(self.rfile.read(n)) if n else None
+        CALLS.append((self.command, self.path, {k.lower(): v for k, v in self.headers.items()}, body))
+        if self.path.startswith("/limit"):
+            self.send_response(429); self.send_header("Retry-After", "7"); self.end_headers()
+            self.wfile.write(b'{"success":false,"message":"Too many requests"}'); return
+        self.send_response(200); self.send_header("Content-Type", "application/json"); self.end_headers()
+        self.wfile.write(json.dumps({"success": True, "data": {"ok": True}}).encode())
+    do_GET = do_POST = do_DELETE = do_PUT = _go
+    def log_message(self, *a): pass
+
+
+class T(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.srv = HTTPServer(("127.0.0.1", 0), Handler)
+        threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
+        cls.c = SmsGora("sgk_test", base_url="http://127.0.0.1:%d/" % cls.srv.server_port)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.srv.shutdown()
+
+    def last(self):
+        return CALLS[-1]
+
+    def test_send(self):
+        self.assertEqual(self.c.send_sms(to="+1555", message="hi"), {"ok": True})
+        m, p, h, b = self.last()
+        self.assertEqual((m, p), ("POST", "/send-sms"))
+        self.assertEqual(h["x-api-key"], "sgk_test")
+        self.assertEqual(b, {"recipients": ["+1555"], "message": "hi"})
+
+    def test_send_device(self):
+        self.c.send_sms(to=["+1", "+2"], message="x", device_id=42, sim_slot=1, schedule_at="2026-12-01T08:00:00Z")
+        m, p, h, b = self.last()
+        self.assertEqual(p, "/devices/42/send-sms")
+        self.assertEqual(b["sim_slot"], 1)
+        self.assertEqual(b["schedule_at"], "2026-12-01T08:00:00Z")
+
+    def test_bulk_and_lists(self):
+        self.c.send_bulk_sms(42, [{"recipients": ["+1"]}], message_template="t")
+        self.assertEqual(self.last()[3], {"messages": [{"recipients": ["+1"]}], "messageTemplate": "t"})
+        self.c.list_received_sms(device_id=3, limit=5, since=None)
+        self.assertEqual(self.last()[1], "/devices/3/get-received-sms?limit=5")
+        self.c.list_messages(status="sent")
+        self.assertEqual(self.last()[1], "/messages?status=sent")
+        self.c.delete_webhook(9)
+        self.assertEqual(self.last()[:2], ("DELETE", "/webhooks/9"))
+
+    def test_error(self):
+        c = SmsGora("k", base_url="http://127.0.0.1:%d/limit" % self.srv.server_port)
+        with self.assertRaises(SmsGoraError) as e:
+            c.get_account()
+        self.assertEqual((e.exception.status, e.exception.retry_after, str(e.exception)), (429, 7.0, "Too many requests"))
+
+    def test_webhook(self):
+        raw = b'{"event":"sms.received"}'
+        sig = "sha256=" + hmac.new(b"s3cret", raw, hashlib.sha256).hexdigest()
+        self.assertTrue(verify_webhook(raw, sig, "s3cret"))
+        self.assertTrue(verify_webhook(raw.decode(), sig, "s3cret"))
+        self.assertFalse(verify_webhook(raw, sig, "wrong"))
+        self.assertFalse(verify_webhook(raw, None, "s3cret"))
+
+    def test_requires_key(self):
+        with self.assertRaises(ValueError):
+            SmsGora("")
+
+
+if __name__ == "__main__":
+    unittest.main()