From 942e8d78bc1d1263c6bc49b9fcb3db5bc325bd3e Mon Sep 17 00:00:00 2001
From: brettlangdon <brett.langdon@datadoghq.com>
Date: Mon, 9 Mar 2020 13:12:16 -0400
Subject: [PATCH] Use .format() instead of f-strings Fixes #1

---
 importhook/finder.py   | 13 +++++++++++--
 importhook/loader.py   | 27 +++++++++++++++++++++++----
 importhook/registry.py | 18 +++++++++++++++---
 3 files changed, 49 insertions(+), 9 deletions(-)

diff --git a/importhook/finder.py b/importhook/finder.py
index c016e76..d1fcc3b 100644
--- a/importhook/finder.py
+++ b/importhook/finder.py
@@ -27,7 +27,12 @@ def hook_finder(finder):
     def wrap_find_spec(find_spec):
         @functools.wraps(find_spec)
         def wrapper(fullname, path, target=None):
-            logger.debug(f'{finder_name}.find_spec(fullname={fullname}, path={path}, target={target})')
+            logger.debug('{}.find_spec(fullname={}, path={}, target={})'.format(
+                finder_name,
+                fullname,
+                path,
+                target,
+            ))
             spec = find_spec(fullname, path, target=target)
             if spec is not None:
                 spec.loader = HookLoader(spec.loader)
@@ -37,7 +42,11 @@ def hook_finder(finder):
     def wrap_find_loader(find_loader):
         @functools.wraps(find_loader)
         def wrapper(fullname, path):
-            logger.debug(f'{finder_name}.find_loader(fullname={fullname}, path={path})')
+            logger.debug('{}.find_loader(fullname={}, path={})'.format(
+                finder_name,
+                fullname,
+                path,
+            ))
             loader = find_loader(fullname, path)
             return HookLoader(loader)
         return wrapper
diff --git a/importhook/loader.py b/importhook/loader.py
index f2d1590..9661c03 100644
--- a/importhook/loader.py
+++ b/importhook/loader.py
@@ -49,14 +49,23 @@ class HookLoader(Loader):
         raise AttributeError
 
     def create_module(self, *args, **kwargs):
-        logger.debug(f'{self.__class__.__name__}.create_module(*args={args}, **kwargs={kwargs})')
+        logger.debug('{}.create_module(*args={}, **kwargs={})'.format(
+            self.__class__.__name__,
+            args,
+            kwargs,
+        ))
         if not hasattr(self.loader, 'create_module'):
             return None
 
         return self.loader.create_module(*args, **kwargs)
 
     def find_module(self, name, *args, **kwargs):
-        logger.debug(f'{self.__class__.__name__}.find_module(name={name}, *args={args}, **kwargs={kwargs})')
+        logger.debug('{}.find_module(name={}, *args={}, **kwargs={})'.format(
+            self.__class__.__name__,
+            name,
+            args,
+            kwargs,
+        ))
         if not hasattr(self.loader, 'find_module'):
             return None
 
@@ -67,7 +76,12 @@ class HookLoader(Loader):
         return module
 
     def load_module(self, name, *args, **kwargs):
-        logger.debug(f'{self.__class__.__name__}.load_module(name={name}, *args={args}, **kwargs={kwargs})')
+        logger.debug('{}.load_module(name={}, *args={}, **kwargs={})'.format(
+            self.__class__.__name__,
+            name,
+            args,
+            kwargs,
+        ))
         if not hasattr(self.loader, 'load_module'):
             return None
 
@@ -78,7 +92,12 @@ class HookLoader(Loader):
         return module
 
     def exec_module(self, module, *args, **kwargs):
-        logger.debug(f'{self.__class__.__name__}.exec_module(module={module}, *args={args}, **kwargs={kwargs})')
+        logger.debug('{}.exec_module(module={}, *args={}, **kwargs={})'.format(
+            self.__class__.__name__,
+            module,
+            args,
+            kwargs,
+        ))
         if not hasattr(self.loader, 'exec_module'):
             return None
 
diff --git a/importhook/registry.py b/importhook/registry.py
index f880e70..02ce12d 100644
--- a/importhook/registry.py
+++ b/importhook/registry.py
@@ -7,7 +7,11 @@ class Hooks(set):
     """Custom set that is used to maintain and call a list of hooks"""
     def __call__(self, module):
         for hook in self:
-            logger.debug(f'Calling hook {hook.__module__}:{hook.__name__}({module})')
+            logger.debug('Calling hook {}:{}({})'.format(
+                hook.__module__,
+                hook.__name__,
+                module,
+            ))
             mod = hook(module)
             # If they modified the module, then use that instead
             if mod is not None:
@@ -22,7 +26,11 @@ class HookRegistry(dict):
 
     def __setitem__(self, key, hook):
         module_name = key or 'ANY_MODULE'
-        logger.debug(f'Registering hook {hook.__module__}:{hook.__name__} for {module_name}')
+        logger.debug('Registering hook {}:{} for {}'.format(
+            hook.__module__,
+            hook.__name__,
+            module_name,
+        ))
 
         # Ensure we have a key for this module and it's value is a `Hooks` set
         if key not in self:
@@ -34,7 +42,11 @@ class HookRegistry(dict):
         # Call hook for a module which has already been loaded
         if key is not None and key in sys.modules:
             module = sys.modules[key]
-            logger.debug(f'Calling hook {hook.__module__}:{hook.__name__}({module})')
+            logger.debug('Calling hook {}:{}({})'.format(
+                hook.__module__,
+                hook.__name__,
+                module,
+            ))
 
             module = hook(sys.modules[key])
             if module is not None: