diff --git a/doc/mvp/compute_task.drawio b/doc/mvp/compute_task.drawio index 981d7a7..ede6cf1 100644 --- a/doc/mvp/compute_task.drawio +++ b/doc/mvp/compute_task.drawio @@ -1,76 +1,76 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/doc/mvp/workflow.drawio b/doc/mvp/workflow.drawio index dfdce99..88b61cc 100644 --- a/doc/mvp/workflow.drawio +++ b/doc/mvp/workflow.drawio @@ -1,368 +1,368 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/aios_kernel/__init__.py b/src/aios_kernel/__init__.py index 515431f..5eff80e 100644 --- a/src/aios_kernel/__init__.py +++ b/src/aios_kernel/__init__.py @@ -1,7 +1,7 @@ -from .environment import environment,environment_event -from .agent import agent_msg,ai_agent,ai_agent_templete -from .compute_kernel import compute_kernel,compute_task -from .compute_node import compute_node,local_compute_node -from .open_ai_node import open_ai_compute_node -from .role import ai_role,ai_role_group -from .workflow import ai_workflow \ No newline at end of file +from .environment import Environment,EnvironmentEvent +from .agent import AgentMsg,AIAgent,AIAgentTemplete +from .compute_kernel import ComputeKernel,ComputeTask +from .compute_node import ComputeNode,LocalComputeNode +from .open_ai_node import OpenAI_ComputeNode +from .role import AIRole,AIRoleGroup +from .workflow import Workflow \ No newline at end of file diff --git a/src/aios_kernel/agent.py b/src/aios_kernel/agent.py index b4738a9..6b0e5fc 100644 --- a/src/aios_kernel/agent.py +++ b/src/aios_kernel/agent.py @@ -4,7 +4,7 @@ import logging logger = logging.getLogger(__name__) -class agent_msg: +class AgentMsg: def __init__(self) -> None: self.sender = None self.target = None @@ -23,7 +23,7 @@ class agent_msg: def parser_target(self,target:str) -> None: pass -class agent_prompt: +class AgentPrompt: def __init__(self) -> None: pass @@ -35,18 +35,18 @@ class agent_prompt: # chat session store the chat history between owner and agent # chat session might be large, so can read / write at stream mode. -class ai_chat_session: +class AIChatSession: def __init__(self) -> None: pass def get_owner_id(self) -> str: pass - def append_post(self,msg:agent_msg) -> None: + def append_post(self,msg:AgentMsg) -> None: """append msg to session, msg is post from session (owner => msg.target)""" pass - def append_recv(self,msg:agent_msg) -> None: + def append_recv(self,msg:AgentMsg) -> None: """append msg to session, msg is recv from msg'sender (msg.sender => owner)""" pass @@ -56,11 +56,11 @@ class ai_chat_session: #TODO : add iterator interface for read chat history -class ai_agent_templete: +class AIAgentTemplete: def __init__(self) -> None: pass -class ai_agent: +class AIAgent: def __init__(self) -> None: self.chat_sessions = None self.llm_model_name = None @@ -74,10 +74,10 @@ class ai_agent: def get_template_id(self) -> str: return self.template_id - def get_chat_session_for_msg(self,msg:agent_msg) -> ai_chat_session: + def get_chat_session_for_msg(self,msg:AgentMsg) -> AIChatSession: pass - def get_chat_session(self,sender:str,session_id:str) -> ai_chat_session: + def get_chat_session(self,sender:str,session_id:str) -> AIChatSession: pass def get_llm_model_name(self) -> str: diff --git a/src/aios_kernel/ai_function.py b/src/aios_kernel/ai_function.py index b3367fb..74cbdcc 100644 --- a/src/aios_kernel/ai_function.py +++ b/src/aios_kernel/ai_function.py @@ -1,4 +1,4 @@ -class ai_function: +class AIFunction: def __init__(self) -> None: self.intro : str = None @@ -21,7 +21,7 @@ class ai_function: pass # call chain is a combination of ai_function,group of ai_function. -class call_chain: +class CallChain: def __init__(self) -> None: pass diff --git a/src/aios_kernel/aios_shell.py b/src/aios_kernel/aios_shell.py index 5599573..610d5a9 100644 --- a/src/aios_kernel/aios_shell.py +++ b/src/aios_kernel/aios_shell.py @@ -1,14 +1,14 @@ # aiso shell like bash of linux -from .workflow import ai_workflow +from .workflow import Workflow -class aios_shell: +class AIOS_Shell: def __init__(self,username:str) -> None: pass async def send_msg(self,msg:str,target_workflow:str) -> str: pass - async def install_workflow(self,workflow_id:ai_workflow) -> None: + async def install_workflow(self,workflow_id:Workflow) -> None: pass \ No newline at end of file diff --git a/src/aios_kernel/compute_kernel.py b/src/aios_kernel/compute_kernel.py index 07dedde..d05bd02 100644 --- a/src/aios_kernel/compute_kernel.py +++ b/src/aios_kernel/compute_kernel.py @@ -3,25 +3,25 @@ from typing import Optional import logging import asyncio -from .agent import agent_prompt -from .compute_node import compute_node +from .agent import AgentPrompt +from .compute_node import ComputeNode logger = logging.getLogger(__name__) # How to dispatch different computing tasks (some tasks may contain a large amount of state for correct execution) # to suitable computing nodes, achieving a balance of speed, cost, and power consumption, # is the CORE GOAL of the entire computing task schedule system (aios_kernel). -class compute_task(ABC): +class ComputeTask(ABC): @abstractmethod def display(self) -> str: pass -class compute_kernel: +class ComputeKernel: _instance = None def __new__(cls): if cls._instance is None: - cls._instance = super(compute_kernel, cls).__new__(cls) + cls._instance = super(ComputeKernel, cls).__new__(cls) return cls._instance def __init__(self) -> None: @@ -29,7 +29,7 @@ class compute_kernel: self.is_start = False pass - def run(self,task:compute_task) -> None: + def run(self,task:ComputeTask) -> None: # check there is compute node can support this task if self.is_task_support(task) is False: logger.error(f"task {task.display()} is not support by any compute node") @@ -47,31 +47,31 @@ class compute_kernel: async def _run_task_loop(): while True: task = self.task_queue.pop(0) - c_node:compute_node= await self._schedule(task) + c_node:ComputeNode= await self._schedule(task) c_node.push_task(task) asyncio.create_task(_run_task_loop()) - async def _schedule(self,task) -> compute_node: + async def _schedule(self,task) -> ComputeNode: pass - def add_compute_node(self,node:compute_node): + def add_compute_node(self,node:ComputeNode): pass def disable_compute_node(self,): pass - def is_task_support(self,task:compute_task) -> bool: + def is_task_support(self,task:ComputeTask) -> bool: pass # friendly interface for use: - def llm_completion(self,prompt:agent_prompt,mode_name:Optional[str] = None,max_token:int = 0) -> compute_task: + def llm_completion(self,prompt:AgentPrompt,mode_name:Optional[str] = None,max_token:int = 0) -> ComputeTask: # craete a llm_work_task ,push on queue's end # then task_schedule would run this task.(might schedule some work_task to another host) pass - async def do_llm_completion(self,prompt:agent_prompt,mode_name:Optional[str] = None,max_token:int = 0) -> str: + async def do_llm_completion(self,prompt:AgentPrompt,mode_name:Optional[str] = None,max_token:int = 0) -> str: pass \ No newline at end of file diff --git a/src/aios_kernel/compute_node.py b/src/aios_kernel/compute_node.py index 2e05fca..acf32a6 100644 --- a/src/aios_kernel/compute_node.py +++ b/src/aios_kernel/compute_node.py @@ -1,9 +1,9 @@ from abc import ABC, abstractmethod -from .compute_kernel import compute_task +from .compute_kernel import ComputeTask -class compute_node(ABC): +class ComputeNode(ABC): @abstractmethod - async def push_task(self,task:compute_task,proiority:int = 0): + async def push_task(self,task:ComputeTask,proiority:int = 0): pass async def remove_task(self,task_id:str): @@ -38,7 +38,7 @@ class compute_node(ABC): -class local_compute_node(compute_node): +class LocalComputeNode(ComputeNode): def display(self) -> str: return super().display() diff --git a/src/aios_kernel/environment.py b/src/aios_kernel/environment.py index 60b2625..29de5b8 100644 --- a/src/aios_kernel/environment.py +++ b/src/aios_kernel/environment.py @@ -4,14 +4,14 @@ from abc import ABC, abstractmethod from typing import Callable -from .agent import agent_msg +from .agent import AgentMsg -class environment_event(ABC): +class EnvironmentEvent(ABC): @abstractmethod def display(self) -> str: pass -class environment: +class Environment: def __init__(self) -> None: pass diff --git a/src/aios_kernel/open_ai_node.py b/src/aios_kernel/open_ai_node.py index f362ed8..69279d9 100644 --- a/src/aios_kernel/open_ai_node.py +++ b/src/aios_kernel/open_ai_node.py @@ -1,6 +1,6 @@ -from .compute_node import compute_node +from .compute_node import ComputeNode -class open_ai_compute_node(compute_node): +class OpenAI_ComputeNode(ComputeNode): def display(self) -> str: return super().display() diff --git a/src/aios_kernel/role.py b/src/aios_kernel/role.py index 2be34f5..0b22a95 100644 --- a/src/aios_kernel/role.py +++ b/src/aios_kernel/role.py @@ -1,22 +1,22 @@ -from .agent import ai_agent +from .agent import AIAgent -class ai_role: +class AIRole: def __init__(self) -> None: self.agent_instance_id : str = None self.role_name : str = None - self.agent : ai_agent = None + self.agent : AIAgent = None self.introduce : str = None def load_from_config(self,config:dict) -> bool: pass - + def get_intro(self) -> str: return self.introduce def get_name(self) -> str: return self.role_name -class ai_role_group: +class AIRoleGroup: def __init__(self) -> None: self.roles : dict[str,str]= None pass diff --git a/src/aios_kernel/workflow.py b/src/aios_kernel/workflow.py index 05e1faa..2192b09 100644 --- a/src/aios_kernel/workflow.py +++ b/src/aios_kernel/workflow.py @@ -3,26 +3,26 @@ import logging import asyncio from typing import Optional,Tuple -from .environment import environment,environment_event -from .agent import agent_prompt,agent_msg,ai_chat_session -from .role import ai_role -from .ai_function import call_chain -from .compute_kernel import compute_kernel +from .environment import Environment,EnvironmentEvent +from .agent import AgentPrompt,AgentMsg,AIChatSession +from .role import AIRole +from .ai_function import CallChain +from .compute_kernel import ComputeKernel logger = logging.getLogger(__name__) -class ai_message_filter: +class MessageFilter: def __init__(self) -> None: pass - def select(self,msg:agent_msg) -> ai_role: + def select(self,msg:AgentMsg) -> AIRole: pass -class ai_workflow: +class Workflow: def __init__(self) -> None: - self.rule_prompt : agent_prompt = None + self.rule_prompt : AgentPrompt = None self.workflow_config = None self.role_group = None - self.input_filter : ai_message_filter= None + self.input_filter : MessageFilter= None self.msg_queue = [] self.connected_environment = {} @@ -33,70 +33,70 @@ class ai_workflow: # When processing one message, it can process another message at the same time. # chatsession is synchronous, it has to wait for the previous message to finish processing before it can process the next message. # Therefore, post a message needs to specify the session_id explicitly, if not specified it will be automatically created by workflow. - def post_msg(self,msg:agent_msg) -> None: + def post_msg(self,msg:AgentMsg) -> None: self.msg_queue.append(msg) return - async def send_msg(self,msg:agent_msg) -> str: + async def send_msg(self,msg:AgentMsg) -> str: pass async def run(self): # TODO add tracking design of msg processing while True: the_msg = await self._pop_msg() - chatsession:ai_chat_session = self._get_chat_session_for_msg(the_msg) + chatsession:AIChatSession = self._get_chat_session_for_msg(the_msg) if chatsession is None: logger.error(f"get_chat_session_for_msg return None for :{the_msg}") continue chatsession.append_recv(the_msg) - async def _process_msg(msg:agent_msg,the_role) -> None: + async def _process_msg(msg:AgentMsg,the_role) -> None: # prompt generat progress is most important part of workflow(app) develope - prompt = agent_prompt() + prompt = AgentPrompt() prompt.append(the_role.get_prompt()) prompt.append(self.get_workflow_rule_prompt()) prompt.append(self._get_function_prompt(the_role.get_name())) prompt.append(self._get_knowlege_prompt(the_role.get_name())) prompt.append(await self._get_prompt_from_session(chatsession,the_role.get_name())) # chat context - result = await compute_kernel().do_llm_completion(prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) + result = await ComputeKernel().do_llm_completion(prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) final_result = result result_type : str = self._get_llm_result_type(result) is_ignore = False match result_type: case "function": - callchain:call_chain = self._parse_function_call_chain(result) + callchain:CallChain = self._parse_function_call_chain(result) resp = await callchain.exec() if callchain.have_result(): # generator proc resp prompt with WAITING state - proc_resp_prompt:agent_prompt = self._get_resp_prompt(resp,msg,the_role,prompt,chatsession) - final_result = await compute_kernel().do_llm_completion(proc_resp_prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) + proc_resp_prompt:AgentPrompt = self._get_resp_prompt(resp,msg,the_role,prompt,chatsession) + final_result = await ComputeKernel().do_llm_completion(proc_resp_prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) return final_result case "send_message": # send message to other / sub workflow - next_msg:agent_msg = self._parse_to_msg(result) + next_msg:AgentMsg = self._parse_to_msg(result) if next_msg is not None: # TODO: Next Target can be another role in workflow - next_workflow:ai_workflow = self.get_workflow(next_msg.get_target()) + next_workflow:Workflow = self.get_workflow(next_msg.get_target()) inner_chat_session = the_role.agent.get_chat_session(next_msg.get_target(),next_msg.get_session_id()) inner_chat_session.append_post(next_msg) resp = await next_workflow.send_msg(next_msg) inner_chat_session.append_recv(resp) # generator proc resp prompt with WAITING state - proc_resp_prompt:agent_prompt = self._get_resp_prompt(resp,msg,the_role,prompt,chatsession) - final_result = await compute_kernel().do_llm_completion(proc_resp_prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) + proc_resp_prompt:AgentPrompt = self._get_resp_prompt(resp,msg,the_role,prompt,chatsession) + final_result = await ComputeKernel().do_llm_completion(proc_resp_prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size()) return final_result case "post_message": # post message to other / sub workflow - next_msg:agent_msg = self._parse_to_msg(result) + next_msg:AgentMsg = self._parse_to_msg(result) if next_msg is not None: - next_workflow:ai_workflow = self.get_workflow(next_msg.get_target()) + next_workflow:Workflow = self.get_workflow(next_msg.get_target()) inner_chat_session = the_role.agent.get_chat_session(next_msg.get_target(),next_msg.get_session_id()) inner_chat_session.append_post(next_msg) next_workflow.post_msg(next_msg) @@ -113,7 +113,7 @@ class ai_workflow: return result - async def _workflow_process_msg(msg:agent_msg) -> None: + async def _workflow_process_msg(msg:AgentMsg) -> None: final_result = None if self.input_filter is not None: select_role = self.input_filter.select(msg) @@ -134,7 +134,7 @@ class ai_workflow: # merge result from all roles # TODO: one input msg can have multiple result msg, at this while ,we only support one result msg - final_result:agent_msg = self._merge_msg_result(results) + final_result:AgentMsg = self._merge_msg_result(results) if chatsession is not None: chatsession.append_post(final_result) @@ -144,59 +144,59 @@ class ai_workflow: asyncio.create_task(_workflow_process_msg(the_msg)) - async def _pop_msg(self) -> agent_msg: + async def _pop_msg(self) -> AgentMsg: pass - def _get_chat_session_for_msg(self,msg:agent_msg) -> ai_chat_session: + def _get_chat_session_for_msg(self,msg:AgentMsg) -> AIChatSession: pass - async def _get_prompt_from_session(self,chatsession:ai_chat_session,role_name:str) -> agent_prompt: + async def _get_prompt_from_session(self,chatsession:AIChatSession,role_name:str) -> AgentPrompt: pass def _get_msg_queue(self,session_id:str): pass - def _merge_msg_result(self,results:dict) -> agent_msg: + def _merge_msg_result(self,results:dict) -> AgentMsg: pass - def _get_function_prompt(self,role_name:str) -> agent_prompt: + def _get_function_prompt(self,role_name:str) -> AgentPrompt: pass - def _get_knowlege_prompt(self,role_name:str) -> agent_prompt: + def _get_knowlege_prompt(self,role_name:str) -> AgentPrompt: pass - def _get_resp_prompt(self,resp:str,msg:agent_msg,role:ai_role,prompt:agent_prompt,chatsession:ai_chat_session) -> agent_prompt: + def _get_resp_prompt(self,resp:str,msg:AgentMsg,role:AIRole,prompt:AgentPrompt,chatsession:AIChatSession) -> AgentPrompt: pass - def get_workflow_rule_prompt(self) -> agent_prompt: + def get_workflow_rule_prompt(self) -> AgentPrompt: return self.rule_prompt def _get_llm_result_type(self,llm_resp_str:str) -> str: pass - def _parse_function_call_chain(self,llm_resp_str) -> call_chain: + def _parse_function_call_chain(self,llm_resp_str) -> CallChain: pass - def _parse_to_msg(self,llm_resp_str) -> agent_msg: + def _parse_to_msg(self,llm_resp_str) -> AgentMsg: pass - def get_workflow(self,workflow_name:str) -> ai_workflow: + def get_workflow(self,workflow_name:str) -> Workflow: """get workflow from known workflow list or sub workflow list""" pass - def _env_event_to_msg(self,env_event:environment_event) -> agent_msg: + def _env_event_to_msg(self,env_event:EnvironmentEvent) -> AgentMsg: pass - def get_inner_environment(self,env_id:str) -> environment: + def get_inner_environment(self,env_id:str) -> Environment: pass - def connect_to_environment(self,env:environment) -> None: + def connect_to_environment(self,env:Environment) -> None: the_env = self.connected_environment.get(env.get_id()) if the_env is None: self.connected_environment[env.get_id()] = env - def _env_msg_handler(env_event:environment_event) -> None: - the_msg:agent_msg= self._env_event_to_msg(env_event) + def _env_msg_handler(env_event:EnvironmentEvent) -> None: + the_msg:AgentMsg= self._env_event_to_msg(env_event) self.post_msg(the_msg) # register all event handler diff --git a/src/component/agent_manager/__init__.py b/src/component/agent_manager/__init__.py index 863c4d1..7313a5a 100644 --- a/src/component/agent_manager/__init__.py +++ b/src/component/agent_manager/__init__.py @@ -1,3 +1,3 @@ -from .agent_manager import agent_manager,agent_manager_client +from .agent_manager import AgentManager,AgentManagerClient from .agent import ai_agent from .templete import ai_agent_templete \ No newline at end of file diff --git a/src/component/agent_manager/agent_manager.py b/src/component/agent_manager/agent_manager.py index b6173b6..af39c88 100644 --- a/src/component/agent_manager/agent_manager.py +++ b/src/component/agent_manager/agent_manager.py @@ -2,14 +2,13 @@ import logging import toml -from .agent import ai_agent -from .templete import ai_agent_templete -from package_manager import pkg_env,pkg_env_mgr,pkg_media_info,media_reader,pkg_install_task +from aios_kernel import AIAgent,AIAgentTemplete +from package_manager import PackageEnv,PackageEnvManager,PackageMediaInfo,PackageInstallTask logger = logging.getLogger(__name__) -class agent_manager: +class AgentManager: _instance = None def __init__(self) -> None: @@ -18,18 +17,18 @@ class agent_manager: def __new__(cls): if cls._instance is None: - cls._instance = super(agent_manager, cls).__new__(cls) + cls._instance = super(AgentManager, cls).__new__(cls) return cls._instance def initial(self,root_dir:str) -> None: - self.agent_templete_env : pkg_env = pkg_env_mgr().get_env(f"{root_dir}templetes/agent_templetes.cfg") - self.agent_env : pkg_env = pkg_env_mgr().get_env(f"{root_dir}agents/agents.cfg") + self.agent_templete_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}templetes/agent_templetes.cfg") + self.agent_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}agents/agents.cfg") if self.agent_templete_env is None: raise Exception("agent_manager initial failed") - def get(self,agent_id:str) -> ai_agent: + def get(self,agent_id:str) -> AIAgent: the_agent = self.loaded_agent_instance.get(agent_id) if the_agent: return the_agent @@ -39,7 +38,7 @@ class agent_manager: if agent_media_info is None: return None - the_agent = self._load_agent_from_media(agent_media_info) + the_agent : AIAgent = self._load_agent_from_media(agent_media_info) if the_agent is None: logger.warn(f"load agent {agent_id} from media failed!") @@ -49,29 +48,25 @@ class agent_manager: def remove(self,agent_id:str)->int: pass - def get_templete(self,templete_id) -> ai_agent_templete: + def get_templete(self,templete_id) -> AIAgentTemplete: template_media_info = self.agent_templete_env.get(templete_id) if template_media_info is None: return None return self._load_templete_from_media(template_media_info) - def install(self,templete_id) -> pkg_install_task: + def install(self,templete_id) -> PackageInstallTask: installer = self.agent_templete_env.get_installer() return installer.install(templete_id) def uninstall(self,templete_id) -> int: pass - def _load_templete_from_media(self,templete_media:pkg_media_info) -> ai_agent_templete: + def _load_templete_from_media(self,templete_media:PackageMediaInfo) -> AIAgentTemplete: pass - def _load_agent_from_media(self,agent_media:pkg_media_info) -> ai_agent: + def _load_agent_from_media(self,agent_media:PackageMediaInfo) -> AIAgent: pass - def create(self,template,agent_name,agent_last_name,agent_introduce) -> ai_agent: + def create(self,template,agent_name,agent_last_name,agent_introduce) -> AIAgent: pass - -class agent_manager_client: - def __init__(self) -> None: - pass \ No newline at end of file diff --git a/src/component/ndn_client/__init__.py b/src/component/ndn_client/__init__.py index 6b4585c..23e2329 100644 --- a/src/component/ndn_client/__init__.py +++ b/src/component/ndn_client/__init__.py @@ -1 +1,2 @@ -from .cid import content_id \ No newline at end of file +from .cid import ContentId +from .ndn_client import NDN_Client \ No newline at end of file diff --git a/src/component/ndn_client/cid.py b/src/component/ndn_client/cid.py index 981df3b..da89ed4 100644 --- a/src/component/ndn_client/cid.py +++ b/src/component/ndn_client/cid.py @@ -1,8 +1,9 @@ -class content_id: +class ContentId: def __init__(self) -> None: pass + @staticmethod def create_from_str(cid_str:str): pass \ No newline at end of file diff --git a/src/component/ndn_client/ndn_client.py b/src/component/ndn_client/ndn_client.py index c507fb1..fe46f6b 100644 --- a/src/component/ndn_client/ndn_client.py +++ b/src/component/ndn_client/ndn_client.py @@ -1,13 +1,13 @@ -from .cid import content_id +from .cid import ContentId -class ndn_get_task: +class NDN_GetTask: def __init__(self) -> None: pass -class ndn_client: +class NDN_Client: def __init__(self): pass - def get_file(cid:content_id,target_path:str,urls:{}=None,options:{}=None): + def get_file(self,cid:ContentId,target_path:str,urls:{}=None,options:{}=None): pass \ No newline at end of file diff --git a/src/component/package_manager/__init__.py b/src/component/package_manager/__init__.py index b603579..0af5eb5 100644 --- a/src/component/package_manager/__init__.py +++ b/src/component/package_manager/__init__.py @@ -1,3 +1,3 @@ -from .env import pkg_env_mgr,pkg_env -from .pkg import pkg_info,pkg_media_info -from .installer import pkg_install_task \ No newline at end of file +from .env import PackageEnvManager,PackageEnv +from .pkg import PackageInfo,PackageMediaInfo +from .installer import PackageInstallTask \ No newline at end of file diff --git a/src/component/package_manager/env.py b/src/component/package_manager/env.py index 85c6b2a..b4cac9c 100644 --- a/src/component/package_manager/env.py +++ b/src/component/package_manager/env.py @@ -2,16 +2,16 @@ import logging import toml -from .pkg import pkg_info,pkg_media_info -from .installer import pkg_installer +from .pkg import PackageInfo,PackageMediaInfo +from .installer import PackageInstaller logger = logging.getLogger(__name__) -class pkg_env_mgr: +class PackageEnvManager: _instance = None def __new__(cls): if cls._instance is None: - cls._instance = super(pkg_env_mgr, cls).__new__(cls) + cls._instance = super(PackageEnvManager, cls).__new__(cls) return cls._instance def __init__(self) -> None: @@ -19,46 +19,46 @@ class pkg_env_mgr: pass - def get_env(self,cfg_path:str) -> pkg_env: + def get_env(self,cfg_path:str) -> PackageEnv: if cfg_path in self._pkg_envs: return self._pkg_envs[cfg_path] else: - pkg_env = pkg_env(cfg_path) + pkg_env = PackageEnv(cfg_path) self._pkg_envs[cfg_path] = pkg_env return pkg_env - def get_user_env(self) -> pkg_env: + def get_user_env(self) -> PackageEnv: pass - def get_system_env(self) -> pkg_env: + def get_system_env(self) -> PackageEnv: pass -class pkg_env: +class PackageEnv: def __init__(self,cfg_path:str) -> None: self.pkg_dir : str = "" self.pkg_obj_dir : str = "" self.is_strict : bool = True - self.parent_envs : list[pkg_env] = None + self.parent_envs : list[PackageEnv] = None self.index_dbs = None self.cfg_path = cfg_path self._load_pkg_cfg(cfg_path) pass - def load(self,pkg_name:str,search_parent=True) -> pkg_media_info: + def load(self,pkg_name:str,search_parent=True) -> PackageMediaInfo: pkg_path = None - pkg_id,verion_str,cid = pkg_info.parse_pkg_name(pkg_name) + pkg_id,verion_str,cid = PackageInfo.parse_pkg_name(pkg_name) if cid is None: if verion_str is None: - channel = self.get_pkg_channel_from_version(verion_str) + channel:str = self.get_pkg_channel_from_version(verion_str) if channel is None: pkg_path = f"{self.pkg_dir}{pkg_id}" else: pkg_path = f"{self.pkg_dir}{pkg_id}#{channel}" else: - channel = self.get_pkg_channel_from_version(verion_str) - the_version = self.get_exact_version_from_installed(verion_str) + channel:str = self.get_pkg_channel_from_version(verion_str) + the_version:str = self.get_exact_version_from_installed(verion_str) if the_version is None: logger.warn(f"load {pkg_name} failed: no match version from {verion_str}") return None @@ -69,7 +69,7 @@ class pkg_env: else: pkg_path = f"{self.pkg_obj_dir}.{pkg_id}/{cid}" - media_info = self.try_load_pkg_media_info(pkg_id,pkg_path) + media_info:PackageMediaInfo = self.try_load_pkg_media_info(pkg_path) if media_info is None: if search_parent: for parent_env in self.parent_envs: @@ -86,28 +86,28 @@ class pkg_env: def get_pkg_channel_from_version(self,pkg_version:str) -> str: pass - def get_pkg_media_info(self,pkg_name:str)->pkg_media_info: + def get_pkg_media_info(self,pkg_name:str)->PackageMediaInfo: pass - def try_load_pkg_media_info(self,pkg_full_path:str) -> pkg_media_info: + def try_load_pkg_media_info(self,pkg_full_path:str) -> PackageMediaInfo: pass - def get_installed_pkg_info(self,pkg_name:str) -> pkg_info: + def get_installed_pkg_info(self,pkg_name:str) -> PackageInfo: pass - def lookup(self,pkg_id:str,version_str:str) -> pkg_info: + def lookup(self,pkg_id:str,version_str:str) -> PackageInfo: # to make sure pkg.cid is correct, we MUST verfiy eveything here pass - def get_installer(self) -> pkg_installer: + def get_installer(self) -> PackageInstaller: pass @classmethod def is_valied_media(pkg_full_path:str) -> bool: pass - def do_pkg_media_trans(self,pkg_info:pkg_info,source_path:str,target_path:str) -> bool: + def do_pkg_media_trans(self,pkg_info:PackageInfo,source_path:str,target_path:str) -> bool: pass def _load_pkg_cfg(self,cfg_path:str): diff --git a/src/component/package_manager/installer.py b/src/component/package_manager/installer.py index e388de3..7055f0c 100644 --- a/src/component/package_manager/installer.py +++ b/src/component/package_manager/installer.py @@ -5,10 +5,9 @@ import aiohttp import aiofiles import os -from ndn_client import content_id,ndn_client -from .pkg import pkg_info,pkg_media_info -from .env import pkg_env - +from ndn_client import ContentId,NDN_Client +from .pkg import PackageInfo,PackageMediaInfo +from .env import PackageEnv logger = logging.getLogger(__name__) @@ -19,8 +18,8 @@ INSTALL_TASK_STATE_DOWNLOADING = 3 INSTALL_TASK_STATE_INSTALLING = 4 INSTALL_TAKS_STATE_ERROR = 5 -class pkg_install_task: - def __init__(self,owner:pkg_env) -> None: +class PackageInstallTask: + def __init__(self,owner:PackageEnv) -> None: self.owner = owner self.state = INSTALL_TASK_STATE_CHECK_DEPENDENCY @@ -29,20 +28,20 @@ class pkg_install_task: self.dependency_tasks = None self.error_str = None -class pkg_installer: - def __init__(self,owner_env:pkg_env) -> None: +class PackageInstaller: + def __init__(self,owner_env:PackageEnv) -> None: self.all_tasks = {} self.owner_env = owner_env def install(self,pkg_name:str, - install_from_dependency = False, can_upgrade = True,skip_depends = False,options = None)->Tuple[pkg_install_task,str]: + install_from_dependency = False, can_upgrade = True,skip_depends = False,options = None)->Tuple[PackageInstallTask,str]: - the_pkg_info : pkg_info = None + the_pkg_info : PackageInfo = None is_upgrade : bool = False need_backup : bool = False - pkg_id,version_str,cid = pkg_info.parse_pkg_name(pkg_name) - media_info : pkg_media_info = self.owner_env.get_media_info(pkg_name) # must use index-db? + pkg_id,version_str,cid = PackageInfo.parse_pkg_name(pkg_name) + media_info : PackageMediaInfo = self.owner_env.get_media_info(pkg_name) # must use index-db? if media_info is not None: if cid is not None: if can_upgrade: @@ -74,7 +73,7 @@ class pkg_installer: return result_task,"already installing" logger.info(f"start download&install {pkg_name},install_from_dependency={install_from_dependency},upgrade={is_upgrade},backup={need_backup},target_pkg_info={the_pkg_info}") - result_task = pkg_install_task() + result_task = PackageInstallTask(self.owner_env) self.all_tasks[the_pkg_info.cid] = result_task async def download_and_install_pkg()->int: # check dependency @@ -104,7 +103,7 @@ class pkg_installer: urls = self.owner_env.get_pkg_urls(the_pkg_info) #download - client = ndn_client() # set watch + client = NDN_Client() # set watch download_result = await client.get_file(the_pkg_info.cid,urls,target_full_path,options) if download_result !=0: result_task.state = INSTALL_TAKS_STATE_ERROR @@ -140,16 +139,16 @@ class pkg_installer: def uninstall(self): pass - def get_dependency_tasks(self,pkg:pkg_info,dependency_tasks): + def get_dependency_tasks(self,pkg:PackageInfo,dependency_tasks): pass - async def check_dependency(self,pkg:pkg_info,task_list:{}) -> bool: + async def check_dependency(self,pkg:PackageInfo,task_list:{}) -> bool: for depend_pkg_name in pkg.depends: depend_task = task_list.get(depend_pkg_name) if depend_task is not None: logger.debug(f"{pkg.name}'s depend pkg {depend_pkg_name} already in task list") continue - depend_task = pkg_install_task() + depend_task = PackageInstallTask(self.owner_env) task_list[depend_pkg_name] = depend_task depend_pkg_info = self.owner_env.lookup(depend_pkg_name) diff --git a/src/component/package_manager/pkg.py b/src/component/package_manager/pkg.py index d501eec..9944103 100644 --- a/src/component/package_manager/pkg.py +++ b/src/component/package_manager/pkg.py @@ -1,5 +1,7 @@ +from typing import Tuple -class pkg_info: + +class PackageInfo: def __init__(self) -> None: self.name = "" self.cid = None @@ -20,7 +22,7 @@ class pkg_info: def cid(self) -> str: return self.cid -class pkg_media_info: +class PackageMediaInfo: def __init__(self) -> None: pass