clinkey-cli 1.0.0__tar.gz

clinkey_cli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dimitri Gaggioli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

clinkey_cli-1.0.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: clinkey-cli
+Version: 1.0.0
+Summary: A command-line tool for generating strong passwords and secret keys.
+Author: Clinkey
+License-Expression: MIT
+Keywords: password,cli,security
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Security
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+![](clinkey_preview.png)  
+
+---
+```bash
+Your password generator *'buddy'*, available on a CLI.  
+```
+---
+```bash
+Usage python3 heat.py clinkey [OPTIONS]
+```
+---
+```bash
+-l, --length				The desired length for the output password(s)
+-n, --number				The amount of password you are expecting from ClinKey to generate.
+-o, --output				The path of a file in which to print the result instead of echoing it into the Terminal.
+-t --type					The strength and complexity of the password content. 
+								Possible values:
+									- 'normal' - Containing only alphabetical characters.
+									- 'strong' - Mixing letters and digits.
+									- 'super_strong' - Adding special characters to the result.
+-ns, --no-sep				Clear the result from the hyphens used to separate the groups of letters usually forming the result.
+-low, --lower				Transform the output password in lowercase string.

clinkey_cli-1.0.0/README.md

@@ -0,0 +1,22 @@
+![](clinkey_preview.png)  
+
+---
+```bash
+Your password generator *'buddy'*, available on a CLI.  
+```
+---
+```bash
+Usage python3 heat.py clinkey [OPTIONS]
+```
+---
+```bash
+-l, --length				The desired length for the output password(s)
+-n, --number				The amount of password you are expecting from ClinKey to generate.
+-o, --output				The path of a file in which to print the result instead of echoing it into the Terminal.
+-t --type					The strength and complexity of the password content. 
+								Possible values:
+									- 'normal' - Containing only alphabetical characters.
+									- 'strong' - Mixing letters and digits.
+									- 'super_strong' - Adding special characters to the result.
+-ns, --no-sep				Clear the result from the hyphens used to separate the groups of letters usually forming the result.
+-low, --lower				Transform the output password in lowercase string.

clinkey_cli-1.0.0/clinkey_cli/__init__.py

@@ -0,0 +1,6 @@
+"""clinkey-cli package public API."""
+
+from .main import Clinkey, clinkey
+
+__all__ = ["Clinkey", "clinkey"]
+__version__ = "1.0.0"

clinkey_cli-1.0.0/clinkey_cli/cli.py

