bioguider 0.2.52__py3-none-any.whl

bioguider/agents/identification_execute_step.py

@@ -0,0 +1,181 @@
+
+import logging
+
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from langchain.tools import BaseTool
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_community.callbacks.openai_info import OpenAICallbackHandler
+
+from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
+from bioguider.agents.agent_utils import CustomOutputParser, CustomPromptTemplate
+from bioguider.agents.peo_common_step import ( 
+    PEOCommonStep,
+)
+
+logger = logging.getLogger(__name__)
+
+## execution system prompt
+IDENTIFICATION_EXECUTION_SYSTEM_PROMPT = """You are an expert Python developer.
+
+You are given a **plan** and are expected to complete it using Python code and the available tools.
+
+---
+
+### **Available Tools**
+{tools}
+
+---
+
+### **Your Task**
+
+Execute the plan step by step using the format below:
+
+```
+Thought: Describe what you are thinking or planning to do next.  
+Action: The tool you are going to use (must be one of: {tool_names})  
+Action Input: The input to the selected action  
+Observation: The result returned by the action  
+```
+
+You may repeat the **Thought → Action → Action Input → Observation** loop as many times as needed.
+
+Once the plan is fully completed, output the result in the following format:
+```
+Thought: I have completed the plan.
+Final Answer:
+Action: {{tool_name}}
+Action Input: {{file_name1}}
+Action Observation: {{Observation1}}
+---
+Action: {{tool_name}}
+Action Input: {{file_name2}}
+Action Observation: {{Observation2}}
+---
+...
+```
+
+---
+
+### **Example**
+```
+Action: summarize_file_tool  
+Action Input: README.md  
+Action Input: "Please extract license information in summarized file content."
+Observation: # BioGuider\nBioGuider is a Python package for bioinformatics.\n...
+...
+Final Answer:
+Action: summarize_file_tool
+Action Input: README.md
+Action Input: "N/A"
+Action Observation: # BioGuider\nBioGuider is a Python package for bioinformatics.\n...
+---
+Action: check_file_related_tool
+Action Input: pyproject.toml
+Action Observation: Yes, the file is related to the project.
+---
+...
+```
+
+---
+
+### **Important Notes**
+
+- You must strictly follow the provided plan.  
+- **Do not take any additional or alternative actions**, even if:  
+  - No relevant result is found  
+  - The file content is missing, empty, or irrelevant  
+- If no information is found in a step, simply proceed to the next action in the plan without improvising.  
+- Only use the tools specified in the plan actions. No independent decisions or extra steps are allowed.
+
+### **Plan**
+{plan_actions}
+
+### **Actions Already Taken**
+{agent_scratchpad}
+
+---
+
+{input}
+"""
+
+class IdentificationExecuteStep(PEOCommonStep):
+    """
+    This class is a placeholder for common step functionality in the PEO agent.
+    It is currently empty and can be extended in the future.
+    """
+    def __init__(
+        self, 
+        llm: BaseChatOpenAI,
+        repo_path: str,
+        repo_structure: str,
+        gitignore_path: str,
+        custom_tools: list[BaseTool] | None = None,
+    ):
+        super().__init__(llm=llm)
+        self.llm = llm
+        self.step_name = "Identification Execution Step"
+        self.repo_path = repo_path
+        self.repo_structure = repo_structure
+        self.gitignore_path = gitignore_path
+        self.custom_tools = custom_tools if custom_tools is not None else []
+
+    def _execute_directly(self, state):
+        plan_actions = state["plan_actions"]
+        prompt = CustomPromptTemplate(
+            template=IDENTIFICATION_EXECUTION_SYSTEM_PROMPT,
+            tools=self.custom_tools,
+            plan_actions=plan_actions,
+            input_variables=[
+                "tools", 
+                "tool_names", 
+                "agent_scratchpad", 
+                "intermediate_steps", 
+                "plan_actions",
+            ],
+        )
+        output_parser = CustomOutputParser()
+        agent = create_react_agent(
+            llm=self.llm,
+            tools=self.custom_tools,
+            prompt=prompt,
+            output_parser=output_parser,
+            stop_sequence=["\nObservation:"],
+        )
+        callback_handler = OpenAICallbackHandler()
+        agent_executor = AgentExecutor(
+            agent=agent,
+            tools=self.custom_tools,
+            max_iterations=10,
+        )
+        response = agent_executor.invoke(
+            input={"plan_actions": plan_actions, "input": "Now, let's begin."},
+            callbacks=[callback_handler],
+        )
+        # parse the response
+        if "output" in response:
+            output = response["output"]
+            if "**Final Answer**" in output:
+                final_answer = output.split("**Final Answer:**")[-1].strip().strip(":")
+                step_output = final_answer
+            elif "Final Answer" in output:
+                final_answer = output.split("Final Answer")[-1].strip().strip(":")
+                step_output = final_answer
+            else:
+                step_output = output
+            step_output = step_output.strip().strip("```").strip('"""')
+            self._print_step(state, step_output=step_output)
+            state["step_output"] = step_output
+        else:
+            logger.error("No output found in the response.")
+            self._print_step(
+                state,
+                step_output="Error: No output found in the response.",
+            )
+            state["step_output"] = "Error: No output found in the response."
+        
+        token_usage = vars(callback_handler)
+        token_usage = {**DEFAULT_TOKEN_USAGE, **token_usage}
+            
+        return state, token_usage
+
+

