Initial Release

Author: dmoruzzi

.github/workflows/releases.yml

@@ -0,0 +1,32 @@
+name: Release binary
+
+on:
+  release:
+    types:
+      - created
+
+permissions:
+  contents: write
+  packages: write
+jobs:
+  build:
+    name: Release Go Binary
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        goos:
+          - linux
+          - windows
+        goarch:
+          - amd64
+          - arm64
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v3
+      - name: Setup go and release
+        uses: wangyoucao577/go-release-action@v1.49
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN  }}
+          goos: ${{ matrix.goos }}
+          goarch: ${{ matrix.goarch }}
+          md5sum: false

README.md

@@ -0,0 +1,77 @@
+# About
+
+This is a quick script to produce the available versions of Python in a JSON format.
+
+
+# Usage
+
+```
+Usage of ./py-versions:
+  -o string
+        Filename to save JSON output (optional; if not provided, output to console)
+  -url string
+        Python FTP Mirror URL (default "https://www.python.org/ftp/python/")
+```
+
+
+## Example Integration
+
+This can be combined with other scripts to alert when a new version is available. This is especially useful when working with embedded and compiled executables.
+
+```bash
+#!/bin/bash
+
+# Define constants
+ALERT_URL="https://api.example.com/v1/project-key"
+TOKEN="tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2"
+
+# Log function
+log() {
+    echo "$(date +"%Y-%m-%d %T") $1"
+}
+
+# Get the target version from the user input, defaulting to 3.9.19 if no input is provided
+if [ -z "$1" ]; then
+    target_version="3.9.19"
+else
+    target_version="$1"
+fi
+
+# Extract the minor version from the target version
+target_minor_version=$(echo "$target_version" | cut -d. -f1,2)
+
+# Get the latest version of Python
+version=$(./py-versions | grep -oP "(?<= \"$target_minor_version\":\{\"latest\":\")[^\"]+")
+
+if [[ -z "$version" ]]; then
+    log "Error: Failed to retrieve the latest version of Python."
+    exit 1
+fi
+
+# Check if the latest version has a different minor version
+if [[ "$version" =~ ^$target_minor_version\. ]]; then
+    # Prepare alert message
+    alert_message="There is a new version of Python $target_minor_version available: $version"
+    
+    # Send an alert with the version number using curl
+    response=$(curl -s -H "Authorization: Bearer $TOKEN" -d "$alert_message" "$ALERT_URL")
+    
+    # Check if alert was successfully sent
+    if [[ "$response" != "success" ]]; then
+        log "Error: Failed to send alert. Response: $response"
+        exit 1
+    fi
+
+    log "Alert sent successfully: $alert_message"
+else
+    log "No new version of Python $target_minor_version available."
+fi
+```
+
+The above could then be combined with cron jobs to alert when a new version is available through:
+
+```bash
+0 8 * * * /path/to/example-script.sh 3.9.19
+```
+
+The `3.9.19` argument is optional and defaults to `3.9.19` if not provided. The API endpoint may trigger an action, such as sending a Slack message or initating a new build with CI/CD pipelines.

go.mod

@@ -0,0 +1,3 @@
+module git.dmoruzzi.com/py-versions
+
+go 1.22.2

go.sum

@@ -0,0 +1,156 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+)
+
+type Version struct {
+	Major int `json:"major"`
+	Minor int `json:"minor"`
+	Patch int `json:"patch"`
+}
+
+func NewVersion(versionStr string) Version {
+	var major, minor, patch int
+	fmt.Sscanf(versionStr, "%d.%d.%d", &major, &minor, &patch)
+	return Version{Major: major, Minor: minor, Patch: patch}
+}
+
+func (v Version) String() string {
+	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
+}
+
+func (v Version) LessThan(other Version) bool {
+	if v.Major != other.Major {
+		return v.Major < other.Major
+	}
+	if v.Minor != other.Minor {
+		return v.Minor < other.Minor
+	}
+	return v.Patch < other.Patch
+}
+
+type Versions []Version
+
+func (v Versions) Len() int {
+	return len(v)
+}
+
+func (v Versions) Swap(i, j int) {
+	v[i], v[j] = v[j], v[i]
+}
+
+func (v Versions) Less(i, j int) bool {
+	return v[i].LessThan(v[j])
+}
+
+func fetchHTML(url string) (string, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	return string(body), nil
+}
+
+func extractVersions(html string) map[string]map[string]interface{} {
+	re := regexp.MustCompile(`href="(\d+\.\d+\.\d+)/"`) // e.g. href="3.9.0/"
+	matches := re.FindAllStringSubmatch(html, -1)
+	versions := make(map[string]map[string]interface{})
+
+	for _, match := range matches {
+		if len(match) == 2 {
+			version := NewVersion(match[1])
+			pyVersion := fmt.Sprintf("%d.%d", version.Major, version.Minor)
+
+			if _, ok := versions[pyVersion]; !ok {
+				versions[pyVersion] = make(map[string]interface{})
+				versions[pyVersion]["latest"] = ""
+				versions[pyVersion]["versions"] = []string{}
+			}
+
+			// Update latest version
+			latest := versions[pyVersion]["latest"].(string)
+			if latest == "" || compareVersions(match[1], latest) > 0 {
+				versions[pyVersion]["latest"] = match[1]
+			}
+
+			// Update versions list
+			versionsList := versions[pyVersion]["versions"].([]string)
+			versionsList = append(versionsList, match[1])
+			versions[pyVersion]["versions"] = versionsList
+		}
+	}
+
+	return versions
+}
+
+func compareVersions(v1, v2 string) int {
+	version1 := NewVersion(v1)
+	version2 := NewVersion(v2)
+
+	if version1.Major != version2.Major {
+		return version1.Major - version2.Major
+	}
+	if version1.Minor != version2.Minor {
+		return version1.Minor - version2.Minor
+	}
+	return version1.Patch - version2.Patch
+}
+
+func writeJSONFile(data interface{}, filename string) error {
+	if filename == "" {
+		encoder := json.NewEncoder(os.Stdout)
+		encoder.SetIndent("", "") // Disable indentation for console output
+		if err := encoder.Encode(data); err != nil {
+			return err
+		}
+	} else {
+		file, err := os.Create(filename)
+		if err != nil {
+			return err
+		}
+		defer file.Close()
+
+		encoder := json.NewEncoder(file)
+		encoder.SetIndent("", "  ")
+		if err := encoder.Encode(data); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func main() {
+	var url, jsonFilename string
+	flag.StringVar(&url, "url", "https://www.python.org/ftp/python/", "Python FTP Mirror URL")
+	flag.StringVar(&jsonFilename, "o", "", "Filename to save JSON output (optional; if not provided, output to console)")
+	flag.Parse()
+
+	html, err := fetchHTML(url)
+	if err != nil {
+		log.Fatalf("failed to fetch HTML: %v", err)
+	}
+
+	versions := extractVersions(html)
+	if err := writeJSONFile(versions, jsonFilename); err != nil {
+		log.Fatalf("failed to write JSON file: %v", err)
+	}
+}