unstructured-ingest 0.0.0__py3-none-any.whl

unstructured_ingest/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

unstructured_ingest/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.0"  # pragma: no cover

unstructured_ingest/cli/__init__.py

@@ -0,0 +1,14 @@
+import typing as t
+
+import click
+
+from unstructured_ingest.cli.cmds import base_dest_cmd_fns, base_src_cmd_fns
+
+src: t.List[click.Group] = [v().get_src_cmd() for v in base_src_cmd_fns]
+
+dest: t.List[click.Command] = [v().get_dest_cmd() for v in base_dest_cmd_fns]
+
+__all__ = [
+    "src",
+    "dest",
+]

unstructured_ingest/cli/base/cmd.py

@@ -0,0 +1,19 @@
+import typing as t
+from abc import ABC
+from dataclasses import dataclass, field
+
+from unstructured_ingest.cli.interfaces import CliConfig
+from unstructured_ingest.interfaces import BaseConfig
+
+
+@dataclass
+class BaseCmd(ABC):
+    cmd_name: str
+    cli_config: t.Optional[t.Type[BaseConfig]] = None
+    additional_cli_options: t.List[t.Type[CliConfig]] = field(default_factory=list)
+    addition_configs: t.Dict[str, t.Type[BaseConfig]] = field(default_factory=dict)
+    is_fsspec: bool = False
+
+    @property
+    def cmd_name_key(self):
+        return self.cmd_name.replace("-", "_")

unstructured_ingest/cli/base/dest.py

@@ -0,0 +1,87 @@
+import logging
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.base.cmd import BaseCmd
+from unstructured_ingest.cli.cmd_factory import get_src_cmd
+from unstructured_ingest.cli.common import (
+    log_options,
+)
+from unstructured_ingest.cli.interfaces import BaseConfig, CliFilesStorageConfig
+from unstructured_ingest.cli.utils import (
+    add_options,
+    conform_click_options,
+    extract_config,
+    extract_configs,
+)
+from unstructured_ingest.logger import ingest_log_streaming_init, logger
+from unstructured_ingest.runner.writers import writer_map
+
+
+@dataclass
+class BaseDestCmd(BaseCmd):
+    write_config: t.Optional[t.Type[BaseConfig]] = None
+
+    def get_dest_runner(self, source_cmd: str, options: dict, parent_options: dict):
+        src_cmd_fn = get_src_cmd(cmd_name=source_cmd)
+        src_cmd = src_cmd_fn()
+        runner = src_cmd.get_source_runner(options=parent_options)
+        addition_configs = self.addition_configs
+        if "connector_config" not in addition_configs:
+            addition_configs["connector_config"] = self.cli_config
+        if self.write_config:
+            addition_configs["write_config"] = self.write_config
+        configs = extract_configs(
+            options,
+            validate=[self.cli_config] if self.cli_config else None,
+            extras=addition_configs,
+            add_defaults=False,
+        )
+        writer_cls = writer_map[self.cmd_name_key]
+        writer = writer_cls(**configs)  # type: ignore
+        runner.writer = writer
+        runner.writer_kwargs = options
+        return runner
+
+    def check_dest_options(self, options: dict):
+        extract_config(flat_data=options, config=self.cli_config)
+
+    def dest(self, ctx: click.Context, **options):
+        if not ctx.parent:
+            raise click.ClickException("destination command called without a parent")
+        if not ctx.parent.info_name:
+            raise click.ClickException("parent command missing info name")
+        source_cmd = ctx.parent.info_name.replace("-", "_")
+        parent_options: dict = ctx.parent.params if ctx.parent else {}
+        conform_click_options(options)
+        verbose = parent_options.get("verbose", False)
+        ingest_log_streaming_init(logging.DEBUG if verbose else logging.INFO)
+        log_options(parent_options, verbose=verbose)
+        log_options(options, verbose=verbose)
+        try:
+            self.check_dest_options(options=options)
+            runner = self.get_dest_runner(
+                source_cmd=source_cmd,
+                options=options,
+                parent_options=parent_options,
+            )
+            runner.run(**parent_options)
+        except Exception as e:
+            logger.error(e, exc_info=True)
+            raise click.ClickException(str(e)) from e
+
+    def get_dest_cmd(self) -> click.Command:
+        # Dynamically create the command without the use of click decorators
+        fn = self.dest
+        fn = click.pass_context(fn)
+        cmd: click.Group = click.command(fn)
+        cmd.name = self.cmd_name
+        cmd.invoke_without_command = True
+        options = [self.cli_config] if self.cli_config else []
+        options += self.additional_cli_options
+        if self.is_fsspec and CliFilesStorageConfig not in options:
+            options.append(CliFilesStorageConfig)
+        add_options(cmd, extras=options, is_src=False)
+        return cmd

