1class BuildingMaterial:
  2    """Represents a generic building material."""
  3
  4    def __init__(self, mass, factory=None):
  5        """
  6        Initialize a BuildingMaterial instance.
  7
  8        Args:
  9            mass (float): The mass of the material.
 10            factory (Factory, optional): The factory that created the material.
 11        """
 12        self._mass = mass
 13        self._used = False
 14        self._factory = factory
 15
 16    @property
 17    def mass(self):
 18        return self._mass
 19
 20    @property
 21    def factory(self):
 22        return self._factory
 23
 24    @factory.setter
 25    def factory(self, other_factory):
 26        self._factory = other_factory
 27
 28    @property
 29    def volume(self):
 30        """Calculate the volume of the material based on its density."""
 31        return self.mass / self.density
 32
 33
 34class Concrete(BuildingMaterial):
 35    """Represents concrete with a specific density."""
 36
 37    density = 2500
 38
 39
 40class Brick(BuildingMaterial):
 41    """Represents brick with a specific density."""
 42
 43    density = 2000
 44
 45
 46class Stone(BuildingMaterial):
 47    """Represents stone with a specific density."""
 48
 49    density = 1600
 50
 51
 52class Wood(BuildingMaterial):
 53    """Represents wood with a specific density."""
 54
 55    density = 600
 56
 57
 58class Steel(BuildingMaterial):
 59    """Represents steel with a specific density."""
 60
 61    density = 7700
 62
 63
 64class Factory:
 65    """Represents a factory that produces building materials and alloys."""
 66
 67    _VALID_MATERIALS = {
 68        "Concrete": Concrete,
 69        "Brick": Brick,
 70        "Stone": Stone,
 71        "Wood": Wood,
 72        "Steel": Steel
 73    }
 74
 75    _created_alloy_types = {}
 76    _total_volume_sum = 0
 77
 78    def __init__(self):
 79        """Initialize a Factory instance."""
 80        self._instance_volume_sum = 0
 81
 82    def _decrease_volume_sums(self, vol):
 83        self._instance_volume_sum -= vol
 84        Factory._total_volume_sum -= vol
 85
 86    def _increase_volume_sums(self, vol):
 87        self._instance_volume_sum += vol
 88        Factory._total_volume_sum += vol
 89
 90    def _create_single_material(self, material_name, mass):
 91        if material_name in Factory._VALID_MATERIALS:
 92            return Factory._VALID_MATERIALS[material_name](mass, self)
 93        elif material_name in Factory._created_alloy_types:
 94            return Factory._created_alloy_types[material_name](mass, self)
 95        else:
 96            raise ValueError("Keyword arguments must have valid materials as keys!")
 97
 98    def _create_materials(self, **kwargs):
 99        result = [self._create_single_material(key, value) for key, value in kwargs.items()]
100        self._increase_volume_sums(sum(m.volume for m in result))
101        return tuple(result)
102
103    @staticmethod
104    def _generate_alloy_name(materials):
105        names = []
106        for material in set(materials):
107            names.extend(material.__class__.__name__.split("_"))
108        return "_".join(sorted(names))
109
110    @classmethod
111    def _add_new_alloy_type(cls, alloy_name):
112        material_types = [cls._VALID_MATERIALS[type_name] for type_name in alloy_name.split("_")]
113        avg_density = sum(m.density for m in material_types) / len(material_types)
114        cls._created_alloy_types[alloy_name] = type(
115            alloy_name,
116            (BuildingMaterial,),
117            {
118                "density": avg_density,
119            }
120        )
121
122    @staticmethod
123    def _invalidate_materials(materials):
124        for m in materials:
125            m._used = True
126            if m.factory:
127                m.factory._decrease_volume_sums(m.volume)
128                m.factory = None
129
130    def _create_dynamic_alloy(self, *materials):
131        for m in materials:
132            if m._used:
133                raise AssertionError("BuildingMaterial objects can't be reused!")
134
135        alloy_name = Factory._generate_alloy_name(materials)
136        mass_sum = sum(m.mass for m in materials)
137
138        if alloy_name not in Factory._created_alloy_types:
139            Factory._add_new_alloy_type(alloy_name)
140
141        Factory._invalidate_materials(materials)
142
143        alloy = Factory._created_alloy_types[alloy_name](mass_sum, self)
144        self._increase_volume_sums(alloy.volume)
145        return alloy
146
147    @staticmethod
148    def _validate_call_arguments(*args, **kwargs):
149        if args and kwargs:
150            raise ValueError("Factory can't be called with both positional and keyword arguments!")
151        if not args and not kwargs:
152            raise ValueError("Factory object can't be called without arguments!")
153
154    def __call__(self, *args, **kwargs):
155        """
156        Create materials or an alloy using the factory.
157
158        Args:
159            *args: Positional arguments for dynamic alloys.
160            **kwargs: Keyword arguments for creating materials.
161        """
162        Factory._validate_call_arguments(*args, **kwargs)
163        if kwargs:
164            return self._create_materials(**kwargs)
165        elif args:
166            alloy = self._create_dynamic_alloy(*args)
167            return alloy
168
169    def can_build(self, volume_target):
170        """Check if the factory can build with the specified volume."""
171        return self._instance_volume_sum >= volume_target
172
173    @classmethod
174    def can_build_together(cls, volume_target):
175        """Check if all factories combined can build with the specified volume."""
176        return cls._total_volume_sum >= volume_target