mukimov 0.1.0__tar.gz

mukimov-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mukimov
+
+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.

mukimov-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: mukimov
+Version: 0.1.0
+Summary: Tiny cross-platform password prompt that echoes * for each character
+Author: mukimov
+License: MIT
+Project-URL: Homepage, https://github.com/mukimov/mukimov
+Keywords: password,getpass,stars,prompt,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mukimov
+
+Tiny cross-platform Python library: password prompt that shows `*` for each typed character — like `getpass()`, but with visual feedback.
+
+```python
+from mukimov import stars
+
+password = stars("Password: ")
+print(password)
+```
+
+Terminal:
+
+```text
+Password: ********
+```
+
+`password` contains the real text (`"12345678"`), only `*` are shown on screen.
+
+## Features
+
+- Only standard library, zero dependencies
+- Windows (`msvcrt`) + Linux/macOS (`termios`/`tty`)
+- Each character is immediately replaced with `*`
+- Backspace correctly deletes the last `*`
+- Enter finishes input
+- Real password is never printed
+- Ctrl+C → `KeyboardInterrupt`, Ctrl+D on empty input → `EOFError`
+- Falls back to `getpass` (no echo) when stdin is not a TTY (pipes, IDE, CI)
+
+## Install
+
+```bash
+pip install .
+```
+
+For development:
+
+```bash
+pip install -e .[test]  # or: pip install -e . && pip install pytest
+pytest -q
+```
+
+## Usage
+
+```python
+from mukimov import stars
+
+username = input("Username: ")
+password = stars("Password: ")
+
+print(username)
+```
+
+```text
+Username: mukimov
+Password: ********
+```
+
+Custom mask character:
+
+```python
+password = stars("Password: ", mask="#")
+```
+
+## Build & publish to PyPI
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Test PyPI first:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+pip install --index-url https://test.pypi.org/simple/ mukimov
+```
+
+## License
+
+MIT

mukimov-0.1.0/README.md

@@ -0,0 +1,84 @@
+# mukimov
+
+Tiny cross-platform Python library: password prompt that shows `*` for each typed character — like `getpass()`, but with visual feedback.
+
+```python
+from mukimov import stars
+
+password = stars("Password: ")
+print(password)
+```
+
+Terminal:
+
+```text
+Password: ********
+```
+
+`password` contains the real text (`"12345678"`), only `*` are shown on screen.
+
+## Features
+
+- Only standard library, zero dependencies
+- Windows (`msvcrt`) + Linux/macOS (`termios`/`tty`)
+- Each character is immediately replaced with `*`
+- Backspace correctly deletes the last `*`
+- Enter finishes input
+- Real password is never printed
+- Ctrl+C → `KeyboardInterrupt`, Ctrl+D on empty input → `EOFError`
+- Falls back to `getpass` (no echo) when stdin is not a TTY (pipes, IDE, CI)
+
+## Install
+
+```bash
+pip install .
+```
+
+For development:
+
+```bash
+pip install -e .[test]  # or: pip install -e . && pip install pytest
+pytest -q
+```
+
+## Usage
+
+```python
+from mukimov import stars
+
+username = input("Username: ")
+password = stars("Password: ")
+
+print(username)
+```
+
+```text
+Username: mukimov
+Password: ********
+```
+
+Custom mask character:
+
+```python
+password = stars("Password: ", mask="#")
+```
+
+## Build & publish to PyPI
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Test PyPI first:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+pip install --index-url https://test.pypi.org/simple/ mukimov
+```
+
+## License
+
+MIT

mukimov-0.1.0/mukimov/__init__.py

@@ -0,0 +1,6 @@
+"""mukimov — tiny cross-platform ``stars()`` password prompt."""
+
+from .stars import stars
+
+__version__ = "0.1.0"
+__all__ = ["stars"]

mukimov-0.1.0/mukimov/stars.py

