semvec/pypi-packages huggingface dataset:
mkprj 0.1.1
Easily create new Python projects.
License: MIT
Requires Python: >=3.5.0


## mkprj

A basic CLI tool to create bare-bones Python projects, the way I like them.

It will:

- Create a project directory
- Initialize `git`
- Add a `.gitignore`
- Create a virtualenv
- Create a `requirements.txt` with the default requirements, or a comma-separate list specified with `--requirements`


## Installation

```bash
pip install mkprj
```

## Usage

```bash
usage: mkprj [-h] [--python PYTHON] [--overwrite] [--requirements REQUIREMENTS] project_path

positional arguments:
  project_path          Path to the project to create.

optional arguments:
  -h, --help            show this help message and exit
  --python PYTHON       Path to Python interpreter to use. Defaults to 'python3'.
  --overwrite           Overwrite existing project at specified directory.
  --requirements REQUIREMENTS
                        Comma-separated list of requirements to install.

```

## Planned enhancements

- A `--docker` flag to create a `Dockerfile`, plus `build.sh` and `push.sh` executable bash scripts
- Better support for creating virtualenvs in a default location (instead of the project directory)
- creating a main.py and test directory

More to come.
quicken 0.1.0
Make Python apps fast.
License: MIT
Requires Python: >=3.7,<4.0

# quicken

Make Python tools fast.

```python
# app/cli.py
import slow_module
import has_lots_of_dependencies


def cli():
    print('hello world')
    # Finally get to work after everything is loaded.
    slow_module.do_work(has_lots_of_dependencies)
    

# app/main.py
from quicken import cli_factory


@cli_factory('app')
def main():
    from .cli import cli
    return cli
```

That's it! The first time `main()` is invoked a server will be created and
stay up even after the process finishes. When another process starts up it
will request the server to execute `cli` instead of reloading all modules
(and dependencies) from disk. This relies on the speed of `fork` being lower
than the startup time of a typical cli application.

If `python -c ''` takes 10ms, this module takes around 40ms. That's how
fast your command-line apps can start every time after the server is up.


# Why

Python command-line tools are slow. We can reduce dependencies, do lazy
importing, and do little/no work at the module level but these can only go
so far.

Our goal is to speed up the cli without giving up any dependencies. Every Python
CLI tool should be able to get to work in less than 100ms.

# Goals

* Be as fast as possible when invoked as a client, be pretty fast when invoked
  and we need to start a server.

# Limitations

* Unix only.
* Debugging may be less obvious for end users or contributors.
* Daemon will not automatically have updated gid list if user was modified.
* Access to the socket file implies access to the daemon (and the associated command that it would run if asked).

# Tips

* Profile import time with -X importtime, see if your startup is actually the
  problem. If it's not then this package will not help you.
* Distribute your package as a wheel. When wheels are installed they create
  scripts that do not import `pkg_resources`, which can save 60ms+ depending
  on disk speed and caching.

# Development

```
ln -sf ../.githooks .git/hooks
```