semvec/pypi-packages huggingface dataset:
py-generator-build-backend 1.1.0
A Python build backend designed to wrap Python package generators into a PEP 517 compatible source tree
Requires Python: >=3.9

# `py-generator-build-backend`

A Python build backend designed to wrap Python package generators (such as
[`openapi-python-client`]) into a PEP 517 compatible source tree.

## Demo

Create a new directory with a `pyproject.toml`:

```toml
[project]
name = "tictactoe-client"
dynamic = [
    "version",
    "dependencies",
]

[build-system]
requires = [
    "py-generator-build-backend",
]
build-backend = "py_generator_build_backend"

[tools.py-generator-build-backend]
generator = "openapi-python-client generate --url https://raw.githubusercontent.com/OAI/learn.openapis.org/refs/heads/main/examples/v3.1/tictactoe.json --output-path $GENERATOR_OUT_PATH"
```

The `tools.py-generator-build-backend.generator` is the key to making this work:
this command must produce a valid PEP 517 source tree in the (not-yet-existent)
directory specified by the `$GENERATOR_OUT_PATH` environment variable. You can
interpolate other environment variables in `generator` if you need to.

Note: you are responsible for making sure the command you want to run is
available on the `PATH`.

Now try to build the package: `python -m build .`. This should fail to build,
with instructions about the build requirements you need to add to your
`build-system.requires`. Add them and confirm that you are now able to build
the package.

Congratulations, you've got a Python package! See [Packaging Python Projects]
for possible next steps.

## Notes

For performance reasons, the output of the generator is cached in
`platformdirs.user_cache_dir`. We compute the cache entry by hashing together
the contents of the entire project directory, along with all environment
variables. This does a pretty good job of capturing all the "inputs" that go
into generating the package, but it's not perfect: the generator could be
non-deterministic, or packages could be updated in the `PATH`. If you care
about things like this, consider adopting a hermetic build tool such as
[nix](https://nixos.org/).

(Ideally we'd have access to a scratch space that only lives as long as the
build frontend is invoking this build backend, but as far as I can tell,
there's no standardized mechanism for that.)

## Development

### Releasing

- Edit `version` in `pyproject.toml`, and commit.
- `uv build`
- `git tag v...`
- `uv publish`
- `git push --tags`

[`openapi-python-client`]: https://github.com/openapi-generators/openapi-python-client
[Packaging Python Projects]: https://packaging.python.org/en/latest/tutorials/packaging-projects/
async2sync 0.1.1
Async Runner - Run async tasks from sync methods
Requires Python: >=3.7
Keywords: async, asyncio, event loop, thread-safe, run async from sync, async wrapper, async inside sync


# Async Runner
**Async Runner** is a minimal Python utility designed to run asynchronous tasks from synchronous code — **without worrying about event loop conflicts or lifecycle issues**.

## Why Async Runner?
In many real-world projects, especially when integrating third-party libraries or legacy synchronous code, you may need to **invoke `async` functions inside a `sync` context**. However, common approaches come with challenges:

- `asyncio.run()` creates a new event loop, which fails if one already exists.
- Some libraries **require an existing event loop**, others **fail if one already exists**.
- Solutions like `greenlet` can be overly complex or unsuitable for certain use cases.

After struggling with these limitations across different projects, this package was built to offer a clean, lightweight, and **thread-safe** solution by:

✅ Delegating async tasks to a background thread <br>
✅ Maintaining a **single, long-running event loop** <br>
✅ Making async-in-sync calls as easy as a regular function call

## Installation
```bash
pip install async2sync
```

## ✅ Features
- Simple, one-line usage
- Thread-safe and reusable
- Works in environments with or without existing event loops
- Avoids `RuntimeError: Event loop is closed` or `This event loop is already running issues`

## How It Works
`async_runner` creates and manages an **event loop inside a dedicated background thread**. This allows your sync code to safely schedule and await asynchronous tasks, without interfering with the main thread’s context.

## Example Usage
```python
import asyncio
from async_runner import run_async

async def async_task():
    await asyncio.sleep(1)
    return "Async task completed"

def sync_task():
    result = run_async(async_task())
    print(result)

sync_task()
```

#### Output:
```
Async task completed
```

## Use Cases
- Calling async APIs from FastAPI views or Python Scripts
- Wrapping async logic inside a sync SDK
- Integrating with libraries that inconsistently depend on event loop presence
Bayesian-Inferences 0.0.1
GNU GENERAL PUBLIC LICENSE
Requires Python: >=3.9
Keywords: python, Bayesian inferences

Bayesian Estimation Environment (BEE) software is availble in both Python and R. It aims to unify the modeling experience by integrating an intuitive model-building syntax with the flexibility of low-level abstraction coding available but also pre-build function for high-level of abstraction and including hardware-accelerated computation for improved scalability.