rabbitmq-amqp-python-client 2.0.0a3__tar.gz → 2.0.0b2__tar.gz

rabbitmq_amqp_python_client-2.0.0b2/.dockerignore

@@ -0,0 +1,15 @@
+.git
+.github
+.venv
+.mypy_cache
+.pytest_cache
+.ruff_cache
+.idea
+.claude
+__pycache__
+*.pyc
+dist
+build
+*.egg-info
+tests
+.ci

rabbitmq_amqp_python_client-2.0.0b2/AGENTS.md

@@ -0,0 +1,46 @@
+# AGENTS.md
+
+Guidance for AI coding agents working in this repository.
+
+## Project
+
+RabbitMQ AMQP 1.0 Python client (version 2.x), a native Python implementation
+with no dependency on `qpid-proton`. See `README.md` for install instructions
+and a quick-start example, and `README.md#project-layout` for how the code is
+organized (`wire/` is the protocol layer; `connection.py`, `session.py`,
+`link.py`, `management.py`, `publisher.py`, `consumer.py`, `reconnection.py`
+build the public API on top of it).
+
+## Setup
+
+```sh
+make install
+```
+
+## Common commands
+
+```sh
+make format           # ruff format, then ruff check --fix
+make lint             # ruff check and ruff format --check
+make typecheck        # mypy rabbitmq_amqp_python_client, in strict mode
+make test-unit        # the unit suite; no broker needed
+make test-integration # the integration suite; needs a broker on localhost:5672
+make test             # both suites
+```
+
+Run `make lint` and `make typecheck` before considering a change done.
+`make test-unit` needs no broker; `make test-integration` needs one running
+on `localhost:5672`.
+
+## Contributing
+
+Every contribution — bug fix or feature — must include one of the following:
+
+- A **failing test case** that reproduces the issue and passes once the fix
+  is applied (add it under `tests/unit` or `tests/integration`, matching the
+  existing style in that directory).
+- A **small, runnable example** that clearly reproduces the issue, in the
+  style of the scripts under `docs/examples/`.
+
+Do not open a change without one of these — it's how reviewers (human or
+agent) confirm the problem is real and that the fix actually addresses it.

{rabbitmq_amqp_python_client-2.0.0a3 → rabbitmq_amqp_python_client-2.0.0b2}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: rabbitmq-amqp-python-client
-Version: 2.0.0a3
+Version: 2.0.0-beta.2
 Summary: A from-scratch AMQP 1.0 client for RabbitMQ, built directly against the wire protocol.
 Author: RabbitMQ Team
 License: Apache-2.0
 Requires-Python: >=3.10
 Provides-Extra: dev
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
 Requires-Dist: mypy>=2.3.1; extra == 'dev'
 Requires-Dist: pika>=1.4.2; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0; extra == 'dev'
@@ -18,13 +19,25 @@ Description-Content-Type: text/markdown
 
 RabbitMQ AMQP 1.0 Python client version 2.x for RabbitMQ 4.x.
 
