functions/lego_classes.py

-'''
-File consists of several classes for the different elements of a device.
-'''
-from __future__ import annotations
-
-from enum import Enum, auto
-import uuid
-from typing import Any, Union, Literal, TypedDict, TypeVar, Type, List, Optional, Dict
-import json
-
-
-# TODO
-# - Docstrings
-# - Beschreibung von Teilen (-> properties)
-# - Gute String Darstellung
-# - Minimalbeispiel für KPIs
-# - Export als GraphViz
-
-
-class ComponentCategory(Enum):
-    BATTERY = auto()
-    MOTOR = auto()
-    FRAME = auto()
-    WHEEL = auto()
-    AXLE = auto()
-    GEAR = auto()
-
-
-class AggregationLayer(Enum):
-    SYSTEM = auto()
-    ASSEMBLY = auto()
-    SUBASSEMBLY = auto()
-    COMPONENT = auto()
-
-
-class LegoComponent:
-    def __init__(self, name: str, category: ComponentCategory, lego_id: str, cost: float, mass: float,
-                 delivery_time: int, layer: AggregationLayer = AggregationLayer.COMPONENT, **properties) -> None:
-        self.uuid: uuid.UUID = uuid.uuid4()
-        self.parent: None | LegoAssembly = None
-        self.name: str = name
-        self.category: ComponentCategory = category
-        self.lego_id: str = lego_id
-        self.cost: float = cost
-        self.mass: float = mass
-        self.delivery_time: int = delivery_time
-        self.layer: AggregationLayer = layer
-        self.properties: dict = properties
-
-    def clone(self) -> LegoComponent:
-        clone = LegoComponent(self.name, self.category, self.lego_id, self.cost, self.mass, self.delivery_time,
-                              self.layer, **self.properties)
-        return clone
-
-    def get_root_assembly(self):
-        if self.parent is None:
-            return None
-        current_assembly = self.parent
-        while current_assembly.parent is not None:
-            current_assembly = current_assembly.parent
-        return current_assembly
-
-    def to_dict(self) -> Dict:
-        ATTRIBUTES = ["uuid", "name", "category", "lego_id", "cost", "mass", "delivery_time", "layer", "properties"]
-        dict_ = {}
-        # store attributes
-        for attr in ATTRIBUTES:
-            dict_[attr] = getattr(self, attr)
-
-        dict_ = {"component": dict_}
-        return dict_
-
-    # TODO good string representation
-    def __str__(self):
-        return self.__repr__()
-        return (
-            f"Item(id={self.uuid}, item_number={self.lego_id}, "
-            f"mass={self.mass}, delivery_time={self.delivery_time}, "
-            f"parent_id={self.parent})"
-        )
-
-    # TODO good repr representation
-    def __repr__(self):
-        return f"LegoComponent {self.name} [{self.uuid}]"
-
-
-class LegoAssembly:
-    def __init__(self, name: str, layer: AggregationLayer, **properties) -> None:
-        self.uuid: uuid.UUID = uuid.uuid4()
-        self.parent: None | LegoAssembly = None
-        self.name: str = name
-        self.layer: AggregationLayer = layer
-        self.properties: dict = properties
-        self.components: List[LegoComponent] = []
-        self.assemblies: List[LegoAssembly] = []
-
-    def add_component(self, component: LegoComponent) -> None:
-        if not isinstance(component, LegoComponent):
-            raise TypeError(f"Argument should be of type {LegoComponent.__name__}, "
-                            f"got {type(component).__name__} instead.")
-        if self.get_root_assembly().contains_uuid(component.uuid):
-            raise AssertionError(f"This assembly or a subassembly already contains the component with ID "
-                                 f"{component.uuid}.")
-        component.parent = self
-        self.components.append(component)
-
-    def add_assembly(self, assembly: LegoAssembly) -> None:
-        if not isinstance(assembly, LegoAssembly):
-            raise TypeError(f"Argument should be of type {LegoAssembly.__name__}, "
-                            f"got {type(assembly).__name__} instead.")
-        if self.get_root_assembly().contains_uuid(assembly.uuid):
-            raise AssertionError(f"This assembly or a subassembly already contains the assembly with ID "
-                                 f"{assembly.uuid}.")
-        assembly.parent = self
-        self.assemblies.append(assembly)
-
-    def children(self) -> Dict[str, List[LegoComponent] | List[LegoAssembly]]:
-        return {'components': self.components, 'assemblies': self.assemblies}
-
-    def get_component_list(self, max_depth: int = -1) -> List[LegoComponent]:
-        component_list = []
-        component_list.extend(self.components)
-        if max_depth > 0:
-            for assembly in self.assemblies:
-                component_list.extend(assembly.get_component_list(max_depth - 1))
-        return component_list
-
-    def get_root_assembly(self) -> LegoAssembly:
-        current_assembly = self
-        while current_assembly.parent is not None:
-            current_assembly = current_assembly.parent
-        return current_assembly
-
-    def contains_uuid(self, uuid_: uuid.UUID):
-        # check component ids
-        component_ids = list(map(lambda c: c.uuid, self.components))
-        if uuid_ in component_ids:
-            return True
-        # check assembly ids
-        assembly_ids = list(map(lambda a: a.uuid, self.assemblies))
-        if uuid_ in assembly_ids:
-            return True
-        # recursively check assemblies
-        for assembly in self.assemblies:
-            if assembly.contains_uuid(uuid_):
-                return True
-        return False
-
-    def to_dict(self) -> Dict:
-        ATTRIBUTES = ["uuid", "name", "layer", "properties"]
-        dict_ = {}
-        # store attributes
-        for attr in ATTRIBUTES:
-            dict_[attr] = getattr(self, attr)
-        # store components
-        dict_["components"] = [component.to_dict() for component in self.components]
-        dict_["assemblies"] = [assembly.to_dict() for assembly in self.assemblies]
-
-        return {"assembly": dict_}
-
-    # TODO find good string representation
-    def __repr__(self):
-        return f"LegoAssembly {self.name} [{self.uuid}]"
-
-
-def print_assembly_tree(root, level=0, is_last=False):
-    # print component
-    assembly_padding = ""
-    if level > 0:
-        assembly_padding += "│   " * (level - 1)
-        if is_last:
-            assembly_padding += "└── "
-        else:
-            assembly_padding += "├── "
-    print(f"{assembly_padding}{root}")
-    # recursively print child components
-    for i, assembly in enumerate(root.assemblies):
-        is_last_ = i == len(root.assemblies) - 1 and len(root.components) == 0
-        print_assembly_tree(assembly, level + 1, is_last_)
-    # print items
-    for i, item in enumerate(root.components):
-        component_padding = "│   " * level if not is_last else "    "
-        component_padding += "├── " if i < len(root.components) - 1 else "└── "
-        print(f"{component_padding}{item}")
-
-
-class KPIEncoder(json.JSONEncoder):
-    def default(self, o):
-        if isinstance(o, uuid.UUID):
-            return "kpi-" + str(o)
-        if isinstance(o, (ComponentCategory, AggregationLayer)):
-            return "kpi-" + o.name
-        return super().default(o)