@@ -0,0 +1,201 @@
+"""Core implementation of ``mukimov.stars``.
+
+Cross-platform password prompt that echoes ``*`` for every typed character.
+Standard library only.
+"""
+
+from __future__ import annotations
+
+import sys
+
+__all__ = ["stars"]
+
+ENTER_KEYS = ("\r", "\n")
+BACKSPACE_KEYS = ("\x08", "\x7f")
+INTERRUPT_KEY = "\x03"  # Ctrl+C
+EOF_KEY = "\x04"  # Ctrl+D
+
+
+def _process_keystrokes(keys) -> str:
+    """Pure, testable core logic: apply keys to a buffer.
+
+    - Normal printable char -> append.
+    - Backspace (``\\x08`` / ``\\x7f``) -> pop last char if any.
+    - Enter (``\\r`` / ``\\n``) -> stop and return result.
+    - Ctrl+C (``\\x03``) -> raise ``KeyboardInterrupt``.
+    - Ctrl+D (``\\x04``) on empty buffer -> raise ``EOFError``.
+    - Other control chars (ord < 32) -> ignored.
+    """
+    buf: list[str] = []
+    for key in keys:
+        if key in ENTER_KEYS:
+            break
+        if key in BACKSPACE_KEYS:
+            if buf:
+                buf.pop()
+            continue
+        if key == INTERRUPT_KEY:
+            raise KeyboardInterrupt
+        if key == EOF_KEY:
+            if not buf:
+                raise EOFError
+            continue
+        if len(key) != 1:
+            continue
+        if key in ("\x00", "\xe0", "\x1b"):
+            # Windows arrow/function-key prefixes and ESC: ignore.
+            continue
+        if ord(key) < 32:
+            # Ignore other control chars.
+            continue
+        buf.append(key)
+    return "".join(buf)
+
+
+def _validate_mask(mask: str) -> str:
+    if not isinstance(mask, str):
+        raise TypeError("mask must be str")
+    if len(mask) != 1:
+        raise ValueError("mask must be a single character, e.g. '*'")
+    return mask
+
+
+def stars(prompt: str = "Password: ", mask: str = "*") -> str:
+    """Read a password, echoing ``mask`` for each character.
+
+    Example:
+        >>> from mukimov import stars
+        >>> password = stars("Password: ")
+        Password: ********
+
+    Behaviour:
+        * Every typed character is immediately shown as ``mask``.
+        * Backspace removes the last ``mask`` symbol and char from result.
+        * Enter finishes input and prints a newline.
+        * The real password is never written to the terminal.
+        * Ctrl+C raises ``KeyboardInterrupt``, Ctrl+D on empty input
+          raises ``EOFError`` (like ``input()`` / ``getpass()``).
+
+    Falls back to :func:`getpass.getpass` (no echo) when stdin is not
+    a TTY (pipes, IDE consoles, CI).
+    """
+    _validate_mask(mask)
+    if not isinstance(prompt, str):
+        raise TypeError("prompt must be str")
+
+    if not sys.stdin.isatty():
+        import getpass
+
+        return getpass.getpass(prompt)
+
+    if sys.platform.startswith("win"):
+        return _stars_windows(prompt, mask)
+    return _stars_unix(prompt, mask)
+
+
+def _stars_windows(prompt: str, mask: str) -> str:
+    import msvcrt
+
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+
+    buf: list[str] = []
+    # getwch handles Unicode correctly; fallback to getch for old Pythons.
+    getwch = getattr(msvcrt, "getwch", None)
+
+    def read_key() -> str:
+        if getwch is not None:
+            return getwch()  # type: ignore[no-any-return]
+        ch = msvcrt.getch()
+        try:
+            return ch.decode("utf-8")
+        except UnicodeDecodeError:
+            return ch.decode("utf-8", errors="ignore")
+
+    try:
+        while True:
+            key = read_key()
+            # Arrow / function keys come as two codes: prefix + scan code.
+            if key in ("\x00", "\xe0"):
+                read_key()  # discard scan code
+                continue
+            if key in ENTER_KEYS:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                break
+            if key in BACKSPACE_KEYS:
+                if buf:
+                    buf.pop()
+                    sys.stdout.write("\b \b")
+                    sys.stdout.flush()
+                continue
+            if key == INTERRUPT_KEY:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                raise KeyboardInterrupt
+            if key == EOF_KEY:
+                if not buf:
+                    sys.stdout.write("\n")
+                    sys.stdout.flush()
+                    raise EOFError
+                continue
+            if len(key) != 1 or ord(key) < 32:
+                continue
+            buf.append(key)
+            sys.stdout.write(mask)
+            sys.stdout.flush()
+    except KeyboardInterrupt:
+        # Let callers handle it; newline already printed.
+        raise
+    return "".join(buf)
+
+
+def _stars_unix(prompt: str, mask: str) -> str:
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+
+    old_settings = termios.tcgetattr(fd)
+    buf: list[str] = []
+    try:
+        tty.setraw(fd)
+        while True:
+            key = sys.stdin.read(1)
+            if not key:
+                # EOF (pipe closed unexpectedly).
+                raise EOFError
+            if key in ENTER_KEYS:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                break
+            if key in BACKSPACE_KEYS:
+                if buf:
+                    buf.pop()
+                    sys.stdout.write("\b \b")
+                    sys.stdout.flush()
+                continue
+            if key == INTERRUPT_KEY:
+                raise KeyboardInterrupt
+            if key == EOF_KEY:
+                if not buf:
+                    raise EOFError
+                continue
+            if key == "\x1b":
+                # Escape sequence (arrows, Home/End...): consume rest.
+                # Most are 2 more chars like "[A". Read them non-blocking-ish.
+                sys.stdin.read(2)
+                continue
+            if len(key) != 1 or ord(key) < 32:
+                continue
+            buf.append(key)
+            sys.stdout.write(mask)
+            sys.stdout.flush()
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        # setraw disables echo/newline handling; ensure cursor on next line
+        # if we exited via exception before printing "\n".
+        sys.stdout.flush()
+    return "".join(buf)

mukimov-0.1.0/mukimov.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: mukimov
+Version: 0.1.0
+Summary: Tiny cross-platform password prompt that echoes * for each character
+Author: mukimov
+License: MIT
+Project-URL: Homepage, https://github.com/mukimov/mukimov
+Keywords: password,getpass,stars,prompt,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mukimov
+
+Tiny cross-platform Python library: password prompt that shows `*` for each typed character — like `getpass()`, but with visual feedback.
+
+```python
+from mukimov import stars
+
+password = stars("Password: ")
+print(password)
+```
+
+Terminal:
+
+```text
+Password: ********
+```
+
+`password` contains the real text (`"12345678"`), only `*` are shown on screen.
+
+## Features
+
+- Only standard library, zero dependencies
+- Windows (`msvcrt`) + Linux/macOS (`termios`/`tty`)
+- Each character is immediately replaced with `*`
+- Backspace correctly deletes the last `*`
+- Enter finishes input
+- Real password is never printed
+- Ctrl+C → `KeyboardInterrupt`, Ctrl+D on empty input → `EOFError`
+- Falls back to `getpass` (no echo) when stdin is not a TTY (pipes, IDE, CI)
+
+## Install
+
+```bash
+pip install .
+```
+
+For development:
+
+```bash
+pip install -e .[test]  # or: pip install -e . && pip install pytest
+pytest -q
+```
+
+## Usage
+
+```python
+from mukimov import stars
+
+username = input("Username: ")
+password = stars("Password: ")
+
+print(username)
+```
+
+```text
+Username: mukimov
+Password: ********
+```
+
+Custom mask character:
+
+```python
+password = stars("Password: ", mask="#")
+```
+
+## Build & publish to PyPI
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Test PyPI first:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+pip install --index-url https://test.pypi.org/simple/ mukimov
+```
+
+## License
+
+MIT

mukimov-0.1.0/mukimov.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+mukimov/__init__.py
+mukimov/stars.py
+mukimov.egg-info/PKG-INFO
+mukimov.egg-info/SOURCES.txt
+mukimov.egg-info/dependency_links.txt
+mukimov.egg-info/top_level.txt
+tests/test_stars.py

mukimov-0.1.0/mukimov.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mukimov-0.1.0/mukimov.egg-info/top_level.txt

@@ -0,0 +1 @@
+mukimov

mukimov-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mukimov"
+version = "0.1.0"
+description = "Tiny cross-platform password prompt that echoes * for each character"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "mukimov" }]
+keywords = ["password", "getpass", "stars", "prompt", "cli"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Security",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/mukimov/mukimov"
+
+[tool.setuptools.packages.find]
+include = ["mukimov*"]

mukimov-0.1.0/setup.cfg

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

mukimov-0.1.0/tests/test_stars.py

@@ -0,0 +1,62 @@
+"""Tests for mukimov core logic (no real terminal needed)."""
+
+import unittest
+
+from mukimov import stars
+from mukimov.stars import _process_keystrokes, _validate_mask
+
+
+class TestProcessKeystrokes(unittest.TestCase):
+    def test_simple_input_enter(self):
+        self.assertEqual(_process_keystrokes(list("12345678") + ["\r"]), "12345678")
+        self.assertEqual(_process_keystrokes(list("abc") + ["\n"]), "abc")
+
+    def test_backspace_bs(self):
+        self.assertEqual(_process_keystrokes(["a", "b", "\x08", "c", "\r"]), "ac")
+
+    def test_backspace_del(self):
+        self.assertEqual(_process_keystrokes(["a", "b", "\x7f", "c", "\r"]), "ac")
+
+    def test_backspace_on_empty_ignored(self):
+        self.assertEqual(_process_keystrokes(["\x08", "\x7f", "a", "\r"]), "a")
+
+    def test_multiple_backspaces(self):
+        self.assertEqual(_process_keystrokes(list("abcd") + ["\x08", "\x08", "\r"]), "ab")
+
+    def test_ctrl_c_raises(self):
+        with self.assertRaises(KeyboardInterrupt):
+            _process_keystrokes(["a", "\x03"])
+
+    def test_ctrl_d_on_empty_raises_eof(self):
+        with self.assertRaises(EOFError):
+            _process_keystrokes(["\x04"])
+
+    def test_ctrl_d_with_content_ignored(self):
+        self.assertEqual(_process_keystrokes(["a", "\x04", "b", "\r"]), "ab")
+
+    def test_control_chars_ignored(self):
+        self.assertEqual(_process_keystrokes(["a", "\x00", "\xe0", "\x1b", "b", "\r"]), "ab")
+
+    def test_unicode(self):
+        self.assertEqual(_process_keystrokes(list("пароль") + ["\r"]), "пароль")
+
+
+class TestApi(unittest.TestCase):
+    def test_stars_importable_and_callable(self):
+        self.assertTrue(callable(stars))
+
+    def test_validate_mask_ok(self):
+        self.assertEqual(_validate_mask("*"), "*")
+        self.assertEqual(_validate_mask("#"), "#")
+
+    def test_validate_mask_bad(self):
+        with self.assertRaises(ValueError):
+            _validate_mask("**")
+        with self.assertRaises(ValueError):
+            _validate_mask("")
+        with self.assertRaises(TypeError):
+            _validate_mask(123)  # type: ignore[arg-type]
+
+
+if __name__ == "__main__":
+    unittest.main()