evo-cli 0.1.1__py3-none-any.whl

evo_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for evo_cli."""
+
+from evo_cli.cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

evo_cli/base.py

@@ -0,0 +1,17 @@
+"""
+evo_cli base module.
+
+This is the principal module of the evo_cli project.
+here you put your main classes and objects.
+
+Be creative! do whatever you want!
+
+If you want to replace this with a Flask application run:
+
+    $ make init
+
+and then choose `flask` as template.
+"""
+
+# example constant variable
+NAME = "evo_cli"

evo_cli/cli.py

@@ -0,0 +1,61 @@
+"""CLI interface for evo_cli project.
+
+Be creative! do whatever you want!
+
+- Install click or typer and create a CLI app
+- Use builtin argparse
+- Start a web application
+- Import things from your .base module
+"""
+
+import argparse
+import sys
+from evo_cli.ssh_setup import setup_ssh, show_usage
+
+def main():  # pragma: no cover
+    """
+    The main function executes on commands:
+    `python -m evo_cli` and `$ evo_cli`.
+
+    This is your program's entry point.
+
+    You can change this function to do whatever you want.
+    Examples:
+        * Run a test suite
+        * Run a server
+        * Do some other stuff
+        * Run a command line application (Click, Typer, ArgParse)
+        * List all available tasks
+        * Run an application (Flask, FastAPI, Django, etc.)
+    """
+    parser = argparse.ArgumentParser(
+        description="EVO CLI - A collection of useful tools",
+        usage="evo <command> [<args>]"
+    )
+    parser.add_argument("command", help="Command to run")
+    
+    # Parse just the command argument
+    args = parser.parse_args(sys.argv[1:2])
+    
+    # Route to appropriate command handler
+    if args.command == "setupssh":
+        # Parse arguments for ssh setup
+        ssh_parser = argparse.ArgumentParser(description="Set up SSH with key-based authentication")
+        ssh_parser.add_argument('-H', '--host', help='SSH server hostname or IP address')
+        ssh_parser.add_argument('-u', '--user', help='SSH username')
+        ssh_parser.add_argument('-p', '--password', help='SSH password (not recommended, use interactive mode instead)')
+        ssh_parser.add_argument('-i', '--identity', help='Path to existing identity file to use')
+        ssh_parser.add_argument('--help-examples', action='store_true', help='Show usage examples')
+        
+        ssh_args = ssh_parser.parse_args(sys.argv[2:])
+        
+        if ssh_args.help_examples:
+            show_usage()
+            return
+            
+        setup_ssh(ssh_args)
+    else:
+        print(f"Unknown command: {args.command}")
+        print("Available commands:")
+        print("  setupssh - Set up SSH key-based authentication")
+        parser.print_help()

evo_cli/ssh_setup.py

@@ -0,0 +1,212 @@
+"""SSH key setup functionality for EVO CLI."""
+import os
+import warnings
+
+# Suppress deprecation warnings before importing paramiko
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+try:
+    from cryptography.utils import CryptographyDeprecationWarning
+    warnings.filterwarnings("ignore", category=CryptographyDeprecationWarning)
+except ImportError:
+    pass
+
+import paramiko
+import getpass
+import sys
+from pathlib import Path
+import subprocess
+import argparse
+
+def connect_ssh(hostname, username, password):
+    """Connect to SSH server using provided credentials."""
+    try:
+        # Create SSH client
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        
+        # Connect to server
+        print(f"Connecting to {hostname} as {username}...")
+        client.connect(hostname=hostname, username=username, password=password)
+        
+        print("Connection successful!")
+        
+        # Execute a simple command to verify connection
+        stdin, stdout, stderr = client.exec_command("hostname")
+        result = stdout.read().decode().strip()
+        print(f"Server hostname: {result}")
+        
+        return client
+    except Exception as e:
+        print(f"Error connecting to SSH: {str(e)}")
+        return None
+
+def ensure_ssh_key_exists():
+    """Generate SSH key if it doesn't exist."""
+    ssh_dir = Path.home() / ".ssh"
+    id_rsa_path = ssh_dir / "id_rsa"
+    id_rsa_pub_path = ssh_dir / "id_rsa.pub"
+    
+    # Create .ssh directory if it doesn't exist
+    os.makedirs(ssh_dir, exist_ok=True)
+    
+    # Check if SSH key already exists
+    if id_rsa_path.exists() and id_rsa_pub_path.exists():
+        print("SSH key pair already exists.")
+        return id_rsa_path, id_rsa_pub_path
+    
+    # Generate SSH key pair
+    print("Generating new SSH key pair...")
+    try:
+        subprocess.run(['ssh-keygen', '-t', 'rsa', '-b', '4096', '-f', str(id_rsa_path), '-N', ''], 
+                      check=True, capture_output=True)
+        print(f"SSH key pair generated at {id_rsa_path}")
+        return id_rsa_path, id_rsa_pub_path
+    except Exception as e:
+        print(f"Error generating SSH key: {str(e)}")
+        return None, None
+
+def upload_ssh_key(client, pub_key_path):
+    """Upload the public key to the remote server."""
+    try:
+        # Read public key content
+        with open(pub_key_path, 'r') as f:
+            pub_key_content = f.read().strip()
+        
+        # Create ~/.ssh directory on remote server if it doesn't exist
+        stdin, stdout, stderr = client.exec_command("mkdir -p ~/.ssh")
+        if stderr.read():
+            print(f"Error creating .ssh directory: {stderr.read().decode()}")
+            return False
+        
+        # Add the public key to authorized_keys
+        stdin, stdout, stderr = client.exec_command(f"echo '{pub_key_content}' >> ~/.ssh/authorized_keys")
+        if stderr.read():
+            print(f"Error adding public key: {stderr.read().decode()}")
+            return False
+        
+        # Set proper permissions
+        stdin, stdout, stderr = client.exec_command("chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys")
+        if stderr.read():
+            print(f"Error setting permissions: {stderr.read().decode()}")
+            return False
+        
+        print("SSH public key successfully uploaded to the server.")
+        return True
+    except Exception as e:
+        print(f"Error uploading SSH key: {str(e)}")
+        return False
+
+def save_to_ssh_config(hostname, username, identity_file):
+    """Save SSH credentials to ~/.ssh/config file."""
+    try:
+        # Get path to SSH config file
+        ssh_dir = Path.home() / ".ssh"
+        ssh_config_path = ssh_dir / "config"
+        
+        # Create .ssh directory if it doesn't exist
+        os.makedirs(ssh_dir, exist_ok=True)
+        
+        # Prepare config entry
+        config_entry = f"""
+Host {hostname}
+  HostName {hostname}
+  User {username}
+  IdentityFile {identity_file}
+"""
+        
+        # Check if file exists and if the host is already configured
+        if ssh_config_path.exists():
+            with open(ssh_config_path, 'r') as f:
+                content = f.read()
+                if f"Host {hostname}" in content:
+                    print(f"Host {hostname} already exists in SSH config. Not modifying the file.")
+                    return
+        
+        # Append to existing file or create new one
+        with open(ssh_config_path, 'a+') as f:
+            f.write(config_entry)
+            
+        print(f"SSH config saved to {ssh_config_path}")
+        print("You can now connect without a password using:")
+        print(f"  ssh {hostname}")
+        print("Or through VSCode by adding this in your SSH config.")
+    except Exception as e:
+        print(f"Error saving SSH config: {str(e)}")
+
+def setup_ssh(args=None):
+    """Main function to set up SSH with key-based authentication."""
+    # Parse command line arguments if provided
+    if args is None:
+        parser = argparse.ArgumentParser(description='Set up SSH with key-based authentication.')
+        parser.add_argument('-H', '--host', help='SSH server hostname or IP address')
+        parser.add_argument('-u', '--user', help='SSH username')
+        parser.add_argument('-p', '--password', help='SSH password (not recommended, use interactive mode instead)')
+        parser.add_argument('-i', '--identity', help='Path to existing identity file to use')
+        args = parser.parse_args()
+    
+    # Get credentials from arguments or prompt the user
+    if args.host and args.user and args.password:
+        # Use command line arguments
+        hostname = args.host
+        username = args.user
+        password = args.password
+        print(f"Using provided credentials for {username}@{hostname}")
+    else:
+        # Get user input for credentials
+        print("Enter SSH connection details:")
+        hostname = args.host or input("Hostname/IP: ").strip()
+        username = args.user or input("Username (default: root): ").strip() or "root"
+        password = args.password or getpass.getpass("Password: ")
+        
+        if not password:
+            print("Password is required. Exiting.")
+            return
+    
+    # Ensure SSH key pair exists or use provided identity
+    if hasattr(args, 'identity') and args.identity:
+        private_key_path = Path(args.identity)
+        public_key_path = Path(f"{args.identity}.pub")
+        if not private_key_path.exists() or not public_key_path.exists():
+            print(f"Specified identity file {args.identity} not found or missing public key.")
+            return
+        print(f"Using existing identity file: {private_key_path}")
+    else:
+        private_key_path, public_key_path = ensure_ssh_key_exists()
+        if not private_key_path or not public_key_path:
+            print("Failed to ensure SSH key exists. Exiting.")
+            return
+    
+    # Connect to SSH server
+    client = connect_ssh(hostname, username, password)
+    if not client:
+        print("SSH connection failed. Exiting.")
+        return
+    
+    # Upload SSH key to server
+    if upload_ssh_key(client, public_key_path):
+        # Close the connection
+        client.close()
+        # Save to SSH config with identity file
+        save_to_ssh_config(hostname, username, str(private_key_path))
+    else:
+        client.close()
+        print("Failed to set up passwordless authentication.")
+
+def show_usage():
+    """Show usage examples."""
+    print("""
+SSH Key Setup Script
+===================
+
+This script helps you set up SSH key-based authentication for password-less login.
+
+Usage examples:
+  1. Interactive mode:
+     evo setupssh
+  
+  2. Command line mode:
+     evo setupssh -H 42.96.16.233 -u root -p YourPassword
+     
+  3. Use existing identity file:
+     evo setupssh -H 42.96.16.233 -u root -p YourPassword -i /path/to/private_key
+""") 

