Update and install pre-commit hooks at creation

Author: sanders41

README.md

@@ -226,76 +226,8 @@ generating the project.
   `https://github.com/sanders41/python-project-generator`
 
 After running the generator a new directory will be created with the name you used for the
-`Project Slug`. Change to this directory then install the python packages and pre-commit hooks.
-
-### Pure Python Projects
-
-#### Install the Python dependencies when using Poetry.
-
-```sh
-poetry install
-```
-
-#### Install the Python dependencies when using setuptools.
-
-First create a virtual environment and activate it.
-
-```sh
-python -m venv .venv
-. .venv/bin/activate
-```
-
-```sh
-python -m pip install -r requirements-dev.txt
-```
-
-#### Install the Python dependencies when using uv.
-
-First create a virtual environment and activate it.
-
-```sh
-uv venv
-. .venv/bin/activate
-```
-
-Next create a lock file
-
-```sh
-uv lock
-```
-
-Then install the dependencies
-
-```sh
-uv sync --frozen
-```
-
-Install the pre-commit hooks.
-
-```sh
-pre-commit install
-```
-
-### PyO3 projects
-
-First create a virtual environment and activate it.
-
-```sh
-python -m venv .venv
-. .venv/bin/activate
-```
-
-Install the dependencies and build the rust module.
-
-```sh
-just install
-```
-
-Install the pre-commit hooks.
-
-```sh
-pre-commit install
-```
+`Project Slug`. Change to this directory and your project is ready to use. If the project is a
+PyO3 project the rust code will need to be compiled. Running `just install` will do this.
 
 ### FastAPI projects
 

src/dev_dependency_installer.rs

@@ -144,3 +144,187 @@ fn maturin_dev_dependency_installer(project_info: &ProjectInfo) -> Result<()> {
         bail!("No Python project manager provided for PyO3 project");
     }
 }
