Initial commit

Author: wilf-phasecraft

.github/__init__.py

@@ -0,0 +1,207 @@
+import os
+import copy
+import re
+import shutil
+
+from bs4 import BeautifulSoup
+
+
+INDEX_FILE = "index.html"
+TEMPLATE_FILE = "pkg_template.html"
+YAML_ACTION_FILES = [".github/workflows/delete.yml", ".github/workflows/update.yml"]
+
+INDEX_CARD_HTML = '''
+<a class="card" href="">
+    placeholder_name
+    <span>
+    </span>
+    <span class="version">
+        placehholder_version
+    </span>
+    <br/>
+    <span class="description">
+        placeholder_description
+    </span>
+</a>'''
+
+
+def normalize(name):
+    """ From PEP503 : https://www.python.org/dev/peps/pep-0503/ """
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def normalize_version(version):
+    version = version.lower()
+    return version[1:] if version.startswith("v") else version
+
+
+def is_stable(version):
+    return not ("dev" in version or "a" in version or "b" in version or "rc" in version)
+
+
+def package_exists(soup, package_name):
+    package_ref = package_name + "/"
+    for anchor in soup.find_all('a'):
+        if anchor['href'] == package_ref:
+            return True
+    return False
+
+
+def transform_github_url(input_url):
+    # Split the input URL to extract relevant information
+    parts = input_url.rstrip('/').split('/')
+    username, repo = parts[-2], parts[-1]
+
+    # Create the raw GitHub content URL
+    raw_url = f'https://raw.githubusercontent.com/{username}/{repo}/main/README.md'
+    return raw_url
+
+
+def register(pkg_name, version, author, short_desc, homepage):
+    link = f'git+{homepage}@{version}'
+    long_desc = transform_github_url(homepage)
+    # Read our index first
+    with open(INDEX_FILE) as html_file:
+        soup = BeautifulSoup(html_file, "html.parser")
+    norm_pkg_name = normalize(pkg_name)
+    norm_version = normalize_version(version)
+
+    if package_exists(soup, norm_pkg_name):
+        raise ValueError(f"Package {norm_pkg_name} seems to already exists")
+
+    # Create a new anchor element for our new package
+    placeholder_card = BeautifulSoup(INDEX_CARD_HTML, 'html.parser')
+    placeholder_card = placeholder_card.find('a')
+    new_package = copy.copy(placeholder_card)
+    new_package['href'] = f"{norm_pkg_name}/"
+    new_package.contents[0].replace_with(pkg_name)
+    spans = new_package.find_all('span')
+    spans[1].string = norm_version  # First span contain the version
+    spans[2].string = short_desc    # Second span contain the short description
+
+    # Add it to our index and save it
+    soup.find('h6', class_='text-header').insert_after(new_package)
+    with open(INDEX_FILE, 'wb') as index:
+        index.write(soup.prettify("utf-8"))
+
+    # Then get the template, replace the content and write to the right place
+    with open(TEMPLATE_FILE) as temp_file:
+        template = temp_file.read()
+
+    template = template.replace("_package_name", pkg_name)
+    template = template.replace("_norm_version", norm_version)
+    template = template.replace("_version", version)
+    template = template.replace("_link", f"{link}#egg={norm_pkg_name}-{norm_version}")
+    template = template.replace("_homepage", homepage)
+    template = template.replace("_author", author)
+    template = template.replace("_long_description", long_desc)
+    template = template.replace("_latest_main", version)
+
+    os.mkdir(norm_pkg_name)
+    package_index = os.path.join(norm_pkg_name, INDEX_FILE)
+    with open(package_index, "w") as f:
+        f.write(template)
+
+
+def update(pkg_name, version):
+    # Read our index first
+    with open(INDEX_FILE) as html_file:
+        soup = BeautifulSoup(html_file, "html.parser")
+    norm_pkg_name = normalize(pkg_name)
+    norm_version = normalize_version(version)
+
+    if not package_exists(soup, norm_pkg_name):
+        raise ValueError(f"Package {norm_pkg_name} seems to not exists")
+
+    # Change the version in the main page (only if stable)
+    if is_stable(version):
+        anchor = soup.find('a', attrs={"href": f"{norm_pkg_name}/"})
+        spans = anchor.find_all('span')
+        spans[1].string = norm_version
+        with open(INDEX_FILE, 'wb') as index:
+            index.write(soup.prettify("utf-8"))
+
+    # Change the package page
+    index_file = os.path.join(norm_pkg_name, INDEX_FILE) 
+    with open(index_file) as html_file:
+        soup = BeautifulSoup(html_file, "html.parser")
+        
+    # Extract the URL from the onclick attribute
+    button = soup.find('button', id='repoHomepage')
+    if button:
+        link = button.get("onclick")[len("openLinkInNewTab('"):-2]
+    else:
+        raise Exception("Homepage URL not found")
+
+    # Create a new anchor element for our new version
+    original_div = soup.find('section', class_='versions').findAll('div')[-1]
+    new_div = copy.copy(original_div)
+    anchor = new_div.find('a')
+    new_div['onclick'] = f"load_readme('{version}', scroll_to_div=true);"
+    new_div['id'] = version
+    new_div['class'] = ""
+    if not is_stable(version):
+        new_div['class'] += "prerelease"
+    else:
+        # replace the latest main version
+        main_version_span = soup.find('span', id='latest-main-version')
+        main_version_span.string = version
+    anchor.string = norm_version
+    anchor['href'] = f"git+{link}@{version}#egg={norm_pkg_name}-{norm_version}"
+
+    # Add it to our index
+    original_div.insert_after(new_div)
+
+    # Change the latest version (if stable)
+    if is_stable(version):
+        soup.html.body.div.section.find_all('span')[1].contents[0].replace_with(version)
+
+    # Save it
+    with open(index_file, 'wb') as index:
+        index.write(soup.prettify("utf-8"))
+
+
+def delete(pkg_name):
+    # Read our index first
+    with open(INDEX_FILE) as html_file:
+        soup = BeautifulSoup(html_file, "html.parser")
+    norm_pkg_name = normalize(pkg_name)
+
+    if not package_exists(soup, norm_pkg_name):
+        raise ValueError(f"Package {norm_pkg_name} seems to not exists")
+
+    # Remove the package directory
+    shutil.rmtree(norm_pkg_name)
+
+    # Find and remove the anchor corresponding to our package
+    anchor = soup.find('a', attrs={"href": f"{norm_pkg_name}/"})
+    anchor.extract()
+    with open(INDEX_FILE, 'wb') as index:
+        index.write(soup.prettify("utf-8"))
+
+
+def main():
+    # Call the right method, with the right arguments
+    action = os.environ["PKG_ACTION"]
+
+    if action == "REGISTER":
+        register(
+            pkg_name=os.environ["PKG_NAME"],
+            version=os.environ["PKG_VERSION"],
+            author=os.environ["PKG_AUTHOR"],
+            short_desc=os.environ["PKG_SHORT_DESC"],
+            homepage=os.environ["PKG_HOMEPAGE"],
+        )
+    elif action == "DELETE":
+        delete(
+            pkg_name=os.environ["PKG_NAME"]
+        )
+    elif action == "UPDATE":
+        update(
+            pkg_name=os.environ["PKG_NAME"],
+            version=os.environ["PKG_VERSION"]
+        )
+
+
+if __name__ == "__main__":
+    main()

