django-keygen 0.1__tar.gz

django_keygen-0.1.0/LICENSE

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

django_keygen-0.1.0/PKG-INFO

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: django-keygen
+Version: 0.1.0
+Summary: django-keygen is a Django management command utility designed to securely generate cryptographic secret keys.
+Author-email: Mouhib sellami <mouhib.sellami@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mouhib-Sellami/django-keygen
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+django-keygen
+=============
+
+django-keygen is a Django management command utility for securely generating
+cryptographic secret keys and passwords, and optionally writing them into your
+project's environment (``.env``) files automatically.
+
+Detailed documentation will be available in the "docs" directory.
+
+Installation
+------------
+
+Install via pip::
+
+    pip install django-keygen
+
+Or install the latest version directly from GitHub::
+
+    pip install git+https://github.com/mouhib-Sellami/django-keygen.git
+
+Quick start
+-----------
+
+1. Add ``django_keygen`` to your ``INSTALLED_APPS``::
+
+    INSTALLED_APPS = [
+        ...,
+        'django_keygen',
+    ]
+
+Commands Overview
+-----------------
+
+django-keygen provides three management commands:
+
++---------------------------+-------------------------------------------------------+
+| Command                   | Purpose                                               |
++===========================+=======================================================+
+| ``keygen``                | Generate secret keys and/or passwords into a named    |
+|                           | ``.env`` file. The recommended all-in-one command.    |
++---------------------------+-------------------------------------------------------+
+| ``generate_django_secret``| Dedicated command for generating a single             |
+|                           | ``DJANGO_SECRET_KEY`` and optionally writing it to    |
+|                           | an env file via an interactive or flag-driven flow.   |
++---------------------------+-------------------------------------------------------+
+| ``generate_password``     | Interactive terminal interface for generating and     |
+|                           | tweaking secure passwords.                            |
++---------------------------+-------------------------------------------------------+
+
+----
+
+1. ``keygen`` — Unified Key & Password Generator
+-------------------------------------------------
+
+The ``keygen`` command is the recommended way to generate one or more secret
+keys and/or passwords and write them into an environment file in a single step.
+Variable names are passed directly as arguments, so each generated value is
+stored under the name you choose.
+
+**Positional arguments:**
+
+* ``SECRET [SECRET ...]``
+    One or more variable names to generate a Django secret key for (e.g.
+    ``SECRET_KEY API_KEY``). Each name receives its own independently generated
+    cryptographic key.
+
+**Flags:**
+
+* ``--passwords PASSWORDS [PASSWORDS ...]``, ``-p``
+    One or more variable names to generate a secure password for instead of a
+    Django secret key (e.g. ``-p DB_PASSWORD REDIS_PASSWORD``).
+
+* ``--file FILE``, ``-f``
+    Path to the env file, relative to ``BASE_DIR`` (default: ``.env``). If the
+    file does not exist, the command offers to create it.
+
+* ``--append``
+    Update the existing file in place rather than recreating it from scratch.
+    Without this flag the file is fully rewritten (all previous content is
+    preserved but reformatted alongside the new values). Prompts a confirmation
+    warning because replacing an active ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--no-input``
+    Skip all confirmation prompts. Useful for automated deployments, Docker
+    entrypoints, and CI/CD pipelines.
+
+**Examples**::
+
+    # Generate SECRET_KEY and write it to .env (recreates the file)
+    python manage.py keygen SECRET_KEY
+
+    # Generate two secret keys into a specific file, no prompts
+    python manage.py keygen SECRET_KEY API_KEY --file .env.production --no-input
+
+    # Generate a secret key and two passwords into .env.local, appending
+    python manage.py keygen SECRET_KEY --passwords DB_PASSWORD REDIS_PASSWORD \
+        --file .env.local --append
+
+    # Generate only passwords (no secret keys)
+    python manage.py keygen --passwords DB_PASSWORD --file .env
+
+----
+
+2. ``generate_django_secret`` — Dedicated Secret Key Command
+-------------------------------------------------------------
+
+The ``generate_django_secret`` command is dedicated to generating a single
+Django secret key stored under the ``DJANGO_SECRET_KEY`` variable. Run it
+without any flags to simply print a key to the terminal, or add ``--append``
+to write it to an env file.
+
+When writing to a file, the command either accepts a path via ``--file`` or
+launches an interactive file-selection menu that scans your project for
+existing ``.env*`` files.
+
+**Flags:**
+
+* ``--append``
+    Write the generated key to an environment file. Without this flag the key
+    is only printed to stdout — no files are touched. Prompts a confirmation
+    warning because replacing a live ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--file FILE``, ``-f``
+    Directly specify the env file to update (e.g. ``-f .env.production``),
+    bypassing the interactive selection menu. If the file does not exist it is
+    created automatically. Only used together with ``--append``.
+
+* ``--no-input``
+    Suppress all interactive prompts, menus, and risk warnings. Useful for
+    automated deployments and CI/CD pipelines.
+
+**Examples**::
+
+    # Print a new secret key to the terminal only (no file changes)
+    python manage.py generate_django_secret
+
+    # Interactively choose which env file to update
+    python manage.py generate_django_secret --append
+
+    # Write directly to a specific file, no prompts
+    python manage.py generate_django_secret --append --no-input -f .env.local
+
+**After running**, update your ``settings.py`` to read the key from the
+environment::
+
+    import os
+    SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')
+
+----
+
+3. ``generate_password`` — Interactive Password Generator
+---------------------------------------------------------
+
+The ``generate_password`` command launches an interactive terminal session for
+generating and refining secure passwords. After each password is shown, you can
+regenerate it or adjust the composition settings without restarting the command.
+
+**Flags** (set initial defaults; all can be changed interactively):
+
+* ``--length LENGTH``, ``-len``
+    Desired password length (default: 12).
+
+* ``--letters``
+    Include lowercase letters (a–z).
+
+* ``--uppercase``
+    Include uppercase letters (A–Z).
+
+* ``--numbers``
+    Include numerical digits (0–9).
+
+* ``--symbol``
+    Include symbols and punctuation characters.
+
+* ``--secure``
+    Shortcut that forces uppercase letters, numbers, symbols, and a minimum
+    length of 20. Overrides individual composition flags.
+
+**Examples**::
+
+    # Launch with defaults (12 characters, no composition constraints)
+    python manage.py generate_password
+
+    # Start with a longer length and reconfigure interactively
+    python manage.py generate_password --length 16
+
+    # Instantly generate a highly secure 20-character password
+    python manage.py generate_password --secure
+
+----
+
+Programmatic Usage
+------------------
+
+The underlying password generator can be imported directly into your own
+Django apps — useful for custom registration flows, invitation tokens, or
+background tasks::
+
+    from django_keygen.core.passwords import generate_password
+
+    # Generate a secure password with specific character sets
+    new_password = generate_password(
+        length=14,
+        use_uppercase=True,
+        use_numbers=True,
+        use_symbols=True,
+    )
+
+    # Use it in your application logic
+    from django.contrib.auth.models import User
+    user = User.objects.create_user(username='johndoe', email='john@example.com')
+    user.set_password(new_password)
+    user.save()
+
+----
+
+License
+-------
+
+django-keygen is released under the **MIT License**.
+
+Copyright (c) 2026 Mouhib Sellami
+
+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.
+
+See the ``LICENSE`` file in the repository root for the full license text,
+or visit: https://github.com/mouhib-Sellami/django-keygen/blob/main/LICENSE

