ws-bom-robot-app 0.0.63__py3-none-any.whl → 0.0.103__py3-none-any.whl

ws_bom_robot_app/llm/vector_store/integration/jira.py

@@ -1,21 +1,39 @@
+import logging
 import asyncio, os
-from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy
+import sys
+from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
 from langchain_core.documents import Document
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from pydantic import BaseModel, Field, AliasChoices
-from typing import Any, Optional, Union
-from unstructured_ingest.interfaces import  ProcessorConfig, ReadConfig
-from unstructured_ingest.connector.jira import SimpleJiraConfig, JiraAccessConfig, JiraSourceConnector, JiraIngestDoc, nested_object_to_field_getter, _get_id_fields_for_issue, _get_project_fields_for_issue
-from unstructured_ingest.runner import JiraRunner
-
+from typing import Any, Generator, Iterable, Optional, Union
+from unstructured_ingest.pipeline.pipeline import Pipeline
+from unstructured_ingest.processes.connectors.jira import (
+    JiraIndexerConfig,
+    JiraIndexer,
+    JiraIssueMetadata,
+    api_page_based_generator,
+    JiraDownloaderConfig,
+    JiraDownloader,
+    DEFAULT_C_SEP,
+    DEFAULT_R_SEP,
+    JiraConnectionConfig,
+    JiraAccessConfig
+)
+from unstructured_ingest.pipeline.pipeline import (
+  Pipeline,
+  PartitionerConfig,
+  FiltererConfig
+)
+from unstructured_ingest.interfaces import ProcessorConfig
 
 class JiraParams(BaseModel):
   """
   JiraParams is a Pydantic model that represents the parameters required to interact with a Jira instance.
+  Docs: https://docs.unstructured.io/open-source/ingestion/source-connectors/jira#jira
 
   Attributes:
     url (str): The URL of the Jira instance, e.g., 'https://example.atlassian.net'.
-    access_token (str): The access token for authenticating with the Jira API.
+    access_token (str): The access token for authenticating with the Jira API: https://id.atlassian.com/manage-profile/security/api-tokens
     user_email (str): The email address of the Jira user.
     projects (list[str]): A list of project keys or IDs to interact with, e.g., ['SCRUM', 'PROJ1'].
     boards (Optional[list[str]]): An optional list of board IDs to interact with. Defaults to None, e.g., ['1', '2'].
@@ -27,34 +45,45 @@ class JiraParams(BaseModel):
   projects: list[str]
   boards: Optional[list[str]] | None = None
   issues: Optional[list[str]] | None = None
+  status_filters: Optional[list[str]] | None = None
 
 class Jira(IntegrationStrategy):
   def __init__(self, knowledgebase_path: str, data: dict[str, Union[str,int,list]]):
     super().__init__(knowledgebase_path, data)
     self.__data = JiraParams.model_validate(self.data)
+    self.__unstructured_ingest = UnstructuredIngest(self.working_directory)
   def working_subdirectory(self) -> str:
     return 'jira'
   def run(self) -> None:
-    access_config = JiraAccessConfig(
-      api_token=self.__data.access_token
-    )
-    config = SimpleJiraConfig(
-      user_email=self.__data.user_email,
-      url = self.__data.url,
-      access_config=access_config,
+    indexer_config = JiraIndexerConfig(
       projects=self.__data.projects,
       boards=self.__data.boards,
-      issues=self.__data.issues
-    )
-    # runner override: waiting for v2 migration https://github.com/Unstructured-IO/unstructured-ingest/issues/106
-    runner = _JiraRunner(
-      connector_config=config,
-      processor_config=ProcessorConfig(reprocess=False,verbose=False,num_processes=2,raise_on_error=False),
-      read_config=ReadConfig(download_dir=self.working_directory,re_download=True,preserve_downloads=True,download_only=True),
-      partition_config=None,
-      retry_strategy_config=None
+      issues=self.__data.issues,
+      status_filters=self.__data.status_filters
       )
-    runner.run()
+    downloader_config = JiraDownloaderConfig(
+      download_dir=self.working_directory,
+      download_attachments=False
+    )
+    _is_cloud = "atlassian.net" in self.__data.url
+    _access_config = JiraAccessConfig(token=self.__data.access_token) \
+      if not _is_cloud  \
+      else JiraAccessConfig(password=self.__data.access_token)
+    connection_config = JiraConnectionConfig(
+      access_config=_access_config,
+      username=self.__data.user_email,
+      url=self.__data.url,
+      cloud=_is_cloud
+    )
+    pipeline: Pipeline = self.__unstructured_ingest.pipeline(
+      indexer_config,
+      downloader_config,
+      connection_config,
+      extension=None)
+    if _is_cloud and sys.platform == "win32":
+      pipeline.indexer_step.process = CustomJiraIndexer(**vars(pipeline.indexer_step.process))
+    pipeline.downloader_step.process = CustomJiraDownloader(**vars(pipeline.downloader_step.process))
+    pipeline.run()
   async def load(self) -> list[Document]:
       await asyncio.to_thread(self.run)
       await asyncio.sleep(1)
@@ -62,8 +91,38 @@ class Jira(IntegrationStrategy):
 
 
 # region override
-class _JiraIngestDoc(JiraIngestDoc):
-  def _get_dropdown_custom_fields_for_issue(issue: dict, c_sep=" " * 5, r_sep="\n") -> str:
+class CustomJiraIndexer(JiraIndexer):
+  """
+    fix default run_jql for cloud: missing enhanced_jql
+  """
+  import sys
+  def __init__(self, **kwargs):
+    for key, value in kwargs.items():
+        try:
+            setattr(super(), key, value)
+        except AttributeError:
+            setattr(self, key, value)
+  def run_jql(self, jql: str, **kwargs) -> Generator[JiraIssueMetadata, None, None]:
+      with self.connection_config.get_client() as client:
+          for issue in api_page_based_generator(client.jql, jql=jql, **kwargs):
+              yield JiraIssueMetadata.model_validate(issue)
+
+class CustomJiraDownloader(JiraDownloader):
+  CUSTOM_FIELDS: list | None = None
+  def _set_custom_fields(self) -> list:
+    with self.connection_config.get_client() as client:
+        _custom_fields = client.get_all_custom_fields()
+        return [{"id": item["id"], "name": item["name"]} for item in _custom_fields]
+  def __init__(self, **kwargs):
+    for key, value in kwargs.items():
+        try:
+            setattr(super(), key, value)
+        except AttributeError:
+            setattr(self, key, value)
+    if not self.CUSTOM_FIELDS:
+      self.CUSTOM_FIELDS = self._set_custom_fields()
+
+  def _get_custom_fields_for_issue(self, issue: dict, c_sep=DEFAULT_C_SEP, r_sep=DEFAULT_R_SEP) -> str:
       def _parse_value(value: Any) -> Any:
           if isinstance(value, dict):
             _candidate = ["displayName", "name", "value"]
@@ -74,45 +133,19 @@ class _JiraIngestDoc(JiraIngestDoc):
       def _remap_custom_fields(fields: dict):
         remapped_fields = {}
         for field_key, field_value in fields.items():
-          new_key = next((map_item["name"] for map_item in _JiraSourceConnector.CUSTOM_FIELDS if field_key == map_item["id"]), field_key)
+          new_key = next((map_item["name"] for map_item in self.CUSTOM_FIELDS if field_key == map_item["id"]), field_key)
           if new_key != field_value:
             remapped_fields[new_key] = field_value
         return remapped_fields
       filtered_fields = {key: _parse_value(value) for key, value in issue.items() if value is not None and type(value) not in [list]}
       custom_fields =_remap_custom_fields(filtered_fields)
       return (r_sep + c_sep ).join([f"{key}: {value}{r_sep}" for key, value in custom_fields.items()])
-  def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-    _issue = self.issue
-    _nested: dict = nested_object_to_field_getter(_issue["fields"])
-    document = "\n\n\n".join(
-              [
-                  _get_id_fields_for_issue(_issue),
-                  _get_project_fields_for_issue(_nested),
-                  _JiraIngestDoc._get_dropdown_custom_fields_for_issue(_nested)
-              ],
-          )
-    _full_filename = str(self.filename)
-    _file_extension  = _full_filename.split(".")[-1]
-    _file_without_extension = _full_filename.replace(f".{_file_extension}","")
-    os.makedirs(os.path.dirname(_file_without_extension), exist_ok=True)
-    with open(f"{_file_without_extension}_extra.{_file_extension}", "w", encoding="utf8") as f:
-      f.write(document)
-
-class _JiraSourceConnector(JiraSourceConnector):
-  CUSTOM_FIELDS: list | None = None
-  def __set_custom_fields(self) -> None:
-    _custom_fields = self.jira.get_all_custom_fields()
-    _JiraSourceConnector.CUSTOM_FIELDS = [{"id":item["id"],"name":item["name"]} for item in _custom_fields]
-    self._jira = None # fix serialization
-  def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-    if not _JiraSourceConnector.CUSTOM_FIELDS:
-      self.__set_custom_fields()
-  def get_ingest_docs(self) -> list[_JiraIngestDoc]:
-     return [_JiraIngestDoc(**item.__dict__) for item in super().get_ingest_docs()]
 
-class _JiraRunner(JiraRunner):
-  def get_source_connector_cls(self):
-    return _JiraSourceConnector
+  def _get_text_fields_for_issue(self, issue: dict, c_sep: str = DEFAULT_C_SEP, r_sep: str = DEFAULT_R_SEP) -> str:
+      #no need any more: original data will be included in the custom fields
+      #_origin = super()._get_text_fields_for_issue(issue, c_sep=c_sep, r_sep=r_sep)
+      _custom_fields = self._get_custom_fields_for_issue(issue, c_sep=c_sep, r_sep=r_sep)
+      return f"""Details:
+      {r_sep}
+      {_custom_fields}"""
 # endregion

ws_bom_robot_app/llm/vector_store/integration/manager.py

@@ -12,7 +12,9 @@ from ws_bom_robot_app.llm.vector_store.integration.sftp import Sftp
 from ws_bom_robot_app.llm.vector_store.integration.sharepoint import Sharepoint
 from ws_bom_robot_app.llm.vector_store.integration.sitemap import Sitemap
 from ws_bom_robot_app.llm.vector_store.integration.slack import Slack
-
+from ws_bom_robot_app.llm.vector_store.integration.thron import Thron
+from ws_bom_robot_app.llm.vector_store.integration.shopify import Shopify
+from ws_bom_robot_app.llm.vector_store.integration.api import Api
 class IntegrationManager:
   _list: dict[str, Type[IntegrationStrategy]] = {
     "llmkbazure": Azure,
@@ -27,7 +29,9 @@ class IntegrationManager:
     "llmkbsharepoint": Sharepoint,
     "llmkbsitemap": Sitemap,
     "llmkbslack": Slack,
-
+    "llmkbthron": Thron,
+    "llmkbshopify": Shopify,
+    "llmkbapi": Api,
   }
   @classmethod
   def get_strategy(cls, name: str, knowledgebase_path: str, data: dict[str, str]) -> IntegrationStrategy:

ws_bom_robot_app/llm/vector_store/integration/s3.py

@@ -1,6 +1,6 @@
 import asyncio
 from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
-from unstructured_ingest.v2.processes.connectors.fsspec.s3 import S3ConnectionConfig, S3AccessConfig, S3DownloaderConfig, S3IndexerConfig
+from unstructured_ingest.processes.connectors.fsspec.s3 import S3ConnectionConfig, S3AccessConfig, S3DownloaderConfig, S3IndexerConfig
 from langchain_core.documents import Document
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from typing import Union, Optional

ws_bom_robot_app/llm/vector_store/integration/sftp.py

@@ -1,6 +1,6 @@
 import asyncio
 from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
-from unstructured_ingest.v2.processes.connectors.fsspec.sftp import SftpConnectionConfig, SftpAccessConfig, SftpDownloaderConfig, SftpIndexerConfig
+from unstructured_ingest.processes.connectors.fsspec.sftp import SftpConnectionConfig, SftpAccessConfig, SftpDownloaderConfig, SftpIndexerConfig
 from langchain_core.documents import Document
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from typing import Union, Optional

ws_bom_robot_app/llm/vector_store/integration/sharepoint.py

@@ -1,7 +1,7 @@
 import asyncio, logging, traceback
 from dataclasses import dataclass
 from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
-from unstructured_ingest.v2.processes.connectors.sharepoint  import SharepointIndexerConfig, SharepointIndexer, SharepointDownloaderConfig, SharepointConnectionConfig, SharepointAccessConfig
+from unstructured_ingest.processes.connectors.sharepoint  import SharepointIndexerConfig, SharepointIndexer, SharepointDownloaderConfig, SharepointConnectionConfig, SharepointAccessConfig
 from langchain_core.documents import Document
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from typing import Union, Optional
@@ -14,22 +14,18 @@ class SharepointParams(BaseModel):
   Attributes:
     client_id (str): The client ID for SharePoint authentication.
     client_secret (str): The client secret for SharePoint authentication.
+    tenant_id (str, optional): The tenant ID for SharePoint authentication. Defaults to None.
     site_url (str): The URL of the SharePoint site. i.e. site collection level: https://<tenant>.sharepoint.com/sites/<site-collection-name>, or root site: https://<tenant>.sharepoint.com
     site_path (str, optional): TThe path in the SharePoint site from which to start parsing files, for example "Shared Documents". Defaults to None.
     recursive (bool, optional): Whether to recursively access subdirectories. Defaults to False.
-    omit_files (bool, optional): Whether to omit files from the results. Defaults to False.
-    omit_pages (bool, optional): Whether to omit pages from the results. Defaults to False.
-    omit_lists (bool, optional): Whether to omit lists from the results. Defaults to False.
     extension (list[str], optional): A list of file extensions to include, i.e. [".pdf"]  Defaults to None.
   """
   client_id : str = Field(validation_alias=AliasChoices("clientId","client_id"))
   client_secret : str = Field(validation_alias=AliasChoices("clientSecret","client_secret"))
   site_url: str = Field(validation_alias=AliasChoices("siteUrl","site_url"))
   site_path: str = Field(default=None,validation_alias=AliasChoices("sitePath","site_path"))
+  tenant_id: str = Field(default=None, validation_alias=AliasChoices("tenantId","tenant_id"))
   recursive: bool = Field(default=False)
-  omit_files: bool = Field(default=False, validation_alias=AliasChoices("omitFiles","omit_files")),
-  omit_pages: bool = Field(default=False, validation_alias=AliasChoices("omitPages","omit_pages")),
-  omit_lists: bool = Field(default=False, validation_alias=AliasChoices("omitLists","omit_lists")),
   extension: list[str] = Field(default=None)
 class Sharepoint(IntegrationStrategy):
   def __init__(self, knowledgebase_path: str, data: dict[str, Union[str,int,list]]):
@@ -41,10 +37,7 @@ class Sharepoint(IntegrationStrategy):
   def run(self) -> None:
     indexer_config = SharepointIndexerConfig(
       path=self.__data.site_path,
-      recursive=self.__data.recursive,
-      omit_files=self.__data.omit_files,
-      omit_pages=self.__data.omit_pages,
-      omit_lists=self.__data.omit_lists
+      recursive=self.__data.recursive
     )
     downloader_config = SharepointDownloaderConfig(
       download_dir=self.working_directory
@@ -53,15 +46,15 @@ class Sharepoint(IntegrationStrategy):
       access_config=SharepointAccessConfig(client_cred=self.__data.client_secret),
       client_id=self.__data.client_id,
       site=self.__data.site_url,
-      permissions_config=None
+      tenant= self.__data.tenant_id if self.__data.tenant_id else None
     )
     pipeline = self.__unstructured_ingest.pipeline(
       indexer_config,
       downloader_config,
       connection_config,
       extension=self.__data.extension)
