Update build_logic.py

build_logic.py

@@ -4,6 +4,7 @@ import tempfile
 import shutil
 import logging
 from pathlib import Path
+import time
 
 from huggingface_hub import (
     create_repo,
@@ -13,6 +14,10 @@ from huggingface_hub import (
     hf_hub_download,
     delete_file as hf_delete_file,
     HfApi,
+    list_repos as hf_list_repos,
+    create_pull_request as hf_create_pull_request,
+    add_space_comment as hf_add_space_comment, # Public API for adding comments to Space discussions
+    like as hf_like # Public API for liking repos
 )
 from huggingface_hub.hf_api import CommitOperationDelete, CommitOperationAdd, CommitOperation
 from huggingface_hub.utils import HfHubHTTPError
@@ -25,12 +30,12 @@ logger = logging.getLogger(__name__)
 
 def _get_api_token(ui_token_from_textbox=None):
     env_token = os.getenv('HF_TOKEN')
-    if env_token:
-        logger.debug("Using HF_TOKEN from environment variable.")
-        return env_token, None
     if ui_token_from_textbox:
         logger.debug("Using HF_TOKEN from UI textbox.")
         return ui_token_from_textbox.strip(), None
+    if env_token:
+        logger.debug("Using HF_TOKEN from environment variable.")
+        return env_token, None
     logger.warning("Hugging Face API token not provided in UI or HF_TOKEN env var.")
     return None, "Error: Hugging Face API token not provided in UI or HF_TOKEN env var."
 
@@ -294,7 +299,6 @@ def get_space_file_content(ui_api_token_from_textbox, space_name_ui, owner_ui, f
         logger.exception(f"Error fetching file content for {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}:")
         return None, f"Error fetching file content: {str(e)}"
 
-# Renamed and modified to only handle file changes (CREATE, UPDATE, DELETE)
 def apply_staged_file_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, file_changeset):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
     repo_id = None
@@ -334,7 +338,7 @@ def apply_staged_file_changes(ui_api_token_from_textbox, owner_ui, space_name_ui
                 logger.warning(f"Could not stage .gitattributes: {e}")
 
 
-            for change in file_changeset: # Iterate only through file changes
+            for change in file_changeset:
                 if change['type'] == 'UPDATE_FILE' or change['type'] == 'CREATE_FILE':
                     file_path_in_repo = change['path'].lstrip('/').replace(os.sep, '/')
                     if not file_path_in_repo:
@@ -402,7 +406,7 @@ def apply_staged_file_changes(ui_api_token_from_textbox, owner_ui, space_name_ui
                          repo_type="space",
                          commit_message=commit_message_upload,
                          allow_patterns=["*"],
-                         timeout=120 # Increased timeout for uploads
+                         timeout=120
                       )
                       status_messages.append(f"File Uploads/Updates: Successfully uploaded/updated {len(paths_to_upload)} files.")
                       logger.info("Upload/Update commit successful.")
@@ -437,6 +441,136 @@ def apply_staged_file_changes(ui_api_token_from_textbox, owner_ui, space_name_ui
     logger.info(f"Finished applying staged file changes. Final status: {final_status}")
     return final_status
 
+def build_logic_create_space(ui_api_token_from_textbox, space_name_ui, owner_ui, sdk_ui, markdown_input, private):
+    repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
+    logger.info(f"Attempting to create space: {repo_id_for_error_logging}")
+
+    if not space_name_ui: return "Error: Space Name cannot be empty."
+    if "/" in space_name_ui: return "Error: Space Name should not contain '/'."
+
+    resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
+    if token_err: return f"API Token Error: {token_err}"
+
+    final_owner = owner_ui
+    if not final_owner:
+         try:
+             user_info = whoami(token=resolved_api_token)
+             final_owner = user_info.get('name')
+             if not final_owner: raise Exception("Could not find user name from token.")
+         except Exception as e:
+             return f"Error auto-detecting owner: {str(e)}. Specify Owner field."
+
+    if not final_owner: return "Error: Owner could not be determined."
+
+    repo_id = f"{final_owner}/{space_name_ui}"
+    temp_dir = None
+
+    try:
+        api = HfApi(token=resolved_api_token)
+
+        # Create the repository
+        api.create_repo(repo_id=repo_id, repo_type="space", space_sdk=sdk_ui, private=private, exist_ok=False)
+        logger.info(f"Successfully created empty space: {repo_id}")
+
+        # Stage files from markdown for upload if markdown is provided
+        if markdown_input:
+             parsed_md = parse_markdown(markdown_input)
+             files_to_upload = parsed_md.get("files", [])
+             if files_to_upload:
+                  logger.info(f"Staging {len(files_to_upload)} files for upload after creation.")
+                  temp_dir = tempfile.TemporaryDirectory()
+                  repo_staging_path = Path(temp_dir.name) / "initial_content"
+                  repo_staging_path.mkdir(exist_ok=True)
+                  paths_to_upload = {}
+                  status_messages = []
+
+                  # Add .gitattributes
+                  gitattributes_path_local = repo_staging_path / ".gitattributes"
+                  try:
+                      with open(gitattributes_path_local, "w", encoding="utf-8") as f:
+                          f.write("* text=auto eol=lf\n")
+                      paths_to_upload[str(gitattributes_path_local)] = ".gitattributes"
+                  except Exception as e:
+                       status_messages.append(f"Warning: Could not stage .gitattributes file: {e}")
+                       logger.warning(f"Could not stage .gitattributes: {e}")
+
+
+                  for file_info in files_to_upload:
+                       file_path_in_repo = file_info['path'].lstrip('/').replace(os.sep, '/')
+                       content_to_write = file_info.get('content', '')
+
+                       if not file_path_in_repo:
+                            status_messages.append(f"Skipping file creation: empty path.")
+                            continue
+
+                       if content_to_write.startswith("[Binary file") or content_to_write.startswith("[Error loading content:") or content_to_write.startswith("[Binary or Skipped file]"):
+                            status_messages.append(f"Skipping file '{file_path_in_repo}': Content is a binary/error placeholder.")
+                            logger.warning(f"Skipping file '{file_path_in_repo}': Content is binary/error placeholder.")
+                            continue
+
+                       file_path_local = repo_staging_path / file_path_in_repo
+                       file_path_local.parent.mkdir(parents=True, exist_ok=True)
+                       try:
+                           with open(file_path_local, "w", encoding="utf-8") as f:
+                                f.write(content_to_write)
+                           paths_to_upload[str(file_path_local)] = file_path_in_repo
+                       except Exception as file_write_error:
+                           status_messages.append(f"Error staging file {file_path_in_repo}: {file_write_error}")
+
+
+                  if paths_to_upload:
+                       try:
+                           commit_message_upload = "Initial files from AI Space Builder"
+                           upload_folder(
+                              repo_id=repo_id,
+                              folder_path=str(repo_staging_path),
+                              path_in_repo=".",
+                              token=resolved_api_token,
+                              repo_type="space",
+                              commit_message=commit_message_upload,
+                              allow_patterns=["*"],
+                              timeout=120
+                           )
+                           status_messages.append(f"Successfully uploaded initial {len(paths_to_upload)} files.")
+                           logger.info("Initial upload successful.")
+                       except HfHubHTTPError as e_http:
+                            status_messages.append(f"Initial Upload HTTP Error ({e_http.response.status_code if e_http.response else 'N/A'}): {e_http.response.text if e_http.response else str(e_http)}. Check logs.")
+                            logger.error(f"HTTP error during initial upload for {repo_id}: {e_http}")
+                       except Exception as e_upload:
+                            status_messages.append(f"Initial Upload Error: {str(e_upload)}. Check logs.")
+                            logger.exception(f"Error during initial upload for {repo_id}:")
+             else:
+                  status_messages = ["No files parsed from markdown for initial upload."]
+        else:
+             status_messages = ["No markdown provided for initial files."]
+
+
+        final_status = "Successfully created space"
+        if status_messages:
+             final_status += " | " + " | ".join(status_messages)
+
+        return final_status
+
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error creating space {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
+        status_code = e_http.response.status_code if e_http.response else 'N/A'
+        if status_code == 409: # Conflict - repo already exists
+            return f"Create Space Error ({status_code}): Space '{repo_id_for_error_logging or 'unknown'}' already exists. Use 'Build / Update' instead."
+        if status_code in (401, 403):
+             return f"Create Space Error ({status_code}): Access denied or authentication required for '{repo_id_for_error_logging or 'unknown'}'. Check token permissions."
+        return f"Create Space HTTP Error ({status_code}): {e_http.response.text if e_http.response else str(e_http)}"
+
+    except Exception as e:
+        logger.exception(f"Error creating space {repo_id_for_error_logging or 'unknown repo'}:")
+        return f"Create Space Error: {str(e)}"
+    finally:
+        if temp_dir:
+            try:
+                temp_dir.cleanup()
+            except Exception as e:
+                logger.error(f"Error cleaning up temp dir: {e}")
+
+
 def delete_space_file(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo, commit_message_ui=None):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
     repo_id = None
@@ -631,6 +765,7 @@ def build_logic_delete_space(hf_api_key, owner, space_name):
         logger.exception(f"Error deleting space {repo_id}:")
         return f"Error deleting space `{repo_id}`: {e}"
 
+
 def build_logic_create_pull_request(hf_api_key, source_repo_id, target_repo_id, title, body=""):
     logger.info(f"Attempting to create PR from '{source_repo_id}' to '{target_repo_id}'. Title: '{title}'")
     try:
@@ -641,30 +776,11 @@ def build_logic_create_pull_request(hf_api_key, source_repo_id, target_repo_id,
 
         api = HfApi(token=token)
 
-        # Assuming the source repo is a Space and the target can be any repo type
-        # Assuming PR is from source_repo_id main branch to target_repo_id main branch
-        # This might need refinement based on actual use cases (e.g., PR from space branch to model repo main)
-        # For simplicity now, assume PR from source_repo_id (space) 'main' to target_repo_id 'main'
-        # Need to check if the token has write access to target_repo_id.
-
-        # A PR is created on the *target* repository
-        # We need to check if the token can write to the target.
-        # There isn't a direct "check write permission" API, so we rely on create_pull_request errors.
-
-        pr_url = api.create_pull_request(
-             repo_id=target_repo_id, # PR is created ON the target repo
+        pr_url = hf_create_pull_request(
+             repo_id=target_repo_id,
              title=title,
              description=body,
-             # Source branch is the branch *in the source repo* (the space)
-             # Target branch is the branch *in the target repo*
-             # By default, create_pull_request assumes 'main' for both,
-             # but source is interpreted as 'main' in the *source_repo_id*
-             # and target as 'main' in the *repo_id* parameter (target_repo_id).
-             # The API docs mention `repo_id` is the target and `base_repo` is the source for cross-repo PRs.
-             # Let's use `repo_id` as target and `base_repo` as source (the space).
-             base_repo=source_repo_id, # The Space repo is the source
-             base="main", # Source branch in the Space (source_repo_id)
-             head="main", # Target branch in the target_repo_id
+             base_repo=source_repo_id,
              token=token,
              timeout=30
         )
@@ -675,13 +791,11 @@ def build_logic_create_pull_request(hf_api_key, source_repo_id, target_repo_id,
     except HfHubHTTPError as e_http:
         logger.error(f"HTTP error creating PR from {source_repo_id} to {target_repo_id}: {e_http}")
         status_code = e_http.response.status_code if e_http.response else 'N/A'
-        # Check for common errors like permission denied or target not found
         if status_code in (401, 403):
              return f"PR Error ({status_code}): Access denied or authentication required to create PR on '{target_repo_id}'. Check token permissions."
         if status_code == 404:
              return f"PR Error ({status_code}): Target repository '{target_repo_id}' not found."
-        # Add more specific error checks if needed (e.g., PR already exists, invalid branches)
-        if e_http.response and 'already exists' in e_http.response.text:
+        if e_http.response and isinstance(e_http.response.text, str) and 'already exists' in e_http.response.text:
              return f"PR Error: Pull Request already exists."
         return f"PR HTTP Error ({status_code}): {e_http.response.text if e_http.response else str(e_http)}"
 
@@ -698,47 +812,17 @@ def build_logic_add_comment(hf_api_key, repo_id, comment_text):
              logger.error(f"Token error adding comment: {err or 'Token not found'}")
              return f"Error getting token: {err or 'Token not found.'}"
 
-        api = HfApi(token=token)
-        # The create_discussion method can be used for comments on the repo itself
-        api.create_discussion(
+        # Use the new public API method add_space_comment
+        hf_add_space_comment(
              repo_id=repo_id,
-             title=f"Comment from AI Space Commander [{time.strftime('%Y-%m-%d %H:%M')}]", # Title required, use timestamp
-             description=comment_text,
+             comment=comment_text,
              token=token,
              timeout=20
         )
-        # Note: This creates a *discussion* rather than a direct comment stream entry.
-        # A more direct comment API might exist or could be simulated via other means,
-        # but create_discussion is the closest public API method for adding arbitrary text.
-        # Let's clarify this limitation or use a different method if available (e.g., adding a commit comment).
-        # HfApi does not seem to expose a simple "add comment to repo page" API.
-        # create_discussion is the most reasonable public function.
-        # Re-reading the API docs... maybe there's no public API for the little comment boxes?
-        # The Discussions API is the closest. Let's use that, but inform the user it's a discussion.
-        # Or, maybe the AI should be suggesting adding a comment via a COMMIT message?
-        # The prompt asks for "send comment", which implies a direct comment stream.
-        # This might require an internal API or simulating via another method.
-        # Let's stick to the most direct public API for now: Discussions.
-        # Or, better, tell the AI this action is not supported via public API or needs clarification.
-        # Let's return an error message for now, as `create_discussion` isn't what the user likely means by "add comment".
-        # Okay, let's re-read the original codebase. There *was* no comment/like function. The user is *requesting* them.
-        # The simplest interpretation of "add comment" is adding to the discussions tab or commit comments.
-        # Let's add `create_discussion` for now as it's a public API and the closest fit.
-        # We should clarify the AI prompt/action description to mention it creates a *discussion*.
-        # Reverted: create_discussion requires a *title*. The prompt just says "comment text".
-        # This reinforces that the requested action might not map directly to a public API.
-        # Let's implement it using `create_discussion` and add a default title.
-
-        api.create_discussion(
-            repo_id=repo_id,
-            title=f"AI Space Commander Comment: {comment_text[:50]}{'...' if len(comment_text) > 50 else ''} [{time.strftime('%Y-%m-%d %H:%M')}]", # Use part of comment + timestamp as title
-            description=comment_text, # Full comment in description
-            token=token,
-            timeout=20
-        )
 
-        logger.info(f"Successfully added comment (as discussion) to {repo_id}.")
-        return f"Successfully added comment (as a discussion) to `{repo_id}`."
+        logger.info(f"Successfully added comment to {repo_id}.")
+        # Note: hf_add_space_comment doesn't return the comment URL directly
+        return f"Successfully added comment to `{repo_id}`."
 
     except HfHubHTTPError as e_http:
         logger.error(f"HTTP error adding comment to {repo_id}: {e_http}")
@@ -762,39 +846,29 @@ def build_logic_like_space(hf_api_key, repo_id):
              logger.error(f"Token error liking space: {err or 'Token not found'}")
              return f"Error getting token: {err or 'Token not found.'}"
 
-        api = HfApi(token=token)
-        # HfApi does not have a direct 'like' method.
-        # This action might also require an internal API or not be publicly exposed.
-        # Let's return an error for now, or note it's not directly supported.
-        # Given the request "add... like", it implies it *should* be possible.
-        # A manual approach might involve an authenticated API call not wrapped by hf_hub.
-        # For now, let's return an informative error.
-        # Reverted: There *is* an internal endpoint used by the UI. It's not in the public `HfApi`.
-        # Implementing this reliably without internal API knowledge is difficult and fragile.
-        # Let's return an error message stating it's not supported via the public API.
-
-        return f"Like Error: Liking spaces is not directly supported via the public Hugging Face Hub API used by this tool."
-
-        # Example (likely unstable/unsupported) attempt using requests if we knew the endpoint:
-        # like_url = f"https://huggingface.co/api/v1/repos/{repo_id}/like"
-        # headers = {"Authorization": f"Bearer {token}"}
-        # response = requests.post(like_url, headers=headers, timeout=10)
-        # response.raise_for_status()
-        # logger.info(f"Successfully liked space: {repo_id}")
-        # return f"Successfully liked space: `{repo_id}`."
-        # except requests.exceptions.HTTPError as e:
-        #      # Handle 409 Conflict (already liked) or other errors
-        #      status_code = e.response.status_code if e.response else 'N/A'
-        #      if status_code == 409: return f"Like Error: Space '{repo_id}' already liked."
-        #      return f"Like HTTP Error ({status_code}): {e.response.text if e.response else str(e)}"
-        # except Exception as e:
-        #      logger.exception(f"Error liking space {repo_id}:")
-        #      return f"Like Error: {e}"
-
-
-    except Exception as e: # Catch potential errors even in the error path above
-        logger.exception(f"Unexpected error in build_logic_like_space for {repo_id}:")
-        return f"Like Error: An unexpected error occurred: {e}"
+        # Use the new public API method like
+        hf_like(
+             repo_id=repo_id,
+             token=token,
+             timeout=10
+        )
+
+        logger.info(f"Successfully liked space: {repo_id}")
+        return f"Successfully liked space: `{repo_id}`."
+
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error liking space {repo_id}: {e_http}")
+        status_code = e_http.response.status_code if e_http.response else 'N/A'
+        if status_code == 409:
+             return f"Like Error ({status_code}): Space '{repo_id}' already liked."
+        if status_code in (401, 403):
+             return f"Like Error ({status_code}): Access denied or authentication required to like '{repo_id}'. Check token permissions."
+        if status_code == 404:
+             return f"Like Error ({status_code}): Space '{repo_id}' not found."
+        return f"Like HTTP Error ({status_code}): {e_http.response.text if e_http.response else str(e_http)}"
+    except Exception as e:
+        logger.exception(f"Error liking space {repo_id}:")
+        return f"Like Error: {e}"
 
 
 def duplicate_space(hf_api_key, source_repo_id, target_repo_id, private: bool = False):
@@ -821,7 +895,7 @@ def duplicate_space(hf_api_key, source_repo_id, target_repo_id, private: bool =
                  logger.error(f"Could not determine target owner from token: {e}")
                  return f"Error: Target repository ID '{target_repo_id}' is missing owner, and owner could not be determined from token ({e}). Use '<owner>/<space_name>' format or set the Owner field."
 
-        api = HfApi(token=token) # Use HfApi object to call duplicate_repo
+        api = HfApi(token=token)
         api.duplicate_repo(
             from_repo=source_repo_id,
             to_repo=target_repo_id,
@@ -861,23 +935,7 @@ def list_user_spaces(hf_api_key, owner=None):
                  return None, f"Error auto-detecting owner for listing: {e}. Please specify Owner field."
 
         api = HfApi(token=token)
-        #spaces = hf_list_repos(effective_owner,token=token)
-        
-        user_repos = {}
-        
-        # List models for the user
-        models = api.list_models(author=owner)
-        user_repos['models'] = [model.id for model in models]
-        
-        # List datasets for the user
-        datasets = api.list_datasets(author=owner)
-        user_repos['datasets'] = [dataset.id for dataset in datasets]
-        
-        # List Spaces for the user
-        spaces = api.list_spaces(author=owner)
-        user_repos['spaces'] = [space.id for space in spaces]
-
-        
+        spaces = api.list_repos(author=effective_owner, type="space", token=token, timeout=20)
         space_ids = [f"{r.author}/{r.id}" for r in spaces]
 
         logger.info(f"Successfully listed {len(space_ids)} spaces for {effective_owner}.")
@@ -893,23 +951,4 @@ def list_user_spaces(hf_api_key, owner=None):
         return None, f"HTTP Error ({status_code}) listing spaces for '{owner or 'authenticated user'}': {e_http.response.text if e_http.response else str(e_http)}"
     except Exception as e:
         logger.exception(f"Error listing spaces for {owner or 'authenticated user'}:")
-        return None, f"Error listing spaces: {e}"
-
-
-def list_user_spaces(username):
-  api = HfApi()
-  user_repos = {}
-
-  # List models for the user
-  models = api.list_models(author=username)
-  user_repos['models'] = [model.id for model in models]
-
-  # List datasets for the user
-  datasets = api.list_datasets(author=username)
-  user_repos['datasets'] = [dataset.id for dataset in datasets]
-
-  # List Spaces for the user
-  spaces = api.list_spaces(author=username)
-  user_repos['spaces'] = [space.id for space in spaces]
-
-  return user_repos
+        return None, f"Error listing spaces: {e}"