Apply ruff format . again.

Author: wojcikstefan

example_config.py

@@ -3,70 +3,70 @@
 
 # Host and port to bind WebSockets.
 
-WS_HOST = '127.0.0.1'
-WS_PORT = '9000'
+WS_HOST = "127.0.0.1"
+WS_PORT = "9000"
 
 # Redis options
 REDIS = {
-    'host': 'localhost',
-    'port': 6379,
+    "host": "localhost",
+    "port": 6379,
 }
 
 # Optional metrics reporting with Prometheus
 METRICS = {
-    'prometheus': {
-        'port': 9090,
+    "prometheus": {
+        "port": 9090,
     }
 }
 
 # Authentication (currently only "ticket" authentication is supported)
 AUTHENTICATION = {
-    'ticket': {
+    "ticket": {
         # API endpoint to validate the ticket and exchange it for auth info.
-        'validation_url': 'http://auth-service/auth/ticket/',
+        "validation_url": "http://auth-service/auth/ticket/",
         # Fields that the validation endpoint returns.
-        'auth_fields': ['session_id', 'user_id'],
+        "auth_fields": ["session_id", "user_id"],
     }
 }
 
 # List of services
 SERVICES = {
-    'my_service': {
+    "my_service": {
         # Whether to always require authentication. When False, anonymous
         # sessions are supported even if an authorizer is configured.
-        'require_authentication': True,
+        "require_authentication": True,
         # URL to the authorizer which receives auth information (from the
         # authentication endpoint), extra fields (configured below), and
         # subscription information.
-        'authorizer': 'http://auth-service/auth/authorizer/',
+        "authorizer": "http://auth-service/auth/authorizer/",
         # Fields returned by the authorizer callback that are passed to all
         # subsequent service callbacks.
-        'authorizer_fields': ['capabilities'],
+        "authorizer_fields": ["capabilities"],
         # Periodically reauthorize subscriptions and add some jitter to avoid
         # thundering herds.
-        'authorization_renewal_period': 300,
-        'authorization_renewal_jitter': 30,
+        "authorization_renewal_period": 300,
+        "authorization_renewal_jitter": 30,
         # If this service requires extra fields to fulfill a subscription,
         # you may provide them here. They are passed to all URL callbacks.
-        'extra_fields': ['organization_id'],
+        "extra_fields": ["organization_id"],
         # If filter fields are specified, messages can be published only to
         # sessions that match the given fields (either from extra_fields or
         # from authorizer_fields).
-        'filter_fields': ['user_id'],
+        "filter_fields": ["user_id"],
         # Optional URL which is called before subscribing to or unsubscribing
         # from this service. When an error is returned, the subscription or
         # unsubscription command fails.
-        "before_subscribe": 'http://my-service/subscribe/',
-        "before_unsubscribe": 'http://my-service/unsubscribe/',
+        "before_subscribe": "http://my-service/subscribe/",
+        "before_unsubscribe": "http://my-service/unsubscribe/",
         # Optional URL which is called after subscribing to or unsubscribing
         # from this service.
-        "on_subscribe": 'http://my-service/on_subscribe/',
-        "on_unsubscribe": 'http://my-service/on_unsubscribe/',
+        "on_subscribe": "http://my-service/on_subscribe/",
+        "on_unsubscribe": "http://my-service/on_unsubscribe/",
         # URL which is called when a message is passed to this service.
-        "on_message": 'http://my-service/on_message/',
+        "on_message": "http://my-service/on_message/",
         # If set, the service will send a heartbeat message to the URL defined
         # in 'on_heartbeat' every 'heartbeat_period' seconds.
         "heartbeat_period": 30,
-        "on_heartbeat": 'http://my-service/on_heartbeat/',
+        "on_heartbeat": "http://my-service/on_heartbeat/",
     },
 }

setup.py

@@ -1,58 +1,58 @@
 from setuptools import setup
 
-with open('README.rst', encoding='utf-8') as file:
+with open("README.rst", encoding="utf-8") as file:
     long_description = file.read()
 
 
 install_requires = [
-    'aiohttp',
-    'aioredis',
-    'click',
-    'structlog',
-    'websockets',
+    "aiohttp",
+    "aioredis",
+    "click",
+    "structlog",
+    "websockets",
 ]
 
 tests_require = install_requires + [
-    'aioresponses',
-    'pytest',
-    'pytest-asyncio',
-    'ruff',
+    "aioresponses",
+    "pytest",
+    "pytest-asyncio",
+    "ruff",
 ]
 
 setup(
-    name='socketshark',
-    version='0.5.0',
-    url='http://github.com/closeio/socketshark',
-    license='MIT',
-    description='WebSocket message router',
+    name="socketshark",
+    version="0.5.0",
+    url="http://github.com/closeio/socketshark",
+    license="MIT",
+    description="WebSocket message router",
     long_description=long_description,
-    test_suite='tests',
+    test_suite="tests",
     tests_require=tests_require,
-    platforms='any',
+    platforms="any",
     install_requires=install_requires,
     extras_require={
-        'prometheus': 'prometheus-async',
+        "prometheus": "prometheus-async",
     },
     classifiers=[
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
-        'Topic :: Software Development :: Libraries :: Python Modules',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.9',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Programming Language :: Python :: 3.12',
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
     ],
     packages=[
-        'socketshark',
-        'socketshark.backend',
-        'socketshark.metrics',
+        "socketshark",
+        "socketshark.backend",
+        "socketshark.metrics",
     ],
     entry_points={
-        'console_scripts': [
-            'socketshark = socketshark.__main__:run',
+        "console_scripts": [
+            "socketshark = socketshark.__main__:run",
         ],
     },
 )

socketshark/__init__.py

@@ -21,21 +21,21 @@
 
 def setup_logging(log_config: LogConfig) -> None:
     # Configure root logger if logging level is specified in config
-    if log_config['level']:
-        level = getattr(logging, log_config['level'])
-        formatter = logging.Formatter(log_config['format'])
+    if log_config["level"]:
+        level = getattr(logging, log_config["level"])
+        formatter = logging.Formatter(log_config["format"])
         sh: logging.StreamHandler[Any] = logging.StreamHandler()
         sh.setFormatter(formatter)
 
         logger = logging.getLogger()
         logger.setLevel(level)
         logger.addHandler(sh)
 
-        trace_level = getattr(logging, log_config['trace_level'])
-        trace_logger = logging.getLogger(log_config['trace_logger_prefix'])
+        trace_level = getattr(logging, log_config["trace_level"])
+        trace_logger = logging.getLogger(log_config["trace_logger_prefix"])
         trace_logger.setLevel(trace_level)
 
-    if log_config['setup_structlog']:
+    if log_config["setup_structlog"]:
         setup_structlog(sys.stdout.isatty())
 
 
@@ -44,7 +44,7 @@ def setup_structlog(tty: bool = False) -> None:
         structlog.stdlib.filter_by_level,
         structlog.stdlib.add_log_level,
         structlog.stdlib.add_logger_name,
-        structlog.processors.TimeStamper(fmt='iso', utc=True),
+        structlog.processors.TimeStamper(fmt="iso", utc=True),
         structlog.processors.StackInfoRenderer(),
         structlog.processors.format_exc_info,
     ]
@@ -66,8 +66,8 @@ def load_backend(config: Config) -> Any:
     """
     Return the backend module from the given SocketShark configuration.
     """
-    backend_name = config.get('BACKEND', 'websockets')
-    backend_module = f'socketshark.backend.{backend_name}'
+    backend_name = config.get("BACKEND", "websockets")
+    backend_module = f"socketshark.backend.{backend_name}"
     return importlib.import_module(backend_module)
 
 
@@ -87,35 +87,35 @@ def __init__(self, config: Config) -> None:
         self.redis_connections: list[RedisConnection] = []
 
     def _init_logging(self) -> None:
-        logger_name = self.config['LOG']['logger_name']
-        trace_logger_prefix = self.config['LOG']['trace_logger_prefix']
-        trace_logger_name = f'{trace_logger_prefix}.{logger_name}'
+        logger_name = self.config["LOG"]["logger_name"]
+        trace_logger_prefix = self.config["LOG"]["trace_logger_prefix"]
+        trace_logger_name = f"{trace_logger_prefix}.{logger_name}"
         pid = os.getpid()
         self.log: structlog.stdlib.BoundLogger = structlog.get_logger(
             logger_name
         ).bind(pid=pid)
         self.trace_log: structlog.stdlib.BoundLogger = structlog.get_logger(
             trace_logger_name
         ).bind(pid=pid)
-        self.trace_log.debug('trace')
+        self.trace_log.debug("trace")
 
     def signal_ready(self) -> None:
         """
         Notify that the backend is ready.
         """
         self.log.info(
-            '🦈  ready',
-            host=self.config['WS_HOST'],
-            port=self.config['WS_PORT'],
-            secure=bool(self.config.get('WS_SSL')),
+            "🦈  ready",
+            host=self.config["WS_HOST"],
+            port=self.config["WS_PORT"],
+            secure=bool(self.config.get("WS_SSL")),
         )
         self.metrics.set_ready(True)
 
     def signal_shutdown(self) -> None:
         """
         Notify that the backend shut down.
         """
-        self.log.info('done')
+        self.log.info("done")
         self.metrics.set_ready(False)
 
     async def _redis_connection_handler(self) -> None:
@@ -132,7 +132,7 @@ async def _redis_connection_handler(self) -> None:
         ]
         await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
 
-        self.log.error('redis unexpectedly closed')
+        self.log.error("redis unexpectedly closed")
         self.metrics.set_ready(False)
 
         # Since we rely on PUBSUB channels, we disconnect all clients when
@@ -145,15 +145,15 @@ async def prepare(self) -> None:
 
         Initialize Redis connection and the receiver class.
         """
-        redis_settings = [self.config['REDIS']]
-        if self.config.get('REDIS_ALT'):
-            redis_settings.append(self.config['REDIS_ALT'])
+        redis_settings = [self.config["REDIS"]]
+        if self.config.get("REDIS_ALT"):
+            redis_settings.append(self.config["REDIS_ALT"])
         try:
             self.redis_connections = await asyncio.gather(
                 *[RedisConnection.create(s) for s in redis_settings]
             )
         except (OSError, aioredis.RedisError):
-            self.log.exception('could not connect to redis')
+            self.log.exception("could not connect to redis")
             raise
 
         self._redis_connection_handler_task = asyncio.ensure_future(
@@ -174,7 +174,7 @@ async def shutdown(self) -> None:
         if self._shutdown:
             return
 
-        self.log.info('shutting down')
+        self.log.info("shutting down")
 
         self._shutdown = True
 
@@ -192,7 +192,7 @@ async def shutdown(self) -> None:
         # Wait for all sessions to close
         while self.sessions:
             self.log.info(
-                'waiting for sessions to close', n_sessions=len(self.sessions)
+                "waiting for sessions to close", n_sessions=len(self.sessions)
             )
             await asyncio.sleep(1)
 
@@ -238,7 +238,7 @@ def _install_signal_handlers(self) -> None:
         """
 
         def request_stop() -> None:
-            self.log.info('stop requested')
+            self.log.info("stop requested")
             asyncio.ensure_future(self.shutdown())
 
         loop = asyncio.get_event_loop()
@@ -254,11 +254,11 @@ def _uninstall_signal_handlers(self) -> None:
         loop.remove_signal_handler(signal.SIGTERM)
 
     def get_ssl_context(self) -> ssl.SSLContext | None:
-        ssl_settings = self.config.get('WS_SSL')
+        ssl_settings = self.config.get("WS_SSL")
         if ssl_settings:
             ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
             ssl_context.load_cert_chain(
-                certfile=ssl_settings['cert'], keyfile=ssl_settings['key']
+                certfile=ssl_settings["cert"], keyfile=ssl_settings["key"]
             )
             return ssl_context
         return None
@@ -286,16 +286,16 @@ def load_config(config_name: str) -> Config:
 
 
 @click.command()
-@click.option('-c', '--config', required=True, help='dotted path to config')
+@click.option("-c", "--config", required=True, help="dotted path to config")
 @click.pass_context
 def run(context: click.Context, config: str) -> None:
     config_obj = load_config(config)
 
-    setup_logging(config_obj['LOG'])
+    setup_logging(config_obj["LOG"])
 
     shark = SocketShark(config_obj)
     try:
         shark.start()
     except Exception:
-        shark.log.exception('unhandled exception')
+        shark.log.exception("unhandled exception")
         raise