unstructured_ingest/cli/base/src.py

@@ -0,0 +1,57 @@
+import logging
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.base.cmd import BaseCmd
+from unstructured_ingest.cli.common import (
+    log_options,
+)
+from unstructured_ingest.cli.interfaces import CliFilesStorageConfig
+from unstructured_ingest.cli.utils import Group, add_options, conform_click_options, extract_configs
+from unstructured_ingest.logger import ingest_log_streaming_init, logger
+from unstructured_ingest.runner import runner_map
+
+
+@dataclass
+class BaseSrcCmd(BaseCmd):
+    def get_source_runner(self, options: dict):
+        addition_configs = self.addition_configs
+        if "connector_config" not in addition_configs:
+            addition_configs["connector_config"] = self.cli_config
+        configs = extract_configs(
+            options,
+            validate=[self.cli_config] if self.cli_config else None,
+            extras=addition_configs,
+        )
+        runner = runner_map[self.cmd_name_key]
+        return runner(**configs)  # type: ignore
+
+    def src(self, ctx: click.Context, **options):
+        if ctx.invoked_subcommand:
+            return
+
+        conform_click_options(options)
+        verbose = options.get("verbose", False)
+        ingest_log_streaming_init(logging.DEBUG if verbose else logging.INFO)
+        log_options(options, verbose=verbose)
+        try:
+            runner = self.get_source_runner(options=options)
+            runner.run(**options)
+        except Exception as e:
+            logger.error(e, exc_info=True)
+            raise click.ClickException(str(e)) from e
+
+    def get_src_cmd(self) -> click.Group:
+        # Dynamically create the command without the use of click decorators
+        fn = self.src
+        fn = click.pass_context(fn)
+        cmd: click.Group = click.group(fn, cls=Group)
+        cmd.name = self.cmd_name
+        cmd.invoke_without_command = True
+        extra_options = [self.cli_config] if self.cli_config else []
+        extra_options += self.additional_cli_options
+        if self.is_fsspec and CliFilesStorageConfig not in extra_options:
+            extra_options.append(CliFilesStorageConfig)
+        add_options(cmd, extras=extra_options)
+        return cmd

unstructured_ingest/cli/cli.py

@@ -0,0 +1,32 @@
+import click
+
+from unstructured_ingest.cli import dest, src
+from unstructured_ingest.v2.cli.cmds import dest as dest_v2
+from unstructured_ingest.v2.cli.cmds import src as src_v2
+
+
+@click.group()
+def ingest():
+    pass
+
+
+def get_cmd() -> click.Command:
+    """Construct and return a Click command object representing the main command for the CLI.
+
+    This function adds all dest_subcommand(s) to each src_subcommand, and adds all of those
+    to the main command as nested subcommands.
+    """
+    cmd = ingest
+    src_dict = {s.name: s for s in src}
+    dest_dict = {d.name: d for d in dest}
+    for s in src_v2:
+        src_dict[s.name] = s
+    for d in dest_v2:
+        dest_dict[d.name] = d
+    # Add all subcommands
+    for src_subcommand in src_dict.values():
+        # Add all destination subcommands
+        for dest_subcommand in dest_dict.values():
+            src_subcommand.add_command(dest_subcommand)
+        cmd.add_command(src_subcommand)
+    return cmd

unstructured_ingest/cli/cmd_factory.py

