fix a million flake8 errors

Author: davidt0x

examples/document.py

@@ -1,7 +1,7 @@
 import modelspec
 from modelspec import field, instance_of, optional
 from modelspec.base_types import Base
-from typing import List, Optional, Union
+from typing import List
 
 # Example showing how to create a model of a document and use it to create/serialize instances
 

src/modelspec/base_types.py

@@ -8,15 +8,7 @@
 
 from typing import (
     Optional,
-    List,
-    Dict,
-    Any,
-    Union,
     Tuple,
-    Type,
-    TypeVar,
-    Callable,
-    Iterable,
 )
 
 from docstring_parser import parse
@@ -29,14 +21,9 @@
 
 from typing import Union, List, Dict, Any
 
-from attr import has, field, fields
-from attr.validators import optional, instance_of, in_
-
-from cattr.gen import make_dict_unstructure_fn, make_dict_structure_fn, override
+from cattr.gen import make_dict_unstructure_fn, override
 from cattr.preconf.pyyaml import make_converter as make_yaml_converter
 
-
-from collections import OrderedDict
 from tabulate import tabulate
 
 verbose = False
@@ -48,7 +35,7 @@
 
 class EvaluableExpression(str):
     """
-    EvaluableExpression is a string that can be evaluated to a value during MDF execution. This class inherits from
+    EvaluableExpression is a string that can be evaluated to a value during modelspec execution. This class inherits from
     str, so it can be used as a string.
     """
 
@@ -139,13 +126,13 @@ def from_dict(cls, d: Dict[str, Any]) -> "Base":
 
     @classmethod
     def from_json(cls, json_str: str) -> "Base":
-        """Instantiate an MDF object from a JSON string"""
+        """Instantiate an modelspec object from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_json_file(
         self, filename: Optional[str] = None, include_metadata: bool = True
     ) -> str:
-        """Convert the MDF model to JSON format and save to a file.
+        """Convert the modelspec model to JSON format and save to a file.
 
          .. note::
             JSON is standard file format uses human-readable text to store and transmit data objects consisting of
@@ -180,10 +167,10 @@ def to_yaml(self, include_metadata: bool = True) -> str:
         return yaml.dump(yaml_converter.unstructure(self.to_dict()), sort_keys=False)
 
     def to_yaml_file(self, filename: str, include_metadata: bool = True) -> str:
-        """Convert file in MDF format to yaml format
+        """Convert modelspec format to yaml format
 
         Args:
-            filename: File in MDF format (Filename extension: .mdf )
+            filename: File in modelspec format (Filename extension: .yaml )
             include_metadata: Contains contact information, citations, acknowledgements, pointers to sample data,
                               benchmark results, and environments in which the specified model was originally implemented
         Returns:
@@ -203,52 +190,52 @@ def to_yaml_file(self, filename: str, include_metadata: bool = True) -> str:
         return filename
 
     @classmethod
-    def from_file(cls, filename: str) -> "Model":
+    def from_file(cls, filename: str) -> "Base":
         """
-        Create a :class:`.Model` from its representation stored in a file. Auto-detect the correct deserialization code
+        Create a :class:`.Base` from its representation stored in a file. Auto-detect the correct deserialization code
         based on file extension. Currently supported formats are; JSON(.json) and YAML (.yaml or .yml)
 
         Args:
             filename: The name of the file to load.
 
         Returns:
-            An MDF :class:`.Model` for this file.
+            An modelspec :class:`.Base` for this file.
         """
         if filename.endswith(".yaml") or filename.endswith(".yml"):
             return cls.from_yaml_file(filename)
         elif filename.endswith(".json"):
             return cls.from_json_file(filename)
         else:
             raise ValueError(
-                f"Cannot auto-detect MDF serialization format from filename ({filename}). The filename "
+                f"Cannot auto-detect modelspec serialization format from filename ({filename}). The filename "
                 f"must have one of the following extensions: .json, .yml, or .yaml."
             )
 
     @classmethod
-    def from_json_file(cls, filename: str) -> "Model":
+    def from_json_file(cls, filename: str) -> "Base":
         """
-        Create a :class:`.Model` from its JSON representation stored in a file.
+        Create a :class:`.Base` from its JSON representation stored in a file.
 
         Args:
             filename: The file from which to load the JSON data.
 
         Returns:
-            An MDF :class:`.Model` for this JSON
+            An modelspec :class:`.Base` for this JSON
         """
         with open(filename) as infile:
             d = json.load(infile)
             return cls.from_dict(d)
 
     @classmethod
-    def from_yaml_file(cls, filename: str) -> "Model":
+    def from_yaml_file(cls, filename: str) -> "Base":
         """
-        Create a :class:`.Model` from its YAML representation stored in a file.
+        Create a :class:`.Base` from its YAML representation stored in a file.
 
         Args:
             filename: The file from which to load the YAML data.
 
         Returns:
-            An MDF :class:`.Model` for this YAML
+            An modelspec :class:`.Base` for this YAML
         """
         with open(filename) as infile:
             d = yaml.safe_load(infile)
@@ -269,7 +256,7 @@ def get_child(self, id: str, type_: str) -> Any:
         """
 
         # We can't find the container for this type of child object.
-        if not type_ in [f.name for f in attr.fields(self.__class__)]:
+        if type_ not in [f.name for f in attr.fields(self.__class__)]:
             return None
 
         children = self.__getattribute__(type_)
