Create the hlper script yoo

Author: 0x61nas

requirements.txt

@@ -0,0 +1,6 @@
+markdownify
+beautifulsoup4
+pytermgui
+lxml
+selenium
+requests

solve.py

@@ -0,0 +1,121 @@
+import os # For getting the current working directory and making directories
+import sys # For getting command line arguments
+from enum import Enum # For the enum class
+from selenium import webdriver # For getting the HTML of the problem
+import requests # For downloading images
+from bs4 import BeautifulSoup # For parsing HTML
+import markdownify as md # For converting HTML to Markdown
+sys.path.append("utils") # Add the utils directory to the path
+import pytermgui_tui as tui # Import the TUI
+from data import Data # Import the Data class
+from projcets_helpers import * # Import the projects creation methods
+
+BASE_URL = "https://leetcode.com/problems/" # The base URL of the problem
+
+BASE_URL = BASE_URL + "merge-two-sorted-lists" # The URL of the problem for testing
+
+# Stup the tui
+tui.setup()
+
+# Check if user provided a URL as an argument
+if len(sys.argv) < 2:
+    # If not, ask for one
+    problem_url = tui.get_the_url(BASE_URL)
+else:
+    # If so, use it
+    problem_url = sys.argv[1]
+    # Check if user provided a problem title instead of a URL, if so, add the base URL
+    if not problem_url.startswith(BASE_URL) and not problem_url.startswith("http"):
+        problem_url = BASE_URL + problem_url
+
+# Check if the URL is valid
+if not problem_url.startswith(BASE_URL):
+    print("Invalid URL, please enter a valid URL(LeeCode problem URL)")
+    exit(1)
+
+# Setup the driver (firefox)
+driver = webdriver.Firefox()
+
+driver.get(problem_url) # Open the URL in the browser
+
+soup = BeautifulSoup(driver.page_source, "lxml") # Parse the HTML
+
+driver.quit() # Close the driver
+
+# Get the main div (the problem details are in this div)
+main_div = soup.find("div", {"class": "ssg__qd-splitter-primary-w"}).find("div", {"class": "ssg__qd-splitter-primary-h"})
+
+# Get the title of the problem
+title = soup.title.string.lower().replace(" - leetcode", "").replace(" ", "_")
+
+level = main_div.find("div", {"class": "mt-3 flex space-x-4"}).find("div", {"class": "py-1"}).text.lower()
+
+# Check if the level directory exists, if not, create it
+if not os.path.exists(level):
+    os.mkdir(level)
+
+# Check if the problem directory exists, if not, create it
+problem_path = os.path.join(level, title)
+if not os.path.exists(problem_path):
+    os.mkdir(problem_path)
+
+# Get the description of the problem
+discription = main_div.find("div", {"class": "_1l1MA"})
+
+# Show the tui for confirm the data and choose the language to solve the problem
+data = tui.confirm_data(Data(title, level, problem_path))
+
+# Download the images if there are any
+for img in discription.find_all("img"):
+    src = img["src"]
+    req = requests.get(src)
+    if req.status_code == 200:
+        img_name = src.split("/")[-1]
+        img_path = os.path.join(data.problem_path, "images", img_name)
+        if not os.path.exists(img_path):
+            if not os.path.exists(os.path.dirname(img_path)):
+                os.makedirs(os.path.dirname(img_path))
+            with open(img_path, "wb") as f:
+                f.write(req.content)
+        img["src"] = img_path.replace(data.problem_path, ".")
+
+# Convert the discription to Markdown
+discription = md.markdownify(str(discription), heading_style="ATX")
+
+# Add the title to the discription
+discription = "# " + data.title.capitalize().replace("_", " ") + "\n" + discription
+
+# Add the problem URL to the discription
+discription = discription + "\n- [Problem URL](" + problem_url + ")"
+
+# Write the discription to the README.md file, if it doesn't exist
+if not os.path.exists(os.path.join(data.problem_path, "README.md")):
+    with open(os.path.join(data.problem_path, "README.md"), "w") as f:
+        f.write(discription)
+
+# Create the NOTE.md file, if it doesn't exist
+if not os.path.exists(os.path.join(data.problem_path, "NOTE.md")):
+    with open(os.path.join(data.problem_path, "NOTE.md"), "w") as f:
+        f.write("## There is no note for this problem yet ¯⁠⁠⁠\(⁠ツ⁠)⁠⁠/⁠¯")
+
+# Create the solution project for each language
+for lang in data.solve_with:
+    lang_path = os.path.join(data.problem_path, lang)
+    if not os.path.exists(lang_path):
+        os.mkdir(lang_path)
+    match lang:
+        case "python" | "py":
+            create_python_project(lang_path)
+        case "java":
+            create_java_project(lang_path)
+        case "c++" | "cpp":
+            create_cpp_project(lang_path)
+        case "c":
+            create_c_project(lang_path)
+        case "rust":
+            create_rust_project(lang_path)
+        case "go":
+            create_go_project(lang_path)
+        case _: # If other language, do nothing
+            pass
+

