1from abc import ABC, abstractmethod
  2
  3
  4class BaseMaterial(ABC):
  5    def __init__(self, mass: int):
  6        self.mass = mass
  7        self.used = False
  8
  9    """Subclasses must define the density."""
 10
 11    @property
 12    @abstractmethod
 13    def density(self):
 14        ...
 15
 16    @property
 17    def volume(self):
 18        return self.mass / self.density
 19
 20    def mark_used(self):
 21        if self.used:
 22            raise AssertionError("Material has already been used.")
 23        self.used = False
 24
 25
 26class Concrete(BaseMaterial):
 27    density = 2500
 28
 29
 30class Brick(BaseMaterial):
 31    density = 2000
 32
 33
 34class Stone(BaseMaterial):
 35    density = 1600
 36
 37
 38class Wood(BaseMaterial):
 39    density = 600
 40
 41
 42class Steel(BaseMaterial):
 43    density = 7700
 44
 45
 46class Factory:
 47
 48    """Use a dictionary because the search is less complex."""
 49    _materials_registry = {
 50        "Concrete": Concrete,
 51        "Brick": Brick,
 52        "Stone": Stone,
 53        "Wood": Wood,
 54        "Steel": Steel}
 55    all_created_materials = []
 56
 57    def __init__(self):
 58        self.created_materials = []
 59
 60    def __call__(self, *args, **kwargs):
 61        if args and kwargs:
 62            raise ValueError("Factory must be called with only positional or keyword arguments, not both.")
 63        if not args and not kwargs:
 64            raise ValueError("Factory must be called with at least one argument.")
 65
 66        if kwargs:
 67            return self._create_named_materials(kwargs)
 68        elif args:
 69            return self._create_new(args)
 70
 71    def _create_named_materials(self, kwargs):
 72        materials = []
 73        for name, mass in kwargs.items():
 74            material_class = Factory._materials_registry.get(name)
 75            if not material_class:
 76                raise ValueError(f"Unknown material type: {name}")
 77
 78            material = material_class(mass)
 79            material.mark_used()
 80            materials.append(material)
 81            self.created_materials.append(material)
 82            Factory.all_created_materials.append(material)
 83        return tuple(materials)
 84
 85    def _create_new(self, args):
 86        for material in args:
 87            if material.used:
 88                raise AssertionError(
 89                    f"Material {material.__class__.__name__} has already been used and cannot be reused.")
 90
 91        # Retrieve the original components of the materials (if composite) - needed for density calculation
 92        components = []
 93        for material in args:
 94            if hasattr(material, "_components"):
 95                components.extend(material._components)
 96            else:
 97                components.append(material)
 98
 99        for arg in args:
100            arg.used = True
101
102        material_classes = sorted({type(component).__name__ for component in components})
103        alloy_name = "_".join(material_classes)
104
105        if alloy_name in Factory._materials_registry:
106            alloy_class = Factory._materials_registry[alloy_name]
107        else:
108            average_density = sum(component.density for component in components) / len(components)
109            alloy_class = type(alloy_name, (BaseMaterial,), {"density": average_density})
110            Factory._materials_registry[alloy_name] = alloy_class
111
112        total_mass = sum(component.mass for component in components)
113        alloy_instance = alloy_class(total_mass)
114        alloy_instance._components = components
115
116        self.created_materials.append(alloy_instance)
117        Factory.all_created_materials.append(alloy_instance)
118        return alloy_instance
119
120    def can_build(self, required_volume):
121        total = sum(material.volume for material in self.created_materials if not material.used)
122        return total >= required_volume
123
124    @staticmethod
125    def can_build_together(required_volume):
126        total = sum(material.volume for material in  Factory.all_created_materials if not material.used)
127        return total >= required_volume