determinist 0.2.0__tar.gz

determinist-0.2.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: determinist
+Version: 0.2.0
+Summary: A deterministic password generator
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: argon2-cffi>=25.1.0
+Requires-Dist: typer>=0.27.0

determinist-0.2.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "determinist"
+version = "0.2.0"
+description = "A deterministic password generator"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "argon2-cffi>=25.1.0",
+    "typer>=0.27.0",
+]
+
+[project.scripts]
+determinist = "determinist.generator:app"
+
+[build-system]
+requires = ["uv_build>=0.8.14,<0.9.0"]
+buuild-backend = "uv_build"
+
+[tool.uv.extra-build-dependencies]
+determinist = ["setuptools"]

determinist-0.2.0/setup.cfg

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

determinist-0.2.0/src/determinist/__init__.py

@@ -0,0 +1 @@
+from .generator import generate_password, app

determinist-0.2.0/src/determinist/algorithms/__init__.py

@@ -0,0 +1,2 @@
+from .v1 import generate
+from .v2 import generate

determinist-0.2.0/src/determinist/algorithms/v1.py

@@ -0,0 +1,30 @@
+from argon2.low_level import Type, hash_secret
+from typing import Literal
+
+def generate(master_pass: str, site_name: str, pass_length: int, spec_mode: Literal["replace", "insert"], char_map: dict[str, str], spec_chars: list, spec_freq: int) -> str:
+    hashed_str = hash_secret(secret=master_pass.encode('utf-8'),
+                                salt=site_name.encode('utf-8'),
+                                time_cost=2,
+                                memory_cost=65536,
+                                parallelism=4,
+                                hash_len=32,
+                                type=Type.ID
+                            ).decode('utf-8')
+    stripped = hashed_str.split('$')[-1]
+
+    chars_added = ""
+    if spec_mode == "insert":
+        for i, char in enumerate(stripped):
+            chars_added += char
+            if (i + 1) % spec_freq == 0:
+                chars_added += spec_chars[i % len(spec_chars)]
+    elif spec_mode == "replace":
+        for _, char in enumerate(stripped):
+            if char.lower() in char_map:
+                chars_added += char_map[char.lower()]
+            else:
+                chars_added += char
+
+    final_password = chars_added[-pass_length:]
+
+    return final_password

determinist-0.2.0/src/determinist/algorithms/v2.py

@@ -0,0 +1,48 @@
+from argon2.low_level import Type, hash_secret
+from string import punctuation, ascii_lowercase, ascii_uppercase, digits
+from random import Random
+from io import BytesIO
+
+def generate(master_pass: str, site_name: str, pass_length: int, char_map: dict[str,str], char_types: list) -> str:
+    types_set = set(char_types)
+    charset = ""
+
+    if "special" in types_set:
+        charset += punctuation
+    if "lowercase" in types_set:
+        charset += ascii_lowercase
+    if "uppercase" in types_set:
+        charset += ascii_uppercase
+    if "digits" in types_set:
+        charset += digits
+
+    charset_list = list(charset)
+    salt = master_pass + site_name + str(pass_length) + str(char_map) + charset
+
+    random = Random(salt)
+    random.shuffle(charset_list)
+
+    hashed_bytes = hash_secret(secret=master_pass.encode('utf-8'),
+                                salt=salt.encode('utf-8'),
+                                time_cost=2,
+                                memory_cost=65536,
+                                parallelism=4,
+                                hash_len=32*pass_length,
+                                type=Type.ID
+                            )
+    stream = BytesIO(hashed_bytes)
+    password = ""
+
+    limit = 256 - (256 % len(charset_list))
+    for i, _ in enumerate(hashed_bytes):
+        byte = stream.getvalue()[i]
+        if i == pass_length:
+            break
+        elif byte < limit:
+            password += charset_list[byte % len(charset_list)]
+
+    password_to_shuffle = list(password)
+    random.shuffle(password_to_shuffle)
+    final = "".join(password_to_shuffle)
+
+    return final

determinist-0.2.0/src/determinist/generator.py