main_kpi.py

-'''
-FAIR Quality KPIs
-
-'''
-
-def main ():
-    print("Hello ;-)")
-    pass
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file

requirements.txt

-pandas
-tables

test-legoclasses.ipynb

-%% Cell type:code id: tags:
-
-``` python
-# import functions.lego_classes as lego_classes
-from functions.lego_classes import LegoItem
-from functions.lego_classes import LegoComponent
-```
-
-%% Cell type:code id: tags:
-
-``` python
-# Test manually creating some item and components
-
-item1 = LegoItem(1,0.10,10)
-item2 = LegoItem(3,0.30,30)
-item3 = LegoItem(2, 0.2,20)
-
-
-
-component1 = LegoComponent()
-# component1.add_item(item1)
-component2 = LegoComponent(item2)
-
-componentall = LegoComponent([component1,component2]) # This will be saved as items for some reasaon
-# component3 = LegoComponent(item3,component1)
-# component3.add(item2) # Can't really use an item twice
-# component3.add(component2)
-print(componentall.items)
-```
-
-%% Output
-
-    [<functions.lego_classes.LegoComponent object at 0x000002720F4BF7F0>, <functions.lego_classes.LegoComponent object at 0x000002720F4BF790>]
-
-%% Cell type:code id: tags:
-
-``` python
-```
-
-%% Cell type:code id: tags:
-
-``` python
-## Let's test the json stuff
-import json
-# import tkinter as tk
-```
-
-%% Cell type:code id: tags:
-
-``` python
-# First level list handling
-
-def read_json(file_path):
-    with open(file_path, 'r') as f:
-        data = json.load(f)
-    return data
-json_list_data = read_json('example_item_data_list.json')
-# that produces a list, we'd prefer a dict
-
-# Clever way to just create an item for each listed element
-def create_all_items(data):
-    items = []
-    for item_data in data:
-        item_number = item_data.get('item_number')
-        mass = item_data.get('mass')
-        delivery_time = item_data.get('delivery_time')
-        # specific_data = item_data.get('specific_data', {})
-        item = LegoItem(item_number, mass, delivery_time)
-        items.append(item)
-    return items
-
-all_items = create_all_items(json_list_data)
-
-# How to get entries for a specific item
-def get_item_by_number(data, item_number):
-    datasheet = [item for item in data if item['item_number' ] == item_number]
-    return datasheet
-
-sheet1 = get_item_by_number(json_list_data, 2) # this is a list? meh
-
-```
-
-%% Cell type:code id: tags:
-
-``` python
-# vs first level dict handling
-
-with open('example_item_data_dict.json') as json_file:
-    json_dict = json.load(json_file)
-    print(type(json_dict))
-    print(json_dict["1"])
-
-sheet2_from_dict = json_dict["2"]
-# Create an item for this:
-def create_item_from_sheet(dict):
-    item_number = dict["item_number"]
-    mass = dict["mass"]
-    delivery_time =["delivery_time"]
-    item = LegoItem(item_number, mass, delivery_time)
-    return item
-
-itemfromdict = create_item_from_sheet(sheet2_from_dict)
-
-```
-
-%% Output
-
-    <class 'dict'>
-    {'item_number': 1, 'mass': 10, 'delivery_time': 1}

