babelqueue 1.1.0__tar.gz → 1.2.0__tar.gz

{babelqueue-1.1.0 → babelqueue-1.2.0}/.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
       - name: Install (dev + all adapters for type context)
         run: |
           python -m pip install --upgrade pip
-          pip install -e ".[dev,celery,django,redis,amqp,sqs]"
+          pip install -e ".[dev,celery,django,redis,amqp,sqs,azureservicebus]"
       - name: Ruff
         run: ruff check src tests
       - name: Mypy
@@ -89,7 +89,7 @@ jobs:
       - name: Install (all adapters — full coverage with brokers)
         run: |
           python -m pip install --upgrade pip
-          pip install -e ".[redis,amqp,sqs,celery,django,dev]"
+          pip install -e ".[redis,amqp,sqs,azureservicebus,celery,django,dev]"
 
       - name: Wait for ElasticMQ
         run: |

{babelqueue-1.1.0 → babelqueue-1.2.0}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 The envelope wire format is versioned separately by `meta.schema_version`
 (currently **1**) — see the contract at [babelqueue.com](https://babelqueue.com).
 
+## [1.2.0] - 2026-06-13
+
+### Added
+- **Azure Service Bus transport** (`babelqueue[azureservicebus]`, `azure-servicebus`) —
+  `AsbTransport`, selected by the `sb://` URL scheme (e.g.
+  `sb://<namespace>.servicebus.windows.net`, Azure AD via `DefaultAzureCredential`; or pass
+  `connection_string=...` / a built `client`). Implements [§4 of the broker-bindings
+  contract](https://babelqueue.com/docs/spec/1.x/broker-bindings#azure-service-bus): the
+  canonical envelope is the message body, projected onto native Service Bus fields
+  (`Subject` = URN, `CorrelationId` = `trace_id`, `MessageId` = `meta.id`, plus the `bq-`
+  application properties); PeekLock reserve → `complete_message` ack; `attempts` reconciled
+  to the broker-authoritative `DeliveryCount − 1`. A client can be injected for tests/DI. The
+  projection + reconciliation are unit-tested with no broker and no `azure-servicebus` (the
+  azure import is lazy); the publish flow is covered with a fake client. The envelope is
+  unchanged (`schema_version: 1`); Azure Service Bus is purely additive. Ships as a MINOR.
+
 ## [1.1.0] - 2026-06-12
 
 ### Added
@@ -99,7 +115,8 @@ reference at [babelqueue.com](https://babelqueue.com).
 - Pre-1.0: the public API may change before the `1.0.0` tag.
 - The core has **zero runtime dependencies** (standard library only); Python `>=3.9`.
 
-[Unreleased]: https://github.com/BabelQueue/babelqueue-python/compare/v1.1.0...HEAD
+[Unreleased]: https://github.com/BabelQueue/babelqueue-python/compare/v1.2.0...HEAD
+[1.2.0]: https://github.com/BabelQueue/babelqueue-python/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/BabelQueue/babelqueue-python/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/BabelQueue/babelqueue-python/compare/v0.5.0...v1.0.0
 [0.5.0]: https://github.com/BabelQueue/babelqueue-python/compare/v0.4.0...v0.5.0

{babelqueue-1.1.0 → babelqueue-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelqueue
-Version: 1.1.0
+Version: 1.2.0
 Summary: Polyglot Queues, Simplified — the Python core: the canonical BabelQueue wire-envelope codec, contracts and dead-letter helpers.
 Project-URL: Homepage, https://babelqueue.com
 Project-URL: Source, https://github.com/BabelQueue/babelqueue-python
@@ -24,6 +24,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Provides-Extra: amqp
 Requires-Dist: pika>=1.3; extra == 'amqp'
+Provides-Extra: azureservicebus
+Requires-Dist: azure-identity>=1.15; extra == 'azureservicebus'
+Requires-Dist: azure-servicebus>=7.11; extra == 'azureservicebus'
 Provides-Extra: celery
 Requires-Dist: celery>=5; extra == 'celery'
 Provides-Extra: dev

{babelqueue-1.1.0 → babelqueue-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "babelqueue"
-version = "1.1.0"
+version = "1.2.0"
 description = "Polyglot Queues, Simplified — the Python core: the canonical BabelQueue wire-envelope codec, contracts and dead-letter helpers."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -32,6 +32,7 @@ dependencies = []
 redis = ["redis>=4"]
 amqp = ["pika>=1.3"]
 sqs = ["boto3>=1.26"]
+azureservicebus = ["azure-servicebus>=7.11", "azure-identity>=1.15"]
 celery = ["celery>=5"]
 django = ["django>=4.2"]
 dev = ["pytest>=7", "pytest-cov>=4", "mypy>=1.8", "ruff>=0.5"]

{babelqueue-1.1.0 → babelqueue-1.2.0}/src/babelqueue/__init__.py

@@ -19,7 +19,7 @@ from .exceptions import BabelQueueError, UnknownUrnError
 from .routing import UnknownUrnStrategy
 from .transport import InMemoryTransport, ReceivedMessage, Transport
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 __all__ = [
     "BabelQueue",

babelqueue-1.2.0/src/babelqueue/asb_transport.py

@@ -0,0 +1,173 @@
+"""Azure Service Bus transport. Requires the ``azureservicebus`` extra:
+
+    pip install "babelqueue[azureservicebus]"
+
+Producing sends the canonical envelope as the message body and projects the contract
+envelope fields onto native Service Bus fields — ``Subject`` = URN, ``CorrelationId`` =
+trace_id, ``MessageId`` = meta.id, plus the ``bq-`` application properties
+(``bq-schema-version`` / ``bq-source-lang`` / ``bq-created-at``) — so a .NET/Java/... peer
+can route on ``Subject`` and correlate on ``CorrelationId`` without parsing the body.
+Consuming uses the PeekLock reservation model (``receive_messages`` -> process ->
+``complete_message``); the authoritative attempt count is the broker's native
+``DeliveryCount`` (1-based), reconciled onto the envelope as ``attempts = DeliveryCount - 1``.
+A message left un-acked has its lock expire and is redelivered (at-least-once).
+
+This implements §4 of the broker-bindings contract. The envelope is unchanged
+(``schema_version`` stays 1); Azure Service Bus is purely additive.
+
+URL form: ``sb://<namespace>.servicebus.windows.net`` (Azure AD via
+``DefaultAzureCredential``). For connection-string auth or a custom client, build the
+transport directly and pass it via ``BabelQueue(transport=...)`` or
+``AsbTransport(connection_string=...)``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+from urllib.parse import urlsplit
+
+from .codec import EnvelopeCodec
+from .transport import ReceivedMessage, Transport
+
+
+class AsbTransport(Transport):
+    def __init__(
+        self,
+        url: str = "sb://",
+        *,
+        client: Any = None,
+        connection_string: Optional[str] = None,
+        credential: Any = None,
+        max_wait_time: Optional[float] = None,
+    ) -> None:
+        parts = urlsplit(url) if url else urlsplit("sb://")
+        self._namespace = parts.hostname or None
+        self._connection_string = connection_string
+        self._credential = credential
+        self._max_wait_time = max_wait_time
+        self._senders: Dict[str, Any] = {}
+        self._receivers: Dict[str, Any] = {}
+
+        if client is not None:
+            self._client = client
+            return
+        self._client = self._build_client()  # pragma: no cover - needs Azure / network
+
+    def _build_client(self) -> Any:  # pragma: no cover - needs Azure / network
+        try:
+            from azure.servicebus import ServiceBusClient
+        except ImportError as exc:
+            raise ImportError(
+                "AsbTransport requires the 'azure-servicebus' package. Install with "
+                'pip install "babelqueue[azureservicebus]".'
+            ) from exc
+        import os
+
+        cs = self._connection_string or os.environ.get("AZURE_SERVICEBUS_CONNECTION_STRING")
+        if cs:
+            return ServiceBusClient.from_connection_string(cs)
+        if self._namespace:
+            credential = self._credential
+            if credential is None:
+                from azure.identity import DefaultAzureCredential
+
+                credential = DefaultAzureCredential()
+            return ServiceBusClient(self._namespace, credential)
+        raise ValueError(
+            "AsbTransport needs a connection string, a namespace + credential, or an injected client."
+        )
+
+    # -- helpers ------------------------------------------------------------
+
+    def _sender(self, queue: str) -> Any:
+        sender = self._senders.get(queue)
+        if sender is None:
+            sender = self._client.get_queue_sender(queue)
+            self._senders[queue] = sender
+        return sender
+
+    def _receiver(self, queue: str) -> Any:
+        receiver = self._receivers.get(queue)
+        if receiver is None:
+            receiver = self._client.get_queue_receiver(queue)
+            self._receivers[queue] = receiver
+        return receiver
+
+    @staticmethod
+    def _projection(body: str) -> Dict[str, Any]:
+        """Native ServiceBusMessage kwargs — Subject/CorrelationId/MessageId + the bq-
+        application properties (a redundant, routable view of the body). §4.2–§4.3."""
+        try:
+            env: Dict[str, Any] = EnvelopeCodec.decode(body)
+        except (ValueError, TypeError):  # pragma: no cover - defensive
+            return {"content_type": "application/json"}
+        meta = env.get("meta") or {}
+
+        props: Dict[str, Any] = {}
+        if meta.get("schema_version") is not None:
+            props["bq-schema-version"] = meta["schema_version"]
+        if meta.get("lang"):
+            props["bq-source-lang"] = meta["lang"]
+        if meta.get("created_at") is not None:
+            props["bq-created-at"] = meta["created_at"]
+
+        kwargs: Dict[str, Any] = {"content_type": "application/json"}
+        if env.get("job"):
+            kwargs["subject"] = env["job"]
+        if env.get("trace_id"):
+            kwargs["correlation_id"] = env["trace_id"]
+        if meta.get("id"):
+            kwargs["message_id"] = meta["id"]
+        if props:
+            kwargs["application_properties"] = props
+        return kwargs
+
+    @staticmethod
+    def _reconcile(body: str, delivery_count: Any) -> str:
+        """Set attempts to max(current, DeliveryCount - 1) — DeliveryCount (1-based) is the
+        broker's native redelivery floor, but the runtime retries by republishing with
+        attempts+1 in the body, so a republished message (DeliveryCount back to 1) must not
+        have its higher body count lowered. First delivery (DeliveryCount 1) reads 0."""
+        try:
+            dc = int(delivery_count)
+        except (ValueError, TypeError):
+            return body
+        if dc <= 1:
+            return body
+        native = dc - 1
+        env = EnvelopeCodec.decode(body)
+        if not env or native <= int(env.get("attempts", 0)):
+            return body
+        env["attempts"] = native
+        return EnvelopeCodec.encode(env)
+
+    # -- Transport ----------------------------------------------------------
+
+    def publish(self, queue: str, body: str) -> None:
+        from azure.servicebus import ServiceBusMessage
+
+        message = ServiceBusMessage(body, **self._projection(body))
+        self._sender(queue).send_messages(message)
+
+    def pop(self, queue: str, timeout: float = 1.0) -> Optional[ReceivedMessage]:
+        wait = self._max_wait_time
+        if wait is None and timeout and timeout > 0:
+            wait = timeout
+        messages = self._receiver(queue).receive_messages(max_message_count=1, max_wait_time=wait)
+        if not messages:
+            return None
+        message = messages[0]
+        body = self._reconcile(str(message), getattr(message, "delivery_count", None))
+        return ReceivedMessage(body=body, queue=queue, handle=message)
+
+    def ack(self, message: ReceivedMessage) -> None:
+        if message.handle is None:
+            return
+        self._receiver(message.queue).complete_message(message.handle)
+
+    def close(self) -> None:  # pragma: no cover - resource cleanup
+        for resource in (*self._senders.values(), *self._receivers.values(), self._client):
+            try:
+                resource.close()
+            except Exception:  # noqa: BLE001 - best-effort cleanup
+                pass

{babelqueue-1.1.0 → babelqueue-1.2.0}/src/babelqueue/transport.py

@@ -83,8 +83,12 @@ def make_transport(broker_url: str) -> Transport:
         from .sqs_transport import SqsTransport
 
         return SqsTransport(broker_url)
+    if scheme in ("sb", "servicebus", "azureservicebus"):
+        from .asb_transport import AsbTransport
+
+        return AsbTransport(broker_url)
 
     raise BabelQueueError(
         f"Unsupported broker scheme {scheme!r}. Use 'memory://', 'redis://', "
-        "'amqp://' or 'sqs://', or pass your own Transport via BabelQueue(transport=...)."
+        "'amqp://', 'sqs://' or 'sb://', or pass your own Transport via BabelQueue(transport=...)."
     )

{babelqueue-1.1.0 → babelqueue-1.2.0}/tests/conformance/manifest.json

@@ -93,5 +93,34 @@
         { "name": "absent-count",          "body_attempts": 3, "approximate_receive_count": null,           "expected_attempts": 3 }
       ]
     }
+  },
+  "asb": {
+    "description": "Azure Service Bus binding conformance (broker-bindings.md §4). Every SDK that ships an ASB transport must satisfy these. The envelope body stays byte-identical (the 'cases' above); these lock the native projection + reconciliation the binding adds. Per-message values reuse fixtures/order-created.json so the expected projection is deterministic.",
+    "property_projection": {
+      "description": "On produce, the transport MUST project these native Service Bus message fields from the envelope: Subject = job (the URN), CorrelationId = trace_id, MessageId = meta.id, ContentType = application/json, plus the bq- ApplicationProperties as native AMQP-typed values (numbers stay numbers, not strings). Applies to every ASB-producing SDK.",
+      "envelope_file": "fixtures/order-created.json",
+      "message": {
+        "subject":        "urn:babel:orders:created",
+        "correlation_id": "7b3f9c2a-e41d-4f88-9b2a-1c0d5e6f7a8b",
+        "message_id":     "f1e2d3c4-b5a6-4789-90ab-cdef01234567",
+        "content_type":   "application/json"
+      },
+      "application_properties": {
+        "bq-schema-version": 1,
+        "bq-source-lang":    "php",
+        "bq-created-at":     1749132727000
+      }
+    },
+    "attempts_reconciliation": {
+      "description": "On consume, attempts = max(body.attempts, DeliveryCount - 1): a first delivery (DeliveryCount 1) reads 0, a runtime-incremented body count is never lowered, and DeliveryCount <= 1 leaves the body's own count untouched (the runtime retries by republishing with attempts+1). DeliveryCount is the native 1-based ASB redelivery counter; the rule is identical across the native-consumer SDKs (.NET/Java/Node) and the Transport+App SDKs (Python/Go).",
+      "cases": [
+        { "name": "first-delivery",            "body_attempts": 0, "delivery_count": 1, "expected_attempts": 0 },
+        { "name": "third-delivery",            "body_attempts": 0, "delivery_count": 3, "expected_attempts": 2 },
+        { "name": "native-exceeds-body",       "body_attempts": 2, "delivery_count": 5, "expected_attempts": 4 },
+        { "name": "never-lower-runtime",       "body_attempts": 5, "delivery_count": 2, "expected_attempts": 5 },
+        { "name": "first-delivery-keeps-body", "body_attempts": 4, "delivery_count": 1, "expected_attempts": 4 },
+        { "name": "zero-count-keeps-body",     "body_attempts": 3, "delivery_count": 0, "expected_attempts": 3 }
+      ]
+    }
   }
 }

babelqueue-1.2.0/tests/test_asb_conformance.py

@@ -0,0 +1,54 @@
+"""Azure Service Bus binding conformance: the vendored manifest's ``asb`` block locks the
+§4 native projection (Subject/CorrelationId/MessageId + bq- application properties) and the
+``attempts = max(body, DeliveryCount - 1)`` reconciliation. No azure-servicebus, no broker —
+pure transport logic against golden values."""
+
+from __future__ import annotations
+
+import json
+import os
+import unittest
+
+from babelqueue import EnvelopeCodec
+from babelqueue.asb_transport import AsbTransport
+
+CONFORMANCE = os.path.join(os.path.dirname(__file__), "conformance")
+
+
+class AsbConformanceTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        with open(os.path.join(CONFORMANCE, "manifest.json"), encoding="utf-8") as fh:
+            cls.asb = json.load(fh)["asb"]
+
+    def test_property_projection(self) -> None:
+        projection = self.asb["property_projection"]
+        with open(os.path.join(CONFORMANCE, projection["envelope_file"]), encoding="utf-8") as fh:
+            body = fh.read()
+
+        got = AsbTransport._projection(body)
+        message = projection["message"]
+
+        self.assertEqual(got.get("subject"), message["subject"])
+        self.assertEqual(got.get("correlation_id"), message["correlation_id"])
+        self.assertEqual(got.get("message_id"), message["message_id"])
+        self.assertEqual(got.get("content_type"), message["content_type"])
+        self.assertEqual(got.get("application_properties"), projection["application_properties"])
+
+    def test_attempts_reconciliation(self) -> None:
+        for case in self.asb["attempts_reconciliation"]["cases"]:
+            env = EnvelopeCodec.make("urn:babel:orders:created", {"x": 1})
+            env["attempts"] = case["body_attempts"]
+            body = EnvelopeCodec.encode(env)
+
+            out = AsbTransport._reconcile(body, case["delivery_count"])
+
+            self.assertEqual(
+                EnvelopeCodec.decode(out)["attempts"],
+                case["expected_attempts"],
+                case["name"],
+            )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

babelqueue-1.2.0/tests/test_asb_transport.py

@@ -0,0 +1,169 @@
+"""Azure Service Bus transport tests.
+
+The native projection and the ``attempts = DeliveryCount - 1`` reconciliation run with no
+broker and no ``azure-servicebus`` (the transport's azure import is lazy). The publish flow,
+which builds a real ``ServiceBusMessage``, is skipped unless ``azure-servicebus`` is installed.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from babelqueue import EnvelopeCodec
+from babelqueue.asb_transport import AsbTransport
+from babelqueue.transport import ReceivedMessage, make_transport
+
+try:
+    import azure.servicebus  # noqa: F401
+
+    HAVE_ASB = True
+except ImportError:
+    HAVE_ASB = False
+
+URN = "urn:babel:orders:created"
+
+
+def body(attempts: int = 0) -> str:
+    env = EnvelopeCodec.decode(
+        EnvelopeCodec.encode(EnvelopeCodec.make(URN, {"order_id": 1042}, queue="orders"))
+    )
+    env["attempts"] = attempts
+    return EnvelopeCodec.encode(env)
+
+
+class FakeReceived:
+    """Duck-typed ServiceBusReceivedMessage (the real one has no public constructor)."""
+
+    def __init__(self, raw: str, delivery_count: int = 1) -> None:
+        self._raw = raw
+        self.delivery_count = delivery_count
+
+    def __str__(self) -> str:
+        return self._raw
+
+
+class FakeSender:
+    def __init__(self) -> None:
+        self.sent: list = []
+
+    def send_messages(self, message) -> None:
+        self.sent.append(message)
+
+
+class FakeReceiver:
+    def __init__(self, messages=()) -> None:
+        self._messages = list(messages)
+        self.completed: list = []
+
+    def receive_messages(self, max_message_count: int = 1, max_wait_time=None):
+        batch = self._messages[:max_message_count]
+        del self._messages[:max_message_count]
+        return batch
+
+    def complete_message(self, message) -> None:
+        self.completed.append(message)
+
+
+class FakeClient:
+    def __init__(self, sender=None, receiver=None) -> None:
+        self.sender = sender if sender is not None else FakeSender()
+        self.receiver = receiver if receiver is not None else FakeReceiver()
+
+    def get_queue_sender(self, queue: str):
+        return self.sender
+
+    def get_queue_receiver(self, queue: str):
+        return self.receiver
+
+
+class AsbProjectionTest(unittest.TestCase):
+    def test_projection_maps_native_fields_and_properties(self):
+        raw = body()
+        env = EnvelopeCodec.decode(raw)
+        proj = AsbTransport._projection(raw)
+
+        self.assertEqual(proj["subject"], URN)
+        self.assertEqual(proj["correlation_id"], env["trace_id"])
+        self.assertEqual(proj["message_id"], env["meta"]["id"])
+        self.assertEqual(proj["content_type"], "application/json")
+        props = proj["application_properties"]
+        self.assertEqual(props["bq-schema-version"], env["meta"]["schema_version"])
+        self.assertEqual(props["bq-source-lang"], env["meta"]["lang"])
+        self.assertEqual(props["bq-created-at"], env["meta"]["created_at"])
+
+    def test_reconcile_attempts_is_delivery_count_minus_one(self):
+        out = AsbTransport._reconcile(body(0), 3)
+        self.assertEqual(EnvelopeCodec.decode(out)["attempts"], 2)
+
+    def test_reconcile_first_delivery_is_zero(self):
+        out = AsbTransport._reconcile(body(0), 1)
+        self.assertEqual(EnvelopeCodec.decode(out)["attempts"], 0)
+
+    def test_reconcile_ignores_garbage_count(self):
+        raw = body(5)
+        self.assertEqual(AsbTransport._reconcile(raw, "not-a-number"), raw)
+
+    def test_reconcile_never_lowers_runtime_count(self):
+        # The runtime retries by republishing with attempts+1 (DeliveryCount back to 1),
+        # so a higher body count must win over a lower native one.
+        raw = body(5)
+        self.assertEqual(int(EnvelopeCodec.decode(AsbTransport._reconcile(raw, 2))["attempts"]), 5)
+
+
+class AsbConsumeTest(unittest.TestCase):
+    def test_pop_reconciles_attempts_and_returns_handle(self):
+        received = FakeReceived(body(0), delivery_count=3)
+        tr = AsbTransport(client=FakeClient(receiver=FakeReceiver([received])))
+
+        msg = tr.pop("orders")
+
+        self.assertIsNotNone(msg)
+        self.assertEqual(msg.queue, "orders")
+        self.assertIs(msg.handle, received)
+        self.assertEqual(EnvelopeCodec.decode(msg.body)["attempts"], 2)
+
+    def test_pop_empty_returns_none(self):
+        tr = AsbTransport(client=FakeClient(receiver=FakeReceiver([])))
+        self.assertIsNone(tr.pop("orders"))
+
+    def test_ack_completes_the_reserved_message(self):
+        received = FakeReceived(body(), delivery_count=1)
+        receiver = FakeReceiver([received])
+        tr = AsbTransport(client=FakeClient(receiver=receiver))
+
+        tr.ack(tr.pop("orders"))
+
+        self.assertEqual(receiver.completed, [received])
+
+    def test_ack_noop_without_handle(self):
+        tr = AsbTransport(client=FakeClient())
+        tr.ack(ReceivedMessage(body="", queue="orders", handle=None))  # no error
+
+    def test_make_transport_routes_sb_scheme(self):
+        if HAVE_ASB:
+            self.skipTest("azure installed — building a real client would need credentials")
+        with self.assertRaises(ImportError):
+            make_transport("sb://ns.servicebus.windows.net")
+
+
+@unittest.skipUnless(HAVE_ASB, "azure-servicebus not installed")
+class AsbPublishTest(unittest.TestCase):
+    def test_publish_builds_message_with_native_projection(self):
+        raw = body()
+        env = EnvelopeCodec.decode(raw)
+        sender = FakeSender()
+        tr = AsbTransport(client=FakeClient(sender=sender))
+
+        tr.publish("orders", raw)
+
+        self.assertEqual(len(sender.sent), 1)
+        sent = sender.sent[0]
+        self.assertEqual(sent.subject, URN)
+        self.assertEqual(sent.correlation_id, env["trace_id"])
+        self.assertEqual(sent.message_id, env["meta"]["id"])
+        self.assertEqual(sent.content_type, "application/json")
+        self.assertEqual(EnvelopeCodec.urn(EnvelopeCodec.decode(str(sent))), URN)
+
+
+if __name__ == "__main__":
+    unittest.main()