+
+pub fn update_precommit_hooks(project_info: &ProjectInfo) -> Result<()> {
+    match project_info.project_manager {
+        ProjectManager::Uv => uv_precommit_autoupdate(project_info)?,
+        ProjectManager::Poetry => poetry_precommit_autoupdate(project_info)?,
+        ProjectManager::Setuptools => setuptools_precommit_autoupdate(project_info)?,
+        ProjectManager::Pixi => pixi_precommit_autoupdate(project_info)?,
+        ProjectManager::Maturin => maturin_precommit_autoupdate(project_info)?,
+    };
+
+    Ok(())
+}
+
+fn uv_precommit_autoupdate(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("uv")
+        .args(["run", "pre-commit", "autoupdate"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to update pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn poetry_precommit_autoupdate(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("poetry")
+        .args(["run", "pre-commit", "autoupdate"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to update pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn setuptools_precommit_autoupdate(project_info: &ProjectInfo) -> Result<()> {
+    let base_dir = project_info.base_dir();
+    let venv_path = base_dir.join(".venv");
+
+    if !venv_path.exists() {
+        bail!("Virtual environment not found at {}", venv_path.display());
+    }
+
+    let precommit_bin = if cfg!(windows) {
+        venv_path.join("Scripts").join("pre-commit.exe")
+    } else {
+        venv_path.join("bin").join("pre-commit")
+    };
+
+    let output = std::process::Command::new(&precommit_bin)
+        .args(["autoupdate"])
+        .current_dir(base_dir)
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to update pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn pixi_precommit_autoupdate(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("pixi")
+        .args(["run", "pre-commit", "autoupdate"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to update pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn maturin_precommit_autoupdate(project_info: &ProjectInfo) -> Result<()> {
+    if let Some(pyo3_python_manager) = &project_info.pyo3_python_manager {
+        match pyo3_python_manager {
+            Pyo3PythonManager::Uv => uv_precommit_autoupdate(project_info),
+            Pyo3PythonManager::Setuptools => setuptools_precommit_autoupdate(project_info),
+        }
+    } else {
+        bail!("No Python project manager provided for PyO3 project");
+    }
+}
+
+pub fn install_precommit_hooks(project_info: &ProjectInfo) -> Result<()> {
+    match project_info.project_manager {
+        ProjectManager::Uv => uv_precommit_install(project_info)?,
+        ProjectManager::Poetry => poetry_precommit_install(project_info)?,
+        ProjectManager::Setuptools => setuptools_precommit_install(project_info)?,
+        ProjectManager::Pixi => pixi_precommit_install(project_info)?,
+        ProjectManager::Maturin => maturin_precommit_install(project_info)?,
+    };
+
+    Ok(())
+}
+
+fn uv_precommit_install(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("uv")
+        .args(["run", "pre-commit", "install"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to install pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn poetry_precommit_install(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("poetry")
+        .args(["run", "pre-commit", "install"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to install pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn setuptools_precommit_install(project_info: &ProjectInfo) -> Result<()> {
+    let base_dir = project_info.base_dir();
+    let venv_path = base_dir.join(".venv");
+
+    if !venv_path.exists() {
+        bail!("Virtual environment not found at {}", venv_path.display());
+    }
+
+    let precommit_bin = if cfg!(windows) {
+        venv_path.join("Scripts").join("pre-commit.exe")
+    } else {
+        venv_path.join("bin").join("pre-commit")
+    };
+
+    let output = std::process::Command::new(&precommit_bin)
+        .args(["install"])
+        .current_dir(base_dir)
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to install pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn pixi_precommit_install(project_info: &ProjectInfo) -> Result<()> {
+    let output = std::process::Command::new("pixi")
+        .args(["run", "pre-commit", "install"])
+        .current_dir(project_info.base_dir())
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Failed to install pre-commit hooks: {stderr}");
+    }
+
+    Ok(())
+}
+
+fn maturin_precommit_install(project_info: &ProjectInfo) -> Result<()> {
+    if let Some(pyo3_python_manager) = &project_info.pyo3_python_manager {
+        match pyo3_python_manager {
+            Pyo3PythonManager::Uv => uv_precommit_install(project_info),
+            Pyo3PythonManager::Setuptools => setuptools_precommit_install(project_info),
+        }
+    } else {
+        bail!("No Python project manager provided for PyO3 project");
+    }
+}

src/main.rs

@@ -25,7 +25,9 @@ use indicatif::{ProgressBar, ProgressStyle};
 use crate::{
     cli::{Args, BooleanChoice, Command, Param},
     config::Config,
-    dev_dependency_installer::install_dev_dependencies,
+    dev_dependency_installer::{
+        install_dev_dependencies, install_precommit_hooks, update_precommit_hooks,
+    },
     project_generator::generate_project,
     project_info::{get_project_info, ProjectInfo, ProjectManager},
     rust_files::cargo_add_pyo3,
@@ -48,6 +50,8 @@ fn create(project_info: &ProjectInfo) -> Result<()> {
     }
 
     install_dev_dependencies(project_info)?;
+    update_precommit_hooks(project_info)?;
+    install_precommit_hooks(project_info)?;
 
     #[cfg(feature = "fastapi")]
     if project_info.is_fastapi_project {

src/package_version.rs

@@ -1,7 +1,4 @@
-use std::{fmt, thread, time::Duration};
-
-use anyhow::{bail, Result};
-use exponential_backoff::Backoff;
+use std::fmt;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum PythonPackage {
@@ -53,68 +50,6 @@ impl fmt::Display for PreCommitHook {
     }
 }
 
-pub trait LatestVersion {
-    fn get_latest_version(&mut self) -> Result<()>;
-}
-
-#[derive(Debug)]
-pub struct PreCommitHookVersion {
-    pub hook: PreCommitHook,
-    pub repo: String,
-    pub rev: String,
-}
-
-impl LatestVersion for PreCommitHookVersion {
-    fn get_latest_version(&mut self) -> Result<()> {
-        let client = reqwest::blocking::Client::new();
-        let attempts = 3;
-        let min = Duration::from_millis(100); // 10ms
-        let max = Duration::from_secs(1);
-        let backoff = Backoff::new(attempts, min, max);
-        let api_url = format!(
-            "{}/releases",
-            self.repo
-                .replace("https://github.com", "https://api.github.com/repos")
-        );
-
-        for duration in backoff {
-            let response = client
-                .get(&api_url)
-                .header(reqwest::header::USER_AGENT, "python-project-generator")
-                .timeout(Duration::new(5, 0))
-                .send();
-
-            match response {
-                Ok(r) => {
-                    let result = r.text()?;
-                    let info: Vec<serde_json::Value> = serde_json::from_str(&result)?;
-                    for i in info {
-                        if i["draft"] == false && i["prerelease"] == false {
-                            self.rev = i["tag_name"].to_string().replace('"', "");
-                            break;
-                        }
-                    }
-
-                    return Ok(());
-                }
-                Err(e) => match duration {
-                    Some(duration) => thread::sleep(duration),
-                    None => bail!("{e}"),
-                },
-            }
-        }
-        bail!("Error retrieving latest version");
-    }
-}
-
-impl PreCommitHookVersion {
-    pub fn new(hook: PreCommitHook) -> Self {
-        let rev = default_pre_commit_rev(&hook);
-        let repo = pre_commit_repo(&hook);
-        PreCommitHookVersion { hook, repo, rev }
-    }
-}
-
 pub fn default_pre_commit_rev(hook: &PreCommitHook) -> String {
     match hook {
         PreCommitHook::MyPy => "v1.18.2".to_string(),