rabbitmq-amqp-python-client 0.1.0b3__tar.gz → 0.2.0__tar.gz

rabbitmq_amqp_python_client-0.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: rabbitmq-amqp-python-client
+Version: 0.2.0
+Summary: Python RabbitMQ client for AMQP 1.0 protocol
+License: Apache-2.0 license
+License-File: LICENSE
+Author: RabbitMQ team
+Requires-Python: >=3.9,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: packaging (>=23.0,<24.0)
+Requires-Dist: python-qpid-proton (>=0.39.0,<0.40.0)
+Requires-Dist: typing-extensions (>=4.13.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+## RabbitMQ AMQP 1.0 Python Client
+This library is meant to be used with RabbitMQ `4.x`. Suitable for testing in pre-production environments.
+
+The client is distributed via [`PIP`](https://pypi.org/project/rabbitmq-amqp-python-client/):
+```bash
+ pip install rabbitmq-amqp-python-client
+```
+
+### Getting Started    
+
+Inside the [examples](./examples) folder you can find a set of examples that show how to use the client.
+
+
+### Documentation
+
+[Client Guide](https://www.rabbitmq.com/client-libraries/amqp-client-libraries) select the python section.
+
+
+### Build
+
+- `make rabbitmq-server`: run the RabbitMQ server in a docker container
+- `poetry build`: build the source project
+- `poetry install`: resolves and install dependencies
+- `make test`: run the tests
+
+### Note for MAC users:
+
+To run TLS you need to:
+``` bash
+- pip uninstall python-qpid-proton
+- brew install swig
+- brew install pkg-config
+- export CFLAGS="-I/usr/local/opt/openssl/include"; pip install python-qpid-proton --verbose --no-cache-dir
+```
+
+Read more about the issue [here](https://stackoverflow.com/questions/44979947/python-qpid-proton-for-mac-using-amqps)
+
+
+
+
+
+
+
+

rabbitmq_amqp_python_client-0.2.0/README.md

@@ -0,0 +1,43 @@
+## RabbitMQ AMQP 1.0 Python Client
+This library is meant to be used with RabbitMQ `4.x`. Suitable for testing in pre-production environments.
+
+The client is distributed via [`PIP`](https://pypi.org/project/rabbitmq-amqp-python-client/):
+```bash
+ pip install rabbitmq-amqp-python-client
+```
+
+### Getting Started    
+
+Inside the [examples](./examples) folder you can find a set of examples that show how to use the client.
+
+
+### Documentation
+
+[Client Guide](https://www.rabbitmq.com/client-libraries/amqp-client-libraries) select the python section.
+
+
+### Build
+
+- `make rabbitmq-server`: run the RabbitMQ server in a docker container
+- `poetry build`: build the source project
+- `poetry install`: resolves and install dependencies
+- `make test`: run the tests
+
+### Note for MAC users:
+
+To run TLS you need to:
+``` bash
+- pip uninstall python-qpid-proton
+- brew install swig
+- brew install pkg-config
+- export CFLAGS="-I/usr/local/opt/openssl/include"; pip install python-qpid-proton --verbose --no-cache-dir
+```
+
+Read more about the issue [here](https://stackoverflow.com/questions/44979947/python-qpid-proton-for-mac-using-amqps)
+
+
+
+
+
+
+

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rabbitmq-amqp-python-client"
-version = "0.1.0-beta.3"
+version = "0.2.0"
 description = "Python RabbitMQ client for AMQP 1.0 protocol"
 authors = ["RabbitMQ team"]
 license = "Apache-2.0 license"
@@ -9,10 +9,13 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.9"
 python-qpid-proton = "^0.39.0"
-pyjwt = "^2.10.1"
 typing-extensions = "^4.13.0"
+packaging = "^23.0"
+
 
 [tool.poetry.group.dev.dependencies]
+pyjwt = "^2.10.1"
+pika = "^1.3.2"
 flake8 = "^7.1.1"
 isort = "^5.9.3"
 mypy = "^0.910"

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/__init__.py

@@ -6,14 +6,17 @@ from .common import ExchangeType, QueueType
 from .connection import Connection
 from .consumer import Consumer
 from .entities import (
+    ConsumerOptions,
     ExchangeCustomSpecification,
     ExchangeSpecification,
     ExchangeToExchangeBindingSpecification,
     ExchangeToQueueBindingSpecification,
+    MessageProperties,
     OAuth2Options,
     OffsetSpecification,
     RecoveryConfiguration,
-    StreamOptions,
+    StreamConsumerOptions,
+    StreamFilterOptions,
 )
 from .environment import Environment
 from .exceptions import (
@@ -42,6 +45,7 @@ from .ssl_configuration import (
     WinClientCert,
     WinSslConfigurationContext,
 )
+from .utils import Converter
 
 try:
     __version__ = metadata.version(__package__)
@@ -84,11 +88,15 @@ __all__ = [
     "CurrentUserStore",
     "PKCS12Store",
     "ConnectionClosed",
-    "StreamOptions",
+    "StreamConsumerOptions",
+    "StreamFilterOptions",
+    "ConsumerOptions",
+    "MessageProperties",
     "OffsetSpecification",
     "OutcomeState",
     "Environment",
     "ExchangeCustomSpecification",
     "RecoveryConfiguration",
     "OAuth2Options",
+    "Converter",
 ]

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/connection.py

@@ -11,13 +11,14 @@ from typing import (
 )
 
 import typing_extensions
+from packaging import version
 
 from .address_helper import validate_address
 from .consumer import Consumer
 from .entities import (
+    ConsumerOptions,
     OAuth2Options,
     RecoveryConfiguration,
-    StreamOptions,
 )
 from .exceptions import (
     ArgumentOutOfRangeException,
@@ -166,6 +167,87 @@ class Connection:
                 password=self._password,
             )
 
+        self._validate_server_properties()
+
+    def _validate_server_properties(self) -> None:
+        """
+        Validate the server properties returned in the connection handshake.
+
+        Checks that the server is RabbitMQ and the version is >= 4.0.0.
+
+        Raises:
+            ValidationCodeException: If server is not RabbitMQ or version < 4.0.0
+        """
+        if self._conn is None or self._conn.conn is None:
+            raise ValidationCodeException("Connection not established")
+
+        remote_props = self._conn.conn.remote_properties
+        if remote_props is None:
+            raise ValidationCodeException("No remote properties received from server")
+
+        # Check if server is RabbitMQ
+        product = remote_props.get("product")
+        if product != "RabbitMQ":
+            raise ValidationCodeException(
+                f"Connection to non-RabbitMQ server detected. "
+                f"Expected 'RabbitMQ', got '{product}'"
+            )
+
+        # Check server version is >= 4.0.0
+        server_version = remote_props.get("version")
+        if server_version is None:
+            raise ValidationCodeException("Server version not provided")
+
+        try:
+            if version.parse(str(server_version)) < version.parse("4.0.0"):
+                raise ValidationCodeException(
+                    f"The AMQP client library requires RabbitMQ 4.0.0 or higher. "
+                    f"Server version: {server_version}"
+                )
+        except Exception as e:
+            raise ValidationCodeException(
+                f"Failed to parse server version '{server_version}': {e}"
+            )
+
+        logger.debug(f"Connected to RabbitMQ server version {server_version}")
+
+    def _is_server_version_gte(self, target_version: str) -> bool:
+        """
+        Check if the server version is greater than or equal to version.
+
+        This is an internal method that can be used to conditionally enable
+        features that require RabbitMQ version or higher.
+
+        Returns:
+            bool: True if server version >= version, False otherwise
+
+        Raises:
+            ValidationCodeException: If connection is not established or
+                                   remote properties are not available
+        """
+        if self._conn is None or self._conn.conn is None:
+            raise ValidationCodeException("Connection not established")
+
+        remote_props = self._conn.conn.remote_properties
+        if remote_props is None:
+            raise ValidationCodeException("No remote properties received from server")
+
+        server_version = remote_props.get("version")
+        if server_version is None:
+            raise ValidationCodeException("Server version not provided")
+
+        try:
+            srv = version.parse(str(server_version))
+            trg = version.parse(target_version)
+            # compare the version even if it contains pre-release or build metadata
+            return (
+                version.parse("{}.{}.{}".format(srv.major, srv.minor, srv.micro)) >= trg
+            )
+        except Exception as e:
+            raise ValidationCodeException(
+                f"Failed to parse server version '{server_version}': {e}"
+            )
+
     def dial(self) -> None:
         """
         Establish a connection to the AMQP server.
@@ -286,7 +368,7 @@ class Connection:
             ArgumentOutOfRangeException: If destination address format is invalid
         """
         if destination != "":
-            if validate_address(destination) is False:
+            if not validate_address(destination):
                 raise ArgumentOutOfRangeException(
                     "destination address must start with /queues or /exchanges"
                 )
@@ -299,7 +381,7 @@ class Connection:
         self,
         destination: str,
         message_handler: Optional[MessagingHandler] = None,
-        stream_filter_options: Optional[StreamOptions] = None,
+        consumer_options: Optional[ConsumerOptions] = None,
         credit: Optional[int] = None,
     ) -> Consumer:
         """
@@ -308,7 +390,7 @@ class Connection:
         Args:
             destination: The address to consume from
             message_handler: Optional handler for processing messages
-            stream_filter_options: Optional configuration for stream consumption
+            consumer_options: Optional configuration for queue consumption. Each queue has its own consumer options.
             credit: Optional credit value for flow control
 
         Returns:
@@ -317,12 +399,20 @@ class Connection:
         Raises:
             ArgumentOutOfRangeException: If destination address format is invalid
         """
-        if validate_address(destination) is False:
+        if not validate_address(destination):
             raise ArgumentOutOfRangeException(
                 "destination address must start with /queues or /exchanges"
             )
+        if consumer_options is not None:
+            consumer_options.validate(
+                {
+                    "4.0.0": self._is_server_version_gte("4.0.0"),
+                    "4.1.0": self._is_server_version_gte("4.1.0"),
+                    "4.2.0": self._is_server_version_gte("4.2.0"),
+                }
+            )
         consumer = Consumer(
-            self._conn, destination, message_handler, stream_filter_options, credit
+            self._conn, destination, message_handler, consumer_options, credit
         )
         self._consumers.append(consumer)
         return consumer

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/consumer.py

@@ -2,7 +2,7 @@ import logging
 from typing import Literal, Optional, Union, cast
 
 from .amqp_consumer_handler import AMQPMessagingHandler
-from .entities import StreamOptions
+from .entities import ConsumerOptions
 from .options import (
     ReceiverOptionUnsettled,
     ReceiverOptionUnsettledWithFilters,
@@ -29,7 +29,7 @@ class Consumer:
         _conn (BlockingConnection): The underlying connection to RabbitMQ
         _addr (str): The address to consume from
         _handler (Optional[MessagingHandler]): Optional message handling callback
-        _stream_options (Optional[StreamOptions]): Configuration for stream consumption
+        _stream_options (Optional[StreamConsumerOptions]): Configuration for stream consumption
         _credit (Optional[int]): Flow control credit value
     """
 
@@ -38,7 +38,7 @@ class Consumer:
         conn: BlockingConnection,
         addr: str,
         handler: Optional[AMQPMessagingHandler] = None,
-        stream_options: Optional[StreamOptions] = None,
+        stream_options: Optional[ConsumerOptions] = None,
         credit: Optional[int] = None,
     ):
         """
@@ -62,7 +62,7 @@ class Consumer:
 
     def _open(self) -> None:
         if self._receiver is None:
-            logger.debug("Creating Sender")
+            logger.debug("Creating Receiver")
             self._receiver = self._create_receiver(self._addr)
 
     def _update_connection(self, conn: BlockingConnection) -> None:

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/entities.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from datetime import timedelta
+from datetime import datetime, timedelta
 from enum import Enum
 from typing import Any, Dict, Optional, Union
 
@@ -7,9 +7,13 @@ from .common import ExchangeType, QueueType
 from .exceptions import ValidationCodeException
 from .qpid.proton._data import Described, symbol
 
+SQL_FILTER = "sql-filter"
+AMQP_SQL_FILTER = "amqp:sql-filter"
 STREAM_FILTER_SPEC = "rabbitmq:stream-filter"
 STREAM_OFFSET_SPEC = "rabbitmq:stream-offset-spec"
 STREAM_FILTER_MATCH_UNFILTERED = "rabbitmq:stream-match-unfiltered"
+AMQP_PROPERTIES_FILTER = "amqp:properties-filter"
+AMQP_APPLICATION_PROPERTIES_FILTER = "amqp:application-properties-filter"
 
 
 @dataclass
@@ -149,7 +153,77 @@ class ExchangeToExchangeBindingSpecification:
     binding_key: Optional[str] = None
 
 
-class StreamOptions:
+class ConsumerOptions:
+    def validate(self, versions: Dict[str, bool]) -> None:
+        raise NotImplementedError("Subclasses should implement this method")
+
+    def filter_set(self) -> Dict[symbol, Described]:
+        raise NotImplementedError("Subclasses should implement this method")
+
+
+@dataclass
+class MessageProperties:
+    """
+    Properties for an AMQP message.
+
+    Attributes:
+        message_id: Uniquely identifies a message within the system (int, UUID, bytes, or str).
+        user_id: Identity of the user responsible for producing the message.
+        subject: Summary information about the message content and purpose.
+        reply_to: Address of the node to send replies to.
+        correlation_id: Client-specific id for marking or identifying messages (int, UUID, bytes, or str).
+        content_type: RFC-2046 MIME type for the message's body.
+        content_encoding: Modifier to the content-type.
+        absolute_expiry_time: Absolute time when the message expires.
+        creation_time: Absolute time when the message was created.
+        group_id: Group the message belongs to.
+        group_sequence: Relative position of this message within its group.
+        reply_to_group_id: Id for sending replies to a specific group.
+    """
+
+    message_id: Optional[Union[int, str, bytes]] = None
+    user_id: Optional[bytes] = None
+    subject: Optional[str] = None
+    reply_to: Optional[str] = None
+    correlation_id: Optional[Union[int, str, bytes]] = None
+    content_type: Optional[str] = None
+    content_encoding: Optional[str] = None
+    absolute_expiry_time: Optional[datetime] = None
+    creation_time: Optional[datetime] = None
+    group_id: Optional[str] = None
+    group_sequence: Optional[int] = None
+    reply_to_group_id: Optional[str] = None
+
+
+"""
+  StreamFilterOptions defines the filtering options for a stream consumer.
+  for values and match_unfiltered see: https://www.rabbitmq.com/blog/2023/10/16/stream-filtering
+"""
+
+
+class StreamFilterOptions:
+    values: Optional[list[str]] = None
+    match_unfiltered: bool = False
+    application_properties: Optional[dict[str, Any]] = None
+    message_properties: Optional[MessageProperties] = None
+    sql: str = ""
+
+    def __init__(
+        self,
+        values: Optional[list[str]] = None,
+        match_unfiltered: bool = False,
+        application_properties: Optional[dict[str, Any]] = None,
+        message_properties: Optional[MessageProperties] = None,
+        sql: str = "",
+    ):
+        self.values = values
+        self.match_unfiltered = match_unfiltered
+        self.application_properties = application_properties
+        self.message_properties = message_properties
+        self.sql = sql
+
+
+class StreamConsumerOptions(ConsumerOptions):
     """
     Configuration options for stream queues.
 
@@ -161,29 +235,42 @@ class StreamOptions:
     Args:
         offset_specification: Either an OffsetSpecification enum value or
                                 an integer offset
-        filters: List of filter strings to apply to the stream
+        filter_options: Filter options for the stream consumer. See StreamFilterOptions
     """
 
     def __init__(
         self,
         offset_specification: Optional[Union[OffsetSpecification, int]] = None,
-        filters: Optional[list[str]] = None,
-        filter_match_unfiltered: bool = False,
+        filter_options: Optional[StreamFilterOptions] = None,
     ):
 
-        if offset_specification is None and filters is None:
+        self._filter_set: Dict[symbol, Described] = {}
+        self._filter_option = filter_options
+
+        if offset_specification is None and filter_options is None:
             raise ValidationCodeException(
                 "At least one between offset_specification and filters must be set when setting up filtering"
             )
-        self._filter_set: Dict[symbol, Described] = {}
         if offset_specification is not None:
             self._offset(offset_specification)
 
-        if filters is not None:
-            self._filter_values(filters)
+        if filter_options is None:
+            return
+
+        if filter_options.values is not None:
+            self._filter_values(filter_options.values)
+
+        if filter_options.match_unfiltered:
+            self._filter_match_unfiltered(filter_options.match_unfiltered)
 
-        if filter_match_unfiltered is True:
-            self._filter_match_unfiltered(filter_match_unfiltered)
+        if filter_options.message_properties is not None:
+            self._filter_message_properties(filter_options.message_properties)
+
+        if filter_options.application_properties is not None:
+            self._filter_application_properties(filter_options.application_properties)
+
+        if filter_options.sql is not None and filter_options.sql != "":
+            self._filter_sql(filter_options.sql)
 
     def _offset(self, offset_specification: Union[OffsetSpecification, int]) -> None:
         """
@@ -225,6 +312,49 @@ class StreamOptions:
             symbol(STREAM_FILTER_MATCH_UNFILTERED), filter_match_unfiltered
         )
 
+    def _filter_message_properties(
+        self, message_properties: Optional[MessageProperties]
+    ) -> None:
+        """
+        Set AMQP message properties for filtering.
+
+        Args:
+            message_properties: MessageProperties object containing AMQP message properties
+        """
+        if message_properties is not None:
+            # dictionary of symbols and described
+            filter_prop: Dict[symbol, Any] = {}
+
+            for key, value in message_properties.__dict__.items():
+                if value is not None:
+                    # replace _ with - for the key
+                    filter_prop[symbol(key.replace("_", "-"))] = value
+
+            if len(filter_prop) > 0:
+                self._filter_set[symbol(AMQP_PROPERTIES_FILTER)] = Described(
+                    symbol(AMQP_PROPERTIES_FILTER), filter_prop
+                )
+
+    def _filter_application_properties(
+        self, application_properties: Optional[dict[str, Any]]
+    ) -> None:
+        if application_properties is not None:
+            app_prop = application_properties.copy()
+
+            if len(app_prop) > 0:
+                self._filter_set[symbol(AMQP_APPLICATION_PROPERTIES_FILTER)] = (
+                    Described(symbol(AMQP_APPLICATION_PROPERTIES_FILTER), app_prop)
+                )
+
+    def _filter_sql(self, sql: str) -> None:
+        """
+        Set SQL filter for the stream.
+
+        Args:
+            sql: SQL string to apply as a filter
+        """
+        self._filter_set[symbol(SQL_FILTER)] = Described(symbol(AMQP_SQL_FILTER), sql)
+
     def filter_set(self) -> Dict[symbol, Described]:
         """
         Get the current filter set configuration.
@@ -234,6 +364,41 @@ class StreamOptions:
         """
         return self._filter_set
 
+    def validate(self, versions: Dict[str, bool]) -> None:
+        """
+        Validates stream filter options against supported RabbitMQ server versions.
+
+        Args:
+            versions: Dictionary mapping version strings to boolean indicating support.
+
+        Raises:
+            ValidationCodeException: If a filter option requires a higher RabbitMQ version.
+        """
+        if self._filter_option is None:
+            return
+        if self._filter_option.values and not versions.get("4.1.0", False):
+            raise ValidationCodeException(
+                "Stream filter by values requires RabbitMQ 4.1.0 or higher"
+            )
+        if self._filter_option.match_unfiltered and not versions.get("4.1.0", False):
+            raise ValidationCodeException(
+                "Stream filter by match_unfiltered requires RabbitMQ 4.1.0 or higher"
+            )
+        if self._filter_option.sql and not versions.get("4.2.0", False):
+            raise ValidationCodeException(
+                "Stream filter by SQL requires RabbitMQ 4.2.0 or higher"
+            )
+        if self._filter_option.message_properties and not versions.get("4.1.0", False):
+            raise ValidationCodeException(
+                "Stream filter by message_properties requires RabbitMQ 4.1.0 or higher"
+            )
+        if self._filter_option.application_properties and not versions.get(
+            "4.1.0", False
+        ):
+            raise ValidationCodeException(
+                "Stream filter by application_properties requires RabbitMQ 4.1.0 or higher"
+            )
+
 
 @dataclass
 class RecoveryConfiguration:

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/management.py

@@ -125,18 +125,20 @@ class Management:
 
     def _request(
         self,
-        id: str,
+        msg_id: str,
         body: Any,
         path: str,
         method: str,
         expected_response_codes: list[int],
     ) -> Message:
         amq_message = Message(
-            id=id,
+            id=msg_id,
             body=body,
+            inferred=False,
             reply_to="$me",
             address=path,
             subject=method,
+            durable=False,
         )
 
         if self._sender is not None:
@@ -169,9 +171,7 @@ class Management:
             ValidationCodeException: If exchange already exists or other validation fails
         """
         logger.debug("declare_exchange operation called")
-        body: dict[str, Any] = {}
-        body["auto_delete"] = exchange_specification.is_auto_delete
-        body["durable"] = exchange_specification.is_durable
+        body: dict[str, Any] = {"durable": exchange_specification.is_durable}
         if isinstance(exchange_specification, ExchangeSpecification):
             body["type"] = exchange_specification.exchange_type.value
         elif isinstance(exchange_specification, ExchangeCustomSpecification):

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/options.py

@@ -1,4 +1,4 @@
-from .entities import StreamOptions
+from .entities import ConsumerOptions
 from .qpid.proton._data import (  # noqa: E402
     PropertyDict,
     symbol,
@@ -68,8 +68,8 @@ class ReceiverOptionUnsettled(LinkOption):  # type: ignore
 
 
 class ReceiverOptionUnsettledWithFilters(Filter):  # type: ignore
-    def __init__(self, addr: str, filter_options: StreamOptions):
-        super().__init__(filter_options.filter_set())
+    def __init__(self, addr: str, consumer_options: ConsumerOptions):
+        super().__init__(consumer_options.filter_set())
         self._addr = addr
 
     def apply(self, link: Link) -> None:

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/publisher.py

@@ -80,6 +80,14 @@ class Publisher:
                 "address specified in both message and publisher"
             )
 
+        if not isinstance(message.body, (bytes, type(None))):
+            raise ArgumentOutOfRangeException(
+                "Message body must be of type bytes or None"
+            )
+
+        if not message.inferred:
+            raise ArgumentOutOfRangeException("Message inferred must be True")
+
         if self._addr != "":
             if self._sender is not None:
                 return self._sender.send(message)

{rabbitmq_amqp_python_client-0.1.0b3 → rabbitmq_amqp_python_client-0.2.0}/rabbitmq_amqp_python_client/qpid/proton/_endpoints.py

@@ -482,7 +482,7 @@ class Connection(Wrapper, Endpoint):
         return c and SymbolList(c)
 
     @property
-    def remote_properties(self):
+    def remote_properties(self) -> Optional[Data]:
         """
         The properties specified by the remote peer for this connection.