agentUniverse 0.0.16.dev6__tar.gz → 0.0.17.dev1__tar.gz

{agentuniverse-0.0.16.dev6 → agentuniverse-0.0.17.dev1}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: agentUniverse
-Version: 0.0.16.dev6
+Version: 0.0.17.dev1
 Summary: agentUniverse is a framework for developing applications powered by multi-agent base on large language model.
+Home-page: https://github.com/agentuniverse-ai/agentUniverse
 Author: AntGroup
 Author-email: jerry.zzw@antgroup.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
@@ -20,7 +21,7 @@ Requires-Dist: anthropic (>=0.26.0,<0.27.0)
 Requires-Dist: cffi (>=1.15.1,<2.0.0)
 Requires-Dist: chromadb (==0.4.24)
 Requires-Dist: dashscope (>=1.19.1,<2.0.0)
-Requires-Dist: duckduckgo-search (>=6.1.7,<7.0.0)
+Requires-Dist: duckduckgo-search (>=6.3.5,<7.0.0)
 Requires-Dist: flask (>=2.3.2,<3.0.0)
 Requires-Dist: flask_cors (==4.0.0)
 Requires-Dist: googleapis-common-protos (>=1.63.0,<2.0.0)
@@ -42,9 +43,9 @@ 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: pillow (>=10.4.0,<11.0.0)
-Requires-Dist: primp (==0.5.5)
+Requires-Dist: primp (>=0.6.5,<0.7.0)
 Requires-Dist: pyarrow (>=16.1.0,<17.0.0)
-Requires-Dist: pydantic (==2.10.0)
+Requires-Dist: pydantic (>=2.10.0,<3.0.0)
 Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "store-ext"
 Requires-Dist: qianfan (>=0.3.12,<0.4.0)
 Requires-Dist: requests (>=2.32.0,<3.0.0)
@@ -53,6 +54,7 @@ Requires-Dist: sphinx-rtd-theme (>=2.0.0,<3.0.0)
 Requires-Dist: tiktoken (==0.5.2)
 Requires-Dist: tomli (>=2.2,<3.0)
 Requires-Dist: tqdm (>=4.66.3,<5.0.0)
+Requires-Dist: tree-sitter (>=0.24.0,<0.25.0)
 Requires-Dist: werkzeug (>=3.0.3,<4.0.0)
 Requires-Dist: wikipedia (>=1.4.0,<2.0.0)
 Project-URL: Repository, https://github.com/agentuniverse-ai/agentUniverse

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/code_ast_processor.py