-    current_indexer_process = pipeline.indexer_step.process
-    pipeline.indexer_step.process = CustomSharepointIndexer(**vars(current_indexer_process))
+    #current_indexer_process = pipeline.indexer_step.process
+    #pipeline.indexer_step.process = CustomSharepointIndexer(**vars(current_indexer_process))
     pipeline.run()
   async def load(self) -> list[Document]:
       await asyncio.to_thread(self.run)

ws_bom_robot_app/llm/vector_store/integration/shopify.py

@@ -0,0 +1,143 @@
+import asyncio, logging, aiohttp
+from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy
+from langchain_core.documents import Document
+from ws_bom_robot_app.llm.vector_store.loader.base import Loader
+from typing import List, Union, Optional
+from pydantic import BaseModel, Field, AliasChoices, field_validator
+import json
+import os
+
+class ShopifyParams(BaseModel):
+  """
+  ShopifyParams is a model that defines the parameters required for Shopify integration.
+
+  Attributes:
+    shop_name (str): The shop name for Shopify.
+    access_token (str): The access token for Shopify.
+    graphql_query (Union[str, dict]): The GraphQL query string or dict for Shopify.
+  """
+  shop_name: str = Field(validation_alias=AliasChoices("shopName","shop_name"))
+  access_token: str = Field(validation_alias=AliasChoices("accessToken","access_token"))
+  graphql_query: Union[str, dict] = Field(validation_alias=AliasChoices("graphqlQuery","graphql_query"))
+
+  @field_validator('graphql_query')
+  @classmethod
+  def extract_query_string(cls, v):
+    """Extract the query string from dict format if needed"""
+    if isinstance(v, dict) and 'query' in v:
+      return v['query']
+    return v
+
+class Shopify(IntegrationStrategy):
+  def __init__(self, knowledgebase_path: str, data: dict[str, Union[str,int,list]]):
+    super().__init__(knowledgebase_path, data)
+    self.__data = ShopifyParams.model_validate(self.data)
+
+  def working_subdirectory(self) -> str:
+    return 'shopify'
+
+  async def run(self) -> None:
+    _data = await self.__get_data()
+    json_file_path = os.path.join(self.working_directory, 'shopify_data.json')
+    with open(json_file_path, 'w', encoding='utf-8') as f:
+      json.dump(_data, f, ensure_ascii=False)
+
+  async def load(self) -> list[Document]:
+    await self.run()
+    await asyncio.sleep(1)
+    return await Loader(self.working_directory).load()
+
+  async def __get_data(self, page_size: int = 50) -> List[dict]:
+      # URL dell'API
+    url = f"https://{self.__data.shop_name}.myshopify.com/admin/api/2024-07/graphql.json"
+
+    # Headers
+    headers = {
+        "X-Shopify-Access-Token": self.__data.access_token,
+        "Content-Type": "application/json"
+    }
+
+    all_data: List[dict] = []
+    has_next_page = True
+    cursor = None
+    retry_count = 0
+    max_retries = 5
+
+    while has_next_page:
+        # Variables per la query
+        variables = {
+            "first": page_size
+        }
+
+        if cursor:
+            variables["after"] = cursor
+
+        # Payload della richiesta
+        payload = {
+            "query": self.__data.graphql_query,
+            "variables": variables
+        }
+
+        try:
+            # Effettua la richiesta
+            async with aiohttp.ClientSession() as session:
+              async with session.post(url, headers=headers, json=payload) as response:
+                # Controlla se la risposta è JSON
+                try:
+                  data = await response.json()
+                except aiohttp.ContentTypeError:
+                  text = await response.text()
+                  logging.error(f"Non-JSON response received. Status code: {response.status}")
+                  logging.error(f"Content: {text}")
+                  raise Exception("Invalid response from API")
+
+            # Gestione del throttling
+            if "errors" in data:
+                error = data["errors"][0]
+                if error.get("extensions", {}).get("code") == "THROTTLED":
+                    retry_count += 1
+                    if retry_count > max_retries:
+                        raise Exception("Too many throttling attempts. Stopping execution.")
+
+                    # Aspetta un po' più a lungo ad ogni tentativo
+                    wait_time = 2 ** retry_count  # Backoff esponenziale
+                    print(f"Rate limit reached. Waiting {wait_time} seconds... (Attempt {retry_count}/{max_retries})")
+                    await asyncio.sleep(wait_time)
+                    continue
+                else:
+                    raise Exception(f"GraphQL errors: {data['errors']}")
+
+            # Resetta il contatore dei retry se la richiesta è andata bene
+            retry_count = 0
+
+            # Estrae i dati
+            _data = list(data["data"].values())[0]
+            edges = _data["edges"]
+            page_info = _data["pageInfo"]
+
+            # Aggiungi i dati alla lista
+            for edge in edges:
+                all_data.append(edge["node"])
+
+            # Aggiorna il cursore e il flag per la paginazione
+            has_next_page = page_info["hasNextPage"]
+            cursor = page_info["endCursor"]
+
+            print(f"Recuperati {len(edges)} prodotti. Totale: {len(all_data)}")
+
+            # Piccola pausa per evitare di saturare l'API
+            await asyncio.sleep(0.1)
+
+        except aiohttp.ClientError as e:
+            logging.error(f"Connection error: {e}")
+            retry_count += 1
+            if retry_count <= max_retries:
+                wait_time = 2 ** retry_count
+                logging.warning(f"Retrying in {wait_time} seconds...")
+                await asyncio.sleep(wait_time)
+                continue
+            else:
+                raise Exception("Too many network errors. Stopping execution.")
+
+    logging.info(f"Data retrieval completed! Total data: {len(all_data)}")
+    return all_data

