chore: fix formatting errors

Signed-off-by: Kanishk Pachauri <[email protected]>

Author: Mr-Sunglasses

podman/domain/containers_create.py

@@ -422,9 +422,7 @@ def _convert_env_list_to_dict(env_list):
 
             # Validate key is not empty
             if not key.strip():
-                raise ValueError(
-                    f"Environment variable at index {i} has empty key: '{env_var}'"
-                )
+                raise ValueError(f"Environment variable at index {i} has empty key: '{env_var}'")
 
             env_dict[key] = value
         return env_dict
@@ -554,9 +552,7 @@ def to_bytes(size: Union[int, str, None]) -> Union[int, None]:
             "cni_networks": [pop("network")],
             "command": args.pop("command", args.pop("cmd", None)),
             "conmon_pid_file": pop("conmon_pid_file"),  # TODO document, podman only
-            "containerCreateCommand": pop(
-                "containerCreateCommand"
-            ),  # TODO document, podman only
+            "containerCreateCommand": pop("containerCreateCommand"),  # TODO document, podman only
             "devices": [],
             "dns_option": pop("dns_opt"),
             "dns_search": pop("dns_search"),
@@ -605,9 +601,7 @@ def to_bytes(size: Union[int, str, None]) -> Union[int, None]:
             "rootfs_propagation": pop("rootfs_propagation"),
             "sdnotifyMode": pop("sdnotifyMode"),  # TODO document, podman only
             "seccomp_policy": pop("seccomp_policy"),  # TODO document, podman only
-            "seccomp_profile_path": pop(
-                "seccomp_profile_path"
-            ),  # TODO document, podman only
+            "seccomp_profile_path": pop("seccomp_profile_path"),  # TODO document, podman only
             "secrets": [],  # TODO document, podman only
             "selinux_opts": pop("security_opt"),
             "shm_size": to_bytes(pop("shm_size")),
@@ -623,9 +617,7 @@ def to_bytes(size: Union[int, str, None]) -> Union[int, None]:
             "unified": pop("unified"),  # TODO document, podman only
             "unmask": pop("unmasked_paths"),  # TODO document, podman only
             "use_image_hosts": pop("use_image_hosts"),  # TODO document, podman only
-            "use_image_resolve_conf": pop(
-                "use_image_resolve_conf"
-            ),  # TODO document, podman only
+            "use_image_resolve_conf": pop("use_image_resolve_conf"),  # TODO document, podman only
             "user": pop("user"),
             "version": pop("version"),
             "volumes": [],
@@ -647,15 +639,9 @@ def to_bytes(size: Union[int, str, None]) -> Union[int, None]:
             params["log_configuration"]["driver"] = args["log_config"].get("Type")
 
             if "Config" in args["log_config"]:
-                params["log_configuration"]["path"] = args["log_config"]["Config"].get(
-                    "path"
-                )
-                params["log_configuration"]["size"] = args["log_config"]["Config"].get(
-                    "size"
-                )
-                params["log_configuration"]["options"] = args["log_config"][
-                    "Config"
-                ].get("options")
+                params["log_configuration"]["path"] = args["log_config"]["Config"].get("path")
+                params["log_configuration"]["size"] = args["log_config"]["Config"].get("size")
+                params["log_configuration"]["options"] = args["log_config"]["Config"].get("options")
             args.pop("log_config")
 
         for item in args.pop("mounts", []):
@@ -710,9 +696,7 @@ def parse_host_port(_container_port, _protocol, _host):
                 result.append(port_map)
             elif isinstance(_host, list):
                 for host_list in _host:
-                    host_list_result = parse_host_port(
-                        _container_port, _protocol, host_list
-                    )
+                    host_list_result = parse_host_port(_container_port, _protocol, host_list)
                     result.extend(host_list_result)
             elif isinstance(_host, dict):
                 _host_port = _host.get("port")
@@ -854,8 +838,7 @@ def parse_host_port(_container_port, _protocol, _host):
 
         if len(args) > 0:
             raise TypeError(
-                "Unknown keyword argument(s): "
-                + " ,".join(f"'{k}'" for k in args.keys())
+                "Unknown keyword argument(s): " + " ,".join(f"'{k}'" for k in args.keys())
             )
 
         return params