test-legoclasses.py

-
-# import functions.lego_classes as lego_classes
-from functions.lego_classes import *
-import json
-import pprint
-# Test manually creating some item and components
-
-battery = LegoComponent("nice battery", ComponentCategory.BATTERY, "bat42", 1, 2, 3)
-motor = LegoComponent("motor goes brrr", ComponentCategory.MOTOR, "motor", 1, 2, 3)
-wheel = LegoComponent("much round wheel", ComponentCategory.WHEEL, "round", 1, 2, 3)
-
-car = LegoAssembly("Car", AggregationLayer.SYSTEM)
-
-chassis = LegoAssembly("Chassis", AggregationLayer.ASSEMBLY)
-door1 = LegoAssembly("Door 1", AggregationLayer.SUBASSEMBLY)
-door2 = LegoAssembly("Door 2", AggregationLayer.SUBASSEMBLY)
-chassis.add_assembly(door1)
-chassis.add_assembly(door2)
-
-engine = LegoAssembly("Engine", AggregationLayer.ASSEMBLY)
-engine.add_component(motor.clone())
-
-fuel_tank = LegoAssembly("Fuel Tank", AggregationLayer.ASSEMBLY)
-fuel_tank.add_component(battery.clone())
-
-wheels = LegoAssembly("Wheels", AggregationLayer.ASSEMBLY)
-for _ in range(4):
-    wheels.add_component(wheel.clone())
-
-car.add_assembly(chassis)
-car.add_assembly(engine)
-car.add_assembly(fuel_tank)
-car.add_assembly(wheels)
-
-print_assembly_tree(car)
-
-# Dump to json file
-with open("car.json", "w") as fp:
-    json.dump(car.to_dict(), fp, cls=KPIEncoder)
-
-pprint.pprint(car.to_dict())
-pass