semvec/pypi-packages huggingface dataset:
whatnext 3.0
A lister of tasks found in Markdown files
Requires Python: >=3.10
Keywords: cli, markdown, tasks, todo

# What next?

I like to keep tasks in Markdown files. That way they can be interspersed
within instructions, serving as reminders, FIXMEs, and other todos.

All the features for enhancing your task lists are discussed in detail in
[the documentation](https://github.com/norm/whatnext/blob/main/docs/index.md).

Document your tasks using an expanded version of the original
[GitHub task list notation][sn]:

```markdown
- [ ] open, this task is outstanding
- [/] in progress, this task is partially complete
- [X] complete, this task has been finished
- [#] cancelled, this task has been scratched
- [<] blocked, this task needs more input

- [ ] _an important task_

# **Make apple pie from scratch**
- [ ] invent the universe

# Things for later

- [ ] get NYE fireworks tickets @2025-12-31
- [ ] but in the end it doesn't even matter @after
```

Then install `whatnext`:

```bash
pip install whatnext
```

Now run it and it'll tell you what's next, sorting by priority and state:

```bash
(computer)% whatnext
README.md:
    # What next? / HIGH
    - [ ] a lot more important

README.md:
    # What next? / MEDIUM
    - [ ] a little more important

README.md:
    # What next? / IMMINENT 6d
    - [ ] get NYE fireworks tickets

README.md:
    # What next?
    - [/] in progress, this task is partially complete
    - [ ] open, this task is outstanding
    - [<] blocked, this task needs more input
```

Also provided, `next` to add tasks to files.

```bash
# by default, adds to $HOME/tasks.md
(computer)% next Add more features to whatnext
Updated tasks.md
```

[sn]: https://blog.github.com/2013-01-09-task-lists-in-gfm-issues-pulls-comments/
autoinput 1.4
Easier input for Python
Requires Python: >=3.9

# Autoinput
This library is for easier input in Python. It is 100% that you don't want to do this:

```Python
while 1:
  try:
    x = int(input())
    break
  except:
    print("Please input a number")
```

because it is 6 lines when you can have 1 line:

```Python
x = autoinput("", autoinput_type.INTEGER)
```

and everything is inside the function. No work by hands.

## how to use
Here is the definition

```Python
def autoinput(outstring: str, typeel, pipe_in: Callable[[str], str]=input, pipe_out: Callable[[str], None]=print, pipe_out_end_name: str="end", pipe_out_flush_name: str="flush", parser=None) -> Any:
```

First argument  - `outstring`, string to show.

Second argument - `typeel`, use autoinput_type enum to form this (example: `autoinput_type.INTEGER | autoinput_type.ARRAY`)

kwargs:

  `pipe_in`  - for custom input function (for example if you use GUI)
  
  `pipe_out` - for custom output function
  
  `parser`   - for custom parser (don't use with `autoinput_type` except of `autoinput_type.ARRAY` and/or `autoinput_type.STRING`)
  
  `pipe_out_end_name`   - if your custom output function doesn't have parameter like `print`'s `end` use `None`, if has but called not `end` use the parameter to specify the name.
  
  `pipe_out_flush_name` - the same as `pipe_out_end_name` but for flush.

## autoinput_type - the way to specify type of data

### values

`autoinput_type` - IntFlag used to specify the type. Here are variants of it:

`autoinput_type.INTEGER` - return integer

`autoinput_type.FLOAT` - return floating point number

`autoinput_type.STRING` - return string, default type

`autoinput_type.BOOLYN` - asks yes or no, return bool

`autoinput_type.BOOLTF` - asks true or false, return bool

`autoinput_type.ARRAY` - asks for array where values are separated by space, return array of another type (if not specified returns str)

### how to use

To combine autoinput_type use `|`. Example:

```Python
autoinput_type.INTEGER | autoinput_type.ARRAY
```

**WARNING:** Do not combine types like that:

```Python
autoinput_type.INTEGER | autoinput_type.FLOAT
```

You will get an error if you try to run this.

If you need not a basic type use `parser` named argument.

## how to get Autoinput

To get Autoinput you can run this:

```Bash
pip install autoinput
```

**or:**

**Linux:**

```Bash
python3 -m pip install autoinput
```

**Windows:**

```cmd
py -m pip install autoinput
```
hatch-django-locales 0.1.5
A hatchling build hook to compile django locale files during build time
Requires Python: >=3.10


# hatch-django-locales

This package provides a hatchling plugin (build hook) for Django projects that
automatically compiles locale files when building the package. 

## Usage

In your projects `pyproject.toml`, make sure you are using the hatchling build system 
and add the following:

```toml
[tool.hatch.build.hooks.django-locales]
dependencies = ["hatch-django-locales>=0.1.5", "django"]
search-directories = ["src"]
```

The ``search-directories`` option should be a list of directories to glob 
for ``locale`` directories and is your project root by default.
Make sure that the ``.mo`` files are actually included in the wheels produced 
by your build process.