restructure

comfyrecipes/builder.py

@@ -0,0 +1,157 @@
+from typing import Any, List, Set
+import os
+import json
+
+import yaml
+import jinja2
+import jsonschema
+import jsonschema.exceptions
+
+import comfyrecipes.parsing as parsing
+
+
+class Builder:
+    def __init__(self) -> None:
+        self.jinjaenv = jinja2.Environment(
+            loader=jinja2.FileSystemLoader(f"{os.path.dirname(__file__)}/templates"),
+            autoescape=jinja2.select_autoescape(),
+        )
+
+        def numprint(input: int) -> str:
+            out = str(input)
+            if out.endswith(".0"):
+                return out.split(".", maxsplit=1)[0]
+            return out
+
+        def amountprint(input: int) -> str:
+            out = numprint(input)
+            if out == "0.5":
+                return "1/2"
+            if out == "0.25":
+                return "1/4"
+            if out == "0.75":
+                return "3/4"
+            return out
+
+        self.jinjaenv.filters["numprint"] = numprint
+        self.jinjaenv.filters["amountprint"] = amountprint
+        self.ctx = parsing.Context()
+        # list of output files that will be built
+        self.outfiles: Set[str] = set()
+
+    def load_file(self, file: str) -> Any:
+        print(f"loading {file}")
+        with open(file, encoding="utf-8") as f:
+            txt = f.read()
+        if file.endswith(".json"):
+            return json.loads(txt)
+        return yaml.safe_load(txt)
+
+    def load_pkgfile(self, file: str) -> Any:
+        return self.load_file(f"{os.path.dirname(__file__)}/{file}")
+
+    def rendertemplate(
+        self, templatepath: str, format: str, file: str, dir: str, args: Any
+    ) -> None:
+        template = self.jinjaenv.get_template(templatepath)
+        print(f"rendering {file}")
+        outstr = template.render(args)
+
+        os.makedirs(f"{dir}/out/{format}", exist_ok=True)
+
+        with open(f"{dir}/out/{format}/{file}", "w", encoding="utf-8") as f:
+            f.write(outstr)
+        self.outfiles.add(file)
+
+    def load(self, dir: str) -> int:
+        if os.path.isfile(dir + "/settings.yaml"):
+            settingsdct = self.load_file(dir + "/settings.yaml")
+            settingsschema = self.load_pkgfile("schemas/settings.json")
+            self.ctx.load_settings(settingsdct, settingsschema)
+            retcode = self.ctx.issues.check()
+            if retcode != 0:
+                return 1
+
+        if os.path.isfile(dir + "/units.yaml"):
+            unitsdct = self.load_file(dir + "/units.yaml")
+            unitsschema = self.load_pkgfile("schemas/units.json")
+            self.ctx.load_units(unitsdct, unitsschema)
+            retcode = self.ctx.issues.check()
+            if retcode != 0:
+                return 1
+
+        if os.path.isfile(dir + "/ingredients.yaml"):
+            ingredientsdct = self.load_file(dir + "/ingredients.yaml")
+            ingredientsschema = self.load_pkgfile("schemas/ingredients.json")
+            self.ctx.load_ingredients(ingredientsdct, ingredientsschema)
+            retcode = self.ctx.issues.check()
+            if retcode != 0:
+                return 1
+
+        return 0
+
+    def run(self, dir: str) -> int:
+        files = []
+        for _, _, filesx in os.walk(dir + "/recipes"):
+            files = filesx
+            files.sort()
+
+        recipes: List[parsing.Recipe] = []
+        recipeschema = self.load_pkgfile("schemas/recipe.json")
+        for file in files:
+            if not file.endswith(".yaml"):
+                print(f"unknown extension of {file}")
+                continue
+            recipedct = self.load_file(dir + "/recipes/" + file)
+            jsonschema.validate(instance=recipedct, schema=recipeschema)
+            recipe = parsing.Recipe.from_dict(self.ctx, recipedct)
+            recipe.srcpath = file
+            recipe.outpath = file[:-5] + ".html"
+            if self.ctx.issues.check() != 0:
+                continue
+            recipes.append(recipe)
+
+        retcode = self.ctx.issues.check()
+        if retcode != 0:
+            return 1
+
+        self.rendertemplate(
+            templatepath="index.html",
+            format="html",
+            file="index.html",
+            dir=dir,
+            args={"recipes": recipes},
+        )
+        for recipe in recipes:
+            self.rendertemplate(
+                templatepath="recipe.html",
+                format="html",
+                file=recipe.outpath,
+                dir=dir,
+                args={"recipe": recipe},
+            )
+        return 0
+
+    def finish(self, dir: str) -> int:
+        files = set()
+        for _, _, filesx in os.walk(f"{dir}/out/html"):
+            files = set(filesx)
+
+        # files we did not generate, probably left by a previous run, but not valid anymore
+        extra_files = files - self.outfiles
+        for file in extra_files:
+            print(f"removing obsolete {file}")
+            os.remove(f"{dir}/out/html/{file}")
+        return 0
+
+    def build(self, path: str) -> int:
+        fcs = [self.load, self.run, self.finish]
+        for func in fcs:
+            try:
+                ret = func(path)
+                if ret != 0:
+                    return ret
+            except jsonschema.exceptions.ValidationError as e:
+                print("ERROR:", e)
+                return 1
+        return 0