@@ -0,0 +1,302 @@
+"""Click-based command line interface for the clinkey password generator."""
+
+from __future__ import annotations
+
+import pathlib
+from typing import Iterable, Optional
+
+import click
+from rich import box
+from rich.align import Align
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .main import Clinkey
+
+
+console = Console(style="on grey11")
+
+
+class ClinkeyView:
+    """Render user interactions with Rich while mirroring the original styling."""
+
+    def __init__(self) -> None:
+        self._logo_style = {
+            "title_color": "light_green",
+            "accent_color": "orchid1",
+            "text_color": "grey100",
+        }
+
+    def _clear(self) -> None:
+        console.clear()
+
+    def _logo_panel(self) -> Panel:
+        logo = Text(
+            """
+╔═╝  ║    ╝  ╔═   ║ ║  ╔═╝  ║ ║
+║    ║    ║  ║ ║  ╔╝   ╔═╝  ═╔╝
+══╝  ══╝  ╝  ╝ ╝  ╝ ╝  ══╝   ╝ 
+            """,
+            style=self._logo_style["title_color"],
+            justify="center",
+        )
+        return Panel.fit(
+            logo,
+            padding=(0, 2),
+            box=box.ROUNDED,
+            border_style=self._logo_style["accent_color"],
+        )
+
+    def display_logo(self) -> None:
+        self._clear()
+        console.print("\n\n")
+        console.print(self._logo_panel(), justify="center")
+        subtitle = Text.from_markup(
+            "Your own [bold light_green]SECRET BUDDY[/]...\n\n",
+            style="white",
+            justify="center",
+        )
+        console.print(Align.center(subtitle))
+        prompt = Text.from_markup(
+            "Press [bold light_green]ENTER[/] to continue...\n\n",
+            style="white",
+        )
+        console.print(Align.center(prompt), end="")
+        input()
+
+    def ask_for_type(self) -> str:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "How [bold light_green]BOLD[/] do you want your password?\n",
+                    style="white",
+                )
+            )
+        )
+        choices = Text.from_markup(
+            "1 - [bold orchid1]Vanilla[/] (letters only)\n"
+            "2 - [bold orchid1]Spicy[/] (letters and digits)\n"
+            "3 - [bold orchid1]Inferno[/] (letters, digits, symbols)",
+            style="white",
+        )
+        console.print(Align.center(choices))
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "Choose your [bold light_green]TRIBE[/] (1 / 2 / 3): ",
+                    style="bright_black",
+                )
+            ),
+            end="",
+        )
+        choice = input().strip()
+        return {"1": "normal", "2": "strong", "3": "super_strong"}.get(choice, "normal")
+
+    def ask_for_length(self) -> int:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "How [bold light_green]LONG[/] should it be?",
+                    style="white",
+                )
+            )
+        )
+        console.print(
+            Align.center(Text.from_markup("(default: 16): ", style="bright_black")),
+            end="",
+        )
+        value = input().strip()
+        try:
+            length = int(value)
+            return length if length > 0 else 16
+        except ValueError:
+            return 16
+
+    def ask_for_number(self) -> int:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "How [bold light_green]MANY[/] passwords do you need?",
+                    style="white",
+                )
+            )
+        )
+        console.print(
+            Align.center(Text.from_markup("(default: 1): ", style="bright_black")),
+            end="",
+        )
+        value = input().strip()
+        try:
+            count = int(value)
+            return count if count > 0 else 1
+        except ValueError:
+            return 1
+
+    def ask_for_options(self) -> list[str]:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "Any extra [bold light_green]OPTIONS[/]? (separate by spaces)",
+                    style="white",
+                )
+            )
+        )
+        console.print(
+            Align.center(Text.from_markup("Available: lower, no_sep", style="bright_black"))
+        )
+        choices = input().strip()
+        return choices.split() if choices else []
+
+    def ask_for_output_path(self) -> Optional[str]:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Align.center(
+                Text.from_markup(
+                    "Enter a file path to save the result (press ENTER to skip):",
+                    style="white",
+                )
+            ),
+            end="",
+        )
+        value = input().strip()
+        return value or None
+
+    def display_passwords(self, passwords: Iterable[str]) -> None:
+        self._clear()
+        console.print(self._logo_panel(), justify="center")
+        console.print(
+            Panel.fit(
+                Align.center(
+                    Text.from_markup(
+                        "Your Clinkey [bold light_green]PASSWORDS[/] are [bold light_green]READY[/]",
+                        style="white",
+                    )
+                ),
+                padding=(0, 1),
+                box=box.ROUNDED,
+                border_style=self._logo_style["accent_color"],
+            ),
+            justify="center",
+        )
+        table = Table(show_header=False, box=box.ROUNDED, border_style=self._logo_style["accent_color"])
+        table.add_column("password", style=self._logo_style["title_color"], justify="center")
+        for password in passwords:
+            table.add_row(Text(password, style="white", justify="center"))
+        console.print(table, justify="center")
+
+        console.print(
+            Align.center(
+                Text.from_markup("Choose one to copy and stay safe!", style="bright_black"),
+            )
+        )
+
+
+view = ClinkeyView()
+
+def _parse_extra_options(options: Iterable[str]) -> dict[str, bool]:
+    lookup = {
+        "lower": {"lower", "low", "-l", "--lower"},
+        "no_sep": {"no_sep", "nosep", "-ns", "--no-sep", "no-sep", "ns"},
+    }
+    result = {"lower": False, "no_sep": False}
+    for option in options:
+        token = option.strip().lower()
+        for key, aliases in lookup.items():
+            if token in aliases:
+                result[key] = True
+    return result
+
+
+def _write_passwords(path: pathlib.Path, passwords: Iterable[str]) -> None:
+    with path.open("w", encoding="utf-8") as handle:
+        for password in passwords:
+            handle.write(f"{password}\n")
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option("-l", "--length", type=int, default=None, help="Password length (default: 16).")
+@click.option(
+    "-t",
+    "--type",
+    "type_",
+    type=click.Choice(["normal", "strong", "super_strong"], case_sensitive=False),
+    default=None,
+    help="Password profile: normal, strong, or super_strong.",
+)
+@click.option(
+    "-n",
+    "--number",
+    type=int,
+    default=None,
+    help="Number of passwords to generate (default: 1).",
+)
+@click.option("-ns", "--no-sep", "no_sep", is_flag=True, help="Remove separators from the result.")
+@click.option("-low", "--lower", is_flag=True, help="Convert generated passwords to lowercase.")
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(dir_okay=False, writable=True, resolve_path=True, path_type=pathlib.Path),
+    default=None,
+    help="Write the result to a file instead of displaying it.",
+)
+def main(
+    length: Optional[int],
+    type_: Optional[str],
+    number: Optional[int],
+    no_sep: bool,
+    lower: bool,
+    output: Optional[pathlib.Path],
+) -> None:
+    """Generate secure, pronounceable passwords from your terminal."""
+
+    generator = Clinkey()
+
+    interactive = length is None and type_ is None and number is None
+
+    if interactive:
+        view.display_logo()
+        length = view.ask_for_length()
+        type_ = view.ask_for_type()
+        number = view.ask_for_number()
+        extra = _parse_extra_options(view.ask_for_options())
+        lower = extra["lower"]
+        no_sep = extra["no_sep"]
+        chosen_output = view.ask_for_output_path()
+        if chosen_output:
+            output = pathlib.Path(chosen_output).expanduser().resolve()
+
+    length = 16 if length is None else length
+    type_ = "normal" if type_ is None else type_.lower()
+    number = 1 if number is None else number
+
+    passwords = generator.generate_batch(
+        length=length,
+        type=type_,
+        count=number,
+        lower=lower,
+        no_separator=no_sep,
+    )
+
+    if output:
+        _write_passwords(output, passwords)
+        click.echo(f"Passwords saved to {output}")
+    elif interactive:
+        view.display_passwords(passwords)
+    else:
+        for password in passwords:
+            click.echo(password)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

