Initial Space setup of broadfield-dev/test-dfsdfsd via Builder

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+[Binary file - 1519 bytes]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Test Dfsdfsd
-emoji: 🏃
-colorFrom: pink
-colorTo: red
+title: Space Builder
+emoji: 🛠️
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 5.32.1
 app_file: app.py
@@ -10,3 +10,19 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+Space Builder
+
+A Gradio app to create, view, and update Hugging Face Spaces with a custom file structure defined via markdown input. Provide your Hugging Face API token and a markdown string to create a new Space, list files in an existing Space, or update specific files with Git commits.
+
+## Features
+- Create a new Hugging Face Space with a specified file structure.
+- View files in an existing Space.
+- Update files in a Space with custom commit messages.
+- Modern Gradio UI with a soft theme.
+
+## Usage
+1. Enter your Hugging Face API token.
+2. To create a Space, provide the space name, owner (optional), SDK, and markdown input with file structure and contents.
+3. To view files, enter the space name and owner (optional).
+4. To update a file, specify the space, file path, new content, and commit message.

app.py

@@ -0,0 +1,184 @@
+import gradio as gr
+No os needed here now for file paths unless for basename for display
+from app_logic import (
+    create_space,
+    update_space_file,
+    load_token_from_image_and_set_env,
+    KEYLOCK_DECODE_AVAILABLE,
+    list_space_files_for_browsing,
+    get_space_file_content,
+)
+
+Gradio interface
+def main_ui():
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue=gr.themes.colors.blue, secondary_hue=gr.themes.colors.sky), title="Hugging Face Space Builder") as demo:
+        gr.Markdown(
+            """
+            # 🛠️ Hugging Face Space Builder
+            ## Build Huggingface Space from a standardized string that models can be prompted to export.
+            
+            Create, view, and manage Hugging Face Spaces.
+            Provide your Hugging Face API token directly or load it from a KeyLock Wallet image.
+            """
+        )
+
+        # --- Authentication Section (Unchanged) ---
+        with gr.Accordion("🔑 Authentication Methods", open=False):
+            gr.Markdown(
+                """
+                **Token Precedence:**
+                1. If a token is successfully loaded from a KeyLock Wallet image, it will be used.
+                2. Otherwise, the token entered in the 'Enter API Token Directly' textbox will be used.
+                """
+            )
+            gr.Markdown("---")
+            gr.Markdown("### Method 1: Enter API Token Directly")
+            api_token_ui_input = gr.Textbox(label="Hugging Face API Token (hf_xxx)", type="password", placeholder="Enter token OR load from Wallet image")
+            if KEYLOCK_DECODE_AVAILABLE:
+                gr.Markdown("---")
+                gr.Markdown("### Method 2: Load API Token to this sytem environment from KeyLock Wallet Image")
+                gr.Markdown("### Get a KeyLock Wallet Image Here: [/spaces/broadfield-dev/KeyLock-API-Wallet](https://huggingface.co/spaces/broadfield-dev/KeyLock-API-Wallet)")
+                with gr.Row():
+                    keylock_image_input = gr.Image(label="KeyLock Wallet Image (PNG)", type="pil", image_mode="RGBA")
+                    keylock_password_input = gr.Textbox(label="Image Password", type="password")
+                keylock_decode_button = gr.Button("Load Token from Wallet Image", variant="secondary")
+                keylock_status_output = gr.Markdown(label="Wallet Image Decoding Status", value="Status...")
+                keylock_decode_button.click(load_token_from_image_and_set_env, [keylock_image_input, keylock_password_input], [keylock_status_output])
+            else:
+                gr.Markdown("_(KeyLock Wallet image decoding disabled: library not found.)_")
+            
+        # --- Main Application Tabs ---
+        with gr.Tabs():
+            with gr.TabItem("🚀 Create New Space"):
+                # (Create Space UI Unchanged)
+                with gr.Row():
+                    space_name_create_input = gr.Textbox(label="Space Name", placeholder="my-awesome-app (no slashes)", scale=2)
+                    owner_create_input = gr.Textbox(label="Owner Username/Org", placeholder="Leave blank for your HF username", scale=1)
+                sdk_create_input = gr.Dropdown(label="Space SDK", choices=["gradio", "streamlit", "docker", "static"], value="gradio")
+                gr.Markdown("### Example Source: [/spaces/broadfield-dev/repo_to_md](https://huggingface.co/spaces/broadfield-dev/repo_to_md)")
+                markdown_input_create = gr.Textbox(label="Markdown File Structure & Content", placeholder="Example:\n### File: app.py\n# ```python\nprint(\"Hello\")\n# ```", lines=15, interactive=True)
+                create_btn = gr.Button("Create Space", variant="primary")
+                create_output_md = gr.Markdown(label="Result")
+                create_btn.click(create_space, [api_token_ui_input, space_name_create_input, owner_create_input, sdk_create_input, markdown_input_create], create_output_md)
+
+
+            # --- "Browse & Edit Files" Tab (Hub-based) ---
+            with gr.TabItem("📂 Browse & Edit Space Files"):
+                gr.Markdown("Browse, view, and edit files directly on a Hugging Face Space.")
+                with gr.Row():
+                    browse_space_name_input = gr.Textbox(label="Space Name", placeholder="my-target-app", scale=2)
+                    browse_owner_input = gr.Textbox(label="Owner Username/Org", placeholder="Leave blank if it's your space", scale=1)
+                
+                browse_load_files_button = gr.Button("Load Files List from Space", variant="secondary")
+                browse_status_output = gr.Markdown(label="File List Status")
+
+                gr.Markdown("---")
+                gr.Markdown("### Select File to View/Edit")
+                # Using Radio for file list. Could be Dropdown for many files.
+                # `choices` will be updated dynamically.
+                file_selector_radio = gr.Radio(
+                    label="Files in Space", 
+                    choices=[], 
+                    interactive=True,
+                    info="Select a file to load its content below."
+                )
+                
+                gr.Markdown("---")
+                gr.Markdown("### File Editor")
+                file_editor_textbox = gr.Textbox(
+                    label="File Content (Editable)", lines=20, interactive=True, 
+                    placeholder="Select a file from the list above to view/edit its content."
+                )
+                edit_commit_message_input = gr.Textbox(label="Commit Message for Update", placeholder="e.g., Update app.py content")
+                update_edited_file_button = gr.Button("Update File in Space", variant="primary")
+                edit_update_status_output = gr.Markdown(label="File Update Result")
+
+                # --- Event Handlers for Browse & Edit Tab (Hub-based) ---
+                def handle_load_space_files_list(token_from_ui, space_name, owner_name):
+                    if not space_name:
+                        return {
+                            browse_status_output: gr.Markdown("Error: Space Name cannot be empty."),
+                            file_selector_radio: gr.Radio(choices=[], value=None), # Clear radio
+                            file_editor_textbox: gr.Textbox(value=""), # Clear editor
+                        }
+                    
+                    files_list, error_msg = list_space_files_for_browsing(token_from_ui, space_name, owner_name)
+                    
+                    if error_msg and files_list is None: # Indicates a hard error
+                        return {
+                            browse_status_output: gr.Markdown(f"Error: {error_msg}"),
+                            file_selector_radio: gr.Radio(choices=[], value=None),
+                            file_editor_textbox: gr.Textbox(value=""),
+                        }
+                    if error_msg and not files_list: # Info message like "no files found"
+                         return {
+                            browse_status_output: gr.Markdown(error_msg), # Show "No files found"
+                            file_selector_radio: gr.Radio(choices=[], value=None),
+                            file_editor_textbox: gr.Textbox(value=""),
+                        }
+                    
+                    return {
+                        browse_status_output: gr.Markdown(f"Files loaded for '{owner_name}/{space_name}'. Select a file to edit."),
+                        file_selector_radio: gr.Radio(choices=files_list, value=None, label=f"Files in {owner_name}/{space_name}"),
+                        file_editor_textbox: gr.Textbox(value=""), # Clear editor on new list load
+                    }
+
+                browse_load_files_button.click(
+                    fn=handle_load_space_files_list,
+                    inputs=[api_token_ui_input, browse_space_name_input, browse_owner_input],
+                    outputs=[browse_status_output, file_selector_radio, file_editor_textbox]
+                )
+
+                def handle_file_selected_for_editing(token_from_ui, space_name, owner_name, selected_filepath_evt: gr.SelectData):
+                    if not selected_filepath_evt or not selected_filepath_evt.value:
+                        # This might happen if the radio is cleared or has no selection
+                        return { 
+                            file_editor_textbox: gr.Textbox(value=""),
+                            browse_status_output: gr.Markdown("No file selected or selection cleared.")
+                        }
+                    
+                    selected_filepath = selected_filepath_evt.value # The value of the selected radio button
+
+                    if not space_name: # Should not happen if file list is populated
+                        return {
+                            file_editor_textbox: gr.Textbox(value="Error: Space name is missing."),
+                            browse_status_output: gr.Markdown("Error: Space context lost. Please reload file list.")
+                        }
+                    
+                    content, error_msg = get_space_file_content(token_from_ui, space_name, owner_name, selected_filepath)
+                    
+                    if error_msg:
+                        return {
+                            file_editor_textbox: gr.Textbox(value=f"Error loading file content: {error_msg}"),
+                            browse_status_output: gr.Markdown(f"Failed to load '{selected_filepath}': {error_msg}")
+                        }
+                    
+                    return {
+                        file_editor_textbox: gr.Textbox(value=content),
+                        browse_status_output: gr.Markdown(f"Content loaded for: {selected_filepath}")
+                    }
+                
+                # Use .select event for gr.Radio
+                file_selector_radio.select(
+                    fn=handle_file_selected_for_editing,
+                    inputs=[api_token_ui_input, browse_space_name_input, browse_owner_input], # Pass space context again
+                    outputs=[file_editor_textbox, browse_status_output]
+                )
+
+                update_edited_file_button.click(
+                    fn=update_space_file,
+                    inputs=[
+                        api_token_ui_input, 
+                        browse_space_name_input, 
+                        browse_owner_input,      
+                        file_selector_radio, # Pass the selected file path from the radio
+                        file_editor_textbox,     
+                        edit_commit_message_input
+                    ],
+                    outputs=[edit_update_status_output]
+                )
+    return demo
+
+if __name__ == "__main__":
+    demo = main_ui()
+    demo.launch(mcp_server=True)

