flinventory 0.3.0__py3-none-any.whl

flinventory/generate_labels.py

@@ -0,0 +1,214 @@
+#!/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
+import os.path
+from typing import cast
+
+try:
+    import treelib
+except ModuleNotFoundError:
+    print(
+        "module treelib not found. "
+        "Install it system-wide or create a conda environment "
+        "with the environment.yml named inventory."
+    )
+    import sys
+
+    sys.exit(1)
+
+from .box import BoxedThing
+from .signprinter_latex import SignPrinterLaTeX
+from . import inventory_io
+
+HEADER_MARKDOWN_THING_LIST = [
+    "---",
+    "classoption:",
+    "- twocolumn",
+    "geometry:",
+    "- margin=0.5cm",
+    "- bottom=1.5cm",
+    "---",
+    "",
+    "# Fahrradteile" "",
+]
+
+
+def add_arg_parsers(subparsers):
+    """Make a command-line argument parser as a child of parent_parser.
+
+    Supply information from command-line arguments.
+
+    Args:
+        subparsers: list of subparsers to add to. Type is private to argparse module.
+    """
+    parser = subparsers.add_parser(
+        "label",
+        description="""Create lists and signs for things in the inventory.
+
+        The output directory is created. If the outputfiles are
+        not directly in the output directory, the directories
+        where the output files are supposed to land must exist.
+
+        Output files overwrite existing files.
+        """,
+    )
+    parser.add_argument(
+        "-l",
+        "--list",
+        dest="list",
+        action="store_true",
+        help="Create pdf list. Uses LaTeX via pandoc, might take a bit longer.",
+    )
+    parser.add_argument(
+        "--signs",
+        action="store_true",
+        help="Create pdf signs as pdf. Uses LaTeX, might take a bit longer.",
+    )
+
+    parser.set_defaults(func=generate_labels)
+
+
+def get_markdown_list(things):
+    """Get markdown representation of thing list."""
+    # each item can appear several times since alternative names
+    # might not be unique: things can be similar.
+    # so for every thing we need a list of lines
+    lines = {}
+
+    def add_line(name: str, new_line: str):
+        if name in lines:
+            lines[name].append(new_line)
+        else:
+            lines[name] = [new_line]
+
+    for thing in things:
+        if thing.get("category", False):
+            continue
+        add_line(thing.best("name", backup="?"), thing.markdown_representation())
+        for alt_name, line in thing.alt_names_markdown().items():
+            add_line(alt_name, line)
+    markdown = "\n".join(
+        HEADER_MARKDOWN_THING_LIST
+        + [
+            line
+            for name in sorted(list(lines.keys()), key=str.lower)
+            for line in lines[name]
+        ]
+    )
+    return markdown
+
+
+def get_tree(things: inventory_io.Inventory) -> str:
+    """Create a simple tree structure visualizing the things."""
+    tree = treelib.Tree()
+    nodes = []
+    tree.create_node("Fahrrad", "fahrrad-0")
+    for thing in things:
+        name = str(thing.best("name", backup="?"))
+        parents = cast(tuple, thing.get("part_of", ["fahrrad"]))
+        for instance_nr, parent in enumerate(parents):
+            node_id = f"{things.get_id(thing)}-{instance_nr}"
+            # doesn't work well with categories that appear several times, whatever:
+            parent = parent + "-0"
+            nodes.append((name, node_id, parent))
+    delayed_nodes = []
+    inserted_node = True  # save if in previous run,
+    # some node got removed from the list of all nodes
+    while inserted_node:
+        logging.debug("Start insertion walkthrough")
+        inserted_node = False
+        for node in nodes:
+            try:
+                tree.create_node(node[0], node[1], node[2])
+            except treelib.exceptions.NodeIDAbsentError:
+                delayed_nodes.append(node)
+            except treelib.exceptions.DuplicatedNodeIdError as e:
+                logging.error(f"{node[1]} twice: {e}")
+                inserted_node = True
+            else:
+                inserted_node = True
+        nodes = delayed_nodes
+        delayed_nodes = []
+    if len(nodes) > 0:
+        logging.error("Remaining nodes:" + ", ".join((str(node) for node in nodes)))
+    return tree.show(stdout=False)
+
+
+def create_listpdf(markdown: str, pdffile):
+    """Create a pdf file that can be printed that lists all things.
+
+    Args:
+        markdown: path to markdown file that is converted
+        pdffile: path to created pdf file
+    """
+    markdown = markdown.replace("\u2640", "(weiblich)").replace("\u2642", "männlich")
+    pypandoc.convert_text(
+        markdown,
+        format="md",
+        to="pdf",
+        outputfile=pdffile,
+        extra_args=[
+            "-V",
+            "geometry:top=1cm,bottom=1cm,left=1cm,right=1.5cm",
+            "-V",
+            "classoption=twocolumn",
+        ],
+    )
+
+
+def generate_labels(options: argparse.Namespace):
+    """Create lists and signs based on command-line options.
+
+    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 list")
+    all_things: list[BoxedThing] = inventory_io.Inventory.from_json_files(
+        options.dataDirectory
+    )
+    with open(
+        os.path.join(options.output_dir, options.output_tree),
+        mode="w",
+        encoding="UTF-8",
+    ) as treefile:
+        logging.info("Start creating tree view.")
+        treefile.write(get_tree(all_things))
+    logging.info("Start creating markdownlist.")
+    markdown = get_markdown_list(all_things)
+    try:
+        with open(
+            list_md_file_name := os.path.join(
+                options.output_dir, options.output_mdlist
+            ),
+            mode="w",
+            encoding="UTF-8",
+        ) as mdfile:
+            mdfile.write(markdown)
+    except IOError as io_error:
+        logging.error(f"IOError {io_error} occured during writing list Markdown file.")
+        if options.list:
+            logging.info("Create no list pdf since the markdown file does not exist..")
+    else:
+        if options.list:
+            create_listpdf(
+                markdown,
+                os.path.join(options.output_dir, options.output_pdflist),
+            )
+    logging.info("Start creating sign LaTeX.")
+    sign_printer_latex = SignPrinterLaTeX(options)
+    if options.signs:
+        sign_printer_latex.create_signs_pdf(all_things)
+    else:
+        sign_printer_latex.save_signs_latex(all_things)

flinventory/inventory_io.py

@@ -0,0 +1,295 @@
+"""Utilities to read and write files for things, locations and signs.
+
+todo: consistency check for Inventory: schema and options all the same and things consistent?
+"""
+
+import random
+
+import argparse
+import logging
+import os
+from typing import Callable, Sequence, Iterable, Optional, Self, Any, Iterator
+
+from . import constant
+from .box import BoxedThing
+from .location import Schema
+
+
+class Inventory(list[BoxedThing]):
+    """A list of things with some metadata.
+
+    An inventory can be list as list[Thing] but also stores
+    the location schema as the attribute inventory.schema
+    (None if none given) and options.
+    """
+
+    def __init__(
+        self,
+        things: Iterable[BoxedThing],
+        directory: str = ".",
+        options: Optional[constant.Options] = None,
+        schema: Optional[Schema] = None,
+    ):
+        """Create an inventory from a list of things.
+
+        Args:
+            directory: where all options and data is stored
+            things: list of things in the inventory
+            options: inventory-wide options. Taken from first thing if not given
+            schema: inventory-wide location schema. Taken from first if not given
+        """
+        super().__init__(things)
+        self._directory = directory
+        os.makedirs(directory, exist_ok=True)
+        if schema is None:
+            if len(self) == 0:
+                self.schema = Schema({})
+            else:
+                self.schema = self[0].location.schema
+        else:
+            self.schema = schema
+
+        if options is None:
+            if len(self) == 0:
+                self.options = constant.Options({})
+            else:
+                self.options = self[0].options
+        else:
+            self.options = options
+
+    @classmethod
+    def from_json_files(cls, directory: str = ".") -> Self:
+        """Create an inventory from a directory with the structure described in the README.
+
+        Args:
+            directory: directory with options, schema and data
+        Returns:
+            an inventory of things including location and sign as members
+        """
+        options = constant.Options.from_file(directory)
+        schema = Schema.from_file(directory)
+        try:
+            thing_directories = os.listdir(
+                os.path.join(directory, constant.THING_DIRECTORY)
+            )
+        except (FileNotFoundError, NotADirectoryError):
+            boxed_things = []
+        else:
+            boxed_things = [
+                BoxedThing.from_files(
+                    directory=os.path.join(
+                        directory, constant.THING_DIRECTORY, thing_directory
+                    ),
+                    options=options,
+                    schema=schema,
+                )
+                for thing_directory in thing_directories
+            ]
+        return cls(
+            things=boxed_things, directory=directory, options=options, schema=schema
+        )
+
+    @property
+    def directory(self):
+        """The directory containing all options and data."""
+        return self._directory
+
+    def add_thing(self) -> BoxedThing:
+        """Add an empty thing.
+
+        Returns:
+            the newly created thing.
+        """
+        things_directory = os.path.join(self._directory, constant.THING_DIRECTORY)
+        os.makedirs(things_directory, exist_ok=True)
+        while (
+            thing_id := random.choices(
+                population="abcdefghijklmnopqrstuvwxyz0123456789", k=5
+            )
+        ) in os.listdir(things_directory):
+            pass
+        thing_directory = os.path.join(things_directory, thing_id)
+        new_thing = BoxedThing.from_files(thing_directory, self.options, self.schema)
+        self.append(new_thing)
+        return new_thing
+
+    def save(self) -> None:
+        """Save inventory files.
+
+        todo: save schema. Schema changes are not implemented in schema yet.
+        Saving schema would be possible with schema.json attribute.
+        todo: maybe save options
+        """
+        logger = logging.getLogger("save_things")
+        for thing in self:
+            thing.save()
+
+    def get_id(self, thing: BoxedThing) -> str:
+        """Return the id (which is its directory with the thing directory) of a thing.
+
+        Needs to be in the inventory because the things know where they are saved
+        but not how much of it is their id and how much is the general thing directory.
+        """
+        return os.path.relpath(
+            thing.directory, os.path.join(self._directory, constant.THING_DIRECTORY)
+        )
+
+    def get_by_id(self, thing_id: str) -> BoxedThing:
+        """Return thing by its id which is its directory name.
+
+        Todo: maybe make more efficient by caching the result in a dict
+        or making the inventory a dict [id: thing]
+
+        Raises:
+            KeyError: if no such thing exists
+        """
+        for thing in self:
+            if self.get_id(thing) == thing_id:
+                return thing
+        raise KeyError(thing_id)
+
+    def get_by_key(self, key, value) -> Iterator[BoxedThing]:
+        """Return all boxed things that have this value for this key.
+
+        For example useful for looking up thing by name: get_by_key(('name', 0), 'Nice thing')
+
+        If value is None, return all things without this value (or actually having
+        this value as None). (If this is trouble because you actually want to search
+        for None, the implementation could change but would be more verbose.)
+
+        Todo: maybe make more efficient by caching the result in a dict
+        """
+        return (box for box in self if box.thing.get(key, None) == value)
+
+    def get_by_best(self, key, value) -> Iterator[BoxedThing]:
+        """Return all boxed things that have this value as the 'best' option for this key.
+
+        Where 'best' is meant in the sense of DefaultedDict.best.
+
+        If value is None, return all things without this value (or actually having
+        this value as None). (If this is trouble because you actually want to search
+        for None, the implementation could change but would be more verbose.)
+
+        Todo: maybe make more efficient by caching the result in a dict
+        """
+        return (box for box in self if box.thing.best(key, backup=None) == value)
+
+
+def check_filename_types(filetypes: Sequence[str]) -> Callable[[str], str]:
+    """Create function that checks for being a simple file.
+
+    If it isn't of one of the specified file types, add the fileending."""
+
+    def check_file_type(path: str):
+        """Throw an error if path is not a simple file name."""
+        # basedir, _ = os.path.split(path)
+        # if len(basedir) > 0:
+        #     raise argparse.ArgumentTypeError("Only simple file name, not path allowed.")
+        _, ext = os.path.splitext(path)
+        if ext not in filetypes:
+            path += filetypes[0]
+        return path
+
+    return check_file_type
+
+
+def add_file_args(parser: argparse.ArgumentParser) -> None:
+    """Add arguments for file names for argument parser."""
+    parser.add_argument(
+        "dataDirectory",
+        default=".",
+        help="Directory with all the data. Structure of this directory is not changable.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        "-d",
+        default="out",
+        help=(
+            "Directory where to put the output "
+            "files like pdf list, sign html pages, LaTeX sign file"
+        ),
+    )
+    parser.add_argument(
+        "--output-mdlist",
+        "-md",
+        default="things.md",
+        help=(
+            "File where to write the list of things"
+            " as a markdown file. Relative to out "
+            "directory."
+        ),
+        type=check_filename_types([".md"]),
+    )
+    parser.add_argument(
+        "--output-tree",
+        "-tree",
+        default="things-tree.txt",
+        help=(
+            "File where to write the list of things"
+            " as a tree in a text file. Relative "
+            "to out directory."
+        ),
+        type=check_filename_types([".txt"]),
+    )
+    parser.add_argument(
+        "--output-pdflist",
+        "-pdf",
+        default="things.pdf",
+        help=(
+            "File where to write the list of things"
+            " as a pdf file. Relative to out "
+            "directory."
+        ),
+        type=check_filename_types([".pdf"]),
+    )
+    parser.add_argument(
+        "--output-signs",
+        "-s",
+        default="signs.html",
+        help=(
+            "File where to write the html page"
+            " with big signs,"
+            " relative to out directory."
+        ),
+        type=check_filename_types([".html", ".htm"]),
+    )
+    parser.add_argument(
+        "--output-signs-latex",
+        default="signs.tex",
+        help=(
+            "File where to write the LaTeX file"
+            " with big signs,"
+            " relative to out directory."
+        ),
+        type=check_filename_types([".tex"]),
+    )
+    parser.add_argument(
+        "--logfile",
+        "-lf",
+        default="things.log",
+        help=("Where to write the log file. Relative to the out directory."),
+        type=check_filename_types([".log"]),
+    )
+
+
+def dict_warn_on_duplicates(ordered_pairs):
+    """Log warning for duplicate keys.
+
+    Args:
+        ordered_pairs: list of key value pairs found in json
+    Returns:
+        dictionary with the given keys and values,
+        in case of duplicate keys, take the first
+    """
+    result_dict = {}
+    logger = logging.getLogger(__name__ + ".jsonImport")
+    for key, value in ordered_pairs:
+        if key in result_dict:
+            logger.warning(
+                f"duplicate key: {key} "
+                f"(first value (used): {result_dict[key]}, "
+                f"new value: {value})"
+            )
+        else:
+            result_dict[key] = value
+    return result_dict