SNOW-633094: Switch all source code to use f-strings and with statements (#331)

Author: sfc-gh-aling

.github/workflows/build_test.yml

@@ -124,8 +124,8 @@ jobs:
           dst_dir = Path(".") / ".tox"
           dst_dir.mkdir()
           for src_file in src_dir.glob("*/.coverage"):
-              dst_file = dst_dir / ".coverage.{}".format(src_file.parent.name[9:])
-              print("{} copy to {}".format(src_file, dst_file))
+              dst_file = dst_dir / f".coverage.{src_file.parent.name[9:]}"
+              print(f"{src_file} copy to {dst_file}")
               shutil.copy(str(src_file), str(dst_file))'
       - name: Combine coverages
         run: python -m tox -e coverage

.github/workflows/snyk-issue.yml

@@ -1,4 +1,4 @@
-name: Snyk Issue 
+name: Snyk Issue
 
 on:
   schedule:
@@ -26,4 +26,3 @@ jobs:
         jira_token: ${{ secrets.jira_token_public_repo }}
       env:
         gh_token: ${{ secrets.github_token }}
-

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
     hooks:
         - id: isort
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v2.34.0
+    rev: v2.37.3
     hooks:
     -   id: pyupgrade
         args: [--py37-plus]
@@ -25,7 +25,7 @@ repos:
               - --safe
           language_version: python3
 -   repo: https://github.com/Lucas-C/pre-commit-hooks.git
-    rev: v1.2.0
+    rev: v1.3.0
     hooks:
     -   id: insert-license
         name: insert-py-license

src/snowflake/sqlalchemy/base.py

@@ -163,6 +163,11 @@ def visit_merge_into(self, merge_into, **kw):
         )
 
     def visit_merge_into_clause(self, merge_into_clause, **kw):
+        case_predicate = (
+            f" AND {str(merge_into_clause.predicate._compiler_dispatch(self, **kw))}"
+            if merge_into_clause.predicate is not None
+            else ""
+        )
         if merge_into_clause.command == "INSERT":
             sets, sets_tos = zip(*merge_into_clause.set.items())
             sets, sets_tos = list(sets), list(sets_tos)
@@ -171,9 +176,7 @@ def visit_merge_into_clause(self, merge_into_clause, **kw):
                     *sorted(merge_into_clause.set.items(), key=operator.itemgetter(0))
                 )
             return "WHEN NOT MATCHED{} THEN {} ({}) VALUES ({})".format(
-                " AND %s" % merge_into_clause.predicate._compiler_dispatch(self, **kw)
-                if merge_into_clause.predicate is not None
-                else "",
+                case_predicate,
                 merge_into_clause.command,
                 ", ".join(sets),
                 ", ".join(map(lambda e: e._compiler_dispatch(self, **kw), sets_tos)),
@@ -193,9 +196,7 @@ def visit_merge_into_clause(self, merge_into_clause, **kw):
                 else ""
             )
             return "WHEN MATCHED{} THEN {}{}".format(
-                " AND %s" % merge_into_clause.predicate._compiler_dispatch(self, **kw)
-                if merge_into_clause.predicate is not None
-                else "",
+                case_predicate,
                 merge_into_clause.command,
                 " SET %s" % sets if merge_into_clause.set else "",
             )
