evm-cli 2.4.0__py3-none-any.whl

evm/exceptions.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+EVM 自定义异常体系
+
+所有 EVM 错误都继承自 EVMError，便于调用者统一捕获。
+"""
+
+
+class EVMError(Exception):
+    """EVM 所有错误的基类"""
+    pass
+
+
+class KeyNotFoundError(EVMError):
+    """请求的环境变量不存在"""
+    def __init__(self, key: str):
+        self.key = key
+        super().__init__(f"Environment variable '{key}' not found")
+
+
+class KeyAlreadyExistsError(EVMError):
+    """目标变量名已存在（rename/copy 冲突）"""
+    def __init__(self, key: str):
+        self.key = key
+        super().__init__(f"Environment variable '{key}' already exists")
+
+
+class StorageError(EVMError):
+    """存储文件读写失败"""
+    pass
+
+
+class CorruptedStorageError(StorageError):
+    """存储文件损坏（JSON 解析失败）"""
+    pass
+
+
+class StoragePermissionError(StorageError):
+    """存储文件权限不足"""
+    pass
+
+
+class LockTimeoutError(StorageError):
+    """获取文件锁超时"""
+    def __init__(self, path: str, timeout: float):
+        self.path = path
+        self.timeout = timeout
+        super().__init__(
+            f"Failed to acquire file lock on '{path}' within {timeout}s. "
+            f"Another process may be writing."
+        )
+
+
+class ExportError(EVMError):
+    """导出失败"""
+    pass
+
+
+class ImportFailedError(EVMError):
+    """导入失败"""
+    def __init__(self, message: str, file_path: str = None):
+        self.file_path = file_path
+        super().__init__(message)
+
+
+class CommandNotFoundError(EVMError):
+    """exec 命令找不到可执行文件"""
+    def __init__(self, command: str):
+        self.command = command
+        super().__init__(f"Command not found: {command}")
+
+
+class GroupNotFoundError(EVMError):
+    """请求的分组不存在"""
+    def __init__(self, group: str):
+        self.group = group
+        super().__init__(f"Group '{group}' not found or has no variables")
+
+
+class GroupOperationError(EVMError):
+    """分组操作错误（如删除 default 组）"""
+    pass
+
+
+class BackupError(EVMError):
+    """备份/恢复失败"""
+    pass
+
+
+class EditorError(EVMError):
+    """编辑器相关错误"""
+    pass
+
+
+class DecryptionError(EVMError):
+    """解密失败"""
+    pass
+
+
+class ValidationError(EVMError):
+    """变量值校验失败"""
+    def __init__(self, key: str, value: str, expected_format: str):
+        self.key = key
+        self.value = value
+        self.expected_format = expected_format
+        super().__init__(
+            f"Variable '{key}' value does not match format '{expected_format}'"
+        )
+
+
+class SchemaError(EVMError):
+    """Schema 相关错误"""
+    def __init__(self, message: str, key: str = None):
+        self.key = key
+        super().__init__(message)
+
+
+class OperationCancelledError(EVMError):
+    """用户取消操作"""
+    pass
+
+
+# 向后兼容别名（将在未来版本移除）
+PermissionError_ = StoragePermissionError
+ImportError_ = ImportFailedError
+
+
+__all__ = [
+    'EVMError',
+    'KeyNotFoundError',
+    'KeyAlreadyExistsError',
+    'StorageError',
+    'CorruptedStorageError',
+    'StoragePermissionError',
+    'LockTimeoutError',
+    'ExportError',
+    'ImportFailedError',
+    'CommandNotFoundError',
+    'GroupNotFoundError',
+    'GroupOperationError',
+    'BackupError',
+    'EditorError',
+    'DecryptionError',
+    'ValidationError',
+    'SchemaError',
+    'OperationCancelledError',
+    # 向后兼容
+    'PermissionError_',
+    'ImportError_',
+]

evm/formatters.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""
+EVM 输出格式化
+
+将业务数据转换为人类可读的终端输出。
+所有 print() 调用集中在此模块。
+"""
+
+import shutil
+from typing import Optional
+
+# 默认终端宽度（无法检测时的回退值）
+_DEFAULT_WIDTH = 80
+
+
+def _term_width() -> int:
+    """获取当前终端宽度，非终端环境返回默认值"""
+    return shutil.get_terminal_size((_DEFAULT_WIDTH, 24)).columns
+
+
+def print_vars_table(
+    vars_dict: dict[str, str],
+    title: str = "Environment Variables",
+    show_total: bool = True,
+) -> None:
+    """以表格形式打印变量字典"""
+    if not vars_dict:
+        print("No environment variables set")
+        return
+
+    max_key_len = max(len(k) for k in vars_dict.keys())
+    width = max(max_key_len + 50, min(_term_width(), 120))
+
+    print(f"\n{title}:")
+    print("-" * width)
+    for key, value in sorted(vars_dict.items()):
+        print(f"{key:<{max_key_len}} = {value}")
+    print("-" * width)
+    if show_total:
+        print(f"Total: {len(vars_dict)} variables")
+
+
+def print_vars_by_group(vars_dict: dict[str, str]) -> None:
+    """按分组打印变量"""
+    groups: dict[str, dict[str, str]] = {}
+    for key, value in vars_dict.items():
+        if ':' in key:
+            group, var_name = key.split(':', 1)
+        else:
+            group = 'default'
+            var_name = key
+        groups.setdefault(group, {})[var_name] = value
+
+    if not groups:
+        print("No environment variables to display")
+        return
+
+    width = min(_term_width(), 120)
+    print("\nEnvironment Variables (by group):")
+    print("=" * width)
+    total_vars = 0
+    for group_name in sorted(groups.keys()):
+        print(f"\n[{group_name}]")
+        print("-" * width)
+        group_vars = groups[group_name]
+        max_key_len = max(len(k) for k in group_vars.keys()) if group_vars else 0
+        for key, value in sorted(group_vars.items()):
+            print(f"{key:<{max_key_len}} = {value}")
+        print("-" * width)
+        print(f"{len(group_vars)} variables")
+        total_vars += len(group_vars)
+    print("\n+" * width)
+    print(f"Total: {len(groups)} groups, {total_vars} variables")
+
+
+def print_search_results(
+    results: dict[str, str],
+    pattern: str,
+    search_value: bool = False,
+) -> None:
+    """打印搜索结果"""
+    if not results:
+        search_text = "key and value" if search_value else "key"
+        print(f"No environment variables match '{pattern}' in {search_text}")
+        return
+
+    print_vars_table(
+        results,
+        title=f"Search results for '{pattern}'",
+    )
+
+
+def print_groups(groups: dict[str, int]) -> None:
+    """打印分组列表"""
+    if not groups:
+        print("No groups found. All variables are in the default namespace.")
+        return
+
+    width = min(_term_width(), 80)
+    print("\nAvailable Groups:")
+    print("-" * width)
+    for group in sorted(groups):
+        print(f"{group:<30} ({groups[group]} variables)")
+    print("-" * width)
+    print(f"Total: {len(groups)} groups")
+
+
+def print_info(info: dict) -> None:
+    """打印工具信息"""
+    print("EVM (Environment Variable Manager)")
+    print(f"Version: {info['version']}")
+    print(f"Author: {info['author']}")
+    print(f"License: {info['license']}")
+    print(f"Python: {info['python']}")
+    print(f"Platform: {info['platform']}")
+    print(f"Storage: {info['storage_path']}")
+    print(f"Storage exists: {info['storage_exists']}")
+    print(f"Total variables: {info['total_variables']}")
+    print(f"Total groups: {info['total_groups']}")
+    print(f"Secret variables: {info['secret_variables']}")
+    if info.get('groups'):
+        print("Groups:")
+        for g, c in sorted(info['groups'].items()):
+            print(f"  {g}: {c} variables")
+    print(f"\nRepository: {info['repository']}")
+
+
+def print_diff(diff_result: dict) -> None:
+    """打印 diff 结果"""
+    added = diff_result.get('added', {})
+    removed = diff_result.get('removed', {})
+    changed = diff_result.get('changed', {})
+    timestamp = diff_result.get('backup_timestamp', '')
+
+    if timestamp:
+        print(f"Comparing with backup (timestamp: {timestamp})\n")
+
+    if not added and not removed and not changed:
+        print("No differences found.")
+        return
+
+    width = min(_term_width(), 80)
+
+    if added:
+        print(f"Added ({len(added)}):")
+        print("-" * width)
+        for key, value in sorted(added.items()):
+            print(f"  + {key} = {value}")
+        print()
+
+    if removed:
+        print(f"Removed ({len(removed)}):")
+        print("-" * width)
+        for key, value in sorted(removed.items()):
+            print(f"  - {key} = {value}")
+        print()
+
+    if changed:
+        print(f"Changed ({len(changed)}):")
+        print("-" * width)
+        for key, values in sorted(changed.items()):
+            print(f"  ~ {key}")
+            print(f"      backup:  {values['backup']}")
+            print(f"      current: {values['current']}")
+        print()
+
+    total = len(added) + len(removed) + len(changed)
+    print(f"Total: {total} differences "
+          f"(+{len(added)} added, -{len(removed)} removed, ~{len(changed)} changed)")
+
+
+def print_load_memory_result(
+    loaded_count: int,
+    add_evm_prefix: bool,
+    filter_prefix: Optional[str],
+) -> None:
+    """打印 loadmemory 结果"""
+    if loaded_count > 0:
+        print(f"Loaded {loaded_count} environment variables to memory")
+        if add_evm_prefix:
+            print("Prefix 'EVM:' added to all variable names")
+        if filter_prefix:
+            print(f"Filter: keys starting with '{filter_prefix}'")
+    else:
+        print("No environment variables to load")
+        if filter_prefix:
+            print(f"No variables found with prefix '{filter_prefix}'")
+
+
+def print_history(entries: list[dict]) -> None:
+    """打印操作历史"""
+    if not entries:
+        print("No history entries found.")
+        return
+
+    width = min(_term_width(), 80)
+    print(f"\nOperation History (latest {len(entries)} entries):")
+    print("-" * width)
+    for entry in entries:
+        ts = entry.get('timestamp', '')[:19]
+        op = entry.get('operation', '')
+        key = entry.get('key', '')
+        details = entry.get('details', '')
+        status = entry.get('status', '')
+        status_mark = '✓' if status == 'success' else '✗'
+        line = f"  {ts}  {status_mark} {op:<12}"
+        if key:
+            line += f" {key}"
+        if details:
+            line += f"  ({details})"
+        print(line)
+    print("-" * width)
+
+
+def print_validate_result(key: str, result: dict) -> None:
+    """打印单个变量的校验结果"""
+    if result['valid']:
+        print(f"  ✓ {key}: valid")
+    else:
+        print(f"  ✗ {key}: INVALID")
+    for err in result.get('errors', []):
+        print(f"      error: {err}")
+    for warn in result.get('warnings', []):
+        print(f"      warning: {warn}")
+
+
+def print_validate_all(results: dict[str, dict]) -> None:
+    """打印所有变量的校验结果"""
+    if not results:
+        print("No schema definitions found.")
+        return
+
+    valid_count = sum(1 for r in results.values() if r['valid'])
+    total = len(results)
+
+    width = min(_term_width(), 80)
+    print(f"\nSchema Validation ({valid_count}/{total} valid):")
+    print("-" * width)
+    for key in sorted(results):
+        print_validate_result(key, results[key])
+    print("-" * width)
+    if valid_count == total:
+        print("All variables passed validation.")
+    else:
+        print(f"{total - valid_count} variable(s) failed validation.")
+
+
+def print_schema(schema: dict) -> None:
+    """打印 schema 定义"""
+    if not schema:
+        print("No schema definitions found.")
+        return
+
+    width = min(_term_width(), 80)
+    print("\nSchema Definitions:")
+    print("-" * width)
+    for key in sorted(schema):
+        entry = schema[key]
+        parts = []
+        if 'format' in entry:
+            parts.append(f"format={entry['format']}")
+        if 'required' in entry:
+            parts.append(f"required={entry['required']}")
+        if 'pattern' in entry:
+            parts.append(f"pattern={entry['pattern']}")
+        if 'description' in entry:
+            parts.append(f"desc={entry['description']}")
+        print(f"  {key:<30} {', '.join(parts)}")
+    print("-" * width)
+    print(f"Total: {len(schema)} definitions")
+
+
+__all__ = [
+    'print_vars_table',
+    'print_vars_by_group',
+    'print_search_results',
+    'print_groups',
+    'print_info',
+    'print_diff',
+    'print_load_memory_result',
+    'print_history',
+    'print_validate_result',
+    'print_validate_all',
+    'print_schema',
+]