semvec/pypi-packages huggingface dataset:
extencli 0.2.0
A set of utilities around click, for extensible CLI
Requires Python: >=3.10

# extencli

A set of utilities around click, which offers extensible CLI mechanism, with little effort

## Features

### Easy third-party extensible click.group

This package offers a specialized
[click.group](https://click.palletsprojects.com/en/stable/api/#click.Group)
implementation. Using it, you can create a CLI that will be extended by
simply installing additional modules.

As an example, here is how one would define an extensible `click.group` in
their python package `core_module`:

```python
import click

from extencli import PluginAutoloaderGroup

@click.group('core', cls=PluginAutoloaderGroup, depends_on='core_module')
def core_group():
    ...
```

The `depends_on` parameter is required:
 - `depends_on` specifies the name of the package that CLI
   extensions should depend on

Now, the CLI extension package should import the `core_group` from the
`core_module` like so:

```python
from core_module.cli import core_group

@core_group.command('myext')
def cli_extension():
    ...
```

Now, by simply installing both the `core_module` and the `extension`
third-party, the `core_module` will be extended with the `myext` command:

```shell
$> core --help
Usage: core [OPTIONS] COMMAND [ARGS]...

Options:
  --help                          Show this message and exit.

Commands:
  myext
```

### Caveats

#### Silent "failure" to load extensions

If the base CLI has its extensible group declared in the `__init__.py` file,
the internal `click` initialization mechanism might use different instances of
the group when loaded by extensions, and when invoked through the CLI.

To avoid this, please refer to the tests's `tests/python_packages/test_core`
python module, which is built in a way that avoid this caveat:
 - extensible group should not be in the `__init__.py` file
 - `pyproject.toml` may refer directly to it for script entrypoints
bwyd 0.2.2
The seed crazy idea here is to consider how human cooks behave like robots, following recipes as instructions.
Requires Python: <4.0.0,>=3.11
Keywords: cooking, dsl, knowledge graph, nlp, publishing, recipes, validation

# Bwyd cooking DSL

Have you ever considered, "How does language generate food?"

While not quite that, language does convey passion, desire, learnings
-- all of which translate into preparing food to be shared lovingly.


## Abstract

Goal: _Implement a DSL (domain specific language) to simplify means
for defining reliable recipes rapidly, while leveraging computational
tools to catch errors and inconsistencies, scale portions, calculate
yields, and so on._

The "seed crazy idea" behind the scenes here is to consider how cooks
behave somewhat like robots, following recipes as step-by-step
instructions.
Recipes make cooks "programmable" to some extent.

Conversely, what if detailed cooking instructions could be expressed
in a way that was computable and represented independently of specific
human languages?
In other words, representing the processes of cooking as source code
plus semi-structured data?

To this point also consider: where do the stories which inspire and
the associated human domain expertise get attached into the process of
defining robust recipes?


## Motivations

Clearly the bulk of free recipes online (circa 2025) are intended and
structured as click-bait, and a growing protion of that content simply
does not work in a kitchen.
Now the popular services of 
["Today's AI"](https://pangaro.com/designconversation/2021/08/newmacy-in-2021-pandemics-ai/)
-- which are intended to provide _abstractive summarization_ --
are beginning to show indications of republishing that degraded content.
A positive feedback loop follows, and it won't be pretty.

Consequently this project is an application of contemporary software
engineering -- particularly drawn from _functional programming_ --
into the process of how people in professional kitchens think about
their work.
Think of this project as a domain specific language for authoring and
navigating cookbooks, customized for use with language models, causal
graphs, neurosymbolic reasoning, and other building blocks for AI
applications.

Code in **Bwyd** language represents the "structure" and "art" of cooking,
which can then be parameterized and rendered as text to generate recipes
for a broader audience of home cooks.

A secondary use for **Bwyd** as a DSL is to provide an intermediate
form for leveraging _generative_ approaches to manipulate recipes
while ensuring the quality required by use in professional kitchens.


## Documentation

  * how to install: [INSTALL.md](https://github.com/DerwenAI/bwyd/blob/main/docs/INSTALL.md)
  * project notes: [NOTES.md](https://github.com/DerwenAI/bwyd/blob/main/NOTES.md)
mcio-ctrl 1.5.2
Python interface to connect to the MCio Minecraft mod
Requires Python: >=3.12

# mcio_ctrl

### [MCio mod](https://github.com/twoturtles/MCio) | [mcio_ctrl](https://github.com/twoturtles/mcio_ctrl) | [Documentation](https://github.com/twoturtles/mcio_ctrl/wiki) | [Discord](https://discord.gg/PBfdc27h4q)

Python library for [MCio](https://github.com/twoturtles/MCio), a Minecraft Fabric mod for AI agent development. Includes [Gymnasium](https://gymnasium.farama.org/) environments for reinforcement learning.

## Features

* Install and launch Minecraft with the MCio mod, create worlds, and run the game from Python
* Faster than real-time performance (>13x on an M3 laptop)
* Gymnasium environments with MineRL 1.0 compatible actions/observations
* Interactive GUI for human control via standard Minecraft controls (human-in-the-loop planned)
* Fully type-hinted
* [VPT and STEVE-1 support](https://github.com/jxiong21029/mcio-vpt-example) on modern Minecraft with [Sodium](https://modrinth.com/mod/sodium)

## Links

* [Documentation / Wiki](https://github.com/twoturtles/mcio_ctrl/wiki)
* [MCio mod](https://github.com/twoturtles/MCio) ([Modrinth](https://modrinth.com/mod/mcio))
* [PyPI](https://pypi.org/project/mcio_ctrl/)
ldpserver 0.0.1
A basic LDP-server implementation based on FastAPI
Requires Python: >=3.12

# LDP-server

A basic LDP-server implementation based on [FastAPI].

This implementation follows the [Linked Data Platform 1.0] recommendation:

>Linked Data Platform (LDP) defines a set of rules for HTTP operations on web resources, some based on RDF, to provide an architecture for read-write Linked Data on the web. 


[FastAPI]: https://github.com/fastapi/fastapi
[Linked Data Platform 1.0]: https://www.w3.org/TR/2015/REC-ldp-20150226/