def test_create_model_with_custom_requirements(sklearn_model_obj, pandas_data):
requirements = Requirements([
InstallableRequirement('dumb', '0.4.1'),
InstallableRequirement('art', '4.0')
])
model = Model.create(sklearn_model_obj,
pandas_data,
custom_requirements=Requirements([Requirement()]))
assert model is not None
assert all(req in [r.module for r in requirements.installable]
for req in model.requirements.installable)
def test_resolve_requirements_arg():
requirements = Requirements([
InstallableRequirement('dumb', '0.4.1'),
InstallableRequirement('art', '4.0')
])
actual_reqs = resolve_requirements(requirements)
assert actual_reqs == requirements
def get_object_requirements_old(obj) -> Requirements:
if isinstance(obj, MutableSequence):
return sum(get_object_requirements_old(o) for o in obj)
if isinstance(obj, Mapping):
return sum(get_object_requirements_old(o) for o in obj.keys()) + \
sum(get_object_requirements_old(o) for o in obj.values())
mod = get_object_base_module(obj)
if mod is None:
raise ValueError('Cant determine object module')
elif mod.__name__ == 'builtins':
return Requirements()
if not is_installable_module(mod):
return Requirements([CustomRequirement(mod.__name__)])
else:
return Requirements([get_module_as_requirement(mod)])
def model(data, prediction):
dataset_meta = DatasetAnalyzer.analyze(data)
output_meta = DatasetAnalyzer.analyze(prediction)
return Model('test model',
SklearnModelWrapper(),
input_meta=dataset_meta,
output_meta=output_meta,
requirements=Requirements([]))
def to_requirements(self):
r = Requirements()
for mod in self._modules:
if is_installable_module(mod):
r.add(get_module_as_requirement(get_base_module(mod)))
elif is_local_module(mod):
r.add(CustomRequirement.from_module(mod))
return r
def _prepare_methods_and_requirements(self, input_data):
requirements = Requirements()
requirements += self._model_requirements()
arg_type = DatasetAnalyzer.analyze(input_data)
requirements += arg_type.requirements
methods = {}
for exposed, wrapped in self._exposed_methods_mapping().items():
output_data = self._call_method(wrapped, input_data)
out_type = DatasetAnalyzer.analyze(output_data)
methods[exposed] = (wrapped, arg_type, out_type)
requirements += out_type.requirements
return methods, requirements
def to_requirements(self):
r = Requirements()
for mod in list(sys.modules.values()):
if not self._should_ignore(mod) and is_local_module(mod):
r.add(CustomRequirement.from_module(mod))
# add imports of this local module
for obj in mod.__dict__.values():
self._add_requirement(obj)
for mod in self._modules:
r.add(get_module_as_requirement(get_base_module(mod)))
return r
def analyze(cls, obj: AnyRequirements) -> Requirements:
"""
Run RequirementHook hooks to analyze obj
:param obj: objects to analyze
:return: Instance of Requirements
"""
obj = resolve_requirements(obj)
to_process = list(obj.requirements)
result = []
for hook in cls.hooks:
while len(to_process) > 0:
req = to_process.pop()
if hook.can_process(req):
result += hook.process(req).requirements
else:
result.append(req)
to_process = result
result = []
return Requirements(to_process)
def get_requirements(self):
return Requirements([])
def _model_requirements(self) -> Requirements:
if get_object_base_module(self.model) is sklearn:
return Requirements([InstallableRequirement.from_module(sklearn)])
# some sklearn compatible model (either from library or user code) - fallback
return super()._model_requirements()
def process(self, obj: Requirement, **kwargs) -> Requirements:
return Requirements([obj, UnixPackageRequirement('libgomp1')])
def requirements(self) -> Requirements:
return sum([i.requirements for i in self.items], Requirements())
def requirements(self) -> Requirements:
return sum([i.requirements for i in self.item_types.values()],
Requirements())
def get_requirements(self):
return Requirements([
InstallableRequirement.from_str(
f'dill=={get_module_version(dill)}')
]) # for example
def model():
return Model('test model',
SklearnModelWrapper(),
requirements=Requirements([]),
description='aaa')
def requirements(self) -> Requirements:
return Requirements([InstallableRequirement.from_module(tf)
]) + super().requirements.fget(self)
def process(self, obj: Requirement, **kwargs) -> Requirements:
return Requirements([obj, InstallableRequirement('bbbb')])
def model():
return Model('test model',
SklearnModelWrapper(),
requirements=Requirements([]))
def requirements(self) -> Requirements:
return Requirements()
def requirements(self) -> Requirements:
return Requirements([InstallableRequirement.from_module(lgb)
]) + self.inner.requirements
def _model_requirements(self) -> Requirements:
return Requirements([
InstallableRequirement.from_module(lib) for lib in self.libraries
])
