1class Material:
  2    """Base material class."""
  3    density = 1
  4
  5    def __init__(self, weight):
  6        self.weight = weight
  7
  8    @property
  9    def volume(self):
 10        """Calculate material's volume."""
 11        return self.weight / self.density
 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    """Create (new) materials."""
 36    # dict to keep track of existing materials
 37    existing_materials = {"Concrete": Concrete, "Brick": Brick, "Stone": Stone,
 38                      "Wood": Wood, "Steel": Steel}
 39    used_materials = [] # keeping the used positional arguments here
 40    available_materials = [] # valid materials for can_build_together()
 41
 42    def __init__(self):
 43        self.materials = [] # valid materials for can_build()
 44
 45    def __call__(self, *args, **kwargs):
 46        if (len(args) and len(kwargs)
 47            or not len(args) and not len(kwargs)):
 48            raise ValueError("Only positional or only keyword arguments allowed.")
 49
 50        if len(kwargs):
 51            created_materials = []
 52            for material in kwargs.items():
 53                if material[0] not in self.existing_materials:
 54                    raise ValueError(f"No such material: {material[0]}.")
 55                created_materials.append(self.existing_materials[material[0]](material[1]))
 56            self.materials.extend(created_materials)
 57            Factory.available_materials.extend(created_materials)
 58            return tuple(created_materials)
 59
 60        # else: len(args) > 0
 61        for pos_arg in args:
 62            if pos_arg in Factory.used_materials:
 63                raise AssertionError("Material has already been used.")
 64            if pos_arg in self.materials:
 65                self.materials.remove(pos_arg)
 66
 67            # in case a material from another factory is passed
 68            if pos_arg in Factory.available_materials:
 69                Factory.available_materials.remove(pos_arg)
 70            Factory.used_materials.append(pos_arg)
 71
 72        materials_to_combine = list(map(lambda x: type(x).__name__, args))
 73        for element in materials_to_combine:
 74            separated_element = element.split('_')
 75            materials_to_combine.remove(element)
 76            materials_to_combine.extend(separated_element)
 77        materials_to_combine.sort()
 78        new_material_name = '_'.join(materials_to_combine)
 79
 80        sum_weights = sum(list(map(lambda x: x.weight, args)))
 81        sum_density = sum(list(map(lambda x: x.density, 
 82                                   [cls for cls in self.existing_materials.values()
 83                                    if cls.__name__ in materials_to_combine])))
 84
 85        if new_material_name not in self.existing_materials:
 86            self.existing_materials[new_material_name] = type(
 87                    new_material_name,
 88                    (Material,),
 89                    {"density": sum_density / len(materials_to_combine)}
 90                )
 91        new_material = self.existing_materials[new_material_name](sum_weights)
 92        self.materials.append(new_material)
 93        Factory.available_materials.append(new_material)
 94        return new_material
 95
 96    def can_build(self, wall_volume):
 97        """Whether instance's materials' volumes are enough to build a wall."""
 98        # in a separate list in case another factory has used materials from the current one
 99        valid_materials = [material for material in self.materials
100                           if material in Factory.available_materials]
101        return sum(list(map(lambda x: x.volume, valid_materials))) >= wall_volume
102
103    @classmethod
104    def can_build_together(cls, wall_volume):
105        """Whether class' materials' volumes are enough to build a wall."""
106        return sum(list(map(lambda x: x.volume, Factory.available_materials))) >= wall_volume