alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/tools/ado/repos/__init__.py

@@ -6,23 +6,25 @@ from pydantic import BaseModel, Field, create_model
 import requests
 
 from ...elitea_base import filter_missconfigured_index_tools
-from ....configurations.ado import AdoReposConfiguration
+from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from .repos_wrapper import ReposApiWrapper
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import check_connection_response
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "ado_repos"
 
 
-def _get_toolkit(tool) -> BaseToolkit:
+def get_toolkit(tool) -> BaseToolkit:
     return AzureDevOpsReposToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        ado_repos_configuration=tool['settings']['ado_repos_configuration'],
+        ado_configuration=tool['settings']['ado_configuration'],
+        repository_id=tool['settings']['repository_id'],
         limit=tool['settings'].get('limit', 5),
-        base_branch=tool['settings'].get('base_branch', ""),
-        active_branch=tool['settings'].get('active_branch', ""),
-        toolkit_name=tool['settings'].get('toolkit_name', ""),
+        base_branch=tool['settings'].get('base_branch', "main"),
+        active_branch=tool['settings'].get('active_branch', "main"),
+        toolkit_name=tool.get('toolkit_name', ''),
         pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         embedding_model=tool['settings'].get('embedding_model'),
         collection_name=tool['toolkit_name'],
@@ -30,26 +32,22 @@ def _get_toolkit(tool) -> BaseToolkit:
         llm=tool['settings'].get('llm', None),
     )
 
-def get_toolkit():
-    return AzureDevOpsReposToolkit.toolkit_config_schema()
-
 def get_tools(tool):
-    return _get_toolkit(tool).get_tools()
+    return get_toolkit(tool).get_tools()
 
 class AzureDevOpsReposToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in ReposApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            ado_repos_configuration=(AdoReposConfiguration, Field(description="Ado Repos configuration", default=None,
-                                                                       json_schema_extra={'configuration_types': ['ado_repos']})),
-            base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
-            active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),
+            ado_configuration=(AdoConfiguration, Field(description="ADO configuration", default=None,
+                                                       json_schema_extra={'configuration_types': ['ado']})),
+            repository_id=(str, Field(description="ADO repository ID or name")),
+            base_branch=(Optional[str], Field(default="main", title="Base branch", description="ADO base branch (e.g., main)")),
+            active_branch=(Optional[str], Field(default="main", title="Active branch", description="ADO active branch (e.g., main)")),
 
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
@@ -57,20 +55,38 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__={'json_schema_extra': {'metadata':
-                {
-                    "label": "ADO repos",
-                    "icon_url": "ado-repos-icon.svg",
-                    "categories": ["code repositories"],
-                    "extra_categories": ["code", "repository", "version control"],
-                }}}
+            __config__={
+                'json_schema_extra': {
+                    'metadata': {
+                        "label": "ADO repos",
+                        "icon_url": "ado-repos-icon.svg",
+                        "categories": ["code repositories"],
+                        "extra_categories": ["code", "repository", "version control"],
+                        "sections": {
+                            "auth": {
+                                "required": True,
+                                "subsections": [
+                                    {
+                                        "name": "Token",
+                                        "fields": ["token"]
+                                    }
+                                ]
+                            }
+                        },
+                        "configuration_group": {
+                            "name": "ado",
+                        }
+                    }
+                }
+            }
         )
 
         @check_connection_response
         def check_connection(self):
+            ado_config = self.ado_configuration
             response = requests.get(
-                f'{self.organization_url}/{self.project}/_apis/git/repositories/{self.repository_id}?api-version=7.0',
-                headers = {'Authorization': f'Bearer {self.token}'},
+                f'{ado_config.organization_url}/{ado_config.project}/_apis/git/repositories/{self.repository_id}?api-version=7.0',
+                headers = {'Authorization': f'Bearer {ado_config.token.get_secret_value() if ado_config.token else ""}'},
                 timeout=5
             )
             return response
