unstructured-ingest 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

unstructured_ingest/cli/base/cmd.py

@@ -1,19 +1,269 @@
-import typing as t
-from abc import ABC
-from dataclasses import dataclass, field
+import inspect
+from abc import ABC, abstractmethod
+from collections import Counter
+from dataclasses import dataclass, field, fields
+from typing import Any, Optional, Type, TypeVar
 
-from unstructured_ingest.cli.interfaces import CliConfig
-from unstructured_ingest.interfaces import BaseConfig
+import click
+from pydantic import BaseModel
+
+from unstructured_ingest.cli.base.importer import import_from_string
+from unstructured_ingest.cli.utils.click import extract_config
+from unstructured_ingest.cli.utils.model_conversion import options_from_base_model, post_check
+from unstructured_ingest.interfaces import ProcessorConfig
+from unstructured_ingest.logger import logger
+from unstructured_ingest.pipeline.pipeline import Pipeline
+from unstructured_ingest.processes.chunker import Chunker, ChunkerConfig
+from unstructured_ingest.processes.connector_registry import (
+    DownloaderT,
+    IndexerT,
+    RegistryEntry,
+    UploaderT,
+    UploadStager,
+    UploadStagerConfig,
+    UploadStagerT,
+    destination_registry,
+    source_registry,
+)
+from unstructured_ingest.processes.connectors.local import LocalUploader, LocalUploaderConfig
+from unstructured_ingest.processes.embedder import Embedder, EmbedderConfig
+from unstructured_ingest.processes.filter import Filterer, FiltererConfig
+from unstructured_ingest.processes.partitioner import Partitioner, PartitionerConfig
+
+CommandT = TypeVar("CommandT", bound=click.Command)
 
 
 @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
+    registry_entry: RegistryEntry
+    default_configs: list[Type[BaseModel]] = field(default_factory=list)
+
+    @abstractmethod
+    def get_registry_options(self):
+        pass
+
+    def get_default_options(self) -> list[click.Option]:
+        options = []
+        for extra in self.default_configs:
+            options.extend(options_from_base_model(model=extra))
+        return options
+
+    @classmethod
+    def consolidate_options(cls, options: list[click.Option]) -> list[click.Option]:
+        option_names = [option.name for option in options]
+        duplicate_names = [name for name, count in Counter(option_names).items() if count > 1]
+        if not duplicate_names:
+            return options
+        consolidated_options = []
+        current_names = []
+        for option in options:
+            if option.name not in current_names:
+                current_names.append(option.name)
+                consolidated_options.append(option)
+                continue
+            existing_option = next(o for o in consolidated_options if o.name == option.name)
+            if existing_option.__dict__ == option.__dict__:
+                continue
+            option_diff = cls.get_options_diff(o1=option, o2=existing_option)
+            raise ValueError(
+                "Conflicting duplicate {} option defined: {}".format(
+                    option.name, " | ".join([f"{d[0]}: {d[1]}" for d in option_diff])
+                )
+            )
+        return consolidated_options
+
+    @staticmethod
+    def get_options_diff(o1: click.Option, o2: click.Option):
+        o1_dict = o1.__dict__
+        o2_dict = o2.__dict__
+        for d in [o1_dict, o2_dict]:
+            d["opts"] = ",".join(d["opts"])
+            d["secondary_opts"] = ",".join(d["secondary_opts"])
+        option_diff = set(o1_dict.items()) ^ set(o2_dict.items())
+        return option_diff
 
     @property
     def cmd_name_key(self):
         return self.cmd_name.replace("-", "_")