utils/data.py

@@ -0,0 +1,9 @@
+class Data:
+    def __init__(self, title: str, level: str, problem_path: str, solve_with: list = None):
+        self.title = title
+        self.level = level
+        self.problem_path = problem_path
+        self.solve_with = solve_with
+    
+    def __str__(self) -> str:
+        return f"Title: {self.title} | Level: {self.level} | Path: {self.problem_path} | Solve with: {self.solve_with}"

utils/projcets_helpers.py

@@ -0,0 +1,87 @@
+import subprocess
+from os import sep, mkdir, chdir
+
+def run(command: str, path: str = None) -> bool:
+    """ Run a command  utility"""
+    # Go to the directory of the project if there is one
+    if path:
+        chdir(path)
+    result = subprocess.run(command.split(' '), capture_output=True)
+    print(result.stdout.decode('utf-8'))
+
+    # Go back to the root directory of the project
+    if path:
+        chdir(sep.join(__file__.split(sep)[:-2]))
+    
+    # Print the error if there is one
+    if result.stderr:
+        print(f"There was an error while running the command: {command}")
+        print(result.stderr.decode('utf-8'))
+
+    return result.returncode == 0
+
+def create_rust_project(path: str) -> None:
+    """ Create a rust project """
+    run(f"cargo new --vcs none --lib {path}")
+
+def create_c_project(path: str) -> None:
+    """ Create a c project """
+    run(f"touch {path}/main.c")
+    run(f"touch {path}/Makefile")
+    run(f"touch {path}/.gitignore")
+
+def create_python_project(path: str) -> None:
+    """ Create a python project """
+    run(f"touch {path}/main.py")
+    with open(f"{path}/test.py", "w") as f:
+        f.write("import unittest\n")
+        f.write("from main import *\n\n")
+        f.write("class Test(unittest.TestCase):\n")
+        f.write("\t def test(self):\n")
+        f.write("\t\t self.assertEqual(True, True)\n\n")
+        f.write("if __name__ == '__main__':\n")
+        f.write("\t unittest.main()\n")
+
+def create_java_project(path: str) -> None:
+    if not run(f"mvn archetype:generate \
+    -DarchetypeGroupId=org.apache.maven.archetypes \
+    -DarchetypeArtifactId=maven-archetype-quickstart \
+    -DarchetypeVersion=1.4 \
+    -DgroupId=com.anas.leetcode.{path.split(sep)[-2]} \
+    -DartifactId={path.split(sep)[-2]} \
+    -Dversion=1.0-SNAPSHOT"):
+        print("Failed to create java project")
+        return
+
+def create_cpp_project(path: str) -> None:
+    with open(f"{path}/main.cpp", "w") as f:
+        f.write("#include <iostream>\n\n")
+        f.write("using namespace std;\n\n")
+    
+    with open(f"{path}/test.cpp", "w") as f:
+        f.write("#include <catch2/catch.hpp>\n")
+        f.write("#include \"main.cpp\"\n\n")
+
+    with open(f"{path}/Makefile", "w") as f:
+        f.write("all: main.cpp test.cpp\n")
+        f.write("\t g++ -o main main.cpp\n")
+        f.write("\t g++ -o test test.cpp -I /usr/local/include -L /usr/local/lib -lcatch2\n")
+        f.write("\t ./test\n")
+
+def create_go_project(path: str) -> None:
+    if run(f"go mod init letcode/{path.split(sep)[-2]}", path):
+        mkdir(f"{path}/src")
+        with open(f"{path}/src/main.go", "w") as f:
+            f.write("package main\n\n")
+            f.write("import \"fmt\"\n\n")
+            f.write("func main() {\n")
+            f.write("\t fmt.Println(\"Hello, World!\")\n")
+            f.write("}\n")
+    
+        with open(f"{path}/src/_test.go", "w") as f:
+            f.write("package main\n\n")
+            f.write("import \"testing\"\n\n")
+            f.write("func TestHello(t *testing.T) {\n")
+            f.write("\t fmt.Println(\"Hello, World!\")\n")
+            f.write("}\n")
+

