local-operator 0.0.1__py3-none-any.whl

local_operator/__init__.py

@@ -0,0 +1 @@
+# This is the initialization file for the local_operator package.

local_operator/cli.py

@@ -0,0 +1,176 @@
+import os
+import re
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from pydantic import SecretStr
+
+
+class LocalCodeExecutor:
+    """A class to handle local Python code execution with safety checks and context management.
+
+    Attributes:
+        context (dict): A dictionary to maintain execution context between code blocks
+        conversation_history (list): A list of message dictionaries tracking the conversation
+        model: The language model used for code analysis and safety checks
+    """
+
+    def __init__(self, model):
+        """Initialize the LocalCodeExecutor with a language model.
+
+        Args:
+            model: The language model instance to use for code analysis
+        """
+        self.context = {}
+        self.conversation_history = []
+        self.model = model
+
+    def extract_code_blocks(self, text):
+        """Extract Python code blocks from text using markdown-style syntax.
+
+        Args:
+            text (str): The text containing potential code blocks
+
+        Returns:
+            list: A list of extracted code blocks as strings
+        """
+        pattern = r"```python\n(.*?)```"
+        matches = re.findall(pattern, text, re.DOTALL)
+        return matches
+
+    async def check_code_safety(self, code):
+        """Analyze code for potentially dangerous operations using the language model.
+
+        Args:
+            code (str): The Python code to analyze
+
+        Returns:
+            bool: True if dangerous operations are detected, False otherwise
+        """
+        safety_check_prompt = f"""
+        Analyze the following Python code for potentially dangerous operations:
+        {code}
+
+        Respond with only "yes" if the code contains dangerous operations that could:
+        - Delete or modify files
+        - Execute system commands
+        - Access sensitive system resources
+        - Perform network operations
+        - Otherwise compromise system security
+
+        Respond with only "no" if the code appears safe to execute.
+        """
+
+        self.conversation_history.append({"role": "user", "content": safety_check_prompt})
+        response = self.model.invoke(self.conversation_history)
+        self.conversation_history.pop()
+
+        return response.content.strip().lower() == "yes"
+
+    async def execute_code(self, code):
+        """Execute Python code with safety checks and context management.
+
+        Args:
+            code (str): The Python code to execute
+
+        Returns:
+            str: Execution result message or error message
+        """
+        try:
+            is_dangerous = await self.check_code_safety(code)
+            if is_dangerous:
+                confirm = input(
+                    "Warning: Potentially dangerous operation detected. Proceed? (y/n): "
+                )
+                if confirm.lower() != "y":
+                    return "Code execution canceled by user"
+
+            exec(code, self.context)
+            return "Code executed successfully"
+        except Exception as e:
+            return f"Error executing code: {str(e)}"
+
+    async def process_response(self, response):
+        """Process model response, extracting and executing any code blocks.
+
+        Args:
+            response (str): The model's response containing potential code blocks
+        """
+        print("\nModel Response:")
+        print(response)
+
+        self.conversation_history.append({"role": "assistant", "content": response})
+
+        code_blocks = self.extract_code_blocks(response)
+        if code_blocks:
+            print("\nExecuting code blocks...")
+            for code in code_blocks:
+                print(f"\nExecuting:\n{code}")
+                result = await self.execute_code(code)
+                print(f"Result: {result}")
+
+                self.conversation_history.append(
+                    {"role": "system", "content": f"Code execution result:\n{result}"}
+                )
+                self.context["last_code_result"] = result
+
+
+class DeepSeekCLI:
+    """A command-line interface for interacting with DeepSeek's language model.
+
+    Attributes:
+        model: The configured ChatOpenAI instance for DeepSeek
+        executor: LocalCodeExecutor instance for handling code execution
+    """
+
+    def __init__(self):
+        """Initialize the CLI by loading environment variables and setting up the model."""
+        load_dotenv()
+        api_key = os.getenv("DEEPSEEK_API_KEY")
+        if not api_key:
+            raise ValueError("DEEPSEEK_API_KEY not found in .env")
+
+        self.model = ChatOpenAI(
+            api_key=SecretStr(api_key),
+            temperature=0.5,
+            base_url="https://api.deepseek.com/v1",
+            model="deepseek-chat",
+        )
+        self.executor = LocalCodeExecutor(self.model)
+
+    async def chat(self):
+        """Run the interactive chat interface with code execution capabilities."""
+        print("Local Executor Agent CLI")
+        print(
+            "You are interacting with a helpful CLI agent that can execute tasks locally "
+            "on your device by running Python code."
+        )
+        print(
+            "The agent will carefully analyze and execute code blocks, explaining any "
+            "errors that occur."
+        )
+        print(
+            "It will prompt you for confirmation before executing potentially dangerous "
+            "or risky operations."
+        )
+        print("Type 'exit' or 'quit' to quit\n")
+
+        self.executor.conversation_history = [
+            {
+                "role": "system",
+                "content": "You are a Python code execution assistant. You strictly run "
+                "Python code locally. You are able to run code on the local machine. "
+                "Your functions: 1) Analyze and execute code blocks when requested 2) "
+                "Validate code safety first 3) Explain code behavior and results 4) "
+                "Never execute harmful code 5) Maintain secure execution. You only "
+                "execute Python code.",
+            }
+        ]
+
+        while True:
+            user_input = input("\033[1m\033[94mYou:\033[0m \033[1m>\033[0m ")
+            if user_input.lower() == "exit" or user_input.lower() == "quit":
+                break
+
+            self.executor.conversation_history.append({"role": "user", "content": user_input})
+            response = self.model.invoke(self.executor.conversation_history)
+            await self.executor.process_response(response.content)

