1BASE_MATERIAL_DENSITIES = {
  2    'Concrete': 2500,
  3    'Brick': 2000,
  4    'Stone': 1600,
  5    'Wood': 600,
  6    'Steel': 7700
  7}
  8
  9classes = {}
 10
 11
 12def initializer_with_density(density):
 13    def instance_initializer_method(instance_reference, mass):
 14        setattr(instance_reference, "mass", mass)
 15        setattr(instance_reference, "volume", mass / density)
 16        setattr(instance_reference, "used", False)
 17    return instance_initializer_method
 18
 19
 20class Material:
 21    def __init__(self, mass):
 22        self.mass = mass
 23        self.used = False
 24
 25
 26def class_generator(*class_names_list):
 27
 28    class_name = "_".join(class_names_list)
 29
 30    if class_name in classes:
 31        return classes[class_name]
 32
 33    if class_name in BASE_MATERIAL_DENSITIES:
 34        density = BASE_MATERIAL_DENSITIES[class_name]
 35    else:
 36        density = sum(map(lambda cls: BASE_MATERIAL_DENSITIES[cls] / len(class_names_list), class_names_list))
 37
 38    classes[class_name] = type(class_name, (Material,), {'volume': property(lambda self: self.mass / density)})
 39    return classes[class_name]
 40
 41
 42Concrete = class_generator('Concrete')
 43Brick = class_generator('Brick')
 44Stone = class_generator('Stone')
 45Steel = class_generator('Steel')
 46Wood = class_generator('Wood')
 47
 48
 49class Factory:
 50
 51    __factory_instances = []
 52
 53    def __init__(self):
 54        self.__factory_instances.append(self)
 55        self.__created_materials = []
 56
 57    def __del__(self):
 58        self.__factory_instances.remove(self)
 59
 60    def __call_with_existing_materials(self, *existing_materials):
 61        if any(map(lambda material: material.used, existing_materials)):
 62            raise AssertionError
 63        else:
 64            for material in existing_materials:
 65                material.used = True
 66
 67        sorted_names = sum(list(map(lambda class_name: class_name.split('_'),
 68                                    map(lambda material: material.__class__.__name__, existing_materials))), [])
 69        sorted_names.sort()
 70        obj = class_generator(*sorted_names)(sum(map(lambda material: material.mass, existing_materials)))
 71        self.__created_materials.append(obj)
 72        return obj
 73
 74    def __call_with_new_materials(self, **new_materials):
 75        newly_created_materials = []
 76        for material_name, mass in new_materials.items():
 77            if material_name in classes:
 78                obj = classes[material_name](mass)
 79                self.__created_materials.append(obj)
 80                newly_created_materials.append(obj)
 81            else:
 82                raise ValueError
 83
 84        return tuple(newly_created_materials)
 85
 86    def __call__(self, *existing_materials, **new_materials):
 87        if not (len(existing_materials) ^ len(new_materials)):
 88            raise ValueError
 89
 90        if len(existing_materials) > 0:
 91            return self.__call_with_existing_materials(*existing_materials)
 92
 93        if len(new_materials) > 0:
 94            return self.__call_with_new_materials(**new_materials)
 95
 96    @property
 97    def volume(self):
 98        return sum(map(lambda ref: ref.volume,
 99                       filter(lambda ref: not ref.used, self.__created_materials)))
100
101    @classmethod
102    def can_build_together(cls, desired_volume):
103        return sum(map(lambda ref: ref.volume, cls.__factory_instances)) >= desired_volume
104
105    def can_build(self, desired_volume):
106        return self.volume >= desired_volume