falco-cli 0.23.2__tar.gz → 0.23.4__tar.gz

{falco_cli-0.23.2 → falco_cli-0.23.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: falco-cli
-Version: 0.23.2
+Version: 0.23.4
 Summary: Enhance your Django developer experience: CLI and Guides for the Modern Developer.
 Project-URL: Documentation, https://falco.oluwatobi.dev/
 Project-URL: Homepage, https://falco.oluwatobi.dev/

{falco_cli-0.23.2 → falco_cli-0.23.4}/docs/install.rst

@@ -16,6 +16,11 @@ You can also automatically install just with falco by running:
 
     pip install falco-cli[just]
 
+.. note::
+
+    The ``just`` extra does not work on Windows. If you are on Windows, you can follow the install instuctions
+    `here <https://just.systems/man/en/chapter_4.html>`_
+
 Next Up
 -------
 

{falco_cli-0.23.2 → falco_cli-0.23.4}/docs/the_cli/start_project/dependency.rst

@@ -22,6 +22,21 @@ The project is set up to use hatch_ for virtual environment management and depen
 
    -- Official hatch documentation
 
+
+.. admonition:: why hatch?
+   :class: dropdown note
+
+   Using hatch is a recent switch for me. Previously, I used `poetry <https://python-poetry.org/>`_ as my preferred tool. While poetry is still a great tool, I have chosen hatch for the following reasons:
+
+   1. Backed by the **pypa** (Python Packaging Authority), hatch aligns with the efforts to solve packaging and tooling issues in the Python ecosystem. I believe that if the Python ecosystem ever manages to overcome these challenges, it will be because the pypa has reached a consensus, and I hope that hatch will be the chosen solution. We all hope to see a cargo-like tool for Python someday.
+
+   2. Hatch now has the ability to install and manage Python versions, along with other existing features. This brings it closer to being the all-in-one tool that every Python developer needs.
+
+   3. Hatch is PEP-friendly, making it compatible with other tools in the ecosystem. It adds minimal custom configuration to the ``pyproject.toml`` file and relies on existing standards for project information and dependencies.
+
+   4. In terms of performance, hatch is faster compared to poetry. While poetry is generally not slow, there have been rare instances where it took 30 minutes to install requirements. I have experienced this a few times.
+
+
 Read the hatch documentation on `environment <https://hatch.pypa.io/latest/environment/>`_ for more information on how to manage virtual environments.
 Hatch can do a lot, including `managing Python installations <https://hatch.pypa.io/latest/cli/reference/#hatch-python>`_, but for the context of the project, these are the things you need to know.
 
@@ -44,94 +59,65 @@ Hatch can do a lot, including `managing Python installations <https://hatch.pypa
 Environments
 ************
 
-The project comes with three environment configurations: ``default``, ``test``, and ``docs``.
+The project comes with three environment configurations: ``default``, ``dev``, and ``docs``.
 
-- The ``default`` environment is activated when you run ``hatch shell``. It contains all the necessary requirements and some development tools.
-- The ``test`` environment contains packages used for testing, such as ``pytest``, ``django-pytest``, etc.
+- The ``default`` environment is activated when you run ``hatch shell``. It is the default environment made available by Hatch and contains all the required dependencies for your project to run in production.
+- The ``dev`` environment contains packages used for development and testing, such as ``django-debug-toolbar``, ``pytest``, ``django-pytest``, etc.
 - The ``docs`` environment is for documentation. It contains tools such as ``sphinx``, ``furo``, etc.
 
-Each environment defines a scripts section with some scripts. To run a script, use the following command:
-
-.. code-block:: bash
-
-   hatch run <env>:<script>
+.. admonition:: Install all dependencies
+   :class: dropdown note
 
-The first time you run the script, Hatch automatically sets up and installs dependencies for the specified environment. 
-You don't need to manage it manually. If the dependencies list has changed, Hatch will automatically install them the next 
-time a command from that environment is run.
+   Running ``just bootstrap`` will create all three environments and install the dependencies for each.
 
-A requirements file for the environment is also created using `hatch-pip.compile <https://github.com/juftin/hatch-pip-compile>`_. For 
-the default environment, the file will be located at the root of your project and named ``requirements.txt``. This is the file 
-you would use to install the requirements in production. For other environments, the file is created in a 
-``requirements`` folder with the name ``requirements-<env>.txt``.
+Although ``hatch`` comes with an integrated script runner, the project uses `just <https://just.systems/>`_ as the script runner. The main reason is that it is a more universal solution (not limited to the Python ecosystem) and 
+I find it more flexible. Paired with the `scripts-to-rule-them-all <https://github.com/github/scripts-to-rule-them-all>`_ pattern, it's an efficient way to standardize a set of commands 
+(``setup``, ``server``, ``console``, etc.) across all your projects, whether they are Django, Python, or something else. This way, you don't need to remember a different set of commands for each project.
 
-
-Activate the virtual environment
-********************************
-
-To activate the default virtual environment, run:
+To see all available scripts or `recipes` as ``just`` calls them, you can run:
 
 .. code-block:: bash
 
-   $ hatch shell
+   $ just
 
-You don't need to activate your shell to run commands. When using ``hatch run``, dependencies will be automatically synced (installed or removed if necessary) and the command will be
-executed in the appropriate virtual environment.
+The primary environment you'll use during development is the ``dev`` environment. To run a command, you can either run ``just run`` or ``hatch --env dev run``. The first command is basically an alias for the second.
 
-For instance, to run the Django development server, you can use the following command:
+**Examples**
 
 .. code-block:: bash
 
-   $ hatch run python manage.py runserver
-
-This will run your project in the default virtual environment.
-
-Add / remove a new dependency
-*****************************
+   $ just run python # launch the Python shell
+   $ just run python manage.py dbshell # launch the database shell
 
-The default virtual environment includes all the dependencies specified in the ``[project.dependencies]`` section of the ``pyproject.toml`` file.
-To add a new dependency to your project, simply edit the ``pyproject.toml`` file and add it to the ``[project.dependencies]`` section.
-The next time you run a command using hatch, such as ``hatch run python manage.py runserver``, hatch will automatically install the new dependency.
-The process is the same for removing a dependency.
+There are aliases for most Django commands, such as ``just server`` to run the development server, ``just migrate`` to apply migrations, ``just createsuperuser`` to create a superuser, etc. 
+. For any other commands that aren't explicitly aliased, you can run ``just dj <command>`` to run the command in the Django context.
 
-Scripts
-*******
+Activate the virtual environment
+********************************
 
-The ``pyproject.toml`` file in the project defines some convenient scripts for common commands in a Django project. The section looks something like this:
+To activate an environment for the current shell, run ``hatch shell <env_name>``, so ``hatch shell dev`` will activate the ``dev`` environment. If no specific environment name is provided, the default environment is activated.
 
-.. code-block:: toml
+.. admonition:: Get the path of the dev environment
+   :class: dropdown note
 
-   [tool.hatch.envs.default.scripts]
-   runserver = ["migrate", "python manage.py tailwind runserver {args}"]
-   migrate = "python manage.py migrate {args}"
-   makemigrations = "python manage.py makemigrations {args}"
-   ...
+   You can get the full path of the dev environment with ``just env-path`` or ``hatch env-path dev``. This can be useful to specify the interpreter in VSCode or PyCharm, for example.
 
-To start the Django development server for example, you can use the command ``hatch run runserver``.
+You don't need to activate your shell to run commands. When running a just script, dependencies will be automatically synced (installed or removed if necessary), since it uses Hatch underneath, and 
+the command will be executed in the appropriate virtual environment.
 
-.. admonition:: Alias Hatch run
-   :class: tip
 
-   To make typing hatch commands faster, you can create an alias for ``hatch run``. For example, you can alias it as ``hr``. So,
-   Instead of typing ``hatch run runserver``, you can simply use the alias ``hr runserver``. However, please note that if your system takes time to resolve the alias,
-   it may impact your overall experience.
+Add / remove a new dependency
+*****************************
 
-For development, I think this workflow should work quite well. Now, what happens when you need to deploy your app? You could install hatch on
-the deploy target machine, but I prefer having a ``requirements.txt`` file that I can use to install dependencies on the deployment machine.
-That's where ``hatch-pip-compile`` comes in.
+The default virtual environment includes all the dependencies specified in the ``[project.dependencies]`` section of the ``pyproject.toml`` file. To add a new dependency to your project, simply edit the ``pyproject.toml`` file and add it to the ``[project.dependencies]`` section. 
+The next time you run a command using ``just``, such as ``just server``, Hatch (used underneath by the just script) will automatically install the new dependency. The process is the same for removing a dependency.
 
-.. admonition:: why hatch?
+.. admonition:: Install a specific version of a package
    :class: dropdown note
 
-   Using hatch is a recent switch for me. Previously, I used `poetry <https://python-poetry.org/>`_ as my preferred tool. While poetry is still a great tool, I have chosen hatch for the following reasons:
+   You can also explicitly install a dependency after adding or removing it by running ``just install``.
 
-   1. Backed by the **pypa** (Python Packaging Authority), hatch aligns with the efforts to solve packaging and tooling issues in the Python ecosystem. I believe that if the Python ecosystem ever manages to overcome these challenges, it will be because the pypa has reached a consensus, and I hope that hatch will be the chosen solution. We all hope to see a cargo-like tool for Python someday.
-
-   2. Hatch now has the ability to install and manage Python versions, along with other existing features. This brings it closer to being the all-in-one tool that every Python developer needs.
-
-   3. Hatch is PEP-friendly, making it compatible with other tools in the ecosystem. It adds minimal custom configuration to the ``pyproject.toml`` file and relies on existing standards for project information and dependencies.
-
-   4. In terms of performance, hatch is faster compared to poetry. While poetry is generally not slow, there have been rare instances where it took 30 minutes to install requirements. I have experienced this a few times.
+For development, I think this workflow should work quite well. Now, what happens when you need to deploy your app? You could install Hatch on the deployment target machine, but I prefer having a ``requirements.txt`` file that I can use to install dependencies on the deployment machine. That's where ``hatch-pip-compile`` comes in.
 
 
 hatch-pip-compile
@@ -149,14 +135,15 @@ Here is the current configuration in the ``pyproject.toml`` file relevant to hat
 
    [tool.hatch.env]
    requires = [
-   "hatch-pip-compile"
+      "hatch-pip-compile>=1.11.2"
    ]
 
    [tool.hatch.envs.default]
    type = "pip-compile"
-   # pip-compile-installer = "pip-sync"
+   pip-compile-constraint = "default"
    pip-compile-installer = "uv"
    pip-compile-resolver = "uv"
+   lock-filename = "requirements.txt"
    ...
 
 Thanks to `hatch-pip-compile <https://juftin.com/hatch-pip-compile/>`_, we can try `uv <https://github.com/astral-sh/uv>`_, which is, and I quote:
@@ -165,28 +152,18 @@ Thanks to `hatch-pip-compile <https://juftin.com/hatch-pip-compile/>`_, we can t
 
    -- Official github
 
-Needless to say, it does make a noticeable difference in speed. If you encounter any issues with ``uv``, comment out the two lines referencing it in the above
-config, and uncomment the currently commented one.
-
-
-Working without hatch
----------------------
-
-You don't have to use Hatch if you don't want to. Thanks to Hatch being very PEP-friendly, you can use the ``pyproject.toml`` file with recent versions of
-pip to install the main dependencies of the project. You won't be able to use the scripts (for that, you can use `peothepoet <https://github.com/nat-n/poethepoet>`_) or any other Hatch features,
-but you may not need them.
-
-Let's assume you want to use the classic ``venv``. Here's what the workflow would look like:
-
-1. Remove any Hatch-related configuration from the pyproject.toml file, including anything starting with ``[tool.hatch]``. This step is optional and up to your choice.
-2. Create a virtual environment using ``python -m venv venv``.
-3. Activate the virtual environment using ``source venv/bin/activate``.
-4. Install the dependencies using ``pip install -e .``. This command will install your project and its dependencies using the ``pyproject.toml`` file.
-
-To add or remove dependencies, the process is the same. You edit the ``[project.dependencies]`` section of the pyproject.toml file and run ``pip install -e .``. You can complement
-this workflow with `pip-tools <https://github.com/jazzband/pip-tools>`_ to generate a requirements file.
+Needless to say, it does make a noticeable difference in speed. If you encounter any issues with ``uv``, you can easily switch back to pip by updating the configurations as below:
 
+.. code-block:: toml
+   :caption: pyproject.toml
 
+   [tool.hatch.envs.default]
+   type = "pip-compile"
+   pip-compile-constraint = "default"
+   pip-compile-installer = "pip"
+   pip-compile-resolver = "pip-compile"
+   lock-filename = "requirements.txt"
+   ...
 
 
 .. _hatch: https://hatch.pypa.io/latest/

{falco_cli-0.23.2 → falco_cli-0.23.4}/docs/the_cli/usage.rst

@@ -24,14 +24,6 @@ please create a `new issue <https://github.com/Tobi-De/falco/issues/new>`_.
 
         pip install falco-cli[just]
 
-    And after you've generated a new project, inside the project directory you can run:
-
-    .. code-block:: bash
-
-        just install-hatch
-
-    This will install hatch globally on your system, you won't need to run this for every new project.
-
 Let's create a new project called **myjourney**. This will be a journaling app and its main app will be **entries**.
 Each **entry** represents a journal entry within the **myjourney** app.
 

{falco_cli-0.23.2 → falco_cli-0.23.4}/pyproject.toml

@@ -237,7 +237,7 @@ source_pkgs = [
 allow_dirty = false
 commit = true
 commit_args = "--no-verify"
-current_version = "0.23.2"
+current_version = "0.23.4"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "Bump version: {current_version} → {new_version}"

{falco_cli-0.23.2 → falco_cli-0.23.4}/src/falco/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present Tobi DEGNON <tobidegnon@proton.me>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.23.2"
+__version__ = "0.23.4"

{falco_cli-0.23.2 → falco_cli-0.23.4}/src/falco/config.py

@@ -35,7 +35,11 @@ def write_falco_config(pyproject_path: Path, **kwargs: Unpack[TypedDict]) -> Non
     new_falco_config = kwargs
     new_crud_config = parse_crud_config_to_pyproject(new_falco_config.pop("crud", {}))
 
-    pyproject = tomlkit.parse(pyproject_path.read_text()) if pyproject_path.exists() else {}
+    # pyproject = tomlkit.parse(pyproject_path.read_text()) if pyproject_path.exists() else {}
+    if pyproject_path.exists():  # noqa
+        pyproject = tomlkit.parse(pyproject_path.read_text(encoding="utf-8"))
+    else:
+        pyproject = {}
     existing_falco_config = pyproject.get("tool", {}).get("falco", {})
     existing_crud_config = existing_falco_config.pop("crud", {})
 
@@ -49,7 +53,7 @@ def write_falco_config(pyproject_path: Path, **kwargs: Unpack[TypedDict]) -> Non
 
 
 def read_falco_config(pyproject_path: Path) -> FalcoConfig:
-    pyproject = tomlkit.parse(pyproject_path.read_text())
+    pyproject = tomlkit.parse(pyproject_path.read_text(encoding="utf-8"))
     falco_config = pyproject.get("tool", {}).get("falco", {})
     crud_config = falco_config.pop("crud", {})
     crud_config = parse_crud_config_from_pyproject(crud_config)

falco_cli-0.23.2/blueprints/falco_blueprint_basic/.git

@@ -1 +0,0 @@
-gitdir: ../../.git/modules/blueprints/falco_blueprint_basic

falco_cli-0.23.2/blueprints/falco_blueprint_basic/.github/workflows/ci.yml

@@ -1,55 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: ['master', 'main']
-  push:
-    branches: ['master', 'main']
-  workflow_dispatch:
-
-jobs:
-  create-project:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install falco
-        run: pip install falco-cli --pre
-      - name: Checkout Code Repository
-        uses: actions/checkout@v4
-      # - name: Debugging with ssh
-      #   uses: lhotari/action-upterm@v1
-      - name: Generate a project
-        run: falco start-project test-project -b . --skip-new-version-check
-        working-directory: ./
-      - name: Install Hatch
-        uses: pypa/hatch@install
-      - name: Install just
-        uses: extractions/setup-just@v2
-      - name: Run django checks
-        run: cd test_project && just dj check --fail-level WARNING
-
-  build-image:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code Repository
-        uses: actions/checkout@v4
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.0.0
-      - name: Install falco
-        run: pip install falco-cli --pre
-      - name: Generate a project
-        run: falco start-project test-project -b . --skip-new-version-check
-        working-directory: ./
-      - name: Install Hatch
-        uses: pypa/hatch@install
-      - name: Install just
-        uses: extractions/setup-just@v2
-      - name: Generate requirements.txt
-        run: cd test_project && just bootstrap
-      - name: Build image
-        run: cd test_project && rm .env && docker build . -f deploy/Dockerfile
-
-

falco_cli-0.23.2/blueprints/falco_blueprint_basic/.github/workflows/pre-commit-auto-update.yml

@@ -1,44 +0,0 @@
-# Run pre-commit autoupdate every day at midnight
-# and create a pull request if any changes
-
-name: Pre-commit auto-update
-
-on:
-  schedule:
-    - cron: "15 2 * * *"
-  workflow_dispatch: # to trigger manually
-
-permissions:
-  contents: read
-
-jobs:
-  auto-update:
-    # Disables this workflow from running in a repository that is not part of the indicated organization/user
-    if: github.repository_owner == 'Tobi-De'
-    permissions:
-      contents: write # for peter-evans/create-pull-request to create branch
-      pull-requests: write # for peter-evans/create-pull-request to create a PR
-
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.11"
-
-      - name: Install pre-commit
-        run: pip install pre-commit
-
-      - name: Autoupdate generated projects
-        working-directory: "{{ cookiecutter.project_name }}"
-        run: pre-commit autoupdate
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v5
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          branch: update/pre-commit-autoupdate
-          title: Auto-update pre-commit hooks
-          commit-message: Auto-update pre-commit hooks
-          body: Update versions of tools in pre-commit configs to latest version
-          labels: update

falco_cli-0.23.2/blueprints/falco_blueprint_basic/LICENSE

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

falco_cli-0.23.2/blueprints/falco_blueprint_basic/README.md

@@ -1,10 +0,0 @@
-# falco blueprint basic
-
-[![CI](https://github.com/Tobi-De/falco_blueprint_basic/actions/workflows/ci.yml/badge.svg)](https://github.com/Tobi-De/falco_blueprint_basic/actions/workflows/ci.yml)
-
-Project blueprint for https://github.com/Tobi-De/falco, run with:
-
-```shell
-pip install falco-cli
-falco start-project my_awesome_project
-```

falco_cli-0.23.2/blueprints/falco_blueprint_basic/cookiecutter.json

@@ -1,6 +0,0 @@
-{
-  "project_name": "{{ cookiecutter.project_name }}",
-  "author_name": "{{ cookiecutter.author_name }}",
-  "author_email": "{{ cookiecutter.author_name }}",
-  "secret_key": "{{ cookiecutter.secret_key }}"
-}

falco_cli-0.23.2/blueprints/falco_blueprint_basic/{{ cookiecutter.project_name }}/.dockerignore

@@ -1,14 +0,0 @@
-*
-
-!{{ cookiecutter.project_name }}/
-!deploy/
-!manage.py
-!requirements*.txt
-!tailwind.config.js
-!package*.json
-
-**/*~
-**/*.log
-**/.DS_Store
-**/Thumbs.db
-**/__pycache__/

falco_cli-0.23.2/blueprints/falco_blueprint_basic/{{ cookiecutter.project_name }}/.editorconfig

@@ -1,27 +0,0 @@
-# http://editorconfig.org
-
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.{py,rst,ini}]
-indent_style = space
-indent_size = 4
-
-[*.{html,css,scss,json,yml,xml,toml}]
-indent_style = space
-indent_size = 2
-
-[*.md]
-trim_trailing_whitespace = false
-
-[Makefile]
-indent_style = tab
-
-[default.conf]
-indent_style = space
-indent_size = 2

falco_cli-0.23.2/blueprints/falco_blueprint_basic/{{ cookiecutter.project_name }}/.env.template

@@ -1,15 +0,0 @@
-SECRET_KEY=
-ALLOWED_HOSTS=
-DEBUG=
-DATABASE_URL=
-ADMIN_URL=
-DEFAULT_FROM_EMAIL=
-
-AWS_ACCESS_KEY_ID=
-AWS_SECRET_ACCESS_KEY=
-AWS_S3_REGION_NAME=
-
-SENTRY_DSN=
-
-DJANGO_SUPERUSER_EMAIL=
-DJANGO_SUPERUSER_PASSWORD=

falco_cli-0.23.2/blueprints/falco_blueprint_basic/{{ cookiecutter.project_name }}/.github/dependabot.yml

@@ -1,16 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: "pip" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "pip"
-    directory: "/requirements"
-    schedule:
-      interval: "weekly"