@@ -0,0 +1,12 @@
+import typing as t
+
+from unstructured_ingest.cli.base.src import BaseSrcCmd
+from unstructured_ingest.cli.cmds import base_src_cmd_fns
+
+
+def get_src_cmd_map() -> t.Dict[str, t.Callable[[], BaseSrcCmd]]:
+    return {b().cmd_name_key: b for b in base_src_cmd_fns}
+
+
+def get_src_cmd(cmd_name: str) -> t.Callable[[], BaseSrcCmd]:
+    return get_src_cmd_map()[cmd_name]

unstructured_ingest/cli/cmds/__init__.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import collections
+import typing as t
+
+from unstructured_ingest.cli.base.src import BaseSrcCmd
+from unstructured_ingest.cli.cmds.fsspec.sftp import get_base_src_cmd as sftp_base_src_cmd
+
+from .airtable import get_base_src_cmd as airtable_base_src_cmd
+from .astra import get_base_dest_cmd as astra_base_dest_cmd
+from .astra import get_base_src_cmd as astra_base_src_cmd
+from .azure_cognitive_search import get_base_dest_cmd as azure_cognitive_search_base_dest_cmd
+from .biomed import get_base_src_cmd as biomed_base_src_cmd
+from .chroma import get_base_dest_cmd as chroma_base_dest_cmd
+from .clarifai import get_base_dest_cmd as clarifai_base_dest_cmd
+from .confluence import get_base_src_cmd as confluence_base_src_cmd
+from .databricks_volumes import get_base_dest_cmd as databricks_volumes_dest_cmd
+from .delta_table import get_base_dest_cmd as delta_table_dest_cmd
+from .delta_table import get_base_src_cmd as delta_table_base_src_cmd
+from .discord import get_base_src_cmd as discord_base_src_cmd
+from .elasticsearch import get_base_dest_cmd as elasticsearch_base_dest_cmd
+from .elasticsearch import get_base_src_cmd as elasticsearch_base_src_cmd
+from .fsspec.azure import get_base_dest_cmd as azure_base_dest_cmd
+from .fsspec.azure import get_base_src_cmd as azure_base_src_cmd
+from .fsspec.box import get_base_dest_cmd as box_base_dest_cmd
+from .fsspec.box import get_base_src_cmd as box_base_src_cmd
+from .fsspec.dropbox import get_base_dest_cmd as dropbox_base_dest_cmd
+from .fsspec.dropbox import get_base_src_cmd as dropbox_base_src_cmd
+from .fsspec.fsspec import get_base_dest_cmd as fsspec_base_dest_cmd
+from .fsspec.fsspec import get_base_src_cmd as fsspec_base_src_cmd
+from .fsspec.gcs import get_base_dest_cmd as gcs_base_dest_cmd
+from .fsspec.gcs import get_base_src_cmd as gcs_base_src_cmd
+from .fsspec.s3 import get_base_dest_cmd as s3_base_dest_cmd
+from .fsspec.s3 import get_base_src_cmd as s3_base_src_cmd
+from .github import get_base_src_cmd as github_base_src_cmd
+from .gitlab import get_base_src_cmd as gitlab_base_src_cmd
+from .google_drive import get_base_src_cmd as google_drive_base_src_cmd
+from .hubspot import get_base_src_cmd as hubspot_base_src_cmd
+from .jira import get_base_src_cmd as jira_base_src_cmd
+from .kafka import get_base_dest_cmd as kafka_base_dest_cmd
+from .kafka import get_base_src_cmd as kafka_base_src_cmd
+from .local import get_base_src_cmd as local_base_src_cmd
+from .mongodb import get_base_dest_cmd as mongo_base_dest_cmd
+from .mongodb import get_base_src_cmd as mongodb_base_src_cmd
+from .notion import get_base_src_cmd as notion_base_src_cmd
+from .onedrive import get_base_src_cmd as onedrive_base_src_cmd
+from .opensearch import get_base_dest_cmd as opensearch_base_dest_cmd
+from .opensearch import get_base_src_cmd as opensearch_base_src_cmd
+from .outlook import get_base_src_cmd as outlook_base_src_cmd
+from .pinecone import get_base_dest_cmd as pinecone_base_dest_cmd
+from .qdrant import get_base_dest_cmd as qdrant_base_dest_cmd
+from .reddit import get_base_src_cmd as reddit_base_src_cmd
+from .salesforce import get_base_src_cmd as salesforce_base_src_cmd
+from .sharepoint import get_base_src_cmd as sharepoint_base_src_cmd
+from .slack import get_base_src_cmd as slack_base_src_cmd
+from .sql import get_base_dest_cmd as sql_base_dest_cmd
+from .vectara import get_base_dest_cmd as vectara_base_dest_cmd
+from .weaviate import get_base_dest_cmd as weaviate_dest_cmd
+from .wikipedia import get_base_src_cmd as wikipedia_base_src_cmd
+
+if t.TYPE_CHECKING:
+    from unstructured_ingest.cli.base.dest import BaseDestCmd
+
+base_src_cmd_fns: t.List[t.Callable[[], BaseSrcCmd]] = [
+    airtable_base_src_cmd,
+    astra_base_src_cmd,
+    azure_base_src_cmd,
+    biomed_base_src_cmd,
+    box_base_src_cmd,
+    confluence_base_src_cmd,
+    delta_table_base_src_cmd,
+    discord_base_src_cmd,
+    dropbox_base_src_cmd,
+    elasticsearch_base_src_cmd,
+    fsspec_base_src_cmd,
+    gcs_base_src_cmd,
+    github_base_src_cmd,
+    gitlab_base_src_cmd,
+    google_drive_base_src_cmd,
+    hubspot_base_src_cmd,
+    jira_base_src_cmd,
+    kafka_base_src_cmd,
+    local_base_src_cmd,
+    mongodb_base_src_cmd,
+    notion_base_src_cmd,
+    onedrive_base_src_cmd,
+    opensearch_base_src_cmd,
+    outlook_base_src_cmd,
+    reddit_base_src_cmd,
+    salesforce_base_src_cmd,
+    sftp_base_src_cmd,
+    sharepoint_base_src_cmd,
+    slack_base_src_cmd,
+    s3_base_src_cmd,
+    wikipedia_base_src_cmd,
+]
+
+# Make sure there are not overlapping names
+src_cmd_names = [b().cmd_name for b in base_src_cmd_fns]
+src_duplicates = [item for item, count in collections.Counter(src_cmd_names).items() if count > 1]
+if src_duplicates:
+    raise ValueError(
+        "multiple base src commands defined with the same names: {}".format(
+            ", ".join(src_duplicates),
+        ),
+    )
+
+base_dest_cmd_fns: t.List[t.Callable[[], "BaseDestCmd"]] = [
+    astra_base_dest_cmd,
+    azure_base_dest_cmd,
+    box_base_dest_cmd,
+    chroma_base_dest_cmd,
+    clarifai_base_dest_cmd,
+    databricks_volumes_dest_cmd,
+    dropbox_base_dest_cmd,
+    elasticsearch_base_dest_cmd,
+    fsspec_base_dest_cmd,
+    gcs_base_dest_cmd,
+    kafka_base_dest_cmd,
+    s3_base_dest_cmd,
+    azure_cognitive_search_base_dest_cmd,
+    delta_table_dest_cmd,
+    sql_base_dest_cmd,
+    weaviate_dest_cmd,
+    mongo_base_dest_cmd,
+    pinecone_base_dest_cmd,
+    qdrant_base_dest_cmd,
+    opensearch_base_dest_cmd,
+    vectara_base_dest_cmd,
+]
+
+# Make sure there are not overlapping names
+dest_cmd_names = [b().cmd_name for b in base_dest_cmd_fns]
+dest_duplicates = [item for item, count in collections.Counter(dest_cmd_names).items() if count > 1]
+if dest_duplicates:
+    raise ValueError(
+        "multiple base dest commands defined with the same names: {}".format(
+            ", ".join(dest_duplicates),
+        ),
+    )
+
+__all__ = [
+    "base_src_cmd_fns",
+    "base_dest_cmd_fns",
+]

