| def get_file_content(owner, repo_name, path, branch="main"): | |
| """Fetches file content from a GitHub repository.""" | |
| url = f"https://raw.githubusercontent.com/{owner}/{repo_name}/{branch}/{path}" | |
| try: | |
| response = requests.get(url) | |
| response.raise_for_status() | |
| return response.text | |
| except requests.exceptions.RequestException as e: | |
| return f"Error fetching file: {e}" | |
| def extract_repo_info(url): | |
| """Extracts owner and repo name from a GitHub URL.""" | |
| match = re.search(r"github\.com/([^/]+)/([^/]+)", url) | |
| return match.group(1), match.group(2) if match else (None, None) | |
| def analyze_file_content(content, file_path): | |
| """Analyzes file content and returns statistics.""" | |
| lines = content.splitlines() | |
| word_count = sum(len(line.split()) for line in lines) | |
| line_count = len(lines) | |
| file_extension = file_path.split('.')[-1].lower() if '.' in file_path else "unknown" | |
| return { | |
| "line_count": line_count, | |
| "word_count": word_count, | |
| "file_extension": file_extension, | |
| } | |
| def github_tool( | |
| action: str, | |
| repo_name: str = None, | |
| branch: str = "main", | |
| path: str = None, | |
| content: str = None, | |
| message: str = None, | |
| owner: str = None, | |
| vcs_url: str = None, | |
| title: str = None, | |
| body: str = None, | |
| base: str = None, | |
| head: str = None, | |
| issue_number: int = None, | |
| labels: str = None, | |
| tag: str = None, | |
| name: str = None, | |
| file_url: str = None, | |
| repo_url: str = None, | |
| template_name: str = None, | |
| template_params: dict = None, | |
| diff: str = None, | |
| diff_message: str = None, | |
| new_description: str = None, | |
| issue_title: str = None, | |
| issue_body: str = None, | |
| issue_state: str = None, | |
| **kwargs | |
| ): | |
| """Manages GitHub repositories.""" | |
| user = g.get_user() | |
| try: | |
| if action == "import_repository": | |
| if not all([owner, repo_name, vcs_url]): | |
| raise ValueError("Missing parameters: owner, repo_name, vcs_url") | |
| try: | |
| user.get_repo(repo_name) | |
| return "Repository already exists." | |
| except GithubException: | |
| pass | |
| headers = { | |
| 'Authorization': f'token {GITHUB_TOKEN}', | |
| 'Accept': 'application/vnd.github.v3+json', | |
| } | |
| import_url = f'https://api.github.com/repos/{owner}/{repo_name}/import' | |
| response = requests.put(import_url, json={'vcs_url': vcs_url, 'vcs': 'git'}, headers=headers) | |
| response.raise_for_status() | |
| return "Repository import started." | |
| elif action == "create_repository": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.create_repo(name=repo_name) | |
| return f"Repository **{repo_name}** created! [Open repository]({repo.html_url})" | |
| elif action == "create_project_from_template": | |
| if not all([repo_name, template_name]): | |
| raise ValueError("Missing parameters: repo_name, template_name") | |
| if template_name not in PROJECT_TEMPLATES: | |
| raise ValueError( | |
| f"Unknown template: {template_name}. Available: {', '.join(PROJECT_TEMPLATES.keys())}" | |
| ) | |
| repo = user.create_repo(name=repo_name) | |
| template = PROJECT_TEMPLATES[template_name] | |
| template_params_final = {} | |
| if "params" in template: | |
| for param_name, param_config in template["params"].items(): | |
| template_params_final[param_name] = template_params.get(param_name, param_config.get("default")) if template_params else param_config.get("default") | |
| repo_name_snake_case = repo_name.replace("-", "_") | |
| readme_filename = "README.md" | |
| env = jinja2.Environment() | |
| for file_path, file_content in template["files"].items(): | |
| final_file_path = file_path | |
| final_file_content = file_content | |
| if "rename_files" in template: | |
| for old_name, new_name_template in template["rename_files"].items(): | |
| if file_path == old_name: | |
| final_file_path = new_name_template.replace("{{repo_name_snake_case}}", repo_name_snake_case).replace("{{repo_name}}", repo_name).replace("{{readme_filename}}", readme_filename) | |
| template_render = env.from_string(final_file_content) | |
| final_file_content = template_render.render( | |
| repo_name=repo_name, | |
| repo_name_snake_case=repo_name_snake_case, | |
| readme_filename=readme_filename, | |
| **template_params_final | |
| ) | |
| repo.create_file( | |
| final_file_path, | |
| f"Create {final_file_path} from template {template_name}", | |
| final_file_content, | |
| branch="main", | |
| ) | |
| if "post_process" in template: | |
| post_process_action = template["post_process"] | |
| if post_process_action == "install_dependencies": | |
| print( | |
| f"Post-processing: install_dependencies for {repo_name} (Not fully implemented in this example).") | |
| elif post_process_action == "shadcn_setup": | |
| instructions = f""" | |
| **Konfiguracja Shadcn UI wymaga dodatkowych kroków po stronie klienta!** | |
| 1. **Sklonuj repozytorium:** `git clone https://github.com/{user.login}/{repo_name}.git` | |
| 2. **Przejdź do katalogu projektu:** `cd {repo_name}` | |
| 3. **Zainstaluj zależności:** `npm install` (lub `yarn install`, `pnpm install`) | |
| 4. **Zainicjuj Shadcn UI:** `npx shadcn-ui@latest init` | |
| 5. **Uruchom aplikację:** `npm run dev` (lub odpowiednia komenda dla Twojego menedżera pakietów) | |
| Po wykonaniu tych kroków, Twoja aplikacja Shadcn UI będzie w pełni skonfigurowana i gotowa do rozwoju. | |
| """ | |
| return f"Repository **{repo_name}** created from template **{template_name}**! [Open repository]({repo.html_url})\n\n{instructions}" | |
| else: | |
| print(f"Unknown post-process action: {post_process_action}") | |
| return f"Repository **{repo_name}** created from template **{template_name}**! [Open repository]({repo.html_url})" | |
| elif action == "create_file": | |
| if not all([repo_name, path, content, message]): | |
| raise ValueError("Missing parameters: repo_name, path, content, message") | |
| repo = user.get_repo(repo_name) | |
| repo.create_file(path, message, content, branch=branch) | |
| return f"File **`{path}`** created in repository **`{repo_name}`** on branch **`{branch}`**." | |
| elif action == "get_file": | |
| if not all([repo_name, path]): | |
| raise ValueError("Missing parameters: repo_name, path") | |
| repo = user.get_repo(repo_name) | |
| file_content = repo.get_contents(path, ref=branch) | |
| return ( | |
| f"File content of **`{path}`** from **`{repo_name}`**:\n\n`\n{file_content.decoded_content.decode()}\n`" | |
| ) | |
| elif action == "get_file_content_by_url": | |
| if not file_url: | |
| raise ValueError("Missing parameter: file_url") | |
| file_content = get_file_content(None, None, None, None) | |
| return f"File content from URL **`{file_url}`**:\n\n`\n{file_content}\n`" | |
| elif action == "delete_file": | |
| if not all([repo_name, path]): | |
| raise ValueError("Missing parameters: repo_name, path") | |
| repo = user.get_repo(repo_name) | |
| file_contents = repo.get_contents(path, ref=branch) | |
| repo.delete_file(path, "Delete file", file_contents.sha, branch=branch) | |
| return f"File **`{path}`** deleted from repository **`{repo_name}`** on branch **`{branch}`**." | |
| elif action == "update_file": | |
| if not all([repo_name, path, content, message]): | |
| raise ValueError("Missing parameters: repo_name, path, content, message") | |
| repo = user.get_repo(repo_name) | |
| file_contents = repo.get_contents(path, ref=branch) | |
| repo.update_file(path, message, content, file_contents.sha, branch=branch) | |
| return f"File **`{path}`** updated in repository **`{repo_name}`** on branch **`{branch}`**." | |
| elif action == "update_file_diff": | |
| if not all([repo_name, path, diff, diff_message]): | |
| raise ValueError("Missing parameters: repo_name, path, diff, diff_message") | |
| repo = user.get_repo(repo_name) | |
| file_contents = repo.get_contents(path, ref=branch) | |
| current_content_text = file_contents.decoded_content.decode() | |
| dmp = diff_match_patch() | |
| try: | |
| patches = dmp.patch_fromText(diff) | |
| except ValueError: | |
| raise ValueError("Invalid patch format. Please provide a valid patch in 'diff' format.") | |
| patched_content_tuple = dmp.patch_apply(patches, current_content_text) | |
| patched_content_text = patched_content_tuple[0] | |
| patch_results = patched_content_tuple[1] | |
| if not any(patch_results): | |
| raise ValueError("Failed to apply patch. Diff might be outdated or invalid.") | |
| repo.update_file(path, diff_message, patched_content_text, file_contents.sha, branch=branch) | |
| return f"File **`{path}`** updated using diff in repository **`{repo_name}`** on branch **`{branch}`**." | |
| elif action == "list_branches": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| branches = repo.get_branches() | |
| branch_list = "\n".join([f"- `{branch.name}`" for branch in branches]) | |
| return f"Branches in repository **`{repo_name}`**:\n{branch_list}" | |
| elif action == "create_branch": | |
| if not all([repo_name, base, head]): | |
| raise ValueError("Missing parameters: repo_name, base, head") | |
| repo = user.get_repo(repo_name) | |
| source_branch = repo.get_branch(base) | |
| repo.create_git_ref(ref=f"refs/heads/{head}", sha=source_branch.commit.sha) | |
| return f"Branch **`{head}`** created from **`{base}`** in repository **`{repo_name}`**." | |
| elif action == "delete_branch": | |
| if not all([repo_name, branch]): | |
| raise ValueError("Missing parameters: repo_name, branch") | |
| repo = user.get_repo(repo_name) | |
| repo.get_git_ref(f"heads/{branch}").delete() | |
| return f"Branch **`{branch}`** deleted from repository **`{repo_name}`**." | |
| elif action == "create_pull_request": | |
| if not all([repo_name, title, body, base, head]): | |
| raise ValueError("Missing parameters: repo_name, title, body, base, head") | |
| repo = user.get_repo(repo_name) | |
| pr = repo.create_pull(title=title, body=body, base=base, head=head) | |
| return f"Pull request created! [Open Pull Request]({pr.html_url})" | |
| elif action == "list_open_pull_requests": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| open_prs = repo.get_pulls(state='open') | |
| if not open_prs: | |
| return f"No open pull requests in repository **`{repo_name}`**." | |
| prs_list = "\n".join([f"- [{pr.title}]({pr.html_url})" for pr in open_prs]) | |
| return f"Open pull requests in repository **`{repo_name}`**:\n{prs_list}" | |
| elif action == "create_issue": | |
| if not all([repo_name, title, body]): | |
| raise ValueError("Missing parameters: repo_name, title, body") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.create_issue(title=title, body=body) | |
| return f"Issue created! [Open Issue]({issue.html_url})" | |
| elif action == "list_issues": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| issues = repo.get_issues(state='open') | |
| if not issues: | |
| return f"No open issues in repository **`{repo_name}`**." | |
| issues_list = "\n".join([f"- [{issue.title}]({issue.html_url})" for issue in issues]) | |
| return f"Open issues in repository **`{repo_name}`**:\n{issues_list}" | |
| elif action == "add_label_to_issue": | |
| if not all([repo_name, issue_number, labels]): | |
| raise ValueError("Missing parameters: repo_name, issue_number, labels") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.get_issue(number=int(issue_number)) | |
| for label in labels.split(","): | |
| issue.add_to_labels(label.strip()) | |
| return ( | |
| f"Labels **`{labels}`** added to issue **#{issue_number}** in repository **`{repo_name}`**." | |
| ) | |
| elif action == "close_issue": | |
| if not all([repo_name, issue_number]): | |
| raise ValueError("Missing parameters: repo_name, issue_number") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.get_issue(number=int(issue_number)) | |
| issue.edit(state='closed') | |
| return f"Issue **#{issue_number}** closed in repository **`{repo_name}`**." | |
| elif action == "add_comment_to_issue": | |
| if not all([repo_name, issue_number, message]): | |
| raise ValueError("Missing parameters: repo_name, issue_number, message") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.get_issue(number=int(issue_number)) | |
| issue.create_comment(body=message) | |
| return f"Comment added to issue **#{issue_number}** in repository **`{repo_name}`**." | |
| elif action == "create_release": | |
| if not all([repo_name, tag, name, message]): | |
| raise ValueError("Missing parameters: repo_name, tag, name, message") | |
| repo = user.get_repo(repo_name) | |
| release = repo.create_git_release(tag=tag, name=name, message=message) | |
| return ( | |
| f"Release **`{name}`** created in repository **`{repo_name}`**! [Open Release]({release.html_url})" | |
| ) | |
| elif action == "list_releases": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| releases = repo.get_releases() | |
| if not releases: | |
| return f"No releases in repository **`{repo_name}`**." | |
| releases_list = "\n".join([f"- [{release.tag_name}]({release.html_url})" for release in releases]) | |
| return f"Releases in repository **`{repo_name}`**:\n{releases_list}" | |
| elif action == "fork_repository": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = g.get_repo(repo_name) | |
| fork = user.create_fork(repo) | |
| return f"Repository **`{repo_name}`** forked! [Open fork]({fork.html_url})" | |
| elif action == "list_forks": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = g.get_repo(repo_name) | |
| forks = repo.get_forks() | |
| if not forks: | |
| return f"No forks of repository **`{repo_name}`**." | |
| forks_list = "\n".join([f"- [{fork.full_name}]({fork.html_url})" for fork in forks]) | |
| return f"Forks of repository **`{repo_name}`**:\n{forks_list}" | |
| elif action == "list_files": | |
| if not all([owner, repo_name]): | |
| raise ValueError("Missing parameters: owner, repo_name") | |
| repo = g.get_repo(f"{owner}/{repo_name}") | |
| contents = repo.get_contents("" if not path else path) | |
| if not contents: | |
| return f"No files in path **`{path}`** of repository **`{repo_name}`**." | |
| files_list = "\n".join([f"- [{content.name}]({content.download_url})" for content in contents]) | |
| return f"Files in path **`{path}`** of repository **`{repo_name}`**:\n{files_list}" | |
| elif action == "get_repository_info": | |
| if not all([owner, repo_name]): | |
| raise ValueError("Missing parameters: owner, repo_name") | |
| repo = g.get_repo(f"{owner}/{repo_name}") | |
| info = { | |
| "Name": repo.name, | |
| "Description": repo.description, | |
| "URL": repo.html_url, | |
| "Owner": repo.owner.login, | |
| "Default branch": repo.default_branch, | |
| "Language": repo.language, | |
| "Stars": repo.stargazers_count, | |
| "Forks": repo.forks_count, | |
| "Created at": str(repo.created_at), | |
| "Last updated": str(repo.updated_at), | |
| } | |
| info_md = "\n".join([f"- **{key}**: {value}" for key, value in info.items()]) | |
| return f"Repository info for **`{repo_name}`**:\n{info_md}" | |
| elif action == "get_file_content": | |
| if not all([owner, repo_name, path]): | |
| raise ValueError("Missing parameters: owner, repo_name, path") | |
| content_text = get_file_content(owner, repo_name, path, branch) | |
| return ( | |
| f"File content of **`{path}`** from repository **`{repo_name}`**:\n\n`\n{content_text}\n`" | |
| ) | |
| elif action == "analyze_repository_by_url": | |
| if not repo_url: | |
| raise ValueError("Missing parameter: repo_url") | |
| owner, repo_name = extract_repo_info(repo_url) | |
| if not owner or not repo_name: | |
| raise ValueError("Invalid repository URL") | |
| repo = g.get_repo(f"{owner}/{repo_name}") | |
| contents = repo.get_contents("") | |
| file_analyses = [] | |
| for content in contents: | |
| if content.type == "file": | |
| file_content = content.decoded_content.decode() | |
| analysis = analyze_file_content(file_content, content.path) | |
| file_analyses.append({ | |
| "name": content.name, | |
| "path": content.path, | |
| "analysis": analysis, | |
| }) | |
| analysis_md = "Repository file analysis:\n" + "\n".join([ | |
| f"- **{f['path']}**:\n" | |
| f" - Lines: {f['analysis']['line_count']}\n" | |
| f" - Words: {f['analysis']['word_count']}\n" | |
| f" - Extension: {f['analysis']['file_extension']}" | |
| for f in file_analyses | |
| ]) | |
| return analysis_md | |
| elif action == "analyze_repository_content": | |
| if not all([owner, repo_name]): | |
| raise ValueError("Missing parameters: owner, repo_name") | |
| repo = g.get_repo(f"{owner}/{repo_name}") | |
| contents = repo.get_contents("") | |
| file_analyses = [] | |
| for content in contents: | |
| if content.type == "file": | |
| file_content = get_file_content(owner, repo_name, content.path, branch) | |
| analysis = analyze_file_content(file_content, content.path) | |
| file_analyses.append({ | |
| "name": content.name, | |
| "path": content.path, | |
| "analysis": analysis, | |
| }) | |
| analysis_md = "Repository content analysis:\n" + "\n".join([ | |
| f"- **{f['path']}**:\n" | |
| f" - Lines: {f['analysis']['line_count']}\n" | |
| f" - Words: {f['analysis']['word_count']}\n" | |
| f" - Extension: {f['analysis']['file_extension']}" | |
| for f in file_analyses | |
| ]) | |
| return analysis_md | |
| elif action == "delete_repository": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| repo.delete() | |
| return f"Repository **`{repo_name}`** deleted!" | |
| elif action == "update_repository_description": | |
| if not all([repo_name, new_description]): | |
| raise ValueError("Missing parameters: repo_name, new_description") | |
| repo = user.get_repo(repo_name) | |
| repo.edit(description=new_description) | |
| return f"Repository **`{repo_name}`** description updated to: \"{new_description}\"" | |
| elif action == "edit_issue": | |
| if not all([repo_name, issue_number]): | |
| raise ValueError("Missing parameters: repo_name, issue_number") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.get_issue(number=int(issue_number)) | |
| issue_update_params = {} | |
| if issue_title is not None: | |
| issue_update_params['title'] = issue_title | |
| if issue_body is not None: | |
| issue_update_params['body'] = issue_body | |
| if issue_state is not None: | |
| issue_update_params['state'] = issue_state | |
| if not issue_update_params: | |
| raise ValueError("No issue details to update provided (title, body, or state)") | |
| issue.edit(**issue_update_params) | |
| updated_fields = ", ".join(issue_update_params.keys()) | |
| return f"Issue **#{issue_number}** in repository **`{repo_name}`** updated fields: {updated_fields}" | |
| elif action == "list_closed_issues": | |
| if not repo_name: | |
| raise ValueError("Missing parameter: repo_name") | |
| repo = user.get_repo(repo_name) | |
| issues = repo.get_issues(state='closed') | |
| if not issues: | |
| return f"No closed issues in repository **`{repo_name}`**." | |
| issues_list = "\n".join([f"- [{issue.title}]({issue.html_url})" for issue in issues]) | |
| return f"Closed issues in repository **`{repo_name}`**:\n{issues_list}" | |
| elif action == "get_issue_details": | |
| if not all([repo_name, issue_number]): | |
| raise ValueError("Missing parameters: repo_name, issue_number") | |
| repo = user.get_repo(repo_name) | |
| issue = repo.get_issue(number=int(issue_number)) | |
| comments = issue.get_comments() | |
| details = f""" | |
| **Issue #{issue.number}: {issue.title}** | |
| State: {issue.state} | |
| Created At: {issue.created_at} | |
| Author: {issue.user.login} | |
| **Body:** | |
| {issue.body} | |
| **Comments:** | |
| """ | |
| if comments: | |
| for comment in comments: | |
| details += f""" | |
| --- | |
| **{comment.user.login}** at {comment.created_at}: | |
| {comment.body} | |
| """ | |
| else: | |
| details += "No comments." | |
| return details | |
| else: | |
| raise ValueError(f"Unknown action: {action}") | |
| except GithubException as e: | |
| return f"**GitHub Error:** {e}" | |
| except ValueError as e: | |
| return f"**Error:** {e}" | |
| except requests.exceptions.RequestException as e: | |
| return f"**Connection Error:** {e}" | |
| except Exception as e: | |
| return f"**Unexpected Error:** {e}" | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# GitHub Tool Plugingit (Simplified Interface)") | |
| with gr.Column(): | |
| action = gr.Dropdown( | |
| choices=[ | |
| "import_repository", "create_repository", "create_project_from_template", | |
| "create_file", "get_file", "get_file_content_by_url", | |
| "delete_file", "update_file", "update_file_diff", | |
| "list_branches", "create_branch", "delete_branch", | |
| "create_pull_request", "list_open_pull_requests", | |
| "create_issue", "list_issues", "list_closed_issues", "get_issue_details", | |
| "add_label_to_issue", "close_issue", "add_comment_to_issue", | |
| "create_release", "list_releases", | |
| "fork_repository", "list_forks", | |
| "list_files", "get_repository_info", | |
| "analyze_repository_by_url", "analyze_repository_content", | |
| "delete_repository", "update_repository_description", "edit_issue" | |
| ], | |
| label="Select Action", | |
| ) | |
| repo_name = gr.Textbox(label="Repository Name") | |
| template_name = gr.Dropdown( | |
| choices=[""] + list(PROJECT_TEMPLATES.keys()), | |
| label="Project Template", | |
| value="", | |
| allow_custom_value=True, | |
| ) | |
| template_params_ui = {} | |
| with gr.Row(): | |
| for template_key, template_config in PROJECT_TEMPLATES.items(): | |
| if "params" in template_config: | |
| with gr.Column(visible=False, elem_classes=f"params_{template_key}") as params_section: | |
| for param_name, param_details in template_config["params"].items(): | |
| if param_details["type"] == "choice": | |
| template_params_ui[param_name] = gr.Dropdown( | |
| choices=param_details["choices"], | |
| label=param_details["description"] or param_name, | |
| value=param_details["default"] | |
| ) | |
| else: | |
| template_params_ui[param_name] = gr.Textbox( | |
| label=param_details["description"] or param_name, | |
| value=param_details["default"] if "default" in param_details else "" | |
| ) | |
| template_params_ui[template_key] = params_section | |
| branch = gr.Textbox(label="Branch", value="main") | |
| path = gr.Textbox(label="File Path") | |
| content = gr.Code(label="File Content", lines=5, language='python', visible=True) | |
| diff = gr.Code(label="Diff Content", lines=5, language='diff', visible=False) | |
| message = gr.Textbox(label="Message/Comment", visible=True) | |
| diff_message = gr.Textbox(label="Diff Message", visible=False) | |
| owner = gr.Textbox(label="Owner") | |
| vcs_url = gr.Textbox(label="VCS URL") | |
| title = gr.Textbox(label="Title") | |
| body = gr.Textbox(label="Body") | |
| base = gr.Textbox(label="Base Branch") | |
| head = gr.Textbox(label="Head Branch/New Branch") | |
| issue_number = gr.Number(label="Issue Number", precision=0) | |
| labels = gr.Textbox(label="Labels (comma-separated)") | |
| tag = gr.Textbox(label="Tag") | |
| release_name = gr.Textbox(label="Release Name") | |
| file_url = gr.Textbox(label="File URL") | |
| repo_url = gr.Textbox(label="Repository URL") | |
| new_description = gr.Textbox(label="New Repository Description", visible=False) | |
| issue_title = gr.Textbox(label="New Issue Title", visible=False) | |
| issue_body = gr.Textbox(label="New Issue Body", visible=False, lines=3) | |
| issue_state = gr.Dropdown(label="New Issue State (open/closed)", choices=["open", "closed", None], value=None, allow_none=True, visible=False) | |
| def show_template_params(template_name): | |
| visibility_map = {key: gr.Column.update(visible=False) for key in PROJECT_TEMPLATES if | |
| "params" in PROJECT_TEMPLATES[key]} | |
| if template_name and template_name in PROJECT_TEMPLATES and "params" in PROJECT_TEMPLATES[template_name]: | |
| visibility_map[template_name] = gr.Column.update(visible=True) | |
| return [visibility_map.get(key, gr.Column.update(visible=False)) for key in PROJECT_TEMPLATES if | |
| "params" in PROJECT_TEMPLATES[key]] | |
| template_param_visibility_outputs = [template_params_ui[key] for key in PROJECT_TEMPLATES if | |
| "params" in PROJECT_TEMPLATES[key]] | |
| template_name.change( | |
| show_template_params, | |
| inputs=[template_name], | |
| outputs=template_param_visibility_outputs | |
| ) | |
| run_button = gr.Button("Execute") | |
| output = gr.Markdown(label="Result") | |
| input_components = [ | |
| action, repo_name, branch, path, content, message, owner, vcs_url, title, body, base, head, issue_number, | |
| labels, tag, release_name, file_url, repo_url, template_name, new_description, issue_title, issue_body, | |
| issue_state, diff, diff_message | |
| ] | |
| for template_key in PROJECT_TEMPLATES: | |
| if "params" in PROJECT_TEMPLATES[template_key]: | |
| for param_name in template_params_ui: | |
| if param_name in PROJECT_TEMPLATES[template_key]["params"]: | |
| input_components.append(template_params_ui[param_name]) | |
| def show_hide_input_fields(action_name): | |
| visibility_map = { | |
| "repo_name": gr.Textbox.update(visible=False), | |
| "branch": gr.Textbox.update(visible=False), | |
| "path": gr.Textbox.update(visible=False), | |
| "content": gr.Code.update(visible=False), | |
| "diff": gr.Code.update(visible=False), | |
| "message": gr.Textbox.update(visible=False), | |
| "diff_message": gr.Textbox.update(visible=False), | |
| "owner": gr.Textbox.update(visible=False), | |
| "vcs_url": gr.Textbox.update(visible=False), | |
| "title": gr.Textbox.update(visible=False), | |
| "body": gr.Textbox.update(visible=False), | |
| "base": gr.Textbox.update(visible=False), | |
| "head": gr.Textbox.update(visible=False), | |
| "issue_number": gr.Number.update(visible=False), | |
| "labels": gr.Textbox.update(visible=False), | |
| "tag": gr.Textbox.update(visible=False), | |
| "release_name": gr.Textbox.update(visible=False), | |
| "file_url": gr.Textbox.update(visible=False), | |
| "repo_url": gr.Textbox.update(visible=False), | |
| "template_name": gr.Dropdown.update(visible=False), | |
| "new_description": gr.Textbox.update(visible=False), | |
| "issue_title": gr.Textbox.update(visible=False), | |
| "issue_body": gr.Textbox.update(visible=False), | |
| "issue_state": gr.Dropdown.update(visible=False), | |
| } | |
| if action_name in ["import_repository"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "owner": gr.Textbox.update(visible=True), "vcs_url": gr.Textbox.update(visible=True)}) | |
| elif action_name in ["create_repository", "delete_repository", "list_branches", "list_open_pull_requests", "list_issues", "list_closed_issues", "list_releases", "list_forks"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True)}) | |
| elif action_name == "create_project_from_template": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "template_name": gr.Dropdown.update(visible=True)}) | |
| elif action_name in ["create_file", "get_file", "delete_file", "get_file_content"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True)}) | |
| if action_name == "create_file": | |
| visibility_map.update({"content": gr.Code.update(visible=True), "message": gr.Textbox.update(visible=True)}) | |
| elif action_name == "update_file": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True), "content": gr.Code.update(visible=True), "message": gr.Textbox.update(visible=True)}) | |
| elif action_name == "update_file_diff": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True), "diff": gr.Code.update(visible=True), "diff_message": gr.Textbox.update(visible=True)}) | |
| elif action_name == "get_file_content_by_url": | |
| visibility_map.update({"file_url": gr.Textbox.update(visible=True)}) | |
| elif action_name in ["create_branch", "delete_branch"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True)}) | |
| if action_name == "create_branch": | |
| visibility_map.update({"base": gr.Textbox.update(visible=True), "head": gr.Textbox.update(visible=True)}) | |
| elif action_name == "create_pull_request": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "title": gr.Textbox.update(visible=True), "body": gr.Textbox.update(visible=True), "base": gr.Textbox.update(visible=True), "head": gr.Textbox.update(visible=True)}) | |
| elif action_name == "create_issue": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "title": gr.Textbox.update(visible=True), "body": gr.Textbox.update(visible=True)}) | |
| elif action_name == "add_label_to_issue": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "issue_number": gr.Number.update(visible=True), "labels": gr.Textbox.update(visible=True)}) | |
| elif action_name in ["close_issue", "add_comment_to_issue", "get_issue_details", "edit_issue"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "issue_number": gr.Number.update(visible=True)}) | |
| if action_name == "add_comment_to_issue": | |
| visibility_map.update({"message": gr.Textbox.update(visible=True)}) | |
| if action_name == "edit_issue": | |
| visibility_map.update({"issue_title": gr.Textbox.update(visible=True), "issue_body": gr.Textbox.update(visible=True), "issue_state": gr.Dropdown.update(visible=True)}) | |
| elif action_name == "create_release": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "tag": gr.Textbox.update(visible=True), "release_name": gr.Textbox.update(visible=True), "message": gr.Textbox.update(visible=True)}) | |
| elif action_name == "fork_repository": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True)}) | |
| elif action_name in ["list_files", "get_repository_info", "analyze_repository_content"]: | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "owner": gr.Textbox.update(visible=True)}) | |
| elif action_name == "analyze_repository_by_url": | |
| visibility_map.update({"repo_url": gr.Textbox.update(visible=True)}) | |
| elif action_name == "update_repository_description": | |
| visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "new_description": gr.Textbox.update(visible=True)}) | |
| return [visibility_map.get(key, gr.Textbox.update(visible=False)) for key in visibility_map] | |
| output_components_visibility = [ | |
| repo_name, branch, path, content, message, owner, vcs_url, title, body, base, head, issue_number, labels, | |
| tag, release_name, file_url, repo_url, template_name, new_description, issue_title, issue_body, | |
| issue_state, diff, diff_message | |
| ] | |
| action.change( | |
| show_hide_input_fields, | |
| inputs=[action], | |
| outputs=output_components_visibility | |
| ) | |
| run_button.click( | |
| github_tool, | |
| inputs=input_components, | |
| outputs=output, | |
| api_name="github_tool" | |
| ) | |
| demo.launch() |