bioguider/agents/identification_observe_step.py

@@ -0,0 +1,104 @@
+
+from langchain.prompts import ChatPromptTemplate
+
+from bioguider.agents.agent_utils import ObservationResult
+from bioguider.agents.common_agent_2step import CommonAgentTwoSteps, CommonAgentTwoChainSteps
+from bioguider.agents.identification_task_utils import IdentificationWorkflowState
+from bioguider.agents.peo_common_step import PEOWorkflowState, PEOCommonStep
+from bioguider.utils.constants import MAX_STEP_COUNT
+
+
+## observation system prompt
+IDENTIFICATION_OBSERVATION_SYSTEM_PROMPT = """Your goal is:
+{goal}
+
+### **Repository File Structure**
+Here is the 2-level file structure of the repository (f - file, d - directory, l - symlink, u - unknown):
+{repo_structure}
+
+### **Intermediate Output**
+{intermediate_output}
+
+### **Instructions**
+Carefully review the **Goal**, **Repository File Structure**, and **Intermediate Output**.
+- If you believe the goal **can be achieved**, proceed as follows:  
+  - Provide your reasoning under **Analysis**  
+  - Then provide your result under **FinalAnswer**  
+  ```
+  **Analysis**: your analysis here  
+  **FinalAnswer**: your final answer here, in **raw json format**, **including** the surrounding "{{}}" but **without** using code fence (```json ... ```), 
+  For example, output exactly: {final_answer_example}
+  ```
+- If the information is **not sufficient** to achieve the goal, simply explain why under **Thoughts**:  
+  ```
+  **Thoughts**: your thoughts here
+  ```
+Be precise and support your reasoning with evidence from the input.
+
+### **Important Instructions**
+{important_instructions}
+
+### Notes
+We are collecting information over multiple rounds, your thoughts and the output of this step will be persisted, so please **do not rush to provide a Final Answer**.  
+If you find the current information insufficient, share your reasoning or thoughts instead—we’ll continue with the next round accordingly.
+"""
+
+
+class IdentificationObserveStep(PEOCommonStep):
+    def __init__(
+        self,
+        llm,
+        repo_path: str,
+        repo_structure: str,
+        gitignore_path: str,
+        custom_tools: list = None,
+    ):
+        super().__init__(llm)
+        self.step_name = "Identification Observe Step"
+        self.repo_path = repo_path
+        self.repo_structure = repo_structure
+        self.gitignore_path = gitignore_path
+        self.custom_tools = custom_tools if custom_tools is not None else []
+
+    def _prepare_system_prompt(self, state: IdentificationWorkflowState): 
+        goal = state["goal"]
+        important_instructions = "N/A" \
+            if not "observe_instructions" in state else state["observe_instructions"]
+        final_answer_example = state["final_answer_example"]
+        intermediate_output = self._build_intermediate_steps(state)
+        prompt = ChatPromptTemplate.from_template(IDENTIFICATION_OBSERVATION_SYSTEM_PROMPT)
+
+        return prompt.format(
+            goal=goal,
+            repo_structure=self.repo_structure,
+            intermediate_output=intermediate_output,
+            final_answer_example=final_answer_example,
+            important_instructions=important_instructions,
+        )
+
+    def _execute_directly(self, state: IdentificationWorkflowState):
+        step_count = state["step_count"]
+        instruction = "Now, we have reached max recursion limit, please give me the **final answer** based on the current information" \
+            if step_count == MAX_STEP_COUNT/3 - 2 else "Now, Let's begin."
+        system_prompt = self._prepare_system_prompt(state)
+        agent = CommonAgentTwoSteps(llm=self.llm)
+        res, _, token_usage, reasoning_process = agent.go(
+            system_prompt=system_prompt,
+            instruction_prompt=instruction,
+            schema=ObservationResult,
+        )
+        state["final_answer"] = res.FinalAnswer
+        analysis = res.Analysis
+        thoughts = res.Thoughts
+        state["step_analysis"] = analysis
+        state["step_thoughts"] = thoughts
+        state["step_count"] += 1
+        self._print_step(
+            state,
+            step_output=f"**Observation Reasoning Process {state['step_count']}**\n{reasoning_process}"
+        )
+        self._print_step(
+            state,
+            step_output=f"Final Answer: {res.FinalAnswer if res.FinalAnswer else None}\nAnalysis: {analysis}\nThoughts: {thoughts}",
+        )
+        return state, token_usage