unstructured_ingest/cli/cmds/airtable.py

@@ -0,0 +1,69 @@
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.base.src import BaseSrcCmd
+from unstructured_ingest.cli.interfaces import (
+    CliConfig,
+)
+from unstructured_ingest.connector.airtable import SimpleAirtableConfig
+
+
+@dataclass
+class AirtableCliConfig(SimpleAirtableConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--personal-access-token"],
+                default=None,
+                help="Personal access token to authenticate into Airtable. Check: "
+                "https://support.airtable.com/docs/creating-and-using-api-keys-and-access-tokens "
+                "for more info",
+            ),
+            click.Option(
+                ["--list-of-paths"],
+                default=None,
+                help="""
+        A list of paths that specify the locations to ingest data from within Airtable.
+
+        If this argument is not set, the connector ingests all tables within each and every base.
+        --list-of-paths: path1 path2 path3 ….
+        path: base_id/table_id(optional)/view_id(optional)/
+
+        To obtain (base, table, view) ids in bulk, check:
+        https://airtable.com/developers/web/api/list-bases (base ids)
+        https://airtable.com/developers/web/api/get-base-schema (table and view ids)
+        https://pyairtable.readthedocs.io/en/latest/metadata.html (base, table and view ids)
+
+        To obtain specific ids from Airtable UI, go to your workspace, and copy any
+        relevant id from the URL structure:
+        https://airtable.com/appAbcDeF1ghijKlm/tblABcdEfG1HIJkLm/viwABCDEfg6hijKLM
+        appAbcDeF1ghijKlm -> base_id
+        tblABcdEfG1HIJkLm -> table_id
+        viwABCDEfg6hijKLM -> view_id
+
+        You can also check: https://support.airtable.com/docs/finding-airtable-ids
+
+        Here is an example for one --list-of-paths:
+            base1/		→ gets the entirety of all tables inside base1
+            base1/table1		→ gets all rows and columns within table1 in base1
+            base1/table1/view1	→ gets the rows and columns that are
+                                  visible in view1 for the table1 in base1
+
+        Examples to invalid airtable_paths:
+            table1          → has to mention base to be valid
+            base1/view1     → has to mention table to be valid
+                """,
+            ),
+        ]
+        return options
+
+
+def get_base_src_cmd() -> BaseSrcCmd:
+    cmd_cls = BaseSrcCmd(
+        cmd_name="airtable",
+        cli_config=AirtableCliConfig,
+    )
+    return cmd_cls

