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

kpass/__init__.py

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

kpass/main.py

@@ -2,6 +2,10 @@ import itertools
 from rich.progress import Progress, BarColumn, TextColumn, TimeElapsedColumn
 import re
 import string
+import json
+from math import perm
+from datetime import datetime
+from pathlib import Path
 
 # -----------------------------------------------------------------------------
 # Ciphers dictionary to replace letters with leetspeak equivalents
@@ -38,7 +42,7 @@ ciphers = {
 }
 
 # -----------------------------------------------------------------------------
-# Function: aplly_ciphers
+# Function: apply_ciphers
 # Description:
 #   Transforms input text by replacing each character according to the ciphers dict
 # Parameters:
@@ -47,77 +51,139 @@ ciphers = {
 #   str: The transformed text with cipher substitutions
 # -----------------------------------------------------------------------------
 
-def aplly_ciphers(text: str) -> str:
+def apply_ciphers(text: str) -> str:
     return ''.join(ciphers.get(char, char) for char in text)
 
 # -----------------------------------------------------------------------------
-# Function: save_to_txt
+# Utility: write with progress bar
+# -----------------------------------------------------------------------------
+
+def _write_with_progress(write_fn, items):
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("[cyan]Saving passwords...", total=len(items))
+        for item in items:
+            write_fn(item)
+            progress.update(task, advance=1)
+
+# -----------------------------------------------------------------------------
+# Function: save_to_file
 # Description:
-#   Writes a list of passwords to a text file, showing progress in the console
+#   Writes a list of passwords, scores, and verdicts to a file with progress
 # Parameters:
-#   passwords (list[str]): List of password strings to save
-#   file_name (str): Output filename (default: 'pass_generated.txt')
+#   passwords (list[str]): List of password strings
+#   scores (list[int]): Corresponding strength scores
+#   verdicts (list[str]): Corresponding verdict strings
+#   file_name (str): Output filename without extension
+#   file_type (str): Extension (json, csv, yaml, yml)
 # 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)
+def save_to_file(
+    passwords: list[str],
+    scores: list[int],
+    verdicts: list[str],
+    file_name: str = "pass_generated",
+    file_type: str = "json"
+) -> None:
+    extension = file_type.lstrip('.')
+    path = Path(f"{file_name}.{extension}")
+    path.write_text("", encoding="utf-8-sig")  # limpa conteúdo existente
+
+    def writer_json(item):
+        pwd, score, verdict = item
+        return json.dumps({"password": pwd, "score": score, "veredict": verdict}, indent=4, ensure_ascii=False) + "\n"
+
+    def writer_csv(item):
+        pwd, score, verdict = item
+        return (
+            f'"password","{pwd}",\n'
+            f'"score","{score}",\n'
+            f'"veredict","{verdict}"\n\\n'
+        )
+
+    def writer_yaml(item):
+        pwd, score, verdict = item
+        return (
+            f'"password": "{pwd}"\n'
+            f'"score": "{score}"\n'
+            f'"veredict": "{verdict}"\n\\n'
+        )
+
+    if extension == "json":
+        writer = writer_json
+    elif extension == "csv":
+        writer = writer_csv
+    elif extension in ("yaml", "yml"):
+        writer = writer_yaml
+    else:
+        raise ValueError(f"Unsupported file type: {file_type}")
+
+    items = list(zip(passwords, scores, verdicts))
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("[cyan]Saving passwords...", total=len(items))
+        with path.open("a", encoding="utf-8-sig") as file:
+            for item in items:
+                file.write(writer(item))
+                progress.update(task, advance=1)
+
+# -----------------------------------------------------------------------------
+# Function: base_files_architecture (no changes needed)
+# -----------------------------------------------------------------------------
+def base_files_architecture(password, score, verdict, file_type):
+    if file_type.lower() in ("json", ".json"):
+        return json.dumps({"password": password, "score": str(score), "veredict": verdict}, indent=4, ensure_ascii=False) + "\n\n"
+    if file_type.lower() in ("csv", ".csv"):
+        return (
+            f'"password","{password}",\n'
+            f'"score","{score}\n"'
+            f'"veredict","{verdict}"\n'
+        ) + "\n"
+    if file_type.lower() in ("yaml", ".yaml", "yml", ".yml"):
+        return (
+            f'"password": "{password}"\n'
+            f'"score": "{score}"\n'
+            f'"veredict": "{verdict}"\n'
+        ) + "\n"
 
 # -----------------------------------------------------------------------------
 # 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)
+#   filters by length, evaluates strength, and saves them
 # -----------------------------------------------------------------------------
 
-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
+def generator(
+    name: str,
+    age: str,
+    birth_date: str,
+    file_type: str = "json",
+    file_name: str = "pass_generated"
+) -> None:
+    dt = datetime.strptime(birth_date, "%d/%m/%Y")
+    day, month, year = dt.strftime("%d"), dt.strftime("m"), dt.strftime("Y")
     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)