evo_cli-0.1.1.dist-info/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

evo_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: evo-cli
+Version: 0.1.1
+Summary: Awesome evo_cli created by maycuatroi
+Home-page: https://github.com/maycuatroi/evo-cli/
+Author: maycuatroi
+License: UNKNOWN
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paramiko>=2.7.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: black; extra == "test"
+Requires-Dist: isort; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: gitchangelog; extra == "test"
+Requires-Dist: mkdocs; extra == "test"
+
+# Evolution CLI (Develop by Dev And for Dev)
+
+[![codecov](https://codecov.io/gh/maycuatroi/evo-cli/branch/main/graph/badge.svg?token=evo-cli_token_here)](https://codecov.io/gh/maycuatroi/evo-cli)
+[![CI](https://github.com/maycuatroi/evo-cli/actions/workflows/main.yml/badge.svg)](https://github.com/maycuatroi/evo-cli/actions/workflows/main.yml)
+
+Awesome evo_cli created by maycuatroi
+
+## Install it from PyPI
+
+```bash
+pip install evo_cli
+```
+
+## Usage
+
+```py
+from evo_cli import BaseClass
+from evo_cli import base_function
+
+BaseClass().base_method()
+base_function()
+```
+
+```bash
+$ python -m evo_cli
+#or
+$ evo_cli
+```
+
+## Development
+
+Read the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+
+## Automatic Release to PyPI
+
+This project is configured to automatically release to PyPI when changes are pushed to the main branch. The process:
+
+1. Automatically bumps the version based on commit messages:
+   - Commits with "BREAKING CHANGE" trigger a major version bump
+   - Commits with "feat" trigger a minor version bump
+   - All other commits trigger a patch version bump
+
+2. Builds and publishes the package to PyPI
+
+3. Creates a GitHub release with auto-generated release notes
+
+### Setup Requirements
+
+To enable automatic PyPI releases, you need to:
+
+1. Create a PyPI API token:
+   - Go to https://pypi.org/manage/account/token/
+   - Create a new token with scope "Entire account"
+   - Copy the token value
+
+2. Add the token to your GitHub repository secrets:
+   - Go to your GitHub repository → Settings → Secrets and variables → Actions
+   - Create a new repository secret named `PYPI_API_TOKEN`
+   - Paste your PyPI token as the value
+
+After these steps, the automated release process will work whenever changes are pushed to the main branch.
+

evo_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+evo_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+evo_cli/__main__.py,sha256=7gjzkdgmHtmiJQKpltZpZ-t26bsBlgXlTzkCIjR0fnk,140
+evo_cli/base.py,sha256=kHzHVhx4SyKp7GETrpa_QpuYnhX2zGxtkaa0xkwBXNo,323
+evo_cli/cli.py,sha256=vFQDqDwTK7niNZ-z0PjmEnW7nmdDaB98bqDqeJSHvVg,2158
+evo_cli/ssh_setup.py,sha256=ii2ii0us0em9aqlVPZmJAC3jPfNEPQFYHwUYUv3_Y0w,7904
+evo_cli-0.1.1.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+evo_cli-0.1.1.dist-info/METADATA,sha256=C3trszSelGZujb8g0O5a2y0nDOUefj6iY9W5wOrSuTQ,2426
+evo_cli-0.1.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+evo_cli-0.1.1.dist-info/entry_points.txt,sha256=KAho_YevnWKWXCxu0LKp7nIFQtMbqWoxQ8_tvDauojs,51
+evo_cli-0.1.1.dist-info/top_level.txt,sha256=oZVCrBYcBYaYGLMqkmnBxt_ZPVDb_shL54Q6dgX5fPk,8
+evo_cli-0.1.1.dist-info/RECORD,,

evo_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

evo_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+evo_cli = evo_cli.__main__:main
+

evo_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+evo_cli