agentUniverse 0.0.11.dev1__tar.gz → 0.0.12.dev1__tar.gz

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentUniverse
-Version: 0.0.11.dev1
+Version: 0.0.12.dev1
 Summary: agentUniverse is a framework for developing applications powered by multi-agent base on large language model.
 Home-page: https://github.com/alipay/agentUniverse
 Author: AntGroup
@@ -36,6 +36,7 @@ Requires-Dist: myst-parser (>=2.0.0,<3.0.0)
 Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: ollama (>=0.2.1,<0.3.0)
 Requires-Dist: openai (==1.13.3)
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.25.0,<2.0.0)
 Requires-Dist: pandas (>=2.2.2,<3.0.0)
 Requires-Dist: pyarrow (>=16.1.0,<17.0.0)

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/action/knowledge/knowledge.py

@@ -14,6 +14,7 @@ from agentuniverse.agent.action.knowledge.reader.reader import Reader
 from agentuniverse.agent.action.knowledge.store.document import Document
 from agentuniverse.agent.action.knowledge.store.query import Query
 from agentuniverse.agent.action.knowledge.store.store import Store
+from agentuniverse.base.annotation.trace import trace_knowledge
 from agentuniverse.base.component.component_base import ComponentBase
 from agentuniverse.base.component.component_enum import ComponentEnum
 from agentuniverse.base.config.application_configer.application_config_manager import ApplicationConfigManager
@@ -53,6 +54,7 @@ class Knowledge(ComponentBase):
         document_list: List[Document] = self.reader.load_data()
         self.store.insert_documents(document_list, **kwargs)
 
+    @trace_knowledge
     def query_knowledge(self, **kwargs) -> List[Document]:
         """Query the knowledge.
 

agentuniverse-0.0.12.dev1/agentuniverse/agent/action/knowledge/reader/file/txt_reader.py

@@ -0,0 +1,39 @@
+
+from pathlib import Path
+from typing import List, Optional, Dict
+
+from agentuniverse.agent.action.knowledge.reader.reader import Reader
+from agentuniverse.agent.action.knowledge.store.document import Document
+
+
+class LineTxtReader(Reader):
+
+    def load_data(self, fpath: Path, ext_info: Optional[Dict] = None) -> List[Document]:
+        dlist = []
+
+        with open(fpath, 'r', encoding='utf-8') as file:
+
+            metadata = {"file_name": file.name}
+            if ext_info is not None:
+                metadata.update(ext_info)
+
+            for line in file:
+                dlist.append(Document(text=line, metadata=metadata or {}))
+
+        return dlist
+
+
+class TxtReader(Reader):
+    """Txt reader."""
+
+    def load_data(self, fpath: Path, ext_info: Optional[Dict] = None) -> List[Document]:
+
+        with open(fpath, 'r', encoding='utf-8') as file:
+
+            metadata = {"file_name": file.name}
+            if ext_info is not None:
+                metadata.update(ext_info)
+
+            txt = file.read()
+
+        return [Document(text=txt, metadata=metadata or {})]

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/action/knowledge/store/chroma_store.py

@@ -96,7 +96,7 @@ class ChromaStore(Store):
             self.collection.add(
                 documents=[document.text],
                 metadatas=[document.metadata],
-                embeddings=[embedding] if embedding is not None else None,
+                embeddings=[embedding] if len(embedding) > 0 else None,
                 ids=[document.id]
             )
 

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/action/tool/tool.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel
 from langchain.tools import Tool as LangchainTool
 
 from agentuniverse.agent.action.tool.enum import ToolTypeEnum
+from agentuniverse.base.annotation.trace import trace_tool
 from agentuniverse.base.component.component_base import ComponentBase
 from agentuniverse.base.component.component_enum import ComponentEnum
 from agentuniverse.base.config.application_configer.application_config_manager import ApplicationConfigManager
@@ -61,6 +62,7 @@ class Tool(ComponentBase):
     def __init__(self, **kwargs):
         super().__init__(component_type=ComponentEnum.TOOL, **kwargs)
 
+    @trace_tool
     def run(self, **kwargs):
         """The callable method that runs the tool."""
         self.input_check(kwargs)
@@ -73,6 +75,7 @@ class Tool(ComponentBase):
             if key not in kwargs.keys():
                 raise Exception(f'{self.get_instance_code()} - The input must include key: {key}.')
 
+    @trace_tool
     def langchain_run(self, *args, callbacks=None, **kwargs):
         """The callable method that runs the tool."""
         kwargs["callbacks"] = callbacks

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/default/executing_agent/executing_agent.py

@@ -5,21 +5,23 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: executing_agent.py
 """Executing Agent module."""
-import copy
 from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED
 from typing import Optional, Any
 
 from agentuniverse.agent.action.tool.tool_manager import ToolManager
 from agentuniverse.agent.agent import Agent
+from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
 from agentuniverse.agent.plan.planner.planner import Planner
 from agentuniverse.agent.plan.planner.planner_manager import PlannerManager
+from agentuniverse.base.context.framework_context_manager import FrameworkContextManager
 
 
 class ExecutingAgent(Agent):
     """Executing Agent class."""
 
     executor: Optional[Any] = ThreadPoolExecutor(max_workers=10, thread_name_prefix="executing_agent")
+    _context_values: Optional[dict] = {}
 
     def input_keys(self) -> list[str]:
         """Return the input keys of the Agent."""
@@ -54,12 +56,16 @@ class ExecutingAgent(Agent):
         llm_result = []
         executing_result = []
         futures = planner_result.get('futures')
+        index = 1
+        # assemble results of the execution process.
         for future in futures:
             task_result = future.result()
             llm_result.append(task_result)
             executing_result.append({
-                'input': task_result['input'], 'output': task_result['output']
+                'input': f"Question {index}: " + task_result.get('input', ''),
+                'output': f"Answer {index}: " + task_result.get('output', '')
             })
+            index += 1
 
         return {'executing_result': executing_result, 'llm_result': llm_result}
 
@@ -73,6 +79,7 @@ class ExecutingAgent(Agent):
         Returns:
             dict: Agent result object.
         """