django_keygen-0.1.0/README.rst

@@ -0,0 +1,245 @@
+django-keygen
+=============
+
+django-keygen is a Django management command utility for securely generating
+cryptographic secret keys and passwords, and optionally writing them into your
+project's environment (``.env``) files automatically.
+
+Detailed documentation will be available in the "docs" directory.
+
+Installation
+------------
+
+Install via pip::
+
+    pip install django-keygen
+
+Or install the latest version directly from GitHub::
+
+    pip install git+https://github.com/mouhib-Sellami/django-keygen.git
+
+Quick start
+-----------
+
+1. Add ``django_keygen`` to your ``INSTALLED_APPS``::
+
+    INSTALLED_APPS = [
+        ...,
+        'django_keygen',
+    ]
+
+Commands Overview
+-----------------
+
+django-keygen provides three management commands:
+
++---------------------------+-------------------------------------------------------+
+| Command                   | Purpose                                               |
++===========================+=======================================================+
+| ``keygen``                | Generate secret keys and/or passwords into a named    |
+|                           | ``.env`` file. The recommended all-in-one command.    |
++---------------------------+-------------------------------------------------------+
+| ``generate_django_secret``| Dedicated command for generating a single             |
+|                           | ``DJANGO_SECRET_KEY`` and optionally writing it to    |
+|                           | an env file via an interactive or flag-driven flow.   |
++---------------------------+-------------------------------------------------------+
+| ``generate_password``     | Interactive terminal interface for generating and     |
+|                           | tweaking secure passwords.                            |
++---------------------------+-------------------------------------------------------+
+
+----
+
+1. ``keygen`` — Unified Key & Password Generator
+-------------------------------------------------
+
+The ``keygen`` command is the recommended way to generate one or more secret
+keys and/or passwords and write them into an environment file in a single step.
+Variable names are passed directly as arguments, so each generated value is
+stored under the name you choose.
+
+**Positional arguments:**
+
+* ``SECRET [SECRET ...]``
+    One or more variable names to generate a Django secret key for (e.g.
+    ``SECRET_KEY API_KEY``). Each name receives its own independently generated
+    cryptographic key.
+
+**Flags:**
+
+* ``--passwords PASSWORDS [PASSWORDS ...]``, ``-p``
+    One or more variable names to generate a secure password for instead of a
+    Django secret key (e.g. ``-p DB_PASSWORD REDIS_PASSWORD``).
+
+* ``--file FILE``, ``-f``
+    Path to the env file, relative to ``BASE_DIR`` (default: ``.env``). If the
+    file does not exist, the command offers to create it.
+
+* ``--append``
+    Update the existing file in place rather than recreating it from scratch.
+    Without this flag the file is fully rewritten (all previous content is
+    preserved but reformatted alongside the new values). Prompts a confirmation
+    warning because replacing an active ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--no-input``
+    Skip all confirmation prompts. Useful for automated deployments, Docker
+    entrypoints, and CI/CD pipelines.
+
+**Examples**::
+
+    # Generate SECRET_KEY and write it to .env (recreates the file)
+    python manage.py keygen SECRET_KEY
+
+    # Generate two secret keys into a specific file, no prompts
+    python manage.py keygen SECRET_KEY API_KEY --file .env.production --no-input
+
+    # Generate a secret key and two passwords into .env.local, appending
+    python manage.py keygen SECRET_KEY --passwords DB_PASSWORD REDIS_PASSWORD \
+        --file .env.local --append
+
+    # Generate only passwords (no secret keys)
+    python manage.py keygen --passwords DB_PASSWORD --file .env
+
+----
+
+2. ``generate_django_secret`` — Dedicated Secret Key Command
+-------------------------------------------------------------
+
+The ``generate_django_secret`` command is dedicated to generating a single
+Django secret key stored under the ``DJANGO_SECRET_KEY`` variable. Run it
+without any flags to simply print a key to the terminal, or add ``--append``
+to write it to an env file.
+
+When writing to a file, the command either accepts a path via ``--file`` or
+launches an interactive file-selection menu that scans your project for
+existing ``.env*`` files.
+
+**Flags:**
+
+* ``--append``
+    Write the generated key to an environment file. Without this flag the key
+    is only printed to stdout — no files are touched. Prompts a confirmation
+    warning because replacing a live ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--file FILE``, ``-f``
+    Directly specify the env file to update (e.g. ``-f .env.production``),
+    bypassing the interactive selection menu. If the file does not exist it is
+    created automatically. Only used together with ``--append``.
+
+* ``--no-input``
+    Suppress all interactive prompts, menus, and risk warnings. Useful for
+    automated deployments and CI/CD pipelines.
+
+**Examples**::
+
+    # Print a new secret key to the terminal only (no file changes)
+    python manage.py generate_django_secret
+
+    # Interactively choose which env file to update
+    python manage.py generate_django_secret --append
+
+    # Write directly to a specific file, no prompts
+    python manage.py generate_django_secret --append --no-input -f .env.local
+
+**After running**, update your ``settings.py`` to read the key from the
+environment::
+
+    import os
+    SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')
+
+----
+
+3. ``generate_password`` — Interactive Password Generator
+---------------------------------------------------------
+
+The ``generate_password`` command launches an interactive terminal session for
+generating and refining secure passwords. After each password is shown, you can
+regenerate it or adjust the composition settings without restarting the command.
+
+**Flags** (set initial defaults; all can be changed interactively):
+
+* ``--length LENGTH``, ``-len``
+    Desired password length (default: 12).
+
+* ``--letters``
+    Include lowercase letters (a–z).
+
+* ``--uppercase``
+    Include uppercase letters (A–Z).
+
+* ``--numbers``
+    Include numerical digits (0–9).
+
+* ``--symbol``
+    Include symbols and punctuation characters.
+
+* ``--secure``
+    Shortcut that forces uppercase letters, numbers, symbols, and a minimum
+    length of 20. Overrides individual composition flags.
+
+**Examples**::
+
+    # Launch with defaults (12 characters, no composition constraints)
+    python manage.py generate_password
+
+    # Start with a longer length and reconfigure interactively
+    python manage.py generate_password --length 16
+
+    # Instantly generate a highly secure 20-character password
+    python manage.py generate_password --secure
+
+----
+
+Programmatic Usage
+------------------
+
+The underlying password generator can be imported directly into your own
+Django apps — useful for custom registration flows, invitation tokens, or
+background tasks::
+
+    from django_keygen.core.passwords import generate_password
+
+    # Generate a secure password with specific character sets
+    new_password = generate_password(
+        length=14,
+        use_uppercase=True,
+        use_numbers=True,
+        use_symbols=True,
+    )
+
+    # Use it in your application logic
+    from django.contrib.auth.models import User
+    user = User.objects.create_user(username='johndoe', email='john@example.com')
+    user.set_password(new_password)
+    user.save()
+
+----
+
+License
+-------
+
+django-keygen is released under the **MIT License**.
+
+Copyright (c) 2026 Mouhib Sellami
+
+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.
+
+See the ``LICENSE`` file in the repository root for the full license text,
+or visit: https://github.com/mouhib-Sellami/django-keygen/blob/main/LICENSE