.github/actions.py

@@ -0,0 +1,109 @@
+import subprocess
+import os
+from importlib.metadata import PackageNotFoundError, version
+from contextlib import contextmanager
+
+
+@contextmanager
+def run_local_pypi_index():
+    # WARNING : This requires the script to be run from the root of the repo
+    p = subprocess.Popen(["python", "-m", "http.server"])
+    try:
+        yield
+    finally:
+        p.terminate()
+
+
+def exists(pkg_name: str) -> bool:
+    try:
+        version(pkg_name)
+    except PackageNotFoundError:
+        return False
+    else:
+        return True
+
+
+def pip_install(pkg_name: str, upgrade: bool = False, version: str = None):
+    package_to_install = pkg_name if version is None else f"{pkg_name}=={version}"
+    cmd = ["python", "-m", "pip", "install", package_to_install, "--upgrade" if upgrade else "", "--extra-index-url", "http://localhost:8000"]
+    subprocess.run([c for c in cmd if c])
+
+
+def pip_uninstall(pkg_name: str):
+    subprocess.run(["python", "-m", "pip", "uninstall", pkg_name, "-y"])
+
+
+def register(pkg_name: str, pkg_version: str, pkg_link: str):
+    env = os.environ.copy()
+    env["PKG_ACTION"] = "REGISTER"
+    env["PKG_NAME"] = pkg_name
+    env["PKG_VERSION"] = pkg_version
+    env["PKG_AUTHOR"] = "Dummy author"
+    env["PKG_SHORT_DESC"] = "Dummy Description"
+    env["PKG_HOMEPAGE"] = pkg_link
+    subprocess.run(["python", ".github/actions.py"], env=env)
+
+
+def update(pkg_name: str, pkg_version: str):
+    env = os.environ.copy()
+    env["PKG_ACTION"] = "UPDATE"
+    env["PKG_NAME"] = pkg_name
+    env["PKG_VERSION"] = pkg_version
+    subprocess.run(["python", ".github/actions.py"], env=env)
+
+
+def delete(pkg_name: str):
+    env = os.environ.copy()
+    env["PKG_ACTION"] = "DELETE"
+    env["PKG_NAME"] = pkg_name
+    subprocess.run(["python", ".github/actions.py"], env=env)
+
+
+def run_tests():
+    # This test is checking that the Github actions for registering, updating,
+    # and deleting are working and the PyPi index is updated accordingly.
+    # What we do is :
+    #  * Serve the HTML locally so we have a local PyPi index
+    #  * Run the actions for registering, updating, and deleting packages in
+    #    this local PyPi
+    #  * In-between, run some basic checks to see if the installation is
+    #    working properly
+    with run_local_pypi_index():
+        # First, make sure the package is not installed
+        assert not exists("public-hello")
+
+        # The package `public-hello` is already registered in our local PyPi
+        # ACTION : Let's remove it from our local PyPi
+        delete("public-hello")
+
+        # Trying to install the package, only the version uploaded to PyPi (0.0.0)
+        # will be detected and installed (the version in our local PyPi was
+        # successfully deleted)
+        pip_install("public-hello")
+        assert exists("public-hello") and version("public-hello") == "0.0.0"
+
+        # ACTION : Register the package, to make it available again
+        register("public-hello", "0.1", "https://github.com/astariul/public-hello")
+
+        # Now we can install it from the local PyPi
+        pip_install("public-hello", upgrade=True)
+        assert exists("public-hello") and version("public-hello") == "0.1"
+
+        # ACTION : Update the package with a new version
+        update("public-hello", "0.2")
+
+        # We can update the package to the newest version
+        pip_install("public-hello", upgrade=True)
+        assert exists("public-hello") and version("public-hello") == "0.2"
+
+        # We should still be able to install the old version
+        pip_install("public-hello", version="0.1")
+        assert exists("public-hello") and version("public-hello") == "0.1"
+
+        # Uninstall the package (for consistency with the initial state)
+        pip_uninstall("public-hello")
+        assert not exists("public-hello")
+
+
+if __name__ == "__main__":
+    run_tests()

.github/tests.py

@@ -0,0 +1,39 @@
+name: delete
+
+on:
+  workflow_dispatch:
+    inputs:
+      package_name:
+        description: Package name
+        required: true
+        type: string
+
+jobs:
+  delete:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Run Action
+      env:
+        PKG_ACTION: DELETE
+        PKG_NAME: ${{ inputs.package_name }}
+      run: |
+        pip install beautifulsoup4
+        python .github/actions.py 
+    - name: Create Pull Request
+      uses: peter-evans/create-pull-request@v3
+      with:
+        commit-message: ':package: [:robot:] Delete package from PyPi index'
+        title: '[🤖] Delete `${{ inputs.package_name }}` from PyPi index'
+        body: Automatically generated PR, deleting `${{ inputs.package_name }}` from
+          PyPi index.
+        branch-suffix: random
+        delete-branch: true