clinkey_cli-1.0.0/clinkey_cli/main.py

@@ -0,0 +1,225 @@
+"""Core password generation logic for the Clinkey CLI package."""
+
+from __future__ import annotations
+
+import random
+import string
+from typing import Callable, Dict
+
+
+class Clinkey:
+    """Generate pronounceable passwords with different complexity presets."""
+
+    def __init__(self) -> None:
+        alphabet = string.ascii_uppercase
+        vowels = "AEIOUY"
+        self._consonants = [char for char in alphabet if char not in vowels]
+        self._vowels = list(vowels)
+        self._digits = list(string.digits)
+        self._specials = [
+            char
+            for char in string.punctuation
+            if char not in {"-", "_", "$", "#", "|", "<", ">", "(", ")", "[", "]", "{", "}", '"', "'", "`", "@", " "}
+        ]
+
+        self._simple_syllables = [consonant + vowel for consonant in self._consonants for vowel in self._vowels]
+        self._complex_syllables = [
+            "TRE",
+            "TRI",
+            "TRO",
+            "TRA",
+            "DRE",
+            "DRI",
+            "DRO",
+            "DRA",
+            "BRE",
+            "BRI",
+            "BRO",
+            "BRA",
+            "CRE",
+            "CRI",
+            "CRO",
+            "CRA",
+            "FRE",
+            "FRI",
+            "FRO",
+            "FRA",
+            "GRE",
+            "GRI",
+            "GRO",
+            "GRA",
+            "PRE",
+            "PRI",
+            "PRO",
+            "PRA",
+            "SRE",
+            "SRI",
+            "SRO",
+            "SRA",
+            "VRE",
+            "VRI",
+            "VRO",
+            "VRA",
+            "ZRE",
+            "ZRI",
+            "ZRO",
+            "ZRA",
+            "LON",
+            "LEN",
+            "LIN",
+            "LAN",
+            "MON",
+            "MEN",
+            "MIN",
+            "MAN",
+            "NON",
+            "NEN",
+            "NIN",
+            "NAN",
+            "PON",
+            "PEN",
+            "PIN",
+            "PAN",
+            "RON",
+            "REN",
+            "RIN",
+            "RAN",
+            "SON",
+            "SEN",
+            "SIN",
+            "SAN",
+            "TON",
+            "TEN",
+            "TIN",
+            "TAN",
+            "VON",
+            "VEN",
+            "VIN",
+            "VAN",
+            "ZON",
+            "ZEN",
+            "ZIN",
+            "ZAN",
+        ]
+
+        self._separators = ["-", "_"]
+        self._generators: Dict[str, Callable[[], str]] = {
+            "normal": self.normal,
+            "strong": self.strong,
+            "super_strong": self.super_strong,
+        }
+
+    def _generate_simple_syllable(self) -> str:
+        return random.choice(self._simple_syllables)
+
+    def _generate_complex_syllable(self) -> str:
+        return random.choice(self._complex_syllables)
+
+    def _generate_pronounceable_word(self, min_length: int = 4, max_length: int = 8) -> str:
+        word = self._generate_simple_syllable()
+        target = random.randint(min_length, max_length)
+
+        while len(word) < target:
+            generator = random.choice([self._generate_simple_syllable, self._generate_complex_syllable])
+            word += generator()
+
+        return word[:target]
+
+    def _generate_number_block(self, length: int = 3) -> str:
+        return "".join(random.choices(self._digits, k=length))
+
+    def _generate_special_characters_block(self, length: int = 3) -> str:
+        return "".join(random.choices(self._specials, k=length))
+
+    def _generate_separator(self) -> str:
+        return random.choice(self._separators)
+
+    def super_strong(self) -> str:
+        words = [self._generate_pronounceable_word(random.randint(4, 6), random.randint(8, 12)) for _ in range(3)]
+        numbers = [self._generate_number_block(random.randint(3, 6)) for _ in range(3)]
+        specials = [self._generate_special_characters_block(random.randint(3, 6)) for _ in range(2)]
+        separators = [self._generate_separator() for _ in range(6)]
+
+        result = []
+        result.append(words.pop() + separators.pop() + specials.pop() + separators.pop() + numbers.pop() + separators.pop())
+        result.append(words.pop() + separators.pop() + specials.pop() + separators.pop() + numbers.pop() + separators.pop())
+        result.append(words.pop())
+        return "".join(result)
+
+    def strong(self) -> str:
+        words = [self._generate_pronounceable_word(random.randint(4, 6), random.randint(8, 12)) for _ in range(3)]
+        numbers = [self._generate_number_block(random.randint(3, 6)) for _ in range(3)]
+        separators = [self._generate_separator() for _ in range(6)]
+
+        result = []
+        for _ in range(3):
+            result.append(words.pop(0) + separators.pop(0) + numbers.pop(0) + separators.pop(0))
+        return "".join(result)
+
+    def normal(self) -> str:
+        words = [self._generate_pronounceable_word(random.randint(4, 6), random.randint(8, 12)) for _ in range(3)]
+        separators = [self._generate_separator() for _ in range(6)]
+
+        result = []
+        for _ in range(3):
+            result.append(words.pop(0) + separators.pop(0))
+        return "".join(result)
+
+    def _fit_to_length(self, generator: Callable[[], str], target_length: int) -> str:
+        password = ""
+        while len(password) < target_length:
+            chunk = generator()
+            if len(password) + len(chunk) <= target_length:
+                password += chunk
+            else:
+                remaining = target_length - len(password)
+                password += chunk[:remaining]
+                break
+        return password
+
+    def generate_password(
+        self,
+        length: int = 16,
+        type: str = "normal",
+        lower: bool = False,
+        no_separator: bool = False,
+    ) -> str:
+        if length <= 0:
+            raise ValueError("length must be a positive integer")
+
+        key = type.strip().lower()
+        if key not in self._generators:
+            valid = ", ".join(sorted(self._generators.keys()))
+            raise ValueError(f"Unsupported type '{type}'. Choose among: {valid}.")
+
+        raw_password = self._fit_to_length(self._generators[key], length)
+        cleaned = raw_password.strip("-_")
+
+        if no_separator:
+            cleaned = cleaned.replace("-", "").replace("_", "")
+
+        if lower:
+            cleaned = cleaned.lower()
+
+        return cleaned
+
+    def generate_batch(
+        self,
+        length: int = 16,
+        type: str = "normal",
+        count: int = 1,
+        lower: bool = False,
+        no_separator: bool = False,
+    ) -> list[str]:
+        if count <= 0:
+            raise ValueError("count must be a positive integer")
+
+        return [
+            self.generate_password(length=length, type=type, lower=lower, no_separator=no_separator)
+            for _ in range(count)
+        ]
+
+
+clinkey = Clinkey()
+
+__all__ = ["Clinkey", "clinkey"]

