f-strings everywhere! fffff

Author: alexcjohnson

dash/_callback.py

@@ -215,7 +215,7 @@ def register_clientside_callback(
     inline_scripts,
     clientside_function,
     *args,
-    **kwargs
+    **kwargs,
 ):
     output, inputs, state, prevent_initial_call = handle_callback_args(args, kwargs)
     insert_callback(
@@ -238,8 +238,8 @@ def register_clientside_callback(
         if isinstance(output, (list, tuple)):
             out0 = output[0]
 
-        namespace = "_dashprivate_{}".format(out0.component_id)
-        function_name = "{}".format(out0.component_property)
+        namespace = f"_dashprivate_{out0.component_id}"
+        function_name = out0.component_property
 
         inline_scripts.append(
             _inline_clientside_template.format(

dash/_callback_context.py

@@ -11,9 +11,7 @@ def has_context(func):
     def assert_context(*args, **kwargs):
         if not flask.has_request_context():
             raise exceptions.MissingCallbackContextException(
-                "dash.callback_context.{} is only available from a callback!".format(
-                    getattr(func, "__name__")
-                )
+                f"dash.callback_context.{getattr(func, '__name__')} is only available from a callback!"
             )
         return func(*args, **kwargs)
 
@@ -119,7 +117,7 @@ def record_timing(name, duration=None, description=None):
         timing_information = getattr(flask.g, "timing_information", {})
 
         if name in timing_information:
-            raise KeyError('Duplicate resource name "{}" found.'.format(name))
+            raise KeyError(f'Duplicate resource name "{name}" found.')
 
         timing_information[name] = {"dur": round(duration * 1000), "desc": description}
 

dash/_configs.py

@@ -47,7 +47,7 @@ def get_combined_config(name, val, default=None):
     if val is not None:
         return val
 
-    env = load_dash_env_vars().get("DASH_{}".format(name.upper()))
+    env = load_dash_env_vars().get(f"DASH_{name.upper()}")
     if env is None:
         return default
 

dash/_get_paths.py

@@ -70,12 +70,10 @@ def app_get_relative_path(requests_pathname, path):
         return requests_pathname
     if not path.startswith("/"):
         raise exceptions.UnsupportedRelativePath(
-            """
+            f"""
             Paths that aren't prefixed with a leading / are not supported.
-            You supplied: {}
-            """.format(
-                path
-            )
+            You supplied: {path}
+            """
         )
     return "/".join([requests_pathname.rstrip("/"), path.lstrip("/")])
 
@@ -137,12 +135,10 @@ def app_strip_relative_path(requests_pathname, path):
         requests_pathname != "/" and not path.startswith(requests_pathname.rstrip("/"))
     ) or (requests_pathname == "/" and not path.startswith("/")):
         raise exceptions.UnsupportedRelativePath(
-            """
+            f"""
             Paths that aren't prefixed with requests_pathname_prefix are not supported.
-            You supplied: {} and requests_pathname_prefix was {}
-            """.format(
-                path, requests_pathname
-            )
+            You supplied: {path} and requests_pathname_prefix was {requests_pathname}
+            """
         )
     if requests_pathname != "/" and path.startswith(requests_pathname.rstrip("/")):
         path = path.replace(

dash/_grouping.py

@@ -94,20 +94,16 @@ def _perform_make_grouping_like(value, next_values):
     if not isinstance(flat_values, list):
         raise ValueError(
             "The flat_values argument must be a list. "
-            "Received value of type {typ}".format(typ=type(flat_values))
+            f"Received value of type {type(flat_values)}"
         )
 
     expected_length = len(flatten_grouping(schema))
     if len(flat_values) != expected_length:
         raise ValueError(
-            "The specified grouping pattern requires {n} elements but received {m}\n"
-            "    Grouping patter: {pattern}\n"
-            "    Values: {flat_values}".format(
-                n=expected_length,
-                m=len(flat_values),
-                pattern=repr(schema),
-                flat_values=flat_values,
-            )
+            f"The specified grouping pattern requires {expected_length} "
+            f"elements but received {len(flat_values)}\n"
+            f"    Grouping pattern: {repr(schema)}\n"
+            f"    Values: {flat_values}"
         )
 
     return _perform_make_grouping_like(schema, list(flat_values))

dash/_utils.py

@@ -31,17 +31,15 @@ def interpolate_str(template, **data):
 
 
 def format_tag(tag_name, attributes, inner="", closed=False, opened=False):
-    tag = "<{tag} {attributes}"
+    attributes = " ".join([f'{k}="{v}"' for k, v in attributes.items()])
+    tag = f"<{tag_name} {attributes}"
     if closed:
         tag += "/>"
     elif opened:
         tag += ">"
     else:
-        tag += ">" + inner + "</{tag}>"
-    return tag.format(
-        tag=tag_name,
-        attributes=" ".join(['{}="{}"'.format(k, v) for k, v in attributes.items()]),
-    )
+        tag += ">" + inner + f"</{tag_name}>"
+    return tag
 
 
 def generate_hash():
@@ -124,23 +122,16 @@ def first(self, *names):
 
 
 def create_callback_id(output):
+    # A single dot within a dict id key or value is OK
+    # but in case of multiple dots together escape each dot
+    # with `\` so we don't mistake it for multi-outputs
+    def _concat(x):
+        return x.component_id_str().replace(".", "\\.") + "." + x.component_property
+
     if isinstance(output, (list, tuple)):
-        return "..{}..".format(
-            "...".join(
-                "{}.{}".format(
-                    # A single dot within a dict id key or value is OK
-                    # but in case of multiple dots together escape each dot
-                    # with `\` so we don't mistake it for multi-outputs
-                    x.component_id_str().replace(".", "\\."),
-                    x.component_property,
-                )
-                for x in output
-            )
-        )
-
-    return "{}.{}".format(
-        output.component_id_str().replace(".", "\\."), output.component_property
-    )
+        return ".." + "...".join(_concat(x) for x in output) + ".."
+
+    return _concat(output)
 
 
 # inverse of create_callback_id - should only be relevant if an old renderer is
@@ -166,7 +157,7 @@ def inputs_to_dict(inputs_list):
         inputsi = i if isinstance(i, list) else [i]
         for ii in inputsi:
             id_str = stringify_id(ii["id"])
-            inputs["{}.{}".format(id_str, ii["property"])] = ii.get("value")
+            inputs[f'{id_str}.{ii["property"]}'] = ii.get("value")
     return inputs