def save(self, base_path=None, version=None):
track_save(self)
if base_path:
repo = LocalRepository(base_path)
else:
repo = get_default_repository()
return repo.add(self, version=version)
def save_to_dir(bento_service, path, version=None, silent=False):
"""Save given BentoService along with all its artifacts, source code and
dependencies to target file path, assuming path exist and empty. If target path
is not empty, this call may override existing files in the given path.
:param bento_service (bentoml.service.BentoService): a Bento Service instance
:param path (str): Destination of where the bento service will be saved. The
destination can be local path or remote path. The remote path supports both
AWS S3('s3://bucket/path') and Google Cloud Storage('gs://bucket/path').
:param version (str): Override the service version with given version string
:param silent (boolean): whether to hide the log message showing target save path
"""
track_save(bento_service)
from bentoml.service import BentoService
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"save_to_dir only works with instances of custom BentoService class"
)
if version is not None:
# If parameter version provided, set bento_service version
# Otherwise it will bet set the first time the `version` property get accessed
bento_service.set_version(version)
if _is_remote_path(path):
# If user provided path is an remote location, the bundle will first save to
# a temporary directory and then upload to the remote location
logger.info(
'Saving bento to an remote path. BentoML will first save the bento '
'to a local temporary directory and then upload to the remote path.'
)
with TempDirectory() as temp_dir:
_write_bento_content_to_dir(bento_service, temp_dir)
with TempDirectory() as tarfile_dir:
file_name = f'{bento_service.name}.tar'
tarfile_path = f'{tarfile_dir}/{file_name}'
with tarfile.open(tarfile_path, mode="w:gz") as tar:
tar.add(temp_dir, arcname=bento_service.name)
_upload_file_to_remote_path(path, tarfile_path, file_name)
else:
_write_bento_content_to_dir(bento_service, path)
copy_zip_import_archives(
os.path.join(path, bento_service.name, ZIPIMPORT_DIR),
bento_service.__class__.__module__,
list(get_zipmodules().keys()),
bento_service.env._zipimport_archives or [],
)
if not silent:
logger.info(
"BentoService bundle '%s:%s' created at: %s",
bento_service.name,
bento_service.version,
path,
)
def upload_bento_service(bento_service, base_path=None, version=None):
"""Save given bento_service via BentoML's default Yatai service, which manages
all saved Bento files and their deployments in cloud platforms. If remote yatai
service has not been configured, this will default to saving new Bento to local
file system under BentoML home directory
Args:
bento_service (bentoml.service.BentoService): a Bento Service instance
base_path (str): optional, base path of the bento repository
version (str): optional,
Return:
URI to where the BentoService is being saved to
"""
track_save(bento_service)
with TempDirectory() as tmpdir:
save_to_dir(bento_service, tmpdir, version)
return _upload_bento_service(tmpdir, base_path)
def save_to_dir(bento_service, path, version=None, silent=False):
"""Save given BentoService along with all its artifacts, source code and
dependencies to target file path, assuming path exist and empty. If target path
is not empty, this call may override existing files in the given path.
:param bento_service (bentoml.service.BentoService): a Bento Service instance
:param path (str): Destination of where the bento service will be saved
:param version (str): Override the service version with given version string
:param silent (boolean): whether to hide the log message showing target save path
"""
track_save(bento_service)
from bentoml.service import BentoService
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"save_to_dir only work with instance of custom BentoService class"
)
if version is not None:
# If parameter version provided, set bento_service version
# Otherwise it will bet set the first time the `version` property get accessed
bento_service.set_version(version)
if not os.path.exists(path):
raise BentoMLException("Directory '{}' not found".format(path))
for artifact in bento_service.artifacts.get_artifact_list():
if not artifact.packed:
logger.warning(
"Missing declared artifact '%s' for BentoService '%s'",
artifact.name,
bento_service.name,
)
module_base_path = os.path.join(path, bento_service.name)
try:
os.mkdir(module_base_path)
except FileExistsError:
raise BentoMLException(
f"Existing module file found for BentoService {bento_service.name}"
)
# write README.md with custom BentoService's docstring if presented
saved_bundle_readme = DEFAULT_SAVED_BUNDLE_README.format(
bento_service.name, bento_service.version
)
if bento_service.__class__.__doc__:
saved_bundle_readme += "\n"
saved_bundle_readme += bento_service.__class__.__doc__.strip()
with open(os.path.join(path, "README.md"), "w") as f:
f.write(saved_bundle_readme)
# save all model artifacts to 'base_path/name/artifacts/' directory
bento_service.artifacts.save(module_base_path)
# write conda environment, requirement.txt
bento_service.env.save(path, bento_service)
# Copy all local python modules used by the module containing the `bento_service`'s
# class definition to saved bundle directory
module_name, module_file = copy_local_py_modules(
bento_service.__class__.__module__, os.path.join(path, bento_service.name)
)
# create __init__.py
with open(os.path.join(path, bento_service.name, "__init__.py"), "w") as f:
f.write(
INIT_PY_TEMPLATE.format(
service_name=bento_service.name,
module_name=module_name,
pypi_package_version=bento_service.version,
)
)
# write setup.py, this make saved BentoService bundle pip installable
setup_py_content = BENTO_SERVICE_BUNDLE_SETUP_PY_TEMPLATE.format(
name=bento_service.name,
pypi_package_version=bento_service.version,
long_description=saved_bundle_readme,
)
with open(os.path.join(path, "setup.py"), "w") as f:
f.write(setup_py_content)
with open(os.path.join(path, "MANIFEST.in"), "w") as f:
f.write(MANIFEST_IN_TEMPLATE.format(service_name=bento_service.name))
# write Dockerfile
logger.debug("Using Docker Base Image %s", bento_service._env._docker_base_image)
with open(os.path.join(path, "Dockerfile"), "w") as f:
f.write(
MODEL_SERVER_DOCKERFILE_CPU.format(
docker_base_image=bento_service._env._docker_base_image
)
)
# copy custom web_static_content if enabled
if bento_service.web_static_content:
src_web_static_content_dir = os.path.join(
os.getcwd(), bento_service.web_static_content
)
if not os.path.isdir(src_web_static_content_dir):
raise BentoMLException(
f'web_static_content directory {src_web_static_content_dir} not found'
)
dest_web_static_content_dir = os.path.join(
module_base_path, 'web_static_content'
)
shutil.copytree(src_web_static_content_dir, dest_web_static_content_dir)
# Copy docker-entrypoint.sh
docker_entrypoint_sh_file_src = os.path.join(
os.path.dirname(__file__), "docker-entrypoint.sh"
)
docker_entrypoint_sh_file_dst = os.path.join(path, "docker-entrypoint.sh")
shutil.copyfile(docker_entrypoint_sh_file_src, docker_entrypoint_sh_file_dst)
# chmod +x docker-entrypoint.sh
st = os.stat(docker_entrypoint_sh_file_dst)
os.chmod(docker_entrypoint_sh_file_dst, st.st_mode | stat.S_IEXEC)
# copy bentoml-init.sh for install targz bundles
bentoml_init_sh_file_src = os.path.join(
os.path.dirname(__file__), "bentoml-init.sh"
)
bentoml_init_sh_file_dst = os.path.join(path, "bentoml-init.sh")
shutil.copyfile(bentoml_init_sh_file_src, bentoml_init_sh_file_dst)
# chmod +x bentoml_init_script file
st = os.stat(bentoml_init_sh_file_dst)
os.chmod(bentoml_init_sh_file_dst, st.st_mode | stat.S_IEXEC)
# write bentoml.yml
config = SavedBundleConfig(bento_service)
config["metadata"].update({"module_name": module_name, "module_file": module_file})
config.write_to_path(path)
# Also write bentoml.yml to module base path to make it accessible
# as package data after pip installed as a python package
config.write_to_path(module_base_path)
bundled_pip_dependencies_path = os.path.join(path, 'bundled_pip_dependencies')
_bundle_local_bentoml_if_installed_from_source(bundled_pip_dependencies_path)
if not silent:
logger.info(
"BentoService bundle '%s:%s' created at: %s",
bento_service.name,
bento_service.version,
path,
)
def save_to_dir(bento_service, path, version=None):
"""Save given BentoService along with all its artifacts, source code and
dependencies to target file path, assuming path exist and empty. If target path
is not empty, this call may override existing files in the given path.
Args:
bento_service (bentoml.service.BentoService): a Bento Service instance
path (str): Destination of where the bento service will be saved
"""
track_save(bento_service)
from bentoml.service import BentoService
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"save_to_dir only work with instance of custom BentoService class")
if version is not None:
bento_service.set_version(version)
if not os.path.exists(path):
raise BentoMLException("Directory '{}' not found".format(path))
module_base_path = os.path.join(path, bento_service.name)
os.mkdir(module_base_path)
# write README.md with user model's docstring
if bento_service.__class__.__doc__:
model_description = bento_service.__class__.__doc__.strip()
else:
model_description = DEFAULT_BENTO_ARCHIVE_DESCRIPTION
with open(os.path.join(path, "README.md"), "w") as f:
f.write(model_description)
# save all model artifacts to 'base_path/name/artifacts/' directory
if bento_service.artifacts:
bento_service.artifacts.save(module_base_path)
# write conda environment, requirement.txt
bento_service.env.save(path)
# TODO: add bentoml.find_packages helper for more fine grained control over this
# process, e.g. packages=find_packages(base, [], exclude=[], used_module_only=True)
# copy over all custom model code
module_name, module_file = copy_used_py_modules(
bento_service.__class__.__module__,
os.path.join(path, bento_service.name))
# create __init__.py
with open(os.path.join(path, bento_service.name, "__init__.py"), "w") as f:
f.write(
INIT_PY_TEMPLATE.format(
service_name=bento_service.name,
module_name=module_name,
pypi_package_version=bento_service.version,
))
# write setup.py, make exported model pip installable
setup_py_content = BENTO_MODEL_SETUP_PY_TEMPLATE.format(
name=bento_service.name,
pypi_package_version=bento_service.version,
long_description=model_description,
)
with open(os.path.join(path, "setup.py"), "w") as f:
f.write(setup_py_content)
with open(os.path.join(path, "MANIFEST.in"), "w") as f:
f.write(MANIFEST_IN_TEMPLATE.format(service_name=bento_service.name))
# write Dockerfile
with open(os.path.join(path, "Dockerfile"), "w") as f:
f.write(BENTO_SERVICE_DOCKERFILE_CPU_TEMPLATE)
with open(os.path.join(path, "Dockerfile-sagemaker"), "w") as f:
f.write(BENTO_SERVICE_DOCKERFILE_SAGEMAKER_TEMPLATE)
# write bento init sh for install targz bundles
with open(os.path.join(path, 'bentoml_init.sh'), 'w') as f:
f.write(BENTO_INIT_SH_TEMPLATE)
# write bentoml.yml
config = BentoArchiveConfig()
config["metadata"].update({
"service_name": bento_service.name,
"service_version": bento_service.version,
"module_name": module_name,
"module_file": module_file,
})
config["env"] = bento_service.env.to_dict()
config['apis'] = _get_apis_list(bento_service)
config['artifacts'] = _get_artifacts_list(bento_service)
config.write_to_path(path)
# Also write bentoml.yml to module base path to make it accessible
# as package data after pip installed as a python package
config.write_to_path(module_base_path)
# if bentoml package in editor mode(pip install -e), will include
# that bentoml package to bento archive
if _is_bentoml_in_develop_mode():
add_local_bentoml_package_to_repo(path)
logger.info(
"Successfully saved Bento '%s:%s' to path: %s",
bento_service.name,
bento_service.version,
path,
)
def save_to_dir(bento_service, path, version=None):
"""Save given BentoService along with all its artifacts, source code and
dependencies to target file path, assuming path exist and empty. If target path
is not empty, this call may override existing files in the given path.
Args:
bento_service (bentoml.service.BentoService): a Bento Service instance
path (str): Destination of where the bento service will be saved
"""
track_save(bento_service)
from bentoml.service import BentoService
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"save_to_dir only work with instance of custom BentoService class")
if version is not None:
bento_service.set_version(version)
if not os.path.exists(path):
raise BentoMLException("Directory '{}' not found".format(path))
for artifact in bento_service._artifacts:
if artifact.name not in bento_service._packed_artifacts:
logger.warning(
"Missing declared artifact '%s' for BentoService '%s'",
artifact.name,
bento_service.name,
)
module_base_path = os.path.join(path, bento_service.name)
try:
os.mkdir(module_base_path)
except FileExistsError:
raise BentoMLException(
f"Existing module file found for BentoService {bento_service.name}"
)
# write README.md with custom BentoService's docstring if presented
saved_bundle_readme = DEFAULT_SAVED_BUNDLE_README.format(
bento_service.name, bento_service.version)
if bento_service.__class__.__doc__:
saved_bundle_readme += "\n"
saved_bundle_readme += bento_service.__class__.__doc__.strip()
with open(os.path.join(path, "README.md"), "w") as f:
f.write(saved_bundle_readme)
# save all model artifacts to 'base_path/name/artifacts/' directory
if bento_service.artifacts:
bento_service.artifacts.save(module_base_path)
# write conda environment, requirement.txt
bento_service.env.save(path, bento_service)
# TODO: add bentoml.find_packages helper for more fine grained control over this
# process, e.g. packages=find_packages(base, [], exclude=[], used_module_only=True)
# copy over all custom model code
module_name, module_file = copy_used_py_modules(
bento_service.__class__.__module__,
os.path.join(path, bento_service.name))
# create __init__.py
with open(os.path.join(path, bento_service.name, "__init__.py"), "w") as f:
f.write(
INIT_PY_TEMPLATE.format(
service_name=bento_service.name,
module_name=module_name,
pypi_package_version=bento_service.version,
))
# write setup.py, this make saved BentoService bundle pip installable
setup_py_content = BENTO_SERVICE_BUNDLE_SETUP_PY_TEMPLATE.format(
name=bento_service.name,
pypi_package_version=bento_service.version,
long_description=saved_bundle_readme,
)
with open(os.path.join(path, "setup.py"), "w") as f:
f.write(setup_py_content)
with open(os.path.join(path, "MANIFEST.in"), "w") as f:
f.write(MANIFEST_IN_TEMPLATE.format(service_name=bento_service.name))
# write Dockerfile
with open(os.path.join(path, "Dockerfile"), "w") as f:
f.write(BENTO_SERVICE_DOCKERFILE_CPU_TEMPLATE)
# write bento init sh for install targz bundles
bentoml_init_script_file = os.path.join(path, 'bentoml_init.sh')
with open(bentoml_init_script_file, 'w') as f:
f.write(BENTO_INIT_SH_TEMPLATE)
# chmod +x bentoml_init_script file
st = os.stat(bentoml_init_script_file)
os.chmod(bentoml_init_script_file, st.st_mode | stat.S_IEXEC)
# write bentoml.yml
config = SavedBundleConfig(bento_service)
config["metadata"].update({
"module_name": module_name,
"module_file": module_file
})
config.write_to_path(path)
# Also write bentoml.yml to module base path to make it accessible
# as package data after pip installed as a python package
config.write_to_path(module_base_path)
# if bentoml package in editor mode(pip install -e), will include
# that bentoml package to saved BentoService bundle
if _is_bentoml_in_develop_mode():
add_local_bentoml_package_to_repo(path)
logger.info(
"BentoService bundle '%s:%s' created at: %s",
bento_service.name,
bento_service.version,
path,
)
def upload_bento_service(bento_service, base_path=None, version=None):
"""Save given bento_service via BentoML's default Yatai service, which manages
all saved Bento files and their deployments in cloud platforms. If remote yatai
service has not been configured, this will default to saving new Bento to local
file system under BentoML home directory
Args:
bento_service (bentoml.service.BentoService): a Bento Service instance
base_path (str): optional, base path of the bento repository
version (str): optional,
Return:
URI to where the BentoService is being saved to
"""
track_save(bento_service)
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"Only instance of custom BentoService class can be saved or uploaded"
)
if version is not None:
bento_service.set_version(version)
# if base_path is not None, default repository base path in config will be override
if base_path is not None:
logger.warning("Overriding default repository path to '%s'", base_path)
from bentoml.yatai import get_yatai_service
yatai = get_yatai_service(repo_base_url=base_path)
request = AddBentoRequest(bento_name=bento_service.name,
bento_version=bento_service.version)
response = yatai.AddBento(request)
if response.status.status_code != Status.OK:
raise BentoMLException(
"Error adding bento to repository: {}:{}".format(
response.status.status_code, response.status.error_message))
if response.uri.type == BentoUri.LOCAL:
# Saving directory to path managed by LocalBentoRepository
save_to_dir(bento_service, response.uri.uri)
update_bento_upload_progress(yatai, bento_service)
# Return URI to saved bento in repository storage
return response.uri.uri
elif response.uri.type == BentoUri.S3:
with tempfile.TemporaryDirectory() as tmpdir:
update_bento_upload_progress(yatai, bento_service,
UploadStatus.UPLOADING, 0)
save_to_dir(bento_service, tmpdir)
fileobj = io.BytesIO()
with tarfile.open(mode="w:gz", fileobj=fileobj) as tar:
tar.add(tmpdir, arcname=bento_service.name)
fileobj.seek(0, 0)
files = {
'file': ('dummy', fileobj)
} # dummy file name because file name
# has been generated when getting the pre-signed signature.
http_response = requests.post(
response.uri.uri,
data=json.loads(response.uri.additional_fields),
files=files,
)
if http_response.status_code != 204:
update_bento_upload_progress(yatai, bento_service,
UploadStatus.ERROR)
raise BentoMLException(
"Error saving Bento to S3 with status code {} and error detail "
"is {}".format(http_response.status_code,
http_response.text))
logger.info(
"Successfully saved Bento '%s:%s' to S3: %s",
bento_service.name,
bento_service.version,
response.uri.uri,
)
update_bento_upload_progress(yatai, bento_service)
return response.uri.uri
else:
raise BentoMLException(
"Error saving Bento to target repository, URI type %s at %s not supported"
% response.uri.type,
response.uri.uri,
)
def upload_bento_service(bento_service, base_path=None, version=None):
"""Save given bento_service via BentoML's default Yatai service, which manages
all saved Bento files and their deployments in cloud platforms. If remote yatai
service has not been configured, this will default to saving new Bento to local
file system under BentoML home directory
Args:
bento_service (bentoml.service.BentoService): a Bento Service instance
base_path (str): optional, base path of the bento repository
version (str): optional,
Return:
URI to where the BentoService is being saved to
"""
track_save(bento_service)
if not isinstance(bento_service, BentoService):
raise BentoMLException(
"Only instance of custom BentoService class can be saved or uploaded"
)
if version is not None:
bento_service.set_version(version)
# if base_path is not None, default repository base path in config will be override
if base_path is not None:
logger.warning("Overriding default repository path to '%s'", base_path)
from bentoml.yatai import get_yatai_service
yatai = get_yatai_service(repo_base_url=base_path)
request = AddBentoRequest(bento_name=bento_service.name,
bento_version=bento_service.version)
response = yatai.AddBento(request)
if response.status.status_code != Status.OK:
raise BentoMLException(
"Error adding bento to repository: {}:{}".format(
response.status.status_code, response.status.error_message))
if response.uri.type == BentoUri.LOCAL:
# Saving directory to path managed by LocalBentoRepository
save_to_dir(bento_service, response.uri.uri)
upload_status = UploadStatus(status=UploadStatus.DONE)
upload_status.updated_at.GetCurrentTime()
update_bento_req = UpdateBentoRequest(
bento_name=bento_service.name,
bento_version=bento_service.version,
upload_status=upload_status,
service_metadata=bento_service._get_bento_service_metadata_pb(),
)
yatai.UpdateBento(update_bento_req)
# Return URI to saved bento in repository storage
return response.uri.uri
else:
raise BentoMLException(
"Error saving Bento to target repository, URI type %s at %s not supported"
% response.uri.type,
response.uri.uri,
)
def save(self, *args, **kwargs):
from bentoml import archive
track_save(self)
return archive.save(self, *args, **kwargs)