@@ -296,7 +297,7 @@ def visit_aws_bucket(self, aws_bucket, **kw):
             )
         )
         uri = "'s3://{}{}'".format(
-            aws_bucket.bucket, "/" + aws_bucket.path if aws_bucket.path else ""
+            aws_bucket.bucket, f"/{aws_bucket.path}" if aws_bucket.path else ""
         )
         return (
             uri,
@@ -316,14 +317,14 @@ def visit_azure_container(self, azure_container, **kw):
             encryption_list.sort(key=operator.itemgetter(0))
         encryption = "ENCRYPTION=({})".format(
             " ".join(
-                ("{}='{}'" if isinstance(v, string_types) else "{}={}").format(n, v)
+                f"{n}='{v}'" if isinstance(v, string_types) else f"{n}={v}"
                 for n, v in encryption_list
             )
         )
         uri = "'azure://{}.blob.core.windows.net/{}{}'".format(
             azure_container.account,
             azure_container.container,
-            "/" + azure_container.path if azure_container.path else "",
+            f"/{azure_container.path}" if azure_container.path else "",
         )
         return (
             uri,
@@ -333,15 +334,10 @@ def visit_azure_container(self, azure_container, **kw):
 
     def visit_external_stage(self, external_stage, **kw):
         if external_stage.file_format is None:
-            return "@{}{}{}".format(
-                external_stage.namespace, external_stage.name, external_stage.path
+            return (
+                f"@{external_stage.namespace}{external_stage.name}{external_stage.path}"
             )
-        return "@{}{}{} (file_format => {})".format(
-            external_stage.namespace,
-            external_stage.name,
-            external_stage.path,
-            external_stage.file_format,
-        )
+        return f"@{external_stage.namespace}{external_stage.name}{external_stage.path} (file_format => {external_stage.file_format})"
 
     def delete_extra_from_clause(
         self, delete_stmt, from_table, extra_froms, from_hints, **kw
@@ -378,18 +374,9 @@ def visit_regexp_replace_op_binary(self, binary, operator, **kw):
         string, pattern, flags = self._get_regexp_args(binary, kw)
         replacement = self.process(binary.modifiers["replacement"], **kw)
         if flags is None:
-            return "REGEXP_REPLACE({}, {}, {})".format(
-                string,
-                pattern,
-                replacement,
-            )
+            return f"REGEXP_REPLACE({string}, {pattern}, {replacement})"
         else:
-            return "REGEXP_REPLACE({}, {}, {}, {})".format(
-                string,
-                pattern,
-                replacement,
-                flags,
-            )
+            return f"REGEXP_REPLACE({string}, {pattern}, {replacement}, {flags})"
 
     def visit_not_regexp_match_op_binary(self, binary, operator, **kw):
         return f"NOT {self.visit_regexp_match_op_binary(binary, operator, **kw)}"

src/snowflake/sqlalchemy/custom_commands.py

@@ -40,10 +40,13 @@ def __init__(self, command):
             self.command = command
 
         def __repr__(self):
+            case_predicate = (
+                f" AND {str(self.predicate)}" if self.predicate is not None else ""
+            )
             if self.command == "INSERT":
                 sets, sets_tos = zip(*self.set.items())
                 return "WHEN NOT MATCHED{} THEN {} ({}) VALUES ({})".format(
-                    " AND %s" % self.predicate if self.predicate is not None else "",
+                    case_predicate,
                     self.command,
                     ", ".join(sets),
                     ", ".join(map(str, sets_tos)),
@@ -56,9 +59,9 @@ def __repr__(self):
                     else ""
                 )
                 return "WHEN MATCHED{} THEN {}{}".format(
-                    " AND %s" % self.predicate if self.predicate is not None else "",
+                    case_predicate,
                     self.command,
-                    " SET %s" % sets if self.set else "",
+                    f" SET {str(sets)}" if self.set else "",
                 )
 
         def values(self, **kwargs):
@@ -72,7 +75,7 @@ def where(self, expr):
     def __repr__(self):
         clauses = " ".join([repr(clause) for clause in self.clauses])
         return f"MERGE INTO {self.target} USING {self.source} ON {self.on}" + (
-            " " + clauses if clauses else ""
+            f" {clauses}" if clauses else ""
         )
 
     def when_matched_then_update(self):
@@ -450,7 +453,7 @@ def from_parent_stage(cls, parent_stage, path, file_format=None):
         """
         return cls(
             parent_stage.name,
-            parent_stage.path + "/" + path,
+            f"{parent_stage.path}/{path}",
             parent_stage.namespace,
             file_format,
         )
@@ -514,15 +517,15 @@ def __repr__(self):
         )
         encryption = "ENCRYPTION=({})".format(
             " ".join(
-                ("{}='{}'" if isinstance(v, string_types) else "{}={}").format(n, v)
+                f"{n}='{v}'" if isinstance(v, string_types) else f"{n}={v}"
                 for n, v in self.encryption_used.items()
             )
         )
-        uri = "'s3://{}{}'".format(self.bucket, "/" + self.path if self.path else "")
+        uri = "'s3://{}{}'".format(self.bucket, f"/{self.path}" if self.path else "")
         return "{}{}{}".format(
             uri,
-            " " + credentials if self.credentials_used else "",
-            " " + encryption if self.encryption_used else "",
+            f" {credentials}" if self.credentials_used else "",
+            f" {encryption}" if self.encryption_used else "",
         )
 
     def credentials(
@@ -590,12 +593,12 @@ def __repr__(self):
         )
         encryption = "ENCRYPTION=({})".format(
             " ".join(
-                ("{}='{}'" if isinstance(v, string_types) else "{}={}").format(n, v)
+                f"{n}='{v}'" if isinstance(v, string_types) else f"{n}={v}"
                 for n, v in self.encryption_used.items()
             )
         )
         uri = "'azure://{}.blob.core.windows.net/{}{}'".format(
-            self.account, self.container, "/" + self.path if self.path else ""
+            self.account, self.container, f"/{self.path}" if self.path else ""
         )
         return "{}{}{}".format(
             uri,

src/snowflake/sqlalchemy/snowdialect.py

@@ -204,7 +204,7 @@ def create_connect_args(self, url):
                 opts["schema"] = name_spaces[1]
             else:
                 raise sa_exc.ArgumentError(
-                    "Invalid name space is specified: {}".format(opts["database"])
+                    f"Invalid name space is specified: {opts['database']}"
                 )
         if ".snowflakecomputing.com" not in opts["host"] and not opts.get("port"):
             opts["account"] = opts["host"]
@@ -239,11 +239,7 @@ def _has_object(self, connection, object_type, object_name, schema=None):
         full_name = self._denormalize_quote_join(schema, object_name)
         try:
             results = connection.execute(
-                text(
-                    "DESC {} /* sqlalchemy:_has_object */ {}".format(
-                        object_type, full_name
-                    )
-                )
+                text(f"DESC {object_type} /* sqlalchemy:_has_object */ {full_name}")
             )
             row = results.fetchone()
             have = row is not None
@@ -529,9 +525,7 @@ def _get_schema_columns(self, connection, schema, **kw):
             col_type_kw = {}
             if col_type is None:
                 sa_util.warn(
-                    "Did not recognize type '{}' of column '{}'".format(
-                        coltype, column_name
-                    )
+                    f"Did not recognize type '{coltype}' of column '{column_name}'"
                 )
                 col_type = sqltypes.NULLTYPE
             else:
@@ -624,9 +618,7 @@ def _get_table_columns(self, connection, table_name, schema=None, **kw):
             col_type_kw = {}
             if col_type is None:
                 sa_util.warn(
-                    "Did not recognize type '{}' of column '{}'".format(
-                        coltype, column_name
-                    )
+                    f"Did not recognize type '{coltype}' of column '{column_name}'"
                 )
                 col_type = sqltypes.NULLTYPE
             else:
@@ -685,9 +677,7 @@ def get_table_names(self, connection, schema=None, **kw):
         if schema:
             cursor = connection.execute(
                 text(
-                    "SHOW /* sqlalchemy:get_table_names */ TABLES IN {}".format(
-                        self._denormalize_quote_join(schema)
-                    )
+                    f"SHOW /* sqlalchemy:get_table_names */ TABLES IN {self._denormalize_quote_join(schema)}"
                 )
             )
         else:
@@ -709,9 +699,7 @@ def get_view_names(self, connection, schema=None, **kw):
         if schema:
             cursor = connection.execute(
                 text(
-                    "SHOW /* sqlalchemy:get_view_names */ VIEWS IN {}".format(
-                        self._denormalize_quote_join(schema)
-                    )
+                    f"SHOW /* sqlalchemy:get_view_names */ VIEWS IN {self._denormalize_quote_join(schema)}"
                 )
             )
         else:
@@ -730,18 +718,15 @@ def get_view_definition(self, connection, view_name, schema=None, **kw):
         if schema:
             cursor = connection.execute(
                 text(
-                    "SHOW /* sqlalchemy:get_view_definition */ VIEWS "
-                    "LIKE '{}' IN {}".format(
-                        self._denormalize_quote_join(view_name),
-                        self._denormalize_quote_join(schema),
-                    )
+                    f"SHOW /* sqlalchemy:get_view_definition */ VIEWS \
+                    LIKE '{self._denormalize_quote_join(view_name)}' IN {self._denormalize_quote_join(schema)}"
                 )
             )
         else:
             cursor = connection.execute(
                 text(
-                    "SHOW /* sqlalchemy:get_view_definition */ VIEWS "
-                    "LIKE '{}'".format(self._denormalize_quote_join(view_name))
+                    f"SHOW /* sqlalchemy:get_view_definition */ VIEWS \
+                    LIKE '{self._denormalize_quote_join(view_name)}'"
                 )
             )
 
@@ -759,8 +744,8 @@ def get_temp_table_names(self, connection, schema=None, **kw):
         if schema:
             cursor = connection.execute(
                 text(
-                    "SHOW /* sqlalchemy:get_temp_table_names */ TABLES "
-                    "IN {}".format(self._denormalize_quote_join(schema))
+                    f"SHOW /* sqlalchemy:get_temp_table_names */ TABLES \
+                    IN {self._denormalize_quote_join(schema)}"
                 )
             )
         else:
@@ -807,7 +792,7 @@ def _get_table_comment(self, connection, table_name, schema=None, **kw):
             "SHOW /* sqlalchemy:_get_table_comment */ "
             "TABLES LIKE '{}'{}".format(
                 table_name,
-                (f" IN SCHEMA {self.normalize_name(schema)}") if schema else "",
+                f" IN SCHEMA {self.normalize_name(schema)}" if schema else "",
             )
         )
         cursor = connection.execute(text(sql_command))
@@ -821,7 +806,7 @@ def _get_view_comment(self, connection, table_name, schema=None, **kw):
             "SHOW /* sqlalchemy:_get_view_comment */ "
             "VIEWS LIKE '{}'{}".format(
                 table_name,
-                (f" IN SCHEMA {self.normalize_name(schema)}") if schema else "",
+                f" IN SCHEMA {self.normalize_name(schema)}" if schema else "",
             )
         )
         cursor = connection.execute(text(sql_command))

tests/conftest.py

@@ -23,10 +23,7 @@
 INTERNAL_SKIP_TAGS = {"external"}
 RUNNING_ON_GH = os.getenv("GITHUB_ACTIONS") == "true"
 
-if os.getenv("TRAVIS") == "true":
-    TEST_SCHEMA = "TRAVIS_JOB_{}".format(os.getenv("TRAVIS_JOB_ID"))
-else:
-    TEST_SCHEMA = "sqlalchemy_tests_" + str(uuid.uuid4()).replace("-", "_")
+TEST_SCHEMA = f"sqlalchemy_tests_{str(uuid.uuid4()).replace('-', '_')}"
 
 create_engine_with_future_flag = create_engine