unstructured_ingest/cli/cmds/astra.py

@@ -0,0 +1,99 @@
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.interfaces import CliConfig, Dict
+from unstructured_ingest.connector.astra import AstraWriteConfig, SimpleAstraConfig
+
+
+@dataclass
+class AstraCliConfig(SimpleAstraConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--token"],
+                required=True,
+                type=str,
+                help="Astra DB Token with access to the database.",
+                envvar="ASTRA_DB_APPLICATION_TOKEN",
+                show_envvar=True,
+            ),
+            click.Option(
+                ["--api-endpoint"],
+                required=True,
+                type=str,
+                help="The API endpoint for the Astra DB.",
+                envvar="ASTRA_DB_API_ENDPOINT",
+                show_envvar=True,
+            ),
+            click.Option(
+                ["--collection-name"],
+                required=False,
+                type=str,
+                help="The name of the Astra DB collection. "
+                "Note that the collection name must only include letters, "
+                "numbers, and underscores.",
+            ),
+            click.Option(
+                ["--namespace"],
+                required=False,
+                default=None,
+                type=str,
+                help="The Astra DB connection namespace.",
+            ),
+        ]
+        return options
+
+
+@dataclass
+class AstraCliWriteConfig(AstraWriteConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--embedding-dimension"],
+                required=True,
+                default=384,
+                type=int,
+                help="The dimensionality of the embeddings",
+            ),
+            click.Option(
+                ["--requested-indexing-policy"],
+                required=False,
+                default=None,
+                type=Dict(),
+                help="The indexing policy to use for the collection."
+                'example: \'{"deny": ["metadata"]}\' ',
+            ),
+            click.Option(
+                ["--batch-size"],
+                default=20,
+                type=int,
+                help="Number of records per batch",
+            ),
+        ]
+        return options
+
+
+def get_base_src_cmd():
+    from unstructured_ingest.cli.base.src import BaseSrcCmd
+
+    cmd_cls = BaseSrcCmd(
+        cmd_name="astra",
+        cli_config=AstraCliConfig,
+    )
+    return cmd_cls
+
+
+def get_base_dest_cmd():
+    from unstructured_ingest.cli.base.dest import BaseDestCmd
+
+    cmd_cls = BaseDestCmd(
+        cmd_name="astra",
+        cli_config=AstraCliConfig,
+        additional_cli_options=[AstraCliWriteConfig],
+        write_config=AstraWriteConfig,
+    )
+    return cmd_cls

