pixano.app.serve

App(data_dir='.', *, library_dir=None, media_dir=None, models_dir=None, aws_endpoint=None, aws_region=None, aws_access_key=None, aws_secret_key=None, host='127.0.0.1', port=7492, pixano_inference_url=None)

The Pixano app.

Attributes:

Name	Type	Description
app	FastAPI	FastAPI App.
config	Config	App config.
server	Server	App server.

Parameters:

Name	Type	Description	Default
data_dir	str	Root data directory containing library/, media/, and models/ subdirectories.	'.'
library_dir	str | None	Override for the library directory. If not provided, defaults to data_dir/library.	None
media_dir	str | None	Override for the media directory. If not provided, defaults to data_dir/media.	None
models_dir	str | None	Override for the models directory. If not provided, defaults to data_dir/models.	None
aws_endpoint	str | None	S3 endpoint URL, use 'AWS' if not provided. Used if library_dir is an S3 path.	None
aws_region	str | None	S3 region name, not always required for private storages. Used if library_dir is an S3 path.	None
aws_access_key	str | None	S3 AWS access key. Used if library_dir is an S3 path.	None
aws_secret_key	str | None	S3 AWS secret key. Used if library_dir is an S3 path.	None
host	str	App host.	'127.0.0.1'
port	int	App port.	7492
pixano_inference_url	str | None	Pixano inference URL if any.	None

Source code in pixano/app/serve.py

def __init__(
    self,
    data_dir: str = ".",
    *,
    library_dir: str | None = None,
    media_dir: str | None = None,
    models_dir: str | None = None,
    aws_endpoint: str | None = None,
    aws_region: str | None = None,
    aws_access_key: str | None = None,
    aws_secret_key: str | None = None,
    host: str = "127.0.0.1",
    port: int = 7492,
    pixano_inference_url: str | None = None,
):
    """Initialize and serve the Pixano app.

    Args:
        data_dir: Root data directory containing library/, media/,
            and models/ subdirectories.
        library_dir: Override for the library directory. If not
            provided, defaults to data_dir/library.
        media_dir: Override for the media directory. If not
            provided, defaults to data_dir/media.
        models_dir: Override for the models directory. If not
            provided, defaults to data_dir/models.
        aws_endpoint: S3 endpoint URL, use 'AWS' if not provided.
            Used if library_dir is an S3 path.
        aws_region: S3 region name, not always required for
            private storages. Used if library_dir is an S3 path.
        aws_access_key: S3 AWS access key. Used if library_dir is
            an S3 path.
        aws_secret_key: S3 AWS secret key. Used if library_dir
            is an S3 path.
        host: App host.
        port: App port.
        pixano_inference_url: Pixano inference URL if any.
    """

    # Override app settings
    @lru_cache
    def get_settings_override():
        inference_providers: dict = {}
        if pixano_inference_url is not None:
            from pixano.inference.providers.pixano_inference import PixanoInferenceProvider

            provider = PixanoInferenceProvider(url=pixano_inference_url)
            inference_providers[provider.name] = provider
        kwargs: dict = {
            "data_dir": data_dir,
            "aws_endpoint": aws_endpoint,
            "aws_region": aws_region,
            "aws_access_key": aws_access_key,
            "aws_secret_key": aws_secret_key,
            "inference_providers": inference_providers,
        }
        if inference_providers:
            kwargs["default_inference_provider"] = next(iter(inference_providers))
        if library_dir is not None:
            kwargs["library_dir"] = library_dir
        if media_dir is not None:
            kwargs["media_dir"] = media_dir
        if models_dir is not None:
            kwargs["models_dir"] = models_dir
        return Settings(**kwargs)

    # Create app
    settings = get_settings_override()
    templates = Jinja2Templates(directory=TEMPLATE_PATH)
    self.app = create_app(settings=settings)
    self.app.dependency_overrides[get_settings] = get_settings_override

    @self.app.get("/", response_class=HTMLResponse)
    def main_page(request: fastapi.Request):
        return templates.TemplateResponse("index.html", {"request": request})

    @self.app.get("/{ds_id}/dataset", response_class=HTMLResponse)
    async def dataset_page(request: fastapi.Request):
        return templates.TemplateResponse("index.html", {"request": request})

    @self.app.get("/{ds_id}/dashboard", response_class=HTMLResponse)
    async def dashboard_page(request: fastapi.Request):
        return templates.TemplateResponse("index.html", {"request": request})

    @self.app.get("/{ds_id}/dataset/{item_id}", response_class=HTMLResponse)
    async def item_page(request: fastapi.Request):
        return templates.TemplateResponse("index.html", {"request": request})

    try:
        self.app.mount("/_app", StaticFiles(directory=ASSETS_PATH), name="assets")
    # TODO: properly define environment variable for production to raise a RuntimeError accordingly
    except RuntimeError:
        warnings.warn(
            "Pixano app assets not found. If it is a production environment, this is not expected, "
            "check if you have built the assets for the UI."
        )
    self.config = uvicorn.Config(self.app, host=host, port=port)
    self.server = uvicorn.Server(self.config)

    # Serve app
    task_functions[self.get_env()](self.server.serve())  # type: ignore[operator]

display(height=1000)

Display the Pixano app.

Parameters:

Name	Type	Description	Default
height	int	Frame height.	1000

Source code in pixano/app/serve.py

def display(self, height: int = 1000) -> None:
    """Display the Pixano app.

    Args:
        height: Frame height.
    """
    # Wait for app to be online
    while not self.server.started:
        task_functions[self.get_env()](asyncio.wait(0.1))  # type: ignore[operator, call-overload]

    # Display app
    for server in self.server.servers:
        for socket in server.sockets:
            address = socket.getsockname()
            display_functions[self.get_env()](url=f"http://{address[0]}", port=address[1], height=height)  # type: ignore[operator]

get_env()

Get the app's current running environment.

Returns:

Type	Description
str	Running environment.

Source code in pixano/app/serve.py

def get_env(self) -> str:
    """Get the app's current running environment.

    Returns:
        Running environment.
    """
    # If Google colab import succeeds
    try:
        import google.colab  # noqa: F401, I001 #type: ignore
        import IPython
    except ImportError:
        pass
    else:
        if IPython.get_ipython() is not None:
            return "colab"

    # If IPython import succeeds
    try:
        import IPython
    except ImportError:
        pass
    else:
        ipython = IPython.get_ipython()
        if ipython is not None and ipython.has_trait("kernel"):
            return "ipython"

    # Else
    return "none"