Командная строка Python: как создать гибкие CLI-интерфейсы

import sys

# Проверяем количество аргументов
if len(sys.argv) < 3:
print("Использование: python script.py <input_file> <output_file>")
sys.exit(1)

input_file = sys.argv[1]
output_file = sys.argv[2]
verbose = "--verbose" in sys.argv

print(f"Входной файл: {input_file}")
print(f"Выходной файл: {output_file}")
print(f"Подробный вывод: {'включен' if verbose else 'выключен'}")

# Дополнительная логика обработки...

import sys

args = sys.argv[1:]
params = {}

i = 0
while i < len(args):
if args[i].startswith('--'):
param_name = args[i][2:] # Убираем '--'
if i + 1 < len(args) and not args[i+1].startswith('--'):
params[param_name] = args[i+1]
i += 2
else:
params[param_name] = True # Флаг без значения
i += 1
else:
# Позиционный аргумент
if 'positional' not in params:
params['positional'] = []
params['positional'].append(args[i])
i += 1

print("Параметры:", params)

import argparse

# Создаем парсер аргументов
parser = argparse.ArgumentParser(description='Обработка файлов данных')

# Добавляем позиционные аргументы
parser.add_argument('input', help='Входной файл')
parser.add_argument('output', help='Выходной файл')

# Добавляем опциональные аргументы
parser.add_argument('--format', choices=['csv', 'json', 'xml'], 
default='csv', help='Формат выходного файла')
parser.add_argument('--verbose', '-v', action='store_true', 
help='Включить подробный вывод')
parser.add_argument('--max-lines', type=int, default=1000,
help='Максимальное число строк для обработки')

# Парсим аргументы командной строки
args = parser.parse_args()

# Используем аргументы в программе
print(f"Входной файл: {args.input}")
print(f"Выходной файл: {args.output}")
print(f"Формат: {args.format}")
print(f"Подробный вывод: {args.verbose}")
print(f"Макс. строк: {args.max_lines}")

usage: script.py [-h] [--format {csv,json,xml}] [--verbose] [--max-lines MAX_LINES] input output

Обработка файлов данных

positional arguments:
input Входной файл
output Выходной файл

optional arguments:
-h, --help show this help message and exit
--format {csv,json,xml}
Формат выходного файла (default: csv)
--verbose, -v Включить подробный вывод
--max-lines MAX_LINES
Максимальное число строк для обработки (default: 1000)

import argparse

# Создаем основной парсер
parser = argparse.ArgumentParser(description='Утилита для работы с данными')
subparsers = parser.add_subparsers(dest='command', help='Доступные команды')

# Создаем парсер для команды "convert"
convert_parser = subparsers.add_parser('convert', help='Конвертировать данные')
convert_parser.add_argument('input', help='Входной файл')
convert_parser.add_argument('output', help='Выходной файл')
convert_parser.add_argument('--format', default='json', 
choices=['json', 'csv', 'xml'],
help='Формат конвертации')

# Создаем парсер для команды "analyze"
analyze_parser = subparsers.add_parser('analyze', help='Анализировать данные')
analyze_parser.add_argument('file', help='Файл для анализа')
analyze_parser.add_argument('--stats', action='store_true',
help='Показать статистику')

# Парсим аргументы
args = parser.parse_args()

# Обрабатываем различные команды
if args.command == 'convert':
print(f"Конвертация {args.input} в {args.output} в формате {args.format}")
elif args.command == 'analyze':
print(f"Анализ файла {args.file}")
if args.stats:
print("С вычислением статистики")
else:
parser.print_help()

import click

@click.group()
def cli():
"""Утилита для обработки файлов."""
pass

@cli.command()
@click.argument('input_file', type=click.Path(exists=True))
@click.argument('output_file', type=click.Path())
@click.option('--format', '-f', type=click.Choice(['json', 'csv', 'xml']),
default='json', help='Формат выходного файла.')
@click.option('--verbose', '-v', is_flag=True, help='Включить подробный вывод.')
def convert(input_file, output_file, format, verbose):
"""Конвертирует файл из одного формата в другой."""
click.echo(f"Конвертация {input_file} в {output_file} (формат: {format})")
if verbose:
click.echo("Режим подробного вывода активирован")
# Логика конвертации...

@cli.command()
@click.argument('file', type=click.Path(exists=True))
@click.option('--lines', '-l', is_flag=True, help='Подсчитать количество строк.')
@click.option('--words', '-w', is_flag=True, help='Подсчитать количество слов.')
def analyze(file, lines, words):
"""Анализирует содержимое файла."""
click.echo(f"Анализ файла {file}")
if lines:
with open(file, 'r') as f:
line_count = sum(1 for _ in f)
click.echo(f"Количество строк: {line_count}")
if words:
with open(file, 'r') as f:
word_count = sum(len(line.split()) for line in f)
click.echo(f"Количество слов: {word_count}")

if __name__ == '__main__':
cli()

"""Naval Fate.

Usage:
naval_fate.py ship new <name>...
naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
naval_fate.py ship shoot <x> <y>
naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
naval_fate.py (-h | --help)
naval_fate.py --version

Options:
-h --help Show this screen.
--version Show version.
--speed=<kn> Speed in knots [default: 10].
--moored Moored (anchored) mine.
--drifting Drifting mine.

"""
from docopt import docopt

if __name__ == '__main__':
arguments = docopt(__doc__, version='Naval Fate 2.0')
print(arguments)

# Используем аргументы для управления логикой
if arguments['ship'] and arguments['new']:
print(f"Создаём корабль с именем: {' '.join(arguments['<name>'])}")
elif arguments['ship'] and arguments['move']:
print(f"Перемещаем {arguments['<name>']} к координатам ({arguments['<x>']}, {arguments['<y>']}) со скоростью {arguments['--speed']} узлов")
# ... и т.д. для других команд

import fire

class FileProcessor:
def convert(self, input_file, output_file, format='json', verbose=False):
"""Конвертирует файл из одного формата в другой.

Args:
input_file: Путь к входному файлу
output_file: Путь к выходному файлу
format: Формат выходного файла (json, csv, xml)
verbose: Включить подробный вывод
"""
print(f"Конвертация {input_file} в {output_file} (формат: {format})")
if verbose:
print("Режим подробного вывода активирован")
# Логика конвертации...

def analyze(self, file, count_lines=False, count_words=False):
"""Анализирует содержимое файла.

Args:
file: Путь к файлу для анализа
count_lines: Подсчитать количество строк
count_words: Подсчитать количество слов
"""
print(f"Анализ файла {file}")
if count_lines:
with open(file, 'r') as f:
line_count = sum(1 for _ in f)
print(f"Количество строк: {line_count}")
if count_words:
with open(file, 'r') as f:
word_count = sum(len(line.split()) for line in f)
print(f"Количество слов: {word_count}")

if __name__ == '__main__':
fire.Fire(FileProcessor)

import argparse
from PIL import Image
import os

def main():
parser = argparse.ArgumentParser(description='Инструмент для обработки изображений')
parser.add_argument('input', help='Входное изображение или директория')
parser.add_argument('-o', '--output', help='Выходная директория')
parser.add_argument('-f', '--format', choices=['jpg', 'png', 'webp'], 
default='jpg', help='Формат выходного изображения')
parser.add_argument('-q', '--quality', type=int, choices=range(1, 101),
default=85, help='Качество (1-100)')
parser.add_argument('-r', '--resize', type=int, nargs=2, 
metavar=('WIDTH', 'HEIGHT'),
help='Изменить размер до WIDTHxHEIGHT')
parser.add_argument('--recursive', action='store_true', 
help='Рекурсивная обработка директорий')

args = parser.parse_args()

# Определяем, это файл или директория
if os.path.isfile(args.input):
process_image(args.input, args)
elif os.path.isdir(args.input):
process_directory(args.input, args)
else:
print(f"Ошибка: {args.input} не существует")

def process_image(image_path, args):
try:
img = Image.open(image_path)

# Изменение размера, если указано
if args.resize:
img = img.resize((args.resize[0], args.resize[1]), Image.LANCZOS)

# Определение выходного пути
if args.output:
output_dir = args.output
else:
output_dir = os.path.dirname(image_path) or '.'

if not os.path.exists(output_dir):
os.makedirs(output_dir)

# Формирование имени файла
filename = os.path.basename(image_path)
name, _ = os.path.splitext(filename)
output_path = os.path.join(output_dir, f"{name}.{args.format}")

# Сохранение с указанным качеством
img.save(output_path, quality=args.quality)
print(f"Обработано: {image_path} -> {output_path}")

except Exception as e:
print(f"Ошибка при обработке {image_path}: {e}")

def process_directory(dir_path, args):
for item in os.listdir(dir_path):
item_path = os.path.join(dir_path, item)

if os.path.isfile(item_path) and item.lower().endswith(('jpg', 'jpeg', 'png')):
process_image(item_path, args)
elif os.path.isdir(item_path) and args.recursive:
process_directory(item_path, args)

if __name__ == '__main__':
main()

import argparse
import requests
import json
import os

def main():
parser = argparse.ArgumentParser(description='GitHub API CLI')
subparsers = parser.add_subparsers(dest='command', help='Команды')

# Команда для просмотра репозиториев
repos_parser = subparsers.add_parser('repos', help='Работа с репозиториями')
repos_parser.add_argument('--user', '-u', required=True,
help='Имя пользователя GitHub')
repos_parser.add_argument('--sort', choices=['updated', 'created', 'pushed'],
default='updated', help='Сортировка репозиториев')
repos_parser.add_argument('--limit', type=int, default=10,
help='Максимальное количество репозиториев')

# Команда для работы с issues
issues_parser = subparsers.add_parser('issues', help='Работа с issues')
issues_parser.add_argument('--repo', '-r', required=True,
help='Репозиторий в формате owner/repo')
issues_parser.add_argument('--state', choices=['open', 'closed', 'all'],
default='open', help='Статус issues')
issues_parser.add_argument('--assignee',
help='Фильтр по назначенному пользователю')

# Общие аргументы
parser.add_argument('--token', help='GitHub API token')
parser.add_argument('--output', '-o', help='Файл для сохранения результатов')

args = parser.parse_args()

# Получение токена из аргументов или переменных окружения
token = args.token or os.environ.get('GITHUB_TOKEN')
headers = {'Authorization': f'token {token}'} if token else {}

# Обработка команд
if args.command == 'repos':
url = f"https://api.github.com/users/{args.user}/repos"
params = {'sort': args.sort, 'per_page': args.limit}
process_request(url, headers, params, args.output)
elif args.command == 'issues':
url = f"https://api.github.com/repos/{args.repo}/issues"
params = {'state': args.state}
if args.assignee:
params['assignee'] = args.assignee
process_request(url, headers, params, args.output)
else:
parser.print_help()

def process_request(url, headers, params, output_file):
try:
response = requests.get(url, headers=headers, params=params)
response.raise_for_status()
data = response.json()

if output_file:
with open(output_file, 'w') as f:
json.dump(data, f, indent=2)
print(f"Результаты сохранены в {output_file}")
else:
print(json.dumps(data, indent=2))
except requests.exceptions.RequestException as e:
print(f"Ошибка запроса: {e}")
except Exception as e:
print(f"Ошибка: {e}")

if __name__ == '__main__':
main()

import argparse
import subprocess
import os
import sys
import datetime

def main():
parser = argparse.ArgumentParser(description='Инструмент для автоматизации деплоя')
parser.add_argument('environment', choices=['dev', 'staging', 'production'],
help='Среда для деплоя')
parser.add_argument('--version', help='Версия для деплоя (по умолчанию – текущая дата)')
parser.add_argument('--skip-tests', action='store_true',
help='Пропустить запуск тестов')
parser.add_argument('--skip-build', action='store_true',
help='Пропустить сборку проекта')
parser.add_argument('--notify', nargs='+',
help='Email-адреса для оповещения о результатах')
parser.add_argument('--dry-run', action='store_true',
help='Вывести команды без их выполнения')

args = parser.parse_args()

# Генерация версии, если не указана
version = args.version or datetime.datetime.now().strftime('%Y%m%d_%H%M')

# Логирование
log_file = f"deploy_{args.environment}_{version}.log"
print(f"Начинаем деплой в {args.environment} (версия: {version})")
print(f"Лог будет сохранен в {log_file}")

try:
# Запуск тестов
if not args.skip_tests:
run_command("Запуск тестов", ["pytest", "--verbose"], args.dry_run, log_file)

# Сборка проекта
if not args.skip_build:
run_command("Сборка проекта", ["npm", "run", "build"], args.dry_run, log_file)

# Деплой в выбранную среду
deploy_command = ["ansible-playbook", f"deploy_{args.environment}.yml",
"-e", f"version={version}"]
run_command(f"Деплой в {args.environment}", deploy_command, args.dry_run, log_file)

# Проверка статуса после деплоя
health_check_command = ["curl", "-s", f"https://{args.environment}.example.com/health"]
run_command("Проверка статуса", health_check_command, args.dry_run, log_file)

# Отправка уведомлений
if args.notify:
for email in args.notify:
notify_command = ["mail", "-s", f"Деплой в {args.environment} успешен", email]
run_command(f"Отправка уведомления на {email}", notify_command, args.dry_run, log_file)

print(f"Деплой в {args.environment} (версия: {version}) успешно завершен")

except Exception as e:
print(f"Ошибка при деплое: {e}")
sys.exit(1)

def run_command(step_name, command, dry_run, log_file):
print(f"\n### {step_name} ###")
print(f"Выполняем: {' '.join(command)}")

if dry_run:
print("(dry-run, команда не выполнена)")
return

try:
with open(log_file, 'a') as log:
log.write(f"\n### {step_name} ###\n")
log.write(f"$ {' '.join(command)}\n")

result = subprocess.run(command, capture_output=True, text=True)
log.write(result.stdout)

if result.stderr:
log.write(f"STDERR:\n{result.stderr}\n")

if result.returncode != 0:
error_msg = f"Ошибка при выполнении {step_name} (код {result.returncode})"
log.write(f"{error_msg}\n")
raise Exception(error_msg)

except subprocess.SubprocessError as e:
print(f"Ошибка при выполнении команды: {e}")
raise

if __name__ == '__main__':
main()