clinkey_cli-1.0.0/clinkey_cli.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: clinkey-cli
+Version: 1.0.0
+Summary: A command-line tool for generating strong passwords and secret keys.
+Author: Clinkey
+License-Expression: MIT
+Keywords: password,cli,security
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Security
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+![](clinkey_preview.png)  
+
+---
+```bash
+Your password generator *'buddy'*, available on a CLI.  
+```
+---
+```bash
+Usage python3 heat.py clinkey [OPTIONS]
+```
+---
+```bash
+-l, --length				The desired length for the output password(s)
+-n, --number				The amount of password you are expecting from ClinKey to generate.
+-o, --output				The path of a file in which to print the result instead of echoing it into the Terminal.
+-t --type					The strength and complexity of the password content. 
+								Possible values:
+									- 'normal' - Containing only alphabetical characters.
+									- 'strong' - Mixing letters and digits.
+									- 'super_strong' - Adding special characters to the result.
+-ns, --no-sep				Clear the result from the hyphens used to separate the groups of letters usually forming the result.
+-low, --lower				Transform the output password in lowercase string.

clinkey_cli-1.0.0/clinkey_cli.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+clinkey_cli/__init__.py
+clinkey_cli/cli.py
+clinkey_cli/main.py
+clinkey_cli.egg-info/PKG-INFO
+clinkey_cli.egg-info/SOURCES.txt
+clinkey_cli.egg-info/dependency_links.txt
+clinkey_cli.egg-info/entry_points.txt
+clinkey_cli.egg-info/requires.txt
+clinkey_cli.egg-info/top_level.txt

clinkey_cli-1.0.0/clinkey_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clinkey_cli-1.0.0/clinkey_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clinkey = clinkey_cli.cli:main

clinkey_cli-1.0.0/clinkey_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.1.0
+rich>=13.0.0

clinkey_cli-1.0.0/clinkey_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+clinkey_cli

clinkey_cli-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=66", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clinkey-cli"
+version = "1.0.0"
+description = "A command-line tool for generating strong passwords and secret keys."
+readme = "README.md"
+requires-python = ">=3.7"
+license = "MIT"
+authors = [{name = "Clinkey"}]
+keywords = ["password", "cli", "security"]
+# J'ai ajouté des "classifiers" pour une meilleure visibilité sur PyPI
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Security",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "click>=8.1.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+clinkey = "clinkey_cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["clinkey_cli*"]

clinkey_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+