1class Material:
  2    def __init__(self, weight):
  3        self.weight = weight
  4
  5    @property
  6    def volume(self):
  7        return self.weight / self.density
  8
  9
 10class Concrete(Material):
 11    density = 2500
 12
 13
 14class Brick(Material):
 15    density = 2000
 16
 17
 18class Stone(Material):
 19    density = 1600
 20
 21
 22class Wood(Material):
 23    density = 600
 24
 25
 26class Steel(Material):
 27    density = 7700
 28
 29
 30class Factory:
 31    _used_instances = set()
 32    _all_created_instances = []
 33    _dynamic_classes = {}
 34    volume = 0
 35    def __init__(self):
 36        self.created_instances = []
 37        self.volume = 0
 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("Must provide arguments.")
 44        if args:
 45            return self._positional_arguments(*args)
 46        return self._keyword_args(**kwargs)
 47
 48    def _positional_arguments(self, *args):
 49        if len(args) == 1:
 50            if args[0] not in Factory._used_instances:
 51                self.volume += args[0].volume
 52                Factory.volume += args[0].volume
 53                Factory._used_instances.add(args[0])
 54                return args[0]
 55            raise AssertionError("This instance has already been used.")
 56        for obj in args:
 57            if obj in Factory._used_instances:
 58                raise AssertionError("This instance has already been used.")
 59            Factory._used_instances.add(obj)
 60            self.volume -= obj.volume
 61            Factory.volume -= obj.volume
 62        base_materials = self._get_base_materials(args)
 63        new_class_name = "_".join(sorted(base_materials.keys()))
 64        if new_class_name in Factory._dynamic_classes:
 65            dynamic_class = Factory._dynamic_classes[new_class_name]
 66        else:
 67            new_density = sum(base_materials.values()) / len(base_materials)
 68
 69            class DynamicMaterial(Material):
 70                density = new_density
 71                _base_classes = base_materials
 72
 73            DynamicMaterial.__name__ = new_class_name
 74            Factory._dynamic_classes[new_class_name] = DynamicMaterial
 75            globals()[new_class_name] = DynamicMaterial
 76            dynamic_class = DynamicMaterial
 77        dynamic_class_weight = sum(obj.weight for obj in args)
 78        instance = dynamic_class(dynamic_class_weight)
 79        Factory._all_created_instances.append(instance)
 80        self.created_instances.append(instance)
 81        self.volume += instance.volume
 82        Factory.volume += instance.volume
 83        return instance
 84
 85    def _get_base_materials(self, materials):
 86        base_classes = {}
 87        for obj in materials:
 88            if isinstance(obj, Material):
 89                if hasattr(obj, "_base_classes"):
 90                    base_classes.update(obj._base_classes)
 91                else:
 92                    base_classes[obj.__class__.__name__] = obj.density
 93            else:
 94                raise ValueError(f"Unrecognized material: {obj}")
 95        return base_classes
 96
 97    def _keyword_args(self, **kwargs):
 98        result = []
 99        for name, weight in kwargs.items():
100            if name not in globals() and name not in Factory._dynamic_classes:
101                raise ValueError(f"Unknown material: {name}")
102            material = globals().get(name) or Factory._dynamic_classes[name]
103            instance = material(weight)
104            result.append(instance)
105            Factory._all_created_instances.append(instance)
106            self.created_instances.append(instance)
107            self.volume += instance.volume
108            Factory.volume += instance.volume
109        return tuple(result)
110
111    def can_build(self, volume):
112        return self.volume >= volume
113
114    @staticmethod
115    def can_build_together(volume):
116        return Factory.volume >= volume