flinventory 2.2.3__tar.gz → 2.3.1__tar.gz

{flinventory-2.2.3 → flinventory-2.3.1}/PKG-INFO

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

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/__init__.py

@@ -6,3 +6,4 @@ from .defaulted_data import DefaultedDict
 from .constant import Options
 from .thing import Thing
 from .labelprinter_typst import LabelPrinter
+from .datacleanup import add_printed

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/constant.py

@@ -4,6 +4,7 @@
 By extracting it into a file that is not importing any other one,
 this can be imported everywhere without circular import problem.
 """
+
 import os.path
 import pathlib
 
@@ -161,14 +162,17 @@ class Options:
 
     def __init__(self, options: dict[str, Any]):
         """Create options from content of option file."""
-        self.languages = options.get("languages", ["de", "en"])
-        if isinstance(self.languages, str):
-            self.languages = [self.languages]
-        if not isinstance(self.languages, list):
+        languages = options.get("languages", ["de", "en"])
+        if isinstance(languages, str):
+            self.languages: list[str] = [languages]
+        elif not isinstance(languages, list) or any(
+            not isinstance(language, str) for language in languages
+        ):
             raise ValueError(
                 "Language codes must be a list of strings of "
                 "valid language codes or a single valid language code."
             )
+        self.languages = languages
         for language in self.languages:
             if language not in VALID_LANGUAGES:
                 raise ValueError(

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/datacleanup.py

@@ -8,6 +8,7 @@ import json
 import os
 import logging
 import string
+from typing import Optional
 
 import yaml
 
@@ -73,7 +74,7 @@ def add_arg_parsers(subparsers):
             + " are not printed next time."
         ),
     )
-    parser_printed.set_defaults(func=add_printed)
+    parser_printed.set_defaults(func=add_printed_from_args)
 
     parser_shortcutreplacement = subparsers.add_parser(
         "shortcut",
@@ -114,7 +115,7 @@ def add_arg_parsers(subparsers):
         ),
     )
     parser_levelname.add_argument("levelname", help="The new levelname.")
-    parser_levelname.set_defaults(func=set_levelname)
+    parser_levelname.set_defaults(func=set_levelname_from_args)
 
     parser_schemaname = subparsers.add_parser(
         "setSchemaname", description="Set the name for a location schema."
@@ -131,10 +132,35 @@ def add_arg_parsers(subparsers):
         ),
     )
     parser_schemaname.add_argument("name", help="The new name.")
-    parser_schemaname.set_defaults(func=set_schema_name)
+    parser_schemaname.set_defaults(func=set_schema_name_from_args)
 
 
-def get_schema(args) -> tuple[location.Schema, inventory_io.Inventory]:
+def get_schema_from_args(
+    args,
+) -> tuple[location.Schema, inventory_io.Inventory]:
+    """Wrapper for get_schema based on command-line arguments.
+
+    Args:
+        args.level: see level_spec in get_schema
+        args.directory: directory of the inventory data
+    Returns:
+        a schema and its surrounding inventory.
+    Raises:
+        ValueError: if get_schema raises. Error is printed.
+    """
+    level_spec = args.level
+    if not level_spec:
+        print("No level specified.")
+        return
+    inventory = inventory_io.Inventory.from_json_files(directory=args.dataDirectory)
+    try:
+        return get_schema(inventory, args), inventory
+    except ValueError as wrong_spec:
+        print(wrong_spec.args[0])
+        return
+
+
+def get_schema(inventory: inventory_io.Inventory, level_spec: str) -> location.Schema:
     """Get a schema in the inventory.
 
     Args:
@@ -146,60 +172,47 @@ def get_schema(args) -> tuple[location.Schema, inventory_io.Inventory]:
         args.directory: directory of the inventory data
     Returns:
         a schema and its surrounding inventory