@@ -0,0 +1,75 @@
+import typer
+import json
+from typing import Literal, Annotated
+from string import punctuation
+from .algorithms import v1, v2
+from rich import print, box
+from rich.table import Table
+
+app = typer.Typer()
+
+def generate_password(master_pass: str, 
+                      site_name: str, 
+                      char_map: dict[str, str] = {}, 
+                      spec_chars: list = list(punctuation), 
+                      version: int = 2, 
+                      pass_length: int = 8, 
+                      spec_mode: Literal["replace", "insert"] = "insert",
+                      spec_freq: int = 4, 
+                      char_types: list = ["special","lowercase","uppercase","digits"]
+                     ) -> str:
+    
+    if version == 1:
+        return v1.generate(master_pass=master_pass, site_name=site_name, pass_length=pass_length, spec_mode=spec_mode, spec_chars=spec_chars, char_map=char_map, spec_freq=spec_freq)
+    elif version == 2:
+        return v2.generate(master_pass=master_pass, site_name=site_name, pass_length=pass_length, char_map=char_map, char_types=char_types)
+    else:
+        raise ValueError(f"Unsupported algorithm version: {version}")
+
+@app.command(name="generate")
+def generate_password_cli(master_pass: Annotated[str, typer.Argument()], 
+                      site_name: Annotated[str, typer.Argument()], 
+                      char_map: Annotated[str, typer.Option("--map", "-M")] = "{}", 
+                      spec_chars: Annotated[str, typer.Option("--special", "-s")] = punctuation, 
+                      version: Annotated[int, typer.Option("--version", "-v", min=1, max=2)] = 2, 
+                      pass_length: Annotated[int, typer.Option("--length", "-l", min=6, max=32)] = 8, 
+                      spec_mode: Annotated[Literal["replace", "insert"], typer.Option("--mode", "-m")] = "insert",
+                      spec_freq: Annotated[int, typer.Option("--frequency", "-f")] = 4, 
+                      char_types: Annotated[str, typer.Option("--chars", "-c")] = "special,lowercase,uppercase,digits"
+                     ):
+
+    char_map_dict = json.loads(char_map)
+    spec_chars_list = list(spec_chars)
+    char_types_list = char_types.split(',')
+
+    password = generate_password(master_pass=master_pass, site_name=site_name, char_map=char_map_dict, char_types=char_types_list, pass_length=pass_length, version=version, spec_mode=spec_mode, spec_chars=spec_chars_list, spec_freq=spec_freq)
+
+    success_table = Table(box=box.SIMPLE_HEAD, show_edge=False)
+    success_table.add_column("Password Generation Successful!", justify="center")
+    success_table.add_row(f"Password: [bold cyan]{password}[/]")
+
+    print(success_table)
+
+@app.command(name="prompt")
+def generate_password_prompt(master_pass: Annotated[str, typer.Argument()], 
+                      site_name: Annotated[str, typer.Argument()], 
+                      char_map: Annotated[str, typer.Option("--map", "-M", prompt="Character map (dict, v1)")] = "{}", 
+                      spec_chars: Annotated[str, typer.Option("--special", "-s", prompt="Special characters (v1)")] = punctuation, 
+                      version: Annotated[int, typer.Option("--version", "-v", min=1, max=2, prompt="version (1/2)")] = 2, 
+                      pass_length: Annotated[int, typer.Option("--length", "-l", min=6, max=32, prompt="Password length (6-32)")] = 8, 
+                      spec_mode: Annotated[Literal["replace", "insert"], typer.Option("--mode", "-m", prompt="Special character mode (v1)")] = "insert",
+                      spec_freq: Annotated[int, typer.Option("--frequency", "-f", prompt="Special character frequency (v1)")] = 4, 
+                      char_types: Annotated[str, typer.Option("--chars", "-c", prompt="Character types (v2)")] = "special,lowercase,uppercase,digits"
+                     ):
+
+    char_map_dict = json.loads(char_map)
+    spec_chars_list = list(spec_chars)
+    char_types_list = char_types.split(',')
+
+    password = generate_password(master_pass=master_pass, site_name=site_name, char_map=char_map_dict, char_types=char_types_list, pass_length=pass_length, version=version, spec_mode=spec_mode, spec_chars=spec_chars_list, spec_freq=spec_freq)
+
+    success_table = Table(box=box.SIMPLE_HEAD, show_edge=False)
+    success_table.add_column("\nPassword Generation Successful!", justify="center")
+    success_table.add_row(f"Password: [bold cyan]{password}[/]")
+
+    print(success_table)