django_keygen-0.1.0/django_keygen/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DjangoKeygenConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_keygen'

django_keygen-0.1.0/django_keygen/core/passwords/__init__.py

@@ -0,0 +1,38 @@
+import string
+import secrets
+
+
+def generate_password(
+    length: int = 12,
+    use_uppercase: bool = False,
+    use_numbers: bool = False,
+    use_symbols: bool = False,
+) -> str:
+    """Generates a cryptographically secure random password based on specified constraints.
+
+    Args:
+        length (int, optional): The length of the generated password. Defaults to
+          8.
+        use_uppercase (bool, optional): If True, includes uppercase letters (A-Z).
+          Defaults to False.
+        use_numbers (bool, optional): If True, includes numerical digits (0-9).
+          Defaults to False.
+        use_symbols (bool, optional): If True, includes punctuation/special
+          characters. Defaults to False.
+
+    Returns:
+        str: A randomly generated password string.
+
+    Example:
+        >>> generate_password(length=12, use_uppercase=True, use_numbers=True)
+        'aB3k9P1zLxQ9'
+    """
+    content = string.ascii_lowercase
+    if use_uppercase:
+        content += string.ascii_uppercase
+    if use_symbols:
+        content += string.punctuation
+    if use_numbers:
+        content += string.digits
+
+    return "".join(secrets.choice(content) for i in range(length))