+        self._context_values: dict = FrameworkContextManager().get_all_contexts()
         framework = agent_input.get('framework', [])
         futures = []
         for task in framework:
@@ -81,11 +88,37 @@ class ExecutingAgent(Agent):
             agent_input_copy['input'] = task
             planner: Planner = PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name'))
             futures.append(
-                self.executor.submit(planner.invoke, self.agent_model, agent_input_copy,
+                self.executor.submit(self.run_in_executor, planner, self.agent_model, agent_input_copy,
                                      self.process_intput_object(input_object, task, planner.input_key)))
         wait(futures, return_when=ALL_COMPLETED)
         return {'futures': futures}
 
+    def run_in_executor(self, planner: Planner, agent_model: AgentModel, planner_input: dict,
+                        input_object: InputObject) -> dict:
+        """The execution function of the thread pool.
+
+        Args:
+            planner(Planner): The planner object.
+            agent_model (AgentModel): The agent model object.
+            planner_input (dict): The planner input dict.
+            input_object (InputObject): The input parameters passed by the user.
+        Returns:
+            dict: The planner execution result.
+        """
+        context_tokens = {}
+        try:
+            # pass the framework context into the thread.
+            for var_name, var_value in self._context_values.items():
+                token = FrameworkContextManager().set_context(var_name, var_value)
+                context_tokens[var_name] = token
+            # invoke planner
+            res = planner.invoke(agent_model, planner_input, input_object)
+            return res
+        finally:
+            # clear the framework context.
+            for var_name, token in context_tokens.items():
+                FrameworkContextManager().reset_context(var_name, token)
+
     def process_intput_object(self, input_object: InputObject, subtask: str, planner_input_key: str) -> InputObject:
         """Process input object for the executing agent.
 

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/memory/message.py

@@ -24,7 +24,7 @@ class Message(BaseModel):
     """
 
     type: Optional[str] = None
-    content: Union[str, List[Union[str, Dict]]] = None
+    content: Optional[Union[str, List[Union[str, Dict]]]] = None
 
     def as_langchain(self):
         """Convert the agentUniverse(aU) message class to the langchain message class."""

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/plan/planner/peer_planner/peer_planner.py

@@ -6,6 +6,7 @@
 # @FileName: peer_planner.py
 """Peer planner module."""
 from agentuniverse.agent.action.tool.tool_manager import ToolManager
+from agentuniverse.agent.agent import Agent
 from agentuniverse.agent.agent_manager import AgentManager
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
@@ -42,7 +43,7 @@ class PeerPlanner(Planner):
         """
         planner_config = agent_model.plan.get('planner')
         sub_agents = self.generate_sub_agents(planner_config)
-        return self.agents_run(agent_model, sub_agents, planner_config, planner_input, input_object)
+        return self.agents_run(sub_agents, planner_config, planner_input, input_object)
 
     @staticmethod
     def generate_sub_agents(planner_config: dict) -> dict:
@@ -79,7 +80,7 @@ class PeerPlanner(Planner):
             elif context:
                 input_object.add_data('expert_framework', context)
 
-    def agents_run(self, agent_mode: AgentModel, agents: dict, planner_config: dict, agent_input: dict,
+    def agents_run(self, agents: dict, planner_config: dict, agent_input: dict,
                    input_object: InputObject) -> dict:
         """Planner agents run.
 
@@ -105,10 +106,10 @@ class PeerPlanner(Planner):
 
         self.build_expert_framework(planner_config, input_object)
 
-        planningAgent = agents.get('planning')
-        executingAgent = agents.get('executing')
-        expressingAgent = agents.get('expressing')
-        reviewingAgent = agents.get('reviewing')
+        planningAgent: Agent = agents.get('planning')
+        executingAgent: Agent = agents.get('executing')
+        expressingAgent: Agent = agents.get('expressing')
+        reviewingAgent: Agent = agents.get('reviewing')
 
         for _ in range(retry_count):
             LOGGER.info(f"Starting peer agents, retry_count is {_ + 1}.")
@@ -126,10 +127,13 @@ class PeerPlanner(Planner):
                 for index, one_framework in enumerate(planning_result.get_data('framework')):
                     logger_info += f"[{index + 1}] {one_framework} \n"
                 LOGGER.info(logger_info)
-                self.stream_output(input_object, {"data": {
-                    'output': planning_result.to_dict(),
-                    "agent_info": agent_mode.info
-                }, "type": "planning"})
+
+                # add planning agent intermediate steps
+                if planningAgent:
+                    self.stream_output(input_object, {"data": {
+                        'output': planning_result.get_data('framework'),
+                        "agent_info": planningAgent.agent_model.info
+                    }, "type": "planning"})
 
             if not executing_result or jump_step in ["planning", "executing"]:
                 if not executingAgent:
@@ -148,10 +152,13 @@ class PeerPlanner(Planner):
                         one_exec_log_info += f"[{index + 1}] output: {one_exec_res['output']}\n"
                         logger_info += one_exec_log_info
                 LOGGER.info(logger_info)
-                self.stream_output(input_object, {"data": {
-                    'output': executing_result.to_dict(),
-                    "agent_info": agent_mode.info
-                }, "type": "executing"})
+
+                # add executing agent intermediate steps
+                if executingAgent:
+                    self.stream_output(input_object, {"data": {
+                        'output': executing_result.get_data('executing_result'),
+                        "agent_info": executingAgent.agent_model.info
+                    }, "type": "executing"})
 
             if not expressing_result or jump_step in ["planning", "executing", "expressing"]:
                 if not expressingAgent:
@@ -166,10 +173,13 @@ class PeerPlanner(Planner):
                 logger_info = f"\nExpressing agent execution result is :\n"
                 logger_info += f"{expressing_result.get_data('output')}"
                 LOGGER.info(logger_info)
-                self.stream_output(input_object, {"data": {
-                    'output': expressing_result.get_data('output'),
-                    "agent_info": agent_mode.info
-                }, "type": "expressing"})
+
+                # add expressing agent intermediate steps
+                if expressingAgent:
+                    self.stream_output(input_object, {"data": {
+                        'output': expressing_result.get_data('output'),
+                        "agent_info": expressingAgent.agent_model.info
+                    }, "type": "expressing"})
 
             if not reviewing_result or jump_step in ["planning", "executing", "expressing", "reviewing"]:
                 if not reviewingAgent:
@@ -193,7 +203,14 @@ class PeerPlanner(Planner):
                     reviewing_info_str = f"review suggestion: {reviewing_result.get_data('suggestion')} \n"
                     reviewing_info_str += f"review score: {reviewing_result.get_data('score')} \n"
                     LOGGER.info(logger_info + reviewing_info_str)
-                    self.stream_output(input_object, {"data": reviewing_result.to_dict(), "type": "reviewing"})
+
+                    # add reviewing agent intermediate steps
+                    self.stream_output(input_object,
+                                       {"data": {
+                                           'output': reviewing_result.get_data('suggestion'),
+                                           "agent_info": reviewingAgent.agent_model.info
+                                       }, "type": "reviewing"})
+
                     if reviewing_result.get_data('score') and reviewing_result.get_data('score') >= eval_threshold:
                         loopResults.append({
                             "planning_result": planning_result,

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/plan/planner/planner.py

@@ -76,6 +76,10 @@ class Planner(ComponentBase):
         """
         chat_history: list = planner_input.get('chat_history')
         memory_name = agent_model.memory.get('name')
+        memory: ChatMemory = MemoryManager().get_instance_obj(component_instance_name=memory_name)
+        if memory is None:
+            return None
+
         llm_model = agent_model.memory.get('llm_model') or dict()
         llm_name = llm_model.get('name') or agent_model.profile.get('llm_model').get('name')
 
@@ -86,10 +90,6 @@ class Planner(ComponentBase):
         params['llm'] = llm
         params['input_key'] = self.input_key
         params['output_key'] = self.output_key
-
-        memory: ChatMemory = MemoryManager().get_instance_obj(component_instance_name=memory_name)
-        if memory is None:
-            return None
         return memory.set_by_agent_model(**params)
 
     def run_all_actions(self, agent_model: AgentModel, planner_input: dict, input_object: InputObject):
@@ -118,8 +118,8 @@ class Planner(ComponentBase):
             knowledge: Knowledge = KnowledgeManager().get_instance_obj(knowledge_name)
             if knowledge is None:
                 continue
-            knowledge_res: List[Document] = knowledge.store.query(
-                Query(query_str=input_object.get_data(self.input_key), similarity_top_k=2), **input_object.to_dict())
+            knowledge_res: List[Document] = knowledge.query_knowledge(query_str=input_object.get_data(self.input_key),
+                                                                      **input_object.to_dict())
             for document in knowledge_res:
                 action_result.append(document.text)
 
@@ -185,8 +185,9 @@ class Planner(ComponentBase):
             return
         output_stream.put_nowait(data)
 
-    def invoke_chain(self, agent_model: AgentModel, chain: RunnableSerializable[Any, str], planner_input: dict, chat_history,
-               input_object: InputObject):
+    def invoke_chain(self, agent_model: AgentModel, chain: RunnableSerializable[Any, str], planner_input: dict,
+                     chat_history,
+                     input_object: InputObject):
 
         if not input_object.get_data('output_stream'):
             res = chain.invoke(input=planner_input, config={"configurable": {"session_id": "unused"}})
@@ -202,4 +203,3 @@ class Planner(ComponentBase):
             })
             result.append(token)
         return "".join(result)
-

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent/plan/planner/react_planner/stream_callback.py

@@ -7,10 +7,12 @@
 # @FileName: stream_callback.py
 
 import asyncio
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union
+from uuid import UUID
 
 from langchain_core.agents import AgentAction, AgentFinish
 from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import GenerationChunk, ChatGenerationChunk
 
 
 class StreamOutPutCallbackHandler(BaseCallbackHandler):
@@ -43,6 +45,24 @@ class StreamOutPutCallbackHandler(BaseCallbackHandler):
             }
         })
 
+    def on_llm_new_token(
+            self,
+            token: str,
+            *,
+            chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
+            run_id: UUID,
+            parent_run_id: Optional[UUID] = None,
+            **kwargs: Any,
+    ) -> Any:
+        # add token chunk to the queue.
+        self.queueStream.put_nowait({
+            "type": "token",
+            "data": {
+                "chunk": chunk.text,
+                "agent_info": self.agent_info
+            }
+        })
+
     def on_tool_end(
             self,
             output: str,

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent_serve/web/dal/request_library.py

@@ -5,7 +5,6 @@
 # @Author  : fanen.lhy
 # @Email   : fanen.lhy@antgroup.com
 # @FileName: request_library.py
-
 import datetime
 
 from sqlalchemy import JSON, Integer, String, DateTime, Text, Column
@@ -65,7 +64,8 @@ class RequestLibrary:
             name="__system_db__",
             db_wrapper_configer=_configer
         )
-        SQLDBWrapperManager().register("__system_db__", self.sqldb_wrapper)
+        SQLDBWrapperManager().register(self.sqldb_wrapper.get_instance_code(),
+                                       self.sqldb_wrapper)
 
     def __init_request_table(self):
         with self.sqldb_wrapper.sql_database._engine.connect() as conn:
@@ -76,8 +76,7 @@ class RequestLibrary:
         if not self.session:
             self.__init_request_table()
             self.session = self.sqldb_wrapper.get_session()
-        return self.session
-
+        return self.session()
 
     def query_request_by_request_id(self, request_id: str) -> RequestDO | None:
         """Get a RequestDO with given request_id.

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent_serve/web/request_task.py

@@ -5,7 +5,6 @@
 # @Author  : fanen.lhy
 # @Email   : fanen.lhy@antgroup.com
 # @FileName: request_task.py
-
 import enum
 from enum import Enum
 import json
@@ -20,6 +19,7 @@ from .dal.request_library import RequestLibrary
 from .dal.entity.request_do import RequestDO
 from .thread_with_result import ThreadWithReturnValue
 from agentuniverse.base.util.logging.logging_util import LOGGER
+from ...agent.output_object import OutputObject
 
 EOF_SIGNAL = '{"type": "EOF"}'
 
@@ -75,6 +75,8 @@ class RequestTask:
             return
         try:
             result = self.thread.result()
+            if isinstance(result, OutputObject):
+                result = result.to_dict()
             yield "data:" + json.dumps({"result": result},
                                        ensure_ascii=False) + "\n\n "
         except Exception as e:
@@ -122,6 +124,7 @@ class RequestTask:
     def stream_run(self):
         """Run the service in a separate thread and yield result stream."""
         self.kwargs['output_stream'] = self.queue
+
         self.thread = ThreadWithReturnValue(target=self.func,
                                             kwargs=self.kwargs)
         self.thread.start()

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent_serve/web/thread_with_result.py

@@ -8,9 +8,12 @@
 
 from threading import Thread
 
+from agentuniverse.base.context.framework_context_manager import FrameworkContextManager
+
 
 class ThreadWithReturnValue(Thread):
     """A thread can save the target func exec result."""
+
     def __init__(self, group=None, target=None, name=None,
                  args=(), kwargs=None):
         super().__init__(group, target, name, args, kwargs)
@@ -22,10 +25,17 @@ class ThreadWithReturnValue(Thread):
         self.target = target
         self._return = None
         self.error = None
+        self._context_values: dict = FrameworkContextManager().get_all_contexts()
 
     def run(self):
         """Run the target func and save result in _return."""
         if self.target is not None:
+            context_tokens = {}
+            # set the context values in the thread
+            for var_name, var_value in self._context_values.items():
+                token = FrameworkContextManager().set_context(var_name, var_value)
+                context_tokens[var_name] = token
+
             try:
                 self._return = self.target(*self.args, **self.kwargs)
             except Exception as e:
@@ -33,6 +43,9 @@ class ThreadWithReturnValue(Thread):
             finally:
                 if 'output_stream' in self.kwargs:
                     self.kwargs['output_stream'].put('{"type": "EOF"}')
+                # finally, clear the context values in the thread
+                for var_name, token in context_tokens.items():
+                    FrameworkContextManager().reset_context(var_name, token)
 
     def result(self):
         """Wait for target func finished, then return the result or raise an

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/agent_serve/web/web_util.py

@@ -13,10 +13,13 @@ import json
 from flask import request, make_response, jsonify
 
 from ..service_instance import ServiceInstance
+from ...agent.agent import Agent
+from ...agent.agent_manager import AgentManager
 
 
 def request_param(func):
     """An annotation used to parse the flask request params."""
+
     def wrapper(*args, **kwargs):
         if request.method == "GET":
             req_data = request.args.to_dict()
@@ -65,6 +68,23 @@ def service_run_queue(service_id, **kwargs):
             stream.put_nowait('{"type": "EOF"}')
 
 
+def agent_run_queue(agent_id, **kwargs):
+    """
+    The func used in a separate thread to run an agent, and the result will be saved in a queue if provided.
+    Args:
+        agent_id: The agent id
+        **kwargs: Arbitrary keyword arguments.
+    """
+    stream: queue.Queue = kwargs.get('output_stream')
+    try:
+        agent: Agent = AgentManager().get_instance_obj(agent_id)
+        res = agent.run(**kwargs)
+        return res
+    finally:
+        if stream:
+            stream.put_nowait('{"type": "EOF"}')
+
+
 def make_standard_response(success: bool,
                            result=None,
                            message: str = None,

{agentuniverse-0.0.11.dev1 → agentuniverse-0.0.12.dev1}/agentuniverse/base/agentuniverse.py

@@ -142,16 +142,16 @@ class AgentUniverse(object):
         for component_enum, package_list in component_package_map.items():
             if not package_list:
                 continue
-            component_configer_list = self.__scan(package_list, ConfigTypeEnum.YAML, component_enum)
+            component_configer_list = self.scan(package_list, ConfigTypeEnum.YAML, component_enum)
             component_configer_list_map[component_enum] = component_configer_list
 
         for component_enum, component_configer_list in component_configer_list_map.items():
             self.__register(component_enum, component_configer_list)
 
-    def __scan(self,
-               package_list: [str],
-               config_type_enum: ConfigTypeEnum,
-               component_enum: ComponentEnum) -> list:
+    def scan(self,
+             package_list: [str],
+             config_type_enum: ConfigTypeEnum,
+             component_enum: ComponentEnum) -> list:
         """Scan the component directory and return certain component configer list.
 
         Args:
@@ -191,6 +191,7 @@ class AgentUniverse(object):
             component_instance: ComponentBase = component_clz().initialize_by_component_configer(configer_instance)
             if component_instance is None:
                 continue
+            component_instance.component_config_path = component_configer.configer.path
             component_manager_clz().register(component_instance.get_instance_code(), component_instance)
 
     def __package_name_to_path(self, package_name: str) -> str: