semvec/pypi-packages huggingface dataset:
sutra-ai 0.1.3
CLI-first executor for small sequential Ollama agent pipelines.
Requires Python: >=3.10
Keywords: pipeline, cli, ollama

**Sutra**

Sutra is a small framework for running sequential LLM pipelines locally.
This project is not affiliated with, endorsed by, or associated with any company or product named Sutra or Sutra AI.

## Install
```bash
pip install sutra-ai
```

## Quick start
1. Create a demo project (menu lets you pick Hello World, support triage, or the interactive wizard):
   ```bash
   sutra create demo "Support ticket helper" --yes
   ```
2. Run the generated pipeline with a short question:
   ```bash
   sutra run projects/demo/pipeline.py --text "My internet is down"
   ```
3. Verify everything still works by running the doctor self-test:
   ```bash
   sutra doctor --selftest
   ```

You can also open the demo pipeline directly with Python:
```bash
python projects/demo/pipeline.py --text "My internet is down"
```

After `sutra create` you will see guidance such as "What happens next?" and reminders like `ollama pull <model>` if the model is missing.

For formal docs and release notes, visit the GitHub repo or PyPI page:
```bash
echo https://github.com/SutraLabs/sutra
echo https://pypi.org/project/sutra-ai/
```

## Example output
The demo pipeline writes an `answer` entry:
```json
{
  "answer": [{"answer": "Thanks for the question."}]
}
```

## Concepts
- **Agent**: one actor (model + prompt) that enforces `expects_json` and `required_keys`.
- **Step**: runs an agent and feeds its outputs to the next step.
- **Pipeline**: a list of steps wired together; it always exposes `build()` and `DEFAULT_INPUT`.

## Commands (kid-friendly)
- `sutra create <name> <description>`: menu lets you pick Hello World, support triage, or the input wizard.
- `sutra run <pipeline.py> --text "Hey!"` (or `sutra run <pipeline.py> "Hey!"`): feeds text to the first agent.
- `sutra --version`: prints the installed `sutra-ai` version.
- `sutra doctor [--selftest]`: checks Ollama connectivity; `--selftest` also tries to import and run a generated pipeline.
- `sutra help`: shows the CLI usage and the names of supported commands.

## Requirements
- Python >=3.10
- Ollama server at http://localhost:11434
- Model requirement: `ollama pull llama3.1:latest`

## What Sutra is / is not
- Is: a CLI-driven pipeline runner that enforces JSON contracts.
- Is: a local workflow for orchestrating Ollama-powered agents.
- Is not: an autonomous planner with self-directed agents.
- Is not: a hosted API service.

## Links
- GitHub: https://github.com/SutraLabs/sutra
- Issues: https://github.com/rajat4493/SutraFramework/issues
- Changelog: https://github.com/rajat4493/SutraFramework/blob/main/CHANGELOG.md
- PyPI: https://pypi.org/project/sutra-ai/0.1.0/
channels-extensions 0.0.1a1
Some extensions for Django Channels.
Requires Python: >=3.11
Keywords: django

# channels-extensions

[![PyPI - Version](https://img.shields.io/pypi/v/channels-extensions.svg)](https://pypi.org/project/channels-extensions)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/channels-extensions.svg)](https://pypi.org/project/channels-extensions)

-----

## Installation

```console
pip install channels-extensions
```

## Usage

### DummyChannelLayer
```DummyChannelLayer``` is an noop (almost) implementation of `BaseChannelLayer`. Messages sent to it are never available, and `receive` never returns.

All methods work as checkpoints to the event loop, yielding control back to it at least once.

```python
CHANNEL_LAYERS = {
    "dummy": {
        "BACKEND": "channels_extensions.layers.DummyChannelLayer",
    }
}
```

### get_channel_layer
This is simply a version of channels `get_channel_layer`, but it raises an `ImproperlyConfigured` if the alias does not exist.

### CurrentSiteMiddleware
A middleware that mimics django's `CurrentSiteMiddleware`. It adds a `site` key to the scope:
```python
class EchoSiteConsumer(AsyncConsumer):
    async def websocket_connect(self, event):
        await self.send({
            "type": "websocket.accept",
        })

    async def websocket_receive(self, event):
        await self.send({
            "type": "websocket.send",
            "text": self.scope["site"],
        })

application = ProtocolTypeRouter({
    "websocket": AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            CurrentSiteMiddleware(
                URLRouter([
                    path("echo/", EchoSiteConsumer.as_asgi()),
                ])
            )
        )
    ),
})
```

## License

`channels-extensions` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
fontforge-stubs 2026.1.2
Type stubs for FontForge's Python modules
Requires Python: >=3.10
Keywords: fontforge, stubs, psMat

# fontforge-stubs

This package provides PEP 561 type stubs and docstrings for
[FontForge](https://github.com/fontforge/fontforge)'s Python modules:

- `fontforge`
- `psMat`

The stubs and docstrings were created by referencing the official FontForge
Python Module documentation and -- when necessary -- the FontForge Python
extension source code.

## Motivation

FontForge provides powerful Python C extension modules. By nature, they do not
contain typing information. Combined with inconsistent naming conventions and
at times ambiguous documentation, FontForge Python scripting is unnecessarily
arduous.

Perhaps you can relate to:

- Never remembering if it's `glyph.name`, `glyph.glyphName`, or `glyph.glyph_name`
- Reading the docs and still not knowing whether `width` is an `int` or a `float`
- Parsing and re-parsing the documentation to figure out the structure of a
  feature-script-lang tuple

With type stubs, editors can provide autocompletion, and type checkers can
identify errors previously only discovered when running your script with
FontForge. Built-in documentation removes the need to constantly switch between
your editor and external documentation -- further increasing productivity.

## Installation

Install the package in your development environment:

```
pip install fontforge-stubs
```

Your editor/type-checker should automatically pick up the stubs.

## Versioning and Compatibility

This project uses YYYY.MM.DD [calendar versioning](https://calver.org/).

It aims to be compatible with FontForge 20230101 and later. Legacy and
deprecated FontForge Python APIs are not officially supported.

Updates to the FontForge Python APIs since the latest offical release
(currently 20251009) are kept in the
[fontforge-next](https://github.com/chanicpanic/fontforge-stubs/tree/fontforge-next)
branch until the next upstream release. If you are using a newer build, you may
want to install from `fontforge-next`:

```
pip install git+https://github.com/chanicpanic/fontforge-stubs@fontforge-next
```

## Contributing

If you find any issues with the type stubs, please open an issue and/or pull request.

## License

This project is under the [MIT License](./LICENSE).

The stubs and docstrings in this project were closely derived from the
[FontForge source](https://github.com/fontforge/fontforge). In particular,
`fontforge.rst`, `psMat.rst`, and `python.c`. See [NOTICE](./NOTICE).