+
+    @property
+    def cli_cmd_name(self):
+        return self.cmd_name.replace("_", "-")
+
+    @abstractmethod
+    def cmd(self, ctx: click.Context, **options) -> None:
+        pass
+
+    def add_options(self, cmd: CommandT) -> CommandT:
+        options = self.get_registry_options()
+        options.extend(self.get_default_options())
+        post_check(options=options, name=cmd.name)
+        cmd.params.extend(options)
+        return cmd
+
+    def get_pipeline(
+        self,
+        src: str,
+        source_options: dict[str, Any],
+        dest: Optional[str] = None,
+        destination_options: Optional[dict[str, Any]] = None,
+    ) -> Pipeline:
+        logger.debug(
+            f"creating pipeline from cli using source {src} with options: {source_options}"
+        )
+        pipeline_kwargs: dict[str, Any] = {
+            "context": self.get_processor_config(options=source_options),
+            "downloader": self.get_downloader(src=src, options=source_options),
+            "indexer": self.get_indexer(src=src, options=source_options),
+            "partitioner": self.get_partitioner(options=source_options),
+        }
+        if chunker := self.get_chunker(options=source_options):
+            pipeline_kwargs["chunker"] = chunker
+        if filterer := self.get_filterer(options=source_options):
+            pipeline_kwargs["filterer"] = filterer
+        if embedder := self.get_embedder(options=source_options):
+            pipeline_kwargs["embedder"] = embedder
+        if dest:
+            logger.debug(
+                f"setting destination on pipeline {dest} with options: {destination_options}"
+            )
+            if uploader_stager := self.get_upload_stager(dest=dest, options=destination_options):
+                pipeline_kwargs["stager"] = uploader_stager
+            pipeline_kwargs["uploader"] = self.get_uploader(dest=dest, options=destination_options)
+        else:
+            # Default to local uploader
+            # TODO remove after v1 no longer supported
+            destination_options = destination_options or {}
+            if "output_dir" not in destination_options:
+                destination_options["output_dir"] = source_options["output_dir"]
+            pipeline_kwargs["uploader"] = self.get_default_uploader(options=destination_options)
+        return Pipeline(**pipeline_kwargs)
+
+    @staticmethod
+    def get_default_uploader(options: dict[str, Any]) -> UploaderT:
+        uploader_config = extract_config(flat_data=options, config=LocalUploaderConfig)
+        return LocalUploader(upload_config=uploader_config)
+
+    @staticmethod
+    def get_chunker(options: dict[str, Any]) -> Optional[Chunker]:
+        chunker_config = extract_config(flat_data=options, config=ChunkerConfig)
+        if not chunker_config.chunking_strategy:
+            return None
+        return Chunker(config=chunker_config)
+
+    @staticmethod
+    def get_filterer(options: dict[str, Any]) -> Optional[Filterer]:
+        filterer_configs = extract_config(flat_data=options, config=FiltererConfig)
+        if not filterer_configs.model_dump():
+            return None
+        return Filterer(config=filterer_configs)
+
+    @staticmethod
+    def get_embedder(options: dict[str, Any]) -> Optional[Embedder]:
+        embedder_config = extract_config(flat_data=options, config=EmbedderConfig)
+        if not embedder_config.embedding_provider:
+            return None
+        return Embedder(config=embedder_config)
+
+    @staticmethod
+    def get_partitioner(options: dict[str, Any]) -> Partitioner:
+        partitioner_config = extract_config(flat_data=options, config=PartitionerConfig)
+        return Partitioner(config=partitioner_config)
+
+    @staticmethod
+    def get_processor_config(options: dict[str, Any]) -> ProcessorConfig:
+        return extract_config(flat_data=options, config=ProcessorConfig)
+
+    @staticmethod
+    def get_indexer(src: str, options: dict[str, Any]) -> IndexerT:
+        source_entry = source_registry[src]
+        indexer_kwargs: dict[str, Any] = {}
+        if indexer_config_cls := source_entry.indexer_config:
+            indexer_kwargs["index_config"] = extract_config(
+                flat_data=options, config=indexer_config_cls
+            )
+        if connection_config_cls := source_entry.connection_config:
+            indexer_kwargs["connection_config"] = extract_config(
+                flat_data=options, config=connection_config_cls
+            )
+        indexer_cls = source_entry.indexer
+        return indexer_cls(**indexer_kwargs)
+
+    @staticmethod
+    def get_downloader(src: str, options: dict[str, Any]) -> DownloaderT:
+        source_entry = source_registry[src]
+        downloader_kwargs: dict[str, Any] = {}
+        if downloader_config_cls := source_entry.downloader_config:
+            downloader_kwargs["download_config"] = extract_config(
+                flat_data=options, config=downloader_config_cls
+            )
+        if connection_config_cls := source_entry.connection_config:
+            downloader_kwargs["connection_config"] = extract_config(
+                flat_data=options, config=connection_config_cls
+            )
+        downloader_cls = source_entry.downloader
+        return downloader_cls(**downloader_kwargs)
+
+    @staticmethod
+    def get_custom_stager(
+        stager_reference: str, stager_config_kwargs: Optional[dict] = None
+    ) -> Optional[UploadStagerT]:
+        uploader_cls = import_from_string(stager_reference)
+        if not inspect.isclass(uploader_cls):
+            raise ValueError(
+                f"custom stager must be a reference to a python class, got: {type(uploader_cls)}"
+            )
+        if not issubclass(uploader_cls, UploadStager):
+            raise ValueError(
+                "custom stager must be an implementation of the UploadStager interface"
+            )
+        fields_dict = {f.name: f.type for f in fields(uploader_cls)}
+        upload_stager_config_cls = fields_dict["upload_stager_config"]
+        if not inspect.isclass(upload_stager_config_cls):
+            raise ValueError(
+                f"custom stager config must be a class, got: {type(upload_stager_config_cls)}"
+            )
+        if not issubclass(upload_stager_config_cls, UploadStagerConfig):
+            raise ValueError(
+                "custom stager config must be an implementation "
+                "of the UploadStagerUploadStagerConfig interface"
+            )
+        upload_stager_kwargs: dict[str, Any] = {}
+        if stager_config_kwargs:
+            upload_stager_kwargs["upload_stager_config"] = upload_stager_config_cls(
+                **stager_config_kwargs
+            )
+        return uploader_cls(**upload_stager_kwargs)
+
+    @staticmethod
+    def get_upload_stager(dest: str, options: dict[str, Any]) -> Optional[UploadStagerT]:
+        if custom_stager := options.get("custom_stager"):
+            return BaseCmd.get_custom_stager(
+                stager_reference=custom_stager,
+                stager_config_kwargs=options.get("custom_stager_config_kwargs"),
+            )
+        dest_entry = destination_registry[dest]
+        upload_stager_kwargs: dict[str, Any] = {}
+        if upload_stager_config_cls := dest_entry.upload_stager_config:
+            upload_stager_kwargs["upload_stager_config"] = extract_config(
+                flat_data=options, config=upload_stager_config_cls
+            )
+        if upload_stager_cls := dest_entry.upload_stager:
+            return upload_stager_cls(**upload_stager_kwargs)
+        return None
+
+    @staticmethod
+    def get_uploader(dest, options: dict[str, Any]) -> UploaderT:
+        dest_entry = destination_registry[dest]
+        uploader_kwargs: dict[str, Any] = {}
+        if uploader_config_cls := dest_entry.uploader_config:
+            uploader_kwargs["upload_config"] = extract_config(
+                flat_data=options, config=uploader_config_cls
+            )
+        if connection_config_cls := dest_entry.connection_config:
+            uploader_kwargs["connection_config"] = extract_config(
+                flat_data=options, config=connection_config_cls
+            )
+        uploader_cls = dest_entry.uploader
+        return uploader_cls(**uploader_kwargs)

unstructured_ingest/cli/base/dest.py

@@ -1,87 +1,84 @@
 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
+from unstructured_ingest.cli.utils.click import Dict, conform_click_options
+from unstructured_ingest.cli.utils.model_conversion import options_from_base_model
+from unstructured_ingest.logger import logger
+from unstructured_ingest.processes.connector_registry import DestinationRegistryEntry
 
 
 @dataclass
-class BaseDestCmd(BaseCmd):
-    write_config: t.Optional[t.Type[BaseConfig]] = None
+class DestCmd(BaseCmd):
+    registry_entry: DestinationRegistryEntry
 
-    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 get_registry_options(self):
+        options = []
+        configs = [
+            config
+            for config in [
+                self.registry_entry.uploader_config,
+                self.registry_entry.upload_stager_config,
+                self.registry_entry.connection_config,
+            ]
+            if config
+        ]
+        for config in configs:
+            options.extend(options_from_base_model(model=config))
+        options = self.consolidate_options(options=options)
+        return options
 
-    def dest(self, ctx: click.Context, **options):
+    def cmd(self, ctx: click.Context, **options) -> None:
+        logger.setLevel(logging.DEBUG if options.get("verbose", False) else logging.INFO)
         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 {}
+        source_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,
+            pipeline = self.get_pipeline(
+                src=source_cmd,
+                source_options=source_options,
+                dest=self.cmd_name,
+                destination_options=options,
             )
