pylint inspired cleanups

Use single quotes instead of backticks in error messages for consistency

Author: mr-c

schema_salad/avro/schema.py

@@ -100,7 +100,7 @@ def __init__(self, atype: str, other_props: Optional[PropsType] = None) -> None:
             raise SchemaParseException(
                 f"Schema type {atype!r} must be a string, was {type(atype)!r}."
             )
-        elif atype not in VALID_TYPES:
+        if atype not in VALID_TYPES:
             fail_msg = f"{atype} is not a valid type."
             raise SchemaParseException(fail_msg)
 
@@ -177,8 +177,7 @@ def get_space(self) -> Optional[str]:
 
         if self._full.find(".") > 0:
             return self._full.rsplit(".", 1)[0]
-        else:
-            return None
+        return None
 
 
 class Names:
@@ -215,10 +214,10 @@ def add_name(
         if to_add.fullname in VALID_TYPES:
             fail_msg = f"{to_add.fullname} is a reserved type name."
             raise SchemaParseException(fail_msg)
-        elif to_add.fullname in self.names:
+        if to_add.fullname in self.names:
             fail_msg = f"The name {to_add.fullname!r} is already in use."
             raise SchemaParseException(fail_msg)
-        elif to_add.fullname is None:
+        if to_add.fullname is None:
             fail_msg = f"{to_add.fullname} is missing, but this is impossible."
             raise SchemaParseException(fail_msg)
 
@@ -240,9 +239,9 @@ def __init__(
         # Ensure valid ctor args
         if not name:
             raise SchemaParseException("Named Schemas must have a non-empty name.")
-        elif not isinstance(name, str):
+        if not isinstance(name, str):
             raise SchemaParseException("The name property must be a string.")
-        elif namespace is not None and not isinstance(namespace, str):
+        if namespace is not None and not isinstance(namespace, str):
             raise SchemaParseException("The namespace property must be a string.")
         if names is None:
             raise SchemaParseException("Must provide Names.")
@@ -284,10 +283,10 @@ def __init__(
         if not name:
             fail_msg = "Fields must have a non-empty name."
             raise SchemaParseException(fail_msg)
-        elif not isinstance(name, str):
+        if not isinstance(name, str):
             fail_msg = "The name property must be a string."  # type: ignore[unreachable]
             raise SchemaParseException(fail_msg)
-        elif order is not None and order not in VALID_FIELD_SORT_ORDERS:
+        if order is not None and order not in VALID_FIELD_SORT_ORDERS:
             fail_msg = f"The order property {order} is not valid."
             raise SchemaParseException(fail_msg)
 
@@ -365,9 +364,9 @@ def __init__(
         # Ensure valid ctor args
         if not isinstance(symbols, list):
             raise AvroException("Enum Schema requires a JSON array for the symbols property.")
-        elif False in [isinstance(s, str) for s in symbols]:
+        if False in [isinstance(s, str) for s in symbols]:
             raise AvroException("Enum Schema requires all symbols to be JSON strings.")
-        elif len(set(symbols)) < len(symbols):
+        if len(set(symbols)) < len(symbols):
             raise AvroException(f"Duplicate symbol: {symbols}")
 
         # Call parent ctor
@@ -457,10 +456,9 @@ def __init__(
                 and new_schema.type in [schema.type for schema in schema_objects]
             ):
                 raise SchemaParseException(f"{new_schema.type} type already in Union")
-            elif new_schema.type == "union":
+            if new_schema.type == "union":
                 raise SchemaParseException("Unions cannot contain other unions.")
-            else:
-                schema_objects.append(new_schema)
+            schema_objects.append(new_schema)
         self._schemas = schema_objects
 
     # read-only properties
@@ -490,10 +488,9 @@ def make_field_objects(field_data: List[PropsType], names: Names) -> List[Field]
                 if not (order is None or isinstance(order, str)):
                     raise SchemaParseException('"order" must be a string or None')
                 doc = field.get("doc")
-                if not (doc is None or isinstance(doc, str) or isinstance(doc, list)):
+                if not (doc is None or isinstance(doc, (list, str))):
                     raise SchemaParseException('"doc" must be a string, list of strings, or None')
-                else:
-                    doc = cast(Union[str, List[str], None], doc)
+                doc = cast(Union[str, List[str], None], doc)
                 other_props = get_other_props(field, FIELD_RESERVED_PROPS)
                 new_field = Field(atype, name, has_default, default, order, names, doc, other_props)
                 parsed_fields[new_field.name] = field
@@ -583,7 +580,7 @@ def make_avsc_object(json_data: JsonDataType, names: Optional[Names] = None) ->
                 raise SchemaParseException(
                     f'"namespace" for type {atype} must be a string or None: {json_data}'
                 )
-            if not (doc is None or isinstance(doc, str) or isinstance(doc, list)):
+            if not (doc is None or isinstance(doc, (str, list))):
                 raise SchemaParseException(
                     f'"doc" for type {atype} must be a string, '
                     f"a list of strings, or None: {json_data}"
@@ -594,19 +591,15 @@ def make_avsc_object(json_data: JsonDataType, names: Optional[Names] = None) ->
                     raise SchemaParseException(
                         f'"symbols" for type enum must be a list of strings: {json_data}'
                     )
-                else:
-                    symbols = cast(List[str], symbols)
+                symbols = cast(List[str], symbols)
                 return EnumSchema(name, namespace, symbols, names, doc, other_props)
             if atype in ["record", "error"]:
                 fields = json_data.get("fields", [])
                 if not isinstance(fields, list):
                     raise SchemaParseException(
-                        '"fields" for type {} must be a list of mappings: {}'.format(
-                            atype, json_data
-                        )
+                        f'"fields" for type {atype} must be a list of mappings: {json_data}'
                     )
-                else:
-                    fields = cast(List[PropsType], fields)
+                fields = cast(List[PropsType], fields)
                 return RecordSchema(name, namespace, fields, names, atype, doc, other_props)
             raise SchemaParseException(f"Unknown Named Type: {atype}")
         if atype in VALID_TYPES:

schema_salad/codegen.py

@@ -57,7 +57,7 @@ def codegen(
         else ".".join(list(reversed(sp.netloc.split("."))) + sp.path.strip("/").split("/"))
     )
     info = parser_info or pkg
-    if lang == "python" or lang == "cpp" or lang == "dlang":
+    if lang in set(["python", "cpp", "dlang"]):
         if target:
             dest: Union[TextIOWrapper, TextIO] = open(target, mode="w", encoding="utf-8")
         else:
@@ -72,7 +72,7 @@ def codegen(
             )
             gen.parse(j)
             return
-        elif lang == "dlang":
+        if lang == "dlang":
             gen = DlangCodeGen(
                 base,
                 dest,
@@ -83,8 +83,7 @@ def codegen(
             )
             gen.parse(j)
             return
-        else:
-            gen = PythonCodeGen(dest, copyright=copyright, parser_info=info)
+        gen = PythonCodeGen(dest, copyright=copyright, parser_info=info)
 
     elif lang == "java":
         gen = JavaCodeGen(

schema_salad/exceptions.py

@@ -73,7 +73,7 @@ def with_sourceline(self, sl: Optional[SourceLine]) -> "SchemaSaladException":
         return self
 
     def leaves(self) -> List["SchemaSaladException"]:
-        if len(self.children):
+        if len(self.children) > 0:
             return sum((c.leaves() for c in self.children), [])
         if len(self.message):
             return [self]
@@ -93,7 +93,7 @@ def prefix(self) -> str:
     def summary(self, level: int = 0, with_bullet: bool = False) -> str:
         indent_per_level = 2
         spaces = (level * indent_per_level) * " "
-        bullet = self.bullet + " " if len(self.bullet) and with_bullet else ""
+        bullet = self.bullet + " " if len(self.bullet) > 0 and with_bullet else ""
         return f"{self.prefix()}{spaces}{bullet}{self.message}"
 
     def __str__(self) -> str:
@@ -108,8 +108,7 @@ def pretty_str(self, level: int = 0) -> str:
         ret = "\n".join(e for e in my_summary + [c.pretty_str(next_level) for c in self.children])
         if level == 0:
             return strip_duplicated_lineno(reflow_all(ret))
-        else:
-            return ret
+        return ret
 
 
 class SchemaException(SchemaSaladException):

schema_salad/fetcher.py

@@ -23,12 +23,10 @@ class Fetcher(ABC):
     @abstractmethod
     def fetch_text(self, url: str, content_types: Optional[List[str]] = None) -> str:
         """Retrieve the given resource as a string."""
-        ...
 
     @abstractmethod
     def check_exists(self, url: str) -> bool:
         """Check if the given resource exists."""
-        ...
 
     @abstractmethod
     def urljoin(self, base_url: str, url: str) -> str:
@@ -82,8 +80,10 @@ def fetch_text(self, url: str, content_types: Optional[List[str]] = None) -> str
                 content_type = resp.headers["content-type"].split(";")[:1][0]
                 if content_type not in content_types:
                     _logger.warning(
-                        f"While fetching {url}, got content-type of "
-                        f"{content_type!r}. Expected one of {content_types}."
+                        "While fetching %s, got content-type of %r. Expected one of %s.",
+                        url,
+                        content_type,
+                        content_types,
                     )
             return resp.text
         if scheme == "file":
@@ -101,8 +101,7 @@ def fetch_text(self, url: str, content_types: Optional[List[str]] = None) -> str
             except OSError as err:
                 if err.filename == path:
                     raise ValidationException(str(err)) from err
-                else:
-                    raise ValidationException(f"Error reading {url}: {err}") from err
+                raise ValidationException(f"Error reading {url}: {err}") from err
         raise ValidationException(f"Unsupported scheme in url: {url}")
 
     def check_exists(self, url: str) -> bool:

schema_salad/jsonld_context.py

@@ -116,9 +116,8 @@ def process_type(
 
         if context.get(recordname, predicate) != predicate:
             raise SchemaException(
-                "Predicate collision on '{}', '{}' != '{}'".format(
-                    recordname, context[recordname], predicate
-                )
+                f"Predicate collision on {recordname!r}, "
+                f"{context[recordname]!r} != {predicate!r}"
             )
 
         if not recordname:

schema_salad/main.py

@@ -20,7 +20,7 @@
 from .ref_resolver import Loader, file_uri
 from .utils import json_dump, stdout
 
-if int(rdflib_version.split(".")[0]) < 6:
+if int(rdflib_version.split(".", maxsplit=1)[0]) < 6:
     register("json-ld", Parser, "rdflib_jsonld.parser", "JsonLDParser")
 _logger = logging.getLogger("salad")
 
@@ -226,8 +226,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
         if args.version:
             print(f"{sys.argv[0]} Current version: {pkg[0].version}")
             return 0
-        else:
-            _logger.info("%s Current version: %s", sys.argv[0], pkg[0].version)
+        _logger.info("%s Current version: %s", sys.argv[0], pkg[0].version)
 
     # Get the metaschema to validate the schema
     metaschema_names, metaschema_doc, metaschema_loader = schema.get_metaschema()
@@ -243,20 +242,20 @@ def main(argsl: Optional[List[str]] = None) -> int:
         schema_doc, schema_metadata = metaschema_loader.resolve_all(schema_raw_doc, schema_uri)
     except ValidationException as e:
         _logger.error(
-            "Schema `%s` failed link checking:\n%s",
+            "Schema %r failed link checking:\n%s",
             args.schema,
             str(e),
-            exc_info=(True if args.debug else False),
+            exc_info=bool(args.debug),
         )
         _logger.debug("Index is %s", list(metaschema_loader.idx.keys()))
         _logger.debug("Vocabulary is %s", list(metaschema_loader.vocab.keys()))
         return 1
     except RuntimeError as e:
         _logger.error(
-            "Schema `%s` read error:\n%s",
+            "Schema %r read error:\n%s",
             args.schema,
             str(e),
-            exc_info=(True if args.debug else False),
+            exc_info=bool(args.debug),
         )
         return 1
 
@@ -287,7 +286,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
     try:
         schema.validate_doc(metaschema_names, schema_doc, metaschema_loader, args.strict)
     except ValidationException as e:
-        _logger.error("While validating schema `%s`:\n%s", args.schema, str(e))
+        _logger.error("While validating schema %r:\n%s", args.schema, str(e))
         return 1
 
     # Get the json-ld context and RDFS representation from the schema
@@ -324,7 +323,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
             avsc_names = schema.make_avro_schema_from_avro(avsc_obj)
         except SchemaParseException as err:
             _logger.error(
-                "Schema `%s` error:\n%s",
+                "Schema %r error:\n%s",
                 args.schema,
                 str(err),
                 exc_info=((type(err), err, None) if args.debug else None),
@@ -333,7 +332,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
                 json_dump(avsc_obj, fp=sys.stdout, indent=4, default=str)
             return 1
     else:
-        _logger.error("Schema `%s` must be a list.", args.schema)  # type: ignore[unreachable]
+        _logger.error("Schema %r must be a list.", args.schema)  # type: ignore[unreachable]
         return 1
 
     # Optionally print Avro-compatible schema from schema
@@ -366,7 +365,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
 
     # If no document specified, all done.
     if not args.document:
-        print(f"Schema `{args.schema}` is valid")
+        print(f"Schema {args.schema!r} is valid")
         return 0
 
     # Load target document and resolve refs
@@ -378,7 +377,7 @@ def main(argsl: Optional[List[str]] = None) -> int:
         except ValidationException as e:
             msg = to_one_line_messages(e) if args.print_oneline else str(e)
             _logger.error(
-                "Document `%s` failed validation:\n%s",
+                "Document %r failed validation:\n%s",
                 args.document,
                 msg,
                 exc_info=args.debug,
@@ -405,23 +404,22 @@ def main(argsl: Optional[List[str]] = None) -> int:
             )
         except ValidationException as e:
             msg2 = to_one_line_messages(e) if args.print_oneline else str(e)
-            _logger.error(f"While validating document {uri!r}:\n{msg2}")
+            _logger.error("While validating document %r:\n%s", uri, msg2)
             return 1
 
         # Optionally convert the document to RDF
         if args.print_rdf:
             if isinstance(document, (Mapping, MutableSequence)):
                 printrdf(uri, document, schema_ctx, args.rdf_serializer)
                 return 0
-            else:
-                print("Document must be a dictionary or list.")
-                return 1
+            print("Document must be a dictionary or list.")
+            return 1
 
         if args.print_metadata:
             json_dump(doc_metadata, fp=sys.stdout, indent=4, default=str)
             return 0
 
-        _logger.info(f"Document {uri!r} is valid")
+        _logger.info("Document %r is valid", uri)
 
     return 0