@@ -0,0 +1,311 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/03/04 14:09
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: code_ast_processor.py
+import json
+from typing import List, Dict, Any, Optional, cast
+
+from agentuniverse.agent.action.knowledge.doc_processor.types.ast_types import AstNode, AstNodePoint, CodeBoundary
+from agentuniverse.agent.action.knowledge.doc_processor.types.code_types import CodeFeatures, CodeRepresentation, ChunkRepresentation
+from agentuniverse.agent.action.knowledge.doc_processor.types.metrics_types import CodeMetrics
+
+from agentuniverse.agent.action.knowledge.doc_processor.doc_processor import DocProcessor
+from agentuniverse.agent.action.knowledge.store.document import Document
+from agentuniverse.agent.action.knowledge.store.query import Query
+from agentuniverse.base.config.component_configer.component_configer import ComponentConfiger
+
+
+class CodeAstProcessor(DocProcessor):
+
+    max_depth: int = 8
+    language_dir: str = None
+    chunk_size: int = 1000
+    chunk_overlap: int = 200
+    max_node_len: int = 100
+    _parser: Optional[Any] = None
+    _languages: Dict[str, Any] = {}
+
+    def _process_docs(self, origin_docs: List[Document], query: Query = None) -> List[Document]:
+        result_docs = []
+        for doc in origin_docs:
+            code = doc.text
+            language = doc.metadata.get('language', 'unknown') if doc.metadata else 'unknown'
+            metadata = doc.metadata.copy() if doc.metadata else {}
+            metadata['document_type'] = 'code_ast'
+            result_docs.extend(self._process_with_tree_sitter(code, language, metadata))
+        return result_docs
+
+    def _process_with_tree_sitter(self, code: str, language: str,
+                                  metadata: Dict[str, Any]) -> List[Document]:
+        def _ensure_language() -> None:
+            if language not in self._languages:
+                try:
+                    from tree_sitter import Language
+                    from importlib import import_module
+                    module_name = f'tree_sitter_{language}'
+                    lang_module = import_module(module_name)
+                    self._languages[language] = Language(lang_module.language())
+                except ImportError:
+                    raise ImportError(
+                        f"Could not import {module_name}. Install with: pip install {module_name}")
+        _ensure_language()
+
+        result_docs: List[Document] = []
+        self._parser.language = self._languages[language]
+        tree = self._parser.parse(bytes(code, "utf8"))
+        ast_json: AstNode = self._convert_tree_to_json(tree.root_node, code)
+        features: CodeFeatures = self._extract_features(tree.root_node, code, language)
+        repr: CodeRepresentation = {
+            "ast": ast_json,
+            "features": features,
+            "language": language,
+            "code_length": len(code)
+        }
+        metadata['processing_method'] = 'tree_sitter'
+        ast_doc: Document = Document(
+            text=json.dumps(repr),
+            metadata=metadata
+        )
+        result_docs.append(ast_doc)
+        if len(code) > self.chunk_size:
+            chunk_docs = self._generate_code_chunks(
+                code, tree.root_node, language, metadata)
+            result_docs.extend(chunk_docs)
+        return result_docs
+
+    def _convert_tree_to_json(self, node, code: str, depth: int = 0) -> AstNode:
+        if depth > self.max_depth:
+            return cast(AstNode, {"type": "max_depth_reached"})
+        if not node:
+            return cast(AstNode, {})
+
+        start_byte, end_byte = node.start_byte, node.end_byte
+        text = code[start_byte:end_byte] if end_byte <= len(code) else ""
+
+        start_point: AstNodePoint = {"row": node.start_point[0], "column": node.start_point[1]}
+        end_point: AstNodePoint = {"row": node.end_point[0], "column": node.end_point[1]}
+
+        result: AstNode = {
+            "type": node.type,
+            "start_point": start_point,
+            "end_point": end_point,
+            "start_byte": start_byte,
+            "end_byte": end_byte
+        }
+
+        if len(text) < self.max_node_len or node.child_count == 0:
+            result["text"] = text
+
+        if node.child_count > 0:
+            children = []
+            for child in node.children:
+                child_json = self._convert_tree_to_json(child, code, depth + 1)
+                if child_json:
+                    children.append(child_json)
+            result["children"] = children
+
+        return result
+
+    def _extract_features(self, node: Any, code: str, language: str) -> CodeFeatures:
+
+        features: CodeFeatures = {
+            "node_counts": self._count_node_types(node),
+            "code_metrics": self._calculate_code_metrics(code, language),
+            "identifier_count": 0,
+            "function_count": 0,
+            "class_count": 0,
+            "statement_count": 0
+        }
+
+        cursor = node.walk()
+
+        def _visit():
+            nonlocal features
+            current_node = cursor.node
+
+            if current_node.type == "identifier":
+                features["identifier_count"] += 1
+            elif current_node.type in ("function_definition", "method_definition", "function_declaration"):
+                features["function_count"] += 1
+            elif current_node.type in ("class_definition", "class_declaration"):
+                features["class_count"] += 1
+            elif "statement" in current_node.type:
+                features["statement_count"] += 1
+
+            if cursor.goto_first_child():
+                _visit()
+                cursor.goto_parent()
+            if cursor.goto_next_sibling():
+                _visit()
+
+        _visit()
+        return features
+
+    def _count_node_types(self, root_node) -> Dict[str, int]:
+        counts = {}
+
+        def _traverse(node):
+            if node.type not in counts:
+                counts[node.type] = 0
+            counts[node.type] += 1
+
+            for child in node.children:
+                _traverse(child)
+
+        _traverse(root_node)
+        return counts
+
+    def _calculate_code_metrics(self, code: str, language: str) -> CodeMetrics:
+
+        lines = code.splitlines()
+        code_lines = [line.strip() for line in lines if line.strip(
+        ) and not line.strip().startswith(('#', '//', '/*', '*', '*/'))]
+
+        metrics: CodeMetrics = {
+            "line_count": len(lines),
+            "code_line_count": len(code_lines),
+            "avg_line_length": sum(len(line) for line in code_lines) / max(len(code_lines), 1),
+            "max_line_length": max([len(line) for line in code_lines]) if code_lines else 0,
+            "character_count": len(code)
+        }
+        return metrics
+
+    def _generate_code_chunks(
+            self,
+            code: str,
+            root_node,
+            language: str,
+            metadata: Dict[str, Any]) -> List[Document]:
+        chunks = []
+        lines = code.splitlines()
+        boundaries = []
+
+        def _collect_declarations(node, path=""):
+
+            if node.type in ("function_definition", "method_definition", "class_definition",
+                             "function_declaration", "method_declaration", "class_declaration"):
+                start_line = node.start_point[0]
+                end_line = node.end_point[0]
+
+                if end_line - start_line >= 3:
+                    node_type = "function" if "function" in node.type else "class"
+                    name = None
+
+                    for child in node.children:
+                        if child.type == "identifier":
+                            name = code[child.start_byte:child.end_byte]
+                            break
+
+                    boundary: CodeBoundary = {
+                        "start": start_line,
+                        "end": end_line,
+                        "type": node_type,
+                        "name": name,
+                        "node": node
+                    }
+                    boundaries.append(boundary)
+
+        traverse_cursor = root_node.walk()
+
+        def _traverse_nodes():
+            current_node = traverse_cursor.node
+
+            _collect_declarations(current_node)
+
+            if traverse_cursor.goto_first_child():
+                _traverse_nodes()
+                traverse_cursor.goto_parent()
+
+            if traverse_cursor.goto_next_sibling():
+                _traverse_nodes()
+
+        _traverse_nodes()
+
+        if boundaries:
+            for boundary in boundaries:
+                start_line = boundary["start"]
+                end_line = boundary["end"]
+
+                if end_line - start_line < 3:
+                    continue
+
+                chunk_code = "\n".join(lines[start_line:end_line + 1])
+
+                chunk_metadata = metadata.copy()
+                chunk_metadata["chunk_type"] = boundary["type"]
+                chunk_metadata["chunk_name"] = boundary["name"]
+                chunk_metadata["start_line"] = start_line
+                chunk_metadata["end_line"] = end_line
+                chunk_metadata["document_type"] = "code_chunk"
+
+                try:
+                    tree = self._parser.parse(bytes(chunk_code, "utf8"))
+                    ast_json = self._convert_tree_to_json(tree.root_node, chunk_code)
+
+                    representation: ChunkRepresentation = {
+                        "ast": ast_json,
+                        "code": chunk_code,
+                        "language": language,
+                        "name": boundary["name"],
+                        "type": boundary["type"]
+                    }
+
+                    chunk_doc = Document(
+                        text=json.dumps(representation),
+                        metadata=chunk_metadata
+                    )
+                    chunks.append(chunk_doc)
+                except BaseException:
+
+                    chunk_metadata["ast_available"] = False
+                    chunks.append(Document(text=chunk_code, metadata=chunk_metadata))
+
+        if len(chunks) < 2 and len(lines) > self.chunk_size:
+            for i in range(0, len(lines), self.chunk_size - self.chunk_overlap):
+                end_idx = min(i + self.chunk_size, len(lines))
+                chunk_code = "\n".join(lines[i:end_idx])
+
+                chunk_metadata = metadata.copy()
+                chunk_metadata["chunk_type"] = "window"
+                chunk_metadata["start_line"] = i
+                chunk_metadata["end_line"] = end_idx - 1
+                chunk_metadata["document_type"] = "code_chunk"
+
+                chunks.append(Document(text=chunk_code, metadata=chunk_metadata))
+
+                if end_idx >= len(lines):
+                    break
+
+        return chunks
+
+    def _initialize_by_component_configer(
+            self, doc_processor_configer: ComponentConfiger) -> 'DocProcessor':
+        super()._initialize_by_component_configer(doc_processor_configer)
+        try:
+            from tree_sitter import Parser
+            self._parser = Parser()
+            self._languages = {}
+        except ImportError:
+            raise ImportError(
+                "tree-sitter not available. Install with: pip install tree-sitter")
+
+        if hasattr(doc_processor_configer, "max_depth"):
+            self.max_depth = doc_processor_configer.max_depth
+
+        if not hasattr(doc_processor_configer, "language_dir"):
+            raise ValueError(
+                "language_dir is required - tree-sitter needs compiled language libraries (.so files) to parse code, download from https://tree-sitter.github.io/tree-sitter/#available-parsers")
+        self.language_dir = doc_processor_configer.language_dir
+
+        if hasattr(doc_processor_configer, "chunk_size"):
+            self.chunk_size = doc_processor_configer.chunk_size
+
+        if hasattr(doc_processor_configer, "chunk_overlap"):
+            self.chunk_overlap = doc_processor_configer.chunk_overlap
+
+        if hasattr(doc_processor_configer, "max_node_text_length"):
+            self.max_node_len = doc_processor_configer.max_node_len
+        return self

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/code_ast_processor.yaml

