semvec/pypi-packages huggingface dataset:
django-tasks-scheduler 4.0.8
An async job scheduler for django using redis/valkey brokers
Requires Python: >=3.10
Keywords: background-jobs, django, job-queue, redis, redis-queue, scheduled-jobs, task-queue, valkey

Django Tasks Scheduler
===================
[![Django CI](https://github.com/django-commons/django-tasks-scheduler/actions/workflows/test.yml/badge.svg)](https://github.com/django-commons/django-tasks-scheduler/actions/workflows/test.yml)
![badge](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/cunla/b756396efb895f0e34558c980f1ca0c7/raw/django-tasks-scheduler-4.json)
[![badge](https://img.shields.io/pypi/dm/django-tasks-scheduler)](https://pypi.org/project/django-tasks-scheduler/)

Documentation can be found in https://django-tasks-scheduler.readthedocs.io/

# Usage

1. Update `settings.py` to include scheduler configuration:

```python
import os
from typing import Dict
from scheduler.types import SchedulerConfiguration, Broker, QueueConfiguration

INSTALLED_APPS = [
    # ...    
    'scheduler',
    # ...
]
SCHEDULER_CONFIG = SchedulerConfiguration(
    EXECUTIONS_IN_PAGE=20,
    SCHEDULER_INTERVAL=10,
    BROKER=Broker.REDIS,
    CALLBACK_TIMEOUT=60,  # Callback timeout in seconds (success/failure/stopped)
    # Default values, can be overriden per task/job
    DEFAULT_SUCCESS_TTL=10 * 60,  # Time To Live (TTL) in seconds to keep successful job results
    DEFAULT_FAILURE_TTL=365 * 24 * 60 * 60,  # Time To Live (TTL) in seconds to keep job failure information
    DEFAULT_JOB_TTL=10 * 60,  # Time To Live (TTL) in seconds to keep job information
    DEFAULT_JOB_TIMEOUT=5 * 60,  # timeout (seconds) for a job
    # General configuration values
    DEFAULT_WORKER_TTL=10 * 60,  # Time To Live (TTL) in seconds to keep worker information after last heartbeat
    DEFAULT_MAINTENANCE_TASK_INTERVAL=10 * 60,  # The interval to run maintenance tasks in seconds. 10 minutes.
    DEFAULT_JOB_MONITORING_INTERVAL=30,  # The interval to monitor jobs in seconds.
    SCHEDULER_FALLBACK_PERIOD_SECS=120,  # Period (secs) to wait before requiring to reacquire locks
)
SCHEDULER_QUEUES: Dict[str, QueueConfiguration] = {
    'default': QueueConfiguration(URL='redis://localhost:6379/0'),
}
```

2. Update `urls.py` to include scheduler urls:

```python
from django.urls import path, include

urlpatterns = [
    # ...
    path('scheduler/', include('scheduler.urls')),
]
```

3. Run migrations:

```bash
python manage.py migrate
```

4. Check out the admin views:
   ![](./docs/media/admin-tasks-list.jpg)

# Sponsor

django-tasks-scheduler is developed for free.

You can support this project by becoming a sponsor using [this link](https://github.com/sponsors/cunla).

# Contributing

Interested in contributing, providing suggestions, or submitting bugs? See
guidelines [at this link](.github/CONTRIBUTING.md).
triggerkit 0.0.1
Modular kit for trigger-based actions
Requires Python: >=3.7
Keywords: nbdev jupyter notebook python

# TriggerKit


<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

## Overview

This system allows you to:

- Define Snowflake views to monitor
- Schedule when to check these views for new data
- Configure actions to trigger when data is available
- Extend with custom actions for your specific needs

### Installation

Install latest from the GitHub
[repository](https://github.com/Datatistics/triggerkit):

``` sh
$ pip install git+https://github.com/Datatistics/triggerkit.git
```

or from [pypi](https://pypi.org/project/triggerkit/)

``` sh
$ pip install triggerkit
```

## Usage

Run the system with your configuration file:

``` bash
# Using default config.toml in current directory
snowflake-actions

# Or specify a config file
snowflake-actions --config /path/to/your/config.toml

# To check your configuration file syntax
snowflake-actions --check-config

# To list available actions
snowflake-actions --list-actions

# For verbose logging
snowflake-actions --verbose
```

## Creating Custom Actions

You can extend the system with your own custom actions:

``` python
import triggerkit as tk

@tk.register("my_custom_action", "Description of what this action does")
def my_custom_action(data: List[Dict]):
    """
    Takes in records from Snowflake view and processes them how you want.
    
    Args:
        data: List of records from Snowflake
        
    Returns:
        Dictionary with action results
    """
    # Your custom logic here
    return {"processed": len(data)}
```

## Environment Variables

- `CONFIG_PATH`: Path to the TOML configuration file
- `SNOWFLAKE_PASSWORD`: Snowflake password (recommended over storing in
  config)
- `LOG_LEVEL`: Set the logging level (DEBUG, INFO, WARNING, ERROR)

## Built-in Actions

The system comes with several built-in actions:

- `send_alert`: Sends email and Slack notifications
- `log_incident`: Records incidents in a tracking system
- `generate_report`: Creates summary reports from data
snakemake-logger-plugin-rich 0.4.0
Log plugin for snakemake using Rich
Requires Python: <4.0,>=3.11

# Snakemake Logger Plugin: Rich

**Note:** This plugin is currently in development and may not be fully stable. Use at your own discretion and report any issues to the repository's issue tracker.

## Introduction

A logging plugin for Snakemake that utilizes [rich](https://github.com/Textualize/rich) for enhanced terminal styling and progress bars. 

## Usage

1. Install via pip:
   ```
   pip install snakemake-logger-plugin-rich
   ```

2. Run Snakemake with the `--logger rich` option:
   ```
   snakemake --logger rich
   ```

## Development

This project uses [pixi](https://github.com/prefix-dev/pixi) for environment management.

### Setting up the development environment

1. Fork the repository

2. Clone the repository:
   ```
   git clone https://github.com/<your-username>/snakemake-logger-plugin-rich.git
   cd snakemake-logger-plugin-rich
   ```

3. Install dependencies using pixi:
   ```
   pixi install
   ```

4. Activate the development environment:
   ```
   pixi shell -e dev
   ```

### Available development tasks

Run these commands with `pixi run`:

- **Demo**: `pixi run demo [snakefile]` - Runs a complete demo workflow and cleans up afterward. Uses `demo/Snakefile` by default, or specify a custom Snakefile path
- **Run Demo**: `pixi run run-demo [snakefile]` - Runs a demonstration Snakemake workflow using the plugin. Uses `demo/Snakefile` by default, or specify a custom Snakefile path
- **Dry Run**: `pixi run dryrun [snakefile]` - Performs a dry run of the demo workflow. Uses `demo/Snakefile` by default, or specify a custom Snakefile path
- **Clean Demo**: `pixi run clean-demo` - Cleans up demo output files
- **Quality Control**: `pixi run qc` - Runs formatting, linting, and type checking
- **Format**: `pixi run format` - Format code with ruff
- **Lint**: `pixi run lint` - Lint code with ruff
- **Lint Fix**: `pixi run lint-fix` - Lint and auto-fix code with ruff
- **Type Check**: `pixi run type-check` - Type check with mypy

### Testing the plugin

To test the plugin with the demo workflow:

```
pixi run demo
```

Or to run just the demo workflow without cleanup:

```
pixi run run-demo
```

To test with a custom Snakefile:

```
pixi run demo path/to/your/Snakefile
```
gluesql 0.18.0
GlueSQL is quite sticky. It attaches to anywhere.
Requires Python: >=3.10

# GlueSQL.py

GlueSQL.py is a Python binding for the [GlueSQL](https://github.com/gluesql/gluesql) database engine. It provides an embedded SQL database that works with a selection of storage backends.

Supported storages:

- `MemoryStorage`
- `JsonStorage`
- `SharedMemoryStorage`
- `SledStorage`

Learn more at **<https://gluesql.org/docs>**.

## Installation

Install from PyPI:

```bash
pip install gluesql
```

## Usage

```python
from gluesql import Glue, MemoryStorage

storage = MemoryStorage()

engine = Glue(storage)

engine.query(
    """
    CREATE TABLE User (id INTEGER, name TEXT);
    INSERT INTO User VALUES (1, 'Hello'), (2, 'World');
    """
)

result = engine.query("SELECT * FROM User;")
print(result)
```

## License

This project is licensed under the Apache License, Version 2.0 - see the [LICENSE](https://raw.githubusercontent.com/gluesql/gluesql/main/LICENSE) file for details.
tts-webui-extension.index-tts 0.0.2
A template extension for TTS Generation WebUI

# Index tts

A template extension for [TTS WebUI](https://github.com/rsxdalv/tts-webui).

## Description

This is a template extension. Replace this content with your extension's description.

## Installation

```bash
pip install git+https://github.com/rsxdalv/tts_webui_extension.index_tts@main
```

## Usage

1. Install the extension
2. Restart TTS Generation WebUI
3. Navigate to the Index tts tab

## Development

To run the extension standalone:

```bash
cd tts_webui_extension/index_tts
python main.py
```

## License

MIT License
mechanical-model 0.0.1
A package to deal with mechanical models and their linear response in oscillations, creep, microrheology, etc.
Requires Python: >=3.9

# Mechanical models

A package to deal with mechanical models and their linear
response in oscillations, creep, microrheology, etc.

##Installation

- Clone from github
- `pip install -e .`

## Drawing diagrams in plain text

```python
from mechanical_model.diagram import Spring, Dashpot, Springpot
print(Spring() + Dashpot('ηs') * (Springpot('V', 'α') + Springpot('W', 'β')))
```

```

                                 ___                
                        __________| |___________    
                       |         _|_| ηs        |   
                       |                        |   
                       |                        |   
____╱╲  ╱╲  ╱╲  _______|____╱╲__________╱╲______|___
      ╲╱  ╲╱  ╲╱ G          ╲╱ V, α     ╲╱ W, β     
```

## Mechanical response in oscillations

```python
import numpy as np
from mechanical_model.linear_mech import Maxwell
from matplotlib import pyplot as plt

omega = np.logspace(-2,2)
fig, axs = plt.subplots(2,1, sharex=True, layout='constrained')
for m in [Maxwell(G=10, eta=1), Maxwell(G=1, tau=0.3)]:
    line, = axs[0].plot(omega, m.tandelta(omega), label=m)
    axs[1].plot(omega, m.Gp(omega), color=line.get_color())
    axs[1].plot(omega, m.Gpp(omega), ls='--', color=line.get_color())

axs[0].set_ylabel(r'$\tan\delta$')
axs[1].set_ylabel(r'$G^\prime,G^{\prime\prime}$')
axs[1].set_xlabel(r'$\omega$')
for ax in axs:
    ax.set_xscale('log')
    ax.set_yscale('log')

axs[0].legend()
```
manim-web 0.1.8.post0
Animation engine for explanatory math videos, for the web.
Requires Python: >=3.9

# Manim Web: The ManimCE fork to create interactive math animations in the web
Do you want to turn your ManimCE code into an interactive web animation? This is your library!

## Main changes
* **MathJax LaTeX rendering:** As we're using a web browser, we can't use system's LaTeX. Instead, we use a really faster implementation called MathJax, that delivers math equations for the web. Notice that there's no `Tex`, so you can do `MathTex(f"\\text{{{tex_code}}}")` to render LaTeX text instead of `Tex(tex_code)`.
* **Text rendering without Pango (under development):** As Pango needs a system, we can't render text with Pango, but we'll use JavaScript libraries to handle that stuff (you don't need any JS, just internal working). This is still under development, so if you try to call `Text("Hello, world!")`, this will raise an error, because `Text` isn't still ready!
* **Interactive animations and integration with JavaScript:** You can now create interactive animations that can be controlled by the user. This is done by using JavaScript to handle events and Manim Web to create the animations.

## Installation
Wait, this is not a system library, so you don't need to install it! In fact, you must start with an HTML file that includes [Pyodide](https://pyodide.org/en/stable/) and loads Manim Web with `micropip.install("manim-web")`. An example is at the demo section below.

## Demo
You have an example at [https://mathityt.github.io/manim-web-demo/](https://mathityt.github.io/manim-web-demo/). The source code is at [https://github.com/MathItYT/manim-web-demo](https://github.com/MathItYT/manim-web-demo/blob/main/index.html).

## Usage
You can use Manim Web like you use ManimCE, but with some differences. Some objects and methods are not available, like `Text` mobject.

```python
from manim import *


class MyScene(Scene):
    def construct(self):
        # Create a square
        square = Square()
        # Add the square to the scene
        self.add(square)
        # Wait for 1 second
        self.wait(1)
        # Rotate the square
        self.play(square.animate.rotate(PI / 4))
        # Wait for 1 second
        self.wait(1)
```

## Limitations
* **No Pango text rendering:** As mentioned above, Pango is not available in the web, so text rendering is not available yet. But `Text` will be available soon!

## Acknowledgements
Thanks to the Manim Community developers and 3Blue1Brown for developing a great animation engine!
omegapy 3.2.1
Python tools for OMEGA/MEx observations analysis
Requires Python: >=3.7

[![version-json](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2FAStcherbinine%2Fomegapy%2Fmaster%2Fomegapy%2Fpackage.json&query=%24.version&label=version&labelColor=grey&color=blue)](https://pypi.org/project/omegapy)
![pythonversion](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2FAStcherbinine%2Fomegapy%2Fmaster%2Fomegapy%2Fpackage.json&query=%24.pythonVersionMin&suffix=%2B&logo=python&logoColor=white&label=python&labelColor=grey&color=blue)
[![DOI](https://zenodo.org/badge/349763849.svg)](https://zenodo.org/doi/10.5281/zenodo.7818828)
[![status](https://joss.theoj.org/papers/15cf348a29d186e12f49a110f9f787f8/status.svg)](https://joss.theoj.org/papers/15cf348a29d186e12f49a110f9f787f8)

<p align="center">
<img width="250" height="250" src="https://raw.githubusercontent.com/AStcherbinine/omegapy/master/docs/logo_omegapy_small2.png">
</p>

# OMEGA-Py : Python tools for OMEGA data

Importation and display of OMEGA/MEx observations in Python 3, based on the IDL *SOFT10* routines developped in the IAS planetary team.

## Installation & Update
### Method 1: from PyPI (recommended)
**Installation:** `pip3 install omegapy`

**Update:** `pip3 install omegapy --upgrade` 


### Method 2: from the GitHub repository (development version)
**Installation:** Clone the repository and install with pip:

~~~bash
git clone https://github.com/AStcherbinine/omegapy.git
cd omegapy
pip3 install .
~~~

**Update:** Go to the previously cloned repository, pull the last updates, and install them with pip:
~~~bash
cd omegapy
git pull
pip3 install .
~~~

## Documentation
Full documentation of the OMEGA-Py module is available at [astcherbinine.github.io/omegapy](https://astcherbinine.github.io/omegapy/)

Planetary Data Workshop 2023: [abstract](https://github.com/AStcherbinine/omegapy/blob/master/docs/Stcherbinine_PDW2023_7007_omegapy.pdf) & [slides](https://github.com/AStcherbinine/omegapy/blob/master/docs/PDW_Flagstaff_Stcherbinine_omegapy_upload.pdf)

## Community guidelines
To contribute to OMEGA-Py, report an issue or seek support, please refer to the community guidelines
page of the documentation available [here](https://astcherbinine.github.io/omegapy/community/).

## Citing OMEGA-Py
If you are using OMEGA-Py in your research, please cite it according to the guidelines available [here](https://astcherbinine.github.io/omegapy/credits/).

## Credits

© Aurélien Stcherbinine (2020–2025)

Institut d'Astrophysique Spatiale (IAS), Université Paris-Saclay, CNRS, Orsay, France

LATMOS/IPSL, UVSQ Université Paris-Saclay, Sorbonne Université, CNRS, Guyancourt, France

Department of Astronomy and Planetary Science, Northern Arizona University, Flagstaff, AZ, USA

Institut de Recherche en Astrophysique et Planétologie (IRAP), CNES, Université Toulouse III,
CNRS, Toulouse, France


## License
This package is released under a MIT open source license. See [`LICENSE`](https://github.com/AStcherbinine/omegapy/blob/master/LICENSE) for more details.