ws_bom_robot_app/llm/vector_store/integration/sitemap.py

@@ -1,3 +1,4 @@
+import sys, asyncio
 from typing import Any, AsyncGenerator, AsyncIterator
 import aiofiles
 import aiofiles.os
@@ -32,6 +33,7 @@ class Sitemap(IntegrationStrategy):
         self.__exclude_class: list[str] = self.data.get("excludeClass",[]) # type: ignore
         self.__exclude_id: list[str] = self.data.get("excludeId",[]) # type: ignore
         self.__restrict_to_same_domain: bool = self.data.get("restrictDomain", True) # type: ignore
+        self.__header_template = self.data.get("headers", None)
     def working_subdirectory(self) -> str:
         return ""
     def _extract(self, tag: Tag) -> str:
@@ -64,6 +66,8 @@ class Sitemap(IntegrationStrategy):
         return f"{self.knowledgebase_path}/{url}" if self._is_local(url) else url
     async def alazy_load(self,loader: SitemapLoader) -> AsyncIterator[Document]:
         """A lazy loader for Documents."""
+        if sys.platform == 'win32':
+          asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
         iterator = await run_in_executor(None, loader.lazy_load)
         done = object()
         while True:
@@ -78,7 +82,8 @@ class Sitemap(IntegrationStrategy):
                 filter_urls=self.__filter_urls,
                 parsing_function=self._parse,
                 is_local=self._is_local(self.__sitemap_url),
-                restrict_to_same_domain=self.__restrict_to_same_domain
+                restrict_to_same_domain=self.__restrict_to_same_domain,
+                header_template=self.__header_template
             )
             _docs = self._output([document async for document in self.alazy_load(_loader)])
             if self._is_local(self.__sitemap_url):

ws_bom_robot_app/llm/vector_store/integration/slack.py

@@ -1,6 +1,7 @@
 import asyncio
 from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
-from unstructured_ingest.v2.processes.connectors.slack import SlackIndexerConfig, SlackDownloaderConfig, SlackConnectionConfig, SlackAccessConfig
+from unstructured_ingest.interfaces.downloader import DownloaderConfig
+from unstructured_ingest.processes.connectors.slack import SlackIndexerConfig, SlackDownloaderConfig, SlackConnectionConfig, SlackAccessConfig
 from langchain_core.documents import Document
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from typing import Union
@@ -39,7 +40,7 @@ class Slack(IntegrationStrategy):
       start_date=datetime.now() - timedelta(days=self.__data.num_days),
       end_date=datetime.now()
     )
-    downloader_config = SlackDownloaderConfig(
+    downloader_config = DownloaderConfig(
       download_dir=self.working_directory
     )
     connection_config = SlackConnectionConfig(