app_logic.py

@@ -0,0 +1,255 @@
+import os
+import re
+import tempfile
+import shutil
+import git
+import re
+
+from huggingface_hub import (
+    create_repo,
+    upload_folder,
+    list_repo_files,
+    Repository,
+    whoami,
+    hf_hub_download, # New import
+)
+import logging
+from pathlib import Path
+from PIL import Image 
+
+try:
+    from keylock_decode import decode_from_image_pil
+    KEYLOCK_DECODE_AVAILABLE = True
+except ImportError:
+    KEYLOCK_DECODE_AVAILABLE = False
+    decode_from_image_pil = None
+    logging.warning("keylock-decode library not found. KeyLock Wallet image feature will be disabled.")
+
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+--- Helper Function to Get API Token (Unchanged) ---
+def _get_api_token(ui_token_from_textbox=None):
+    env_token = os.getenv('HF_TOKEN')
+    if env_token: return env_token, None
+    if ui_token_from_textbox: return ui_token_from_textbox, None
+    return None, "Error: Hugging Face API token not provided."
+
+--- `load_token_from_image_and_set_env` (Unchanged - Terminology and debug logic as before) ---
+def load_token_from_image_and_set_env(image_pil_object: Image.Image, password: str):
+    if not KEYLOCK_DECODE_AVAILABLE: return "Error: KeyLock-Decode library is not installed."
+    if image_pil_object is None: return "Error: No KeyLock Wallet image provided."
+    if not password: return "Error: Password cannot be empty."
+    status_messages_display = []
+    # ... (rest of the function, ensure debug logic is as intended or removed)
+    try:
+        logger.info(f"Attempting to decode from KeyLock Wallet image...")
+        decoded_data, status_msgs_from_lib = decode_from_image_pil(image_pil_object, password, set_environment_variables=True)
+        status_messages_display.extend(status_msgs_from_lib)
+        if decoded_data:
+            status_messages_display.append("\n**Decoded Data Summary (sensitive values masked):**")
+            for key, value in decoded_data.items():
+                display_value = '********' if any(k_word in key.upper() for k_word in ['TOKEN', 'KEY', 'SECRET', 'PASS']) else value
+                status_messages_display.append(f"- {key}: {display_value}")
+            if os.getenv('HF_TOKEN'): status_messages_display.append(f"\n**SUCCESS: HF_TOKEN set from KeyLock Wallet image.**")
+            # ... (other status messages)
+    except ValueError as e: status_messages_display.append(f"**Decoding Error:** {e}")
+    except Exception as e: status_messages_display.append(f"**Unexpected decoding error:** {str(e)}")
+    return "\n".join(status_messages_display)
+
+
+
+'''def process_commented_markdown(commented_input):
+    """Process a commented markdown string by stripping '# ' from each line if '# # Space:' is present."""
+    lines = commented_input.strip().split("\n")
+    print(type(lines))
+    # Check for '# # Space:' or variations (e.g., '# Space:') in any line
+    if any( "# # Space:" in line.strip() for line in lines):
+        print("YES")
+        cleaned_lines = [line.lstrip("# ") for line in lines]
+        return cleaned_lines
+    return lines'''
+
+def process_commented_markdown(commented_input):
+    """Process a commented markdown string by stripping '# ' from each line if '# # Space:' is present."""
+    lines = commented_input.strip().split("\n")
+    print(type(lines)) # Original debug print
+    # Check for '# # Space:' or variations (e.g., '# Space:') in any line
+    if any( "# # Space:" in line.strip() for line in lines):
+        print("YES") # Original debug print
+        
+        cleaned_lines = [line[2:] if line.startswith("# ") else line for line in lines]
+        
+        return cleaned_lines
+    return lines
+
+def parse_markdown(markdown_input):
+    space_info = {"repo_name_md": "", "owner_md": "", "files": []}
+    current_file_path = None; current_file_content_lines = []
+    in_file_definition = False; in_code_block = False
+    print(markdown_input)
+    lines = process_commented_markdown(markdown_input)
+    print(lines)
+    #lines = markdown_input.strip().split("\n")
+    
+    for line_content_orig in lines:
+        line_content_stripped = line_content_orig.strip()
+        if line_content_stripped.startswith("### File:"):
+            if current_file_path and in_file_definition:
+                space_info["files"].append({"path": current_file_path, "content": "\n".join(current_file_content_lines)})
+            current_file_path = line_content_stripped.replace("### File:", "").strip()
+            current_file_content_lines = []
+            in_file_definition = True; in_code_block = False
+            continue
+        if not in_file_definition:
+            if line_content_stripped.startswith("# Space:"):
+                full_space_name_md = line_content_stripped.replace("# Space:", "").strip()
+                if "/" in full_space_name_md: space_info["owner_md"], space_info["repo_name_md"] = full_space_name_md.split("/", 1)
+                else: space_info["repo_name_md"] = full_space_name_md
+            continue
+        if line_content_stripped.startswith("```"):
+            in_code_block = not in_code_block
+            continue
+        current_file_content_lines.append(line_content_orig)
+    if current_file_path and in_file_definition:
+        space_info["files"].append({"path": current_file_path, "content": "\n".join(current_file_content_lines)})
+    space_info["files"] = [f for f in space_info["files"] if f.get("path")]
+    return space_info
+
+
+
+--- `_determine_repo_id` (Unchanged) ---
+def _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui):
+    if not space_name_ui: return None, "Error: Space Name cannot be empty."
+    if "/" in space_name_ui: return None, "Error: Space Name should not contain '/'. Use Owner field."
+    final_owner = owner_ui; error_message = None
+    if not final_owner:
+        resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+        if token_err: return None, token_err 
+        if not resolved_api_token: return None, "Error: API token required for auto owner determination."
+        try:
+            user_info = whoami(token=resolved_api_token)
+            if user_info and 'name' in user_info: final_owner = user_info['name']
+            else: error_message = "Error: Could not retrieve username. Check token/permissions or specify Owner."
+        except Exception as e: error_message = f"Error retrieving username: {str(e)}. Specify Owner."
+        if error_message: return None, error_message
+    if not final_owner: return None, "Error: Owner could not be determined."
+    return f"{final_owner}/{space_name_ui}", None
+
+
+--- New Function to Fetch File Content from Hub ---
+def get_space_file_content(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo):
+    """Fetches content of a specific file from a Hugging Face Space."""
+    repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    try:
+        resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+        if token_err:
+            return None, token_err # Return error as second element for consistency
+
+        repo_id, err = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
+        if err:
+            return None, err
+        repo_id_for_error_logging = repo_id
+        
+        if not file_path_in_repo:
+            return None, "Error: File path cannot be empty."
+
+        logger.info(f"Attempting to download file: {file_path_in_repo} from Space: {repo_id}")
+        downloaded_file_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=file_path_in_repo,
+            repo_type="space",
+            token=resolved_api_token,
+            # revision="main", # Optional: specify a branch/commit
+            # cache_dir=... # Optional: manage cache
+        )
+        
+        content = Path(downloaded_file_path).read_text(encoding="utf-8")
+        logger.info(f"Successfully downloaded and read file: {file_path_in_repo} from {repo_id}")
+        return content, None # Return content and no error
+        
+    except Exception as e:
+        # Catch specific huggingface_hub.utils.HFValidationError for not found etc.
+        if "404" in str(e) or "not found" in str(e).lower():
+             logger.warning(f"File not found {file_path_in_repo} in {repo_id_for_error_logging}: {e}")
+             return None, f"Error: File '{file_path_in_repo}' not found in Space '{repo_id_for_error_logging}'."
+        logger.exception(f"Error fetching file content for {file_path_in_repo} from {repo_id_for_error_logging}:")
+        return None, f"Error fetching file content: {str(e)}"
+
+--- Function to list files (reused, but now distinct from fetching content) ---
+def list_space_files_for_browsing(ui_api_token_from_textbox, space_name_ui, owner_ui):
+    """Lists files in a Hugging Face Space, returns list or error."""
+    repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    try:
+        resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+        if token_err: return None, token_err
+        
+        repo_id, err = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
+        if err: return None, err
+        repo_id_for_error_logging = repo_id
+            
+        files = list_repo_files(repo_id=repo_id, token=resolved_api_token, repo_type="space")
+        if not files:
+            return [], f"No files found in Space `{repo_id}`." # Return empty list and info message
+        return files, None # Return list of files and no error
+    except Exception as e:
+        logger.exception(f"Error listing files for {repo_id_for_error_logging}:")
+        return None, f"Error listing files for `{repo_id_for_error_logging}`: {str(e)}"
+
+
+--- Core Functions: `create_space`, `update_space_file` (Unchanged from previous correct versions) ---
+def create_space(ui_api_token_from_textbox, space_name_ui, owner_ui, sdk_ui, markdown_input):
+    repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    try:
+        resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+        if token_err: return token_err
+        repo_id, err = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
+        if err: return err
+        repo_id_for_error_logging = repo_id
+        space_info = parse_markdown(markdown_input)
+        if not space_info["files"]: return "Error: No files found in markdown."
+        with tempfile.TemporaryDirectory() as temp_dir:
+            repo_staging_path = Path(temp_dir) / "repo_staging_content"
+            repo_staging_path.mkdir(exist_ok=True)
+            for file_info in space_info["files"]:
+                if not file_info.get("path"): continue
+                file_path_abs = repo_staging_path / file_info["path"]
+                file_path_abs.parent.mkdir(parents=True, exist_ok=True)
+                with open(file_path_abs, "w", encoding="utf-8") as f: f.write(file_info["content"])
+            try:
+                create_repo(repo_id=repo_id, token=resolved_api_token, repo_type="space", space_sdk=sdk_ui, private=False)
+            except Exception as e:
+                err_str = str(e).lower()
+                if not ("already exists" in err_str or "you already created this repo" in err_str or "exists" in err_str):
+                    return f"Error creating Space '{repo_id}': {str(e)}"
+            upload_folder(repo_id=repo_id, folder_path=str(repo_staging_path), path_in_repo=".", token=resolved_api_token, repo_type="space", commit_message=f"Initial Space setup of {repo_id} via Builder")
+            return f"Successfully created/updated Space: [{repo_id}](https://huggingface.co/spaces/{repo_id})"
+    except Exception as e:
+        logger.exception(f"Error in create_space for {repo_id_for_error_logging}:")
+        return f"Error during Space creation/update: {str(e)}"
+
+def update_space_file(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo, file_content, commit_message_ui):
+    repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    try:
+        resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+        if token_err: return token_err
+        repo_id, err = _determine_repo_id(ui_api_token_from_textbox, space_name_ui, owner_ui)
+        if err: return err
+        repo_id_for_error_logging = repo_id
+        if not file_path_in_repo: return "Error: File Path to update cannot be empty."
+        file_path_in_repo = file_path_in_repo.lstrip('/').replace(os.sep, '/')
+        commit_message_ui = commit_message_ui or f"Update {file_path_in_repo} via Space Builder"
+        with tempfile.TemporaryDirectory() as temp_dir_for_update:
+            repo_local_clone_path = Path(temp_dir_for_update) / "update_clone"
+            cloned_repo = Repository(local_dir=str(repo_local_clone_path), clone_from=f"https://huggingface.co/spaces/{repo_id}", repo_type="space", use_auth_token=resolved_api_token, git_user="Space Builder Bot", git_email="[email protected]")
+            full_local_file_path = Path(cloned_repo.local_dir) / file_path_in_repo
+            full_local_file_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(full_local_file_path, "w", encoding="utf-8") as f: f.write(file_content)
+            cloned_repo.push_to_hub(commit_message=commit_message_ui)
+            return f"Successfully updated `{file_path_in_repo}` in Space [{repo_id}](https://huggingface.co/spaces/{repo_id})"
+    except Exception as e:
+        logger.exception(f"Error in update_space_file for {repo_id_for_error_logging}, file {file_path_in_repo}:")
+        return f"Error updating file for `{repo_id_for_error_logging}`: {str(e)}"

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.44.0
+huggingface_hub==0.24.6
+gitpython==3.1.43
+Pillow
+git+https://github.com/broadfield-dev/keylock-decode.git