semvec/pypi-packages huggingface dataset:
cronevents 0.0.40a13
A package to run cron jobs(events)
Requires Python: >=3.10
Keywords: cron jobs

# Cron Events

This module provides a way to schedule recurring events using a cron-like syntax.
Events can be scheduled to run at specific intervals or at specific times on specific days.


## Table of Contents
<!--
- [Features](#features)
-->
- [Installation](#installation) <!-- - [Quick Start](#quick-start) -->
- [Learn by Example](#example) 
- [License](#license)

## Installation

`pip install cronevents`


[//]: # (## Quick Start)

[//]: # (1. Get example template: `bue example` &#40;warning: this command will over-write `.env`&#41;)

[//]: # (2. Start Bucket server, Hub and 3 workers: `bue demo`)

[//]: # (3. Upload script and wait for results: `python3 example.py`)


## Learn by Example

```python
"""Cron-like event scheduling module.

This module provides a way to schedule recurring events using a cron-like syntax.
Events can be scheduled to run at specific intervals or at specific times on specific days.

Syntax:
    'every (`Weekday` or `n unit`) [@ hh[:mm[:ss]] ["am" or "pm"]]'

Examples:
    'every 2 days @ 10:00:00 pm'
    'every Monday @ 23'
    'every 5 seconds'

Note:
    Using '@' will run the event at least once a day.
"""

# Uncomment to register events to the event manager
# import os
# os.environ['REGISTER_CRON_EVENT'] = 'true'

from cronevents.event_manager import event


@event('every 31 seconds')
def test():
    """Write 'test' to a file and print it every 31 seconds."""
    with open('test.txt', 'a') as f:
        f.write('test\n')
    print('test')


@event('every 2 days 1 hours 23 minutes 2 seconds')
def test2():
    """Write 'test2' to a file and print 'test2' every 2 days, 1 hour, 23 minutes, and 2 seconds."""
    with open('test.txt', 'a') as f:
        f.write('test2\n')
    print('test2')


@event('every 1 days @ 2:00 pm')
def test3():
    """Write 'test3' to a file and print it daily at 2:00 PM."""
    with open('test.txt', 'a') as f:
        f.write('test3\n')
    print('test3')


@event('every Friday')
def test4():
    """Write 'test4' to a file and print it every Friday."""
    with open('test.txt', 'a') as f:
        f.write('test4\n')
    print('test4')


@event('every Tuesday @ 3:00')
def test5():
    """Write 'test5' to a file and print it every Tuesday at 3:00 AM."""
    with open('test.txt', 'a') as f:
        f.write('test5\n')
    print('test5')
```

## License
* MIT License
agi-steps 0.1.9
Framework para gerenciamento e execução de etapas (steps) configuráveis em Python. Permite organizar scripts em grupos, ativar/desativar etapas e customizar configurações via dicionários.
Requires Python: >=3.11

# agi-steps

Framework para gerenciamento e execução de etapas (steps) configuráveis em Python.

## Descrição

O `agi-steps` permite organizar scripts em grupos, ativar/desativar etapas e customizar configurações via dicionários. Ideal para pipelines, automações e fluxos de trabalho flexíveis.

## Instalação

```bash
pip install agi-steps
```

## Uso Básico

### Como módulo (CLI)

```bash
python -m agi_steps
```

### Como biblioteca

```python
from agi_steps.steps import create_steps
steps_dict = {
    # Defina suas etapas aqui
}
grupos = create_steps(steps_dict)
```

## Principais Funções

- `create_steps(steps: dict) -> dict[list]`: Cria grupos de etapas a partir de um dicionário de configuração.
- `sorts_steps(steps: list[str]) -> list[str]`: Ordena etapas.
- `get_step_settings(steps: dict, step_setting: str) -> str`: Recupera configurações de uma etapa.
- `get_active_steps(steps: dict) -> list[str]`: Lista etapas ativas.
- `get_group_config(steps: dict, group_name: str) -> dict`: Retorna configurações de um grupo.
- `get_available_steps_groups(steps: dict) -> dict[list]`: Lista grupos disponíveis de etapas.
- `create_json_file(group: str, steps: list[dict], parallelism: bool = False) -> None`: Gera arquivos JSON das etapas.

## Requisitos

- Python >= 3.11
- tomli >= 2.2.1

## Licença

MIT
autopep723 0.2.0
Auto-generate PEP 723 metadata for Python scripts by analyzing imports
Requires Python: >=3.9

# autopep723

[![PyPI](https://img.shields.io/pypi/v/autopep723.svg)](https://pypi.org/project/autopep723/)
[![Read the Docs](https://img.shields.io/readthedocs/autopep723)](https://autopep723.readthedocs.io/en/latest/)
[![Changelog](https://img.shields.io/github/v/release/mgaitan/autopep723?include_prereleases&label=changelog)](https://github.com/mgaitan/autopep723/releases)
[![CI](https://github.com/mgaitan/autopep723/actions/workflows/ci.yml/badge.svg)](https://github.com/mgaitan/autopep723/actions/workflows/ci.yml)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v0.json)](https://github.com/mgaitan/autopep723/actions/workflows/ci.yml)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/mgaitan/autopep723/blob/main/LICENSE)


`autopep723` is a tiny wrapper on top of `uv run` that automatically manages third-party dependencies of Python scripts. Forget about manually managing dependencies for simple experiments!

## Quick Start

Run your script using third-party dependencies via `uvx autopep723`:

```bash
# Run directly without installing
uvx autopep723 script.py

# Or remote scripts directly from URLs
uvx autopep723 https://gist.githubusercontent.com/user/repo/script.py
```

To install the tool permanently:

```bash
uv tool install autopep723
autopep723 script.py
```

## Shebang Integration

You can use `autopep723` directly as a shebang:

```python
#!/usr/bin/env -S uvx autopep723
import requests
import numpy as np

# Your script here...
```


## Features

- ⚡ **Zero dependencies** - uses only Python standard library
- 🪶 **Minimal footprint** - perfect as `uv run` wrapper
- 🔍 **Automatic dependency detection** via AST analysis
- ✅ **PEP 723 compliant** metadata generation
- 🌐 **Remote script support** - run scripts directly from URLs

For detailed usage see the [documentation](https://autopep723.readthedocs.io/).

## License

MIT - see [LICENSE](LICENSE) file for details.
miniflux-summary-agent 0.1.0
Summarize Miniflux articles with Ollama
Requires Python: >=3.10
Keywords: rss, miniflux, ollama, summarization, ai, news

# Miniflux Summary Agent

A command-line RSS article summarization tool that fetches articles from your [Miniflux](https://miniflux.app/) RSS reader and generates concise AI-powered summaries organized by category.

## Installation

### Using pipx (recommended)
```bash
pipx install miniflux-summary-agent
```

### Using uvx
```bash
uvx miniflux-summary-agent
```

### Using pip
```bash
pip install miniflux-summary-agent
```

## Quick Start

1. **Prerequisites**: Ensure you have [Miniflux](https://miniflux.app/) running and [Ollama](https://ollama.com/) installed locally
2. **Setup**: Configure environment variables (see Configuration section)
3. **Run**: 
   - `miniflux-summary` (if installed globally)
   - `python -m miniflux-summary-agent` (alternative)

### Development Setup

For development setup and contribution guidelines, see the [Development Guide](https://github.com/trly/miniflux-summary-agent/blob/main/DEVELOPMENT.md)

## How It Works

The agent follows a simple workflow:

1. **Fetch**: Retrieves articles from your Miniflux RSS reader using the API
2. **Enhance**: Detects brief summaries and fetches full article content when possible, or if needed
3. **Summarize**: Processes each article through Ollama to generate 2-4 sentence summaries
5. **Organize**: Groups summaries by category and generates an HTML report

## Configuration

Configure via environment variables:

- `MINIFLUX_URL`: Your Miniflux instance URL
- `MINIFLUX_API_KEY`: API key from Miniflux settings
- `ARTICLE_HOURS_BACK`: Hours of articles to fetch (default: 6)
- `LOG_LEVEL`: Logging level (default: INFO)

## Requirements

- Python ≥3.10
- [Miniflux](https://miniflux.app/) RSS reader instance
- [Ollama](https://ollama.com/) with [llama3.1:8b](https://ollama.com/library/llama3.1:8b) model

## License

This project is open source. Please check the repository for license details.
coldfront 1.1.7
HPC Resource Allocation System
Requires Python: >=3.9
Keywords: high-performance-computing, resource-allocation

![ColdFront](docs/pages/images/logo-lg.png)

# ColdFront - Resource Allocation System

[![Documentation Status](https://readthedocs.org/projects/coldfront/badge/?version=latest)](https://coldfront.readthedocs.io/en/latest/?badge=latest)

ColdFront is an open source resource and allocation management system designed to provide a
central portal for administration, reporting, and measuring scientific impact
of cyberinfrastructure resources. ColdFront was created to help high performance computing (HPC) centers manage access to a diverse set of resources across large groups of users and provide a rich set of
extensible meta data for comprehensive reporting. The flexiblity of ColdFront allows centers to manage and automate their policies and procedures within the framework provided or extend the functionality with [plugins](docs/pages/index.md#extensibility).  ColdFront is written in Python and released under the GPLv3 license.

## Features

- Allocation based system for managing access to resources
- Self-service portal for users to request access to resources for their research group
- Collection of Project, Grant, and Publication data from users
- Center director approval system and annual project review process
- Email notifications for expiring/renewing access to resources
- Ability to define custom attributes on resources and allocations 
- Integration with 3rd party systems for automation, access control, and other system provisioning tasks

[Read more](docs/pages/index.md)  

## Community Supported Plugins

- [OpenStack Plugin](https://github.com/nerc-project/coldfront-plugin-openstack)
- [Keycloak User Search](https://github.com/nerc-project/coldfront-plugin-keycloak)
- [Starfish Plugin](https://github.com/fasrc/sftocf)

_Submit a PR to add your plugin to the list above._

## Documentation

For more information on installing and using ColdFront see our [documentation here](https://coldfront.readthedocs.io)

## Contact Information
If you would like a live demo followed by QA, please contact us at
ccr-coldfront-admin-list@listserv.buffalo.edu. You can also contact us for
general inquiries and installation troubleshooting.

If you would like to join our mailing list to receive news and updates, please
send an email to listserv@listserv.buffalo.edu with no subject, and the
following command in the body of the message:

subscribe ccr-open-coldfront-list@listserv.buffalo.edu first_name last_name


## License

ColdFront is released under the AGPLv3 license. See REUSE.toml.