determinist-0.2.0/src/determinist.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: determinist
+Version: 0.2.0
+Summary: A deterministic password generator
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: argon2-cffi>=25.1.0
+Requires-Dist: typer>=0.27.0

determinist-0.2.0/src/determinist.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+src/determinist/__init__.py
+src/determinist/generator.py
+src/determinist.egg-info/PKG-INFO
+src/determinist.egg-info/SOURCES.txt
+src/determinist.egg-info/dependency_links.txt
+src/determinist.egg-info/entry_points.txt
+src/determinist.egg-info/requires.txt
+src/determinist.egg-info/top_level.txt
+src/determinist/algorithms/__init__.py
+src/determinist/algorithms/v1.py
+src/determinist/algorithms/v2.py
+tests/test_v1.py
+tests/test_v2.py

determinist-0.2.0/src/determinist.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

determinist-0.2.0/src/determinist.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+determinist = determinist.generator:app

determinist-0.2.0/src/determinist.egg-info/requires.txt

@@ -0,0 +1,2 @@
+argon2-cffi>=25.1.0
+typer>=0.27.0

determinist-0.2.0/src/determinist.egg-info/top_level.txt

@@ -0,0 +1 @@
+determinist

determinist-0.2.0/tests/test_v1.py

@@ -0,0 +1,25 @@
+import unittest
+from determinist import generate_password
+from unittest import TestCase
+
+class TestGenV1(TestCase):
+    def test_deterministic_output(self):
+        self.assertEqual(generate_password("Very-Strong-Passphrase", "github.com", version=1), "gZR5(UQQ")
+
+    def test_site_changes_output(self):
+        self.assertEqual(generate_password("Very-Strong-Passphrase", "reddit.com", version=1), "LkW7(WnU")
+
+    def test_master_changes_output(self):
+        self.assertEqual(generate_password("Another-Very-Strong-Passphrase", "github.com", version=1), "20Ps(XiE")
+
+    def test_length(self):
+        self.assertEqual(len(generate_password("Very-Strong-Passphrase", "github.com", version=1, pass_length=12)), 12)
+
+    def test_replace(self):
+        self.assertEqual(generate_password("Very-Strong-Passphrase", "github.com", version=1, spec_mode="replace", char_map={"g": "{", "q": ".", "r": "="}), "V{Z=5U..")
+
+    def test_frequency(self):
+        self.assertEqual(generate_password("Very-Strong-Passphrase", "github.com", version=1, spec_freq=2, pass_length=16), "wZ\"LV$gZ&R5(UQ*Q")
+        
+if __name__ == "__main__":
+    unittest.main()

determinist-0.2.0/tests/test_v2.py

@@ -0,0 +1,36 @@
+from calendar import c
+import unittest
+from determinist import generate_password, app
+from unittest import TestCase
+from typer.testing import CliRunner
+
+class TestGenV2(TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    def test_deterministic_output(self):
+        self.assertEqual(generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com"), "Vo`Ns\\f3")
+
+    def test_site_changes_output(self):
+        self.assertNotEqual(generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="reddit.com"), "Vo`Ns\\f3")
+
+    def test_master_changes_output(self):
+        self.assertNotEqual(generate_password(version=2, master_pass="Another-Very-Strong-Passphrase", site_name="github.com"), "Vo`Ns\\f3")
+
+    def test_length(self):
+        self.assertEqual(len(generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com", pass_length=12)), 12)
+
+    def test_length_diff(self):
+        self.assertNotEqual(generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com", pass_length=16), generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com", pass_length=12))
+
+    def test_charset(self):
+        self.assertEqual(generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com", pass_length=16, char_types=["digits", "lowercase"]), "ikii50pfdlweu1ru")
+
+    def test_cli_core_match(self):
+        core = generate_password(version=2, master_pass="Very-Strong-Passphrase", site_name="github.com", pass_length=12, char_types=["digits", "special", "uppercase"])
+        cli = self.runner.invoke(app, ["generate", "Very-Strong-Passphrase", "github.com", "-l", "12", "-c", "digits,special,uppercase", "-v" "2"])
+
+        self.assertIn(core, cli.output.strip())
+        
+if __name__ == "__main__":
+    unittest.main()