1class Material:
  2    def __init__(self, mass: int, density: int):
  3        self.mass = mass
  4        self._density = density
  5        self._valid = True  
  6
  7    @property
  8    def volume(self):
  9        return self.mass / self._density
 10
 11    def invalidate(self):
 12        self._valid = False
 13
 14    def is_valid(self):
 15        return self._valid
 16
 17def create_material_class(name, density):
 18    return type(
 19        name,
 20        (Material,),
 21        {
 22            "__init__": lambda self, mass: super(type(self), self).__init__(mass, density)
 23        }
 24    )
 25
 26class Factory:
 27    _dynamic_classes = {}  
 28    _created_objects = []
 29    _material_classes = {}  
 30
 31    def __init__(self):
 32        self._materials = []
 33
 34    @classmethod
 35    def register_material_class(cls, name, material_class):
 36        cls._material_classes[name] = material_class
 37
 38    def __call__(self, *args, **kwargs):
 39        if args and kwargs:
 40            raise ValueError("Cannot mix positional and keyword arguments.")
 41        if not args and not kwargs:
 42            raise ValueError("Cannot call factory without arguments.")
 43
 44        if args:  
 45            return self._handle_positional(args)
 46        elif kwargs: 
 47            return self._handle_keyword(kwargs)
 48
 49    def _handle_positional(self, args):
 50        if any(not material.is_valid() for material in args):
 51            raise AssertionError("Material has already been used.")
 52
 53        class_names = sorted(type(arg).__name__ for arg in args)
 54        combined_material_name = "_".join(class_names)
 55        
 56        if combined_material_name not in Factory._dynamic_classes:
 57            avg_density = sum(arg._density for arg in args) / len(args)
 58
 59            class DynamicMaterial(Material):
 60                def __init__(self, mass: int):
 61                    super().__init__(mass, avg_density)
 62
 63            DynamicMaterial.__name__ = combined_material_name
 64            Factory._dynamic_classes[combined_material_name] = DynamicMaterial
 65
 66        for material in args:
 67            material.invalidate()
 68
 69        new_class = Factory._dynamic_classes[combined_material_name]
 70        mass = sum(material.mass for material in args)
 71        instance = new_class(mass)
 72        self._materials.append(instance)
 73        
 74        return instance
 75
 76    def _handle_keyword(self, kwargs):
 77        instances = []
 78        for key, mass in kwargs.items():
 79            if key not in self._material_classes:
 80                raise ValueError(f"Unknown material type: {key}")
 81            material_class = self._material_classes[key]
 82            instance = material_class(mass)
 83            instances.append(instance)
 84            self._materials.append(instance)
 85        return tuple(instances)
 86
 87    def can_build(self, volume: int):
 88        total_volume = sum(mat.volume for mat in self._materials if mat.is_valid())
 89        return total_volume >= volume
 90
 91    @classmethod
 92    def can_build_together(cls, volume: int):
 93        total_volume = sum(mat.volume for mat in cls._created_objects if mat.is_valid())
 94        return total_volume >= volume
 95
 96Concrete = create_material_class("Concrete", 2500)
 97Brick = create_material_class("Brick", 2000)
 98Stone = create_material_class("Stone", 1600)
 99Wood = create_material_class("Wood", 600)
100Steel = create_material_class("Steel", 7700)
101
102Factory.register_material_class("Concrete", Concrete)
103Factory.register_material_class("Brick", Brick)
104Factory.register_material_class("Stone", Stone)
105Factory.register_material_class("Wood", Wood)
106Factory.register_material_class("Steel", Steel)