#File Operations

import requests


class SandboxFileAPI:
    def __init__(self, base_url="http://localhost:8080"):
        self.base_url = base_url.rstrip("/")

    def read_file(self, file_path, start_line=None, end_line=None):
        payload = {"file": file_path}
        if start_line is not None:
            payload["start_line"] = start_line
        if end_line is not None:
            payload["end_line"] = end_line

        response = requests.post(
            f"{self.base_url}/v1/file/read",
            json=payload,
            timeout=30,
        )
        return response.json()

    def write_file(self, file_path, content, append=False):
        response = requests.post(
            f"{self.base_url}/v1/file/write",
            json={
                "file": file_path,
                "content": content,
                "append": append,
            },
            timeout=30,
        )
        return response.json()

    def search_files(self, pattern, directory="/home/gem/workspace"):
        response = requests.post(
            f"{self.base_url}/v1/file/find",
            json={
                "path": directory,
                "glob": pattern,
            },
            timeout=30,
        )
        return response.json()


api = SandboxFileAPI()

api.write_file("/home/gem/workspace/config.json", '{"debug": false}\n')
config = api.read_file("/home/gem/workspace/config.json")
print(config["data"]["content"])

api.write_file("/home/gem/workspace/app.log", "Process started\n", append=True)

files = api.search_files("*.py", "/home/gem/workspace/src")
for file_path in files["data"]["files"]:
    print(f"Found: {file_path}")

import json

content = client.file.read_file(
    file="/home/gem/Downloads/data.csv",
).data.content

processed = process_csv(content)
client.file.write_file(
    file="/home/gem/workspace/results.json",
    content=json.dumps(processed),
)

def batch_process_files(api, directory, pattern):
    files_result = api.search_files(pattern, directory)

    for file_path in files_result["data"]["files"]:
        content_result = api.read_file(file_path)

        if content_result["success"]:
            content = content_result["data"]["content"]
            output_path = file_path.replace(".txt", "_processed.txt")
            api.write_file(output_path, content.upper())


batch_process_files(api, "/home/gem/workspace/data", "*.txt")

import json
import requests


def safe_file_operation(api, operation, **kwargs):
    try:
        result = operation(**kwargs)

        if result["success"]:
            return result["data"]

        error = result.get("data") or {}
        if error.get("error_type") == "not_found":
            print("File does not exist")
            return None

        print(f"Operation failed: {result['message']}")
        return None

    except requests.exceptions.RequestException as exc:
        print(f"Network error: {exc}")
        return None
    except json.JSONDecodeError as exc:
        print(f"JSON decode error: {exc}")
        return None


content = safe_file_operation(
    api,
    api.read_file,
    file_path="/home/gem/workspace/data.txt",
)

result = api.read_file("/home/gem/workspace/file.txt")

result = api.read_file("/etc/nginx/nginx.conf", sudo=True)

api.write_file(
    "/etc/cron.d/example",
    "0 2 * * * root /home/gem/workspace/backup.sh\n",
    sudo=True,
)

import os
import re


def secure_file_operation(file_path, base_directory="/home/gem/workspace"):
    normalized = os.path.normpath(file_path)

    if not normalized.startswith(base_directory):
        raise ValueError("Path is outside the allowed directory")

    if not re.match(r"^[a-zA-Z0-9._/-]+$", normalized):
        raise ValueError("Invalid characters in filename")

    return normalized


try:
    safe_path = secure_file_operation("/home/gem/workspace/data.txt")
except ValueError as exc:
    print(f"Security violation: {exc}")

def read_large_file(api, file_path, chunk_size=1000):
    total_lines = 0
    content_parts = []

    while True:
        result = api.read_file(
            file_path,
            start_line=total_lines,
            end_line=total_lines + chunk_size,
        )

        if not result["success"] or not result["data"]["content"]:
            break

        content = result["data"]["content"]
        content_parts.append(content)
        total_lines += chunk_size

        if len(content.splitlines()) < chunk_size:
            break

    return "\n".join(content_parts)

import aiohttp
import asyncio


async def read_file_async(session, file_path):
    payload = {"file": file_path}
    async with session.post(
        "http://localhost:8080/v1/file/read",
        json=payload,
    ) as response:
        return await response.json()


async def parallel_file_operations(files):
    async with aiohttp.ClientSession() as session:
        tasks = [read_file_async(session, file_path) for file_path in files]
        return await asyncio.gather(*tasks)