django_keygen-0.1.0/django_keygen/management/commands/generate_django_secret.py

@@ -0,0 +1,176 @@
+from pathlib import Path
+from django.core.management.utils import get_random_secret_key
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from dotenv import dotenv_values
+
+
+class Command(BaseCommand):
+    help = "Generate a secure secret key for Django and manage environment files."
+
+    env_content = """# Security Warning: keep the secret key used in production secret!
+# This file was generated by django-env
+
+"""
+    env_generated_key_warning = "\n# This is managed by django-keygen"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--append",
+            action="store_true",
+            help="Append or update the generated secret key in chosen environment files."
+        )
+
+        parser.add_argument(
+            "--no-input",
+            action="store_true",
+            help="Skip all interactive prompts and warnings automatically."
+        )
+
+        parser.add_argument(
+            "--file",
+            "-f",
+            type=str,
+            default=None,
+            help="Directly specify the name or path of an env file (skips interactive selection)."
+        )
+
+    def _append_to_env(self, generated_secret_key: str, env_files: list[str]):
+        for env in env_files:
+            env_path = Path(settings.BASE_DIR, env)
+            config = dotenv_values(env_path)
+
+            config['DJANGO_SECRET_KEY'] = generated_secret_key
+            self._write_to_env(config, env_path)
+
+    def _write_to_env(self, config: dict, env_file_path: Path):
+        content = self.env_content
+        for key, value in config.items():
+            if key == 'DJANGO_SECRET_KEY':
+                content += self.env_generated_key_warning + '\n'
+            content += f"{key}='{value}'\n"
+
+        with open(env_file_path, 'w') as f:
+            f.write(content)
+
+    def _select_env_file(self, no_input: bool = False) -> list[str]:
+        self.stdout.write(
+            "Searching for environment files (.env, .env.local, .env.production, etc.)...")
+
+        env_files = []
+        for file in Path(settings.BASE_DIR).rglob('*.env*'):
+            relative_path = file.relative_to(settings.BASE_DIR)
+            env_files.append(str(relative_path))
+
+        if not env_files:
+            self.stdout.write(self.style.WARNING(
+                "No environment files found to write to."))
+
+            self.stdout.write(
+                "Would you like to create a new '.env.local' file? [Y/n]: ", ending="")
+            if not no_input:
+                user_choice = input().strip().lower()
+            else:
+                user_choice = 'y'
+                
+            if user_choice in ['y', 'yes', '']:
+                new_file = '.env.local'
+
+                new_file_path = Path(settings.BASE_DIR) / new_file
+                new_file_path.touch(exist_ok=True)
+
+                self.stdout.write(self.style.SUCCESS(
+                    f"Created new file: {new_file}"))
+                return [new_file]
+            else:
+                self.stdout.write(self.style.WARNING(
+                    "Operation cancelled. No files were updated."))
+                return []
+
+        self.stdout.write(self.style.WARNING(
+            "\n⚠️  WARNING: Modifying configuration files can alter or overwrite existing variables.\n"
+            "Ensure you have a backup of your secrets before continuing."
+        ))
+
+        self.stdout.write("\nSelect an environment file to update:")
+        self.stdout.write(f"  0 - Select all files ({len(env_files)} found)")
+        for idx, file_name in enumerate(env_files):
+            self.stdout.write(f"  {idx + 1} - {file_name}")
+        if not no_input:
+            while True:
+                self.stdout.write("\nEnter selection number: ", ending="")
+                action = input().strip()
+
+                try:
+                    action_number = int(action)
+                    if action_number < 0 or action_number > len(env_files):
+                        self.stdout.write(self.style.ERROR(
+                            "Invalid selection. Number out of range."))
+                    else:
+                        if action_number == 0:
+                            return env_files
+                        return [env_files[action_number - 1]]
+                except ValueError:
+                    self.stdout.write(self.style.ERROR(
+                        "Invalid input. Please enter a valid integer number."))
+        else:
+            return env_files
+
+    def handle(self, *args, **options):
+        if settings.DEBUG:
+            self.stdout.write(self.style.WARNING(
+                "\n⚠️  SECURITY NOTICE: 'settings.DEBUG' is currently set to True.\n"
+                "Never run your Django application in a production environment with DEBUG enabled.\n"
+            ))
+
+        if options['append']:
+            self.stdout.write(self.style.WARNING(
+                "⚠️  IMPORTANT NOTICE:\n"
+                "Replacing an active server's SECRET_KEY will immediately invalidate all existing user sessions,\n"
+                "auth tokens, and signed cookies. If you only want to generate a text key without updating files,\n"
+                "abort this command and run it again without the '--append' flag.\n"
+            ))
+
+            self.stdout.write(
+                "Press [ENTER] to acknowledge this risk and continue, or Ctrl+C to abort...")
+            if not options['no_input']:
+                input()
+
+        self.stdout.write("Generating new secret key...")
+        secret_key = get_random_secret_key()
+
+        self.stdout.write(self.style.SUCCESS(
+            f"\nYour Secret Key: {secret_key}\n"))
+
+        if options['append']:
+            if options['file']:
+                target_file = options['file']
+                target_path = Path(settings.BASE_DIR) / target_file
+
+                if not target_path.exists():
+                    self.stdout.write(self.style.WARNING(
+                        f"File '{target_file}' does not exist. Creating it now."))
+                    target_path.touch(exist_ok=True)
+
+                selected_files = [target_file]
+            else:
+                selected_files = self._select_env_file(no_input=options['no_input'])
+
+            if selected_files:
+                self._append_to_env(secret_key, selected_files)
+                self.stdout.write(self.style.SUCCESS(
+                    f"Successfully updated files: {', '.join(selected_files)}"))
+            else:
+                self.stdout.write(self.style.WARNING(
+                    "No updates were made to files."))
+        else:
+            self.stdout.write(self.style.SUCCESS("Successfully generated!"))
+
+        self.stdout.write(self.style.SUCCESS(
+            "\n"
+            "Action Required: Update your settings.py \n"
+            "--------------------------------------------------\n"
+            "To make Django read your newly generated key, use:\n\n"
+            "SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')\n"
+            "--------------------------------------------------"
+        ))

