python_code stringlengths 0 108k |
|---|
raise NotImplementedError(
f"""\
Support for "{__name__}" is temporarily unavailable as BentoML transition to the new \
design in version 1.0.0 release. Before this module is officially implemented in \
BentoML, users may use Custom Runner as a workaround. Learn more at http://docs.bentoml.org
"""
)
|
raise NotImplementedError(
f"""\
Support for "{__name__}" is temporarily unavailable as BentoML transition to the new \
design in version 1.0.0 release. Before this module is officially implemented in \
BentoML, users may use Custom Runner as a workaround. Learn more at http://docs.bentoml.org
"""
)
|
raise NotImplementedError(
f"""\
Support for "{__name__}" is temporarily unavailable as BentoML transition to the new \
design in version 1.0.0 release. Before this module is officially implemented in \
BentoML, users may use Custom Runner as a workaround. Learn more at http://docs.bentoml.org
"""
)
|
from __future__ import annotations
import os
import typing as t
import datetime
from abc import ABC
from abc import abstractmethod
from contextlib import contextmanager
import fs
import fs.errors
from fs.base import FS
from .tag import Tag
from .types import PathType
from .exportable import Exportable
from ..excepti... |
from __future__ import annotations
from contextvars import ContextVar
from opentelemetry import trace # type: ignore[import]
class ServiceContextClass:
def __init__(self) -> None:
self.request_id_var: ContextVar[int | None] = ContextVar(
"request_id_var", default=None
)
self... |
from __future__ import annotations
import typing as t
import logging
import logging.config
from .trace import ServiceContext
from .configuration import get_debug_mode
from .configuration import get_quiet_mode
default_factory = logging.getLogRecordFactory()
# TODO: remove this filter after implementing CLI output a... |
from __future__ import annotations
import os
import re
import typing as t
import logging
import urllib.parse
from abc import ABC
from abc import abstractmethod
import fs
import fs.copy
import fs.errors
import fs.mirror
import fs.opener
import fs.tempfs
from fs import open_fs
from fs.base import FS
T = t.TypeVar("T",... |
from __future__ import annotations
import io
import os
import sys
import typing as t
import logging
from types import TracebackType
from typing import TYPE_CHECKING
from datetime import date
from datetime import time
from datetime import datetime
from datetime import timedelta
from dataclasses import dataclass
from .... |
from __future__ import annotations
import typing as t
import contextvars
from abc import ABC
from abc import abstractmethod
from typing import TYPE_CHECKING
import attr
import starlette.datastructures
from .utils.http import Cookie
if TYPE_CHECKING:
import starlette.requests
import starlette.responses
cla... |
import re
import uuid
import base64
import typing as t
import logging
import fs
import attr
from .utils import bentoml_cattr
from ..exceptions import InvalidArgument
from ..exceptions import BentoMLException
logger = logging.getLogger(__name__)
tag_fmt = "[a-z0-9]([-._a-z0-9]*[a-z0-9])?"
tag_max_length = 63
tag_max... |
import os
import uuid
import typing as t
import logging
import multiprocessing
from typing import TYPE_CHECKING
from dataclasses import dataclass
import yaml
from schema import Or
from schema import And
from schema import Use
from schema import Schema
from schema import Optional
from schema import SchemaError
from dee... |
import os
import typing as t
import logging
from functools import lru_cache
try:
import importlib.metadata as importlib_metadata
except ModuleNotFoundError:
import importlib_metadata
import yaml
try:
import bentoml._version as version_mod
except ImportError:
# Since we aren't VCS _version.py, which i... |
from typing import TYPE_CHECKING
if TYPE_CHECKING:
import typing as t
from starlette.types import Send as ASGISend
from starlette.types import Scope as ASGIScope
from starlette.types import ASGIApp
from starlette.types import Message as ASGIMessage
from starlette.types import Receive as ASGIRe... |
import typing as t
from transformers.modeling_utils import PreTrainedModel
from transformers.pipelines.base import Pipeline as TransformersPipeline
from transformers.modeling_tf_utils import TFPreTrainedModel
from transformers.tokenization_utils import PreTrainedTokenizer
from transformers.configuration_utils import P... |
import typing as t
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Literal
from pandas import Series as _PdSeries
from pandas import DataFrame as PdDataFrame
from pyarrow.plasma import ObjectID
from pyarrow.plasma import PlasmaClient
PdSeries = _PdSeries[t.Any]
DataF... |
import typing as t
from tensorflow.python.framework.ops import Tensor
from tensorflow.python.module.module import Module
from tensorflow.python.client.session import Session
from tensorflow.python.eager.function import FunctionSpec
from tensorflow.python.eager.def_function import Function
from tensorflow.python.framew... |
import time
import typing as t
import asyncio
import logging
import functools
import traceback
import collections
import numpy as np
from ..utils import cached_property
from ..utils.alg import TokenBucket
logger = logging.getLogger(__name__)
class NonBlockSema:
def __init__(self, count):
self.sema = co... |
from __future__ import annotations
import typing as t
import logging
from typing import TYPE_CHECKING
from functools import lru_cache
import attr
from ..types import ParamSpec
from ..utils import first_not_none
from .resource import Resource
from .runnable import Runnable
from .strategy import Strategy
from .strateg... |
from __future__ import annotations
import os
import re
import math
import typing as t
import logging
import functools
import attr
import psutil
from cattrs.gen import override
from cattrs.gen import make_dict_unstructure_fn
from ..utils import bentoml_cattr
from ...exceptions import BentoMLException
logger = loggin... |
from .runner import Runner
from .runnable import Runnable
__all__ = ["Runner", "Runnable"]
|
import os
import abc
import math
import typing as t
import logging
from .resource import Resource
from .runnable import Runnable
logger = logging.getLogger(__name__)
class Strategy(abc.ABC):
@classmethod
@abc.abstractmethod
def get_worker_count(
cls,
runnable_class: t.Type[Runnable],
... |
from __future__ import annotations
import abc
import pickle
import typing as t
import itertools
from typing import TYPE_CHECKING
from simple_di import inject
from simple_di import Provide
from ..types import LazyType
from ..configuration.containers import DeploymentContainer
SingleType = t.TypeVar("SingleType")
Bat... |
from __future__ import annotations
import typing as t
import logging
import itertools
from typing import TYPE_CHECKING
from bentoml.exceptions import InvalidArgument
logger = logging.getLogger(__name__)
if TYPE_CHECKING:
from aiohttp import MultipartWriter
from starlette.requests import Request
from .... |
from __future__ import annotations
import typing as t
import logging
from abc import ABC
from abc import abstractmethod
from typing import overload
from typing import TYPE_CHECKING
import attr
from ..types import LazyType
from ..types import ParamSpec
if TYPE_CHECKING:
from ..types import AnyType
T = t.TypeVar... |
from __future__ import annotations
import json
import typing as t
import asyncio
import functools
from typing import TYPE_CHECKING
from json.decoder import JSONDecodeError
from urllib.parse import urlparse
from . import RunnerHandle
from ..container import Payload
from ...utils.uri import uri_to_path
from ....excepti... |
from __future__ import annotations
import typing as t
import functools
from typing import TYPE_CHECKING
from bentoml._internal.runner.utils import Params
from bentoml._internal.runner.container import Payload
from bentoml._internal.runner.container import AutoContainer
from . import RunnerHandle
if TYPE_CHECKING:
... |
from __future__ import annotations
import typing as t
import logging
from abc import ABC
from abc import abstractmethod
from typing import TYPE_CHECKING
from ....exceptions import StateException
if TYPE_CHECKING:
from ..runner import Runner
from ..runner import RunnerMethod
R = t.TypeVar("R")
P = t.... |
from __future__ import annotations
import typing as t
from typing import TYPE_CHECKING
from starlette.requests import Request
from multipart.multipart import parse_options_header
from starlette.responses import Response
from .base import IODescriptor
from ...exceptions import InvalidArgument
from ...exceptions impor... |
from __future__ import annotations
import io
import typing as t
import logging
import functools
import importlib.util
from enum import Enum
from typing import TYPE_CHECKING
from starlette.requests import Request
from starlette.responses import Response
from .base import IODescriptor
from .json import MIME_TYPE_JSON
... |
from .base import IODescriptor
from .file import File
from .json import JSON
from .text import Text
from .image import Image
from .numpy import NumpyNdarray
from .pandas import PandasSeries
from .pandas import PandasDataFrame
from .multipart import Multipart
__all__ = [
"File",
"Image",
"IODescriptor",
... |
from __future__ import annotations
import json
import typing as t
import logging
from typing import TYPE_CHECKING
from starlette.requests import Request
from starlette.responses import Response
from .base import IODescriptor
from .json import MIME_TYPE_JSON
from ..types import LazyType
from ..utils.http import set_c... |
from __future__ import annotations
import io
import typing as t
import logging
from typing import TYPE_CHECKING
from starlette.requests import Request
from multipart.multipart import parse_options_header
from starlette.responses import Response
from starlette.datastructures import UploadFile
from .base import IODesc... |
from __future__ import annotations
import typing as t
from typing import TYPE_CHECKING
from starlette.requests import Request
from starlette.responses import Response
from .base import IODescriptor
from ..utils.http import set_cookies
if TYPE_CHECKING:
from ..context import InferenceApiContext as Context
MIME... |
from __future__ import annotations
import json
import typing as t
import dataclasses
from typing import TYPE_CHECKING
from starlette.requests import Request
from starlette.responses import Response
from .base import IODescriptor
from ..types import LazyType
from ..utils.http import set_cookies
from ...exceptions imp... |
from __future__ import annotations
import io
import typing as t
from typing import TYPE_CHECKING
from urllib.parse import quote
from starlette.requests import Request
from multipart.multipart import parse_options_header
from starlette.responses import Response
from .base import IODescriptor
from ..types import LazyT... |
from __future__ import annotations
import typing as t
from abc import ABC
from abc import abstractmethod
from typing import TYPE_CHECKING
from starlette.requests import Request
from starlette.responses import Response
if TYPE_CHECKING:
from types import UnionType
from ..types import LazyType
from ..cont... |
import abc
import typing as t
import logging
from typing import TYPE_CHECKING
from starlette.responses import PlainTextResponse
from starlette.exceptions import HTTPException
if TYPE_CHECKING:
from starlette.routing import BaseRoute
from starlette.requests import Request
from starlette.responses import Re... |
from __future__ import annotations
import json
import typing as t
import asyncio
import logging
import functools
from typing import TYPE_CHECKING
from functools import partial
from ..trace import ServiceContext
from ..runner.utils import PAYLOAD_META_HEADER
from ..runner.utils import multipart_to_payload_params
from ... |
from __future__ import annotations
import os
import sys
import typing as t
import asyncio
import logging
import functools
from typing import TYPE_CHECKING
from simple_di import inject
from simple_di import Provide
from ..context import trace_context
from ..context import InferenceApiContext as Context
from ...except... |
import logging
from timeit import default_timer
from typing import TYPE_CHECKING
from contextvars import ContextVar
if TYPE_CHECKING:
from .. import external_typing as ext
REQ_CONTENT_LENGTH = "REQUEST_CONTENT_LENGTH"
REQ_CONTENT_TYPE = "REQUEST_CONTENT_TYPE"
RESP_CONTENT_LENGTH = "RESPONSE_CONTENT_LENGTH"
RESP_C... |
import os
import sys
import json
import math
import shutil
import typing as t
import logging
import tempfile
import contextlib
import psutil
from simple_di import inject
from simple_di import Provide
from bentoml import load
from ..utils import reserve_free_port
from ..utils.uri import path_to_uri
from ..utils.circu... |
import logging
import contextvars
from timeit import default_timer
from typing import TYPE_CHECKING
from simple_di import inject
from simple_di import Provide
from ..configuration.containers import DeploymentContainer
if TYPE_CHECKING:
from .. import external_typing as ext
from ..service import Service
f... |
# type: ignore[reportMissingTypeStubs]
import os
import sys
import typing as t
import logging
from functools import partial
logger = logging.getLogger(__name__)
class PrometheusClient:
def __init__(
self,
*,
namespace: str = "",
multiproc: bool = True,
multiproc_dir: t.Opt... |
from __future__ import annotations
import sys
import socket
import typing as t
from typing import TYPE_CHECKING
from urllib.parse import urlparse
import psutil
from bentoml import load
from bentoml._internal.utils.uri import uri_to_path
from ...log import SERVER_LOGGING_CONFIG
from ...trace import ServiceContext
i... |
def main():
from ...utils.ngrok import start_ngrok
from ...configuration.containers import DeploymentContainer
start_ngrok(DeploymentContainer.api_server_config.port.get())
if __name__ == "__main__":
main()
|
from __future__ import annotations
import sys
import json
import socket
import typing as t
from typing import TYPE_CHECKING
from urllib.parse import urlparse
import psutil
import bentoml
from ...log import SERVER_LOGGING_CONFIG
from ...trace import ServiceContext
if TYPE_CHECKING:
from asgiref.typing import AS... |
import socket
import typing as t
from urllib.parse import urlparse
import click
import psutil
from bentoml import load
from ...log import SERVER_LOGGING_CONFIG
from ...trace import ServiceContext
@click.command()
@click.argument("bento_identifier", type=click.STRING, required=False, default=".")
@click.option("--b... |
import time
class FixedBucket:
"""
Fixed size FIFO container.
"""
def __init__(self, size):
self._data = [None] * size
self._cur = 0
self._size = size
self._flag_full = False
def put(self, v):
self._data[self._cur] = v
self._cur += 1
if sel... |
from __future__ import annotations
import typing as t
import logging
import click
logger = logging.getLogger(__name__)
def unparse_click_params(
params: dict[str, t.Any],
command_params: list[click.Parameter],
*,
factory: t.Callable[..., t.Any] | None = None,
) -> list[str]:
"""
Unparse cli... |
import shutil
import logging
import os.path
import tempfile
from ..configuration import get_debug_mode
logger = logging.getLogger(__name__)
class TempDirectory(object):
"""
Helper class that creates and cleans up a temporary directory, can
be used as a context manager.
>>> with TempDirectory() as t... |
from __future__ import annotations
import typing as t
from datetime import datetime
import cattr
from attr import fields
from cattr import override # type: ignore
from cattr.gen import AttributeOverride
bentoml_cattr = cattr.Converter()
def omit_if_init_false(cls: t.Any) -> dict[str, AttributeOverride]:
retur... |
from __future__ import annotations
import os
import typing as t
import logging
import functools
import subprocess
from typing import TYPE_CHECKING
from ..types import PathType
from ...exceptions import BentoMLException
if TYPE_CHECKING:
P = t.ParamSpec("P")
logger = logging.getLogger(__name__)
DOCKER_BUILDX_CM... |
import sys
import types
import typing as t
import logging
import importlib
from ...exceptions import MissingDependencyException
logger = logging.getLogger(__name__)
class LazyLoader(types.ModuleType):
"""
LazyLoader module borrowed from Tensorflow
https://github.com/tensorflow/tensorflow/blob/v2.2.0/te... |
import math
import time
import asyncio
from collections import defaultdict
from tabulate import tabulate
def wrap_line(s, line_width=120, sep="\n"):
ls = s.split(sep)
outs = []
for line in ls:
while len(line) > line_width:
outs.append(line[:line_width])
line = line[line_wi... |
import os
import json
import time
import shutil
import logging
import zipfile
import platform
import tempfile
import subprocess
from pathlib import Path
from threading import Thread
import requests
from ...exceptions import BentoMLException
logger = logging.getLogger(__name__)
def get_command() -> str:
"""
... |
import io
import json
import typing as t
import itertools
from typing import TYPE_CHECKING
from . import catch_exceptions
from .csv import csv_row
from .csv import csv_quote
from .csv import csv_split
from .csv import csv_unquote
from .csv import csv_splitlines
from .lazy_loader import LazyLoader
from ...exceptions im... |
from __future__ import annotations
import os
import sys
import uuid
import random
import socket
import typing as t
import functools
import contextlib
from typing import overload
from typing import TYPE_CHECKING
from pathlib import Path
from datetime import date
from datetime import time
from datetime import datetime
f... |
# type: ignore[reportMissingTypeStubs]
import typing as t
from typing import TYPE_CHECKING
from opentelemetry.trace import get_current_span
from opentelemetry.sdk.trace.sampling import Decision
from opentelemetry.sdk.trace.sampling import ALWAYS_ON
from opentelemetry.sdk.trace.sampling import ParentBased
from opentele... |
import re
import typing as t
import logging
from typing import TYPE_CHECKING
from ...exceptions import BentoMLException
logger = logging.getLogger(__name__)
if TYPE_CHECKING:
import click
def to_valid_docker_image_name(name: str) -> str:
# https://docs.docker.com/engine/reference/commandline/tag/#extended-... |
import typing as t
import logging
import importlib.util
from typing import TYPE_CHECKING
from bentoml.exceptions import BentoMLException
from ..types import LazyType
from .lazy_loader import LazyLoader
try:
import importlib.metadata as importlib_metadata
except ImportError:
import importlib_metadata
if TYPE... |
import signal
import subprocess
from typing import TYPE_CHECKING
import psutil
if TYPE_CHECKING:
import typing as t
def kill_subprocess_tree(p: "subprocess.Popen[t.Any]") -> None:
"""
Tell the process to terminate and kill all of its children. Availabe both on Windows and Linux.
Note: It will return... |
from __future__ import annotations
import io
import uuid
import typing as t
from typing import TYPE_CHECKING
import multipart.multipart as multipart
from starlette.requests import Request
from starlette.responses import Response
from starlette.formparsers import MultiPartMessage
from starlette.datastructures import H... |
import os
import pathlib
from urllib.parse import unquote
from urllib.parse import urlparse
from urllib.request import url2pathname
import psutil
def path_to_uri(path: str) -> str:
"""
Convert a path to a URI.
Args:
path: Path to convert to URI.
Returns:
URI string. (quoted, absolut... |
from __future__ import annotations
from typing import TYPE_CHECKING
import attr
if TYPE_CHECKING:
import starlette.responses
@attr.define
class Cookie:
key: str
value: str
max_age: int | None
expires: int | None
path: str
domain: str | None
secure: bool
httponly: bool
samesi... |
# CSV utils following https://tools.ietf.org/html/rfc4180
import typing as t
def csv_splitlines(string: str) -> t.Iterator[str]:
if '"' in string:
def _iter_line(line: str) -> t.Iterator[str]:
quoted = False
last_cur = 0
for i, c in enumerate(line):
if ... |
try:
import importlib.metadata as importlib_metadata
except ImportError:
import importlib_metadata
get_pkg_version = importlib_metadata.version
|
import json
import typing as t
from dataclasses import asdict
from dataclasses import fields as get_fields
from dataclasses import is_dataclass
class DataclassJsonEncoder(json.JSONEncoder):
"""Special json encoder for numpy types"""
def default(self, o: t.Any): # pylint: disable=method-hidden
if is_... |
from __future__ import annotations
import typing as t
import logging
import pathlib
from typing import TYPE_CHECKING
from urllib.parse import urlparse
from circus.plugins import CircusPlugin # type: ignore[reportMissingTypeStubs]
if TYPE_CHECKING:
from circus.arbiter import Arbiter # type: ignore[reportMissing... |
import typing as t
from typing import TYPE_CHECKING
from .. import calc_dir_size
from .schemas import BentoBuildEvent
if TYPE_CHECKING:
from ...bento.bento import Bento
def _cli_bentoml_build_event(
cmd_group: str,
cmd_name: str,
return_value: "t.Optional[Bento]",
) -> BentoBuildEvent: # pragma: no... |
import os
import typing as t
import logging
import secrets
import threading
import contextlib
from typing import TYPE_CHECKING
from datetime import datetime
from datetime import timezone
from functools import wraps
from functools import lru_cache
import attr
import requests
from simple_di import inject
from simple_di ... |
from .schemas import CliEvent
from .schemas import ModelSaveEvent
from .schemas import BentoBuildEvent
from .schemas import ServeUpdateEvent
from .cli_events import cli_events_map
from .usage_stats import track
from .usage_stats import ServeInfo
from .usage_stats import track_serve
from .usage_stats import get_serve_in... |
import os
import re
import uuid
import typing as t
from abc import ABC
from typing import TYPE_CHECKING
from datetime import datetime
from datetime import timezone
from platform import platform
from platform import python_version
from functools import lru_cache
import attr
import yaml
import psutil
import attr.convert... |
from .model import Model
from .model import copy_model
from .model import ModelStore
from .model import ModelContext
from .model import ModelOptions
# Deprecated. Use framework module local constants and name the saved files with API
# Version in mind. E.g.:
# api_v1_model_file_name = "saved_model.pkl"
# api_v2_model_... |
from __future__ import annotations
import io
import typing as t
import logging
import importlib
from sys import version_info as pyver
from typing import overload
from typing import TYPE_CHECKING
from datetime import datetime
from datetime import timezone
import fs
import attr
import yaml
import fs.errors
import fs.mi... |
# type: ignore[reportUnusedFunction]
import sys
import typing as t
import logging
import click
from ..log import configure_server_logging
from ..configuration.containers import DeploymentContainer
logger = logging.getLogger(__name__)
DEFAULT_DEV_SERVER_HOST = "127.0.0.1"
DEFAULT_RELOAD_DELAY = 0.25
def add_serve_... |
from __future__ import annotations
import sys
import typing as t
import logging
import click
from bentoml.bentos import containerize as containerize_bento
from ..utils import kwargs_transformers
from ..utils.docker import validate_tag
logger = logging.getLogger("bentoml")
def containerize_transformer(
value:... |
# type: ignore[reportUnusedFunction]
import sys
import json
import typing as t
import logging
from typing import TYPE_CHECKING
import yaml
import click
from simple_di import inject
from simple_di import Provide
from rich.table import Table
from rich.syntax import Syntax
from rich.console import Console
from bentoml i... |
import click
import psutil
from bentoml import __version__ as BENTOML_VERSION
from .yatai import add_login_command
from .click_utils import BentoMLCommandGroup
from .bento_server import add_serve_command
from .containerize import add_containerize_command
from .bento_management import add_bento_management_commands
fro... |
import os
import re
import time
import typing as t
import difflib
import logging
import functools
from typing import TYPE_CHECKING
import click
from click import ClickException
from click.exceptions import UsageError
from ..log import configure_logging
from ...exceptions import BentoMLException
from ..configuration i... |
# type: ignore[reportUnusedFunction]
import logging
import click
from bentoml.exceptions import CLIException
from ..cli.click_utils import BentoMLCommandGroup
from ..yatai_rest_api_client.yatai import YataiRESTApiClient
from ..yatai_rest_api_client.config import add_context
from ..yatai_rest_api_client.config import... |
# type: ignore[reportUnusedFunction]
import json
import typing as t
import logging
from typing import TYPE_CHECKING
import yaml
import click
from simple_di import inject
from simple_di import Provide
from rich.table import Table
from rich.syntax import Syntax
from rich.console import Console
from bentoml import Tag
f... |
import os
import logging
from typing import List
from typing import Optional
from pathlib import Path
import attr
import yaml
import cattr
from bentoml.exceptions import YataiRESTApiClientError
from .yatai import YataiRESTApiClient
from ..configuration.containers import BENTOML_HOME
logger = logging.getLogger(__nam... |
import json
from enum import Enum
from typing import Any
from typing import Dict
from typing import List
from typing import Type
from typing import TypeVar
from typing import Optional
from datetime import datetime
import attr
import cattr
from dateutil.parser import parse
time_format = "%Y-%m-%d %H:%M:%S.%f"
def da... |
import logging
from typing import Optional
from urllib.parse import urljoin
import requests
from .schemas import UserSchema
from .schemas import BentoSchema
from .schemas import ModelSchema
from .schemas import schema_to_json
from .schemas import schema_from_json
from .schemas import CreateBentoSchema
from .schemas i... |
import io
import typing as t
import tarfile
from pathlib import Path
from tempfile import NamedTemporaryFile
from functools import wraps
from contextlib import contextmanager
from concurrent.futures import ThreadPoolExecutor
import fs
import requests
from rich.live import Live
from simple_di import inject
from simple_... |
import os
import uuid
import shutil
import logging
import importlib
import importlib.util
from ..configuration import is_pypi_installed_bentoml
from ..utils.tempdir import TempDirectory
logger = logging.getLogger(__name__)
BENTOML_DEV_BUILD = "BENTOML_BUNDLE_LOCAL_BUILD"
def build_bentoml_editable_wheel(target_pat... |
from __future__ import annotations
import os
import re
import typing as t
import logging
from sys import version_info
from typing import TYPE_CHECKING
import attr
from jinja2 import Environment
from jinja2.loaders import FileSystemLoader
from ..utils import resolve_user_filepath
from .docker import DistroSpec
from .... |
from .bento import Bento
from .bento import BentoStore
__all__ = ["Bento", "BentoStore"]
|
from __future__ import annotations
import os
import typing as t
import logging
from typing import TYPE_CHECKING
from datetime import datetime
from datetime import timezone
import fs
import attr
import yaml
import fs.osfs
import pathspec
import fs.errors
import fs.mirror
from fs.copy import copy_file
from cattr.gen im... |
from __future__ import annotations
import typing as t
import logging
from typing import TYPE_CHECKING
import attr
from ...exceptions import InvalidArgument
from ...exceptions import BentoMLException
if TYPE_CHECKING:
P = t.ParamSpec("P")
logger = logging.getLogger(__name__)
# Python supported versions
SUPPOR... |
import os
import re
import sys
import typing as t
import logging
import subprocess
from sys import version_info as pyver
from typing import TYPE_CHECKING
import fs
import attr
import yaml
import fs.copy
from dotenv import dotenv_values # type: ignore
from .gen import generate_dockerfile
from ..utils import bentoml_c... |
import os
import re
import sys
import inspect
import logging
import importlib
import modulefinder
from typing import List
from typing import Tuple
from unittest.mock import patch
from ..types import PathType
from .pip_pkg import get_all_pip_installed_modules
from ...exceptions import BentoMLException
logger = logging... |
import os
import ast
import sys
import typing as t
import logging
import pkgutil
import zipfile
import zipimport
from typing import TYPE_CHECKING
from collections import defaultdict
try:
import importlib.metadata as importlib_metadata
except ImportError:
import importlib_metadata
from packaging.requirements im... |
from __future__ import annotations
import typing as t
import logging
from typing import TYPE_CHECKING
import attr
from bentoml.exceptions import BentoMLException
from ..tag import Tag
from ..models import Model
from ..runner import Runner
from ..bento.bento import get_default_bento_readme
from .inference_api import... |
import typing as t
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from . import Service
from ..io_descriptors import IODescriptor
HEALTHZ_DESC = (
"Health check endpoint. Expecting an empty response with status code"
" <code>200</code> when the service is in health state. The <code>/healthz</code... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.