kpass-gen 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

kpass/__init__.py

@@ -1,3 +1,19 @@
-from .generator import generator, save_to_txt, aplly_ciphers
+from .main import (
+    generator,
+    save_to_txt,
+    aplly_ciphers,
+    check_sequences,
+    veredict,
+    verify,
+)
 
-__version__ = "0.1.4"
+__version__ = "0.2.0"
+
+__all__ = [
+    "generator",
+    "save_to_txt",
+    "aplly_ciphers",
+    "check_sequences",
+    "veredict",
+    "verify",
+]

kpass/main.py

@@ -0,0 +1,221 @@
+import itertools
+from rich.progress import Progress, BarColumn, TextColumn, TimeElapsedColumn
+import re
+import string
+
+# -----------------------------------------------------------------------------
+# Ciphers dictionary to replace letters with leetspeak equivalents
+# Each key is a character and the corresponding value is its cipher substitution
+# -----------------------------------------------------------------------------
+
+ciphers = {
+    "A": "4", "a": "4", "Á": "4", "á": "4", "@": "4",
+    "B": "8", "b": "8",
+    "C": "(", "c": "(",
+    "D": "[)", "d": "[)",
+    "E": "3", "e": "3", "É": "3", "é": "3", "&": "3",
+    "F": "#", "f": "#",
+    "G": "6", "g": "6",
+    "H": "#", "h": "#",
+    "I": "1", "i": "1", "Í": "1", "í": "1", "!": "1",
+    "J": "_|", "j": "_|",
+    "K": "|<", "k": "|<",
+    "L": "1", "l": "1",
+    "M": "/\\/\\", "m": "/\\/\\",
+    "N": "|\\|", "n": "|\\|",
+    "O": "0", "o": "0", "Ó": "0", "ó": "0",
+    "P": "|D", "p": "|D",
+    "Q": "0_", "q": "0_",
+    "R": "12", "r": "12",
+    "S": "$", "s": "$", "Š": "$", "š": "$",
+    "T": "7", "t": "7",
+    "U": "(_)", "u": "(_)",
+    "V": "\\/", "v": "\\/",
+    "W": "\\/\\/", "w": "\\/\\/",
+    "X": "%", "x": "%",
+    "Y": "`/", "y": "`/",
+    "Z": "2", "z": "2"
+}
+
+# -----------------------------------------------------------------------------
+# Function: aplly_ciphers
+# Description:
+#   Transforms input text by replacing each character according to the ciphers dict
+# Parameters:
+#   text (str): The original text to be ciphered
+# Returns:
+#   str: The transformed text with cipher substitutions
+# -----------------------------------------------------------------------------
+
+def aplly_ciphers(text: str) -> str:
+    return ''.join(ciphers.get(char, char) for char in text)
+
+# -----------------------------------------------------------------------------
+# Function: save_to_txt
+# Description:
+#   Writes a list of passwords to a text file, showing progress in the console
+# Parameters:
+#   passwords (list[str]): List of password strings to save
+#   file_name (str): Output filename (default: 'pass_generated.txt')
+# Returns:
+#   None
+# -----------------------------------------------------------------------------
+
+def save_to_txt(passwords: list[str], file_name: str = "pass_generated.txt") -> None:
+    with open(file_name, "w", encoding="utf-8-sig") as file:
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TimeElapsedColumn(),
+        ) as progress:
+            tarefa = progress.add_task("[cyan]Saving passwords...", total=len(passwords))
+            for pwd in passwords:
+                file.write(pwd + "\n")
+                progress.update(tarefa, advance=1)
+
+# -----------------------------------------------------------------------------
+# Function: generator
+# Description:
+#   Builds possible password permutations based on user info and ciphers,
+#   filters by length, and saves them using save_to_txt()
+# Parameters:
+#   name (str): Full name input for generating bases
+#   age (str): Age string (e.g., '25')
+#   birth_date (str): Birth date in 'DD/MM/YYYY' format
+# Returns:
+#   None (calls save_to_txt internally)
+# -----------------------------------------------------------------------------
+
+def generator(name: str, age: str, birth_date: str) -> None:
+    # Split birth_date into components
+    day, month, year = birth_date.split("/")
+
+    # Normalize variants of the name
+    name_tiny = name.lower().replace(" ", "")
+    name_capital = name.upper().replace(" ", "")
+
+    parts = name.split()
+    first = parts[0]
+    middle = "".join(parts[1:-1]) if len(parts) > 2 else ""
+    last = parts[-1] if len(parts) > 1 else ""
+
+    # Reverse age string for variation
+    age_reversed = age[::-1]
+
+    # Base building blocks for passwords
+    base_combinations = [
+        name_tiny, name_capital, first, middle, last,
+        day, month, year,
+        age, age_reversed,
+        aplly_ciphers(name_tiny), aplly_ciphers(first), aplly_ciphers(last)
+    ]
+
+    # Remove duplicates and empty strings
+    base_combinations = list({item for item in base_combinations if item.strip()})
+
+    possible_passwords = set()
+
+    # Calculate total permutations for progress bar
+    total = sum(len(list(itertools.permutations(base_combinations, i))) for i in range(2, 5))
+
+    with Progress(
+        TextColumn("[cyan]Generating passwords..."),
+        BarColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("passwords", total=total)
+        for length in range(2, 5):
+            for combo in itertools.permutations(base_combinations, length):
+                pwd = "".join(combo)
+                if 6 <= len(pwd) <= 18:
+                    possible_passwords.add(pwd)
+                progress.update(task, advance=1)
+
+    # Save results to file
+    save_to_txt(list(possible_passwords))
+
+# -----------------------------------------------------------------------------
+# Function: check_sequences
+# Description:
+#   Detects ascending or descending numeric sequences of length 3 in password
+# Parameters:
+#   password (str): The password string to check
+# Returns:
+#   bool: True if a sequence is found, False otherwise
+# -----------------------------------------------------------------------------
+
+def check_sequences(password: str) -> bool:
+    digits = [int(c) for c in password if c.isdigit()]
+    for i in range(len(digits) - 2):
+        if digits[i] + 1 == digits[i+1] == digits[i+2] - 1:
+            return True
+        if digits[i] - 1 == digits[i+1] == digits[i+2] + 1:
+            return True
+    return False
+
+# -----------------------------------------------------------------------------
+# Function: veredict
+# Description:
+#   Maps numeric strength score to a hashtag-based verdict string
+# Parameters:
+#   score (int): Numeric strength score (0-6)\# Returns:
+#   str: Verdict hashtag
+# -----------------------------------------------------------------------------
+
+def veredict(score: int) -> str:
+    levels = [
+        "#very_weak",   # 0
+        "#weak",        # 1
+        "#weak",        # 2
+        "#mean",        # 3
+        "#good",        # 4
+        "#strong",      # 5
+        "#very_strong"  # 6
+    ]
+    # Safeguard for out-of-range scores
+    return levels[score] if 0 <= score < len(levels) else "#unknown"
+
+# -----------------------------------------------------------------------------
+# Function: verify
+# Description:
+#   Evaluates password strength by checking length, digits, punctuation,
+#   case variety, and absence of predictable sequences
+# Parameters:
+#   password (str): Password string to evaluate
+#   want_verdict (bool): If True, return textual verdict; else, return numeric score
+# Returns:
+#   int | str: Numerical strength score or verdict string for you to treat the values ​​as you wish, the values ​​(int) range from 0 - 6
+# -----------------------------------------------------------------------------
+
+def verify(
+    password: str,
+    want_verdict: bool = True,
+) -> int | str:
+    strength = 0
+
+    # Length check (>=8 chars)
+    if len(password) >= 8:
+        strength += 1
+
+        # Digit presence
+        if re.search(r'\d', password):
+            strength += 1
+
+            # Special character presence
+            if any(c in string.punctuation for c in password):
+                strength += 1
+
+                # Uppercase letter presence
+                if any(c.isupper() for c in password):
+                    strength += 1
+
+                # Lowercase letter presence
+                if any(c.islower() for c in password):
+                    strength += 1
+
+                # Sequence check (deduct if predictable)
+                if not check_sequences(password):
+                    strength += 1
+
+    # Return verdict or raw score
+    return veredict(strength) if want_verdict else strength

kpass_gen-0.2.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: kpass-gen
+Version: 0.2.0
+Summary: kpass is a simple password generator based on full name, age, and birthdate.
+Author-email: "Lucas Paulino Da Silva (KsxDynamic)" <lucas.workps@gmail.com>
+License: MIT License
+        
+        Copyright (c) [year] [fullname]
+        
+        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.
+Project-URL: Homepage, https://github.com/lucaspy-stack/kpass
+Project-URL: Repository, https://github.com/lucaspy-stack/kpass
+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.txt
+Requires-Dist: rich
+Dynamic: license-file
+
+# kpass
+
+**kpass** is a Python library that:
+
+1. Generates hundreds (or thousands) of password combinations based on a person’s full name, age, and date of birth.  
+2. Applies “leet”-style substitutions (e.g., A → 4, S → $, E → 3).  
+3. Calculates **password strength** according to length, digit presence, special characters, mixed case, and absence of simple numeric sequences.  
+4. Automatically saves generated passwords to a `.txt` file with progress bars powered by the `rich` library.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install kpass-gen
+````
+
+---
+
+## 🚀 Example Usage
+
+### 1. Generating Passwords
+
+```python
+from kpass import generator
+
+# Generate hundreds of password combinations based on personal data
+generator(
+    name="Johnny Silverhand",
+    age="34",
+    birth_date="16/11/1988"
+)
+```
+
+> This will create a file named `pass_generated.txt` (in the default or specified folder) containing all valid passwords between 6 and 18 characters, with a progress bar shown during generation.
+
+---
+
+### 2. Applying Leet-Style Substitutions
+
+```python
+from kpass import aplly_ciphers
+
+original = "SecurePass"
+leet = aplly_ciphers(original)
+print(leet)  # → "$3cur3P4$$" (example)
+```
+
+---
+
+### 3. Saving Passwords Manually
+
+If you already have a list of passwords and only want to save them:
+
+```python
+from kpass import save_to_txt
+
+passwords = ["abc123!", "Johnny34@", "4bcc!23"]
+save_to_txt(passwords, file_name="my_passwords.txt")
+```
+
+---
+
+### 4. Checking Password Strength
+
+```python
+from kpass import verify
+
+# Returns a numeric score (0–6)
+score = verify(password="Luc@s683", want_verdict=False)
+print(score)        # → 6
+
+# Returns a hashtag verdict
+label = verify(password="Luc@s683", want_verdict=True)
+print(label)        # → "#very_strong"
+```
+
+| Score | Verdict       | Description |
+| :---: | :------------ | :---------- |
+|   0   | #very\_weak   | Very weak   |
+|  1–2  | #weak         | Weak        |
+|   3   | #mean         | Average     |
+|   4   | #good         | Good        |
+|   5   | #strong       | Strong      |
+|   6   | #very\_strong | Very strong |
+
+---
+
+## 🔧 API Reference
+
+```python
+generator(
+    name: str,
+    age: str,
+    birth_date: str
+) -> None
+```
+
+* **Generates** and **saves** password combinations automatically to `pass_generated.txt`.
+
+```python
+aplly_ciphers(
+    text: str
+) -> str
+```
+
+* **Transforms** the input text using leet-style substitutions defined in the internal dictionary.
+
+```python
+save_to_txt(
+    passwords: list[str],
+    file_name: str = "pass_generated.txt"
+) -> None
+```
+
+* **Saves** the list of passwords to a text file, displaying a progress bar in the terminal.
+
+```python
+verify(
+    password: str,
+    want_verdict: bool = True
+) -> int | str
+```
+
+* **Evaluates** the strength of a password: returns a numeric score (0–6) or, if `want_verdict=True`, the corresponding hashtag verdict.
+
+---
+
+## ✅ Requirements
+
+* Python 3.6 or higher
+* `rich`
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License.

kpass_gen-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+kpass/__init__.py,sha256=bUr2UtraVAjFR9W9po0s0pRyNKoPFOG8rnrjPda9Gso,287
+kpass/main.py,sha256=Rc10h0zP4GXHIf6yJbOnD6n-RgnrJHlEUV1ZLo_BVnc,8112
+kpass_gen-0.2.0.dist-info/licenses/LICENSE.txt,sha256=Qv2ilebwoUtMJnRsZwRy729xS5JZQzLauJ0tQzkAkTA,1088
+kpass_gen-0.2.0.dist-info/METADATA,sha256=438Fn1LAAha1AKCvJP23c064ce91lgsxjRkkZ6PcB6w,5059
+kpass_gen-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kpass_gen-0.2.0.dist-info/top_level.txt,sha256=l8YfdoHutpiGNi7Zw-_bkGH48JGtmWU2Ac6nwvSb3dU,6
+kpass_gen-0.2.0.dist-info/RECORD,,

kpass/generator.py

@@ -1,103 +0,0 @@
-# Password generator itself
-
-import itertools
-from rich.progress import Progress, BarColumn, TextColumn, TimeElapsedColumn
-import os
-
-# Ciphers dictionary to replace letters
-ciphers = {
-    "A": "4", "a": "4", "Á": "4", "á": "4", "@": "4",
-    "B": "8", "b": "8",
-    "C": "(", "c": "(",
-    "D": "[)", "d": "[)",
-    "E": "3", "e": "3", "É": "3", "é": "3", "&": "3",
-    "F": "#", "f": "#",
-    "G": "6", "g": "6",
-    "H": "#", "h": "#",
-    "I": "1", "i": "1", "Í": "1", "í": "1", "!": "1",
-    "J": "_|", "j": "_|",
-    "K": "|<", "k": "|<",
-    "L": "1", "l": "1",
-    "M": "/\\/\\", "m": "/\\/\\",
-    "N": "|\\|", "n": "|\\|",
-    "O": "0", "o": "0", "Ó": "0", "ó": "0",
-    "P": "|D", "p": "|D",
-    "Q": "0_", "q": "0_",
-    "R": "12", "r": "12",
-    "S": "$", "s": "$", "Š": "$", "š": "$",
-    "T": "7", "t": "7",
-    "U": "(_)", "u": "(_)",
-    "V": "\\/", "v": "\\/",
-    "W": "\\/\\/", "w": "\\/\\/",
-    "X": "%", "x": "%",
-    "Y": "`/", "y": "`/",
-    "Z": "2", "z": "2"
-}
-
-
-# Function to apply ciphers to text
-def aplly_ciphers(text):
-    return ''.join(ciphers.get(char, char) for char in text)
-
-# Function to generate passwords
-
-def generator(name, age, birth_date):
-    day, month, yaer = birth_date.split("/")
-
-    name_tiny = name.lower().replace(" ", "")
-    name_capital = name.upper().replace(" ", "")
-
-    parts_name = name.split()
-    first = parts_name[0]
-    middle = "".join(parts_name[1:-1]) if len(parts_name) > 2 else ""
-    last = parts_name[-1] if len(parts_name) > 1 else ""
-
-    age_reversed  = age[::-1]
-
-    base_combinations = [
-        name_tiny, name_capital, first, middle, last,
-        day, month, yaer,
-        age, age_reversed,
-        aplly_ciphers(name_tiny), aplly_ciphers(first), aplly_ciphers(last)
-    ]
-
-    base_combinations = list(set(filter(lambda x: x.strip() != "", base_combinations)))
-
-    possible_passwords = set()
-
-    # Calcula o total de combinações pra progress bar
-    total = sum(len(list(itertools.permutations(base_combinations, i))) for i in range(2, 5))
-
-    with Progress(
-        TextColumn("[cyan]Generating passwords..."),
-        BarColumn(),
-        TimeElapsedColumn(),
-    ) as progress:
-        task = progress.add_task("passwords", total=total)
-
-        for i in range(2, 5):
-            for combo in itertools.permutations(base_combinations, i):
-                password = "".join(combo)
-                if 6 <= len(password) <= 18:
-                    possible_passwords.add(password)
-                progress.update(task, advance=1)
-                
-    return  save_to_txt(list(possible_passwords))
-    
-    
-
-# Function to save passwords to file
-
-def save_to_txt(passwords, file_name="pass_generated.txt"):
-    with open(file_name, "w", encoding="utf-8-sig") as file:
-        with Progress(
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TimeElapsedColumn(),
-        ) as progress:
-
-            tarefa = progress.add_task("[cyan]Saving passwords...", total=len(passwords))
-
-            for password in passwords:
-                file.write(password + "\n")
-                progress.update(tarefa, advance=1)

kpass_gen-0.1.5.dist-info/METADATA

@@ -1,103 +0,0 @@
-Metadata-Version: 2.4
-Name: kpass-gen
-Version: 0.1.5
-Summary: kpass is a simple password generator based on full name, age, and birthdate.
-Author-email: "Lucas Paulino Da Silva (KsxDynamic)" <lucas.workps@gmail.com>
-License: MIT License
-        
-        Copyright (c) [year] [fullname]
-        
-        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.
-Project-URL: Homepage, https://github.com/lucaspy-stack/kpass
-Project-URL: Repository, https://github.com/lucaspy-stack/kpass
-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.txt
-Requires-Dist: rich
-Dynamic: license-file
-
-# kpass 
-
-**kpass** is a Python library that generates hundreds (or thousands) of password combinations based on a person's full name, age, and date of birth.
-
-It also includes `leet`-style substitutions (e.g., A → 4, S → $, E → 3), and automatically saves the generated passwords to a `.txt` file with progress bars using the `rich` library.
-
----
-
-## 📦 Installation
-
-```bash
-pip install kpass-gen
-```
----
-
-🚀 Example usage
-
-
-```python
-from kpass import generator
-
-# Generate passwords based on personal data
-generator(
-    name="Jhonny Silverhand",
-    age="34",
-    birth_date="16/11/1988"
-)
-```
-
-This will create a folder called passwords_generator containing a file named pass_generated.txt with valid password combinations between 6 and 18 characters.
-
-
----
-
-🔧 Available functions
-
-generator(name: str, age: str, birth_date: str) -> bool
-
-Generates and saves passwords automatically.
-
-aplly_ciphers(text: str) -> str
-
-Applies leet-style substitutions to the given text (e.g., A → 4, S → $, etc.).
-
-save_to_txt(passwords: list[str], file_name: str = "pass_generated.txt")
-
-Saves a list of passwords to a .txt file with a progress bar.
-
-
----
-
-✅ Requirements
-
-Python 3.6 or higher
-
-rich
-
-
----
-
-📄 License
-
-This project is licensed under the MIT License.
-
-
-

kpass_gen-0.1.5.dist-info/RECORD

@@ -1,7 +0,0 @@
-kpass/__init__.py,sha256=7tPJvUG773KYCUtTleuO4FwNrXARMznP8ciIXD5Ki68,87
-kpass/generator.py,sha256=eY1cfbo1v2qE7fUGckvT0tYchD4PIm-I81gU4BwCZaM,3270
-kpass_gen-0.1.5.dist-info/licenses/LICENSE.txt,sha256=Qv2ilebwoUtMJnRsZwRy729xS5JZQzLauJ0tQzkAkTA,1088
-kpass_gen-0.1.5.dist-info/METADATA,sha256=bnT-1C-8Wpiab2LJDDiPWsg0o2MN9UugKGEZ5MTkNNI,3242
-kpass_gen-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kpass_gen-0.1.5.dist-info/top_level.txt,sha256=l8YfdoHutpiGNi7Zw-_bkGH48JGtmWU2Ac6nwvSb3dU,6
-kpass_gen-0.1.5.dist-info/RECORD,,