Avoid collisions between cases, enums, variants, and records of the same name by putting them in different modules.

Author: erikrose

fastly_compute/exceptions.py fastly_compute/exceptions_sketch.pyfastly_compute/exceptions.py renamed to fastly_compute/exceptions_sketch.py

@@ -19,13 +19,17 @@
 #
 # I want to avoid setattr and string repr of methods so IDEs have a chance. OTOH, IDEs don't give a crap about the exception wrapper; I'm not changing the signature as far as Python is concerned.
 
+from collections import defaultdict
 import json
+from pathlib import Path
 from subprocess import check_output
 import textwrap
 from typing import Any, Iterable, Self
 from types import NoneType
 
+
 WIT_DIR = "wit"
+PACKAGE = "fastly:compute@0.0.0-prerelease.0"
 
 
 class DocsHaver:
@@ -66,7 +70,7 @@ class Type(DocsHaver):
     """
 
     @classmethod
-    def from_id(cls, type_id: int | str | None, types_json: list[dict]) -> Self:
+    def from_id(cls, type_id: int | str | None, wit_json: list[dict]) -> Self:
         """Construct a type of the given index in the WIT's "types" key.
 
         If that type is an alias (which is the case when referencing a type from
@@ -78,30 +82,30 @@ def from_id(cls, type_id: int | str | None, types_json: list[dict]) -> Self:
         while True:
             if isinstance(type_id, str):
                 # It's a primitive.
-                return cls(type_id, type_id, types_json)
+                return cls(type_id, type_id, wit_json)
             elif isinstance(type_id, NoneType):
                 return NullType()
 
             # It's an int. Chase that down, including following type aliases.
-            current_type = types_json[type_id]
+            current_type = wit_json["types"][type_id]
             next_type = current_type["kind"].get("type")
             if next_type is None:
                 kind = only(current_type["kind"].keys())
                 class_ = KINDS_TO_CLASSES.get(kind, cls)
-                return class_(type_id, current_type, types_json)
+                return class_(type_id, current_type, wit_json)
             else:
                 # It's a pointer to a different tyoe.
                 type_id = next_type
 
-    def __init__(self, id: int | str, type_: dict | str, types_json: list[dict]):
+    def __init__(self, id: int | str, type_: dict | str, wit_json: list[dict]):
         """Private constructor. Use from_id() instead.
 
         Type instances compare and hash based on their IDs: their positions in
         the WIT's type array. Only non-alias type IDs occur in instances.
         """
         self._id: int | str = id
         self._type: str | dict[str] = type_
-        self._types = types_json
+        self._wit = wit_json
 
     def name(self) -> str:
         """Return the name of this type, in usual WIT kebab case."""
@@ -122,13 +126,17 @@ def __repr__(self):
     def has_cases(self):
         return False
 
+    def interface(self) -> "Interface":
+        """Return the interface where this type is defined."""
+        return Interface(self._wit["interfaces"][self._type["owner"]["interface"]], self._wit)
+
 
 class Result(Type):
     """A WIT ``result``"""
 
     def error_type(self):
         """Return the type of my error case."""
-        return self.from_id(self._type["kind"]["result"]["err"], self._types)
+        return self.from_id(self._type["kind"]["result"]["err"], self._wit)
 
 
 class NullType(Type):
@@ -174,9 +182,9 @@ def cases(self):
 
 
 class Function:
-    def __init__(self, function_json: dict, types_json: list[dict]):
+    def __init__(self, function_json: dict, wit_json: list[dict]):
         self._function = function_json
-        self._types = types_json
+        self._wit = wit_json
 
     def error_type_of_returned_result(self) -> Type | None:
         """If this Function returns a single ``result`` type, return the type of its error case.
@@ -188,30 +196,32 @@ def error_type_of_returned_result(self) -> Type | None:
         if num_returns > 1:
             raise NotImplementedError("Multi-value return isn't supported yet.")
         if num_returns == 1:
-            return_type = Type.from_id(returns[0]["type"], self._types)
+            return_type = Type.from_id(returns[0]["type"], self._wit)
             if isinstance(return_type, Result):
                 return return_type.error_type()
 
 
 class Interface:
-    def __init__(self, interface_json: dict[str, Any], types_json: list[dict]):
+    def __init__(self, interface_json: dict[str, Any], wit_json: list[dict]):
         self._interface = interface_json
-        self._types = types_json
+        self._wit = wit_json
+
+    def name(self) -> str:
+        return self._interface["name"]
 
     def functions(self) -> Iterable[Function]:
         for function in self._interface["functions"].values():
-            yield Function(function, self._types)
+            yield Function(function, self._wit)
 
 
 class Package:
-    def __init__(self, package_json: dict, interfaces_json: list[dict], types_json: list[dict]):
+    def __init__(self, package_json: dict, wit_json: list[dict]):
         self._package = package_json
-        self._interfaces = interfaces_json
-        self._types = types_json
+        self._wit = wit_json
 
     def interfaces(self) -> Iterable[Interface]:
         for interface_num in self._package["interfaces"].values():
-            yield Interface(self._interfaces[interface_num], self._types)
+            yield Interface(self._wit["interfaces"][interface_num], self._wit)
 
 
 class Wit:
@@ -231,7 +241,7 @@ def __init__(self, wit_json: dict[str, list[dict]]):
 
         :arg wit_json: The loaded JSON out of ``wasm-tools component wit wit/ --json``
         """
-        self._packages: dict[str, Package] = {p["name"]: Package(p, wit_json["interfaces"], wit_json["types"]) for p in wit_json["packages"]}
+        self._packages: dict[str, Package] = {p["name"]: Package(p, wit_json) for p in wit_json["packages"]}
 
     def package(self, name: str) -> Package:
         """Return a package of the given name, e.g.
@@ -240,10 +250,15 @@ def package(self, name: str) -> Package:
 
 
 def upper_camel(s: str):
-    """Convert lower-kebab case to upper camel case."""
+    """Convert lower-kebab case to UpperCamelCase."""
     return "".join(word.capitalize() for word in s.split('-'))
 
 
+def lower_snake(s: str):
+    """Convert lower-kebab case to lower_snake_case."""
+    return s.replace("-", "_")
+
+
 def indent(s: str):
     """Indent as for a docstring.
 
@@ -253,28 +268,60 @@ def indent(s: str):
     return textwrap.indent(s, "    ").strip()
 
 
-def generate_exception_classes(error_types: Iterable[Type]):
+def exception_code_tree(error_types: Iterable[Type]) -> dict[str, dict[str, str]]:
     """Generate Python exception classes we can map variant and enum cases to.
 
     Inherit the names and docstrings from the WIT. Create a common superclass
     for each type so you can catch the whole smear if you like.
+
+    :return: A dict of package names pointing to module names pointing to
+        contained code. For example, acl (from the interface name) -> acl_error
+        (from the enum name) -> class AclError(FastlyError)...
     """
-    ret = ""
+    # interface name -> module name -> code chunks:
+    code = defaultdict(lambda: defaultdict(str))
+
     for error_type in error_types:
-        error_class_name = upper_camel(error_type.name())
-        # Common superclass for exceptions based on the enum or variant's
-        # members. Also functions as the raised exception itself for records.
-        ret += (f'''class {error_class_name}(FastlyError):\n'''
-                f'''    """{error_type.docstring_or_pass()}"""\n\n\n''')
+        package = lower_snake(error_type.interface().name())
         if error_type.has_cases():  # It's an enum or variant.
-            for case in error_type.cases():
-                ret += (f'''class {upper_camel(case.name())}({error_class_name}):\n'''
-                        f'''    """{case.docstring_or_pass()}"""\n\n\n''')
-        elif not isinstance(error_type, Record):
+            module = lower_snake(error_type.name()) + ".py"
+        elif isinstance(error_type, Record):
+            module = "__init__.py"
+        else:
             raise NotImplementedError(
                 "Only variants, enums, and records are currently handled as "
                 "``result`` error types. Looks like it's time to support others!")
-    return ret
+
+        # Create package's empty __init__.py if not already there:
+        code[package]["__init__.py"]
+
+        error_class_name = upper_camel(error_type.name())
+        # Common superclass for exceptions based on the enum or variant's
+        # members. Or the raised exception itself for records.
+        code[package][module] += (
+            f'''class {error_class_name}(FastlyError):\n'''
+            f'''    """{error_type.docstring_or_pass()}"""\n\n\n''')
+        if error_type.has_cases():
+            # Insert enum or variant cases.
+            for case in error_type.cases():
+                code[package][module] += (
+                    f'''class {upper_camel(case.name())}({error_class_name}):\n'''
+                    f'''    """{case.docstring_or_pass()}"""\n\n\n''')
+    return code
+
+
+def write_files(tree: dict[str, dict[str, str]], base_folder: Path):
+    """Create filesystem artifacts mirroring a nested dict representing folders,
+    then files, then file contents.
+
+    Overwrite files that are mentioned in ``tree``, but don't delete anything else.
+    """
+    for folder, files in tree.items():
+        folder_path = base_folder / folder
+        folder_path.mkdir(parents=True, exist_ok=True)
+        for file, contents in files.items():
+            file_path = folder_path / file
+            file_path.write_text(contents)
 
 
 def main():
@@ -303,7 +350,7 @@ def main():
     exceptions_to_generate: dict[Type, bool] = {}
     functions_to_patch = []
 
-    for interface in wit.package("fastly:compute@0.0.0-prerelease.0").interfaces():
+    for interface in wit.package(PACKAGE).interfaces():
         for function in interface.functions():
             if error_type := function.error_type_of_returned_result():
                 if not isinstance(error_type, NullType):
@@ -319,9 +366,9 @@ def main():
                     # identifiable:
                     functions_to_patch.append((interface, function))
 
-    print(generate_exception_classes(exceptions_to_generate.keys()))
-    generate_function_patches(functions_to_patch)
-
+    write_files(exception_code_tree(exceptions_to_generate.keys()),
+                Path(__file__).parent.parent / "fastly_compute" / "exceptions")
+    #generate_function_patches(functions_to_patch)
 
 
 if __name__ == "__main__":