pre-commit-crocodile 2.0.0__py3-none-any.whl

pre_commit_crocodile/package/version.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from os import environ
+from sys import version_info
+
+# Components
+from ..system.platform import Platform
+from .bundle import Bundle
+
+# Version class
+class Version:
+
+    # Getter
+    @staticmethod
+    def get() -> str:
+
+        # Fake test version
+        if Bundle.ENV_DEBUG_VERSION_FAKE in environ:
+            return environ[Bundle.ENV_DEBUG_VERSION_FAKE]
+
+        # Acquire version from metadata
+        try:
+            from importlib import metadata # pylint: disable=import-outside-toplevel
+            return metadata.version(Bundle.PACKAGE)
+        except Exception: # pylint: disable=broad-exception-caught # pragma: no cover
+            pass
+
+        # Acquire version from resources
+        try: # pragma: no cover
+            from pkg_resources import require # pylint: disable=import-outside-toplevel
+            name = __name__.split('.', maxsplit=1)[0]
+            return str(require(name)[0].version)
+
+        # Default fallback
+        except Exception: # pylint: disable=broad-exception-caught # pragma: no cover
+            return '0.0.0'
+
+    # Path
+    @staticmethod
+    def path() -> str:
+
+        # Acquire path
+        path = __file__
+
+        # Strip package path
+        index = path.rfind(Platform.PATH_SEPARATOR)
+        index = path.rfind(Platform.PATH_SEPARATOR, 0, index)
+        path = path[0:index]
+
+        # Result
+        return path
+
+    # Python
+    @staticmethod
+    def python() -> str:
+
+        # Acquire Python version
+        version = f'{version_info.major}.{version_info.minor}'
+
+        # Result
+        return version
+
+    # Revision
+    @staticmethod
+    def revision() -> str:
+
+        # Force package revision
+        if Bundle.ENV_DEBUG_REVISION_SHA in environ:
+            return environ[Bundle.ENV_DEBUG_REVISION_SHA]
+
+        # Acquire package version
+        version: str = Version.get()
+
+        # Handle development version
+        if '+g' in version:
+            return version.split('+g')[1].split('.')[0]
+
+        # Result
+        return version

pre_commit_crocodile/prints/boxes.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from shutil import get_terminal_size
+from typing import List
+
+# Components
+from ..system.platform import Platform
+from ..types.strings import Strings
+from .colors import Colors
+
+# Boxes class
+class Boxes:
+
+    # Constants
+    __TOP_LEFT: str = '╭' if Platform.IS_TTY_UTF8 else '-'
+    __TOP_LINE: str = '─' if Platform.IS_TTY_UTF8 else '-'
+    __TOP_RIGHT: str = '╮' if Platform.IS_TTY_UTF8 else '-'
+    __MIDDLE_LEFT: str = '│' if Platform.IS_TTY_UTF8 else '|'
+    __MIDDLE_RIGHT: str = '│' if Platform.IS_TTY_UTF8 else '|'
+    __BOTTOM_LEFT: str = '╰' if Platform.IS_TTY_UTF8 else '-'
+    __BOTTOM_LINE: str = '─' if Platform.IS_TTY_UTF8 else '-'
+    __BOTTOM_RIGHT: str = '╯' if Platform.IS_TTY_UTF8 else '-'
+    __OFFSET_LINE: int = 2
+    __PADDING_LINE: int = 2
+
+    # Members
+    __lines: List[str]
+
+    # Constructor
+    def __init__(self) -> None:
+
+        # Initialize members
+        self.__lines = []
+
+    # Adder
+    def add(self, line: str) -> None:
+
+        # Add line
+        self.__lines += [line]
+
+    # Printer
+    def print(self) -> None:
+
+        # Evaluate lines length
+        length = max(len(Colors.strip(line)) for line in self.__lines)
+
+        # Acquire terminal width
+        columns, _ = get_terminal_size()
+
+        # Limit line length
+        limit = columns - Boxes.__OFFSET_LINE - len(
+            Boxes.__MIDDLE_LEFT) - 2 * Boxes.__PADDING_LINE - len(Boxes.__MIDDLE_RIGHT)
+        limit = max(limit, 1)
+        length = min(length, limit)
+
+        # Header
+        print(' ')
+
+        # Print header line
+        print(f"{' ' * Boxes.__OFFSET_LINE}{Colors.YELLOW}{Boxes.__TOP_LEFT}" \
+            f'{Boxes.__TOP_LINE * (length + 2 * Boxes.__PADDING_LINE)}{Boxes.__TOP_RIGHT}')
+
+        # Print content lines
+        for line in self.__lines:
+            for part in Strings.wrap(line, length=length):
+                print(
+                    f"{' ' * Boxes.__OFFSET_LINE}{Colors.YELLOW}{Boxes.__MIDDLE_LEFT}" \
+                        f"{' ' * Boxes.__PADDING_LINE}{Strings.center(part, length)}" \
+                            f"{' ' * Boxes.__PADDING_LINE}{Colors.YELLOW}{Boxes.__MIDDLE_RIGHT}"
+                )
+
+        # Print bottom line
+        print(
+            f"{' ' * Boxes.__OFFSET_LINE}{Colors.YELLOW}{Boxes.__BOTTOM_LEFT}" \
+                f'{Boxes.__BOTTOM_LINE * (length + 2 * Boxes.__PADDING_LINE)}' \
+                    f'{Boxes.__BOTTOM_RIGHT}{Colors.RESET}'
+        )
+
+        # Footer
+        print(' ')
+        Platform.flush()

