async def edit(self, ti: ToolchainIntegration) -> ToolchainIntegration:
"""
Edit Toolchain Integration
:param ti: Toolchain Integration
:return Message from API server
"""
return ToolchainIntegration.from_dict(await self.query(
TOOLCHAIN_INTEGRATION_URL, action='PUT', payload=ti.to_dict()))
def create(self, ti: ToolchainIntegration) -> ToolchainIntegration:
"""
Create Toolchain Integration
:param ti: Toolchain Integration
:return Message from API server
"""
return ToolchainIntegration.from_dict(
self.query(TOOLCHAIN_INTEGRATION_URL,
action='POST',
payload=ti.to_dict()))
async def get(self, name: str) -> ToolchainIntegration:
"""
Get Toolchain Integration from API server
:param name: Toolchain Integration name
:type name: str
:return: Toolchain Integration
"""
return ToolchainIntegration.from_dict(
await self.query(f'{TOOLCHAIN_INTEGRATION_URL}/{name}'))
def get_all(self) -> typing.List[ToolchainIntegration]:
"""
Get all Toolchain Integrations from API server
:return: all Toolchain Integrations
"""
return [
ToolchainIntegration.from_dict(ti)
for ti in self.query(TOOLCHAIN_INTEGRATION_URL)
]
def test_local_training_relative_output_dir(mocker: MockFixture, cli_runner: CliRunner):
"""
Tests issue #208 - Converting relative path to output-dir to absolute,
because Docker requires mount paths to be absolute
:param mocker: mocker fixture
:param cli_runner: Click runner fixture
"""
trainer_mock = mocker.patch.object(training, 'K8sTrainer', autospec=True).return_value
trainer_mock.model_training.spec.model.artifact_name_template = 'model_dir_template'
api_client = Mock()
mocker.patch.object(training_sdk, 'create_mt_config_file')
mocker.patch.object(training_sdk, 'stream_container_logs')
mocker.patch.object(training_sdk, 'raise_error_if_container_failed')
docker_mock: Mock = mocker.patch.object(training_sdk.docker, 'from_env').return_value
docker_mock.api.inspect_container = Mock(return_value={})
with tempfile.TemporaryDirectory(dir=os.curdir) as temp_dir:
temp_dir_path = pathlib.Path(temp_dir)
training_yml = temp_dir_path / 'training.yml'
training_yml.write_text(json.dumps(
{**ModelTraining(id='training1', spec=ModelTrainingSpec(toolchain='toolchain1')).to_dict(),
**{'kind': 'ModelTraining'}}))
toolchain_yml = temp_dir_path / 'toolchain.yml'
toolchain_yml.write_text(json.dumps({**ToolchainIntegration(id='toolchain1').to_dict(),
**{'kind': 'ToolchainIntegration'}}))
temp_dir_relative_path: str = os.path.relpath(temp_dir_path)
result: Result = cli_runner.invoke(
training.training_group,
['run', '--output-dir', temp_dir_relative_path, '--manifest-file', str(training_yml),
'--manifest-file', str(toolchain_yml), '--id', 'training1'],
obj=api_client)
assert result.exit_code == 0, f'command invocation ended with exit code {result.exit_code}'
assert result.exception is None, f'command invocation ended with exception {result.exception}'
abs_path = os.path.abspath(temp_dir)
for call in docker_mock.containers.run.call_args_list:
call_kwargs = call[1]
mounts: List[Mount] = call_kwargs.get('mounts', [])
for mount in filter(lambda m: m.get('Target') == MODEL_OUTPUT_CONTAINER_PATH, mounts):
assert os.path.dirname(mount.get('Source')) == abs_path
TRAINING = EntityTestData(
ModelTrainingClient(),
ModelTraining(
id=ENTITY_ID,
spec=ModelTrainingSpec(work_dir="/1/2/3",
model=ModelIdentity(name="name",
version="version")),
status=ModelTrainingStatus(state=SUCCEEDED_STATE)), training.training,
'ModelTraining')
TOOLCHAIN = EntityTestData(
ToolchainIntegrationClient(),
ToolchainIntegration(
id=ENTITY_ID,
spec=ToolchainIntegrationSpec(
default_image="mock-image",
entrypoint="default-entrypoint",
),
),
toolchain_integration.toolchain_integration,
'ToolchainIntegration',
)
PACKAGING = EntityTestData(
ModelPackagingClient(),
ModelPackaging(id=ENTITY_ID,
spec=ModelPackagingSpec(artifact_name='test-artifact-name',
integration_name='test'),
status=ModelPackagingStatus(state=SUCCEEDED_STATE, )),
packaging.packaging,
'ModelPackaging',