+    Raises:
+        ValueError: if the level_spec was invalid. Exception.args[0] contains error message
     """
-    level_spec = args.level
-    if not level_spec:
-        print("No level specified.")
-        return
-    inventory = inventory_io.Inventory.from_json_files(directory=args.dataDirectory)
     separator = level_spec[0]
     if separator in string.digits + string.ascii_letters + " ":
-        print(
+        raise ValueError(
             "Probably separator missing as first character. Use non-digit, non-letter, non-space"
         )
-        return
     schema = inventory.schema
     for schema_name in level_spec.split(separator)[1:]:
         print(
             f"debug: Currently at schema {schema.name if not schema.is_default() else '<default>'}"
         )
         if schema_name:
-            print(f"choose subschema {schema_name}")
+            print(f"debug: choose subschema {schema_name}")
             schema = schema.get_subschema(schema_name)
         else:
-            print("choose sub schema default")
+            print("debug: choose sub schema default")
             schema = schema.sub_schema_default
-            print(schema)
-    return schema, inventory
+            print("debug", schema)
+    return schema
 
 
-def set_levelname(args):
+def set_levelname_from_args(args):
     """Set the levelname of one location schema."""
     new_levelname = args.levelname
-    schema, inventory = get_schema(args)
-    try:
-        print(
-            f"Change level name of {args.level} from {schema.levelname} to {new_levelname}."
-        )
-    except location.InvalidLocation:
-        print(f"Set level name of {args.level} from nothing to {new_levelname}.")
-    schema.levelname = new_levelname
-    inventory.save()
+    schema, inventory = get_schema_from_args(args)
+    inventory.set_levelname(schema, new_levelname)
 
 
-def set_schema_name(args):
-    """Set the same of a schema.
+def set_schema_name_from_args(args):
+    """Set the name of a schema based on comand-line arguments.
 
     Fails on default schemas.
+
+    Raises:
+        ValueError: if level_spec is invalid
+        ValueError: if new name is empty except for whitespace
     """
-    new_name = args.name
-    schema, inventory = get_schema(args)
-    if schema.is_default():
-        print(f"Cannot change name of default schema {args.level}")
-        return
-    print(f"Change name of {args.level} from {schema.name} to {new_name}")
-    schema.name = new_name
-    inventory.save()
+    schema, inventory = get_schema_from_args(args)
+    inventory.set_schema_name(schema, args.name)
 
 
 def example_action(args):
@@ -267,14 +280,15 @@ def use_ids(args):
     things.save()
 
 
-def add_printed(args):
-    """Add to all things the attribute printed=True."""
+def add_printed_from_args(args):
+    """Add to all things that would be printed the attribute printed=True. Read invetory from files."""
+    add_printed(inventory_io.Inventory.from_json_files(directory=args.dataDirectory))
+
+
+def add_printed(inventory: inventory_io.Inventory):
+    """Add to all things that would be printed the attribute printed=True."""
     things = (
-        labelprinter_typst.LabelPrinter()
-        .sign_things_to_be_printed(
-            inventory_io.Inventory.from_json_files(directory=args.dataDirectory)
-        )
-        .keys()
+        labelprinter_typst.LabelPrinter().sign_things_to_be_printed(inventory).keys()
     )
     for thing in things:
         thing.sign["printed"] = True

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/defaulted_data.py

@@ -22,7 +22,9 @@ from typing import Any, Iterable, Union, Iterator, cast, Callable
 from . import constant
 
 IMMUTABLE_TYPES = (str, int, float, bool, type(None))
-Immutable = Union[*IMMUTABLE_TYPES]
+Immutable = Union[
+    str, int, float, bool, type(None)
+]  # *IMMUTABLE_TYPES was not accepted
 Key = Union[str, tuple[str, str]]
 """Type of keys of DefaultedDict"""
 Value = Union[Immutable, list[Immutable]]

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/generate_labels.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """Create a list of things to hang in the place with all the stuff (e.g. a bike shed)."""
+
 import importlib.resources
 import json
 
@@ -9,11 +10,11 @@ import pathlib
 import argparse
 import os.path
 import typst