@@ -462,7 +449,7 @@ def _is_base_type(
             or (can_be_list and value == list)
             or (can_be_dict and value == dict)
             or (can_be_ndarray and value == numpy.ndarray)
-            or (can_be_none and value is type(None))
+            or (can_be_none and value is None)
             or (can_be_eval_expr and cls._is_evaluable_expression(value))
             or value == Union
         )
@@ -485,7 +472,6 @@ def _type_to_str(type_: Any) -> str:
 
         # If its a Generic type
         elif get_origin(type_) is not None:
-            collection_arg = None
             if get_origin(type_) == list and len(get_args(type_)) > 0:
                 return Base._type_to_str(get_args(type_)[0])
             elif get_origin(type_) == dict and len(get_args(type_)) > 0:
@@ -532,7 +518,7 @@ def _cls_generate_documentation(cls, format: str = MARKDOWN_FORMAT):
         rst_url_format = "`%s <%s>`_"
 
         def insert_links(text, format=MARKDOWN_FORMAT):
-            if not "_" in text:
+            if "_" not in text:
                 return text
             if '"' in text:
                 return text  # Assume it's a quoted string containing an underscore...
@@ -811,13 +797,13 @@ def f(obj_list):
     return f
 
 
-def _structure_list_mdfbase(cl):
+def _structure_list_base(cl):
     """Deserialize list of dict of Base objects as a list if all of their elements have ids"""
-    mdf_class = get_args(cl)[0]
+    base_class = get_args(cl)[0]
 
     def f(obj_dict, t):
         try:
-            obj_list = [converter.structure(v, mdf_class) for v in obj_dict.values()]
+            obj_list = [converter.structure(v, base_class) for v in obj_dict.values()]
 
             # Give each object the id that is its key in the dict.
             for id, obj in zip(obj_dict.keys(), obj_list):
@@ -845,7 +831,7 @@ def _is_list_base(cl):
     _base_unstruct_hook_factory,
 )
 
-converter.register_structure_hook_factory(_is_list_base, _structure_list_mdfbase)
+converter.register_structure_hook_factory(_is_list_base, _structure_list_base)
 converter.register_structure_hook_factory(
     lambda cl: issubclass(cl, Base) and "id" in [a.name for a in fields(cl)],
     _base_struct_hook_factory,

src/modelspec/utils.py

@@ -1,12 +1,11 @@
-from modelspec import *
 import sys
 import json
 import yaml
 import os
 import math
 import numpy as np
 
-from modelspec.base_types import print_v, print_
+from modelspec.base_types import print_
 from modelspec.base_types import EvaluableExpression
 
 verbose = False
@@ -118,7 +117,6 @@ def _parse_attributes(dict_format, to_build):
 
                     if type_to_use == EvaluableExpression:
                         vv = {}
-                        dd = _parse_attributes(value, vv)
                         to_build.__setattr__(key, vv)
                     else:
                         ff = type_to_use()
@@ -133,9 +131,9 @@ def _parse_attributes(dict_format, to_build):
             elif type(value) == list:
                 type_to_use = to_build.allowed_children[key][1]
 
-                for l in value:
+                for vl in value:
                     ff = type_to_use()
-                    ff = _parse_element(l, ff)
+                    ff = _parse_element(vl, ff)
                     exec("to_build.%s.append(ff)" % key)
             else:
                 type_to_use = to_build.allowed_fields[key][1]
@@ -150,7 +148,7 @@ def locate_file(f, base_dir):
     """
     Utility method for finding full path to a filename as string
     """
-    if base_dir == None:
+    if base_dir is None:
         return f
     file_name = os.path.join(base_dir, f)
     real = os.path.realpath(file_name)
@@ -325,5 +323,4 @@ def parse_list_like(list_str):
         except:
             pass
         if "[" in list_str:
-            l = eval(list_str)
-            return l
+            return eval(list_str)

tests/test_base.py

@@ -160,7 +160,7 @@ def test_save_load_json(tmp_path):
     filenamey = str(tmp_path / f"{net.id}.yaml")
     # net.id = net.id+'_yaml'
     net.to_yaml_file(filenamey)
-    from modelspec.utils import load_json, load_yaml, _parse_element
+    from modelspec.utils import load_json, load_yaml
 
     dataj = load_json(filenamej)
     print_v("Loaded network specification from %s" % filenamej)
@@ -174,7 +174,6 @@ def test_save_load_json(tmp_path):
     nety = NewNetwork.from_dict(datay)
     str_nety = str(nety)
 
-    verbose = False
     print("----- Before -----")
     print(str_orig)
     print("----- After via %s -----" % filenamej)
@@ -295,7 +294,7 @@ class Document(Base):
     doc.sections.append(a)
     doc.sections.append(Section(id="Chapter 1"))
 
-    json_str = doc.to_json()
-    yaml_str = doc.to_yaml()
-    doc_md = doc.generate_documentation(format="markdown")
-    doc_rst = doc.generate_documentation(format="rst")
+    doc.to_json()
+    doc.to_yaml()
+    doc.generate_documentation(format="markdown")
+    doc.generate_documentation(format="rst")

tests/test_utils.py

@@ -1,6 +1,4 @@
-from modelspec.base_types import *
-from modelspec.utils import *
-
+from modelspec.utils import evaluate
 from modelspec.utils import _val_info
 
 import numpy as np