unstructured_ingest/cli/cmds/azure_cognitive_search.py

@@ -0,0 +1,65 @@
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.interfaces import (
+    CliConfig,
+)
+from unstructured_ingest.connector.azure_cognitive_search import (
+    AzureCognitiveSearchWriteConfig,
+    SimpleAzureCognitiveSearchStorageConfig,
+)
+
+
+@dataclass
+class AzureCognitiveSearchCliConfig(SimpleAzureCognitiveSearchStorageConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--key"],
+                required=True,
+                type=str,
+                help="Key credential used for authenticating to an Azure service.",
+                envvar="AZURE_SEARCH_API_KEY",
+                show_envvar=True,
+            ),
+            click.Option(
+                ["--endpoint"],
+                required=True,
+                type=str,
+                help="The URL endpoint of an Azure search service. "
+                "In the form of https://{{service_name}}.search.windows.net",
+                envvar="AZURE_SEARCH_ENDPOINT",
+                show_envvar=True,
+            ),
+        ]
+        return options
+
+
+@dataclass
+class AzureCognitiveSearchCliWriteConfig(AzureCognitiveSearchWriteConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--index"],
+                required=True,
+                type=str,
+                help="The name of the index to connect to",
+            ),
+        ]
+        return options
+
+
+def get_base_dest_cmd():
+    from unstructured_ingest.cli.base.dest import BaseDestCmd
+
+    cmd_cls = BaseDestCmd(
+        cmd_name="azure-cognitive-search",
+        cli_config=AzureCognitiveSearchCliConfig,
+        additional_cli_options=[AzureCognitiveSearchCliWriteConfig],
+        write_config=AzureCognitiveSearchCliWriteConfig,
+    )
+    return cmd_cls

unstructured_ingest/cli/cmds/biomed.py

@@ -0,0 +1,52 @@
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from unstructured_ingest.cli.base.src import BaseSrcCmd
+from unstructured_ingest.cli.interfaces import (
+    CliConfig,
+)
+from unstructured_ingest.connector.biomed import SimpleBiomedConfig
+
+
+@dataclass
+class BiomedCliConfig(SimpleBiomedConfig, CliConfig):
+    @staticmethod
+    def get_cli_options() -> t.List[click.Option]:
+        options = [
+            click.Option(
+                ["--api-id"],
+                default=None,
+                help="ID parameter for OA Web Service API.",
+            ),
+            click.Option(
+                ["--api-from"],
+                default=None,
+                help="From parameter for OA Web Service API.",
+            ),
+            click.Option(
+                ["--api-until"],
+                default=None,
+                help="Until parameter for OA Web Service API.",
+            ),
+            click.Option(
+                ["--path"],
+                default=None,
+                help="PMC Open Access FTP Directory Path.",
+            ),
+            click.Option(
+                ["--max-request-time"],
+                default=45,
+                help="(In seconds) Max request time to OA Web Service API.",
+            ),
+        ]
+        return options
+
+
+def get_base_src_cmd() -> BaseSrcCmd:
+    cmd_cls = BaseSrcCmd(
+        cmd_name="biomed",
+        cli_config=BiomedCliConfig,
+    )
+    return cmd_cls