leanup 0.0.2__tar.gz → 0.0.3__tar.gz

{leanup-0.0.2 → leanup-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leanup
-Version: 0.0.2
+Version: 0.0.3
 Summary: Python package for Lean Environment Management
 Author-email: Lean-zh Community <leanprover@outlook.com>
 Maintainer-email: Lean-zh Community <leanprover@outlook.com>
@@ -10,6 +10,11 @@ Project-URL: changelog, https://github.com/{{ cookiecutter.github_username }}/{{
 Project-URL: homepage, https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: gitpython
+Requires-Dist: psutil
+Requires-Dist: click
+Requires-Dist: platformdirs
+Requires-Dist: loguru
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
@@ -23,8 +28,8 @@ Dynamic: license-file
     <a href="https://pypi.python.org/pypi/leanup">
         <img src="https://img.shields.io/pypi/v/leanup.svg" alt="PyPI version" />
     </a>
-    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml">
-        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml/badge.svg" alt="Tests" />
+    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml">
+        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml/badge.svg" alt="Tests" />
     </a>
     <a href="https://codecov.io/gh/Lean-zh/leanup">
         <img src="https://codecov.io/gh/Lean-zh/leanup/branch/main/graph/badge.svg" alt="Coverage" />

{leanup-0.0.2 → leanup-0.0.3}/README.md

@@ -4,8 +4,8 @@
     <a href="https://pypi.python.org/pypi/leanup">
         <img src="https://img.shields.io/pypi/v/leanup.svg" alt="PyPI version" />
     </a>
-    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml">
-        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml/badge.svg" alt="Tests" />
+    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml">
+        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml/badge.svg" alt="Tests" />
     </a>
     <a href="https://codecov.io/gh/Lean-zh/leanup">
         <img src="https://codecov.io/gh/Lean-zh/leanup/branch/main/graph/badge.svg" alt="Coverage" />

{leanup-0.0.2/build/lib/build/lib → leanup-0.0.3}/leanup/__init__.py

@@ -2,4 +2,6 @@
 
 __author__ = """Lean-zh Community"""
 __email__ = 'leanprover@outlook.com'
-__version__ = '0.0.2'
+__version__ = '0.0.3'
+
+from leanup.utils import CommandExecutor

leanup-0.0.3/leanup/cli.py

@@ -0,0 +1,12 @@
+import click
+
+@click.group()
+def main():
+    """A command-line interface for LeanUp."""
+    pass
+
+@main.group()
+def repo():
+    """Manage Lean repo installations"""
+    pass
+

leanup-0.0.3/leanup/const.py

@@ -0,0 +1,15 @@
+import os
+import platform
+import platformdirs
+from pathlib import Path
+
+OS_TYPE = None
+if platform.system() == 'Windows':
+    OS_TYPE = 'Windows'
+elif platform.system() == 'Darwin':
+    OS_TYPE = 'MacOS'
+elif platform.system() == 'Linux':
+    OS_TYPE = 'Linux'
+
+LEANUP_CACHE_DIR = Path(
+    os.getenv('LEANUP_CACHE_DIR', platformdirs.user_cache_dir("leanup")))

leanup-0.0.3/leanup/utils/__init__.py

@@ -0,0 +1 @@
+from leanup.utils.executor import CommandExecutor

leanup-0.0.3/leanup/utils/executor.py

@@ -0,0 +1,183 @@
+import subprocess
+import os
+from pathlib import Path
+import tempfile
+from contextlib import contextmanager
+from typing import Optional, Union, Tuple, List, Dict, Any, Generator
+import git
+from psutil import Process, NoSuchProcess
+import logging
+
+logger = logging.getLogger(__name__)
+
+class CommandExecutor:
+    def __init__(self, cwd: Optional[str] = None, timeout: Optional[int] = None):
+        """
+        Initialize command executor
+        
+        Args:
+            cwd: Default working directory
+            timeout: Default timeout for commands
+        """
+        self.cwd = cwd
+        self.timeout = timeout
+        self.active_processes = []  # Track active processes
+    
+    @contextmanager
+    def working_directory(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        chdir: bool = False,
+    ) -> Generator[Path, None, None]:
+        """
+        Context manager for working directory operations
+        
+        Args:
+            path: Target working directory path. If None, creates a temporary directory
+            chdir: Whether to actually change the current working directory
+            
+        Yields:
+            Path object representing working directory
+        """
+        origin = Path.cwd()
+        if path is None: # Create temporary directory
+            tmp_dir = tempfile.TemporaryDirectory()
+            path = tmp_dir.__enter__()
+            is_temporary = True
+        else:
+            is_temporary = False
+            
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+            
+        if chdir: os.chdir(path)
+        try:
+            yield path
+        finally:
+            if chdir: os.chdir(origin)
+            if is_temporary:
+                tmp_dir.__exit__(None, None, None)
+
+    def execute_in_directory(self, command: list, 
+                           directory: Optional[Union[str, Path]] = None,
+                           chdir: bool = False,
+                           **kwargs) -> Tuple[str, str, int]:
+        """
+        Execute command in specified directory using context manager
+        
+        Args:
+            command: Command list to execute
+            directory: Target directory for execution
+            chdir: Whether to change working directory
+            **kwargs: Additional arguments passed to execute()
+            
+        Returns:
+            Tuple containing (stdout, stderr, return_code)
+        """
+        with self.working_directory(directory, chdir=chdir) as work_dir:
+            return self.execute(command, cwd=str(work_dir), **kwargs)
+
+    def execute(self, command: list,
+            cwd: Optional[str] = None, 
+            text: bool = True,
+            input: Union[str, None] = None,
+            capture_output: bool = True,
+            timeout: Optional[int] = None) -> Tuple[str, str, int]:
+        """
+        Execute command and capture output
+        
+        Args:
+            command: Command list to execute
+            cwd: Working directory for command execution
+            text: Whether to use text mode
+            input: Input to pass to command
+            capture_output: Whether to capture command output
+            timeout: Command execution timeout in seconds
+            
+        Returns:
+            Tuple containing (stdout, stderr, return_code)
+        """
+        working_dir = cwd or self.cwd
+        self.active_processes = []
+        timeout = timeout if timeout is not None else self.timeout
+        
+        try:
+            # Configure output pipes
+            stdout_pipe = subprocess.PIPE if capture_output else None
+            stderr_pipe = subprocess.PIPE if capture_output else None
+            
+            # Create and start process
+            proc = subprocess.Popen(
+                command,
+                cwd=working_dir,
+                stdout=stdout_pipe,
+                stderr=stderr_pipe,
+                text=text
+            )
+            
+            # Track process and its children
+            main_pid = proc.pid
+            self.active_processes = self._get_process_children(main_pid) + [Process(main_pid)]
+            
+            # Wait for completion and get output
+            proc_output, proc_error = proc.communicate(input=input, timeout=timeout)
+            exit_code = proc.returncode
+            
+            # Ensure output strings are not None
+            command_output = proc_output or ""
+            error_output = proc_error or ""
+            
+        except Exception as e:
+            # Handle execution errors
+            command_output, error_output, exit_code = "", str(e), -1
+        finally:
+            # Always cleanup processes
+            self._cleanup_processes()
+        return command_output, error_output, exit_code
+
+    def _get_process_children(self, pid: int) -> List[Process]:
+        """
+        Get child processes for given PID
+        
+        Args:
+            pid: Parent process ID
+            
+        Returns:
+            List of child processes
+        """
+        try:
+            parent_process = Process(pid)
+            return parent_process.children(recursive=True)
+        except NoSuchProcess:
+            return []
+    
+    def _cleanup_processes(self):
+        """
+        Clean up all tracked processes
+        Attempts to terminate processes gracefully
+        """
+        for process in self.active_processes:
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except Exception as e:
+                if not isinstance(e, NoSuchProcess):
+                    logger.debug(f"Failed to terminate process {process}: {e}")
+    
+    # Git operations
+    def git_clone(self, repo_url: str, target_dir: Optional[str] = None) -> Tuple[bool, str]:
+        """
+        Clone a git repository
+        
+        Args:
+            repo_url: Repository URL to clone
+            target_dir: Target directory for clone
+            
+        Returns:
+            Tuple of (success_status, error_message)
+        """
+        try:
+            git.Repo.clone_from(repo_url, target_dir or os.path.basename(repo_url.split('/')[-1].split('.')[0]))
+            return True, ""
+        except Exception as e:
+            return False, str(e)

{leanup-0.0.2 → leanup-0.0.3}/leanup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leanup
-Version: 0.0.2
+Version: 0.0.3
 Summary: Python package for Lean Environment Management
 Author-email: Lean-zh Community <leanprover@outlook.com>
 Maintainer-email: Lean-zh Community <leanprover@outlook.com>
@@ -10,6 +10,11 @@ Project-URL: changelog, https://github.com/{{ cookiecutter.github_username }}/{{
 Project-URL: homepage, https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: gitpython
+Requires-Dist: psutil
+Requires-Dist: click
+Requires-Dist: platformdirs
+Requires-Dist: loguru
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
@@ -23,8 +28,8 @@ Dynamic: license-file
     <a href="https://pypi.python.org/pypi/leanup">
         <img src="https://img.shields.io/pypi/v/leanup.svg" alt="PyPI version" />
     </a>
-    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml">
-        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yml/badge.svg" alt="Tests" />
+    <a href="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml">
+        <img src="https://github.com/Lean-zh/leanup/actions/workflows/ci.yaml/badge.svg" alt="Tests" />
     </a>
     <a href="https://codecov.io/gh/Lean-zh/leanup">
         <img src="https://codecov.io/gh/Lean-zh/leanup/branch/main/graph/badge.svg" alt="Coverage" />

leanup-0.0.3/leanup.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+README.md
+pyproject.toml
+./leanup/__init__.py
+./leanup/cli.py
+./leanup/const.py
+./leanup/leanup.py
+./leanup/utils/__init__.py
+./leanup/utils/executor.py
+./tests/__init__.py
+./tests/conftest.py
+./tests/test_executor.py
+./tests/test_leanup.py
+leanup/__init__.py
+leanup/cli.py
+leanup/const.py
+leanup/leanup.py
+leanup.egg-info/PKG-INFO
+leanup.egg-info/SOURCES.txt
+leanup.egg-info/dependency_links.txt
+leanup.egg-info/entry_points.txt
+leanup.egg-info/requires.txt
+leanup.egg-info/top_level.txt
+leanup/utils/__init__.py
+leanup/utils/executor.py
+tests/__init__.py
+tests/conftest.py
+tests/test_executor.py
+tests/test_leanup.py

leanup-0.0.3/leanup.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leanup = leanup.cli:main

leanup-0.0.3/leanup.egg-info/requires.txt

@@ -0,0 +1,11 @@
+gitpython
+psutil
+click
+platformdirs
+loguru
+
+[dev]
+coverage
+mypy
+pytest
+ruff

{leanup-0.0.2 → leanup-0.0.3}/leanup.egg-info/top_level.txt

@@ -1,4 +1,3 @@
-build
 dist
 leanup
 tests

{leanup-0.0.2 → leanup-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "leanup"
-version = "0.0.2"
+version = "0.0.3"
 description = "Python package for Lean Environment Management"
 readme = "README.md"
 authors = [
@@ -18,7 +18,11 @@ classifiers = [
 ]
 license = {text = "MIT license"}
 dependencies = [
-  
+  "gitpython",
+  "psutil",  # Process management
+  "click",  # Command line interface
+  "platformdirs",  # Platform-specific directories
+  "loguru",  # Logging
 ]
 
 [project.optional-dependencies]
@@ -29,6 +33,9 @@ dev = [
     "ruff"  # linting
 ]
 
+[project.scripts]
+leanup = "leanup.cli:main"
+
 [project.urls]
 
 bugs = "https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}/issues"

leanup-0.0.3/tests/conftest.py

@@ -0,0 +1,22 @@
+import tempfile
+import pytest
+from pathlib import Path
+from leanup.const import LEANUP_CACHE_DIR
+from leanup.utils import CommandExecutor
+
+
+@pytest.fixture
+def cache_dir():
+    """Fixture to provide the LeanUp cache directory."""
+    return LEANUP_CACHE_DIR
+
+@pytest.fixture
+def executor():
+    """Create a CommandExecutor instance for testing"""
+    return CommandExecutor()
+
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory for testing"""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        yield Path(tmp_dir)

leanup-0.0.3/tests/test_executor.py

@@ -0,0 +1,88 @@
+import os
+import pytest
+from pathlib import Path
+import tempfile
+from leanup.const import OS_TYPE
+from leanup.utils.executor import CommandExecutor
+
+def test_basic_execute(executor:CommandExecutor):
+    """Test basic command execution"""
+    cmd = ['echo', 'hello']
+    
+    output, error, code = executor.execute(cmd)
+    assert code == 0
+    assert 'hello' in output
+    assert error == ''
+
+def test_execute_with_error(executor:CommandExecutor):
+    """Test command execution with error"""
+    if OS_TYPE == 'Windows':
+        cmd = ['dir', '/invalid_path']
+    else:
+        cmd = ['ls', '/nonexistent_directory']
+    
+    output, error, code = executor.execute(cmd)
+    assert code != 0
+    assert error != ''
+
+def test_working_directory(executor:CommandExecutor, temp_dir:Path):
+    """Test working directory context manager"""
+    test_file = temp_dir / 'test.txt'
+    test_file.write_text('test content')
+
+    with executor.working_directory(temp_dir, chdir=True):
+        if OS_TYPE == 'Windows':
+            cmd = ['dir']
+        else:
+            cmd = ['ls']
+        output, error, code = executor.execute(cmd)
+        assert code == 0
+        assert 'test.txt' in output
+
+def test_execute_in_directory(executor:CommandExecutor, temp_dir:Path):
+    """Test execute_in_directory method"""
+    test_file = temp_dir / 'test.txt'
+    test_file.write_text('test content')
+
+    if OS_TYPE == 'Windows':
+        cmd = ['dir']
+    else:
+        cmd = ['ls']
+    
+    output, error, code = executor.execute_in_directory(cmd, directory=temp_dir)
+    assert code == 0
+    assert 'test.txt' in output
+
+def test_timeout(executor:CommandExecutor):
+    """Test command execution with timeout"""
+    if OS_TYPE == 'Windows':
+        cmd = ['timeout', '10']
+    else:
+        cmd = ['sleep', '10']
+    
+    output, error, code = executor.execute(cmd, timeout=1)
+    assert code != 0
+
+
+def test_multiple_commands(executor:CommandExecutor):
+    """Test executing multiple commands sequentially"""
+    commands = []
+    if OS_TYPE == 'Windows':
+        commands = [
+            ['echo', 'first'],
+            ['echo', 'second'],
+        ]
+    else:
+        commands = [
+            ['echo', 'first'],
+            ['echo', 'second'],
+        ]
+    
+    results = []
+    for cmd in commands:
+        output, error, code = executor.execute(cmd)
+        results.append((output, code))
+    
+    assert all(code == 0 for _, code in results)
+    assert 'first' in results[0][0]
+    assert 'second' in results[1][0]

leanup-0.0.3/tests/test_leanup.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+"""Tests for `leanup` package."""
+
+import pytest
+from leanup.const import LEANUP_CACHE_DIR, OS_TYPE
+
+def test_leanup_basic():
+    """Test if the package can be imported."""
+    from leanup import __version__
+    print(f"LeanUp version: {__version__}")
+    print(f"LeanUp cache directory: {LEANUP_CACHE_DIR}")
+
+def test_system():
+    """Test if the computer system is recognized."""
+    assert OS_TYPE in ['Windows', 'MacOS', 'Linux'], f"Unexpected OS_TYPE: {OS_TYPE}"
+

leanup-0.0.2/build/lib/build/lib/cli/__init__.py

@@ -1,15 +0,0 @@
-from .install import (
-    install_repl, install_lean_repo, install_lean, install_mathlib, get_valid_versions
-)
-from .utils import (
-    list_lookeng_cache, list_mathlib_cache, list_repo_cache,
-    read_lookeng_cache, read_mathlib_cache, read_repo_cache,
-    get_lookeng_versions, get_mathlib_versions
-)
-
-
-help_message = """
-Lean Repo management CLI
-
-A tool for managing Lean repositories.
-"""

leanup-0.0.2/build/lib/build/lib/cli/install.py

@@ -1,143 +0,0 @@
-from lookeng.utils import working_directory, execute_command, execute_popen_command
-from lookeng.constants import MATHLIB_URL
-from lookeng import constants
-import os
-import toml, subprocess, shutil, re
-from pathlib import Path
-from typing import Tuple, Optional, List
-from loguru import logger
-from git import Repo, BadName
-from .utils import (
-    url_to_repo_name, install_lean, get_valid_versions, get_tag_sha,
-    detect_lakefile, update_lakefile_toml, update_lakefile_lean, url_to_prefix
-)
-
-class InstallationError(Exception):
-    pass
-
-def install_lean_repo(url:str, version: str,
-                      prefix:Optional[str]=None,
-                      force: bool = False, 
-                      dest_dir: Optional[str] = None,
-                      with_mathlib:bool=False,
-                      build_cmds:Optional[list[str]]=None) -> Path:
-    """
-    Download and build Lean 4 Repo.
-    
-    Args:
-        url: Lean repository URL
-        version: Lean tag (e.g. 'v4.10.0')
-        prefix: Prefix for the installation directory, extract from url by default
-        force: If True, overwrite existing installation
-        dest_dir: Custom installation directory
-        build_cmds: List of build commands to run
-        
-    Returns:
-        Path: Installation directory path
-        
-    Raises:
-        InstallationError: If installation fails
-    """
-    # make sure `elan`` is installed
-    if shutil.which('lake') is None:
-        install_lean()
-        os.environ['PATH'] += os.pathsep + os.path.expanduser('~/.elan/bin')
-    # default build commands
-    if build_cmds is None:
-        build_cmds = ['lake update -R', 'lake build']
-    # Setup paths
-    dest_dir = dest_dir and Path(dest_dir).resolve()
-    if dest_dir is not None and not force and dest_dir.exists():
-        logger.info(f"Destination directory {dest_dir} already exists")
-        return dest_dir
-
-    # Check existing cache
-    username, repo_name = url_to_repo_name(url)
-    prefix = prefix or url_to_prefix(url)
-    cache_dir = Path(constants.LOOKENG_CACHE_DIR)
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    cache_path = cache_dir / f"{prefix}-{version}"
-    
-    if cache_path.exists() and not force:
-        logger.info(f"Version {version} already installed at {cache_path}")
-        if dest_dir is not None:
-            _, err, code = execute_command(["cp", "-r", cache_path, dest_dir])
-            if code != 0:
-                raise InstallationError(f"Failed to copy cache to destination directory: {err}")
-            return dest_dir
-        return cache_path
-    
-    work_dir = dest_dir and dest_dir.parent # set None if not specified
-    with working_directory(work_dir, chdir=True) as work_dir:
-        if dest_dir is None: # use temp dir
-            repo_path = Path(work_dir) / f"{prefix}-{version}"
-            logger.debug(f"Working in temporary directory: {work_dir}")
-        else:
-            repo_path = dest_dir
-            logger.debug(f"Working in directory: {work_dir}")
-            if repo_path.exists(): # remove existing directory
-                shutil.rmtree(repo_path)
-        cache_repo_base = cache_dir / url_to_prefix(url) # track the latest repo
-        # Create new repo
-        try:
-            if not (version in get_valid_versions(url, update=False) or version in get_valid_versions(url, update=False)):
-                raise InstallationError(f"Unknown version: {version}")
-            Repo.clone_from(str(cache_repo_base), repo_path, branch=version)
-        except BadName:
-            raise InstallationError(f"Version {version} not found in repository")
-        if with_mathlib and repo_name not in ['mathlib', 'mathlib4']:
-            # update lakefile
-            lakefile, file_type = detect_lakefile(repo_path)
-            mathlib_rev = get_tag_sha(MATHLIB_URL, version)
-            logger.debug(f"Detected {file_type} lakefile at {lakefile}")
-            if file_type == 'toml':
-                update_lakefile_toml(lakefile, mathlib_rev)
-            else:
-                update_lakefile_lean(lakefile, version)
-        for cmd in build_cmds:
-            logger.info(f"Running command: {cmd}")
-            _, err, code = execute_command(cmd.split(), cwd=repo_path, capture_output=False)
-            if code != 0:
-                raise InstallationError(f"Failed to run {cmd}: {err}")
-
-        # Save to cache
-        if cache_path.exists():
-            shutil.rmtree(cache_path)
-        logger.debug(f"Saving installation to cache: {cache_path}")
-        _, err, code = execute_command(["mv", repo_path, cache_path])
-        if code != 0:
-            raise InstallationError(f"Failed to save installation to cache: {err}")
-    if dest_dir is None:
-        repo_path = cache_path # return the cache path
-    logger.info(f"Setup completed successfully in {repo_path}")
-    return repo_path
-
-def install_mathlib(version: str,
-                    force: bool = False,
-                    dest_dir: Optional[str] = None):
-    """Install mathlib4."""
-    build_cmds = ['lake exe cache get', 'lake build']
-    return install_lean_repo(MATHLIB_URL, version, prefix='mathlib', force=force, dest_dir=dest_dir, build_cmds=build_cmds)
-
-# set up REPL
-def install_repl( version: str
-                , force: bool = False
-                , dest_dir:Optional[Path] = None
-                , url:Optional[str]=None) -> Path:
-    """
-    Install specified version of Lean REPL
-    
-    Args:
-        version: REPL version to install, None for latest
-        force: Force reinstall if already exists
-        dest_dir: Destination directory for installation
-    
-    Returns:
-        Path to installed REPL
-    
-    Raises:
-        InstallationError: If installation fails
-    """
-    if url is None:
-        url = 'https://github.com/leanprover-community/repl'
-    return install_lean_repo(url, version, prefix='repl', force=force, dest_dir=dest_dir, with_mathlib=True)