-This client version built from scratch. The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1, providing a fully native Python client. 
+Client is tested and validated against RabbitMQ 4.3.0
+
+This client version built from scratch.</br> 
+The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1.0, providing a fully native Python client, see [here](https://github.com/rabbitmq/rabbitmq-amqp-python-client/discussions/123). 
 This client is inspired by the Java and .NET AMQP 1.0 clients, aiming to deliver the same behavior and user experience across ecosystems.
 
 The client is different from 1.0 and not compatible, so read the documentation before updating the client.
 
 
-## Installation
+## Install 
+
+The client is distributed via [`PIP`](https://pypi.org/project/rabbitmq-amqp-python-client/):
+```bash
+ pip install rabbitmq-amqp-python-client==2.0.0ax
+```
+
+
+
+## Build from source
 
 ```sh
 python3 -m venv .venv

{rabbitmq_amqp_python_client-2.0.0a3 → rabbitmq_amqp_python_client-2.0.0b2}/README.md

@@ -2,13 +2,25 @@
 
 RabbitMQ AMQP 1.0 Python client version 2.x for RabbitMQ 4.x.
 
-This client version built from scratch. The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1, providing a fully native Python client. 
+Client is tested and validated against RabbitMQ 4.3.0
+
+This client version built from scratch.</br> 
+The primary reason for this rewrite is to remove the dependency on the `qpid-proton` C library present in version 1.0, providing a fully native Python client, see [here](https://github.com/rabbitmq/rabbitmq-amqp-python-client/discussions/123). 
 This client is inspired by the Java and .NET AMQP 1.0 clients, aiming to deliver the same behavior and user experience across ecosystems.
 
 The client is different from 1.0 and not compatible, so read the documentation before updating the client.
 
 
-## Installation
+## Install 
+
+The client is distributed via [`PIP`](https://pypi.org/project/rabbitmq-amqp-python-client/):
+```bash
+ pip install rabbitmq-amqp-python-client==2.0.0ax
+```
+
+
+
+## Build from source
 
 ```sh
 python3 -m venv .venv

{rabbitmq_amqp_python_client-2.0.0a3 → rabbitmq_amqp_python_client-2.0.0b2}/docs/examples/README.md

@@ -18,7 +18,8 @@ one layer at a time, and the rest build on them.
 | [`publisher_example.py`](publisher_example.py) | The three targets a publisher can have — a queue, an exchange plus a routing key, and none at all. The anonymous publisher sends to two different addresses over one link by setting `properties.to` per message, and a publish to an unbound routing key shows a `RELEASED` outcome, which is not an error. |
 | [`consumer_example.py`](consumer_example.py) | A `message_handler` that accepts and counts every delivery, `unsettled_message_count` while it does, and `pause()`/`unpause()` as flow control: messages published while paused stay queued and arrive the moment credit is restored. |
 | [`auto_reconnection.py`](auto_reconnection.py) | A connection surviving a forced socket drop: publishers and consumers built before the drop keep working afterwards, and `RecoveryConfiguration(topology=True)` re-declares the topology the broker lost. |
-| [`console_application.py`](console_application.py) | The whole client end to end — declare, publish, consume, report — as a scriptable smoke test with meaningful exit codes. `--help` lists its options. |
+| [`console_application.py`](console_application.py) | The whole client end to end — declare, publish, consume, report — as a scriptable smoke test with meaningful exit codes. `--help` lists its options, every one of which also has an `AMQP_*` environment-variable override; see [`docker/`](docker/) for running it as a container configured entirely that way. |
+| [`reliable.py`](reliable.py) | Modeled on [rabbitmq-amqp-go-client's own `reliable` example](https://github.com/rabbitmq/rabbitmq-amqp-go-client/tree/main/docs/examples/reliable): a publisher and a consumer built once on a quorum queue and left running while a broker disconnect/reconnect can happen at any point without either being rebuilt, with every publish outcome classified and periodic stats logged throughout. Configured entirely through environment variables, no command-line flags; see [`docker/reliable/`](docker/reliable/) for running it as a container. |
 | [`performance_test.py`](performance_test.py) | A throughput/latency generator: many publishers and consumers on one or more connections, with periodic rate and latency reporting. |
 | [`presettled_consumer_example.py`](presettled_consumer_example.py) | At-most-once consumption: `settle_strategy(ConsumerSettleStrategy.PRESETTLED)` attaches with `snd-settle-mode = settled`, so the broker settles every delivery itself, the handler never touches its `Context`, and `unsettled_message_count` stays at `0` for the consumer's whole life — including across a forced disconnect that auto-reconnection recovers from. |
 | [`direct_reply_to_example.py`](direct_reply_to_example.py) | Request/reply without a dedicated reply queue: `settle_strategy(ConsumerSettleStrategy.DIRECT_REPLY_TO)` attaches to no queue at all and reads back a broker-generated pseudo-queue address from `consumer.queue`; a request naming it as `properties.reply_to` gets answered by an ordinary queue-bound consumer publishing to that address. The pseudo-queue is session-scoped, so a forced disconnect and auto-reconnection leave the requester with a brand new address, which the script re-reads before sending its second request. |

{rabbitmq_amqp_python_client-2.0.0a3 → rabbitmq_amqp_python_client-2.0.0b2}/docs/examples/console_application.py

@@ -10,6 +10,15 @@ both confirmed and consumed, so this doubles as a scriptable smoke test::
     python3 docs/examples/console_application.py --messages 500 --queue-type quorum
     python3 docs/examples/console_application.py --help
 
+Every flag also has an ``AMQP_*`` environment variable that sets its default
+(a flag given on the command line always wins); see each flag's ``--help``
+text for its variable's name. That is what lets docs/examples/docker/Dockerfile
+run this script as a container configured entirely through ``docker run -e``,
+with nothing broker-specific baked into the image::
+
+    docker build -f docs/examples/docker/Dockerfile -t console-application .
+    docker run --rm -e AMQP_HOST=rabbitmq -e AMQP_MESSAGES=500 console-application
+
 This program adds nothing to the client's public surface: it is built entirely
 out of :class:`~rabbitmq_amqp_python_client.Connection`,
 :class:`~rabbitmq_amqp_python_client.Management`,
@@ -33,6 +42,7 @@ from __future__ import annotations
 
 import argparse
 import logging
+import os
 import ssl
 import sys
 import threading
@@ -44,9 +54,12 @@ from pathlib import Path
 from typing import TYPE_CHECKING, TextIO
 
 # Make the client importable when this example is run straight from a checkout,
-# with neither the package installed nor PYTHONPATH set.
-_SOURCE_ROOT = Path(__file__).resolve().parents[2]
-if _SOURCE_ROOT.is_dir() and str(_SOURCE_ROOT) not in sys.path:
+# with neither the package installed nor PYTHONPATH set. Guarded by a length
+# check because a containerized copy of this script (see docs/examples/docker/)
+# lives too shallow in the image's filesystem for a third parent to exist.
+_RESOLVED_PARENTS = Path(__file__).resolve().parents
+_SOURCE_ROOT = _RESOLVED_PARENTS[2] if len(_RESOLVED_PARENTS) > 2 else None
+if _SOURCE_ROOT is not None and _SOURCE_ROOT.is_dir() and str(_SOURCE_ROOT) not in sys.path:
     sys.path.insert(0, str(_SOURCE_ROOT))
 
 from rabbitmq_amqp_python_client import (  # noqa: E402 - after the sys.path bootstrap above
@@ -93,6 +106,79 @@ QUEUE_TYPES = (QUEUE_TYPE_CLASSIC, QUEUE_TYPE_QUORUM, QUEUE_TYPE_STREAM)
 #: Prefix of the queue name generated when ``--queue`` is not given.
 GENERATED_QUEUE_PREFIX = "console-app-"
 
+# --- environment overrides (§2) -----------------------------------------
+#
+# Every flag below also reads an ``AMQP_*`` environment variable as its
+# default, before argparse's own default applies; a flag given on the command
+# line always wins. This is what lets docs/examples/docker/Dockerfile
+# configure a run entirely through ``docker run -e``, with no broker detail
+# baked into the image.
+
+_ENV_TRUE_VALUES = frozenset({"1", "true", "yes", "on"})
+_ENV_FALSE_VALUES = frozenset({"0", "false", "no", "off"})
+
+
+def _env_str(name: str, default: str) -> str:
+    """Return the string environment variable ``name``, or ``default`` if unset."""
+    return os.environ.get(name, default)
+
+
+def _env_optional_int(name: str) -> int | None:
+    """Return ``name`` parsed as an int, or ``None`` if unset.
+
+    Raises:
+        OptionsError: If ``name`` is set but is not a valid integer.
+    """
+    value = os.environ.get(name)
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        raise OptionsError(f"{name}={value!r} is not a valid integer") from None
+
+
+def _env_int(name: str, default: int) -> int:
+    """Return ``name`` parsed as an int, or ``default`` if unset."""
+    value = _env_optional_int(name)
+    return default if value is None else value
+
+
+def _env_float(name: str, default: float) -> float:
+    """Return ``name`` parsed as a float, or ``default`` if unset.
+
+    Raises:
+        OptionsError: If ``name`` is set but is not a valid float.
+    """
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        raise OptionsError(f"{name}={value!r} is not a valid float") from None
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    """Return the boolean ``name`` is set to, or ``default`` if unset.
+
+    Accepts ``1``/``true``/``yes``/``on`` and ``0``/``false``/``no``/``off``,
+    case-insensitively.
+
+    Raises:
+        OptionsError: If ``name`` is set to anything else.
+    """
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    normalized = value.strip().lower()
+    if normalized in _ENV_TRUE_VALUES:
+        return True
+    if normalized in _ENV_FALSE_VALUES:
+        return False
+    raise OptionsError(f"{name}={value!r} is not a valid boolean (true/false, yes/no, on/off, 1/0)")
+
+
 # --- timing -------------------------------------------------------------
 
 #: How long the drain wait blocks per poll before re-reading the counters.
@@ -169,8 +255,19 @@ def build_parser() -> argparse.ArgumentParser:
 
     Returns:
         A parser whose defaults match :class:`Options`', except for ``--queue``,
-        which is generated per run by :func:`parse_args`.
+        which is generated per run by :func:`parse_args`. Every default is first
+        read from its ``AMQP_*`` environment variable, falling back to
+        :class:`Options`' own default when that variable is unset.
+
+    Raises:
+        OptionsError: If an ``AMQP_*`` environment variable is set to a value
+            its flag cannot accept — the same rejection :func:`parse_args`
+            raises for a bad command-line value, just discovered earlier.
     """
+    queue_type_default = _env_str("AMQP_QUEUE_TYPE", QUEUE_TYPE_CLASSIC)
+    if queue_type_default not in QUEUE_TYPES:
+        raise OptionsError(f"AMQP_QUEUE_TYPE={queue_type_default!r} must be one of {', '.join(QUEUE_TYPES)}")
+
     parser = argparse.ArgumentParser(
         prog="console_application.py",
         description="Publish and consume messages against one RabbitMQ queue, then report what happened.",
@@ -179,52 +276,87 @@ def build_parser() -> argparse.ArgumentParser:
         "-n",
         "--messages",
         type=int,
-        default=DEFAULT_MESSAGE_COUNT,
-        help="how many messages to publish (default: %(default)s); 0 is rejected",
+        default=_env_int("AMQP_MESSAGES", DEFAULT_MESSAGE_COUNT),
+        help="how many messages to publish (default: %(default)s, env: AMQP_MESSAGES); 0 is rejected",
     )
     parser.add_argument(
         "--queue-type",
         choices=QUEUE_TYPES,
-        default=QUEUE_TYPE_CLASSIC,
-        help="which queue sub-builder declares the queue (default: %(default)s)",
+        default=queue_type_default,
+        help="which queue sub-builder declares the queue (default: %(default)s, env: AMQP_QUEUE_TYPE)",
+    )
+    parser.add_argument(
+        "--queue",
+        default=_env_str("AMQP_QUEUE", ""),
+        help="queue name (default: a generated console-app-* name, env: AMQP_QUEUE)",
+    )
+    parser.add_argument(
+        "--keep-queue",
+        action="store_true",
+        default=_env_bool("AMQP_KEEP_QUEUE", False),
+        help="do not delete the queue during teardown (env: AMQP_KEEP_QUEUE)",
     )
-    parser.add_argument("--queue", default="", help="queue name (default: a generated console-app-* name)")
-    parser.add_argument("--keep-queue", action="store_true", help="do not delete the queue during teardown")
     parser.add_argument(
         "--consume-timeout",
         type=float,
-        default=DEFAULT_CONSUME_TIMEOUT_SECONDS,
-        help="seconds to wait for consumption to catch up (default: %(default)s)",
+        default=_env_float("AMQP_CONSUME_TIMEOUT", DEFAULT_CONSUME_TIMEOUT_SECONDS),
+        help="seconds to wait for consumption to catch up (default: %(default)s, env: AMQP_CONSUME_TIMEOUT)",
     )
     parser.add_argument(
         "--publish-timeout",
         type=float,
-        default=DEFAULT_PUBLISH_TIMEOUT_SECONDS,
-        help="per-call publish timeout, in seconds (default: %(default)s)",
+        default=_env_float("AMQP_PUBLISH_TIMEOUT", DEFAULT_PUBLISH_TIMEOUT_SECONDS),
+        help="per-call publish timeout, in seconds (default: %(default)s, env: AMQP_PUBLISH_TIMEOUT)",
     )
     parser.add_argument(
         "--stats-interval",
         type=float,
-        default=DEFAULT_STATS_INTERVAL_SECONDS,
-        help="seconds between periodic stats blocks (default: %(default)s)",
+        default=_env_float("AMQP_STATS_INTERVAL", DEFAULT_STATS_INTERVAL_SECONDS),
+        help="seconds between periodic stats blocks (default: %(default)s, env: AMQP_STATS_INTERVAL)",
+    )
+    parser.add_argument(
+        "--host",
+        default=_env_str("AMQP_HOST", "localhost"),
+        help="broker host (default: %(default)s, env: AMQP_HOST)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=_env_optional_int("AMQP_PORT"),
+        help="broker port (default: 5672, or 5671 with --tls; env: AMQP_PORT)",
+    )
+    parser.add_argument(
+        "--user",
+        default=_env_str("AMQP_USER", "guest"),
+        help="SASL PLAIN username (default: %(default)s, env: AMQP_USER)",
+    )
+    parser.add_argument(
+        "--password",
+        default=_env_str("AMQP_PASSWORD", "guest"),
+        help="SASL PLAIN password (default: %(default)s, env: AMQP_PASSWORD)",
+    )
+    parser.add_argument(
+        "--vhost",
+        default=_env_str("AMQP_VHOST", "/"),
+        help="virtual host (default: %(default)s, env: AMQP_VHOST)",
+    )
+    parser.add_argument(
+        "--tls",
+        action="store_true",
+        default=_env_bool("AMQP_TLS", False),
+        help="wrap the connection in TLS (env: AMQP_TLS)",
     )
-    parser.add_argument("--host", default="localhost", help="broker host (default: %(default)s)")
-    parser.add_argument("--port", type=int, default=None, help="broker port (default: 5672, or 5671 with --tls)")
-    parser.add_argument("--user", default="guest", help="SASL PLAIN username (default: %(default)s)")
-    parser.add_argument("--password", default="guest", help="SASL PLAIN password (default: %(default)s)")
-    parser.add_argument("--vhost", default="/", help="virtual host (default: %(default)s)")
-    parser.add_argument("--tls", action="store_true", help="wrap the connection in TLS")
     parser.add_argument(
         "--recovery",
         action=argparse.BooleanOptionalAction,
-        default=True,
-        help="auto-reconnect after an unexpected disconnect (default: enabled)",
+        default=_env_bool("AMQP_RECOVERY", True),
+        help="auto-reconnect after an unexpected disconnect (default: enabled, env: AMQP_RECOVERY)",
     )
     parser.add_argument(
         "--recovery-topology",
         action=argparse.BooleanOptionalAction,
-        default=False,
-        help="redeclare recorded topology after a reconnect (default: disabled)",
+        default=_env_bool("AMQP_RECOVERY_TOPOLOGY", False),
+        help="redeclare recorded topology after a reconnect (default: disabled, env: AMQP_RECOVERY_TOPOLOGY)",
     )
     return parser
 

rabbitmq_amqp_python_client-2.0.0b2/docs/examples/docker/reliable/Dockerfile

@@ -0,0 +1,45 @@
+# Runs docs/examples/reliable.py as a container. Every runtime parameter is
+# external — set with `docker run -e` — following the same pattern as
+# rabbitmq-amqp-go-client's docs/examples/reliable/Dockerfile, which this
+# example is itself modeled on.
+#
+# Build context must be the repository root, since the image needs both the
+# installable package and the example script:
+#
+#     docker build -f docs/examples/docker/reliable/Dockerfile -t reliable-example .
+#
+# Run against a broker reachable as `rabbitmq`, publishing 1000 messages
+# non-interactively:
+#
+#     docker run --rm -e AMQP_HOST=rabbitmq -e MESSAGES_TO_SEND=1000 reliable-example
+#
+# See docs/examples/docker/reliable/README.md for the full variable table.
+
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# The client (pyproject.toml's `dependencies = []`) is pure Python with no
+# third-party dependencies, so it needs no `pip install` step — copying the
+# package onto PYTHONPATH is enough, and keeps the build itself needing no
+# network access beyond pulling this base image.
+COPY rabbitmq_amqp_python_client ./rabbitmq_amqp_python_client
+COPY docs/examples/reliable.py ./reliable.py
+ENV PYTHONPATH=/app
+
+# Matches reliable.py's own defaults, except QUEUE_NAME and IS_SILENT: a
+# container has no interactive stdin to press a key on, and
+# "clients-integration" is the queue name shared across the RabbitMQ clients'
+# own Dockerfiles. AMQP_PASSWORD's default is RabbitMQ's own documented
+# local-broker default, not a real secret.
+ENV AMQP_HOST=localhost \
+    AMQP_USER=guest \
+    AMQP_PASSWORD=guest \
+    AMQP_VHOST=/ \
+    AMQP_TLS=false \
+    QUEUE_NAME=clients-integration \
+    MESSAGES_TO_SEND=500000 \
+    IS_SILENT=true \
+    DELAY_MESSAGE=false
+
+ENTRYPOINT ["python", "reliable.py"]

rabbitmq_amqp_python_client-2.0.0b2/docs/examples/docker/reliable/README.md

@@ -0,0 +1,60 @@
+# Reliable messaging, containerized
+
+[`Dockerfile`](Dockerfile) packages [`reliable.py`](../../reliable.py) — a
+long-running publish/consume demo that keeps running through a broker
+disconnect and reconnect — as a container image, following the same pattern
+as [rabbitmq-amqp-go-client's own reliable
+example](https://github.com/rabbitmq/rabbitmq-amqp-go-client/tree/main/docs/examples/reliable).
+Every runtime parameter is external: nothing broker-specific is baked into
+the image, and every environment variable `reliable.py` reads can be set at
+`docker run` time instead.
+
+## Build
+
+Run from the repository root, since the build needs both the installable
+package and the example script:
+
+```sh
+docker build -f docs/examples/docker/reliable/Dockerfile -t reliable-example .
+```
+
+## Run
+
+```sh
+docker run --rm \
+  -e AMQP_HOST=rabbitmq \
+  -e MESSAGES_TO_SEND=1000 \
+  reliable-example
+```
+
+Against a broker on the Docker host rather than another container, use
+`--network host` (Linux) or `-e AMQP_HOST=host.docker.internal` (macOS/Windows).
+
+The image defaults `IS_SILENT=true`, since a container has no interactive
+stdin to press a key on: the process keeps publishing, consuming and logging
+periodic stats until the container is stopped (`docker stop`), rather than
+waiting for input like an un-containerized run does by default.
+
+## Environment variables
+
+Each variable sets that setting's value directly — there are no command-line
+flags, matching the Go example this is modeled on. Defaults below are the
+image's own (set in the `Dockerfile`), which match `reliable.py`'s
+un-containerized defaults except where noted.
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `QUEUE_NAME` | `clients-integration` | Quorum queue to declare, publish to and consume from. |
+| `MESSAGES_TO_SEND` | `500000` | How many messages the publish loop attempts; must be > 0. |
+| `IS_SILENT` | `true` | Run forever instead of waiting on stdin before tearing down. |
+| `DELAY_MESSAGE` | `false` | Pace the publish loop with a small sleep between messages. |
+| `AMQP_HOST` | `localhost` | Broker host. |
+| `AMQP_PORT` | unset (5672, or 5671 with `AMQP_TLS=true`) | Broker port. |
+| `AMQP_USER` | `guest` | SASL PLAIN username. |
+| `AMQP_PASSWORD` | `guest` | SASL PLAIN password. |
+| `AMQP_VHOST` | `/` | Virtual host. |
+| `AMQP_TLS` | `false` | Wrap the connection in TLS. |
+
+Boolean variables accept `true`/`false`, `yes`/`no`, `on`/`off` or `1`/`0`,
+case-insensitively; any other value is rejected before the container connects
+to anything.