+    bases = [
+        name_tiny, name.upper().replace(" ", ""), first, middle, last,
+        day, month, year, age, age_reversed,
+        apply_ciphers(name_tiny), apply_ciphers(first), apply_ciphers(last)
     ]
-
-    # Remove duplicates and empty strings
-    base_combinations = list({item for item in base_combinations if item.strip()})
-
+    bases = list({b for b in bases if b.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))
-
+    total = sum(perm(len(bases), r) for r in range(2, 5))
     with Progress(
         TextColumn("[cyan]Generating passwords..."),
         BarColumn(),
@@ -125,23 +191,17 @@ def generator(name: str, age: str, birth_date: str) -> None:
     ) as progress:
         task = progress.add_task("passwords", total=total)
         for length in range(2, 5):
-            for combo in itertools.permutations(base_combinations, length):
+            for combo in itertools.permutations(bases, 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))
+    scored = [(pwd, verify(pwd, False), veredict(verify(pwd, False))) for pwd in possible_passwords]
+    passwords, scores, verdicts = zip(*scored)
+    save_to_file(list(passwords), list(scores), list(verdicts), file_name, file_type)
 
 # -----------------------------------------------------------------------------
-# 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
+# Sequence, verdict, and verify unchanged (except typo fix)
 # -----------------------------------------------------------------------------
 
 def check_sequences(password: str) -> bool:
@@ -153,69 +213,27 @@ def check_sequences(password: str) -> bool:
             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
+        "#very_weak", "#weak", "#weak", "#mean", "#good", "#strong", "#very_strong"
     ]
