1class Material:
  2    DENSITY = 0
  3
  4    def __init__(self, mass):
  5        self.mass = mass
  6
  7    @property
  8    def volume(self):
  9        return float(self.mass / self.DENSITY)
 10    
 11
 12class Concrete(Material):
 13    DENSITY = 2500
 14
 15
 16class Brick(Material):
 17    DENSITY = 2000
 18
 19
 20class Stone(Material):
 21    DENSITY = 1600
 22
 23
 24class Wood(Material):
 25    DENSITY = 600
 26
 27
 28class Steel(Material):
 29    DENSITY = 7700
 30
 31
 32class Factory:
 33    _MATERIALS = { 
 34        'Concrete': Concrete,
 35        'Brick': Brick,
 36        'Stone': Stone,
 37        'Wood': Wood,
 38        'Steel': Steel
 39        }
 40    
 41    _alloys = {}
 42    _all_materials = set()
 43    _used_materials = set()
 44   
 45    def __init__(self):
 46        self._curr_materials = set()
 47
 48    def __call__(self, *args, **kwargs):
 49        if args and kwargs:
 50            raise ValueError('Function can be called with only positional or only keyword arguments')
 51        elif not args and not kwargs:
 52            raise ValueError('Function cannot be called without arguments')
 53        elif kwargs:
 54            return self._get_result_from_kwargs(**kwargs) 
 55        elif args:
 56            return self._get_alloy_from_args(*args)
 57                
 58    def _get_result_from_kwargs(self, **kwargs):
 59        """Return tuple of instances of materials, created from keyword arguments."""  
 60        res = []
 61        for key, val in kwargs.items():
 62            material = self._MATERIALS.get(key)
 63            if material is None:
 64                material = Factory._alloys.get(key)
 65                
 66            if material is None or not issubclass(material, Material):
 67                raise ValueError('Invalid material')
 68            
 69            new_material = material(val)
 70            Factory._all_materials.add(new_material) 
 71            self._curr_materials.add(new_material)
 72            
 73            res.append(new_material)
 74
 75        return tuple(res)
 76    
 77    def _get_average_density(self, *args):
 78        """Return the average density of the materials."""
 79        density_sum = 0
 80        for arg in args:
 81            density_sum += type(arg).DENSITY
 82        
 83        average_density = density_sum / len(args)
 84        return average_density
 85    
 86    def _get_mass(self, *args):
 87        """Calculate the sum of the masses of the materials"""
 88        mass_sum = 0
 89        for arg in args:
 90            mass_sum += arg.mass
 91
 92        return mass_sum
 93
 94    def _get_alloy_from_args(self, *args):
 95        """Create a dynamic class (alloy) from materials."""
 96        base_classes_names = []
 97
 98        for arg in args:
 99            if arg in Factory._used_materials:
100                raise AssertionError('Invalid material')
101            
102            Factory._used_materials.add(arg)
103            
104            base_classes_names.extend(type(arg).__name__.split('_'))
105            
106        sorted_materials_names = sorted(base_classes_names)
107        new_alloy_name = '_'.join(sorted_materials_names)
108
109        if new_alloy_name not in Factory._alloys:
110            average_density = self._get_average_density(*args)
111            alloy = type(
112                new_alloy_name,
113                  (Material,), 
114                  {'DENSITY': average_density}
115                )
116            Factory._alloys[new_alloy_name] = alloy
117
118        alloy = Factory._alloys[new_alloy_name]
119        alloy_mass = self._get_mass(*args)
120        
121        new_alloy = alloy(alloy_mass)
122        self._curr_materials.add(new_alloy)
123        Factory._all_materials.add(new_alloy)
124        return new_alloy
125        
126    def can_build(self, needed_volume):
127        volume_sum = 0
128        for material in self._curr_materials:
129            if material not in Factory._used_materials:
130                volume_sum += material.volume
131        
132        return volume_sum >= needed_volume
133    
134    @classmethod
135    def can_build_together(cls, needed_volume):
136        volume_sum = 0
137        for material in cls._all_materials:
138            volume_sum += material.volume
139
140        return volume_sum >= needed_volume