@@ -0,0 +1,13 @@
+name: 'code_ast_processor'
+description: 'Tree-sitter based code AST processor for code retrieval and analysis'
+metadata:
+  type: 'DOC_PROCESSOR'
+  module: 'agentuniverse.agent.action.knowledge.doc_processor.code_ast_processor'
+  class: 'CodeAstProcessor'
+config:
+  language_dir: '/path/to/tree-sitter/libraries'  
+  max_depth: 8   
+  max_node_len: 100  
+
+  chunk_size: 1000   
+  chunk_overlap: 200  

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/types/__init__.py

@@ -0,0 +1,11 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/3/4 15:05
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: __init__.py
+
+from agentuniverse.agent.action.knowledge.doc_processor.types.ast_types import *
+from agentuniverse.agent.action.knowledge.doc_processor.types.code_types import *
+from agentuniverse.agent.action.knowledge.doc_processor.types.metrics_types import *

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/types/ast_types.py

@@ -0,0 +1,32 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/3/4 15:05
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: ast_types.py
+
+from typing import List, Any, Optional, TypedDict
+
+
+class AstNodePoint(TypedDict):
+    row: int
+    column: int
+
+
+class AstNode(TypedDict):
+    type: str
+    start_point: AstNodePoint
+    end_point: AstNodePoint
+    start_byte: int
+    end_byte: int
+    text: Optional[str]
+    children: Optional[List['AstNode']]
+
+
+class CodeBoundary(TypedDict):
+    start: int
+    end: int
+    type: str
+    name: Optional[str]
+    node: Any

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/types/code_types.py