podman/tests/unit/test_containersmanager.py

@@ -260,9 +260,9 @@ def test_create_parse_host_port(self, mock):
                 "protocol": "tcp",
             },
         ]
-        actual_ports = json.loads(
-            self.client.containers.client.post.call_args[1]["data"]
-        )["portmappings"]
+        actual_ports = json.loads(self.client.containers.client.post.call_args[1]["data"])[
+            "portmappings"
+        ]
         self.assertEqual(expected_ports, actual_ports)
 
     @requests_mock.Mocker()
@@ -284,9 +284,9 @@ def test_create_userns_mode_simple(self, mock):
         self.client.containers.client.post.assert_called()
         expected_userns = {"nsmode": userns}
 
-        actual_userns = json.loads(
-            self.client.containers.client.post.call_args[1]["data"]
-        )["userns"]
+        actual_userns = json.loads(self.client.containers.client.post.call_args[1]["data"])[
+            "userns"
+        ]
         self.assertEqual(expected_userns, actual_userns)
 
     @requests_mock.Mocker()
@@ -308,9 +308,9 @@ def test_create_userns_mode_dict(self, mock):
         self.client.containers.client.post.assert_called()
         expected_userns = dict(**userns)
 
-        actual_userns = json.loads(
-            self.client.containers.client.post.call_args[1]["data"]
-        )["userns"]
+        actual_userns = json.loads(self.client.containers.client.post.call_args[1]["data"])[
+            "userns"
+        ]
         self.assertEqual(expected_userns, actual_userns)
 
     def test_create_unsupported_key(self):
@@ -323,13 +323,10 @@ def test_create_unknown_key(self):
 
     @requests_mock.Mocker()
     def test_create_convert_env_list_to_dict(self, mock):
-
         env_list1 = ["FOO=foo", "BAR=bar"]
         # Test valid list
         converted_dict1 = {"FOO": "foo", "BAR": "bar"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list1), converted_dict1
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list1), converted_dict1)
 
         # Test empty string
         env_list2 = ["FOO=foo", ""]
@@ -346,51 +343,37 @@ def test_create_convert_env_list_to_dict(self, mock):
         # Test empty list
         env_list5 = []
         converted_dict5 = {}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list5), converted_dict5
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list5), converted_dict5)
 
         # Test single valid environment variable
         env_list6 = ["SINGLE=value"]
         converted_dict6 = {"SINGLE": "value"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list6), converted_dict6
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list6), converted_dict6)
 
         # Test environment variable with empty value
         env_list7 = ["EMPTY="]
         converted_dict7 = {"EMPTY": ""}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list7), converted_dict7
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list7), converted_dict7)
 
         # Test environment variable with multiple equals signs
         env_list8 = ["URL=https://example.com/path?param=value"]
         converted_dict8 = {"URL": "https://example.com/path?param=value"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list8), converted_dict8
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list8), converted_dict8)
 
         # Test environment variable with spaces in value
         env_list9 = ["MESSAGE=Hello World", "PATH=/usr/local/bin:/usr/bin"]
         converted_dict9 = {"MESSAGE": "Hello World", "PATH": "/usr/local/bin:/usr/bin"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list9), converted_dict9
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list9), converted_dict9)
 
         # Test environment variable with special characters
         env_list10 = ["SPECIAL=!@#$%^&*()_+-=[]{}|;':\",./<>?"]
         converted_dict10 = {"SPECIAL": "!@#$%^&*()_+-=[]{}|;':\",./<>?"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list10), converted_dict10
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list10), converted_dict10)
 
         # Test environment variable with numeric values
         env_list11 = ["PORT=8080", "TIMEOUT=30"]
         converted_dict11 = {"PORT": "8080", "TIMEOUT": "30"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list11), converted_dict11
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list11), converted_dict11)
 
         # Test environment variable with boolean-like values
         env_list12 = ["DEBUG=true", "VERBOSE=false", "ENABLED=1", "DISABLED=0"]
