linux-command 0.2.3__tar.gz → 0.3.1__tar.gz

{linux-command-0.2.3/linux_command.egg-info → linux_command-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: linux-command
-Version: 0.2.3
+Version: 0.3.1
 Summary: A command line tool to perform custom tasks.
 Home-page: https://github.com/MouxiaoHuang/linux-command
 Author: Mouxiao Huang
@@ -11,6 +11,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
 
 
 # linux-command
@@ -25,6 +34,16 @@ To install the package, run the following command:
 pip install linux-command
 ```
 
+## Install From Source (Development)
+
+If you want to develop or modify the tool locally:
+
+```bash
+git clone https://github.com/MouxiaoHuang/linux-command.git
+cd linux-command
+pip install -e .
+```
+
 ## Usage
 
 Once installed, you can access all commands using `cmd` followed by the specific command name. You can use `cmd -h` or `cmd --help` to see the supported commands. Below is a list of supported commands along with examples for each.
@@ -155,6 +174,12 @@ cmd ps-grep python
 cmd kill process_name
 ```
 
+To force kill:
+
+```bash
+cmd kill --force process_name
+```
+
 ---
 
 ### 21. `df` - Show disk usage in human-readable format
@@ -163,7 +188,7 @@ cmd kill process_name
 cmd df
 ```
 
-### 22. `du [path]` - Show disk usage for a specific file or directory
+### 22. `du [path]` - Show disk usage for a specific file or directory (default: current directory)
 
 ```bash
 cmd du /path/to/directory
@@ -256,6 +281,21 @@ This command will create a `.zip` file at `/path/to/output.zip` that contains ev
 
 ---
 
+## Aliases
+
+These commands are aliases for the same behavior:
+
+- `lsf` = `ls-file`
+- `lsd` = `ls-dir`
+- `ls-bs` = `ls-block-size`
+- `disk` = `du`
+- `tar` = `tar-compress`
+- `untar` = `tar-extract`
+- `zip` = `zip-compress`
+- `zip-all` = `zip-compress`
+- `unzip` = `unzip-all`
+- `convert-vid` = `convert-video`
+
 ## Contributing
 
 We welcome contributions from the community! If you'd like to help improve `linux-command`, feel free to report issues or submit pull requests.

linux-command-0.2.3/PKG-INFO → linux_command-0.3.1/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.1
-Name: linux-command
-Version: 0.2.3
-Summary: A command line tool to perform custom tasks.
-Home-page: https://github.com/MouxiaoHuang/linux-command
-Author: Mouxiao Huang
-Author-email: huangmouxiao@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 
 # linux-command
 
@@ -25,6 +11,16 @@ To install the package, run the following command:
 pip install linux-command
 ```
 
+## Install From Source (Development)
+
+If you want to develop or modify the tool locally:
+
+```bash
+git clone https://github.com/MouxiaoHuang/linux-command.git
+cd linux-command
+pip install -e .
+```
+
 ## Usage
 
 Once installed, you can access all commands using `cmd` followed by the specific command name. You can use `cmd -h` or `cmd --help` to see the supported commands. Below is a list of supported commands along with examples for each.
@@ -155,6 +151,12 @@ cmd ps-grep python
 cmd kill process_name
 ```
 
+To force kill:
+
+```bash
+cmd kill --force process_name
+```
+
 ---
 
 ### 21. `df` - Show disk usage in human-readable format
@@ -163,7 +165,7 @@ cmd kill process_name
 cmd df
 ```
 
-### 22. `du [path]` - Show disk usage for a specific file or directory
+### 22. `du [path]` - Show disk usage for a specific file or directory (default: current directory)
 
 ```bash
 cmd du /path/to/directory
@@ -256,6 +258,21 @@ This command will create a `.zip` file at `/path/to/output.zip` that contains ev
 
 ---
 
+## Aliases
+
+These commands are aliases for the same behavior:
+
+- `lsf` = `ls-file`
+- `lsd` = `ls-dir`
+- `ls-bs` = `ls-block-size`
+- `disk` = `du`
+- `tar` = `tar-compress`
+- `untar` = `tar-extract`
+- `zip` = `zip-compress`
+- `zip-all` = `zip-compress`
+- `unzip` = `unzip-all`
+- `convert-vid` = `convert-video`
+
 ## Contributing
 
 We welcome contributions from the community! If you'd like to help improve `linux-command`, feel free to report issues or submit pull requests.

{linux-command-0.2.3 → linux_command-0.3.1}/linux_command/linux_command.py

@@ -26,18 +26,23 @@ SOFTWARE.
 For more information, visit the project page: https://github.com/MouxiaoHuang/linux-command
 """
 import argparse
-import os
 import glob
+import os
+import shutil
+import signal
+import subprocess
+from fnmatch import fnmatch
 
 
 # Define the version 
-VERSION = "0.2.3"
+VERSION = "0.3.1"
 PROJECT_URL = "https://github.com/MouxiaoHuang/linux-command" 
 
 
 # Command descriptions
 commands = {
     'ls': 'List contents.',
+    'ls-all': 'List all files, including hidden ones.',
     'lsf': 'Count all files or filter by a specified pattern, extension or keyword. Same as `ls-file`.',
     'ls-file': 'Count all files or filter by a specified pattern, extension or keyword. Same as `lsf`.',
     'lsd': 'Count all directories. Same as `ls-dir`.',
@@ -47,6 +52,7 @@ commands = {
     'ls-human': 'List in human-readable format (for file sizes)',
     'ls-long': 'Long format listing',
     'ls-size': 'Sort files by size',
+    'ls-recursive': 'Recursively list files in directories and subdirectories.',
     'ls-recursive-size': 'List all files and directories recursively, with sizes in human-readable format',
     'ls-bs': 'Display the size of each file in specified block size (e.g., K, M, G).',
     'ls-block-size': 'Display the size of each file in specified block size (e.g., K, M, G).',
@@ -64,12 +70,13 @@ commands = {
     'rm': 'Remove file, directory, or multiple files by patterns (e.g., *.txt)',
     'grep': 'Search for a pattern in files or output.',
     'tar': 'Pack into .tar or .tar.gz file.',
-    'tar-comress': 'Pack into .tar or .tar.gz file.',
+    'tar-compress': 'Pack into .tar or .tar.gz file.',
     'untar': 'Unpack .tar or .tar.gz file, or batch process in a directory.',
     'tar-extract': 'Unpack .tar or .tar.gz file, or batch process in a directory.',
     'tar-list': 'List all contents in a tar file.',
     'tar-add': 'Add a file to a tar file.',
     'zip': 'Pack a folder to a .zip file.',
+    'zip-compress': 'Pack a folder to a .zip file.',
     'zip-all': 'Pack a folder to a .zip file.',
     'unzip': 'Unpack all .zip files in a directory to another.',
     'unzip-all': 'Unpack all .zip files in a directory to another.',
@@ -92,6 +99,130 @@ def confirm_action(message):
     return confirmation in ['yes', 'y']
 
 
+def run_cmd(cmd_args):
+    """Run a command safely without invoking a shell."""
+    try:
+        subprocess.run(cmd_args, check=False)
+    except FileNotFoundError:
+        print(f"Command not found: {cmd_args[0]}")
+
+
+def parse_excludes(args):
+    excludes = []
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == '--exclude':
+            if i + 1 < len(args):
+                excludes.append(args[i + 1])
+                i += 2
+            else:
+                break
+        elif arg.startswith('--exclude='):
+            excludes.append(arg.split('=', 1)[1])
+            i += 1
+        else:
+            excludes.append(arg)
+            i += 1
+    return excludes
+
+
+def expand_globs(args):
+    expanded = []
+    for arg in args:
+        if any(ch in arg for ch in ['*', '?', '[']):
+            matches = glob.glob(arg)
+            if matches:
+                expanded.extend(matches)
+            else:
+                expanded.append(arg)
+        else:
+            expanded.append(arg)
+    return expanded
+
+
+def list_files_in_dir(path):
+    try:
+        return os.listdir(path)
+    except FileNotFoundError:
+        print(f"Path not found: {path}")
+        return []
+
+
+def count_dirs(root):
+    total = 0
+    for _, dirs, _ in os.walk(root):
+        total += len(dirs)
+    return total
+
+
+def count_files(root, pattern=None):
+    files = [f for f in list_files_in_dir(root) if os.path.isfile(os.path.join(root, f))]
+    if pattern is None:
+        return len(files)
+    if any(ch in pattern for ch in ['*', '?', '[']):
+        return sum(1 for f in files if fnmatch(f, pattern))
+    return sum(1 for f in files if pattern in f)
+
+
+def filter_ps(keyword):
+    try:
+        result = subprocess.run(['ps', 'aux'], check=False, capture_output=True, text=True)
+    except FileNotFoundError:
+        print("Command not found: ps")
+        return []
+    lines = result.stdout.splitlines()
+    matches = []
+    for line in lines:
+        if keyword in line and 'ps aux' not in line:
+            matches.append(line)
+    return matches
+
+
+def kill_processes(target, force=False):
+    sig = signal.SIGKILL if force else signal.SIGTERM
+    if target.isdigit():
+        try:
+            os.kill(int(target), sig)
+            print(f"Killed PID {target} with signal {sig}.")
+        except ProcessLookupError:
+            print(f"No such process: {target}")
+        except PermissionError:
+            print(f"Permission denied to kill PID {target}")
+        return
+
+    matches = filter_ps(target)
+    if not matches:
+        print(f"No processes found matching: {target}")
+        return
+
+    pids = []
+    for line in matches:
+        parts = line.split()
+        if len(parts) >= 2 and parts[1].isdigit():
+            pids.append(parts[1])
+
+    if not pids:
+        print(f"No processes found matching: {target}")
+        return
+
+    print("Matched processes:")
+    for line in matches:
+        print(line)
+
+    if confirm_action(f"Kill {len(pids)} process(es) matching '{target}'?"):
+        for pid in pids:
+            try:
+                os.kill(int(pid), sig)
+            except ProcessLookupError:
+                print(f"No such process: {pid}")
+            except PermissionError:
+                print(f"Permission denied to kill PID {pid}")
+        print("Kill completed.")
+    else:
+        print("Operation canceled.")
+
+
 def main():
     # Set up argparse
     parser = argparse.ArgumentParser(
@@ -104,11 +235,17 @@ def main():
     parser.add_argument('-V', '--version', action='store_true', help='Show program\'s version number and exit')
     
     # Main command and subcommands
-    parser.add_argument('command', nargs='?', help='Command to execute')
-    parser.add_argument('extra', nargs='*', help='Additional arguments for the command')
+    subparsers = parser.add_subparsers(dest='command')
+    for command, description in commands.items():
+        subparser = subparsers.add_parser(command, help=description, add_help=True)
+        subparser.add_argument('extra', nargs=argparse.REMAINDER, help='Additional arguments for the command')
 
     # Parse the arguments
-    args = parser.parse_args()
+    args, unknown = parser.parse_known_args()
+    if unknown:
+        if not hasattr(args, 'extra') or args.extra is None:
+            args.extra = []
+        args.extra.extend(unknown)
 
     if args.help:
         custom_help()
@@ -117,140 +254,107 @@ def main():
     if args.version:
         print(f'linux-command {VERSION}')
         return
+    
+    if args.command is None:
+        custom_help()
+        return
+
+    ls_simple = {
+        'ls': [],
+        'ls-all': ['-a'],
+        'ls-reverse': ['-r'],
+        'ls-time': ['-lt'],
+        'ls-long': ['-l'],
+        'ls-human': ['-lh'],
+        'ls-recursive': ['-R'],
+        'ls-recursive-size': ['-lRh'],
+        'ls-size': ['-lS'],
+    }
+
+    ps_simple = {
+        'ps': [],
+        'ps-all': ['-A'],
+        'ps-aux': ['aux'],
+        'ps-sort-memory': ['aux', '--sort=-%mem'],
+        'ps-sort-cpu': ['aux', '--sort=-%cpu'],
+    }
 
     # `ls` commands
-    if args.command == 'ls':
-        if len(args.extra) == 0:
-            # List current directory
-            os.system('ls')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls {options}')
-    
-    # Advanced `ls` commands
+    if args.command in ls_simple:
+        run_cmd(['ls', *ls_simple[args.command], *expand_globs(args.extra)])
 
+    # Advanced `ls` commands
     elif args.command == 'ls-dir' or args.command == 'lsd':
         # Count the number of directories
-        os.system('ls -lR | grep "^d" | wc -l')
+        print(count_dirs('.'))
     
     elif args.command == 'ls-file' or args.command == 'lsf':
         if len(args.extra) == 0:
             # Count the number of all files
-            os.system('ls -l | grep "^-" | wc -l')
+            print(count_files('.'))
         else:
             # Count files of a specific type based on provided extension or pattern
             pattern = args.extra[0]  # First extra argument as file pattern
-            os.system(f'ls -l | grep "^-" | grep "{pattern}" | wc -l')
-    
-    elif args.command == 'ls-reverse':
-        # List files and directories in reverse order
-        if len(args.extra) == 0:
-            os.system('ls -r')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -r {options}')
-    
-    elif args.command == 'ls-time':
-        # Sort by modification time, newest first
-        if len(args.extra) == 0:
-            os.system('ls -lt')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -lt {options}')
-    
-    elif args.command == 'ls-long':
-        # Long format listing
-        if len(args.extra) == 0:
-            os.system('ls -l')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -l {options}')
-
-    elif args.command == 'ls-human':
-        # List in human-readable format (for file sizes)
-        if len(args.extra) == 0:
-            os.system('ls -lh')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -lh {options}')
-    
-    elif args.command == 'ls-recursive-size':
-        # List all files and directories recursively, with sizes in human-readable format
-        if len(args.extra) == 0:
-            os.system('ls -lRh')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -lRh {options}')
-    
-    elif args.command == 'ls-size':
-        # Sort files by size
-        if len(args.extra) == 0:
-            os.system('ls -lS')
-        else:
-            options = ' '.join(args.extra)
-            os.system(f'ls -lS {options}')
+            print(count_files('.', pattern=pattern))
     
     elif args.command == 'ls-block-size' or args.command == 'ls-bs':
         # Display the size of each file in specified block size
         if len(args.extra) == 1:
             block_size = args.extra[0]
-            os.system(f'ls --block-size={block_size}')
+            run_cmd(['ls', f'--block-size={block_size}'])
         else:
             print('Please provide a valid block size (e.g., K, M, G).')
     
     # `ps` commands
-    elif args.command == 'ps':
-        # Basic process list
-        os.system('ps')
-
-    elif args.command == 'ps-all':
-        # Show all processes
-        os.system('ps -A')
+    elif args.command in ps_simple:
+        run_cmd(['ps', *ps_simple[args.command]])
     
     elif args.command == 'ps-user':
         # Show processes for a specific user
         if len(args.extra) > 0:
             user = args.extra[0]
-            os.system(f'ps -u {user}')
+            run_cmd(['ps', '-u', user])
         else:
             print('Please provide a username to show processes for that user')
 
-    elif args.command == 'ps-aux':
-        # Show detailed information about all processes
-        os.system('ps aux')
-
-    elif args.command == 'ps-sort-memory':
-        # Sort processes by memory usage
-        os.system('ps aux --sort=-%mem')
-
-    elif args.command == 'ps-sort-cpu':
-        # Sort processes by CPU usage
-        os.system('ps aux --sort=-%cpu')
-
     elif args.command == 'ps-grep':
         # Search for a specific process by name or keyword
         if len(args.extra) > 0:
             keyword = args.extra[0]
-            os.system(f'ps aux | grep {keyword}')
+            matches = filter_ps(keyword)
+            for line in matches:
+                print(line)
         else:
             print('Please provide a keyword to search for in process list')
 
     # `kill` command
     elif args.command == 'kill':
-        if len(args.extra) > 0:
-            os.system(f'ps -ef | grep {args.extra[0]} | grep -v grep | cut -c 9-16 | xargs kill -9')
-        else:
+        if len(args.extra) == 0:
             print('Please provide a process name or PID for kill command')
+        else:
+            force = False
+            extras = list(args.extra)
+            if '-9' in extras:
+                extras.remove('-9')
+                force = True
+            if '--force' in extras:
+                extras.remove('--force')
+                force = True
+            if len(extras) == 0:
+                print('Please provide a process name or PID for kill command')
+                return
+            target = extras[0]
+            kill_processes(target, force=force)
 
     # Disk usage and free space commands
     elif args.command == 'df':
-        os.system('df -h')
+        run_cmd(['df', '-h'])
 
     elif args.command == 'du' or args.command == 'disk':
         if len(args.extra) > 0:
-            os.system(f'du -sh {args.extra[0]}')
+            run_cmd(['du', '-sh', args.extra[0]])
         else:
-            print('Please provide a valid path for du command')
+            run_cmd(['du', '-sh', '.'])
 
     # Remove files or directories with confirmation and support for bulk removal
     elif args.command == 'rm':
@@ -258,9 +362,12 @@ def main():
             target = args.extra[0]
             if confirm_action(f"Are you sure you want to remove '{target}'?"):
                 if os.path.isdir(target):
-                    os.system(f'rm -rf {target}')
+                    shutil.rmtree(target)
+                elif os.path.isfile(target):
+                    os.remove(target)
                 else:
-                    os.system(f'rm {target}')
+                    print(f"Path not found: {target}")
+                    return
                 print(f"'{target}' has been removed.")
             else:
                 print(f"Operation canceled. '{target}' was not removed.")
@@ -273,7 +380,10 @@ def main():
                     print(f"Found {len(files_to_remove)} files to remove: {files_to_remove}")
                     if confirm_action(f"Are you sure you want to remove these files?"):
                         for file in files_to_remove:
-                            os.system(f'rm {file}')
+                            if os.path.isdir(file):
+                                shutil.rmtree(file)
+                            elif os.path.isfile(file):
+                                os.remove(file)
                         print(f"Removed files matching {pattern}.")
                     else:
                         print(f"Operation canceled for files matching {pattern}.")
@@ -283,7 +393,7 @@ def main():
     # Search for a pattern in files or output
     elif args.command == 'grep':
         if len(args.extra) == 2:
-            os.system(f'grep "{args.extra[0]}" {args.extra[1]}')
+            run_cmd(['grep', args.extra[0], args.extra[1]])
         else:
             print('Please provide a keyword and file path for grep command')
 
@@ -292,12 +402,11 @@ def main():
         if len(args.extra) >= 2:
             source = args.extra[0]
             output = args.extra[1]
-            exclude = args.extra[2:]  # Additional arguments as exclude patterns
-            exclude_params = ' '.join(f'--exclude={x}' for x in exclude)
+            exclude = parse_excludes(args.extra[2:])  # Additional arguments as exclude patterns
             if output.endswith('.tar.gz'):
-                os.system(f'tar -czvf {output} {exclude_params} {source}')
+                run_cmd(['tar', '-czvf', output, *[f'--exclude={x}' for x in exclude], source])
             elif output.endswith('.tar'):
-                os.system(f'tar -cvf {output} {exclude_params} {source}')
+                run_cmd(['tar', '-cvf', output, *[f'--exclude={x}' for x in exclude], source])
             else:
                 print('Unsupported output format. Please provide .tar or .tar.gz as the output file extension.')
         else:
@@ -319,14 +428,14 @@ def main():
 
                 for tar_file in tar_files:
                     if tar_file.endswith('.tar'):
-                        os.system(f'tar -xvf {tar_file} -C {destination}')
+                        run_cmd(['tar', '-xvf', tar_file, '-C', destination])
                     elif tar_file.endswith('.tar.gz'):
-                        os.system(f'tar -xzvf {tar_file} -C {destination}')
+                        run_cmd(['tar', '-xzvf', tar_file, '-C', destination])
             # Extract a single tar file
             elif source.endswith('.tar.gz'):
-                os.system(f'tar -xzvf {source} -C {destination}')
+                run_cmd(['tar', '-xzvf', source, '-C', destination])
             elif source.endswith('.tar'):
-                os.system(f'tar -xvf {source} -C {destination}')
+                run_cmd(['tar', '-xvf', source, '-C', destination])
             else:
                 print('Please provide a valid .tar or .tar.gz file, or a directory containing such files.')
 
@@ -334,13 +443,13 @@ def main():
 
     elif args.command == 'tar-list':
         if len(args.extra) > 0:
-            os.system(f'tar -tvf {args.extra[0]}')
+            run_cmd(['tar', '-tvf', args.extra[0]])
         else:
             print('Please provide a tar file to list contents')
 
     elif args.command == 'tar-add':
         if len(args.extra) == 2:
-            os.system(f'tar -rvf {args.extra[1]} {args.extra[0]}')
+            run_cmd(['tar', '-rvf', args.extra[1], args.extra[0]])
         else:
             print('Please provide a file to add and the target tar file')
     
@@ -349,17 +458,19 @@ def main():
         if len(args.extra) == 2:
             source_dir = args.extra[0]
             target_dir = args.extra[1]
-            os.system(f'find {source_dir} -name "*.zip" -exec unzip {{}} -d {target_dir} \;')
+            for root, _, files in os.walk(source_dir):
+                for name in files:
+                    if name.endswith('.zip'):
+                        run_cmd(['unzip', os.path.join(root, name), '-d', target_dir])
         else:
             print('Please provide both a source and a target directory.')
     
     # Zip compress
-    elif args.command == 'zip-all' or args.command == 'zip':
+    elif args.command == 'zip-all' or args.command == 'zip' or args.command == 'zip-compress':
         if len(args.extra) >= 2:
             output = args.extra[0]
-            sources = args.extra[1:]  # All other arguments as sources to be zipped
-            source_params = ' '.join(sources)
-            os.system(f'zip -r {output} {source_params}')
+            sources = expand_globs(args.extra[1:])  # All other arguments as sources to be zipped
+            run_cmd(['zip', '-r', output, *sources])
         else:
             print('Please provide an output file name and at least one source to compress.')
 
@@ -371,17 +482,17 @@ def main():
 
             if '*' in source:
                 # Handle wildcard batch conversion
-                source_files = glob.glob(source)
+                source_files = sorted(glob.glob(source))
                 destination_dir = os.path.dirname(destination)
                 file_extension = destination.split('.')[-1]
 
                 for src_file in source_files:
                     basename = os.path.splitext(os.path.basename(src_file))[0]
                     dest_file = os.path.join(destination_dir, f'{basename}.{file_extension}')
-                    os.system(f'ffmpeg -i "{src_file}" -c copy "{dest_file}" -y')
+                    run_cmd(['ffmpeg', '-i', src_file, '-c', 'copy', dest_file, '-y'])
             else:
                 # Handle single file conversion
-                os.system(f'ffmpeg -i "{source}" -c copy "{destination}" -y')
+                run_cmd(['ffmpeg', '-i', source, '-c', 'copy', destination, '-y'])
         else:
             print('Usage: convert-video [source file or pattern] [destination file or pattern]')
 

linux-command-0.2.3/README.md → linux_command-0.3.1/linux_command.egg-info/PKG-INFO

@@ -1,3 +1,26 @@
+Metadata-Version: 2.4
+Name: linux-command
+Version: 0.3.1
+Summary: A command line tool to perform custom tasks.
+Home-page: https://github.com/MouxiaoHuang/linux-command
+Author: Mouxiao Huang
+Author-email: huangmouxiao@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
 
 # linux-command
 
@@ -11,6 +34,16 @@ To install the package, run the following command:
 pip install linux-command
 ```
 
+## Install From Source (Development)
+
+If you want to develop or modify the tool locally:
+
+```bash
+git clone https://github.com/MouxiaoHuang/linux-command.git
+cd linux-command
+pip install -e .
+```
+
 ## Usage
 
 Once installed, you can access all commands using `cmd` followed by the specific command name. You can use `cmd -h` or `cmd --help` to see the supported commands. Below is a list of supported commands along with examples for each.
@@ -141,6 +174,12 @@ cmd ps-grep python
 cmd kill process_name
 ```
 
+To force kill:
+
+```bash
+cmd kill --force process_name
+```
+
 ---
 
 ### 21. `df` - Show disk usage in human-readable format
@@ -149,7 +188,7 @@ cmd kill process_name
 cmd df
 ```
 
-### 22. `du [path]` - Show disk usage for a specific file or directory
+### 22. `du [path]` - Show disk usage for a specific file or directory (default: current directory)
 
 ```bash
 cmd du /path/to/directory
@@ -242,6 +281,21 @@ This command will create a `.zip` file at `/path/to/output.zip` that contains ev
 
 ---
 
+## Aliases
+
+These commands are aliases for the same behavior:
+
+- `lsf` = `ls-file`
+- `lsd` = `ls-dir`
+- `ls-bs` = `ls-block-size`
+- `disk` = `du`
+- `tar` = `tar-compress`
+- `untar` = `tar-extract`
+- `zip` = `zip-compress`
+- `zip-all` = `zip-compress`
+- `unzip` = `unzip-all`
+- `convert-vid` = `convert-video`
+
 ## Contributing
 
 We welcome contributions from the community! If you'd like to help improve `linux-command`, feel free to report issues or submit pull requests.

{linux-command-0.2.3 → linux_command-0.3.1}/linux_command.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+pyproject.toml
 setup.py
 linux_command/__init__.py
 linux_command/linux_command.py
@@ -7,4 +8,5 @@ linux_command.egg-info/PKG-INFO
 linux_command.egg-info/SOURCES.txt
 linux_command.egg-info/dependency_links.txt
 linux_command.egg-info/entry_points.txt
-linux_command.egg-info/top_level.txt
+linux_command.egg-info/top_level.txt
+tests/test_linux_command.py

linux_command-0.3.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=40.8.0", "wheel"]
+build-backend = "setuptools.build_meta"

linux_command-0.3.1/setup.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from setuptools import setup, find_packages
+
+
+def read_metadata():
+    content = Path(__file__).parent.joinpath("linux_command", "linux_command.py").read_text(encoding="utf-8")
+    version = None
+    project_url = None
+    for line in content.splitlines():
+        if line.startswith("VERSION ="):
+            version = line.split("=", 1)[1].strip().strip('"').strip("'")
+        if line.startswith("PROJECT_URL ="):
+            project_url = line.split("=", 1)[1].strip().strip('"').strip("'")
+    if version is None:
+        raise RuntimeError("VERSION not found in linux_command.py")
+    if project_url is None:
+        raise RuntimeError("PROJECT_URL not found in linux_command.py")
+    return version, project_url
+
+
+VERSION, PROJECT_URL = read_metadata()
+
+
+setup(
+    name='linux-command',
+    version=VERSION,
+    packages=find_packages(),
+    entry_points={
+        'console_scripts': [
+            'cmd=linux_command.linux_command:main',
+        ],
+    },
+    install_requires=[],
+    author='Mouxiao Huang',
+    author_email='huangmouxiao@gmail.com',
+    description='A command line tool to perform custom tasks.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url=PROJECT_URL,
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.6',
+)

linux_command-0.3.1/tests/test_linux_command.py

@@ -0,0 +1,308 @@
+import builtins
+import signal
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+import linux_command.linux_command as lc
+
+
+class RunSpy:
+    def __init__(self):
+        self.calls = []
+
+    def __call__(self, cmd_args, check=False, **kwargs):
+        # Mimic subprocess.run signature used in code.
+        self.calls.append(list(cmd_args))
+        class Result:
+            stdout = ""
+        return Result()
+
+
+class RunCmdSpy:
+    def __init__(self):
+        self.calls = []
+
+    def __call__(self, cmd_args):
+        self.calls.append(list(cmd_args))
+
+
+def run_main_with_args(monkeypatch, argv, run_spy=None):
+    monkeypatch.setattr(sys, "argv", ["cmd", *argv])
+    if run_spy is not None:
+        monkeypatch.setattr(lc.subprocess, "run", run_spy)
+    lc.main()
+
+
+def test_ls_and_ls_all(monkeypatch):
+    run_spy = RunSpy()
+    run_main_with_args(monkeypatch, ["ls"], run_spy)
+    run_main_with_args(monkeypatch, ["ls-all"], run_spy)
+    assert run_spy.calls[0] == ["ls"]
+    assert run_spy.calls[1] == ["ls", "-a"]
+
+
+def test_ls_variants(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    for cmd, expected in [
+        ("ls-reverse", ["ls", "-r"]),
+        ("ls-time", ["ls", "-lt"]),
+        ("ls-long", ["ls", "-l"]),
+        ("ls-human", ["ls", "-lh"]),
+        ("ls-recursive", ["ls", "-R"]),
+        ("ls-recursive-size", ["ls", "-lRh"]),
+        ("ls-size", ["ls", "-lS"]),
+    ]:
+        run_main_with_args(monkeypatch, [cmd])
+        assert run_cmd_spy.calls[-1] == expected
+
+
+def test_ls_block_size_ok(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["ls-block-size", "M"])
+    assert run_cmd_spy.calls[0] == ["ls", "--block-size=M"]
+
+
+def test_ls_block_size_missing_arg(monkeypatch, capsys):
+    run_spy = RunSpy()
+    run_main_with_args(monkeypatch, ["ls-block-size"], run_spy)
+    out = capsys.readouterr().out
+    assert "Please provide a valid block size" in out
+
+
+def test_ps_user(monkeypatch):
+    run_spy = RunSpy()
+    run_main_with_args(monkeypatch, ["ps-user", "root"], run_spy)
+    assert run_spy.calls[0] == ["ps", "-u", "root"]
+
+
+def test_ps_variants(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    for cmd, expected in [
+        ("ps", ["ps"]),
+        ("ps-all", ["ps", "-A"]),
+        ("ps-aux", ["ps", "aux"]),
+        ("ps-sort-memory", ["ps", "aux", "--sort=-%mem"]),
+        ("ps-sort-cpu", ["ps", "aux", "--sort=-%cpu"]),
+    ]:
+        run_main_with_args(monkeypatch, [cmd])
+        assert run_cmd_spy.calls[-1] == expected
+
+
+def test_ps_grep_filters(monkeypatch, capsys):
+    def fake_run(cmd_args, check=False, capture_output=False, text=False):
+        class Result:
+            stdout = "root 1 0.0 0.1 ? Ss 00:00 python\nuser 2 0.0 0.1 ? Ss 00:00 bash\n"
+        return Result()
+
+    monkeypatch.setattr(lc.subprocess, "run", fake_run)
+    run_main_with_args(monkeypatch, ["ps-grep", "python"])
+    out = capsys.readouterr().out
+    assert "python" in out
+    assert "bash" not in out
+
+
+def test_kill_pid(monkeypatch, capsys):
+    killed = []
+
+    def fake_kill(pid, sig):
+        killed.append((pid, sig))
+
+    monkeypatch.setattr(lc.os, "kill", fake_kill)
+    run_main_with_args(monkeypatch, ["kill", "1234"])
+    assert killed == [(1234, signal.SIGTERM)]
+
+
+def test_kill_force_pid(monkeypatch):
+    killed = []
+
+    def fake_kill(pid, sig):
+        killed.append((pid, sig))
+
+    monkeypatch.setattr(lc.os, "kill", fake_kill)
+    run_main_with_args(monkeypatch, ["kill", "--force", "999"])
+    assert killed == [(999, signal.SIGKILL)]
+
+
+def test_kill_name_confirm(monkeypatch, capsys):
+    def fake_run(cmd_args, check=False, capture_output=False, text=False):
+        class Result:
+            stdout = "root 10 0.0 0.1 ? Ss 00:00 myproc\n"
+        return Result()
+
+    killed = []
+
+    def fake_kill(pid, sig):
+        killed.append((pid, sig))
+
+    monkeypatch.setattr(lc.subprocess, "run", fake_run)
+    monkeypatch.setattr(lc.os, "kill", fake_kill)
+    monkeypatch.setattr(builtins, "input", lambda _: "y")
+    run_main_with_args(monkeypatch, ["kill", "myproc"])
+    assert killed == [(10, signal.SIGTERM)]
+
+
+def test_du_default(monkeypatch):
+    run_spy = RunSpy()
+    run_main_with_args(monkeypatch, ["du"], run_spy)
+    assert run_spy.calls[0] == ["du", "-sh", "."]
+
+
+def test_disk_alias(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["disk", "/tmp"])
+    assert run_cmd_spy.calls[0] == ["du", "-sh", "/tmp"]
+
+
+def test_rm_single_file(monkeypatch, tmp_path):
+    target = tmp_path / "a.txt"
+    target.write_text("x")
+    monkeypatch.setattr(builtins, "input", lambda _: "y")
+    run_main_with_args(monkeypatch, ["rm", str(target)])
+    assert not target.exists()
+
+
+def test_rm_pattern(monkeypatch, tmp_path):
+    (tmp_path / "a.log").write_text("x")
+    (tmp_path / "b.log").write_text("x")
+    (tmp_path / "c.txt").write_text("x")
+    monkeypatch.setattr(builtins, "input", lambda _: "y")
+    run_main_with_args(monkeypatch, ["rm", str(tmp_path), "*.log"])
+    assert not (tmp_path / "a.log").exists()
+    assert not (tmp_path / "b.log").exists()
+    assert (tmp_path / "c.txt").exists()
+
+
+def test_expand_globs(tmp_path):
+    (tmp_path / "x.txt").write_text("x")
+    (tmp_path / "y.txt").write_text("x")
+    args = [str(tmp_path / "*.txt")]
+    expanded = lc.expand_globs(args)
+    assert len(expanded) == 2
+
+
+def test_ls_dir_and_ls_file(monkeypatch, tmp_path, capsys):
+    (tmp_path / "a.txt").write_text("x")
+    (tmp_path / "b.log").write_text("x")
+    (tmp_path / "dir1").mkdir()
+    (tmp_path / "dir2").mkdir()
+    monkeypatch.chdir(tmp_path)
+
+    run_main_with_args(monkeypatch, ["ls-dir"])
+    out = capsys.readouterr().out.strip()
+    assert out == "2"
+
+    run_main_with_args(monkeypatch, ["ls-file"])
+    out = capsys.readouterr().out.strip()
+    assert out == "2"
+
+    run_main_with_args(monkeypatch, ["lsf", "*.log"])
+    out = capsys.readouterr().out.strip()
+    assert out == "1"
+
+    run_main_with_args(monkeypatch, ["lsd"])
+    out = capsys.readouterr().out.strip()
+    assert out == "2"
+
+
+def test_grep_command(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["grep", "needle", "file.txt"])
+    assert run_cmd_spy.calls[0] == ["grep", "needle", "file.txt"]
+
+
+def test_tar_compress(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["tar-compress", "src", "out.tar"])
+    run_main_with_args(monkeypatch, ["tar", "src", "out.tar.gz", "--exclude", "node_modules"])
+    assert run_cmd_spy.calls[0] == ["tar", "-cvf", "out.tar", "src"]
+    assert run_cmd_spy.calls[1] == ["tar", "-czvf", "out.tar.gz", "--exclude=node_modules", "src"]
+
+
+def test_tar_compress_bad_ext(monkeypatch, capsys):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["tar-compress", "src", "out.zip"])
+    out = capsys.readouterr().out
+    assert "Unsupported output format" in out
+
+
+def test_tar_extract_single(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["tar-extract", "a.tar.gz", "dest"])
+    run_main_with_args(monkeypatch, ["untar", "b.tar", "dest"])
+    assert run_cmd_spy.calls[0] == ["tar", "-xzvf", "a.tar.gz", "-C", "dest"]
+    assert run_cmd_spy.calls[1] == ["tar", "-xvf", "b.tar", "-C", "dest"]
+
+
+def test_tar_extract_dir(monkeypatch, tmp_path):
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "a.tar").write_text("x")
+    (src / "b.tar.gz").write_text("x")
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["tar-extract", str(src), str(tmp_path / "dest"), "all"])
+    assert run_cmd_spy.calls[0] == ["tar", "-xvf", str(src / "a.tar"), "-C", str(tmp_path / "dest")]
+    assert run_cmd_spy.calls[1] == ["tar", "-xzvf", str(src / "b.tar.gz"), "-C", str(tmp_path / "dest")]
+
+
+def test_tar_list_and_add(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["tar-list", "a.tar"])
+    run_main_with_args(monkeypatch, ["tar-add", "file.txt", "a.tar"])
+    assert run_cmd_spy.calls[0] == ["tar", "-tvf", "a.tar"]
+    assert run_cmd_spy.calls[1] == ["tar", "-rvf", "a.tar", "file.txt"]
+
+
+def test_unzip_all(monkeypatch, tmp_path):
+    src = tmp_path / "zips"
+    src.mkdir()
+    (src / "a.zip").write_text("x")
+    (src / "b.txt").write_text("x")
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["unzip-all", str(src), str(tmp_path / "out")])
+    assert run_cmd_spy.calls[0] == ["unzip", str(src / "a.zip"), "-d", str(tmp_path / "out")]
+
+
+def test_zip_commands(monkeypatch, tmp_path):
+    (tmp_path / "a.txt").write_text("x")
+    (tmp_path / "b.txt").write_text("x")
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["zip", "out.zip", str(tmp_path / "*.txt")])
+    run_main_with_args(monkeypatch, ["zip-compress", "out.zip", str(tmp_path / "a.txt")])
+    assert run_cmd_spy.calls[0][0:3] == ["zip", "-r", "out.zip"]
+    assert run_cmd_spy.calls[1] == ["zip", "-r", "out.zip", str(tmp_path / "a.txt")]
+
+
+def test_convert_video_single(monkeypatch):
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["convert-video", "a.mp4", "b.mkv"])
+    assert run_cmd_spy.calls[0] == ["ffmpeg", "-i", "a.mp4", "-c", "copy", "b.mkv", "-y"]
+
+
+def test_convert_video_wildcard(monkeypatch, tmp_path):
+    src_dir = tmp_path / "src"
+    out_dir = tmp_path / "out"
+    src_dir.mkdir()
+    out_dir.mkdir()
+    (src_dir / "a.mp4").write_text("x")
+    (src_dir / "b.mp4").write_text("x")
+    run_cmd_spy = RunCmdSpy()
+    monkeypatch.setattr(lc, "run_cmd", run_cmd_spy)
+    run_main_with_args(monkeypatch, ["convert-vid", str(src_dir / "*.mp4"), str(out_dir / "out.mkv")])
+    assert run_cmd_spy.calls[0] == ["ffmpeg", "-i", str(src_dir / "a.mp4"), "-c", "copy", str(out_dir / "a.mkv"), "-y"]
+    assert run_cmd_spy.calls[1] == ["ffmpeg", "-i", str(src_dir / "b.mp4"), "-c", "copy", str(out_dir / "b.mkv"), "-y"]

linux-command-0.2.3/setup.py

@@ -1,27 +0,0 @@
-from setuptools import setup, find_packages
-from linux_command.linux_command import VERSION, PROJECT_URL
-
-
-setup(
-    name='linux-command',
-    version=VERSION,
-    packages=find_packages(),
-    entry_points={
-        'console_scripts': [
-            'cmd=linux_command.linux_command:main',
-        ],
-    },
-    install_requires=[],
-    author='Mouxiao Huang',
-    author_email='huangmouxiao@gmail.com',
-    description='A command line tool to perform custom tasks.',
-    long_description=open('README.md').read(),
-    long_description_content_type='text/markdown',
-    url=PROJECT_URL,
-    classifiers=[
-        'Programming Language :: Python :: 3',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
-    ],
-    python_requires='>=3.6',
-)