django_keygen-0.1.0/django_keygen/management/commands/generate_password.py

@@ -0,0 +1,94 @@
+import sys
+from django.core.management.base import BaseCommand
+from django_keygen.core.passwords import generate_password
+
+
+class Command(BaseCommand):
+    help = "Interactively generate highly secure, random passwords."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--symbol",
+            action="store_true",
+            help="Include symbols/punctuation in the generated password.",
+        )
+        parser.add_argument(
+            "--numbers",
+            action="store_true",
+            help="Include numerical digits (0-9) in the generated password.",
+        )
+        parser.add_argument(
+            "--letters",
+            action="store_true",
+            help="Include lowercase letters (a-z) in the generated password.",
+        )
+        parser.add_argument(
+            "--uppercase",
+            action="store_true",
+            help="Include uppercase letters (A-Z) in the generated password.",
+        )
+        parser.add_argument(
+            "--secure",
+            action="store_true",
+            help="Shortcut to force uppercase, numbers, symbols, and a length of 20.",
+        )
+        parser.add_argument(
+            "--length",
+            "-len",
+            type=int,
+            default=12,
+            help="The length of the generated password (default: 12).",
+        )
+
+    def handle(self, *args, **options):
+        use_uppercase = True if options["secure"] else options["uppercase"]
+        use_symbols = True if options["secure"] else options["symbol"]
+        use_numbers = True if options["secure"] else options["numbers"]
+        length = options["length"]
+
+        while True:
+            password = generate_password(
+                length=length,
+                use_numbers=use_numbers,
+                use_symbols=use_symbols,
+                use_uppercase=use_uppercase,
+            )
+
+            self.stdout.write("\n" + "=" * 40)
+            self.stdout.write(
+                self.style.SUCCESS(f"Generated Password: {password}")
+            )
+            self.stdout.write("=" * 40 + "\n")
+
+            regen = (
+                input("Regenerate a new password? (y/N): ").strip().lower()
+            )
+            if regen != "y":
+                self.stdout.write(self.style.SUCCESS("Exiting."))
+                break
+
+            modify_config = (
+                input("Modify password configurations? (y/N): ")
+                .strip()
+                .lower()
+            )
+            if modify_config == "y":
+                action = input("Use symbols? (y/N): ").strip().lower()
+                use_symbols = action == "y"
+
+                action = input("Use numbers? (y/N): ").strip().lower()
+                use_numbers = action == "y"
+
+                action = input("Use uppercase? (y/N): ").strip().lower()
+                use_uppercase = action == "y"
+
+                try:
+                    len_input = input(f"Password length ({length}): ").strip()
+                    if len_input:
+                        length = int(len_input)
+                except ValueError:
+                    self.stdout.write(
+                        self.style.WARNING(
+                            f"Invalid number. Keeping current length of {length}."
+                        )
+                    )