@@ -400,16 +383,12 @@ def test_create_convert_env_list_to_dict(self, mock):
             "ENABLED": "1",
             "DISABLED": "0",
         }
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list12), converted_dict12
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list12), converted_dict12)
 
         # Test environment variable with whitespace in key (should preserve)
         env_list13 = [" SPACED_KEY =value", "KEY= spaced_value "]
         converted_dict13 = {" SPACED_KEY ": "value", "KEY": " spaced_value "}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list13), converted_dict13
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list13), converted_dict13)
 
         # Test missing equals sign
         env_list14 = ["FOO=foo", "INVALID"]
@@ -440,38 +419,28 @@ def test_create_convert_env_list_to_dict(self, mock):
         # Test duplicate keys (last one should win)
         env_list21 = ["KEY=first", "KEY=second", "OTHER=value"]
         converted_dict21 = {"KEY": "second", "OTHER": "value"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list21), converted_dict21
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list21), converted_dict21)
 
         # Test very long environment variable
         long_value = "x" * 1000
         env_list22 = [f"LONG_VAR={long_value}"]
         converted_dict22 = {"LONG_VAR": long_value}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list22), converted_dict22
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list22), converted_dict22)
 
         # Test environment variable with newlines and tabs
         env_list23 = ["MULTILINE=line1\nline2\ttabbed"]
         converted_dict23 = {"MULTILINE": "line1\nline2\ttabbed"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list23), converted_dict23
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list23), converted_dict23)
 
         # Test environment variable with unicode characters
         env_list24 = ["UNICODE=こんにちは", "EMOJI=🚀🌟"]
         converted_dict24 = {"UNICODE": "こんにちは", "EMOJI": "🚀🌟"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list24), converted_dict24
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list24), converted_dict24)
 
         # Test case sensitivity
         env_list25 = ["path=/usr/bin", "PATH=/usr/local/bin"]
         converted_dict25 = {"path": "/usr/bin", "PATH": "/usr/local/bin"}
-        self.assertEqual(
-            CreateMixin._convert_env_list_to_dict(env_list25), converted_dict25
-        )
+        self.assertEqual(CreateMixin._convert_env_list_to_dict(env_list25), converted_dict25)
 
     @requests_mock.Mocker()
     def test_run_detached(self, mock):
@@ -494,9 +463,7 @@ def test_run_detached(self, mock):
             json=FIRST_CONTAINER,
         )
 
-        with patch.multiple(
-            Container, logs=DEFAULT, wait=DEFAULT, autospec=True
-        ) as mock_container:
+        with patch.multiple(Container, logs=DEFAULT, wait=DEFAULT, autospec=True) as mock_container:
             mock_container["logs"].return_value = []
             mock_container["wait"].return_value = {"StatusCode": 0}
 
@@ -529,27 +496,21 @@ def test_run(self, mock):
             b"This is a unittest - line 2",
         )
 
-        with patch.multiple(
-            Container, logs=DEFAULT, wait=DEFAULT, autospec=True
-        ) as mock_container:
+        with patch.multiple(Container, logs=DEFAULT, wait=DEFAULT, autospec=True) as mock_container:
             mock_container["wait"].return_value = 0
 
             with self.subTest("Results not streamed"):
                 mock_container["logs"].return_value = iter(mock_logs)
 
                 actual = self.client.containers.run("fedora", "/usr/bin/ls")
                 self.assertIsInstance(actual, bytes)
-                self.assertEqual(
-                    actual, b"This is a unittest - line 1This is a unittest - line 2"
-                )
+                self.assertEqual(actual, b"This is a unittest - line 1This is a unittest - line 2")
 
             # iter() cannot be reset so subtests used to create new instance
             with self.subTest("Stream results"):
                 mock_container["logs"].return_value = iter(mock_logs)
 
-                actual = self.client.containers.run(
-                    "fedora", "/usr/bin/ls", stream=True
-                )
+                actual = self.client.containers.run("fedora", "/usr/bin/ls", stream=True)
                 self.assertNotIsInstance(actual, bytes)
                 self.assertIsInstance(actual, Iterator)
                 self.assertEqual(next(actual), b"This is a unittest - line 1")