utils/pytermgui_tui.py

@@ -0,0 +1,86 @@
+import pytermgui as ptg
+from data import Data
+
+CONFIG = """
+config:
+    InputField:
+        styles:
+            prompt: dim italic
+            cursor: '@72'
+    Label:
+        styles:
+            value: dim bold
+
+    Window:
+        styles:
+            border: '60'
+            corner: '60'
+
+    Container:
+        styles:
+            border: '96'
+            corner: '96'
+"""
+
+problem_url = ""  # The URL of the problem
+
+def setup() -> None:
+    """ 
+    Stup the pytermgui 
+    load the config styles
+    """
+    with ptg.YamlLoader() as loader:
+        loader.load(CONFIG)
+
+def submit_url(manager: ptg.WindowManager, window: ptg.Window) -> None:
+    """Submit the URL of the problem"""
+    global problem_url
+    for widget in window:
+        if isinstance(widget, ptg.InputField):
+            problem_url = widget.value
+            break
+    manager.stop()
+
+def get_the_url(base_url: str) -> str:
+    """ Show the tui using the pytermgui for enter the URL of the problem """
+    with ptg.WindowManager() as wm:
+        wm.layout.add_slot("Body")
+        window = (
+            ptg.Window(
+                "",
+                ptg.InputField(base_url, prompt="URL: "),
+                "",
+                ["Submit", lambda *_: submit_url(wm, window)],
+                width=60,
+                box="DOUBLE",
+            )
+            .set_title("[green bold]Enter the URL of the problem")
+            .center()
+        )
+        wm.add(window)
+        wm.run()
+    return problem_url
+
+def confirm_data(data: Data) -> Data:
+    """ Show the tui using the pytermgui for confirm the data and choose the language to solve the problem """
+    with ptg.WindowManager() as wm:
+        wm.layout.add_slot("Body")
+        window = (
+            ptg.Window(
+                "",
+                ptg.InputField(data.title, prompt="Title: "),
+                ptg.InputField(data.level, prompt="Level: "),
+                ptg.InputField(data.problem_path, prompt="Base path:"),
+                "",
+                ["Confirm", lambda *_: wm.stop()],
+                width=60,
+                box="DOUBLE",
+            )
+            .set_title("[green bold]Confirm the data")
+            .center()
+        )
+        wm.add(window)
+        wm.run()
+    
+    data.solve_with = ["python", "java", "c++", "c", "go"]
+    return data

utils/tui.py

@@ -0,0 +1,13 @@
+import zope.interface
+from data import Data
+
+class ITextUserInterface(zope.interface.Interface):
+    def setup(self) -> None:
+        """Stup the tui"""
+        pass
+    def get_the_url(self, base_url: str) -> str:
+        """Show the tui for enter the URL of the problem"""
+        pass
+    def confirm_data(self, data: Data) -> Data:
+        """Show the tui for confirm the data and choose the language to solve the problem"""
+        pass