1class Material:
  2    density = 0
  3    def __init__(self, weight):
  4        self.weight = weight
  5    
  6    @property
  7    def volume(self):
  8        return self.weight / self.density
  9
 10    def _get_class_name(self):
 11        return self.__class__.__name__
 12
 13
 14class Concrete(Material):
 15    density = 2500
 16    
 17    
 18class Brick(Material):
 19    density = 2000
 20
 21
 22class Stone(Material):
 23    density = 1600
 24
 25
 26class Wood(Material):
 27    density = 600
 28
 29
 30class Steel(Material):
 31    density = 7700
 32
 33
 34class Factory:
 35    created_material_classes = {
 36        "Brick": Brick,
 37        "Concrete": Concrete,
 38        "Steel": Steel,
 39        "Stone": Stone,
 40        "Wood": Wood,
 41    }
 42        
 43    used_instances = set()
 44    all_instances = set()
 45
 46    def __init__(self):
 47        self.current_instances = set()
 48    
 49    def _get_base_densities(self, args, processed_classes):
 50        """Get the densities of the base materials used to create the given instances."""
 51        densities = []
 52
 53        for arg in args:
 54            if isinstance(arg, Material):
 55                class_name = arg._get_class_name()
 56                base_classes = class_name.split("_")
 57
 58                for base in base_classes:
 59                    if base not in processed_classes:
 60                        if base in self.created_material_classes:
 61                            densities.append(self.created_material_classes[base].density)
 62                            processed_classes.add(base)
 63                        else:
 64                            raise ValueError(f"Unknown material base: {base}")
 65        return densities
 66
 67    def __call__(self, *args, **kwargs):
 68        if not args and not kwargs:
 69            raise ValueError("Cannot call with no arguments.")
 70        if args and kwargs:
 71            raise ValueError("Cannot mix positional and keyword arguments.")
 72        
 73        if kwargs:
 74            instances = ()
 75            for key, value in kwargs.items():
 76                if key in self.created_material_classes:
 77                    material_class = self.created_material_classes[key]
 78                    instance = material_class(value)
 79                    instances += (instance,)
 80                    
 81                    self.current_instances.add(instance)
 82                    self.all_instances.add(instance)
 83                else:
 84                    raise ValueError(f"Invalid name of keyword argument: {key}")
 85            return instances
 86        
 87        if args:
 88            for arg in args:
 89                if arg in self.used_instances:
 90                    raise AssertionError(f"Instance {arg} has already been used.")
 91                if not any(isinstance(arg, cls) for cls in self.created_material_classes.values()):
 92                    raise ValueError(f"Invalid material instance: {arg}")
 93            
 94            class_name = "_".join(
 95                sorted(
 96                    set(
 97                        base_name
 98                        for arg in args
 99                        for base_name in arg._get_class_name().split("_")
100                    )))            
101            
102            if class_name in self.created_material_classes:
103                dynamic_class = self.created_material_classes[class_name]
104            else:
105                processed_classes = set()
106                base_densities = self._get_base_densities(args, processed_classes)
107                average_density = sum(base_densities) / len(base_densities)
108
109                dynamic_class = type(
110                    class_name,
111                    (Material,),
112                    {
113                        "density": average_density,
114                    },
115                )
116
117                self.created_material_classes[class_name] = dynamic_class
118                
119            self.used_instances.update(args)
120            total_weight = sum(arg.weight for arg in args)
121            instance = dynamic_class(total_weight)
122            
123            self.current_instances.add(instance)
124            self.all_instances.add(instance)
125            
126            return instance
127        
128    def can_build(self, required_volume):
129        total_volume = sum(
130            instance.volume
131            for instance in self.current_instances
132            if instance not in self.used_instances
133        )
134        return total_volume >= required_volume
135    
136    @classmethod
137    def can_build_together(cls, required_volume):
138        total_volume = sum(
139            instance.volume
140            for instance in cls.all_instances
141            if instance not in cls.used_instances
142        )
143        return total_volume >= required_volume