1class Material:
  2    """Parent class for all the materials."""
  3
  4    DENSITY = 0
  5
  6    def __init__(self, mass):
  7        self.mass = mass
  8        self.is_used = False
  9        self.BASIC_CLASSES = (type(self),)
 10
 11    @property
 12    def volume(self):
 13        return self.mass / self.DENSITY
 14
 15
 16class Concrete(Material):
 17    """Create concrete with mass, density and volume."""
 18
 19    DENSITY = 2500
 20
 21
 22class Brick(Material):
 23    """Create brick with mass, density and volume."""
 24
 25    DENSITY = 2000
 26
 27
 28class Stone(Material):
 29    """Create stone with mass, density and volume."""
 30
 31    DENSITY = 1600
 32
 33
 34class Wood(Material):
 35    """Create wood with mass, density and volume."""
 36
 37    DENSITY = 600
 38
 39
 40class Steel(Material):
 41    """Create steel with mass, density and volume."""
 42
 43    DENSITY = 7700
 44
 45
 46class Factory:
 47    """Create a factory that is callable."""
 48
 49    MATERIAL_PARENT = Material
 50    all_factories = []
 51
 52    def __init__(self):
 53        self.materials = []
 54        self.all_factories.append(self)
 55
 56    def __call__(self, *args, **kwargs):
 57        if not self.__check_for_valid_input(*args, **kwargs):
 58            raise ValueError('Cannot create factory')
 59
 60        if args:
 61            return self.__create_new_material(*args)
 62        else:
 63            return self.__create_known_materials(**kwargs)
 64
 65    def __check_for_valid_input(self, *args, **kwargs):
 66        return bool(args) ^ bool(kwargs)
 67
 68    def __create_new_material(self, *args):
 69        material_classes = {cls.__name__: cls for cls in self.MATERIAL_PARENT.__subclasses__()}
 70        # create new class name
 71        classes_for_new_material = set()
 72        for inst in args:
 73            if type(inst) not in material_classes.values():
 74                raise ValueError('Invalid material')
 75            if inst.is_used:
 76                raise AssertionError('Material is already used')
 77            classes_for_new_material.update((cls for cls in inst.BASIC_CLASSES if cls not in classes_for_new_material))
 78            inst.is_used = True
 79        classes_for_new_material = list(classes_for_new_material)
 80        classes_for_new_material.sort(key=lambda cls: cls.__name__)
 81        new_class_name = '_'.join((cls.__name__ for cls in classes_for_new_material))
 82
 83        # calculate new mass
 84        mass = sum((inst.mass for inst in args))
 85
 86        # earlier exit if class exists
 87        if new_class_name in material_classes:
 88            new_material = material_classes[new_class_name](mass)
 89            self.materials.append(new_material)
 90            return new_material
 91
 92        # calculate new density
 93        basic_densities = set()
 94        for inst in args:
 95            basic_densities.update(inst.BASIC_CLASSES)
 96        new_density = sum(cls.DENSITY for cls in basic_densities) / len(basic_densities)
 97
 98        # create new class
 99        new_class = type(new_class_name,
100                         (self.MATERIAL_PARENT,),
101                         { 'DENSITY': new_density })
102        new_material = new_class(mass)
103        new_material.BASIC_CLASSES = tuple(classes_for_new_material)
104        self.materials.append(new_material)
105        return new_material
106
107    def __create_known_materials(self, **kwargs):
108        material_classes = {cls.__name__: cls for cls in self.MATERIAL_PARENT.__subclasses__()}
109        new_materials = []
110        for key in kwargs.keys():
111            cls = material_classes.get(key, None)
112            if not cls:
113                raise ValueError('Invalid material name')
114            new_materials.append(cls(kwargs[key]))
115
116        self.materials.extend(new_materials)
117        return tuple(new_materials)
118
119    @property
120    def volume_available(self):
121        return sum(mat.volume for mat in self.materials if not mat.is_used)
122
123    def can_build(self, volume):
124        return self.volume_available >= volume
125
126    @classmethod
127    def can_build_together(cls, volume_to_build):
128        total_volume = sum(fact.volume_available for fact in cls.all_factories)
129        return total_volume >= volume_to_build