@@ -90,25 +106,28 @@ class AzureDevOpsReposToolkit(BaseToolkit):
 
         wrapper_payload = {
             **kwargs,
-            # TODO use ado_repos_configuration fields
-            **kwargs['ado_repos_configuration'],
-            **kwargs['ado_repos_configuration']['ado_configuration'],
+            # Extract ADO configuration fields
+            **kwargs['ado_configuration'],
             **(kwargs.get('pgvector_configuration') or {}),
         }
         azure_devops_repos_wrapper = ReposApiWrapper(**wrapper_payload)
         available_tools = azure_devops_repos_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(
                 BaseAction(
                     api_wrapper=azure_devops_repos_wrapper,
-                    name=prefix + tool["name"],
-                    description=tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}",
+                    name=tool["name"],
+                    description=description,
                     args_schema=tool["args_schema"],
+                    metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
                 )
             )
         return cls(tools=tools)

alita_sdk/tools/ado/repos/repos_wrapper.py

@@ -23,9 +23,11 @@ from langchain_core.tools import ToolException
 from msrest.authentication import BasicAuthentication
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
-from ..utils import extract_old_new_pairs, generate_diff, get_content_from_generator
+from ...elitea_base import BaseCodeToolApiWrapper
+from ..utils import generate_diff, get_content_from_generator
 from ...code_indexer_toolkit import CodeIndexerToolkit
 from ...utils.available_tools_decorator import extend_with_parent_available_tools
+from ...utils.tool_prompts import EDIT_FILE_DESCRIPTION, UPDATE_FILE_PROMPT_NO_PATH
 
 logger = logging.getLogger(__name__)
 
@@ -111,8 +113,7 @@ class ArgsSchema(Enum):
             Field(
                 description=(
                     "Branch to be used for read file operation."
-                ),
-                default=None
+                )
             ),
         )
     )