-            runner.run(**parent_options)
+            pipeline.run()
         except Exception as e:
-            logger.error(e, exc_info=True)
+            logger.error(f"failed to run destination command {self.cmd_name}: {e}", exc_info=True)
             raise click.ClickException(str(e)) from e
 
-    def get_dest_cmd(self) -> click.Command:
+    def get_cmd(self) -> click.Command:
         # Dynamically create the command without the use of click decorators
-        fn = self.dest
+        fn = self.cmd
         fn = click.pass_context(fn)
-        cmd: click.Group = click.command(fn)
-        cmd.name = self.cmd_name
+        cmd = click.command(fn)
+        if not isinstance(cmd, click.core.Command):
+            raise ValueError(f"generated command was not of expected type Command: {type(cmd)}")
+        cmd.name = self.cli_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)
+        self.add_options(cmd)
+        cmd.params.append(
+            click.Option(
+                ["--custom-stager"],
+                required=False,
+                type=str,
+                default=None,
+                help="Pass a pointer to a custom upload stager to use, "
+                "must be in format '<module>:<attribute>'",
+            )
+        )
+        cmd.params.append(
+            click.Option(
+                ["--custom-stager-config-kwargs"],
+                required=False,
+                type=Dict(),
+                default=None,
+                help="Any kwargs to instantiate the configuration "
+                "associated with the customer stager",
+            )
+        )
         return cmd

unstructured_ingest/cli/base/src.py

@@ -1,57 +1,75 @@
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Any
 
 import click
+from pydantic import BaseModel
 
 from unstructured_ingest.cli.base.cmd import BaseCmd
-from unstructured_ingest.cli.common import (
-    log_options,
+from unstructured_ingest.cli.utils.click import Group, conform_click_options
+from unstructured_ingest.cli.utils.model_conversion import options_from_base_model
+from unstructured_ingest.interfaces import ProcessorConfig
+from unstructured_ingest.logger import logger
+from unstructured_ingest.processes import (
+    ChunkerConfig,
+    EmbedderConfig,
+    FiltererConfig,
+    PartitionerConfig,
 )
-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
+from unstructured_ingest.processes.connector_registry import SourceRegistryEntry
 
 
 @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):
+class SrcCmd(BaseCmd):
+    registry_entry: SourceRegistryEntry
+    default_configs: list[BaseModel] = field(
+        default_factory=lambda: [
+            ProcessorConfig,
+            PartitionerConfig,
+            EmbedderConfig,
+            FiltererConfig,
+            ChunkerConfig,
+        ]
+    )
+
+    def get_registry_options(self):
+        options = []
+        configs = [
+            config
+            for config in [
+                self.registry_entry.connection_config,
+                self.registry_entry.indexer_config,
+                self.registry_entry.downloader_config,
+            ]
+            if config
+        ]
+        for config in configs:
+            options.extend(options_from_base_model(model=config))
+        options = self.consolidate_options(options=options)
+        return options
+
+    def cmd(self, ctx: click.Context, **options: dict[str, Any]) -> None:
         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)
+        logger.setLevel(logging.DEBUG if options.get("verbose", False) else logging.INFO)
         try:
-            runner = self.get_source_runner(options=options)
-            runner.run(**options)
+            pipeline = self.get_pipeline(src=self.cmd_name, source_options=options)
+            pipeline.run()
         except Exception as e:
-            logger.error(e, exc_info=True)
+            logger.error(f"failed to run source command {self.cmd_name}: {e}", exc_info=True)
             raise click.ClickException(str(e)) from e
 
-    def get_src_cmd(self) -> click.Group:
+    def get_cmd(self) -> click.Group:
         # Dynamically create the command without the use of click decorators
-        fn = self.src
+        fn = self.cmd
         fn = click.pass_context(fn)