@@ -0,0 +1,36 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/3/4 15:06
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: code_types.py
+
+from typing import Dict, Optional, TypedDict
+
+from agentuniverse.agent.action.knowledge.doc_processor.types.ast_types import AstNode
+from agentuniverse.agent.action.knowledge.doc_processor.types.metrics_types import CodeMetrics
+
+
+class CodeFeatures(TypedDict):
+    node_counts: Dict[str, int]
+    code_metrics: CodeMetrics
+    identifier_count: int
+    function_count: int
+    class_count: int
+    statement_count: int
+
+
+class CodeRepresentation(TypedDict):
+    ast: AstNode
+    features: CodeFeatures
+    language: str
+    code_length: int
+
+
+class ChunkRepresentation(TypedDict):
+    ast: AstNode
+    code: str
+    language: str
+    name: Optional[str]
+    type: str

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/doc_processor/types/metrics_types.py

@@ -0,0 +1,17 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/3/4 15:06
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: metrics_types.py
+
+from typing import TypedDict
+
+
+class CodeMetrics(TypedDict):
+    line_count: int
+    code_line_count: int
+    avg_line_length: float
+    max_line_length: int
+    character_count: int

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/reader/cloud_file_reader/feishu_reader.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/4/10 17:40
+# @Author  : zhaoyifei
+# @Email   : 2179709293@qq.com
+# @FileName: feishu_reader.py
+
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from bs4 import BeautifulSoup
+import time
+from typing import Dict,List
+from agentuniverse.agent.action.knowledge.store.document import Document
+
+class PublicFeishuReader:
+    """Feishu public document reader using Selenium
+
+    Extracts content from public Feishu documents through web scraping with dynamic rendering support.
+
+    Attributes:
+        driver: Selenium WebDriver instance configured for headless browsing
+    """
+
+    def __init__(self):
+        """Initialize Selenium WebDriver with headless configuration"""
+        chrome_options = Options()
+        chrome_options.add_argument("--headless")
+        chrome_options.add_argument("--disable-gpu")
+        chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument(
+            "User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        )
+        self.driver = webdriver.Chrome(options=chrome_options)
+
+    def _fetch_document_content(self, url: str) -> str:
+        """Fetch Feishu document content after dynamic rendering
+
+        Args:
+            url (str): URL of the public Feishu document
+
+        Returns:
+            str: Extracted document content or empty string on failure
+
+        Raises:
+            RuntimeError: If page loading fails
+        """
+        try:
+            self.driver.get(url)
+            # Wait for dynamic content loading
+            time.sleep(5)
+            page_source = self.driver.page_source
+            soup = BeautifulSoup(page_source, 'html.parser')
+            return self._parse_content(soup)
+        except Exception as e:
+            print(f"Error fetching document: {e}")
+            return ""
+
+    def _parse_content(self, soup: BeautifulSoup) -> str:
+        """Parse document content and extract meaningful text
+
+        Args:
+            soup (BeautifulSoup): Parsed HTML document object
+
+        Returns:
+            str: Cleaned text content with deduplication
+
+        Raises:
+            ValueError: If document structure is invalid
+        """
+        # Find the body tag
+        body = soup.find('body')
+        if not body:
+            return "Body tag not found"
+
+        content = []
+
+        # Extract document title
+        title_tag = soup.find('h1')
+        if title_tag:
+            title_text = title_tag.get_text(strip=True)
+            if title_text:
+                content.append(f"Title: {title_text}")
+
+        # Define irrelevant class names for filtering
+        irrelevant_classes = ['footer', 'nav', 'navigation', 'header', 'comment', 'help', 'login']
+
+        # Try to locate main content container
+        content_div = soup.find('div', class_='doc-content')  # Update class name as needed
+        if content_div:
+            # Extract text from content container
+            for tag in content_div.find_all(['p', 'div', 'span'], recursive=True):
+                if tag.get('class') and any(cls.lower() in irrelevant_classes for cls in tag.get('class')):
+                    continue
+                text = tag.get_text(strip=True)
+                if text and text.strip() and not any(
+                        keyword in text.lower() for keyword in ['login', 'sign up', 'comment', 'help']):
+                    content.append(text)
+        else:
+            # Fallback extraction from body
+            for div in body.find_all('div', recursive=True):
+                if div.get('class') and any(cls.lower() in irrelevant_classes for cls in div.get('class')):
+                    continue
+                text = div.get_text(strip=True)
+                if text and text.strip() and not any(
+                        keyword in text.lower() for keyword in ['login', 'sign up', 'comment', 'help']):
+                    content.append(text)
+
+        # Deduplicate while preserving order
+        unique_content = list(dict.fromkeys(content))
+        return "\n".join(unique_content) if unique_content else "No meaningful content found"
+
+    def load_data(self, url: str) -> List[Document]:
+        """Load and process Feishu document data
+
+        Args:
+            url (str): URL of the target document
+
+        Returns:
+            List[Document]: List of documents containing feishu online file content
+        """
+        content = self._fetch_document_content(url)
+        # If the content is empty, return an empty list
+        if not content:
+            return []
+        # Construct metadata
+        metadata = {"source": url}
+        # Create a Document object
+        document = Document(text=content, metadata=metadata)
+        # Return a list containing a single Document
+        return [document]
+
+    def __del__(self):
+        """Cleanup resources by closing browser instance"""
+        if hasattr(self, 'driver'):
+            self.driver.quit()
+
+"""
+if __name__ == "__main__":
+    # Example usage
+    test_url = "https://www.feishu.cn/docx/SV2JdR5P4odO8AxIhpBcVo1Xncg"
+    reader = PublicFeishuReader()
+    data = reader.load_data(test_url)
+    print(data)
+    print("Document Summary:", data[0].text)
+"""

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/reader/cloud_file_reader/feishu_reader.yaml

@@ -0,0 +1,6 @@
+name: 'default_feishu_reader'
+description: 'default feishu cloud document reader'
+metadata:
+  type: 'READER'
+  module: 'agentuniverse.agent.action.knowledge.reader.cloud_document.feishu_reader'
+  class: 'PublicFeishuReader'

agentuniverse-0.0.17.dev1/agentuniverse/agent/action/knowledge/reader/file/code_reader.py

@@ -0,0 +1,66 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2025/03/04 13:19
+# @Author  : hiro
+# @Email   : hiromesh@qq.com
+# @FileName: code_reader.py
+import os
+from pathlib import Path
+from typing import List, Union, Optional, Dict
+
+from agentuniverse.agent.action.knowledge.reader.reader import Reader
+from agentuniverse.agent.action.knowledge.store.document import Document
+
+
+CODE_FILE_EXTENSIONS = {
+    '.py': 'python',
+    '.js': 'javascript',
+    '.ts': 'typescript',
+    '.java': 'java',
+    '.cpp': 'cpp',
+    '.c': 'c',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.cs': 'csharp',
+    '.go': 'go',
+    '.rb': 'ruby',
+    '.php': 'php',
+    '.swift': 'swift',
+    '.kt': 'kotlin',
+    '.rs': 'rust',
+    '.sh': 'shell',
+    '.html': 'html',
+    '.css': 'css',
+    '.sql': 'sql',
+    '.json': 'json',
+    '.xml': 'xml',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.md': 'markdown',
+}
+
+
+class CodeReader(Reader):
+
+    def _load_data(self,
+                   file: Union[str, Path],
+                   ext_info: Optional[Dict] = None) -> List[Document]:
+        if isinstance(file, str):
+            file = Path(file)
+        if isinstance(file, Path):
+            if not file.exists():
+                raise FileNotFoundError(f"Code file not found: {file}")
+        file_content = file.read_text(encoding="utf-8")
+        file_name = file.name
+        file_suffix = file.suffix.lower()
+        language = CODE_FILE_EXTENSIONS.get(file_suffix, 'unknown')
+        metadata = {
+            "file_name": file_name,
+            "file_path": str(file),
+            "language": language,
+            "file_suffix": file_suffix,
+        }
+        if ext_info:
+            metadata.update(ext_info)
+        return [Document(text=file_content, metadata=metadata)]