-    # 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.5.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: kpass-gen
+Version: 0.2.5
+Summary: kpass is a Python toolkit for generating, ciphering and evaluating passwords with JSON, CSV and YAML export.
+Author-email: "Lucas Paulino Da Silva (~K')" <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
+Keywords: password,generator,leet,name-based,cybersecurity,pentest,automation,security,rich,csv,yaml,json,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: rich
+Dynamic: license-file
+
+# 🔐 kpass — Smart Password Generator & Evaluator
+
+<p align="center">
+  <img src="assets/kpass_icon.png" alt="kpass logo" width="100%"/>
+</p>
+
+**kpass** is a Python toolkit for **generating**, **ciphering** and **evaluating** passwords—designed for **educational**, **testing** and **automation** scenarios.
+
+---
+
+## ✨ Features
+
+* **Generate** hundreds or thousands of password combinations from:
+
+  * Full name
+  * Age
+  * Birth date
+* **Leet‑speak** substitutions like `A → 4`, `E → 3`, `S → $`
+* **Strength evaluation** based on:
+
+  * Length
+  * Digits
+  * Special characters
+  * Mixed case
+  * Numeric sequence patterns
+* **Export** automatically to `.json`, `.csv` or `.yaml` with a progress bar powered by **rich**
+
+---
+
+## ⚠️ Security Disclaimer
+
+This project **does not** produce secure passwords for production systems.
+It uses **predictable** inputs (names, dates) and should **not** be used for real authentication.
+
+---
+
+## 🎯 Use Cases
+
+* 🧠 **Cybersecurity Awareness**
+  Learn why personal info makes weak passwords.
+
+* 🧰 **Pentesting & Wordlist Creation**
+  Build custom dictionaries for ethical hacking.
+
+* 🧪 **Automation & Testing**
+  Generate dummy passwords for scripts, bots or sandbox environments.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install kpass-gen
+```
+
+> Requires Python 3.6+
+
+---
+
+## 🚀 Quick Start
+
+### 1. Generate Passwords
+
+```python
+from kpass import generator
+
+# Example: Johnny Silverhand (born 08/07/2000, age 50 in 2077)
+generator(
+    name="Johnny Silverhand",
+    age="50",
+    birth_date="08/07/2000",
+    file_type="json",         # optional: json, csv, yaml or yml
+    file_name="jsilverhand"   # optional: filename without extension
+)
+```
+
+### 2. Apply Leet Cipher
+
+```python
+from kpass import apply_ciphers
+
+# Example: Panam Palmer
+leet = apply_ciphers("Panam Palmer")
+print(leet)  # → "|D4|\\|4/\\/\\ |D41/\\/\\312"
+```
+
+### 3. Save Custom Password Lists
+
+```python
+from kpass import save_to_file
+
+# Example passwords inspired by Cyberpunk characters
+passwords = ["Chipp4020!", "AltAccount2077$", "RoughTrade37#"]
+scores    = [3, 5, 4]
+verdicts  = ["#mean", "#strong", "#good"]
+
+save_to_file(
+    passwords,
+    scores,
+    verdicts,
+    file_name="cyberpunk_list",
+    file_type="csv"    # outputs cyberpunk_list.csv
+)
+```
+
+### 4. Check Password Strength
+
+```python
+from kpass import verify
+
+# returns "#very_strong"
+print(verify("R0gueDr1ft!99"))
+
+# returns 6
+print(verify("R0gueDr1ft!99", want_verdict=False))
+```
+
+---
+
+## 🔧 API Reference
+
+| Function                                                          | Description                                                                 |
+| ----------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `generator(name, age, birth_date, file_type, file_name)`          | Generates permutations, evaluates strength, and saves to a file             |
+| `apply_ciphers(text)`                                             | Applies leet‑speak substitutions                                            |
+| `save_to_file(passwords, scores, verdicts, file_name, file_type)` | Exports password list + scores + verdicts with a progress bar               |
+| `verify(password, want_verdict=True)`                             | Evaluates strength; returns an `int` score or `str` verdict (`#good`, etc.) |
+| `check_sequences(password)`                                       | Detects ascending/descending numeric sequences                              |
+| `veredict(score)`                                                 | Maps numeric score to verdict string (`#weak`, `#strong`, etc.)             |
+
+---
+
+## ✅ Requirements
+
+* Python 3.6 or higher
+* [rich](https://pypi.org/project/rich/) for progress bars
+
+---
+
+## 📄 License
+
+MIT License — free to use, modify and share.

kpass_gen-0.2.5.dist-info/RECORD

@@ -0,0 +1,7 @@
+kpass/__init__.py,sha256=EC7FCcioji9m_sHw2aQbb7azvFdEbaukRhKv6P2sAbc,287
+kpass/main.py,sha256=mrabkAqt15OCakMiCgsH35NoT5AAwvAQGu4I2lh34wk,9027
+kpass_gen-0.2.5.dist-info/licenses/LICENSE.txt,sha256=Qv2ilebwoUtMJnRsZwRy729xS5JZQzLauJ0tQzkAkTA,1088
+kpass_gen-0.2.5.dist-info/METADATA,sha256=AAd4pOSmeUNpN3r7QpIthlGGdHT7RBNOwa0ln0mb8MI,6640
+kpass_gen-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kpass_gen-0.2.5.dist-info/top_level.txt,sha256=l8YfdoHutpiGNi7Zw-_bkGH48JGtmWU2Ac6nwvSb3dU,6
+kpass_gen-0.2.5.dist-info/RECORD,,

kpass_gen-0.2.0.dist-info/METADATA

@@ -1,175 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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,,