semvec/pypi-packages huggingface dataset:
django-flowcontrol 0.0.5
Design and run workflows in Django
Requires Python: >=3.10

# django-flowcontrol

Django Flowcontrol is a Django app that allows creating and running flows of actions including branching and looping logic.

- Actions are defined in Python code and can have optional per-instance configuration. The app provides built-in actions for conditional logic, loops, and state management.
- Flows with their actions and triggers are defined in the Django admin.
- A running instance of a flow – a flow run – has persistent state and can have an optional model object associated with it.

## Run tests

```
pytest
```

## Build documentation

```pip install -e .[docs]
cd docs
mkdocs serve
```
addteam 0.9.0
One-command collaborator management for GitHub repos with GitOps support.
Requires Python: >=3.10
Keywords: github, collaborators, team, access, gitops, automation

# addteam

Invite GitHub collaborators from a simple YAML file.

## Install

```bash
pip install addteam
```

Or run without installing:

```bash
uvx addteam
```

**Prerequisite:** [GitHub CLI](https://cli.github.com/) must be installed and authenticated (`gh auth login`).

## First Run

```bash
# In your repo directory, create a team.yaml
addteam --init

# Edit team.yaml with your team members, then run:
addteam
```

That's it! Your collaborators will be invited.

---

## team.yaml Format

```yaml
default_permission: push

admins:
  - alice

developers:
  - bob
  - charlie

reviewers:
  - eve
```

Role names map to permissions automatically:

| Role | Permission |
|------|------------|
| `admins` | admin |
| `maintainers` | maintain |
| `developers`, `contributors` | push |
| `reviewers`, `readers` | pull |
| `triagers` | triage |

## Common Commands

```bash
addteam                    # invite from local team.yaml
addteam -n                 # dry-run (preview only)
addteam -a                 # audit (show drift)
addteam -s                 # sync (also removes unlisted users)
addteam owner/repo         # use team.yaml from another repo
```

## Central Team Config

Keep one `team.yaml` in a shared repo, apply it anywhere:

```bash
# Anyone on your team can run this in any repo:
uvx addteam myorg/team-config
```

The AI summary at the end is perfect for sharing via email or Slack.

## Options

| Flag | Description |
|------|-------------|
| `-n, --dry-run` | Preview without making changes |
| `-s, --sync` | Remove collaborators not in list |
| `-a, --audit` | Show drift without making changes |
| `-r, --repo` | Target a specific repo |
| `-q, --quiet` | Minimal output |
| `--no-welcome` | Skip creating welcome issues |
| `--no-ai` | Skip AI-generated summaries |

## GitOps Setup

Automatically sync collaborators when team.yaml changes:

```bash
addteam --init --init-action
```

This creates:
- `team.yaml` - your team config
- `.github/workflows/sync-collaborators.yml` - runs on push

Add a `TEAM_SYNC_TOKEN` secret (PAT with `repo` scope) to your repo.

## Advanced Features

### Expiring Access

```yaml
contractors:
  - username: temp-dev
    permission: push
    expires: 2025-06-01
```

### GitHub Teams (orgs)

```yaml
teams:
  - myorg/backend-team
  - myorg/frontend-team: pull
```

### Multi-Repo Management

```bash
addteam --init-multi-repo
```

Creates `repos.txt` to sync the same team across multiple repos.

### Welcome Issues

New collaborators automatically get a welcome issue with an AI-generated summary of your repo (requires `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `GOOGLE_API_KEY`).

## License

MIT
enc4ppm 0.1.9
Encode logs for predictive process monitoring
Requires Python: >=3.9

# Encoding For Predictive Process Monitoring (enc4ppm)

`enc4ppm` is a Python package than provides common process mining encodings.

[Documentation and reference](https://process-and-data-intelligence.github.io/enc4ppm/).

## Installation

Using pip:

```bash
pip install enc4ppm
```

## Example

The following example performs frequency encoding with latest payload for next activity prediction task:

```python
import pandas as pd

from enc4ppm.frequency_encoder import FrequencyEncoder
from enc4ppm.constants import LabelingType

# Load log
log = pd.read_csv('bpic2012.csv')

# Create encoder
encoder = FrequencyEncoder(
    labeling_type=LabelingType.NEXT_ACTIVITY,
    include_latest_payload=True,
    attributes=['AMOUNT_REQ'],
)

# Encode log
encoded_log = encoder.encode(log)
```

## Features

- Frequency, simple-index and complex-index encodings
- Next activity, remaining time and outcome labelings
- Save encoder to disk for later use
- Freeze encoder on training set, then use it on unseen data (automatic handling of unknown values)
- Standardize numerical features
- Convert categorical features to one-hot encoding, or keep them as strings
- Add time features (time since case start and time since last event) to the encoding

## Development

### Documentation

Documentation is provided by mkdocs. To build and push the documentation website to GitHub, run the following command: `mkdocs gh-deploy`.

## License

MIT License
ovito 3.15.0.dev219
A scientific data visualization and analysis software for particle-based simulations
Requires Python: >=3.10

OVITO (Open Visualization Tool) is a scientific visualization and analysis package for atomistic and
particle-based simulation data. Visit the official website for more information:

<https://www.ovito.org/>

This PyPI package provides the ``ovito`` module, which allows you to employ OVITO's
data I/O, analysis and rendering capabilities in standalone Python scripts
and integrate them into automated workflows.

The OVITO desktop application is available as a separate download
from [www.ovito.org](https://www.ovito.org/). It provides a graphical user interface
for interactive analysis and visualization of simulation data.

### Documentation

Documentation for the most recent version of the ``ovito`` module:

<https://docs.ovito.org/python/>

### Installation

To download and install the ``ovito`` module in your Python interpreter, run
```
python -m pip install -U ovito
```

The ``ovito`` module is available for the following target platforms:

| Operating system | CPU architecture      | Python versions       |
|------------------|-----------------------|-----------------------|
| Windows          | x86_64 (Intel)        | 3.10 - 3.14           |
| Linux            | x86_64 (Intel)        | 3.10 - 3.14           |
| macOS 12.0+      | arm64 (Apple silicon) | 3.10 - 3.14           |