django-sslwireless-sms 0.1.0__tar.gz

django_sslwireless_sms-0.1.0/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Keeps the commit-pinned actions in .github/workflows up to date.
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly
+    cooldown:
+      default-days: 7
+    groups:
+      github-actions:
+        patterns: ["*"]

django_sslwireless_sms-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,130 @@
+name: Publish
+
+# Every push to main runs the tests and builds the package. It is published to
+# TestPyPI and then PyPI only when __version__ is not on PyPI yet, so pushes
+# without a version bump skip publishing.
+#
+# Trusted publishers on pypi.org and test.pypi.org must use this workflow
+# filename (publish.yml) and the environments "pypi" and "testpypi".
+
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: publish
+  cancel-in-progress: false
+
+permissions: {}
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python }}, Django ${{ matrix.django }})
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - python: "3.10"
+            django: "4.2"
+          - python: "3.14"
+            django: "6.1"
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        with:
+          python-version: ${{ matrix.python }}
+          enable-cache: false
+      - name: Install dependencies
+        env:
+          DJANGO_VERSION: ${{ matrix.django }}
+        run: |
+          uv sync --locked
+          uv pip install "django~=${DJANGO_VERSION}.0"
+      - name: Run unit tests
+        run: uv run --no-sync pytest
+
+  build:
+    name: Build
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      publish: ${{ steps.version.outputs.publish }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        with:
+          enable-cache: false
+      - name: Build
+        run: uv build
+      - name: Check distributions
+        run: uvx twine check dist/*
+      - name: Decide whether to publish
+        id: version
+        run: |
+          version=$(sed -n 's/^__version__ = "\(.*\)"$/\1/p' django_sslwireless_sms/__init__.py)
+          test -f "dist/django_sslwireless_sms-${version}-py3-none-any.whl"
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+          status=$(curl -s -o /dev/null -w '%{http_code}' "https://pypi.org/pypi/django-sslwireless-sms/${version}/json")
+          case "$status" in
+            404)
+              echo "publish=true" >> "$GITHUB_OUTPUT"
+              echo "::notice::Publishing django-sslwireless-sms ${version}" ;;
+            200)
+              echo "publish=false" >> "$GITHUB_OUTPUT"
+              echo "::notice::Version ${version} is already on PyPI, so publishing is skipped. Bump __version__ to release." ;;
+            *)
+              echo "::error::Could not check PyPI for version ${version} (HTTP ${status})"
+              exit 1 ;;
+          esac
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dist
+          path: dist/
+
+  publish-testpypi:
+    name: Publish to TestPyPI
+    needs: build
+    if: needs.build.outputs.publish == 'true'
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/project/django-sslwireless-sms/${{ needs.build.outputs.version }}/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          # Lets a re-run continue to PyPI if TestPyPI already has this version.
+          skip-existing: true
+
+  publish-pypi:
+    name: Publish to PyPI
+    needs: [build, publish-testpypi]
+    if: needs.build.outputs.publish == 'true'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/django-sslwireless-sms/${{ needs.build.outputs.version }}/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2

django_sslwireless_sms-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+build/
+dist/
+.pytest_cache/
+.coverage
+htmlcov/
+.env

django_sslwireless_sms-0.1.0/LICENSE

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

django_sslwireless_sms-0.1.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.5
+Name: django-sslwireless-sms
+Version: 0.1.0
+Summary: Django integration for the SSL Wireless ISMS Plus SMS API v3: single, bulk, dynamic and secure OTP messages.
+Project-URL: Homepage, https://github.com/aniksharif/django-sslwireless-sms
+Project-URL: Repository, https://github.com/aniksharif/django-sslwireless-sms
+Project-URL: Issues, https://github.com/aniksharif/django-sslwireless-sms/issues
+Project-URL: API documentation, https://ismsplus.sslwireless.com/api-documentation
+Author-email: Anik Sharif <aniksharif@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bangladesh,django,isms plus,otp,sms,ssl wireless
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Telephony
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=41
+Requires-Dist: django>=4.2
+Requires-Dist: requests>=2.28
+Description-Content-Type: text/markdown
+
+# django-sslwireless-sms
+
+Django integration for the [SSL Wireless ISMS Plus SMS API v3](https://ismsplus.sslwireless.com/api-documentation).
+
+| Function           | Endpoint                 | Use for                                           |
+| ------------------ | ------------------------ | ------------------------------------------------- |
+| `send_sms`         | `POST /send-sms`         | One message to one recipient                      |
+| `send_bulk_sms`    | `POST /send-sms/bulk`    | The same message to up to 100 recipients          |
+| `send_dynamic_sms` | `POST /send-sms/dynamic` | Up to 100 different messages in one request       |
+| `send_otp`         | `POST /secure/otp-sms`   | OTPs: AES-256-CBC encrypted body + `X-Signature`  |
+
+Requires Python 3.10+ and Django 4.2+.
+
+## Installation
+
+```bash
+pip install django-sslwireless-sms
+```
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "django_sslwireless_sms",  # optional; enables system checks for the settings below
+]
+
+SSLWIRELESS_SMS = {
+    "API_TOKEN": os.environ["SSLWIRELESS_SMS_API_TOKEN"],
+    "SID": os.environ["SSLWIRELESS_SMS_SID"],
+    "SECRET_KEY": os.environ.get("SSLWIRELESS_SMS_SECRET_KEY", ""),  # only needed for send_otp
+    # Optional. Empty or unset uses https://smsplus.sslwireless.com/api/v3
+    "BASE_URL": os.environ.get("SSLWIRELESS_SMS_BASE_URL", ""),
+    "TIMEOUT": os.environ.get("SSLWIRELESS_SMS_TIMEOUT", 10),  # seconds
+    # "BACKEND": "django_sslwireless_sms.backends.api.SSLWirelessBackend",  # default
+}
+```
+
+The API only accepts requests from IPs whitelisted in the ISMS Plus portal.
+
+## Usage
+
+```python
+from django_sslwireless_sms import send_sms, send_bulk_sms, send_dynamic_sms, send_otp
+
+send_sms("8801712345678", "Your order has shipped", csms_id="order-1042")
+
+send_bulk_sms(["8801712345678", "8801812345678"], "We are closed on Friday")
+
+send_dynamic_sms([
+    {"msisdn": "8801712345678", "text": "Hi John, your balance is 120 BDT"},
+    {"msisdn": "8801812345678", "text": "Hi Jane, your balance is 80 BDT", "csms_id": "bal-2"},
+])
+
+send_otp("8801712345678", "Your login code is 482913")
+```
+
+`csms_id` is your unique reference for a message (at most 20 characters). If you leave it
+out, a random one is generated. Batch size (100) and `csms_id` length are checked before
+anything is sent, and violations raise `ValueError`.
+
+### Results
+
+Every call returns a `SendResult`:
+
+```python
+result = send_bulk_sms(numbers, "Hello")
+result.status_code          # 200
+for info in result.smsinfo:  # one SMSInfo per recipient
+    info.msisdn, info.sms_status, info.csms_id, info.reference_id
+result.failed               # recipients the API did not accept
+result.raw                  # the decoded JSON
+```
+
+### Errors
+
+When the API answers `"status": "FAILED"`, the call raises a subclass of `SSLWirelessAPIError`.
+The error carries `.status_code`, `.error_message`, and the parsed `.result`.
+
+| Exception               | Status codes                                             |
+| ----------------------- | -------------------------------------------------------- |
+| `AuthenticationError`   | 4001 unauthorized, 4002 SID not permitted, 4003 IP not whitelisted |
+| `RateLimitError`        | 4029, 4031 TPS, 4033 too many OTPs to one recipient      |
+| `SignatureError`        | 4034 can't decrypt SMS, 4035 signature mismatch          |
+| `ServerError`           | 5000                                                     |
+| `InvalidRequestError`   | Any other 4xxx (invalid MSISDN, duplicate `csms_id`, ...) |
+
+The other errors are:
+- `SSLWirelessConnectionError`: the API could not be reached.
+- `SSLWirelessResponseError`: the API returned something other than a JSON result.
+
+All of these errors inherit from `SSLWirelessError`. `StatusCode` lists every documented code.
+
+```python
+from django_sslwireless_sms import RateLimitError, SSLWirelessError, StatusCode, send_otp
+
+try:
+    send_otp(phone, f"Your code is {code}")
+except RateLimitError:
+    ...  # ask the user to wait
+except SSLWirelessError:
+    logger.exception("OTP delivery failed")
+```
+
+### Without Django settings
+
+`SSLWirelessClient` has no Django dependency:
+
+```python
+from django_sslwireless_sms import SSLWirelessClient
+
+client = SSLWirelessClient(api_token, sid, secret_key=secret_key, timeout=5)
+client.send_sms("8801712345678", "Hello")
+```
+
+## Backends
+
+Backends work like Django's email backends. Choose one with `SSLWIRELESS_SMS["BACKEND"]`, or pass
+`backend="dotted.path"` to any `send_*` function.
+
+| Backend                                                  | Behaviour                                                  |
+| -------------------------------------------------------- | ---------------------------------------------------------- |
+| `django_sslwireless_sms.backends.api.SSLWirelessBackend` | Sends through the API (default)                            |
+| `django_sslwireless_sms.backends.locmem.LocmemBackend`   | Stores messages in `django_sslwireless_sms.outbox` instead |
+| `django_sslwireless_sms.backends.console.ConsoleBackend` | Prints messages to stdout instead                          |
+
+The simulated backends validate input the same way the API client does. They return a
+successful `SendResult` and need no credentials.
+
+### Testing your project
+
+```python
+import django_sslwireless_sms
+from django.test import TestCase, override_settings
+
+
+@override_settings(SSLWIRELESS_SMS={"BACKEND": "django_sslwireless_sms.backends.locmem.LocmemBackend"})
+class SignupTests(TestCase):
+    def setUp(self):
+        django_sslwireless_sms.outbox.clear()
+
+    def test_sends_otp(self):
+        self.client.post("/signup/", {"phone": "8801712345678"})
+        [sms] = django_sslwireless_sms.outbox
+        assert sms.kind == "otp" and sms.msisdn == "8801712345678"
+```
+
+For local development, set `"BACKEND": "django_sslwireless_sms.backends.console.ConsoleBackend"`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest                  # unit tests; HTTP is mocked, nothing leaves the machine
+```
+
+The unit tests mock HTTP with [`responses`](https://github.com/getsentry/responses) and check
+request payloads against the API documentation. The OTP encryption and signature are compared
+with known-answer vectors from the official Python and Node.js samples.
+
+Integration tests call the real API and are deselected by default:
+
+```bash
+uv run pytest -m integration   # without credentials: only checks that a bad token is rejected
+
+export SSLWIRELESS_SMS_API_TOKEN=... SSLWIRELESS_SMS_SID=... SSLWIRELESS_SMS_TEST_MSISDN=8801XXXXXXXXX
+export SSLWIRELESS_SMS_SECRET_KEY=...  # optional, enables the OTP test
+export SSLWIRELESS_SMS_BASE_URL=...    # optional, overrides the default API host
+uv run pytest -m integration   # sends real SMS to SSLWIRELESS_SMS_TEST_MSISDN (uses credit)
+```
+
+Run the tests from a whitelisted IP.
+
+### Releasing
+
+Every push to `main` runs [`.github/workflows/publish.yml`](.github/workflows/publish.yml):
+
+1. Runs the unit tests on Python 3.10 with Django 4.2 and on Python 3.14 with Django 6.1.
+2. Builds the package and checks it with `twine check`.
+3. Checks PyPI for `__version__` from `django_sslwireless_sms/__init__.py`. If that version isn't
+   there yet, it uploads to TestPyPI and then PyPI using trusted publishing. Otherwise it skips
+   publishing.
+
+To release, bump `__version__` and push to `main`.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

django_sslwireless_sms-0.1.0/README.md

@@ -0,0 +1,187 @@
+# django-sslwireless-sms
+
+Django integration for the [SSL Wireless ISMS Plus SMS API v3](https://ismsplus.sslwireless.com/api-documentation).
+
+| Function           | Endpoint                 | Use for                                           |
+| ------------------ | ------------------------ | ------------------------------------------------- |
+| `send_sms`         | `POST /send-sms`         | One message to one recipient                      |
+| `send_bulk_sms`    | `POST /send-sms/bulk`    | The same message to up to 100 recipients          |
+| `send_dynamic_sms` | `POST /send-sms/dynamic` | Up to 100 different messages in one request       |
+| `send_otp`         | `POST /secure/otp-sms`   | OTPs: AES-256-CBC encrypted body + `X-Signature`  |
+
+Requires Python 3.10+ and Django 4.2+.
+
+## Installation
+
+```bash
+pip install django-sslwireless-sms
+```
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "django_sslwireless_sms",  # optional; enables system checks for the settings below
+]
+
+SSLWIRELESS_SMS = {
+    "API_TOKEN": os.environ["SSLWIRELESS_SMS_API_TOKEN"],
+    "SID": os.environ["SSLWIRELESS_SMS_SID"],
+    "SECRET_KEY": os.environ.get("SSLWIRELESS_SMS_SECRET_KEY", ""),  # only needed for send_otp
+    # Optional. Empty or unset uses https://smsplus.sslwireless.com/api/v3
+    "BASE_URL": os.environ.get("SSLWIRELESS_SMS_BASE_URL", ""),
+    "TIMEOUT": os.environ.get("SSLWIRELESS_SMS_TIMEOUT", 10),  # seconds
+    # "BACKEND": "django_sslwireless_sms.backends.api.SSLWirelessBackend",  # default
+}
+```
+
+The API only accepts requests from IPs whitelisted in the ISMS Plus portal.
+
+## Usage
+
+```python
+from django_sslwireless_sms import send_sms, send_bulk_sms, send_dynamic_sms, send_otp
+
+send_sms("8801712345678", "Your order has shipped", csms_id="order-1042")
+
+send_bulk_sms(["8801712345678", "8801812345678"], "We are closed on Friday")
+
+send_dynamic_sms([
+    {"msisdn": "8801712345678", "text": "Hi John, your balance is 120 BDT"},
+    {"msisdn": "8801812345678", "text": "Hi Jane, your balance is 80 BDT", "csms_id": "bal-2"},
+])
+
+send_otp("8801712345678", "Your login code is 482913")
+```
+
+`csms_id` is your unique reference for a message (at most 20 characters). If you leave it
+out, a random one is generated. Batch size (100) and `csms_id` length are checked before
+anything is sent, and violations raise `ValueError`.
+
+### Results
+
+Every call returns a `SendResult`:
+
+```python
+result = send_bulk_sms(numbers, "Hello")
+result.status_code          # 200
+for info in result.smsinfo:  # one SMSInfo per recipient
+    info.msisdn, info.sms_status, info.csms_id, info.reference_id
+result.failed               # recipients the API did not accept
+result.raw                  # the decoded JSON
+```
+
+### Errors
+
+When the API answers `"status": "FAILED"`, the call raises a subclass of `SSLWirelessAPIError`.
+The error carries `.status_code`, `.error_message`, and the parsed `.result`.
+
+| Exception               | Status codes                                             |
+| ----------------------- | -------------------------------------------------------- |
+| `AuthenticationError`   | 4001 unauthorized, 4002 SID not permitted, 4003 IP not whitelisted |
+| `RateLimitError`        | 4029, 4031 TPS, 4033 too many OTPs to one recipient      |
+| `SignatureError`        | 4034 can't decrypt SMS, 4035 signature mismatch          |
+| `ServerError`           | 5000                                                     |
+| `InvalidRequestError`   | Any other 4xxx (invalid MSISDN, duplicate `csms_id`, ...) |
+
+The other errors are:
+- `SSLWirelessConnectionError`: the API could not be reached.
+- `SSLWirelessResponseError`: the API returned something other than a JSON result.
+
+All of these errors inherit from `SSLWirelessError`. `StatusCode` lists every documented code.
+
+```python
+from django_sslwireless_sms import RateLimitError, SSLWirelessError, StatusCode, send_otp
+
+try:
+    send_otp(phone, f"Your code is {code}")
+except RateLimitError:
+    ...  # ask the user to wait
+except SSLWirelessError:
+    logger.exception("OTP delivery failed")
+```
+
+### Without Django settings
+
+`SSLWirelessClient` has no Django dependency:
+
+```python
+from django_sslwireless_sms import SSLWirelessClient
+
+client = SSLWirelessClient(api_token, sid, secret_key=secret_key, timeout=5)
+client.send_sms("8801712345678", "Hello")
+```
+
+## Backends
+
+Backends work like Django's email backends. Choose one with `SSLWIRELESS_SMS["BACKEND"]`, or pass
+`backend="dotted.path"` to any `send_*` function.
+
+| Backend                                                  | Behaviour                                                  |
+| -------------------------------------------------------- | ---------------------------------------------------------- |
+| `django_sslwireless_sms.backends.api.SSLWirelessBackend` | Sends through the API (default)                            |
+| `django_sslwireless_sms.backends.locmem.LocmemBackend`   | Stores messages in `django_sslwireless_sms.outbox` instead |
+| `django_sslwireless_sms.backends.console.ConsoleBackend` | Prints messages to stdout instead                          |
+
+The simulated backends validate input the same way the API client does. They return a
+successful `SendResult` and need no credentials.
+
+### Testing your project
+
+```python
+import django_sslwireless_sms
+from django.test import TestCase, override_settings
+
+
+@override_settings(SSLWIRELESS_SMS={"BACKEND": "django_sslwireless_sms.backends.locmem.LocmemBackend"})
+class SignupTests(TestCase):
+    def setUp(self):
+        django_sslwireless_sms.outbox.clear()
+
+    def test_sends_otp(self):
+        self.client.post("/signup/", {"phone": "8801712345678"})
+        [sms] = django_sslwireless_sms.outbox
+        assert sms.kind == "otp" and sms.msisdn == "8801712345678"
+```
+
+For local development, set `"BACKEND": "django_sslwireless_sms.backends.console.ConsoleBackend"`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest                  # unit tests; HTTP is mocked, nothing leaves the machine
+```
+
+The unit tests mock HTTP with [`responses`](https://github.com/getsentry/responses) and check
+request payloads against the API documentation. The OTP encryption and signature are compared
+with known-answer vectors from the official Python and Node.js samples.
+
+Integration tests call the real API and are deselected by default:
+
+```bash
+uv run pytest -m integration   # without credentials: only checks that a bad token is rejected
+
+export SSLWIRELESS_SMS_API_TOKEN=... SSLWIRELESS_SMS_SID=... SSLWIRELESS_SMS_TEST_MSISDN=8801XXXXXXXXX
+export SSLWIRELESS_SMS_SECRET_KEY=...  # optional, enables the OTP test
+export SSLWIRELESS_SMS_BASE_URL=...    # optional, overrides the default API host
+uv run pytest -m integration   # sends real SMS to SSLWIRELESS_SMS_TEST_MSISDN (uses credit)
+```
+
+Run the tests from a whitelisted IP.
+
+### Releasing
+
+Every push to `main` runs [`.github/workflows/publish.yml`](.github/workflows/publish.yml):
+
+1. Runs the unit tests on Python 3.10 with Django 4.2 and on Python 3.14 with Django 6.1.
+2. Builds the package and checks it with `twine check`.
+3. Checks PyPI for `__version__` from `django_sslwireless_sms/__init__.py`. If that version isn't
+   there yet, it uploads to TestPyPI and then PyPI using trusted publishing. Otherwise it skips
+   publishing.
+
+To release, bump `__version__` and push to `main`.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

django_sslwireless_sms-0.1.0/django_sslwireless_sms/__init__.py

@@ -0,0 +1,80 @@
+"""Django integration for the SSL Wireless ISMS Plus SMS API (v3)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+
+from .backends import get_backend
+from .backends.base import SentSMS
+from .backends.locmem import outbox
+from .client import SSLWirelessClient
+from .exceptions import (
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    ServerError,
+    SignatureError,
+    SSLWirelessAPIError,
+    SSLWirelessConnectionError,
+    SSLWirelessError,
+    SSLWirelessResponseError,
+)
+from .results import SendResult, SMSInfo, SMSStatus, StatusCode
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AuthenticationError",
+    "InvalidRequestError",
+    "RateLimitError",
+    "SMSInfo",
+    "SMSStatus",
+    "SSLWirelessAPIError",
+    "SSLWirelessClient",
+    "SSLWirelessConnectionError",
+    "SSLWirelessError",
+    "SSLWirelessResponseError",
+    "SendResult",
+    "SentSMS",
+    "ServerError",
+    "SignatureError",
+    "StatusCode",
+    "get_backend",
+    "outbox",
+    "send_bulk_sms",
+    "send_dynamic_sms",
+    "send_otp",
+    "send_sms",
+]
+
+
+def send_sms(
+    msisdn: str | int, text: str, *, csms_id: str | None = None, backend: str | None = None
+) -> SendResult:
+    """Send one SMS to one recipient."""
+    return get_backend(backend).send_sms(msisdn, text, csms_id=csms_id)
+
+
+def send_bulk_sms(
+    msisdns: Iterable[str | int],
+    text: str,
+    *,
+    batch_csms_id: str | None = None,
+    backend: str | None = None,
+) -> SendResult:
+    """Send the same SMS to up to 100 recipients."""
+    return get_backend(backend).send_bulk_sms(msisdns, text, batch_csms_id=batch_csms_id)
+
+
+def send_dynamic_sms(
+    messages: Iterable[Mapping[str, str]], *, backend: str | None = None
+) -> SendResult:
+    """Send up to 100 personalised messages (``{"msisdn", "text", "csms_id"?}`` mappings)."""
+    return get_backend(backend).send_dynamic_sms(messages)
+
+
+def send_otp(
+    msisdn: str | int, text: str, *, csms_id: str | None = None, backend: str | None = None
+) -> SendResult:
+    """Send an OTP through the encrypted, signed ``secure/otp-sms`` endpoint."""
+    return get_backend(backend).send_otp(msisdn, text, csms_id=csms_id)

django_sslwireless_sms-0.1.0/django_sslwireless_sms/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class SSLWirelessConfig(AppConfig):
+    name = "django_sslwireless_sms"
+    verbose_name = "SSL Wireless SMS"
+
+    def ready(self) -> None:
+        from . import checks  # noqa: F401  (registers system checks)

django_sslwireless_sms-0.1.0/django_sslwireless_sms/backends/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.utils.module_loading import import_string
+
+from ..conf import get_settings
+from .base import BaseSMSBackend
+
+
+def get_backend(backend: str | None = None, **options: Any) -> BaseSMSBackend:
+    """Instantiate ``backend`` (a dotted path), defaulting to ``SSLWIRELESS_SMS['BACKEND']``."""
+    return import_string(backend or get_settings()["BACKEND"])(**options)