django_keygen-0.1.0/django_keygen/management/commands/keygen.py

@@ -0,0 +1,140 @@
+from pathlib import Path
+from django.core.management.utils import get_random_secret_key
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from dotenv import set_key, dotenv_values
+from django_keygen.core.passwords import generate_password
+
+
+class Command(BaseCommand):
+    help = "Generate secret keys or passwords into an environment file."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "secret",
+            nargs="*",
+            metavar="SECRET",
+            help="One or more variable names to generate a Django secret key for.",
+        )
+        parser.add_argument(
+            "--passwords",
+            "-p",
+            nargs="+",
+            metavar="PASSWORDS",
+            default=[],
+            help="One or more variable names to generate a secure password for.",
+        )
+        parser.add_argument(
+            "--file", "-f",
+            type=str,
+            default=".env",
+            help="Path to the env file relative to BASE_DIR (default: .env).",
+        )
+        parser.add_argument(
+            "--append",
+            action="store_true",
+            help="Append/update keys into the existing file instead of recreating it.",
+        )
+        parser.add_argument(
+            "--no-input",
+            action="store_true",
+            help="Skip all confirmation prompts.",
+        )
+
+    def _affix(self, value: str, options: dict) -> str:
+        prefix = options.get("prefix") or ""
+        suffix = options.get("suffix") or ""
+        return f"{prefix}{value}{suffix}"
+
+    def _resolve_file(self, options: dict) -> Path | None:
+        env_path = Path(settings.BASE_DIR) / options["file"]
+
+        if not env_path.exists():
+            if not options["no_input"]:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"'{options['file']}' does not exist. Create it? [Y/n]: "),
+                    ending="",
+                )
+                if input().strip().lower() not in ("y", "yes", ""):
+                    self.stdout.write(self.style.ERROR("Aborted."))
+                    return None
+            env_path.touch()
+            self.stdout.write(self.style.SUCCESS(f"Created {options['file']}"))
+
+        if not options["append"] and not options["no_input"]:
+            self.stdout.write(self.style.WARNING(
+                f"\n⚠️  '{options['file']}' will be recreated and all existing values overwritten.\n"
+                "Press [ENTER] to continue or Ctrl+C to abort..."
+            ))
+            input()
+
+        return env_path
+
+    def _write_all(self, env_path: Path, secrets: dict[str, str]):
+        existing = dict(dotenv_values(env_path)) if env_path.exists() else {}
+        existing.update(secrets)
+        lines = "# Security Warning: keep the secret key used in production secret!\n"
+        lines += "# This file was managed/generated by django-keygen\n\n"
+        for key, value in existing.items():
+            lines += "\n# This secret was managed/generated by django-keygen\n"
+            lines += f"{key}='{value}'\n"
+        env_path.write_text(lines)
+
+    def handle(self, *args, **options):
+        if settings.DEBUG:
+            self.stdout.write(self.style.WARNING(
+                "\n⚠️  SECURITY NOTICE: 'settings.DEBUG' is currently set to True.\n"
+                "Never run your Django application in a production environment with DEBUG enabled.\n"
+            ))
+
+        if options['append']:
+            self.stdout.write(self.style.WARNING(
+                "⚠️  IMPORTANT NOTICE:\n"
+                "Replacing an active server's SECRET_KEY will immediately invalidate all existing user sessions,\n"
+                "auth tokens, and signed cookies. If you only want to generate a text key without updating files,\n"
+                "abort this command and run it again without the '--append' flag.\n"
+            ))
+
+            self.stdout.write(
+                "Press [ENTER] to acknowledge this risk and continue, or Ctrl+C to abort...")
+            if not options['no_input']:
+                input()
+        secret_names: list[str] = options["secret"]
+        passwords_names: list[str] = options["passwords"]
+        print(passwords_names)
+        if not secret_names and not passwords_names:
+            self.stdout.write(self.style.ERROR(
+                "Provide at least one variable name.\n"
+                "  Secrets:   python manage.py keygen KEY1 KEY2\n"
+                "  Passwords: python manage.py keygen --passwords PASS1 PASS2\n"
+                "  Mixed:     python manage.py keygen KEY1 --passwords PASS1 --file .env.local"
+            ))
+            return
+
+        env_path = self._resolve_file(options)
+        if env_path is None:
+            return
+
+        generated: dict[str, str] = {}
+
+        for name in secret_names:
+            generated[name] = self._affix(get_random_secret_key(), options)
+
+        for name in passwords_names:
+            generated[name] = self._affix(generate_password(), options)
+
+        if options["append"]:
+            for key, value in generated.items():
+                set_key(env_path, key, value)
+        else:
+            self._write_all(env_path, generated)
+
+        self.stdout.write(self.style.MIGRATE_HEADING(
+            f"\n--- {options['file']} ---"))
+        for key, value in generated.items():
+            self.stdout.write(f"  {self.style.MIGRATE_LABEL(key)}='{value}'")
+
+        self.stdout.write(self.style.SUCCESS(
+            f"\n {len(generated)} value(s) written to {options['file']}"
+        ))

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

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: django-keygen
+Version: 0.1.0
+Summary: django-keygen is a Django management command utility designed to securely generate cryptographic secret keys.
+Author-email: Mouhib sellami <mouhib.sellami@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mouhib-Sellami/django-keygen
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+django-keygen
+=============
+
+django-keygen is a Django management command utility for securely generating
+cryptographic secret keys and passwords, and optionally writing them into your
+project's environment (``.env``) files automatically.
+
+Detailed documentation will be available in the "docs" directory.
+
+Installation
+------------
+
+Install via pip::
+
+    pip install django-keygen
+
+Or install the latest version directly from GitHub::
+
+    pip install git+https://github.com/mouhib-Sellami/django-keygen.git
+
+Quick start
+-----------
+
+1. Add ``django_keygen`` to your ``INSTALLED_APPS``::
+
+    INSTALLED_APPS = [
+        ...,
+        'django_keygen',
+    ]
+
+Commands Overview
+-----------------
+
+django-keygen provides three management commands:
+
++---------------------------+-------------------------------------------------------+
+| Command                   | Purpose                                               |
++===========================+=======================================================+
+| ``keygen``                | Generate secret keys and/or passwords into a named    |
+|                           | ``.env`` file. The recommended all-in-one command.    |
++---------------------------+-------------------------------------------------------+
+| ``generate_django_secret``| Dedicated command for generating a single             |
+|                           | ``DJANGO_SECRET_KEY`` and optionally writing it to    |
+|                           | an env file via an interactive or flag-driven flow.   |
++---------------------------+-------------------------------------------------------+
+| ``generate_password``     | Interactive terminal interface for generating and     |
+|                           | tweaking secure passwords.                            |
++---------------------------+-------------------------------------------------------+
+
+----
+
+1. ``keygen`` — Unified Key & Password Generator
+-------------------------------------------------
+
+The ``keygen`` command is the recommended way to generate one or more secret
+keys and/or passwords and write them into an environment file in a single step.
+Variable names are passed directly as arguments, so each generated value is
+stored under the name you choose.
+
+**Positional arguments:**
+
+* ``SECRET [SECRET ...]``
+    One or more variable names to generate a Django secret key for (e.g.
+    ``SECRET_KEY API_KEY``). Each name receives its own independently generated
+    cryptographic key.
+
+**Flags:**
+
+* ``--passwords PASSWORDS [PASSWORDS ...]``, ``-p``
+    One or more variable names to generate a secure password for instead of a
+    Django secret key (e.g. ``-p DB_PASSWORD REDIS_PASSWORD``).
+
+* ``--file FILE``, ``-f``
+    Path to the env file, relative to ``BASE_DIR`` (default: ``.env``). If the
+    file does not exist, the command offers to create it.
+
+* ``--append``
+    Update the existing file in place rather than recreating it from scratch.
+    Without this flag the file is fully rewritten (all previous content is
+    preserved but reformatted alongside the new values). Prompts a confirmation
+    warning because replacing an active ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--no-input``
+    Skip all confirmation prompts. Useful for automated deployments, Docker
+    entrypoints, and CI/CD pipelines.
+
+**Examples**::
+
+    # Generate SECRET_KEY and write it to .env (recreates the file)
+    python manage.py keygen SECRET_KEY
+
+    # Generate two secret keys into a specific file, no prompts
+    python manage.py keygen SECRET_KEY API_KEY --file .env.production --no-input
+
+    # Generate a secret key and two passwords into .env.local, appending
+    python manage.py keygen SECRET_KEY --passwords DB_PASSWORD REDIS_PASSWORD \
+        --file .env.local --append
+
+    # Generate only passwords (no secret keys)
+    python manage.py keygen --passwords DB_PASSWORD --file .env
+
+----
+
+2. ``generate_django_secret`` — Dedicated Secret Key Command
+-------------------------------------------------------------
+
+The ``generate_django_secret`` command is dedicated to generating a single
+Django secret key stored under the ``DJANGO_SECRET_KEY`` variable. Run it
+without any flags to simply print a key to the terminal, or add ``--append``
+to write it to an env file.
+
+When writing to a file, the command either accepts a path via ``--file`` or
+launches an interactive file-selection menu that scans your project for
+existing ``.env*`` files.
+
+**Flags:**
+
+* ``--append``
+    Write the generated key to an environment file. Without this flag the key
+    is only printed to stdout — no files are touched. Prompts a confirmation
+    warning because replacing a live ``SECRET_KEY`` invalidates all existing
+    sessions, tokens, and signed cookies.
+
+* ``--file FILE``, ``-f``
+    Directly specify the env file to update (e.g. ``-f .env.production``),
+    bypassing the interactive selection menu. If the file does not exist it is
+    created automatically. Only used together with ``--append``.
+
+* ``--no-input``
+    Suppress all interactive prompts, menus, and risk warnings. Useful for
+    automated deployments and CI/CD pipelines.
+
+**Examples**::
+
+    # Print a new secret key to the terminal only (no file changes)
+    python manage.py generate_django_secret
+
+    # Interactively choose which env file to update
+    python manage.py generate_django_secret --append
+
+    # Write directly to a specific file, no prompts
+    python manage.py generate_django_secret --append --no-input -f .env.local
+
+**After running**, update your ``settings.py`` to read the key from the
+environment::
+
+    import os
+    SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')
+
+----
+
+3. ``generate_password`` — Interactive Password Generator
+---------------------------------------------------------
+
+The ``generate_password`` command launches an interactive terminal session for
+generating and refining secure passwords. After each password is shown, you can
+regenerate it or adjust the composition settings without restarting the command.
+
+**Flags** (set initial defaults; all can be changed interactively):
+
+* ``--length LENGTH``, ``-len``
+    Desired password length (default: 12).
+
+* ``--letters``
+    Include lowercase letters (a–z).
+
+* ``--uppercase``
+    Include uppercase letters (A–Z).
+
+* ``--numbers``
+    Include numerical digits (0–9).
+
+* ``--symbol``
+    Include symbols and punctuation characters.
+
+* ``--secure``
+    Shortcut that forces uppercase letters, numbers, symbols, and a minimum
+    length of 20. Overrides individual composition flags.
+
+**Examples**::
+
+    # Launch with defaults (12 characters, no composition constraints)
+    python manage.py generate_password
+
+    # Start with a longer length and reconfigure interactively
+    python manage.py generate_password --length 16
+
+    # Instantly generate a highly secure 20-character password
+    python manage.py generate_password --secure
+
+----
+
+Programmatic Usage
+------------------
+
+The underlying password generator can be imported directly into your own
+Django apps — useful for custom registration flows, invitation tokens, or
+background tasks::
+
+    from django_keygen.core.passwords import generate_password
+
+    # Generate a secure password with specific character sets
+    new_password = generate_password(
+        length=14,
+        use_uppercase=True,
+        use_numbers=True,
+        use_symbols=True,
+    )
+
+    # Use it in your application logic
+    from django.contrib.auth.models import User
+    user = User.objects.create_user(username='johndoe', email='john@example.com')
+    user.set_password(new_password)
+    user.save()
+
+----
+
+License
+-------
+
+django-keygen is released under the **MIT License**.
+
+Copyright (c) 2026 Mouhib Sellami
+
+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.
+
+See the ``LICENSE`` file in the repository root for the full license text,
+or visit: https://github.com/mouhib-Sellami/django-keygen/blob/main/LICENSE

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

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.rst
+pyproject.toml
+django_keygen/__init__.py
+django_keygen/apps.py
+django_keygen.egg-info/PKG-INFO
+django_keygen.egg-info/SOURCES.txt
+django_keygen.egg-info/dependency_links.txt
+django_keygen.egg-info/requires.txt
+django_keygen.egg-info/top_level.txt
+django_keygen/core/__init__.py
+django_keygen/core/passwords/__init__.py
+django_keygen/management/__init__.py
+django_keygen/management/commands/__init__.py
+django_keygen/management/commands/generate_django_secret.py
+django_keygen/management/commands/generate_password.py
+django_keygen/management/commands/keygen.py

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

@@ -0,0 +1 @@
+

django_keygen-0.1.0/django_keygen.egg-info/requires.txt

@@ -0,0 +1,2 @@
+django>=4.2
+python-dotenv>=1.0.0

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

@@ -0,0 +1 @@
+django_keygen

django_keygen-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["django_keygen*"]
+
+[project]
+name = "django-keygen"
+version = "0.1.0"
+dependencies = [
+    "django>=4.2",
+    "python-dotenv>=1.0.0",
+]
+description = "django-keygen is a Django management command utility designed to securely generate cryptographic secret keys."
+readme = "README.rst"
+license = "MIT"
+requires-python = ">= 3.9"
+authors = [
+    {name = "Mouhib sellami", email = "mouhib.sellami@gmail.com"},
+]
+classifiers = [
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14"
+]
+
+[project.urls]
+Homepage = "https://github.com/mouhib-Sellami/django-keygen"

django_keygen-0.1.0/setup.cfg

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