bioguider/agents/identification_plan_step.py

@@ -0,0 +1,140 @@
+
+from langchain.prompts import ChatPromptTemplate
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from bioguider.agents.agent_utils import get_tool_names_and_descriptions
+from bioguider.agents.common_agent_2step import CommonAgentTwoChainSteps, CommonAgentTwoSteps
+from bioguider.agents.identification_task_utils import IdentificationWorkflowState
+from bioguider.agents.peo_common_step import PEOCommonStep
+
+## plan system prompt
+IDENTIFICATION_PLAN_SYSTEM_PROMPT = ChatPromptTemplate.from_template("""### **Goal**
+You are an expert developer in the field of biomedical domain. Your goal is:
+{goal}
+
+### **Repository File Structure**
+Here is the 2-level file structure of the repository (f - file, d - directory, l - symlink, u - unknown):
+{repo_structure}
+
+### **Function Tools**
+You are provided the following function tools:
+{tools}
+
+### Intermediate Steps
+Hers are the intermediate steps results:
+{intermediate_steps}
+
+### Intermediate Thoughts
+Analysis: {intermediate_analysis}
+Thoughts: {intermediate_thoughts}
+
+### **Instruction**
+We will repeat **Plan - Execution - Observation** loops as many times as needed. All the results in each round will be persisted, 
+meaning that states and variables will persisted through multiple rounds of plan execution. Be sure to take advantage of this by 
+developing your collection plan incrementally and reflect on the intermediate observations at each round, instead of coding up 
+everything in one go. Be sure to take only one or two actions in each step.
+
+### **Important Instructions**
+{important_instructions}
+
+### **Output**
+You plan should follow this format:
+Step: tool name, should be one of {tool_names}
+Step Input: file name or directory name
+Step: tool name, should be one of {tool_names}
+Step Input: file name or directory name
+""")
+
+class IdentificationPlanResult(BaseModel):
+    """ Identification Plan Result """
+    actions: list[dict] = Field(description="a list of action dictionary, e.g. [{'name': 'read_file', 'input': 'README.md'}, ...]")
+
+IdentificationPlanResultJsonSchema = {
+    "title": "identification_plan_result",
+    "description": "plan result",
+    "type": "object",
+    "properties": {
+        "actions": {
+            "type": "array",
+            "description": """a list of action dictionary, e.g. [{'name': 'read_file', 'input': 'README.md'}, ...]""",
+            "title": "Actions",
+            "items": {"type": "object"}
+        },
+    },
+    "required": ["actions"],
+}
+
+class IdentificationPlanStep(PEOCommonStep):
+    def __init__(
+        self,
+        llm: BaseChatOpenAI,
+        repo_path: str,
+        repo_structure: str,
+        gitignore_path: str,
+        custom_tools: list[BaseTool] | None = None,
+    ): 
+        super().__init__(llm)
+        self.step_name = "Identification Plan Step"
+        self.repo_path = repo_path
+        self.repo_structure = repo_structure
+        self.gitignore_path = gitignore_path
+        self.custom_tools = custom_tools if custom_tools is not None else []
+
+    def _prepare_system_prompt(self, state: IdentificationWorkflowState) -> str:
+        goal = state["goal"]
+        important_instructions = "N/A" if not "plan_instructions" in state else state["plan_instructions"]
+        repo_structure = self.repo_structure
+        intermdediate_steps = self._build_intermediate_steps(state)
+        step_analysis, step_thoughts = self._build_intermediate_analysis_and_thoughts(state)
+        self._print_step(
+            state,
+            step_output="**Intermediate Step Output**\n" + intermdediate_steps
+        )
+        self._print_step(
+            state,
+            step_output="**Intermediate Step Analysis**\n{step_analysis}\n**Intermediate Step Thoughts**\n{step_thoughts}",
+        )
+        tool_names, tools_desc = get_tool_names_and_descriptions(self.custom_tools)
+        return IDENTIFICATION_PLAN_SYSTEM_PROMPT.format(
+            goal=goal,
+            repo_structure=repo_structure,
+            tools=tools_desc,
+            intermediate_steps=intermdediate_steps,
+            intermediate_analysis=step_analysis,
+            intermediate_thoughts=step_thoughts,
+            tool_names=tool_names,
+            important_instructions=important_instructions,
+        )
+
+    def _convert_to_plan_actions_text(self, actions: list[dict]) -> str:
+        plan_str = ""
+        for action in actions:
+            action_str = f"Step: {action['name']}\n"
+            action_str += f"Step Input: {action['input']}\n"
+            plan_str += action_str
+        return plan_str
+
+    def _execute_directly(self, state: IdentificationWorkflowState):
+        system_prompt = self._prepare_system_prompt(state)
+        agent = CommonAgentTwoSteps(llm=self.llm)
+        res, _, token_usage, reasoning_process = agent.go(
+            system_prompt=system_prompt,
+            instruction_prompt="Now, let's begin.",
+            schema=IdentificationPlanResultJsonSchema,
+        )
+        PEOCommonStep._reset_step_state(state)
+        res = IdentificationPlanResult(**res)
+        self._print_step(
+            state,
+            step_output="**Reasoning Process**\n" + reasoning_process,
+        )
+        self._print_step(
+            state,
+            step_output=f"**Plan**\n{res.actions}"
+        )
+        state["plan_actions"] = self._convert_to_plan_actions_text(res.actions)
+
+        return state, token_usage
+

