1class Material:
  2    THICKNESS = 0
  3    def __init__(self, mass: int):
  4        self.mass = mass
  5
  6    @property
  7    def volume(self):
  8        return float(self.mass / self.THICKNESS)
  9
 10
 11class Concrete(Material):
 12    THICKNESS = 2500
 13
 14
 15class Brick(Material):
 16    THICKNESS = 2000
 17
 18
 19class Stone(Material):
 20    THICKNESS = 1600
 21
 22
 23class Wood(Material):
 24    THICKNESS = 600
 25
 26
 27class Steel(Material):
 28    THICKNESS = 7700
 29
 30
 31class Factory:
 32    _dynamic_classes = {}
 33    all_created_materials = set()  
 34    used_materials = set()  
 35
 36    def __init__(self):
 37        self.current_materials = set()  
 38
 39    def __call__(self, *args, **kwargs):
 40        if args and kwargs:
 41            raise ValueError("Cannot mix positional and keyword arguments.")
 42        if not args and not kwargs:
 43            raise ValueError("Cannot call the function without arguments.")
 44
 45        if args:
 46            return self._call_with_positional_args(args)
 47        if kwargs:
 48            return self._call_with_keyword_args(kwargs)
 49
 50    def _call_with_keyword_args(self, kwargs):
 51        ALLOWED_NAMES = {
 52            "Concrete": Concrete,
 53            "Brick": Brick,
 54            "Stone": Stone,
 55            "Wood": Wood,
 56            "Steel": Steel,
 57        }
 58
 59        result = []
 60        for name, mass in kwargs.items():
 61            if name not in ALLOWED_NAMES and name not in Factory._dynamic_classes:
 62                raise ValueError(f"Invalid material type: {name}")
 63            material_class = (
 64                ALLOWED_NAMES.get(name) or Factory._dynamic_classes[name]
 65            )
 66            material = material_class(mass)
 67            self.current_materials.add(material)
 68            Factory.all_created_materials.add(material)
 69            result.append(material)
 70
 71        return tuple(result)
 72
 73    def _call_with_positional_args(self, args):
 74        for material in args:
 75            if material in Factory.used_materials:
 76                raise AssertionError("This material has already been used.")
 77            if not isinstance(material, Material):
 78                raise ValueError("Positional arguments must be instances of Materials.")
 79            Factory.used_materials.add(material)
 80
 81        base_classes_names = []
 82        for arg in args:
 83            base_classes_names += type(arg).__name__.split('_')
 84
 85        sorted_materials_names = sorted(base_classes_names)
 86        new_class_name = '_'.join(sorted_materials_names)
 87
 88        if new_class_name not in Factory._dynamic_classes:
 89            avg_thickness = sum(material.THICKNESS for material in args) / len(args)
 90            new_class = type(new_class_name, (Material,), {"THICKNESS": avg_thickness})
 91            Factory._dynamic_classes[new_class_name] = new_class
 92
 93        new_class = Factory._dynamic_classes[new_class_name]
 94        total_mass = sum(material.mass for material in args)
 95        new_material = new_class(total_mass)
 96
 97        self.current_materials.add(new_material)
 98        Factory.all_created_materials.add(new_material)
 99        return new_material
100
101    def can_build(self, necessary_volume: int):
102        total_volume = sum(
103            instance.volume
104            for instance in self.current_materials
105            if instance not in Factory.used_materials
106        )
107        return total_volume >= necessary_volume
108
109    @classmethod
110    def can_build_together(cls, necessary_volume: int):
111        total_volume = sum(
112            instance.volume
113            for instance in cls.all_created_materials
114            if instance not in cls.used_materials or isinstance(instance, Material)
115        )
116        return total_volume >= necessary_volume