semvec/pypi-packages huggingface dataset:
sqil-core 2.0.0
The codebase of the SQIL group in EPFL
Requires Python: <4.0,>=3.12

# For users

## Installation

```bash
$ pip install sqil_core
```

## Usage

You can find all the functions available and examples in the documentation.

```python
import sqil_core as sqil

path = 'path to your data folder'

# Extract data
mag, phase, freq = sqil.extract_h5_data(path, ['mag_dB', 'phase', 'ro_freq'])
```

## Documentation
You can find the documentation for this package [here](https://sqil-epfl.github.io/sqil-core/)

# For developers

## Development

1. **Install poetry if you haven't already**

```bash
$ pip install poetry
$ pip install poetry-plugin-shell
```

2. **Install the required packages using poetry**

```bash
$ poetry install
```

3. **Install the pre-commit hooks**
   If you are on windows you need to install git ([https://git-scm.com/downloads](here)) and add it to your windows PATH.
   After the installation open a new terminal.

```bash
$ poetry run pre-commit install
```

This will check if your python files are formatted correctly when you try to commit.
If that's not the case the commit will be canceled and the files will be automatically formatted.
Then you'll have to add and commit again the new files.

4. **Start the virtual environment**

```bash
$ poetry shell
```

To exit the virtual environment just use `exit`

#### Test your changes

```bash
$ pip install -e . --user
```

**Anaconda**
If you want to install in a specific anaconda environment

- from your poetry shell build the package

```bash
$ poetry run build
```

- open an anaconda shell
- activate the desired environemnt
- pip install the wheel file (.whl) in the dist folder of the sqil-core project

```bash
$ pip install PATH_TO_SQIL_CORE_FOLDER/dist/SQIL_CORE-VERSION.whl
```

If you're testing a new function remember to import it in the folder's `__init__.py` file.


If you're using a jupyter notebook remember to restart the kernel.


## Build

```bash
$ poetry run build
```

## Publish

To publish version X.X.X run the commands below. This will trigger a GitHub action that deploys to release to PyPi (pip) and GitHub.
Remember also to change the version number in the `pyproject.toml` file.

```bash
$ git tag vX.X.X
$ git push origin vX.X.X
```

## Docs

Serve docs

```bash
$ poetry run docs_serve
```

Build docs

```bash
$ poetry run docs_build
```
vercel-workers 0.0.10
Python SDK for Vercel Workers
Requires Python: >=3.12

# vercel-workers

## Installation

```bash
pip install vercel-workers
```

## Django 6.0 `django.tasks` integration (Vercel Queues)

This repo ships an optional `django.tasks` backend that enqueues tasks into **Vercel Queues** and
executes them via a **queue callback route** (similar in spirit to the Celery integration in this repo).

### Install

```bash
pip install "vercel-workers[django]"
```

### Configure Django

In `settings.py`:

```python
TASKS = {
    "default": {
        "BACKEND": "vercel.workers.django.backend.VercelQueuesBackend",
        # Optional: restrict which Django queue_name values are allowed.
        "QUEUES": ["default"],
        "OPTIONS": {
            # TaskResult storage (uses Django cache; for production prefer Redis).
            "cache_alias": "default",
            "result_ttl_seconds": 86400,

            # Callback execution settings (visibility/lease).
            "visibility_timeout_seconds": 30,
            "visibility_refresh_interval_seconds": 10.0,

            # Basic retry policy for task exceptions.
            "max_attempts": 3,
            "retry_backoff_base_seconds": 5,
            "retry_backoff_factor": 2.0,

            # Optional publish-time overrides passed through to vercel.workers.client.send()
            # (you can also set env vars like VERCEL_QUEUE_TOKEN / VERCEL_QUEUE_BASE_URL).
            # "token": "...",
            # "base_url": "...",
            # "base_path": "...",
            # "retention_seconds": 86400,
            # "deployment_id": "...",
            # "timeout": 10.0,
        },
    }
}
```

### Define and enqueue tasks

```python
from django.tasks import task


@task(queue_name="default")
def send_email(to: str) -> None:
    ...


result = send_email.enqueue(to="user@example.com")
```

### Expose the Vercel Queue callback route

You must expose a **WSGI/ASGI endpoint** that Vercel Queues can POST CloudEvents to:

- WSGI: `vercel.workers.django.get_wsgi_app(backend_alias="default")`
- ASGI: `vercel.workers.django.get_asgi_app(backend_alias="default")`

How you mount that depends on your deployment setup (Vercel Python entrypoint / framework).

### Notes / limitations

- **Queue naming**: Django `Task.queue_name` maps directly to the Vercel Queue name you publish to.
- **Priority**: not supported (Django Tasks will validate priority is default).
- **run_after**: supported by delaying the queue message (visibility timeout) when it is delivered early.
- **Results**: stored in Django cache. With `LocMemCache`, `get_result()` is process-local; for real
  cross-request results use Redis (or another shared cache backend).
rotools 0.1.161
Robert Olechowski python tools
Requires Python: >=3.13

# Description
    ..........................
    

# Todo:
 - update build config to pyproject.toml 
 - Add Merge command in DictObj

# Build on Windows in Pycharm
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass 
```

```
python setup.py sdist
rm .\dist\* 
python -m build
twine upload dist/*
```


# Notes
 - .\tools\build.ps1 
 - pip install --upgrade ROTools