pre_commit_crocodile/prints/colors.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from typing import List
+
+# Modules libraries
+try:
+    try: # colored>=2.0.0
+        from colored import Colored
+    except ImportError: # colored<2.0.0 # pragma: no cover
+        from colored import colored as Colored
+except ModuleNotFoundError: # pragma: no cover
+    pass
+
+# Colors class, pylint: disable=too-few-public-methods
+class Colors:
+
+    # Attributes
+    ALL: List[str] = []
+    BOLD = ''
+    CYAN = ''
+    GREEN = ''
+    GREY = ''
+    RED = ''
+    RESET = ''
+    YELLOW = ''
+    YELLOW_LIGHT = ''
+
+    # Enabled
+    @staticmethod
+    def enabled() -> bool:
+
+        # Result
+        try:
+            return bool(Colored('').enabled())
+        except (NameError, TypeError): # pragma: no cover
+            return False
+
+    # Prepare
+    @staticmethod
+    def prepare() -> None:
+
+        # Colors enabled
+        if Colors.enabled():
+            Colors.RESET = Colored('reset').attribute()
+            Colors.BOLD = Colors.RESET + Colored('bold').attribute()
+            Colors.CYAN = Colors.BOLD + Colored('cyan').foreground()
+            Colors.GREEN = Colors.BOLD + Colored('green').foreground()
+            Colors.GREY = Colors.BOLD + Colored('light_gray').foreground()
+            Colors.RED = Colors.BOLD + Colored('red').foreground()
+            Colors.YELLOW = Colors.BOLD + Colored('yellow').foreground()
+            Colors.YELLOW_LIGHT = Colors.BOLD + Colored('light_yellow').foreground()
+            Colors.ALL = [
+                Colors.CYAN,
+                Colors.GREEN,
+                Colors.GREY,
+                Colors.RED,
+                Colors.YELLOW,
+                Colors.YELLOW_LIGHT,
+                Colors.BOLD,
+                Colors.RESET,
+            ]
+
+        # Colors disabled
+        else:
+            Colors.BOLD = ''
+            Colors.CYAN = ''
+            Colors.GREEN = ''
+            Colors.GREY = ''
+            Colors.RED = ''
+            Colors.RESET = ''
+            Colors.YELLOW = ''
+            Colors.YELLOW_LIGHT = ''
+            Colors.ALL = []
+
+    # Strip
+    @staticmethod
+    def strip(string: str) -> str:
+
+        # Strip all colors
+        for item in Colors.ALL:
+            string = string.replace(item, '')
+
+        # Result
+        return string

pre_commit_crocodile/system/commands.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from pathlib import Path
+from shutil import which
+import subprocess
+from typing import List
+
+# Commands
+class Commands:
+
+    # Exists
+    @staticmethod
+    def exists(binary: str) -> bool:
+
+        # Check system binary exists
+        return which(binary) is not None
+
+    # Grep
+    @staticmethod
+    def grep(file: Path, string: str) -> bool:
+
+        # Ignore missing file
+        if not file.exists():
+            return False
+
+        # Check file contains string
+        with open(
+                file,
+                encoding='utf8',
+                mode='r',
+        ) as f:
+            for line in f.readlines():
+
+                # Find string in line
+                if string in line:
+                    return True
+
+        # Fallback
+        return False # pragma: no cover
+
+    # Output
+    @staticmethod
+    def output(binary: str, arguments: List[str]) -> str:
+
+        # Get system output
+        try:
+            return subprocess.check_output(
+                args=[binary] + arguments,
+                cwd=None,
+                shell=False,
+            ).strip().decode()
+        except subprocess.CalledProcessError as err:
+            return str(err.output.decode())
+        except FileNotFoundError:
+            return ''
+
+    # Command
+    @staticmethod
+    def pip(arguments: List[str]) -> bool:
+
+        # Run with pipx
+        if Commands.exists('pipx'):
+            return Commands.run(
+                'pipx',
+                arguments,
+            )
+
+        # Run with pip # pragma: no cover
+        return Commands.run(
+            'sudo',
+            ['pip'] + arguments,
+        )
+
+    # Command
+    @staticmethod
+    def run(binary: str, arguments: List[str]) -> bool:
+
+        # Run system command
+        try:
+            process = subprocess.run(
+                args=[binary] + arguments,
+                cwd=None,
+                check=True,
+                shell=False,
+            )
+            return process.returncode == 0
+        except subprocess.CalledProcessError as e:
+            print(f"Error executing command: {e}")
+            return False

pre_commit_crocodile/system/platform.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from os import access, environ, R_OK, sep
+from os.path import expanduser
+from pathlib import Path
+from sys import platform, stdin, stdout
+
+# Platform
+class Platform:
+
+    # Environment
+    ENV_SIMULATE_MAC_OS: str = 'SIMULATE_MAC_OS'
+    ENV_SUDO_USER: str = 'SUDO_USER'
+
+    # Constants
+    IS_LINUX: bool = platform in ['linux', 'linux2']
+    IS_MAC_OS: bool = platform in ['darwin'] or ENV_SIMULATE_MAC_OS in environ
+    IS_SIMULATED: bool = ENV_SIMULATE_MAC_OS in environ
+    IS_WINDOWS: bool = platform in ['win32', 'win64']
+
+    # Separators
+    PATH_SEPARATOR: str = sep
+
+    # TTYs
+    IS_TTY_STDIN: bool = stdin.isatty() and stdin.encoding != 'cp1252'
+    IS_TTY_STDOUT: bool = stdout.isatty()
+    IS_TTY_UTF8: bool = str(stdout.encoding).lower() == 'utf-8'
+
+    # Outputs
+    IS_FLUSH_ENABLED: bool = IS_TTY_STDOUT or IS_WINDOWS
+
+    # Users
+    IS_USER_SUDO: bool = ENV_SUDO_USER in environ
+    USER_SUDO: str = environ[ENV_SUDO_USER] if IS_USER_SUDO else ''
+
+    # Flush
+    @staticmethod
+    def flush() -> None:
+
+        # Flush output
+        print(
+            '',
+            end='',
+            flush=Platform.IS_FLUSH_ENABLED,
+        )
+
+    # Userspace
+    @staticmethod
+    def userspace(name: str) -> Path:
+
+        # Variables
+        home: None | Path = None
+
+        # Elevated home
+        if Platform.IS_USER_SUDO:
+            home = Path(expanduser(f'~{Platform.USER_SUDO}'))
+            if not access(home, R_OK): # pragma: no cover
+                home = None
+
+        # Default home
+        if not home or not home.is_dir():
+            home = Path.home()
+
+        # Windows userspace
+        if Platform.IS_WINDOWS:
+            return home / 'AppData' / 'Local' / name
+
+        # macOS userspace
+        if Platform.IS_MAC_OS:
+            return home / 'Library' / 'Preferences' / name
+
+        # Linux userspace
+        return home / '.config' / name

pre_commit_crocodile/types/environments.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from os import environ
+from typing import Dict, List, NamedTuple
+
+# Environments class
+class Environments:
+
+    # Constants
+    LINE_EOL: str = '\n'
+
+    # Variable
+    class Variable(NamedTuple):
+
+        # Variables
+        name: str
+        description: str
+        fallback: str
+
+        # Value
+        @property
+        def value(self) -> str:
+            if self.fallback:
+                return environ.get(self.name, environ.get(self.fallback, ''))
+            return environ.get(self.name, '')
+
+    # Members
+    __group: str
+    __variables: Dict[str, Variable]
+
+    # Constructor
+    def __init__(self) -> None:
+        self.__group = ''
+        self.__variables = {}
+
+    # Group
+    @property
+    def group(self) -> str:
+        return self.__group
+
+    # Group
+    @group.setter
+    def group(self, value: str) -> None:
+        self.__group = value
+
+    # Add
+    def add(
+        self,
+        key: str,
+        name: str,
+        description: str,
+        fallback: str = '',
+    ) -> None:
+
+        # Append variable to list
+        self.__variables[key] = Environments.Variable(
+            name=name,
+            description=description,
+            fallback=fallback,
+        )
+
+    # Help
+    def help(self, help_position: int) -> str:
+
+        # Variables
+        lines: List[str] = []
+
+        # Append group
+        if self.__group:
+            lines += [f'{self.__group}:']
+
+        # Append variables
+        for _, variable in self.__variables.items():
+            line = f'  {variable.name: <{help_position - 2}}'
+            line += f'{variable.description}'
+            if variable.fallback:
+                line += f' (fallback: {variable.fallback})'
+            lines += [line]
+
+        # Result
+        return Environments.LINE_EOL.join(lines)
+
+    # Value
+    def value(self, key: str) -> str:
+
+        # Get value of declared variable
+        if key in self.__variables:
+            return self.__variables[key].value
+
+        # Fallback
+        return ''

pre_commit_crocodile/types/strings.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from random import choices
+from string import ascii_letters, digits
+from typing import List
+
+# Components
+from ..prints.colors import Colors
+
+# Strings class
+class Strings:
+
+    # Center
+    @staticmethod
+    def center(string: str, length: int) -> str:
+
+        # Extract text
+        text: str = Colors.strip(string)
+
+        # Center string
+        if len(text) < length:
+            paddings = length - len(text)
+            left = paddings // 2
+            right = -(-paddings // 2)
+            return ' ' * left + string + ' ' * right
+
+        # Default string
+        return string
+
+    # Quote
+    @staticmethod
+    def quote(string: str) -> str: # pragma: no cover
+
+        # Single quotes
+        if '\'' not in string:
+            return '\'' + string + '\''
+
+        # Double quotes
+        if '\"' not in string:
+            return '\"' + string + '\"'
+
+        # Adaptive quotes
+        return '\'' + string.replace('\'', '\\\'') + '\''
+
+    # Random
+    @staticmethod
+    def random(length: int) -> str: # pragma: no cover
+
+        # Generate random string
+        return ''.join(choices(ascii_letters + digits, k=length))
+
+    # Wrap
+    @staticmethod
+    def wrap(string: str, length: int) -> List[str]:
+
+        # Variables
+        color: str = ''
+        index: int = 0
+        line_data: str = ''
+        line_length: int = 0
+        lines: List[str] = []
+        space: str = ''
+        word: str = ''
+
+        # Length limitations
+        length = max(length, 1)
+
+        # Append line
+        def append_line() -> None:
+            nonlocal line_data, line_length, lines
+            if line_length > 0:
+                lines += [line_data]
+                line_data = ''
+                line_length = 0
+
+        # Store word
+        def store_word() -> None:
+            nonlocal color, length, line_data, line_length, space, word
+            if len(word) > 0:
+
+                # Word overflows
+                if line_length + len(space) + len(word) > length:
+                    word_full = word
+                    if len(word_full) > length:
+                        while len(word_full) > 0:
+                            word = word_full[0:length]
+                            store_word()
+                            word_full = word_full[length:]
+                    append_line()
+
+                # Word spacing
+                if line_length > 0 and space:
+                    line_data += space
+                    line_length += len(space)
+                space = ''
+
+                # Word appendation
+                line_data += color + word
+                line_length += len(word)
+                word = ''
+
+                # Line wrapping
+                if line_length >= length:
+                    append_line()
+
+        # Add char
+        def add_char(char: str) -> None:
+            nonlocal index, word
+            index += 1
+            word += char
+
+        # Iterate through chars
+        while index < len(string):
+
+            # Space separator
+            if string[index] == ' ':
+
+                # Store last word
+                store_word()
+
+                # Reset word data
+                space += ' '
+                index += 1
+                continue
+
+            # Color marker
+            for item in Colors.ALL:
+                if item and string[index:].startswith(item):
+
+                    # Store last word
+                    store_word()
+
+                    # Store new color
+                    color = item
+                    index += len(color)
+                    break
+
+            # Text content
+            else:
+
+                # Append character
+                add_char(string[index])
+
+        # Store last word
+        store_word()
+
+        # Append last line
+        append_line()
+
+        # Result
+        return lines