flinventory 0.5.0__tar.gz → 0.6.0__tar.gz

{flinventory-0.5.0 → flinventory-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flinventory
-Version: 0.5.0
+Version: 0.6.0
 Summary: An inventory system for self-help repair shops
 Author-Email: flukx <flinventory-flukx@612211124.xyz>
 License: GPL3

{flinventory-0.5.0 → flinventory-0.6.0}/flinventory/generate_labels.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """Create a list of things to hang in the place with all the stuff (e.g. a bike shed)."""
 import logging
+
 import pypandoc
 
 import argparse
@@ -70,6 +71,16 @@ def add_arg_parsers(subparsers):
 
     parser.set_defaults(func=generate_labels)
 
+    parser_single_sign = subparsers.add_parser(
+        "single_sign", description="Create a single sign as svg."
+    )
+    parser_single_sign.add_argument(
+        "thing_id",
+        help="Thing id of the thing the sign is for. "
+        "This is the directory name of the thing.",
+    )
+    parser_single_sign.set_defaults(func=generate_single_sign_svg)
+
 
 def get_markdown_list(things):
     """Get markdown representation of thing list."""
@@ -212,3 +223,51 @@ def generate_labels(options: argparse.Namespace):
         sign_printer_latex.create_signs_pdf(all_things)
     else:
         sign_printer_latex.save_signs_latex(all_things)
+
+
+def generate_single_sign_svg(options: argparse.Namespace):
+    """Generate sign for a single thing, given by options.thing_id.
+
+    Args:
+        options: command line options given
+    """
+    try:
+        os.mkdir(options.output_dir)
+    except FileExistsError:
+        pass  # everything fine
+    logging.basicConfig(
+        filename=os.path.join(options.output_dir, options.logfile),
+        level=logging.DEBUG,
+        filemode="w",
+    )
+    logging.info("Create thing sign")
+    all_things = inventory_io.Inventory.from_json_files(options.dataDirectory)
+    logging.info("Start creating sign svg.")
+    try:
+        thing = all_things.get_by_id(options.thing_id)
+    except KeyError as id_not_found:
+        print("key error:")
+        print(id_not_found)
+        possible_things = list(all_things.get_by_best("name", options.thing_id))
+        if len(possible_things) == 1:
+            thing = possible_things[0]
+        else:
+            error_message = (
+                f"No thing with the id {options.thing_id} and 0 or >1 thing "
+                f"with this name. Do not do anything."
+            )
+            logging.error(error_message)
+            print(error_message)
+            return
+    sign_printer_latex = SignPrinterLaTeX(options)
+    svg_path = sign_printer_latex.create_sign_svg(thing)
+    if svg_path:
+        print(
+            f"sign svg created for {thing.best('name', backup="?")} "
+            f"({options.thing_id}): find it at {svg_path}"
+        )
+    else:
+        print(
+            f"Error at creating sign for {thing.best('name', backup="?")} "
+            f"({options.thing_id})."
+        )

{flinventory-0.5.0 → flinventory-0.6.0}/flinventory/location.py

@@ -283,6 +283,9 @@ class Location(dict[str, Value]):
         options: global options including the seperator
     """
 
+    EMPTY: list[Any] = [None, "", [], {}]
+    """Values that are considered empty and mean that nothing should be saved."""
+
     def __init__(
         self,
         schema: Schema,
@@ -356,11 +359,11 @@ class Location(dict[str, Value]):
     def __setitem__(self, level: str, value: Value) -> None:
         """Set one level info.
 
-        Or deletes it if it's None or "" or [] or {}
+        Or deletes it if it's None or "" or [] or {} (see EMPTY)
 
         Update internal info.
         """
-        if value in [None, "", [], {}]:
+        if value in self.EMPTY:
             if level in self:
                 del self[level]
         else:
@@ -406,7 +409,7 @@ class Location(dict[str, Value]):
         Sorts by schema hierarchy.
         """
         self._levels = self.schema.get_schema_hierarchy(self)
-        as_dict = {
+        as_dict: dict[str, Value] = {
             level.levelname: self._levels[index + 1].name
             for index, level in list(enumerate(self._levels))[:-1]
         }

{flinventory-0.5.0 → flinventory-0.6.0}/flinventory/signprinter_latex.py

@@ -9,7 +9,7 @@ import importlib.resources
 import os.path
 import logging
 import subprocess
-from typing import Union, Iterable
+from typing import Union, Iterable, Optional
 
 from .box import BoxedThing
 from .sign import Sign
@@ -18,7 +18,7 @@ from . import thingtemplate_latex
 
 TEMPLATE_PACKAGE = thingtemplate_latex
 TEMPLATE_PRE = "signlist-header.tex"
-    #importlib.resources.read_text("flinventory", "signlist-header.tex"))
+# importlib.resources.read_text("flinventory", "signlist-header.tex"))
 TEMPLATE_POST = "signlist-footer.tex"
 TEMPLATE_SIGN = "sign.tex"
 DUMMY_IMAGE = "dummyImage.jpg"
@@ -59,6 +59,7 @@ MAX_WIDTH = 18  # otherwise too wide for A4 page
 MAX_HEIGHT = 28  # otherwise too long for A4 page
 # maximum height for a sign [cm]
 
+
 def sanitize_latex_code(latex: Union[str, int, float]):
     """Make a string insertable into LaTeX code.
 
@@ -113,11 +114,14 @@ class SignPrinterLaTeX:
         # todo remove function by using importlib, which gives directly the text
         file_contents = []
         for filename in [TEMPLATE_PRE, TEMPLATE_SIGN, TEMPLATE_POST]:
-            file_contents.append(importlib.resources.read_text(TEMPLATE_PACKAGE, filename))
+            file_contents.append(
+                importlib.resources.read_text(TEMPLATE_PACKAGE, filename)
+            )
         return file_contents
 
-    def controlled_length(self, sign:Sign, key: str, backup: Union[int, float],
-                          max: Union[int, float]):
+    def controlled_length(
+        self, sign: Sign, key: str, backup: Union[int, float], max: Union[int, float]
+    ):
         """Get the value for the key if it exists and is a number and < max, otherwise backup."""
         value = sign.get(key, backup)
         try:
@@ -126,8 +130,10 @@ class SignPrinterLaTeX:
             self.logger(f"{key} {value} is not a number. Use {backup} {UNIT} instead.")
             return backup
         if value <= 0:
-            self.logger(f"{key} {value} is non-positive and therefore not a valid sign {key}. "
-                        f"Use {backup} {UNIT} instead.")
+            self.logger(
+                f"{key} {value} is non-positive and therefore not a valid sign {key}. "
+                f"Use {backup} {UNIT} instead."
+            )
             return backup
         if value == int(value):
             return min(int(value), max)
@@ -138,11 +144,15 @@ class SignPrinterLaTeX:
 
         In UNIT.
         """
-        return self.controlled_length(thing.sign, key='width', backup=STANDARD_WIDTH, max=MAX_WIDTH)
+        return self.controlled_length(
+            thing.sign, key="width", backup=STANDARD_WIDTH, max=MAX_WIDTH
+        )
 
     def height(self, thing: BoxedThing) -> Union[int, float]:
         """Get the height of the sign of a boxed thing, using backup and max size."""
-        return self.controlled_length(thing.sign, key='height', backup=STANDARD_HEIGHT, max=MAX_HEIGHT)
+        return self.controlled_length(
+            thing.sign, key="height", backup=STANDARD_HEIGHT, max=MAX_HEIGHT
+        )
 
     def if_use_landscape_template(self, thing: BoxedThing):
         """Return if we want to use the landscape template for this thing.
@@ -152,7 +162,7 @@ class SignPrinterLaTeX:
         than high.
         """
         try:
-            return thing.sign.get('landscape')
+            return thing.sign.get("landscape")
         except KeyError:
             try:
                 return self.width(thing) >= self.width(thing) * LANDSCAPE_MIN_RATIO
@@ -180,11 +190,11 @@ class SignPrinterLaTeX:
         width = self.width(thing)
         height = self.height(thing)
         used_width = width - height  # that is approximately the part the image uses
-        german = thing.sign.get(('name', 0), '')
-        english = thing.sign.get(('name', 1), '')
+        german = thing.sign.get(("name", 0), "")
+        english = thing.sign.get(("name", 1), "")
         german_expected_width_at_standard = len(german) * STANDARD_LETTER_LENGTH
         german_max_by_width = (
-                STANDARD_FONT_SIZE_GERMAN * used_width / german_expected_width_at_standard
+            STANDARD_FONT_SIZE_GERMAN * used_width / german_expected_width_at_standard
         )
         german_max_by_height = (
             height
@@ -193,10 +203,10 @@ class SignPrinterLaTeX:
             * GERMAN_TO_ENGLISH_SHARE
         )
         english_expected_width_at_standard = (
-                len(english)
-                * STANDARD_LETTER_LENGTH
-                * STANDARD_FONTSIZE_ENGLISH
-                / STANDARD_FONT_SIZE_GERMAN
+            len(english)
+            * STANDARD_LETTER_LENGTH
+            * STANDARD_FONTSIZE_ENGLISH
+            / STANDARD_FONT_SIZE_GERMAN
         )
         english_max_by_width = (
             STANDARD_FONTSIZE_ENGLISH * used_width / english_expected_width_at_standard
@@ -218,8 +228,8 @@ class SignPrinterLaTeX:
         """
         # use german and english as aliases for primary and secondary language
         # because it's easier to read
-        german = thing.get(('name', 0), '')
-        english = thing.get(('name', 1), '')
+        german = thing.get(("name", 0), "")
+        english = thing.get(("name", 1), "")
         german_words = german.replace("-", "- ").split() or [" "]
         english_words = english.replace("-", " ").split() or [" "]
         # ignore cases with more than 2 lines, should be considered by hand
@@ -257,23 +267,23 @@ class SignPrinterLaTeX:
             )
             german_expected_width_at_standard = german_length * STANDARD_LETTER_LENGTH
             german_max_by_width = (
-                    STANDARD_FONT_SIZE_GERMAN * width / german_expected_width_at_standard
+                STANDARD_FONT_SIZE_GERMAN * width / german_expected_width_at_standard
             )
             text_height = height * (
                 1 if height < MINIMAL_HEIGHT_FOR_IMAGE else IMAGE_SHARE
             )
             german_max_by_height = (
-                    STANDARD_FONT_SIZE_GERMAN
-                    * text_height
-                    / STANDARD_LETTER_HEIGHT
-                    / (german_number_lines * GERMAN_TO_ENGLISH_SHARE + english_number_lines)
-                    * GERMAN_TO_ENGLISH_SHARE
+                STANDARD_FONT_SIZE_GERMAN
+                * text_height
+                / STANDARD_LETTER_HEIGHT
+                / (german_number_lines * GERMAN_TO_ENGLISH_SHARE + english_number_lines)
+                * GERMAN_TO_ENGLISH_SHARE
             )
             english_expected_width_at_standard = (
-                    english_length
-                    * STANDARD_LETTER_LENGTH
-                    * STANDARD_FONTSIZE_ENGLISH
-                    / STANDARD_FONT_SIZE_GERMAN
+                english_length
+                * STANDARD_LETTER_LENGTH
+                * STANDARD_FONTSIZE_ENGLISH
+                / STANDARD_FONT_SIZE_GERMAN
             )
             # in factor size compared to normal size
             english_max_by_width = (
@@ -324,19 +334,34 @@ class SignPrinterLaTeX:
         Returns:
             (german font size, english font size)
         """
-        default_german_font_size, default_english_font_size = self.guess_font_size(thing)
-        german_font_size = thing.sign.get(('fontsize', 0), default_german_font_size)
-        english_font_size = thing.sign.get(('fontsize', 1), default_english_font_size)
+        default_german_font_size, default_english_font_size = self.guess_font_size(
+            thing
+        )
+        german_font_size = thing.sign.get(("fontsize", 0), default_german_font_size)
+        english_font_size = thing.sign.get(("fontsize", 1), default_english_font_size)
         logging.info(
             f"{thing.best('name')} font factor: (de) {german_font_size} (en) {english_font_size}"
         )
         return german_font_size, english_font_size
 
-    def create_latex(self, things: Iterable[BoxedThing]):
+    def create_latex_single_sign(self, thing: BoxedThing) -> str:
+        """Create latex code (as str) that shows one sign in a minimal document."""
+        return "\n".join(
+            (
+                r"\documentclass{standalone}",
+                *(self.pre.splitlines()[2:]),
+                self.create_sign(thing),
+                self.post,
+            )
+        )
+
+    def create_latex(self, things: Iterable[BoxedThing]) -> str:
         """Create latex code (as str) that shows all signs.
 
         Arguments:
             things: list of things to be described
+        Return:
+            latex code with document with all signs that should be printed
         """
         content_latex = [self.pre]
         current_line_filled_width = 0
@@ -367,8 +392,8 @@ class SignPrinterLaTeX:
             imageheight
             location
         """
-        german = thing.sign.get(('name', 0), '')
-        english = thing.sign.get(('name', 1), '')
+        german = thing.sign.get(("name", 0), "")
+        english = thing.sign.get(("name", 1), "")
 
         width = self.width(thing)
         height = self.height(thing)
@@ -382,9 +407,7 @@ class SignPrinterLaTeX:
         }
 
         if not insertions["location"]:  # empty string
-            logging.warning(
-                f"Print sign for {german} ({english}) without location."
-            )
+            logging.warning(f"Print sign for {german} ({english}) without location.")
 
         # todo: make image height configurable
         if height < MINIMAL_HEIGHT_FOR_IMAGE:
@@ -397,10 +420,7 @@ class SignPrinterLaTeX:
         # at first only portrait sign, landscape sign can be implemented later
         # if self.if_use_landscape_template(thing):  # would need different condition
         if image_path := thing.thing.image_path():  # not None or ""
-            rel_path_to_image = os.path.relpath(
-                image_path,
-                self.output_dir
-            )
+            rel_path_to_image = os.path.relpath(image_path, self.output_dir)
             insertions["imagepath"] = rel_path_to_image
         else:
             if insertions["imageheight"] > 0:
@@ -414,15 +434,18 @@ class SignPrinterLaTeX:
             except FileExistsError:
                 pass
             else:
-                dummy_image = importlib.resources.read_binary(TEMPLATE_PACKAGE, DUMMY_IMAGE)
+                dummy_image = importlib.resources.read_binary(
+                    TEMPLATE_PACKAGE, DUMMY_IMAGE
+                )
                 with image_file:
                     image_file.write(dummy_image)
         font_sizes = self.get_font_size(thing)
         insertions["textscalePrimary"] = font_sizes[0]  # /12
         insertions["textscaleSecondary"] = font_sizes[1]  # /12
 
-        insertions["locationShiftDown"] = thing.sign.get('location_shift_down',
-                                                         STANDARD_LOCATION_SHIFT_DOWN)
+        insertions["locationShiftDown"] = thing.sign.get(
+            "location_shift_down", STANDARD_LOCATION_SHIFT_DOWN
+        )
         return insertions
 
     def create_sign(self, thing):
@@ -444,7 +467,7 @@ class SignPrinterLaTeX:
         Arguments:
             things: list of things to visualize
         Returns:
-            path to created file
+            path to created file. None in case of error.
         """
         things.sort(key=lambda t: self.height(t))
         file_signs = os.path.join(self.output_dir, self.signs_file)
@@ -456,16 +479,103 @@ class SignPrinterLaTeX:
     def create_signs_pdf(self, things: list[BoxedThing]):
         """Create a pdf and latex files with signs."""
         self.save_signs_latex(things)
-        latex = subprocess.run(['latexmk', self.signs_file,
-                                f'-aux-directory={AUX_DIR}',
-                                "-pdf"],
-                               cwd=self.output_dir,
-                               capture_output=True,
-                               text=True)  # text=True makes output a str instead of bytes
-        with open(os.path.join(self.output_dir, AUX_DIR, 'latex_output.txt'), mode="w") as stdout_file:
+        latex = subprocess.run(
+            ["latexmk", self.signs_file, f"-aux-directory={AUX_DIR}", "-pdf"],
+            cwd=self.output_dir,
+            capture_output=True,
+            text=True,
+        )  # text=True makes output a str instead of bytes
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, "latex_output.txt"), mode="w"
+        ) as stdout_file:
+            stdout_file.write(latex.stdout)
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, "latex_error.txt"), mode="w"
+        ) as stderr_file:
+            stderr_file.write(latex.stderr)
+        if latex.returncode != 0:
+            print(
+                f"Latex finished with returncode {latex.returncode}."
+                f"Check in {os.path.join(self.output_dir, AUX_DIR)} for details."
+            )
+
+    def create_sign_svg(self, thing: BoxedThing) -> Optional[str]:
+        """Create a svg from a pdf with a sign for this thing.
+
+        Args:
+            thing: the thing which sign should be created
+        Returns:
+            path of the created svg file. None if error
+        """
+        tex = self.create_latex_single_sign(thing)
+        tex_hash = str(abs(hash(tex)))
+        file_tex = tex_hash + ".tex"
+        path_tex = os.path.join(self.output_dir, tex_hash + ".tex")
+        file_pdf = tex_hash + ".pdf"
+        path_pdf = os.path.join(self.output_dir, file_pdf)
+        file_svg = tex_hash + ".svg"
+        path_svg = os.path.join(self.output_dir, file_svg)
+        if os.path.isfile(path_tex) and os.path.isfile(path_svg):
+            self.logger(f"Do not regenerate {tex_hash}.")
+            return file_svg
+        with open(path_tex, mode="w") as file_tex_f:
+            file_tex_f.write(tex)
+        latex = subprocess.run(
+            ["latexmk", file_tex, f"-aux-directory={AUX_DIR}", "-pdf"],
+            cwd=self.output_dir,
+            capture_output=True,
+            text=True,
+        )  # text=True makes output a str instead of bytes
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, f"latex_output_{tex_hash}.txt"),
+            mode="w",
+        ) as stdout_file:
             stdout_file.write(latex.stdout)