-from typing import cast, Union, Literal
+from typing import cast, Union, Literal, TypeVar
 import treelib
 
 from .box import BoxedThing
-from . import inventory_io, labelprinter_typst, thingtemplate_typst
+from . import inventory_io, labelprinter_typst, thingtemplate_typst, constant
 
 
 def add_arg_parsers(subparsers):
@@ -49,9 +50,22 @@ def add_arg_parsers(subparsers):
     parser_single_label.set_defaults(func=generate_single_label_svg)
 
 
-def get_thing_list_data(things: inventory_io.Inventory) -> dict[str, str]:
+def get_thing_list_data(
+    things: inventory_io.Inventory,
+    languages: list[str] | None = None,
+    alternatives: bool = True,
+    also_without_location: bool = False,
+) -> dict[str, str]:
     """Get list[dict] representation of thing list.
 
+    Args:
+        things: inventory with listed things
+        languages: None for all languages, otherwise list of languages of thing names printed
+            Note that this option excludes things with missing names in some languages
+        alternatives: whether to list all alternative names.
+            Makes the list much longer but also more useful.
+        also_without_location: whether to include things that have no box.
+            This makes the list longer.
     Returns:
         list of dicts. Each dict has "name" and "id", most have "where",
         many have "name_alt".
@@ -62,6 +76,18 @@ def get_thing_list_data(things: inventory_io.Inventory) -> dict[str, str]:
     lines: dict[str, list[dict[str, str | None]]] = {}
 
     def add_line(front_name: str, new_line: dict[str, str | None]):
+        """Add a line to the lines dict.
+
+        Do not add the line if no "where" is contained in new_line and
+        also_without_location is False.
+
+        Args:
+            front_name: string to sort by: what the reader looks for
+            new_line: all data for this line on which the typst formatting
+                is building on
+        """
+        if new_line["where"] is None and not also_without_location:
+            return
         if "where" in new_line and not new_line["where"]:
             del new_line["where"]
         if front_name in lines:
@@ -69,10 +95,18 @@ def get_thing_list_data(things: inventory_io.Inventory) -> dict[str, str]:
         else:
             lines[front_name] = [new_line]
 
+    N = TypeVar("N")
+
+    def filter_language(name_dict: dict[str, N]) -> dict[str, N]:
+        """Only include keys, values which are in languages."""
+        if languages is None:
+            return name_dict
+        return {key: value for key, value in name_dict.items() if key in languages}
+
     for thing in things:
         if thing.get("category", False):
             continue
-        for name in thing.get("name", {}).values():
+        for name in filter_language(thing.get("name", {})).values():
             add_line(
                 name,
                 {
@@ -81,7 +115,9 @@ def get_thing_list_data(things: inventory_io.Inventory) -> dict[str, str]:
                     "where": thing.where if thing.location else None,
                 },
             )
-        for lang, names_alt in thing.get("name_alt", {}).items():
+        if not alternatives:
+            continue
+        for lang, names_alt in filter_language(thing.get("name_alt", {})).items():
             logging.debug("f{(lang, names_alt)=}")
             for name_alt in names_alt:
                 add_line(
@@ -96,7 +132,7 @@ def get_thing_list_data(things: inventory_io.Inventory) -> dict[str, str]:
                     },
                 )
     return {
-        "title": things.schema.name,
+        "title": str(things.schema.name),
         "data": json.dumps(
             [
                 line
@@ -218,11 +254,26 @@ def generate_labels(options: argparse.Namespace):
         logging.info("Start creating tree view.")
         treefile.write(get_tree(all_things))
 
-    logging.getLogger("generateLabels").info("Start creating thing list.")
-    create_listpdf(
-        get_thing_list_data(all_things),
-        options.output_dir / options.output_list,
-    )
+    logging.getLogger("generateLabels").info("Start creating thing lists.")
+    list_path = options.output_dir / options.output_list
+    for language in [None] + all_things.options.languages:
+        for alternatives in [True, False]:
+            for without_location in [True, False]:
+                create_listpdf(
+                    get_thing_list_data(
+                        all_things,
+                        languages=None if language is None else [language],
+                        alternatives=alternatives,
+                        also_without_location=without_location,
+                    ),
+                    list_path.with_name(
+                        options.output_list.stem
+                        + (f"_{language}" if language else "")
+                        + ("_onlyExisting" if not without_location else "")
+                        + ("_onlyPrimaryNames" if not alternatives else "")
+                        + options.output_list.suffix
+                    ),
+                )
 
     logging.info("Start creating label pdf.")
     labelprinter_typst.LabelPrinter().create_labels(

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/inventory_io.py

@@ -13,7 +13,7 @@ from typing import Callable, Sequence, Iterable, Optional, Self, Iterator, cast
 
 from . import constant
 from .box import BoxedThing
-from .location import Schema
+from .location import Schema, InvalidLocation
 
 
 class Inventory(list[BoxedThing]):
@@ -238,6 +238,64 @@ class Inventory(list[BoxedThing]):
 
         return supers.difference({thing})
 
+    def set_levelname(self, schema: Schema, new_levelname: str):
+        """Set the levelname of one location schema.
+
+        Strip off whitespace.
+
+        Empty levelname raises ValueError if sub schemas exist.
+        Otherwise, it removes the possibility of this schema having subschemas.
+
+        Save the changes to disk.
+
+        This must be a method of the inventory, because all changed things must be saved afterwards
+        and the schema does not know which things are affected.
+
+        Args:
+            schema: schema (level) to be changed
+            new_levelname: the new levelname
+        Raises:
+            ValueError: if the new levelname is empty or whitespace-only and sub schemas exist
+        """
+        schema_name = "a default schema" if schema.is_default() else schema.name
+        new_levelname = new_levelname.strip()
+        try:
+            print(
+                f"debug: Change level name of {schema_name} from {schema.levelname} to {new_levelname}."
+            )
+        except InvalidLocation:
+            print(
+                f"debug: Set level name of {schema_name} from nothing to {new_levelname}."
+            )
+        schema.levelname = new_levelname
+        self.save()
+
+    def set_schema_name(self, schema: Schema, new_name: str):
+        """Set the name of a schema.
+
+        Fails on default schemas.
+
+        This must be a method of the inventory, because all changed things must be saved afterwards
+        and the schema does not know which things are affected.
+
+        Args:
+            inventory: inventory with schema and things (both needed)
+            schema: schema (level) to be changed
+            new_name: new name of the schema. Is stripped of surrounding whitespace.
+        Raises:
+            ValueError: if new name is empty except for whitespace
+        """
+        if schema.is_default():
+            raise ValueError(f"Cannot change name of default schema.")
+        if not new_name.strip():
+            raise ValueError(
+                f"The new name '{new_name}' is empty (or only whitespace). This is invalid."
+            )
+        new_name = new_name.strip()
+        print(f"debug: Change schema name from {schema.name} to {new_name}")
+        schema.name = new_name
+        self.save()
+
 
 def check_filename_types(filetypes: Sequence[str]) -> Callable[[str], pathlib.Path]:
     """Create function that checks for being a simple file.

{flinventory-2.2.3 → flinventory-2.3.1}/flinventory/sign.py

@@ -1,13 +1,14 @@
 #! /usr/bin/env python
 """Class sign that contains the info for a sign for a thing."""
+
 import itertools
 
 import logging
 import os.path
 
 import pathlib
-import yaml
 from typing import Optional, override
+import yaml
 
 from . import constant
 from . import defaulted_data

{flinventory-2.2.3 → flinventory-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flinventory"
-version = "2.2.3"
+version = "2.3.1"
 description = "An inventory system for self-help repair shops"
 authors = [
     { name = "flukx", email = "flinventory-flukx@612211124.xyz" },
@@ -60,3 +60,6 @@ include = [
     { path = "thingtemplate_typst" },
 ]
 exclude = "tests"
+
+[tool.mypy]
+warn_unreachable = true