1class Material:
  2    density = None
  3
  4    def __init__(self, mass):
  5        self.mass = mass
  6        self.used = False
  7
  8    @property
  9    def volume(self):
 10        return self.mass / self.density
 11
 12
 13class Brick(Material):
 14    density = 2000
 15
 16
 17class Concrete(Material):
 18    density = 2500
 19
 20
 21class Stone(Material):
 22    density = 1600
 23
 24
 25class Wood(Material):
 26    density = 600
 27
 28
 29class Steel(Material):
 30    density = 7700
 31
 32
 33class Factory:
 34    current_material_classes = [Brick, Concrete, Stone, Wood, Steel]
 35    factories = []
 36
 37    def __init__(self):
 38        self.generated_materials = []
 39        self.factories.append(self)
 40
 41    def __call__(self, *args, **kwargs):
 42        self._validate_call_input(args, kwargs)
 43        if kwargs:
 44            return self._get_result_from_kwargs(kwargs)
 45        return self._get_result_from_args(args)
 46
 47    def can_build(self, volume):
 48        return self.generated_materials_volume >= volume
 49
 50    @classmethod
 51    def can_build_together(cls, volume):
 52        generated_volume = sum([factory.generated_materials_volume for factory in cls.factories])
 53        return generated_volume >= volume
 54
 55    @property
 56    def generated_materials_volume(self):
 57        return sum([mat.volume for mat in self.generated_materials if not mat.used])
 58
 59    def _get_new_instance(self, base_classes, cls_name, mass):
 60        new_density = sum([base_class.density for base_class in base_classes]) / len(base_classes)
 61        new_cls = type(
 62            cls_name,
 63            (Material,),
 64            {
 65                "density": new_density
 66            }
 67        )
 68        self.current_material_classes.append(new_cls)
 69        instance = new_cls(mass)
 70        self.generated_materials.append(instance)
 71        return instance
 72
 73    @classmethod
 74    def __get_material_class_by_name(cls, name):
 75        for cur in cls.current_material_classes:
 76            if cur.__name__ == name:
 77                return cur
 78        raise ValueError()
 79
 80    @staticmethod
 81    def _validate_call_input(args, kwargs):
 82        if not args and not kwargs:
 83            raise ValueError()
 84        if args and kwargs:
 85            raise ValueError()
 86
 87    def _get_result_from_kwargs(self, kwargs):
 88        result = []
 89        for (current_type_name, mass) in kwargs.items():
 90            result_class = self.__get_material_class_by_name(current_type_name)
 91            instance = result_class(mass)
 92            result.append(instance)
 93            self.generated_materials.append(instance)
 94        return tuple(result)
 95
 96    def _get_result_from_args(self, args):
 97        self._check_for_material_usage(args)
 98        base_classes, new_mass = self._get_new_class_props(args)
 99        cls_name = "_".join([base.__name__ for base in base_classes])
100        try:
101            result_class = self.__get_material_class_by_name(cls_name)
102            instance = result_class(new_mass)
103            self.generated_materials.append(instance)
104            return instance
105        except ValueError:
106            return self._get_new_instance(base_classes, cls_name, new_mass)
107
108    @staticmethod
109    def _check_for_material_usage(materials):
110        for material_instance in materials:
111            if material_instance.used:
112                raise AssertionError()
113            material_instance.used = True
114
115    @classmethod
116    def _get_new_class_props(cls, args):
117        new_base_classes = []
118        mass = 0
119        for instance in args:
120            for base_class_name in instance.__class__.__name__.split('_'):
121                new_base_classes.append(cls.__get_material_class_by_name(base_class_name))
122            mass += instance.mass
123        new_base_classes.sort(key=lambda obj: obj.__name__)
124        return new_base_classes, mass