-        with open(os.path.join(self.output_dir, AUX_DIR, 'latex_error.txt'), mode="w") as stderr_file:
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, f"latex_error.{tex_hash}.txt"),
+            mode="w",
+        ) as stderr_file:
             stderr_file.write(latex.stderr)
         if latex.returncode != 0:
-            print(f"Latex finished with returncode {latex.returncode}."
-                  f"Check in {os.path.join(self.output_dir, AUX_DIR)} for details.")
+            error_message = (
+                f"Latex for {thing.best('name', backup=tex_hash)} "
+                f"finished with returncode {latex.returncode}."
+                f"Check in {os.path.join(self.output_dir, AUX_DIR)} ({tex_hash}) for details."
+            )
+            self.logger.error(error_message)
+            print(error_message)
+            return None
+        svg = subprocess.run(
+            ["pdf2svg", path_pdf, path_svg],
+            capture_output=True,
+            text=True,
+        )  # text=True makes output a str instead of bytes
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, f"svg_output_{tex_hash}.txt"),
+            mode="w",
+        ) as stdout_file:
+            stdout_file.write(svg.stdout)
+        with open(
+            os.path.join(self.output_dir, AUX_DIR, f"svg_error.{tex_hash}.txt"),
+            mode="w",
+        ) as stderr_file:
+            stderr_file.write(svg.stderr)
+        if svg.returncode != 0:
+            error_message = (
+                f"svg for {thing.best('name', backup=tex_hash)} "
+                f"finished with returncode {svg.returncode}."
+                f"Check in {os.path.join(self.output_dir, tex_hash)}* for details."
+            )
+            self.logger.error(error_message)
+            print(error_message)
+            return None
+        if os.path.isfile(path_svg):
+            return path_svg
+        error_message = (
+            f"svg for {thing.best('name', backup=tex_hash)} "
+            f"finished with returncode 0 but the svg was not created. "
+            f"Check in {os.path.join(self.output_dir, tex_hash)}* for details."
+        )
+        self.logger.error(error_message)
+        print(error_message)
+        return None

{flinventory-0.5.0 → flinventory-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flinventory"
-version = "0.5.0"
+version = "0.6.0"
 description = "An inventory system for self-help repair shops"
 authors = [
     { name = "flukx", email = "flinventory-flukx@612211124.xyz" },