@@ -130,9 +131,18 @@ class ArgsSchema(Enum):
     )
     UpdateFile = create_model(
         "UpdateFile",
-        branch_name=(str, Field(description="The name of the branch, e.g. `my_branch`.")),
-        file_path=(str, Field(description="Path of a file to be updated.")),
-        update_query=(str, Field(description="Update query used to adjust target file.")),
+        branch_name=(
+            str,
+            Field(description="The name of the branch, e.g. `my_branch`.")
+        ),
+        file_path=(
+            str,
+            Field(description="Path of a file to be updated."),
+        ),
+        update_query=(
+            str,
+            Field(description=UPDATE_FILE_PROMPT_NO_PATH),
+        ),
     )
     DeleteFile = create_model(
         "DeleteFile",
@@ -244,14 +254,24 @@ class ArgsSchema(Enum):
 
 
 class ReposApiWrapper(CodeIndexerToolkit):
-    # TODO use ado_repos_configuration fields
-    organization_url: Optional[str]
-    project: Optional[str]
-    repository_id: Optional[str]
-    base_branch: Optional[str]
-    active_branch: Optional[str]
-    token: Optional[SecretStr]
-    _client: Optional[GitClient] = PrivateAttr()
+    # ADO Configuration fields (from AdoConfiguration)
+    organization_url: Optional[str] = None
+    project: Optional[str] = None
+    token: Optional[SecretStr] = None
+
+    # Repository-specific fields (toolkit level)
+    repository_id: Optional[str] = None
+    base_branch: Optional[str] = None
+    active_branch: Optional[str] = None
+
+    # Alita instance
+    alita: Optional[Any] = None
+
+    # Client instance - marked as exclude=True
+    ado_client_instance: Optional[GitClient] = Field(default=None, exclude=True)
+
+    # Reuse common file helpers from BaseCodeToolApiWrapper
+    edit_file = BaseCodeToolApiWrapper.edit_file
 
     class Config:
         arbitrary_types_allowed = True
@@ -259,43 +279,71 @@ class ReposApiWrapper(CodeIndexerToolkit):
     @model_validator(mode="before")
     @classmethod
     def validate_toolkit(cls, values):
-        project = values["project"]
-        organization_url = values["organization_url"]
-        repository_id = values["repository_id"]
-        base_branch = values["base_branch"]
-        active_branch = values["active_branch"]
-        credentials = BasicAuthentication("", values["token"])
+        from langchain.utils import get_from_dict_or_env
+
+        # Get ADO configuration values
+        organization_url = get_from_dict_or_env(values, ["organization_url"], "ADO_ORGANIZATION_URL", default=None)
+        project = get_from_dict_or_env(values, ["project"], "ADO_PROJECT", default=None)
+        token = get_from_dict_or_env(values, ["token"], "ADO_TOKEN", default=None)
+
+        # Get repository-specific values
+        repository_id = get_from_dict_or_env(values, ["repository_id"], "ADO_REPOSITORY_ID", default=None)
+        base_branch = get_from_dict_or_env(values, ["base_branch"], "ADO_BASE_BRANCH", default="main")
+        active_branch = get_from_dict_or_env(values, ["active_branch"], "ADO_ACTIVE_BRANCH", default="main")
 
         if not organization_url or not project or not repository_id:
             raise ToolException(
                 "Parameters: organization_url, project, and repository_id are required."
             )
 
+        credentials = BasicAuthentication("", token)
+
         try:
-            cls._client = GitClient(base_url=organization_url, creds=credentials)
-            # workaround to check if user is authorized to access ADO Git
-            cls._client.get_repository(repository_id, project=project)
+            # Initialize ADO Git client
+            ado_client = GitClient(base_url=organization_url, creds=credentials)
+            # Verify access to repository
+            ado_client.get_repository(repository_id, project=project)
+
+            # Store client instance
+            values["ado_client_instance"] = ado_client
+
+            def branch_exists(branch_name):
+                try:
+                    branch = ado_client.get_branch(
+                        repository_id=repository_id, name=branch_name, project=project
+                    )
+                    return branch is not None
+                except Exception:
+                    return False
+
+            if base_branch:
+                if not branch_exists(base_branch):
+                    raise ToolException(f"The base branch '{base_branch}' does not exist.")
+            if active_branch:
+                if not branch_exists(active_branch):
+                    raise ToolException(f"The active branch '{active_branch}' does not exist.")
+
         except Exception as e:
+            if isinstance(e, ToolException):
+                raise
             raise ToolException(f"Failed to connect to Azure DevOps: {e}")
 
-        def branch_exists(branch_name):
-            try:
-                branch = cls._client.get_branch(
-                    repository_id=repository_id, name=branch_name, project=project
-                )
-                return branch is not None
-            except Exception:
-                return False
-
-        if base_branch:
-            if not branch_exists(base_branch):
-                raise ToolException(f"The base branch '{base_branch}' does not exist.")
-        if active_branch:
-            if not branch_exists(active_branch):
-                raise ToolException(f"The active branch '{active_branch}' does not exist.")
+        # Update values with configuration
+        values["organization_url"] = organization_url
+        values["project"] = project
+        values["token"] = token
+        values["repository_id"] = repository_id
+        values["base_branch"] = base_branch
+        values["active_branch"] = active_branch
 
         return super().validate_toolkit(values)
 
+    # Expose ADO Git client via property
+    @property
+    def _client(self) -> GitClient:
+        """Access to ADO Git client methods"""
+        return self.ado_client_instance
+
     def _get_commits(self, file_path: str, branch: str, top: int = None) -> List[GitCommitRef]:
         """
         Get commits for a specific file in a specific branch.
@@ -645,8 +693,18 @@ class ReposApiWrapper(CodeIndexerToolkit):
 
         return dumps(data)
 
-    def download_file(self, path):
-        return b"".join(self._client.get_item_content(self.repository_id, path=path, project=self.project, download=True))
+    def download_file(self, path: str, branch: str = None):
+        branch = branch or self.active_branch or self.base_branch
+        version_descriptor = GitVersionDescriptor(
+            version=branch, version_type="branch"
+        )
+        return b"".join(self._client.get_item_content(
+            self.repository_id,
+            path=path,
+            project=self.project,
+            download=True,
+            version_descriptor=version_descriptor
+        ))
 
     def get_file_content(self, commit_id, path):
         version_descriptor = GitVersionDescriptor(
@@ -836,22 +894,50 @@ class ReposApiWrapper(CodeIndexerToolkit):
             logger.error(msg)
             return ToolException(msg)
 
-    def update_file(self, branch_name: str, file_path: str, update_query: str) -> str:
+    def _write_file(self, file_path: str, content: str, branch: str = None, commit_message: str = None) -> str:
+        """Write content to a file in Azure DevOps by creating an edit commit.
+
+        This implementation follows the previous `update_file` behavior: it always
+        performs an 'edit' change (does not create the file), gets the latest
+        commit id for the branch and pushes a new commit containing the change.
         """
-        Updates a file with new content in Azure DevOps.
+        try:
+            # Get the latest commit ID of the target branch
+            branch_obj = self._client.get_branch(
+                repository_id=self.repository_id,
+                project=self.project,
+                name=branch,
+            )
+            if branch_obj is None or not hasattr(branch_obj, 'commit') or not hasattr(branch_obj.commit, 'commit_id'):
+                raise ToolException(f"Branch `{branch}` does not exist or has no commits.")
+
+            latest_commit_id = branch_obj.commit.commit_id
+
+            # Build edit change and push
+            change = GitChange("edit", file_path, content).to_dict()
+
+            ref_update = GitRefUpdate(name=f"refs/heads/{branch}", old_object_id=latest_commit_id)
+            new_commit = GitCommit(comment=commit_message or ("Update " + file_path), changes=[change])
+            push = GitPush(commits=[new_commit], ref_updates=[ref_update])
+
+            self._client.create_push(push=push, repository_id=self.repository_id, project=self.project)
+            return f"Updated file {file_path}"
+        except ToolException:
+            # Re-raise known tool exceptions
+            raise
+        except Exception as e:
+            logger.error(f"Unable to write file {file_path}: {e}")
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
+
+    def update_file(self, branch_name: str, file_path: str, update_query: str) -> str:
+        """Updates a file with new content in Azure DevOps using OLD/NEW markers.
+
         Parameters:
             branch_name (str): The name of the branch where update the file.
             file_path (str): Path to the file for update.
-            update_query(str): Contains the file contents requried to be updated.
-                The old file contents is wrapped in OLD <<<< and >>>> OLD
-                The new file contents is wrapped in NEW <<<< and >>>> NEW
-                For example:
-                OLD <<<<
-                Hello Earth!
-                >>>> OLD
-                NEW <<<<
-                Hello Mars!
-                >>>> NEW
+            update_query(str): Contains the file contents required to be updated,
+                wrapped in Git-style OLD/NEW blocks.
+
         Returns:
             A success or failure message
         """
@@ -864,43 +950,16 @@ class ReposApiWrapper(CodeIndexerToolkit):
                 "Please create a new branch and try again."
             )
         try:
-            file_content = self._read_file(file_path, branch_name)
-
-            if isinstance(file_content, ToolException):
-                return file_content
-
-            updated_file_content = file_content
-            for old, new in extract_old_new_pairs(update_query):
-                if not old.strip():
-                    continue
-                updated_file_content = updated_file_content.replace(old, new)
-
-            if file_content == updated_file_content:
-                return (
-                    "File content was not updated because old content was not found or empty. "
-                    "It may be helpful to use the read_file action to get "
-                    "the current file contents."
-                )
-
-            # Get the latest commit ID of the active branch to use as oldObjectId
-            branch = self._client.get_branch(
-                repository_id=self.repository_id,
-                project=self.project,
-                name=self.active_branch,
-            )
-            latest_commit_id = branch.commit.commit_id
-
-            change = GitChange("edit", file_path, updated_file_content).to_dict()
-
-            ref_update = GitRefUpdate(
-                name=f"refs/heads/{self.active_branch}", old_object_id=latest_commit_id
-            )
-            new_commit = GitCommit(comment=f"Update {file_path}", changes=[change])
-            push = GitPush(commits=[new_commit], ref_updates=[ref_update])
-            self._client.create_push(
-                push=push, repository_id=self.repository_id, project=self.project
+            # Let edit_file handle parsing and content updates; this will call _read_file and _write_file.
+            # For ADO, branch_name is used as branch; commit message is derived from file_path.
+            return self.edit_file(
+                file_path=file_path,
+                file_query=update_query,
+                branch=self.active_branch,
+                commit_message=f"Update {file_path}",
             )
-            return "Updated file " + file_path
+        except ToolException as e:
+            return str(e)
         except Exception as e:
             msg = f"Unable to update file due to error:\n{str(e)}"
             logger.error(msg)
@@ -1236,7 +1295,7 @@ class ReposApiWrapper(CodeIndexerToolkit):
             {
                 "ref": self.update_file,
                 "name": "update_file",
-                "description": self.update_file.__doc__,
+                "description": EDIT_FILE_DESCRIPTION,
                 "args_schema": ArgsSchema.UpdateFile.value,
             },
             {

alita_sdk/tools/ado/test_plan/__init__.py

@@ -10,26 +10,38 @@ from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 
 name = "azure_devops_plans"
 name_alias = "ado_plans"
 
+def get_toolkit(tool):
+    return AzureDevOpsPlansToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        ado_configuration=tool['settings']['ado_configuration'],
+        limit=tool['settings'].get('limit', 5),
+        toolkit_name=tool.get('toolkit_name', ''),
+        alita=tool['settings'].get('alita', None),
+        llm=tool['settings'].get('llm', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        collection_name=tool['toolkit_name'],
+        doctype='doc',
+        embedding_model=tool['settings'].get('embedding_model'),
+        vectorstore_type="PGVector"
+    )
 
 class AzureDevOpsPlansToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestPlanApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsPlansToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name_alias,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
             ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
-            limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
+            limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5, gt=0)),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
                                                                            description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
@@ -97,17 +109,21 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         azure_devops_api_wrapper = TestPlanApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
             print(tool)
+            description = tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_devops_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + f"\nADO instance: {azure_devops_api_wrapper.organization_url}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/ado/test_plan/test_plan_wrapper.py

@@ -180,7 +180,29 @@ class TestPlanApiWrapper(NonCodeIndexerToolkit):
             connection = Connection(base_url=values['organization_url'], creds=credentials)
             cls._client = connection.clients.get_test_plan_client()
         except Exception as e:
-            raise ImportError(f"Failed to connect to Azure DevOps: {e}")
+            error_msg = str(e).lower()
+            if "expired" in error_msg or "token" in error_msg and ("invalid" in error_msg or "unauthorized" in error_msg):
+                raise ValueError(
+                    "Azure DevOps connection failed: Your access token has expired or is invalid. "
+                    "Please refresh your token in the toolkit configuration."
+                )
+            elif "401" in error_msg or "unauthorized" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Authentication failed. "
+                    "Please check your credentials in the toolkit configuration."
+                )
+            elif "404" in error_msg or "not found" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Organization or project not found. "
+                    "Please verify your organization URL and project name."
+                )
+            elif "timeout" in error_msg or "timed out" in error_msg:
+                raise ValueError(
+                    "Azure DevOps connection failed: Connection timed out. "
+                    "Please check your network connection and try again."
+                )
+            else:
+                raise ValueError(f"Azure DevOps connection failed: {e}")
         return super().validate_toolkit(values)
 
     def create_test_plan(self, test_plan_create_params: str):

alita_sdk/tools/ado/utils.py

@@ -1,24 +1,6 @@
-import re
 import difflib
 
 
-def extract_old_new_pairs(file_query: str):
-    """
-    Extracts old and new content pairs from a file query.
-    Parameters:
-        file_query (str): The file query containing old and new content.
-    Returns:
-        list of tuples: A list where each tuple contains (old_content, new_content).
-    """
-    old_pattern = re.compile(r"OLD <<<<\s*(.*?)\s*>>>> OLD", re.DOTALL)
-    new_pattern = re.compile(r"NEW <<<<\s*(.*?)\s*>>>> NEW", re.DOTALL)
-
-    old_contents = old_pattern.findall(file_query)
-    new_contents = new_pattern.findall(file_query)
-
-    return list(zip(old_contents, new_contents))
-
-
 def generate_diff(base_text, target_text, file_path):
     base_lines = base_text.splitlines(keepends=True)
     target_lines = target_text.splitlines(keepends=True)
@@ -28,6 +10,7 @@ def generate_diff(base_text, target_text, file_path):
 
     return "".join(diff)
 
+
 def get_content_from_generator(content_generator):
     def safe_decode(chunk):
         try: