Now using f-strings

django_pgschemas/management/commands/cloneschema.py

@@ -36,10 +36,10 @@ def _ask(self, question):
         answer = None
         while answer is None:
             try:
-                raw_answer = input("{} [Y/n] ".format(question.strip())).strip() or "y"
+                raw_answer = input(f"{question.strip()} [Y/n] ").strip() or "y"
                 answer = strtobool(raw_answer)
             except ValueError:
-                self.stderr.write("{} is not a valid answer.".format(raw_answer))
+                self.stderr.write(f"{raw_answer} is not a valid answer.")
                 pass
         return answer
 
@@ -64,12 +64,10 @@ def _get_constructed_instance(self, model_class, data):
         fields = [field for field in model_class._meta.fields if self._check_required_field(field, data.keys())]
         instance = model_class(**data)
         if fields:
-            self.stdout.write(
-                self.style.WARNING("We need some data for model '{}':".format(model_class._meta.model_name))
-            )
+            self.stdout.write(self.style.WARNING(f"We need some data for model '{model_class._meta.model_name}':"))
             for field in fields:
                 while field.name not in data:
-                    raw_value = input("Value for field '{}': ".format(field.name))
+                    raw_value = input(f"Value for field '{field.name}': ")
                     try:
                         data[field.name] = field.clean(raw_value, None)
                         instance = model_class(**data)

django_pgschemas/postgresql_backend/base.py

@@ -78,15 +78,15 @@ def _cursor(self, name=None):
             if not self.schema:
                 raise ImproperlyConfigured("Database schema not set. Did you forget to call set_schema()?")
             check_schema_name(self.schema.schema_name)
-            search_paths = []
+            search_path = []
 
             if self.schema.schema_name == "public":
-                search_paths = ["public"]
+                search_path = ["public"]
             elif self.include_public_schema:
-                search_paths = [self.schema.schema_name, "public"]
+                search_path = [self.schema.schema_name, "public"]
             else:
-                search_paths = [self.schema.schema_name]
-            search_paths.extend(EXTRA_SEARCH_PATHS)
+                search_path = [self.schema.schema_name]
+            search_path.extend(EXTRA_SEARCH_PATHS)
 
             if name:
                 # Named cursor can only be used once
@@ -100,7 +100,8 @@ def _cursor(self, name=None):
             # if the next instruction is not a rollback it will just fail also, so
             # we do not have to worry that it's not the good one
             try:
-                cursor_for_search_path.execute("SET search_path = {0}".format(",".join(search_paths)))
+                search_path_string = ",".join(search_path)
+                cursor_for_search_path.execute(f"SET search_path = {search_path_string}")
             except (DatabaseError, psycopg2.InternalError):
                 self.search_path_set = False
             else:

django_pgschemas/routers.py

@@ -12,7 +12,7 @@ class SyncRouter:
 
     def app_in_list(self, app_label, app_list):
         app_config = apps.get_app_config(app_label)
-        app_config_full_name = "{}.{}".format(app_config.__module__, app_config.__class__.__name__)
+        app_config_full_name = f"{app_config.__module__}.{app_config.__class__.__name__}"
         return (app_config.name in app_list) or (app_config_full_name in app_list)
 
     def allow_migrate(self, db, app_label, model_name=None, **hints):

django_pgschemas/test/cases.py

@@ -38,10 +38,10 @@ class StaticTenantTestCase(BaseTenantTestCaseMixin, TestCase):
     def setUpClass(cls):
         assert (
             cls.schema_name in settings.TENANTS
-        ), "{class_name}.schema_name must be defined to a valid static tenant".format(class_name=cls.__name__)
+        ), f"{cls.__name__}.schema_name must be defined to a valid static tenant"
         assert (
             cls.schema_name not in ["public", "default"] and cls.schema_name != get_clone_reference()
-        ), "{class_name}.schema_name must be defined to a valid static tenant".format(class_name=cls.__name__)
+        ), f"{cls.__name__}.schema_name must be defined to a valid static tenant"
         super(TestCase, cls).setUpClass()
         cls.sync_public()
         cls.add_allowed_test_domain()

django_pgschemas/urlresolvers.py

@@ -19,7 +19,7 @@ def tenant_prefix(self):
             domain = DomainModel.objects.exclude(folder="").get(
                 tenant__schema_name=connection.schema.schema_name, domain=connection.schema.domain_url
             )
-            return "{}/".format(domain.folder)
+            return f"{domain.folder}/"
         except DomainModel.DoesNotExist:
             return "/"
 
@@ -38,7 +38,7 @@ def check(self):
         return []
 
     def describe(self):
-        return "'{}'".format(self)
+        return f"'{self}'"
 
     def __str__(self):
         return self.tenant_prefix
@@ -62,7 +62,7 @@ def get_dynamic_tenant_prefixed_urlconf(urlconf, dynamic_path):
 
     class LazyURLConfModule(ModuleType):
         def __getattr__(self, attr):
-            imported = import_string("{}.{}".format(urlconf, attr))
+            imported = import_string(f"{urlconf}.{attr}")
             if attr == "urlpatterns":
                 return tenant_patterns(*imported)
             return imported

dpgs_sandbox/tests/test_executors.py

@@ -16,9 +16,9 @@ class ExecutorsTestCase(TransactionTestCase):
     @classmethod
     def setUpClass(cls):
         for i in range(10):
-            tenant = TenantModel(schema_name="tenant{}".format(i + 1))
+            tenant = TenantModel(schema_name=f"tenant{i + 1}")
             tenant.save(verbosity=0)
-            DomainModel.objects.create(tenant=tenant, domain="tenant{}.test.com".format(i + 1), is_primary=True)
+            DomainModel.objects.create(tenant=tenant, domain=f"tenant{i + 1}.test.com", is_primary=True)
 
     @classmethod
     def tearDownClass(cls):

dpgs_sandbox/tests/test_static_tenant_test_case.py

@@ -18,7 +18,7 @@ def assert_expected_error(self, klass):
             klass.setUpClass()
         self.assertEqual(
             str(ctx.exception),
-            "{class_name}.schema_name must be defined to a valid static tenant".format(class_name=klass.__name__),
+            f"{klass.__name__}.schema_name must be defined to a valid static tenant",
         )
 
     def test_set_up_with_empty(self):

dpgs_sandbox/tests/test_urlresolvers.py

@@ -43,10 +43,10 @@ def fake_get_response(request):
         cls.paths = {"tenant-home": "/", "profile": "/profile/", "advanced-profile": "/profile/advanced/"}
 
         for i in range(1, 4):
-            schema_name = "tenant{}".format(i)
+            schema_name = f"tenant{i}"
             tenant = TenantModel(schema_name=schema_name)
             tenant.save(verbosity=0)
-            DomainModel.objects.create(tenant=tenant, domain="{}.test.com".format(schema_name))
+            DomainModel.objects.create(tenant=tenant, domain=f"{schema_name}.test.com")
             DomainModel.objects.create(tenant=tenant, domain="everyone.test.com", folder=schema_name)  # primary
         connection.set_schema_to_public()
         super().setUpClass()
@@ -65,26 +65,23 @@ def test_tenant_prefix(self):
             with tenant:
                 self.assertEqual(tpp.tenant_prefix, tenant.get_primary_domain().folder + "/")
             # Try with subdomain
-            tenant.domain_url = "{}.test.com".format(tenant.schema_name)  # This should be set by middleware
+            tenant.domain_url = f"{tenant.schema_name}.test.com"  # This should be set by middleware
             with tenant:
                 self.assertEqual(tpp.tenant_prefix, "/")
         with SchemaDescriptor.create(schema_name="tenant1", domain_url="unexisting-domain.test.com"):
             self.assertEqual(tpp.tenant_prefix, "/")
 
     def test_unprefixed_reverse(self):
         for tenant in TenantModel.objects.all():
-            domain = "{}.test.com".format(tenant.schema_name)
+            domain = f"{tenant.schema_name}.test.com"
             for name, path in self.paths.items():
                 self.assertEqual(self.reverser(name, domain), path)
 
     def test_prefixed_reverse(self):
         for tenant in TenantModel.objects.all():
             domain = "everyone.test.com"
             for name, path in self.paths.items():
-                self.assertEqual(
-                    self.reverser(name, domain, "/{}/".format(tenant.schema_name)),
-                    "/{}{}".format(tenant.schema_name, path),
-                )
+                self.assertEqual(self.reverser(name, domain, f"/{tenant.schema_name}/"), f"/{tenant.schema_name}{path}")
 
 
 class URLConfFactoryTestCase(TestCase):
@@ -97,7 +94,7 @@ def setUpClass(cls):
         schema_name = "tenant1"
         tenant = TenantModel(schema_name=schema_name)
         tenant.save(verbosity=0)
-        DomainModel.objects.create(tenant=tenant, domain="{}.test.com".format(schema_name))
+        DomainModel.objects.create(tenant=tenant, domain=f"{schema_name}.test.com")
         DomainModel.objects.create(tenant=tenant, domain="everyone.test.com", folder=schema_name)  # primary
         connection.set_schema_to_public()
         super().setUpClass()