Use f-strings throughout.

Author: tillahoffmann

compose/testcontainers/compose/__init__.py

@@ -36,13 +36,13 @@ class DockerCompose:
                 host = compose.get_service_host("hub", 4444)
                 port = compose.get_service_port("hub", 4444)
                 driver = webdriver.Remote(
-                    command_executor=("http://{}:{}/wd/hub".format(host,port)),
+                    command_executor=(f"http://{host}:{port}/wd/hub"),
                     desired_capabilities=CHROME,
                 )
                 driver.get("http://automation-remarks.com")
                 stdout, stderr = compose.get_logs()
                 if stderr:
-                    print("Errors\\n:{}".format(stderr))
+                    print(f"Errors\\n:{stderr}")
 
         .. code-block:: yaml
 

core/testcontainers/core/generic.py

@@ -44,11 +44,9 @@ def _create_connection_url(self, dialect: str, username: str, password: str,
             raise ContainerStartException("container has not been started")
         host = host or self.get_container_host_ip()
         port = self.get_exposed_port(port)
-        url = "{dialect}://{username}:{password}@{host}:{port}".format(
-            dialect=dialect, username=username, password=password, host=host, port=port
-        )
+        url = f"{dialect}://{username}:{password}@{host}:{port}"
         if db_name:
-            url += '/' + db_name
+            url = f"{url}/{db_name}"
         return url
 
     def start(self) -> 'DbContainer':

elasticsearch/testcontainers/elasticsearch/__init__.py

@@ -93,7 +93,7 @@ def _connect(self) -> None:
     def get_url(self) -> str:
         host = self.get_container_host_ip()
         port = self.get_exposed_port(self.port_to_expose)
-        return 'http://{}:{}'.format(host, port)
+        return f'http://{host}:{port}'
 
     def start(self) -> "ElasticSearchContainer":
         super().start()

google/testcontainers/google/pubsub.py

@@ -42,14 +42,12 @@ def __init__(self, image: str = "google/cloud-sdk:emulators", project: str = "te
         self.project = project
         self.port = port
         self.with_exposed_ports(self.port)
-        self.with_command("gcloud beta emulators pubsub start --project="
-                          "{project} --host-port=0.0.0.0:{port}".format(
-                              project=self.project, port=self.port,
-                          ))
+        self.with_command(
+            f"gcloud beta emulators pubsub start --project={project} --host-port=0.0.0.0:{port}"
+        )
 
     def get_pubsub_emulator_host(self) -> str:
-        return "{host}:{port}".format(host=self.get_container_host_ip(),
-                                      port=self.get_exposed_port(self.port))
+        return f"{self.get_container_host_ip()}:{self.get_exposed_port(self.port)}"
 
     def _get_channel(self, channel: Optional[grpc.Channel] = None) -> grpc.Channel:
         if channel is None:

kafka/testcontainers/kafka/__init__.py

@@ -30,7 +30,7 @@ def __init__(self, image: str = "confluentinc/cp-kafka:5.4.3", port_to_expose: i
         super(KafkaContainer, self).__init__(image, **kwargs)
         self.port_to_expose = port_to_expose
         self.with_exposed_ports(self.port_to_expose)
-        listeners = 'PLAINTEXT://0.0.0.0:{},BROKER://0.0.0.0:9092'.format(port_to_expose)
+        listeners = f'PLAINTEXT://0.0.0.0:{port_to_expose},BROKER://0.0.0.0:9092'
         self.with_env('KAFKA_LISTENERS', listeners)
         self.with_env('KAFKA_LISTENER_SECURITY_PROTOCOL_MAP',
                       'BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT')
@@ -45,7 +45,7 @@ def __init__(self, image: str = "confluentinc/cp-kafka:5.4.3", port_to_expose: i
     def get_bootstrap_server(self) -> str:
         host = self.get_container_host_ip()
         port = self.get_exposed_port(self.port_to_expose)
-        return '{}:{}'.format(host, port)
+        return f'{host}:{port}'
 
     @wait_container_is_ready(UnrecognizedBrokerVersion, NoBrokersAvailable, KafkaError, ValueError)
     def _connect(self) -> None:
@@ -57,21 +57,21 @@ def _connect(self) -> None:
     def tc_start(self) -> None:
         host = self.get_container_host_ip()
         port = self.get_exposed_port(self.port_to_expose)
-        listeners = 'PLAINTEXT://{}:{},BROKER://$(hostname -i):9092'.format(host, port)
+        listeners = f'PLAINTEXT://{host}:{port},BROKER://$(hostname -i):9092'
         data = (
             dedent(
-                """
+                f"""
                 #!/bin/bash
                 echo 'clientPort=2181' > zookeeper.properties
                 echo 'dataDir=/var/lib/zookeeper/data' >> zookeeper.properties
                 echo 'dataLogDir=/var/lib/zookeeper/log' >> zookeeper.properties
                 zookeeper-server-start zookeeper.properties &
                 export KAFKA_ZOOKEEPER_CONNECT='localhost:2181'
-                export KAFKA_ADVERTISED_LISTENERS={}
+                export KAFKA_ADVERTISED_LISTENERS={listeners}
                 . /etc/confluent/docker/bash-config
                 /etc/confluent/docker/configure
                 /etc/confluent/docker/launch
-                """.format(listeners)
+                """
             )
             .strip()
             .encode('utf-8')
@@ -80,7 +80,7 @@ def tc_start(self) -> None:
 
     def start(self) -> "KafkaContainer":
         script = KafkaContainer.TC_START_SCRIPT
-        command = 'sh -c "while [ ! -f {} ]; do sleep 0.1; done; sh {}"'.format(script, script)
+        command = f'sh -c "while [ ! -f {script} ]; do sleep 0.1; done; sh {script}"'
         self.with_command(command)
         super().start()
         self.tc_start()

keycloak/testcontainers/keycloak/__init__.py

@@ -48,12 +48,12 @@ def _configure(self) -> None:
     def get_url(self) -> str:
         host = self.get_container_host_ip()
         port = self.get_exposed_port(self.port_to_expose)
-        return "http://{}:{}".format(host, port)
+        return f"http://{host}:{port}"
 
     @wait_container_is_ready(requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout)
     def _connect(self) -> None:
         url = self.get_url()
-        response = requests.get("{}/auth".format(url), timeout=1)
+        response = requests.get(f"{url}/auth", timeout=1)
         response.raise_for_status()
 
     def start(self) -> "KeycloakContainer":
@@ -64,7 +64,7 @@ def start(self) -> "KeycloakContainer":
 
     def get_client(self, **kwargs) -> KeycloakAdmin:
         default_kwargs = dict(
-            server_url="{}/auth/".format(self.get_url()),
+            server_url=f"{self.get_url()}/auth/",
             username=self.username,
             password=self.password,
             realm_name="master",

localstack/testcontainers/localstack/__init__.py

@@ -62,7 +62,7 @@ def get_url(self) -> str:
         """
         host = self.get_container_host_ip()
         port = self.get_exposed_port(self.edge_port)
-        return 'http://{}:{}'.format(host, port)
+        return f'http://{host}:{port}'
 
     def start(self, timeout: float = 60) -> "LocalStackContainer":
         super().start()

neo4j/testcontainers/neo4j/__init__.py

@@ -50,11 +50,7 @@ def _configure(self) -> None:
         self.with_env("NEO4J_AUTH", f"neo4j/{self.password}")
 
     def get_connection_url(self) -> str:
-        return "{dialect}://{host}:{port}".format(
-            dialect="bolt",
-            host=self.get_container_host_ip(),
-            port=self.get_exposed_port(self.bolt_port),
-        )
+        return f"bolt://{self.get_container_host_ip()}:{self.get_exposed_port(self.bolt_port)}"
 
     @wait_container_is_ready()
     def _connect(self) -> None:

postgres/testcontainers/postgres/__init__.py

@@ -60,7 +60,7 @@ def _configure(self) -> None:
 
     def get_connection_url(self, host=None) -> str:
         return super()._create_connection_url(
-            dialect="postgresql+{}".format(self.driver), username=self.username,
+            dialect=f"postgresql+{self.driver}", username=self.username,
             password=self.password, db_name=self.dbname, host=host,
             port=self.port_to_expose,
         )