Make error handling more robust (#107).

- Create vendored version of openapi-pydantic-schema in `schema`.
  - Update to this projects quality standards.
  - Allow (ignore) extra keys when parsing schema
- Redo error handling to be much more robust so more pieces of the
generator can degrade gracefully instead of outright failing.

Author: dbanty

CHANGELOG.md

@@ -6,9 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 ## 0.5.0 - Unreleased
+### Changes
+- When encountering a problem, the generator will now differentiate between warnings (things it was able to skip past)
+    and errors (things which halt generation altogether).
+
+### Additions
+- The generator can now handle many more errors gracefully, skipping the things it can't generate and continuing
+    with the pieces it can.
+    
 ### Internal Changes
-- Switched OpenAPI document parsing to use 
-    [openapi-schema-pydantic](https://github.com/kuimono/openapi-schema-pydantic/pull/1) (#103)
+- Switched OpenAPI document parsing to use Pydantic based on a vendored version of 
+    [openapi-schema-pydantic](https://github.com/kuimono/openapi-schema-pydantic/) (#103).
+
 
 
 ## 0.4.2 - 2020-06-13

openapi_python_client/__init__.py

@@ -6,16 +6,16 @@
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Sequence
 
 import httpx
 import yaml
 from jinja2 import Environment, PackageLoader
 
 from openapi_python_client import utils
 
-from .openapi_parser import GeneratorData, import_string_from_reference
-from .openapi_parser.errors import MultipleParseError
+from .parser import GeneratorData, import_string_from_reference
+from .parser.errors import GeneratorError
 
 if sys.version_info.minor == 7:  # version did not exist in 3.7, need to use a backport
     from importlib_metadata import version  # type: ignore
@@ -37,22 +37,32 @@ def load_config(*, path: Path) -> None:
     config_data = yaml.safe_load(path.read_text())
 
     if "class_overrides" in config_data:
-        from .openapi_parser import reference
+        from .parser import reference
 
         for class_name, class_data in config_data["class_overrides"].items():
             reference.class_overrides[class_name] = reference.Reference(**class_data)
 
 
-def create_new_client(*, url: Optional[str], path: Optional[Path]) -> None:
-    """ Generate the client library """
+def create_new_client(*, url: Optional[str], path: Optional[Path]) -> Sequence[GeneratorError]:
+    """
+    Generate the client library
+
+    Returns:
+         A list containing any errors encountered when generating.
+    """
     project = _get_project_for_url_or_path(url=url, path=path)
-    project.build()
+    return project.build()
+
 
+def update_existing_client(*, url: Optional[str], path: Optional[Path]) -> Sequence[GeneratorError]:
+    """
+    Update an existing client library
 
-def update_existing_client(*, url: Optional[str], path: Optional[Path]) -> None:
-    """ Update an existing client library """
+    Returns:
+         A list containing any errors encountered when generating.
+    """
     project = _get_project_for_url_or_path(url=url, path=path)
-    project.update()
+    return project.update()
 
 
 def _get_json(*, url: Optional[str], path: Optional[Path]) -> Dict[str, Any]:
@@ -85,19 +95,22 @@ def __init__(self, *, openapi: GeneratorData) -> None:
 
         self.env.filters.update(self.TEMPLATE_FILTERS)
 
-    def build(self) -> None:
+    def build(self) -> Sequence[GeneratorError]:
         """ Create the project from templates """
 
         print(f"Generating {self.project_name}")
-        self.project_dir.mkdir()
+        try:
+            self.project_dir.mkdir()
+        except FileExistsError:
+            return [GeneratorError(detail="Directory already exists. Delete it or use the update command.")]
         self._create_package()
         self._build_metadata()
         self._build_models()
         self._build_api()
         self._reformat()
-        self._raise_errors()
+        return self._get_errors()
 
-    def update(self) -> None:
+    def update(self) -> Sequence[GeneratorError]:
         """ Update an existing project """
 
         if not self.package_dir.is_dir():
@@ -108,20 +121,20 @@ def update(self) -> None:
         self._build_models()
         self._build_api()
         self._reformat()
-        self._raise_errors()
+        return self._get_errors()
 
     def _reformat(self) -> None:
         subprocess.run(
             "isort .", cwd=self.project_dir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
         )
         subprocess.run("black .", cwd=self.project_dir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
-    def _raise_errors(self) -> None:
+    def _get_errors(self) -> Sequence[GeneratorError]:
         errors = []
         for collection in self.openapi.endpoint_collections_by_tag.values():
             errors.extend(collection.parse_errors)
-        if errors:
-            raise MultipleParseError(parse_errors=errors)
+        errors.extend(self.openapi.schemas.errors)
+        return errors
 
     def _create_package(self) -> None:
         self.package_dir.mkdir()
@@ -170,7 +183,7 @@ def _build_models(self) -> None:
         types_path.write_text(types_template.render())
 
         model_template = self.env.get_template("model.pyi")
-        for model in self.openapi.models.values():
+        for model in self.openapi.schemas.models.values():
             module_path = models_dir / f"{model.reference.module_name}.py"
             module_path.write_text(model_template.render(model=model))
             imports.append(import_string_from_reference(model.reference))

openapi_python_client/cli.py

@@ -1,11 +1,10 @@
 import pathlib
-from contextlib import contextmanager
 from pprint import pformat
-from typing import Generator, Optional
+from typing import Optional, Sequence
 
 import typer
 
-from openapi_python_client.openapi_parser.errors import MultipleParseError, ParseError
+from openapi_python_client.parser.errors import ErrorLevel, GeneratorError, ParseError
 
 app = typer.Typer()
 
@@ -42,35 +41,56 @@ def cli(
     pass
 
 
-def _print_parser_error(e: ParseError) -> None:
-    formatted_data = pformat(e.data)
-    typer.secho(e.header, bold=True, fg=typer.colors.BRIGHT_RED, err=True)
-    typer.secho(formatted_data, fg=typer.colors.RED, err=True)
-    if e.message:
-        typer.secho(e.message, fg=typer.colors.BRIGHT_RED, err=True)
-    gh_link = typer.style(
-        "https://github.com/triaxtec/openapi-python-client/issues/new/choose", fg=typer.colors.BRIGHT_BLUE
-    )
-    typer.secho(f"Please open an issue at {gh_link}", fg=typer.colors.RED, err=True)
+def _print_parser_error(e: GeneratorError, color: str) -> None:
+    typer.secho(e.header, bold=True, fg=color, err=True)
+    if e.detail:
+        typer.secho(e.detail, fg=color, err=True)
+
+    if isinstance(e, ParseError) and e.data is not None:
+        formatted_data = pformat(e.data)
+        typer.secho(formatted_data, fg=color, err=True)
+
     typer.secho()
 
 
-@contextmanager
-def handle_errors() -> Generator[None, None, None]:
+def handle_errors(errors: Sequence[GeneratorError]) -> None:
     """ Turn custom errors into formatted error messages """
-    try:
-        yield
-    except ParseError as e:
-        _print_parser_error(e)
-        raise typer.Exit(code=1)
-    except MultipleParseError as e:
-        typer.secho("MULTIPLE ERRORS WHILE PARSING:", underline=True, bold=True, fg=typer.colors.BRIGHT_RED, err=True)
-        for err in e.parse_errors:
-            _print_parser_error(err)
-        raise typer.Exit(code=1)
-    except FileExistsError:
-        typer.secho("Directory already exists. Delete it or use the update command.", fg=typer.colors.RED, err=True)
-        raise typer.Exit(code=1)
+    if len(errors) == 0:
+        return
+    color = typer.colors.YELLOW
+    for error in errors:
+        if error.level == ErrorLevel.ERROR:
+            typer.secho(
+                "Error(s) encountered while generating, client was not created",
+                underline=True,
+                bold=True,
+                fg=typer.colors.BRIGHT_RED,
+                err=True,
+            )
+            color = typer.colors.RED
+            break
+    else:
+        typer.secho(
+            "Warning(s) encountered while generating. Client was generated, but some pieces may be missing",
+            underline=True,
+            bold=True,
+            fg=typer.colors.BRIGHT_YELLOW,
+            err=True,
+        )
+
+    for err in errors:
+        _print_parser_error(err, color)
+
+    gh_link = typer.style(
+        "https://github.com/triaxtec/openapi-python-client/issues/new/choose", fg=typer.colors.BRIGHT_BLUE
+    )
+    typer.secho(
+        f"If you believe this was a mistake or this tool is missing a feature you need, "
+        f"please open an issue at {gh_link}",
+        fg=typer.colors.BLUE,
+        err=True,
+    )
+    raise typer.Exit(code=1)
 
 
 @app.command()
@@ -87,8 +107,8 @@ def generate(
     if url and path:
         typer.secho("Provide either --url or --path, not both", fg=typer.colors.RED)
         raise typer.Exit(code=1)
-    with handle_errors():
-        create_new_client(url=url, path=path)
+    errors = create_new_client(url=url, path=path)
+    handle_errors(errors)
 
 
 @app.command()
@@ -105,5 +125,6 @@ def update(
     if url and path:
         typer.secho("Provide either --url or --path, not both", fg=typer.colors.RED)
         raise typer.Exit(code=1)
-    with handle_errors():
-        update_existing_client(url=url, path=path)
+
+    errors = update_existing_client(url=url, path=path)
+    handle_errors(errors)

openapi_python_client/openapi_parser/errors.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+__all__ = ["GeneratorError", "ParseError", "PropertyError"]
+
+from pydantic import BaseModel
+
+
+class ErrorLevel(Enum):
+    """ The level of an error """
+
+    WARNING = "WARNING"  # Client is still generated but missing some pieces
+    ERROR = "ERROR"  # Client could not be generated
+
+
+@dataclass
+class GeneratorError:
+    """ Base data struct containing info on an error that occurred """
+
+    detail: Optional[str] = None
+    level: ErrorLevel = ErrorLevel.ERROR
+    header: str = "Unable to generate the client"
+
+
+@dataclass
+class ParseError(GeneratorError):
+    """ An error raised when there's a problem parsing an OpenAPI document """
+
+    level: ErrorLevel = ErrorLevel.WARNING
+    data: Optional[BaseModel] = None
+    header: str = "Unable to parse this part of your OpenAPI document: "
+
+
+@dataclass
+class PropertyError(ParseError):
+    """ Error raised when there's a problem creating a Property """
+
+    header = "Problem creating a Property: "