bioguider/agents/identification_task.py

@@ -0,0 +1,270 @@
+
+import os
+import json
+import logging
+from enum import Enum
+from typing import Callable
+from pydantic import BaseModel, Field
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from langchain.tools import Tool, StructuredTool
+from langgraph.graph import StateGraph, START, END
+
+from bioguider.utils.constants import PrimaryLanguageEnum, ProjectTypeEnum
+from bioguider.utils.file_utils import get_file_type
+from bioguider.agents.agent_tools import (
+    read_file_tool, 
+    read_directory_tool, 
+    summarize_file_tool,
+)
+from bioguider.agents.agent_utils import (
+    read_directory,
+    try_parse_json_object,
+)
+from bioguider.agents.identification_execute_step import IdentificationExecuteStep
+from bioguider.agents.identification_observe_step import IdentificationObserveStep
+from bioguider.agents.identification_plan_step import IdentificationPlanStep
+from bioguider.agents.identification_task_utils import IdentificationWorkflowState
+from bioguider.agents.peo_common_step import PEOCommonStep
+from bioguider.agents.prompt_utils import (
+    IDENTIFICATION_GOAL_PROJECT_TYPE, 
+    IDENTIFICATION_GOAL_PRIMARY_LANGUAGE,
+    IDENTIFICATION_GOAL_META_DATA,
+)
+from bioguider.agents.python_ast_repl_tool import CustomPythonAstREPLTool
+from bioguider.agents.agent_task import AgentTask
+from bioguider.database.summarized_file_db import SummarizedFilesDb
+
+logger = logging.getLogger(__name__)
+
+META_DATA_FINAL_ANSWER_EXAMPLE = '{{"name": "repo name", ...}}'
+PROJECT_TYPE_FINAL_ANSWER_EXAMPLE = '{{"project_type": "project type"}}'
+PRIMARY_LANGUAGE_FINAL_ANSWER_EXAMPLE = '{{"primary_language": "primary language"}}'
+
+class IdentificationPlanResult(BaseModel):
+    """ Identification Plan Result """
+    actions: list[dict] = Field(description="a list of action dictionary, e.g. [{'name': 'read_file', 'input': 'README.md'}, ...]")
+
+IdentificationPlanResultJsonSchema = {
+    "title": "identification_plan_result",
+    "description": "plan result",
+    "type": "object",
+    "properties": {
+        "actions": {
+            "type": "array",
+            "description": """a list of action dictionary, e.g. [{'name': 'read_file', 'input': 'README.md'}, ...]""",
+            "title": "Actions",
+            "items": {"type": "object"}
+        },
+    },
+    "required": ["actions"],
+}
+
+class IdentificationTask(AgentTask):
+    def __init__(
+        self, 
+        llm: BaseChatOpenAI,
+        step_callback: Callable | None=None,
+        summarized_files_db: SummarizedFilesDb | None = None,
+        provided_files: list[str] | None = None,
+    ):
+        super().__init__(llm=llm, step_callback=step_callback, summarized_files_db=summarized_files_db)
+        self.repo_path: str | None = None
+        self.gitignore_path: str | None = None
+        self.repo_structure: str | None = None
+        self.tools = []
+        self.custom_tools = []
+        self.steps: list[PEOCommonStep] = []
+        self.provided_files = provided_files
+
+    def _prepare_tools(self):
+        tool_rd = read_directory_tool(repo_path=self.repo_path)
+        tool_sum = summarize_file_tool(
+            llm=self.llm,
+            repo_path=self.repo_path,
+            output_callback=self.step_callback,
+            db=self.summarized_files_db,
+        )
+        tool_rf = read_file_tool(repo_path=self.repo_path)
+        
+        self.tools = [tool_rd, tool_sum, tool_rf,]
+        self.custom_tools = [
+            Tool(
+                name = tool_rd.__class__.__name__,
+                func = tool_rd.run,
+                description=tool_rd.__class__.__doc__,
+            ),
+            StructuredTool.from_function(
+                tool_sum.run,
+                description=tool_sum.__class__.__doc__,
+                name=tool_sum.__class__.__name__,
+            ),
+            Tool(
+                name = tool_rf.__class__.__name__,
+                func = tool_rf.run,
+                description=tool_rf.__class__.__doc__,
+            ),
+        ]
+        # self.custom_tools.append(CustomPythonAstREPLTool())
+
+    def _initialize(self):        
+        if not os.path.exists(self.repo_path):
+            raise ValueError(f"Repository path {self.repo_path} does not exist.")
+        files = self.provided_files
+        if files is None:
+            files = read_directory(self.repo_path, os.path.join(self.repo_path, ".gitignore"))
+        file_pairs = [(f, get_file_type(os.path.join(self.repo_path, f)).value) for f in files]
+        self.repo_structure = ""
+        for f, f_type in file_pairs:
+            self.repo_structure += f"{f} - {f_type}\n"
+
+        self._prepare_tools()
+        self.steps = [
+            IdentificationPlanStep(
+                llm=self.llm,
+                repo_path=self.repo_path,
+                repo_structure=self.repo_structure,
+                gitignore_path=self.gitignore_path,
+                custom_tools=self.custom_tools,
+            ),
+            IdentificationExecuteStep(
+                llm=self.llm,
+                repo_path=self.repo_path,
+                repo_structure=self.repo_structure,
+                gitignore_path=self.gitignore_path,
+                custom_tools=self.custom_tools,
+            ),
+            IdentificationObserveStep(
+                llm=self.llm,
+                repo_path=self.repo_path,
+                repo_structure=self.repo_structure,
+                gitignore_path=self.gitignore_path,
+                custom_tools=self.custom_tools,
+            )
+        ]
+        
+    
+    def _compile(
+        self, 
+        repo_path: str,
+        gitignore_path: str,
+        **kwargs,
+    ):
+        self.repo_path = repo_path
+        self.gitignore_path = gitignore_path
+        self._initialize()
+                
+        def check_observation_step(state: IdentificationWorkflowState):
+            if "final_answer" in state and state["final_answer"] is not None:
+                return END
+            return "plan_step"
+        
+        graph = StateGraph(IdentificationWorkflowState)
+        graph.add_node("plan_step", self.steps[0].execute)
+        graph.add_node("execute_step", self.steps[1].execute)
+        graph.add_node("observe_step", self.steps[2].execute)
+        graph.add_edge(START, "plan_step")
+        graph.add_edge("plan_step", "execute_step")
+        graph.add_edge("execute_step", "observe_step")
+        graph.add_conditional_edges("observe_step", check_observation_step, {"plan_step", END})
+
+        self.graph = graph.compile()
+        
+    def identify_project_type(self):
+        s = self._go_graph({
+            "goal": IDENTIFICATION_GOAL_PROJECT_TYPE,
+            "final_answer_example": PROJECT_TYPE_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
+        })
+        proj_type = s["final_answer"] if "final_answer" in s else "unknown type"
+        return self._parse_project_type(proj_type)
+    
+    def identify_primary_language(self):
+        s = self._go_graph({
+            "goal": IDENTIFICATION_GOAL_PRIMARY_LANGUAGE,
+            "final_answer_example": PRIMARY_LANGUAGE_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
+        })
+        language = s["final_answer"] if "final_answer" in s else "unknown type"
+        return self._parse_primary_language(language)
+    
+    def identify_meta_data(self):
+        s = self._go_graph({
+            "goal": IDENTIFICATION_GOAL_META_DATA,
+            "final_answer_example": META_DATA_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
+        })
+        meta_data = s["final_answer"] if "final_answer" in s else "unknown type"
+        return self._parse_meta_data(meta_data)
+        
+    def identify_customize_goal(
+        self,
+        goal: str,
+        final_answer_example: str,
+        plan_instructions: str = "N/A",
+        observe_instructions: str = "N/A",
+    ):
+        s = self._go_graph({
+            "goal": goal,
+            "final_answer_example": final_answer_example,
+            "plan_instructions": plan_instructions,
+            "observe_instructions": observe_instructions,
+            "step_count": 0,
+        })
+        return s["final_answer"] if "final_answer" in s else None
+
+    def _parse_project_type(self, proj_type_obj: str) -> ProjectTypeEnum:
+        proj_type_obj = proj_type_obj.strip()
+        the_obj = try_parse_json_object(proj_type_obj)
+        if not the_obj is None and "project_type" in the_obj:
+            proj_type = the_obj["project_type"]
+        elif proj_type_obj in [
+            ProjectTypeEnum.application.value, 
+            ProjectTypeEnum.package.value, 
+            ProjectTypeEnum.pipeline.value
+        ]:
+            return ProjectTypeEnum(proj_type_obj)
+        else:
+            proj_type = "unknown"
+        if proj_type == "application":
+            return ProjectTypeEnum.application
+        elif proj_type == "package":
+            return ProjectTypeEnum.package
+        elif proj_type == "pipeline":
+            return ProjectTypeEnum.pipeline
+        else:
+            return ProjectTypeEnum.unknown
+        
+    def _parse_primary_language(self, language_obj: str) -> PrimaryLanguageEnum:
+        # try to handle some common errors
+        language_obj  = language_obj.strip()
+        the_obj = try_parse_json_object(language_obj)
+        if not the_obj is None and "primary_language" in the_obj:
+            language = the_obj["primary_language"]
+        elif language_obj in [
+            PrimaryLanguageEnum.python.value, 
+            PrimaryLanguageEnum.R.value, 
+        ]:
+            return PrimaryLanguageEnum(language_obj)  
+        else:
+            language = "unknown"
+
+        language = language.strip()
+        if language == "python":
+            return PrimaryLanguageEnum.python
+        elif language == "R":
+            return PrimaryLanguageEnum.R
+        else:
+            return PrimaryLanguageEnum.unknown
+        
+    def _parse_meta_data(self, meta_data_obj: str) -> dict:
+        meta_data_obj  = meta_data_obj.strip()
+        the_obj = try_parse_json_object(meta_data_obj)
+        
+        return the_obj if the_obj is not None else {
+            "name": "unknown",
+            "description": "unknown",
+            "license": "unknown",
+            "owner": "unknown",
+        }
+        
+