-        cmd: click.Group = click.group(fn, cls=Group)
-        cmd.name = self.cmd_name
+        cmd = click.group(fn, cls=Group)
+        if not isinstance(cmd, click.core.Group):
+            raise ValueError(f"generated src command was not of expected type Group: {type(cmd)}")
+        cmd.name = self.cli_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)
+        self.add_options(cmd)
+
         return cmd

unstructured_ingest/cli/cli.py

@@ -1,13 +1,6 @@
-from typing import TYPE_CHECKING
-
 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
-
-if TYPE_CHECKING:
-    from click import Command
+from unstructured_ingest.cli.cmds import dest, src
 
 
 @click.group()
@@ -15,23 +8,17 @@ def ingest():
     pass
 
 
-def get_cmd() -> "Command":
+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():
+    for src_subcommand in src:
         # Add all destination subcommands
-        for dest_subcommand in dest_dict.values():
+        for dest_subcommand in dest:
             src_subcommand.add_command(dest_subcommand)
         cmd.add_command(src_subcommand)
     return cmd

unstructured_ingest/{v2/cli → cli}/cmds.py

@@ -1,7 +1,7 @@
 import click
 
-from unstructured_ingest.v2.cli.base import DestCmd, SrcCmd
-from unstructured_ingest.v2.processes.connector_registry import (
+from unstructured_ingest.cli.base import DestCmd, SrcCmd
+from unstructured_ingest.processes.connector_registry import (
     destination_registry,
     source_registry,
 )

unstructured_ingest/{v2/cli → cli}/utils/model_conversion.py

@@ -25,7 +25,7 @@ from pydantic.fields import FieldInfo
 from pydantic.types import _SecretBase
 from pydantic_core import PydanticUndefined
 
-from unstructured_ingest.v2.cli.utils.click import (
+from unstructured_ingest.cli.utils.click import (
     DelimitedString,
     Dict,
     PydanticDate,
@@ -106,7 +106,7 @@ def get_numerical_type(field: FieldInfo) -> click.ParamType:
         if range_args:
             return click.IntRange(**range_args)  # type: ignore[arg-type]
         return click.INT
-    # Non-integer numerical types default to float
+    # Non-integer numerical data_types default to float
     if range_args:
         return click.FloatRange(**range_args)  # type: ignore[arg-type]
     return click.FLOAT
@@ -183,13 +183,13 @@ def is_subclass(x: Any, y: Any) -> bool:
     return False
 
 
-def post_check(options: list[Option]):
+def post_check(options: list[Option], name: str):
     option_names = [option.name for option in options]
     duplicate_names = [name for name, count in Counter(option_names).items() if count > 1]
     if duplicate_names:
         raise ValueError(
-            "the following field name were reused, all must be unique: {}".format(
-                ", ".join(duplicate_names)
+            "[{}] the following field name were reused, all must be unique: {}".format(
+                name, ", ".join(duplicate_names)
             )
         )
 
@@ -218,5 +218,5 @@ def options_from_base_model(model: Union[BaseModel, Type[BaseModel]]) -> list[Op
                 field_info.description = f"[sensitive] {field_info.description}"
             options.append(get_option_from_field(option_name=option_name, field_info=field_info))
 
-    post_check(options=options)
+    post_check(options=options, name=model.__name__)
     return options

unstructured_ingest/{v2/types → data_types}/file_data.py

@@ -5,7 +5,7 @@ from uuid import NAMESPACE_DNS, uuid5
 
 from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
 
-from unstructured_ingest.v2.logger import logger
+from unstructured_ingest.logger import logger
 
 
 class SourceIdentifiers(BaseModel):

unstructured_ingest/embed/bedrock.py

@@ -13,15 +13,15 @@ from unstructured_ingest.embed.interfaces import (
     BaseEmbeddingEncoder,
     EmbeddingConfig,
 )
-from unstructured_ingest.logger import logger
-from unstructured_ingest.utils.dep_check import requires_dependencies
-from unstructured_ingest.v2.errors import (
+from unstructured_ingest.errors_v2 import (
     ProviderError,
     RateLimitError,
     UserAuthError,
     UserError,
     is_internal_error,
 )
+from unstructured_ingest.logger import logger
+from unstructured_ingest.utils.dep_check import requires_dependencies
 
 if TYPE_CHECKING:
     from botocore.client import BaseClient