local_operator/main.py

@@ -0,0 +1,30 @@
+"""
+Main entry point for the Local Operator CLI application.
+
+This script initializes and runs the DeepSeekCLI interface, which provides:
+- Interactive chat with AI assistant
+- Safe execution of Python code blocks
+- Context-aware conversation history
+- Built-in safety checks for code execution
+
+The application uses asyncio for asynchronous operation and includes
+error handling for graceful failure.
+
+Example Usage:
+    python main.py
+"""
+
+from local_operator.cli import DeepSeekCLI
+import asyncio
+
+if __name__ == "__main__":
+    try:
+        # Initialize the CLI interface
+        cli = DeepSeekCLI()
+
+        # Start the async chat interface
+        asyncio.run(cli.chat())
+    except Exception as e:
+        # Handle any unexpected errors gracefully
+        print(f"Error: {str(e)}")
+        print("Please check your .env configuration and internet connection.")

local_operator-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Damian Tran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

local_operator-0.0.1.dist-info/METADATA

@@ -0,0 +1,409 @@
+Metadata-Version: 2.2
+Name: local-operator
+Version: 0.0.1
+Summary: A Python-based agent for local command execution
+Author-email: Damian Tran <damianvtran@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Damian Tran
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/damianvtran/local-operator
+Keywords: local,agent,execution,operator
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-openai
+Requires-Dist: python-dotenv
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Dynamic: requires-python
+
+# Local Operator
+
+Local Operator is a Python-based agent that runs locally on your device, enabling secure execution of commands through a conversational chat interface. It provides a safe environment for running Python code while maintaining system security through built-in safety checks and user confirmation prompts.
+
+This repository is open source and free to use, with an MIT license.  Feel free to incorporate it into your own projects as needed.  Though, we would love to hear your feedback and any contributions to the project will greatly help the community!
+
+Artificial intelligence tools like these should be open and freely available to the majority of people due to the exponential impact that they have on personal productivity.  We hope to make this a reality for everyone!
+
+## Key Features
+
+- **Interactive CLI Interface**: Chat with an AI assistant that can execute Python code locally
+- **Code Safety Verification**: Built-in safety checks analyze code for potentially dangerous operations
+- **Contextual Execution**: Maintains execution context between code blocks
+- **Conversation History**: Tracks the full interaction history for context-aware responses
+- **DeepSeek Integration**: Uses DeepSeek's AI models through LangChain's ChatOpenAI implementation
+- **Asynchronous Execution**: Safe code execution with async/await pattern
+- **Environment Configuration**: Uses .env file for API key management
+
+The Local Operator provides a command-line interface where you can:
+1. Interact with the AI assistant in natural language
+2. Execute Python code blocks marked with ```python``` syntax
+3. Get safety warnings before executing potentially dangerous operations
+4. View execution results and error messages
+5. Maintain context between code executions
+
+## Setup
+
+Clone the `.env.template` file and rename it to `.env`.  Add your DeepSeek API key to the `.env` file.
+
+It's recommended to use a virtual environment to manage dependencies, but not necessary.
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+Install the required packages either in the virtual environment or globally:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+Run the script from the root of the project directory with `python main.py`
+
+Everything else is handled by the agent 😊
+
+Quit by typing `exit` or `quit`.
+
+## Examples
+
+### Hello World
+
+> **You: >** make a new file called test.txt and write Hello World in it
+>
+> Model Response:
+> I'll create a new file called `test.txt` and write "Hello World" in it. Here's the code I'll execute:
+>
+> ```python
+> # Create a new file called test.txt and write "Hello World" in it
+> with open("test.txt", "w") as file:
+>     file.write("Hello World")
+> ```
+>
+> Let me run this code for you.
+>
+> ---
+>
+> The code has been executed successfully. A file named `test.txt` has been created, and it contains the text "Hello World". You can check the file in your current working directory.
+>
+> Executing code blocks...
+>
+> Executing:
+> ```python
+> # Create a new file called test.txt and write "Hello World" in it
+> with open("test.txt", "w") as file:
+>     file.write("Hello World")
+> ```
+>
+> Result: Code executed successfully
+
+### Creating a new git repository
+
+> **You: >** make a git repo in the folder ~/local-operator for a project called "local-operator"
+> 
+> Model Response:
+> To create a Git repository in the folder `~/local-operator` for a project called "local-operator", you can follow these steps:
+> 
+> 1. Create the directory if it doesn't exist.
+> 2. Initialize a Git repository in that directory.
+>
+> Here is the Python code to achieve this:
+>
+> ```python
+> import os
+> import subprocess
+>
+> # Define the directory path
+> repo_path = os.path.expanduser("~/local-operator")
+>
+> # Create the directory if it doesn't exist
+> if not os.path.exists(repo_path):
+>     os.makedirs(repo_path)
+>     print(f"Directory '{repo_path}' created.")
+> else:
+>     print(f"Directory '{repo_path}' already exists.")
+>
+> # Initialize the Git repository
+> try:
+>     subprocess.run(["git", "init"], cwd=repo_path, check=True)
+>     print(f"Git repository initialized in '{repo_path}'.")
+> except subprocess.CalledProcessError as e:
+>     print(f"Failed to initialize Git repository: {e}")
+> ```
+>
+> ### Explanation:
+> - **`os.path.expanduser("~/local-operator")`**: This expands the `~` to the user's home directory, resulting in the full path to the `local-operator` directory.
+> - **`os.makedirs(repo_path)`**: This creates the directory if it doesn't already exist.
+> - **`subprocess.run(["git", "init"], cwd=repo_path, check=True)`**: This runs the `git init` command in the specified directory (`cwd` stands for "current working directory"). The `check=True` ensures that an exception is raised if the command fails.
+>
+> ### Running the Code:
+> When you run this code, it will:
+> 1. Create the `~/local-operator` directory if it doesn't exist.
+> 2. Initialize a Git repository in that directory.
+>
+> Let me know if you want to proceed with running this code!
+>
+> Executing code blocks...
+>
+> Executing:
+> ```python
+> import os
+> import subprocess
+>
+> # Define the directory path
+> repo_path = os.path.expanduser("~/local-operator")
+>
+> # Create the directory if it doesn't exist
+> if not os.path.exists(repo_path):
+>     os.makedirs(repo_path)
+>     print(f"Directory '{repo_path}' created.")
+> else:
+>     print(f"Directory '{repo_path}' already exists.")
+>
+> # Initialize the Git repository
+> try:
+>     subprocess.run(["git", "init"], cwd=repo_path, check=True)
+>     print(f"Git repository initialized in '{repo_path}'.")
+> except subprocess.CalledProcessError as e:
+>     print(f"Failed to initialize Git repository: {e}")
+> ```
+>
+> Result:
+> ```
+> Directory '/Users/damiantran/local-operator' already exists.
+> hint: Using 'master' as the name for the initial branch. This default branch name
+> hint: is subject to change. To configure the initial branch name to use in all
+> hint: of your new repositories, which will suppress this warning, call:
+> hint: 
+> hint:   git config --global init.defaultBranch <name>
+> hint: 
+> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
+> hint: 'development'. The just-created branch can be renamed via this command:
+> hint: 
+> hint:   git branch -m <name>
+> Initialized empty Git repository in /Users/damiantran/local-operator/.git/
+> Git repository initialized in '/Users/damiantran/local-operator'.
+> Result: Code executed successfully
+> ```
+
+### Performing unsafe operations
+
+> **You: >** remove the placeholder module1.py and test-module1.py, etc. files 
+>
+> Model Response:
+> To remove the placeholder files (`module1.py`, `module2.py`, `test_module1.py`, and `test_module2.py`) from the `local-operator` repository, we can use Python's `os` module to delete these files. Here's the updated code:
+>
+> ```python
+> import os
+> import shutil
+>
+> # Define paths
+> source_file = os.path.expanduser("~/python-sandbox/python-sandbox/local_operator.py")
+> repo_path = os.path.expanduser("~/local-operator")
+> destination_file = os.path.join(repo_path, "local_operator", "local_operator.py")
+>
+> # Copy the file
+> try:
+>     shutil.copy(source_file, destination_file)
+>     print(f"Copied '{source_file}' to '{destination_file}'.")
+> except FileNotFoundError:
+>     print(f"Source file '{source_file}' not found.")
+> except Exception as e:
+>     print(f"Failed to copy file: {e}")
+>
+> # Remove placeholder files
+> files_to_remove = [
+>     "local_operator/module1.py",
+>     "local_operator/module2.py",
+>     "tests/test_module1.py",
+>     "tests/test_module2.py"
+> ]
+>
+> for file_path in files_to_remove:
+>     full_path = os.path.join(repo_path, file_path)
+>     try:
+>         if os.path.exists(full_path):
+>             os.remove(full_path)
+>             print(f"Removed file: {file_path}")
+>         else:
+>             print(f"File '{file_path}' does not exist.")
+>     except Exception as e:
+>         print(f"Failed to remove file '{file_path}': {e}")
+>
+> # Update remaining files with meaningful content
+> files_to_update = {
+>     "local_operator/__init__.py": "# This is the initialization file for the local_operator package.\n",
+>     "README.md": "# Local Operator\n\nThis is a Python project for local operations.\n",
+>     "requirements.txt": "# Add your project dependencies here.\n",
+>     "setup.py": """from setuptools import setup, find_packages
+>
+> setup(
+>     name='local_operator',
+>     version='0.1',
+>     packages=find_packages(),
+>     install_requires=[],
+> )
+> """
+> }
+>
+> # Update files
+> for file_path, content in files_to_update.items():
+>     full_path = os.path.join(repo_path, file_path)
+>     try:
+>         with open(full_path, "w") as f:
+>             f.write(content)
+>         print(f"Updated file: {file_path}")
+>     except Exception as e:
+>         print(f"Failed to update file '{file_path}': {e}")
+> ```
+>
+> ### Explanation:
+> 1. **Removing Placeholder Files**:
+>    - The `files_to_remove` list contains the paths of the placeholder files to be deleted.
+>    - The script iterates over this list and removes each file using `os.remove()` if it exists.
+>
+> 2. **Updating Remaining Files**:
+>    - The `files_to_update` dictionary contains the paths and content for the remaining files (`__init__.py`, `README.md`, `requirements.txt`, and `setup.py`).
+>    - The script updates these files with meaningful content.
+>
+> ### Running the Code:
+> When you run this code, it will:
+> 1. Copy the `local_operator.py` file to the `local_operator` directory in the new repository.
+> 2. Remove the placeholder files (`module1.py`, `module2.py`, `test_module1.py`, and `test_module2.py`).
+> 3. Update the remaining files with meaningful content.
+>
+> Let me know if you'd like to proceed with running this code!
+>
+> Executing code blocks...
+>
+> Executing:
+> ```python
+> import os
+> import shutil
+>
+> # Define paths
+> source_file = os.path.expanduser("~/python-sandbox/python-sandbox/local_operator.py")
+> repo_path = os.path.expanduser("~/local-operator")
+> destination_file = os.path.join(repo_path, "local_operator", "local_operator.py")
+>
+> # Copy the file
+> try:
+>     shutil.copy(source_file, destination_file)
+>     print(f"Copied '{source_file}' to '{destination_file}'.")
+> except FileNotFoundError:
+>     print(f"Source file '{source_file}' not found.")
+> except Exception as e:
+>     print(f"Failed to copy file: {e}")
+> ```
+>
+> # Remove placeholder files
+> ```python
+> files_to_remove = [
+>     "local_operator/module1.py",
+>     "local_operator/module2.py",
+>     "tests/test_module1.py",
+>     "tests/test_module2.py"
+> ]
+>
+> for file_path in files_to_remove:
+>     full_path = os.path.join(repo_path, file_path)
+>     try:
+>         if os.path.exists(full_path):
+>             os.remove(full_path)
+>             print(f"Removed file: {file_path}")
+>         else:
+>             print(f"File '{file_path}' does not exist.")
+>     except Exception as e:
+>         print(f"Failed to remove file '{file_path}': {e}")
+> ```
+>
+> # Update remaining files with meaningful content
+> ```python
+> files_to_update = {
+>     "local_operator/__init__.py": "# This is the initialization file for the local_operator package.\n",
+>     "README.md": "# Local Operator\n\nThis is a Python project for local operations.\n",
+>     "requirements.txt": "# Add your project dependencies here.\n",
+>     "setup.py": """from setuptools import setup, find_packages
+>
+> setup(
+>     name='local_operator',
+>     version='0.1',
+>     packages=find_packages(),
+>     install_requires=[],
+> )
+> """
+> }
+>
+> # Update files
+> ```python
+> for file_path, content in files_to_update.items():
+>     full_path = os.path.join(repo_path, file_path)
+>     try:
+>        with open(full_path, "w") as f:
+>             f.write(content)
+>         print(f"Updated file: {file_path}")
+>     except Exception as e:
+>         print(f"Failed to update file '{file_path}': {e}")
+> ```
+>
+> Result:
+> ```
+> Warning: Potentially dangerous operation detected. Proceed? (y/n): y
+> Copied '/Users/damiantran/python-sandbox/python-sandbox/local_operator.py' to '/Users/damiantran/local-operator/local_operator/local_operator.py'.
+> Removed file: local_operator/module1.py
+> Removed file: local_operator/module2.py
+> Removed file: tests/test_module1.py
+> Removed file: tests/test_module2.py
+> Updated file: local_operator/__init__.py
+> Updated file: README.md
+> Updated file: requirements.txt
+> Updated file: setup.py
+> Result: Code executed successfully
+> ```
+
+
+## Safety Features
+
+The system includes multiple layers of protection:
+- Automatic detection of dangerous operations (file access, system commands, etc.)
+- User confirmation prompts for potentially unsafe code
+- Isolated execution context to prevent system-wide changes
+- Strict Python-only code execution policy
+
+## Requirements
+
+- Python 3.12+
+- DeepSeek API key (set in .env file)
+- Required packages: langchain-openai, python-dotenv, pydantic
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

local_operator-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+local_operator/__init__.py,sha256=t8kpWb_uJEQc8ztkQwq0RvUUeomJbwtpsoF50zh_Vac,66
+local_operator/cli.py,sha256=5TkZTrg0FV5IgFZhWwGMFyGdCDtA_LGepcVyxxW5QGY,6468
+local_operator/main.py,sha256=pQoJmfAZEff3VdCdIFEB--dktI13PaLP6mhz7-UmLhA,868
+local_operator-0.0.1.dist-info/LICENSE,sha256=LOb3oIbc5GUnQghD0djAAhOOGDO4db7PueK3DLaHj5s,1068
+local_operator-0.0.1.dist-info/METADATA,sha256=OWuXM4MzEET00MD3gsZlT28bPLoD2SrLxJ9v5vy92UE,15044
+local_operator-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+local_operator-0.0.1.dist-info/entry_points.txt,sha256=E1EThC2_NfpQdBzOeYtL7wt7NbRrOezweh19XsnYZxQ,60
+local_operator-0.0.1.dist-info/top_level.txt,sha256=CNAhpbm8y8CSHaq3eOv7qXX0Qu28ENBRd97MsCW-KhM,15
+local_operator-0.0.1.dist-info/RECORD,,

local_operator-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

local_operator-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+local-operator = local_operator.main:main

local_operator-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+local_operator