Revert "100% Test Success (#5)"

This reverts commit ff504dd.

Author: SamuelMarks

cdd/__init__.py

@@ -9,7 +9,7 @@
 from logging import getLogger as get_logger
 
 __author__ = "Samuel Marks"  # type: str
-__version__ = "0.0.99rc47"  # type: str
+__version__ = "0.0.99rc46"  # type: str
 __description__ = (
     "Open API to/fro routes, models, and tests. "
     "Convert between docstrings, classes, methods, argparse, pydantic, and SQLalchemy."

cdd/docstring/utils/parse_utils.py

@@ -13,7 +13,6 @@
 from cdd.shared.ast_utils import deduplicate
 from cdd.shared.pure_utils import (
     count_iter_items,
-    pp,
     simple_types,
     sliding_window,
     type_to_name,
@@ -57,7 +56,6 @@
     ("List", " ", "of"): "List",
     ("Tuple", " ", "of"): "Tuple",
     ("Dictionary", " ", "of"): "Mapping",
-    ("One", " ", "of"): "Union",
 }
 
 
@@ -371,19 +369,8 @@ def _parse_adhoc_doc_for_typ_phase0(doc, words):
     word_chars: str = "{0}{1}`'\"/|".format(string.digits, string.ascii_letters)
     sentence_ends: int = -1
     break_the_union: bool = False  # lincoln
-    counter = Counter(doc)  # Imperfect because won't catch escaped quote marks
-    balanced_single: bool = counter["'"] > 0 and counter["'"] & 1 == 0
-    balanced_double: bool = counter['"'] > 0 and counter['"'] & 1 == 0
-
-    i: int = 0
-    n: int = len(doc)
-    while i < n:
-        ch: str = doc[i]
-        if (ch == "'" and balanced_single or ch == '"' and balanced_double) and (
-            i == 0 or doc[i - 1] != "\\"
-        ):
-            i = eat_quoted(ch, doc, i, words, n)
-        elif (
+    for i, ch in enumerate(doc):
+        if (
             ch in word_chars
             or ch == "."
             and len(doc) > (i + 1)
@@ -393,20 +380,14 @@ def _parse_adhoc_doc_for_typ_phase0(doc, words):
         ):
             words[-1].append(ch)
         elif ch in frozenset((".", ";", ",")) or ch.isspace():
-            if words[-1]:
-                words[-1] = "".join(words[-1])
-                words.append(ch)
-            else:
-                words[-1] = ch
+            words[-1] = "".join(words[-1])
+            words.append(ch)
             if ch == "." and sentence_ends == -1:
                 sentence_ends: int = len(words)
             elif ch == ";":
                 break_the_union = True
             words.append([])
-        i += 1
     words[-1] = "".join(words[-1])
-    if not words[-1]:
-        del words[-1]
     candidate_type: Optional[str] = next(
         map(
             adhoc_type_to_type.__getitem__,
@@ -433,47 +414,4 @@ def _parse_adhoc_doc_for_typ_phase0(doc, words):
     return candidate_type, fst_sentence, sentence
 
 
-def eat_quoted(ch, doc, chomp_start_idx, words, n):
-    """
-    Chomp from quoted character `ch` to quoted character `ch`
-
-    :param ch: Character of `'` or `"`
-    :type ch: ```Literal["'", '"']```
-
-    :param doc: Possibly ambiguous docstring for argument, that *might* hint as to the type
-    :type doc: ```str```
-
-    :param chomp_start_idx: chomp_start_idx
-    :type chomp_start_idx: ```int```
-
-    :param words: Words
-    :type words: ```List[Union[List[str], str]]```
-
-    :param n: Length of `doc`
-    :type n: ```int```
-
-    :return: chomp_end_idx
-    :rtype: ```int```
-    """
-    chomp_end_idx: int = next(
-        filter(
-            lambda _chomp_end_idx: doc[_chomp_end_idx + 1] != ch
-            or doc[_chomp_end_idx] == "\\",
-            range(chomp_start_idx, n),
-        ),
-        chomp_start_idx,
-    )
-    quoted_str: str = doc[chomp_start_idx:chomp_end_idx]
-    from operator import iadd
-
-    pp({"b4::words": words, '"".join(words[-1])': "".join(words[-1])})
-    (
-        iadd(words, (quoted_str, []))
-        if len(words[-1]) == 1 and words[-1][-1] == "`"
-        else iadd(words, ("".join(words[-1]), quoted_str, []))
-    )
-    pp({"words": words})
-    return chomp_end_idx
-
-
 __all__ = ["parse_adhoc_doc_for_typ"]  # type: list[str]

cdd/shared/ast_utils.py

@@ -427,10 +427,8 @@ def get_default_val(val):
             )
         elif _param.get("typ") == "Str":
             _param["typ"] = "str"
-        elif _param.get("typ") in frozenset(("Constant", "NameConstant")):
+        elif _param.get("typ") in frozenset(("Constant", "NameConstant", "Num")):
             _param["typ"] = "object"
-        elif _param.get("typ") == "Num":
-            _param["typ"] = "float"
     if "typ" in _param and needs_quoting(_param["typ"]):
         default = (
             _param.get("default")

cdd/shared/defaults_utils.py

@@ -228,38 +228,27 @@ def _parse_out_default_and_doc(
     :rtype: Tuple[str, Optional[str]]
     """
     if typ is not None and typ in simple_types and default not in none_types:
-        keep_default: bool = False
-        try:
-            lit = (
-                ast.AST()
-                if typ != "str"
-                and any(
-                    map(
-                        partial(
-                            contains, frozenset(("*", "^", "&", "|", "$", "@", "!"))
-                        ),
-                        default,
-                    )
+        lit = (
+            ast.AST()
+            if typ != "str"
+            and any(
+                map(
+                    partial(contains, frozenset(("*", "^", "&", "|", "$", "@", "!"))),
+                    default,
                 )
-                else literal_eval("({default})".format(default=default))
             )
-        except ValueError as e:
-            assert e.args[0].startswith("malformed node or string"), e
-            keep_default = True
+            else literal_eval("({default})".format(default=default))
+        )
         default = (
-            default
-            if keep_default
-            else (
-                "```{default}```".format(default=default)
-                if isinstance(lit, ast.AST)
-                else {
-                    "bool": bool,
-                    "int": int,
-                    "float": float,
-                    "complex": complex,
-                    "str": str,
-                }[typ](lit)
-            )
+            "```{default}```".format(default=default)
+            if isinstance(lit, ast.AST)
+            else {
+                "bool": bool,
+                "int": int,
+                "float": float,
+                "complex": complex,
+                "str": str,
+            }[typ](lit)
         )
     elif default.isdecimal():
         default = int(default)

cdd/sqlalchemy/utils/emit_utils.py

@@ -38,6 +38,7 @@
 from json import dumps
 from operator import attrgetter, eq, methodcaller
 from os import path
+from platform import system
 from typing import Any, Dict, List, Optional
 
 import cdd.shared.ast_utils
@@ -78,7 +79,8 @@ def param_to_sqlalchemy_column_calls(name_param, include_name):
     :return: Iterable of elements in form of: `Column(…)`
     :rtype: ```Iterable[Call]```
     """
-    # if system() == "Darwin": print("param_to_sqlalchemy_column_calls::include_name:", include_name, ";")
+    if system() == "Darwin":
+        print("param_to_sqlalchemy_column_calls::include_name:", include_name, ";")
     name, _param = name_param
     del name_param
 

cdd/sqlalchemy/utils/shared_utils.py

@@ -87,12 +87,9 @@ def update_args_infer_typ_sqlalchemy(_param, args, name, nullable, x_typ_sql):
         parsed_typ: Call = cast(
             Call, cdd.shared.ast_utils.get_value(ast.parse(_param["typ"]).body[0])
         )
-        try:
-            assert (
-                parsed_typ.value.id == "Literal"
-            ), "Expected `Literal` got: {!r}".format(parsed_typ.value.id)
-        except AssertionError:
-            raise
+        assert parsed_typ.value.id == "Literal", "Expected `Literal` got: {!r}".format(
+            parsed_typ.value.id
+        )
         val = cdd.shared.ast_utils.get_value(parsed_typ.slice)
         (
             args.append(

cdd/tests/mocks/docstrings.py

@@ -500,22 +500,20 @@
 )
 docstring_google_pytorch_lbfgs_str: str = "\n".join(docstring_google_pytorch_lbfgs)
 
-docstring_google_args_str: str = """Args:
+docstring_google_str: str = (
+    """{docstring_header_str}
+Args:
   dataset_name (str): name of dataset. Defaults to "mnist"
   tfds_dir (str): directory to look for models in. Defaults to "~/tensorflow_datasets"
   K (Literal['np', 'tf']): backend engine, e.g., `np` or `tf`. Defaults to "np"
   as_numpy (Optional[bool]): Convert to numpy ndarrays
   data_loader_kwargs (Optional[dict]): pass this as arguments to data_loader function
-"""
-docstring_google_footer_return_str: str = """Returns:
+
+Returns:
   Union[Tuple[tf.data.Dataset, tf.data.Dataset], Tuple[np.ndarray, np.ndarray]]:
    Train and tests dataset splits. Defaults to (np.empty(0), np.empty(0))
-"""
-docstring_google_str: str = "\n".join(
-    (
-        docstring_header_str,
-        docstring_google_args_str,
-        docstring_google_footer_return_str,
+""".format(
+        docstring_header_str=docstring_header_str
     )
 )
 

cdd/tests/test_compound/test_exmod_utils.py

@@ -57,7 +57,6 @@ def test_emit_file_on_hierarchy(self) -> None:
         with patch(
             "cdd.compound.exmod_utils.EXMOD_OUT_STREAM", new_callable=StringIO
         ), TemporaryDirectory() as tempdir:
-            output_directory: str = path.join(tempdir, "haz")
             open(path.join(tempdir, INIT_FILENAME), "a").close()
             emit_file_on_hierarchy(
                 ("foo.bar", "foo_dir", ir),
@@ -66,13 +65,13 @@ def test_emit_file_on_hierarchy(self) -> None:
                 "",
                 True,
                 filesystem_layout="as_input",
-                output_directory=output_directory,
+                output_directory=tempdir,
                 first_output_directory=tempdir,
                 no_word_wrap=None,
                 dry_run=False,
                 extra_modules_to_all=None,
             )
-            self.assertTrue(path.isdir(output_directory))
+            self.assertTrue(path.isdir(tempdir))
 
     def test__emit_symbols_isfile_emit_filename_true(self) -> None:
         """Test `_emit_symbol` when `isfile_emit_filename is True`"""

cdd/tests/test_marshall_docstring.py

@@ -248,25 +248,6 @@ def test_from_docstring_google_str(self) -> None:
         _intermediate_repr_no_default_doc["doc"] = docstring_header_str
         self.assertDictEqual(ir, _intermediate_repr_no_default_doc)
 
-    def test_from_docstring_google_str_extra_after(self) -> None:
-        """
-        Tests whether `parse_docstring` produces `intermediate_repr_no_default_doc`  + "\n\n\ntrailer"
-              from `docstring_google_str` + "\n\n\ntrailer"
-        """
-        ir: IntermediateRepr = parse_docstring(
-            "{}\n\n\ntrailer".format(docstring_google_str)
-        )
-        _intermediate_repr_no_default_doc = deepcopy(
-            intermediate_repr_no_default_with_nones_doc
-        )
-        _intermediate_repr_no_default_doc["doc"] = "{0}\n\n\n\ntrailer".format(
-            docstring_header_str
-        )
-
-        self.assertDictEqual(ir, _intermediate_repr_no_default_doc)
-
-    maxDiff = None
-
     def test_from_docstring_google_keras_squared_hinge(self) -> None:
         """
         Tests whether `parse_docstring` produces the right IR

cdd/tests/test_shared/test_ast_utils.py

@@ -1011,39 +1011,6 @@ def test_param2ast_with_wrapped_default(self) -> None:
             ),
         )
 
-    def test_param2ast_with_simple_types(self) -> None:
-        """Check that `param2ast` behaves correctly with simple types"""
-        deque(
-            map(
-                lambda typ_res: run_ast_test(
-                    self,
-                    param2ast(
-                        ("zion", {"typ": typ_res[0], "default": NoneStr}),
-                    ),
-                    gold=AnnAssign(
-                        annotation=Name(
-                            typ_res[1], Load(), lineno=None, col_offset=None
-                        ),
-                        simple=1,
-                        target=Name("zion", Store(), lineno=None, col_offset=None),
-                        value=set_value(None),
-                        expr=None,
-                        expr_target=None,
-                        expr_annotation=None,
-                        col_offset=None,
-                        lineno=None,
-                    ),
-                ),
-                (
-                    ("Str", "str"),
-                    ("Constant", "object"),
-                    ("NameConstant", "object"),
-                    ("Num", "float"),
-                ),
-            ),
-            maxlen=0,
-        )
-
     def test_param2argparse_param_none_default(self) -> None:
         """
         Tests that param2argparse_param works to reparse the default

cdd/tests/test_sqlalchemy/test_emit_sqlalchemy_utils.py

@@ -337,34 +337,6 @@ def test_update_args_infer_typ_sqlalchemy_early_exit(self) -> None:
             (True, None),
         )
 
-    def test_update_args_infer_typ_sqlalchemy_list_struct(self) -> None:
-        """Tests that `update_args_infer_typ_sqlalchemy` behaves correctly on List[struct]"""
-        args = []
-        self.assertTupleEqual(
-            update_args_infer_typ_sqlalchemy(
-                {"typ": "List[struct]"},
-                args=args,
-                name="",
-                nullable=True,
-                x_typ_sql={},
-            ),
-            (True, None),
-        )
-        self.assertEqual(len(args), 1)
-        run_ast_test(
-            self,
-            args[0],
-            Call(
-                func=Name("ARRAY", Load(), lineno=None, col_offset=None),
-                args=[Name("JSON", Load(), lineno=None, col_offset=None)],
-                keywords=[],
-                expr=None,
-                expr_func=None,
-                lineno=None,
-                col_offset=None,
-            ),
-        )
-
     def test_update_with_imports_from_columns(self) -> None:
         """
         Tests basic `cdd.sqlalchemy.utils.emit_utils.update_with_imports_from_columns` usage