semvec/pypi-packages huggingface dataset:
caldav-event-pusher 0.1.1
Push (or update) events to a CalDAV calendar
Requires Python: >=3.12
Keywords: caldav, calendar

# 📅 CalDAV Event Pusher

This is a tool to automate bulk creation and updates of events on a CalDAV calendar server such as [Radicale](https://radicale.org).
You give it some JSON mapping an arbitrary unique ID to VEVENT keys and it'll update existing events on the server or create new events:

`myevents.json`:

```json
{
  "myevent-1234": {
    "SUMMARY": "My Event 1234",
    "DTSTART": "20260216T104500Z",
    "DTEND": "20260216T121500Z"
  },
  "myevent-2345": {
    "SUMMARY": "My Event 2345",
    "LOCATION": "here and there",
    "DTSTART": "20260217T163000Z",
    "DTEND": "20260217T183000Z"
  }
}
```

`credentials.sh`:

```bash
export CALDAV_USER=myuser
export CALDAV_PASSWORD=mypassword
export CALDAV_SERVER=https://caldav.myserver.de
```

```bash
> source credentials.sh # source credentials environment variables (to not have password in shell history)
> caldav-event-pusher --calendar uas --eventsfile myevents.json --dry-run # first check changes, then remove the --dry-run
...
╭─────────────────────── ✨ New event 'myevent-1234' ───────────────────────╮
│  ➕                       UID    →  b19c122d-eead-4de7-8f69-a3ac34450e14  │
│  ➕                   SUMMARY    →  My Event 1234                         │
│  ➕                   DTSTART    →  2026-02-16T10:45:00+00:00             │
│  ➕                     DTEND    →  2026-02-16T12:15:00+00:00             │
│  ➕  X-CALDAV-EVENT-PUSHER-ID    →  myevent-1234                          │
│  ➕             LAST-MODIFIED    →  2026-02-16T14:50:35.214112+00:00      │
│  ➕                   DTSTAMP    →  2026-02-16T14:50:35.214112+00:00      │
╰───────────────────────────────────────────────────────────────────────────╯
╭─────────────────────── ✨ New event 'myevent-2345' ───────────────────────╮
│  ➕                       UID    →  9f29985c-7db1-47b2-bd21-0664349eba4b  │
│  ➕                   SUMMARY    →  My Event 2345                         │
│  ➕                  LOCATION    →  here and there                        │
│  ➕                   DTSTART    →  2026-02-17T16:30:00+00:00             │
│  ➕                     DTEND    →  2026-02-17T18:30:00+00:00             │
│  ➕  X-CALDAV-EVENT-PUSHER-ID    →  myevent-2345                          │
│  ➕             LAST-MODIFIED    →  2026-02-16T14:50:35.224139+00:00      │
│  ➕                   DTSTAMP    →  2026-02-16T14:50:35.224139+00:00      │
╰───────────────────────────────────────────────────────────────────────────╯
...
# If you uploaded, then change myevents.json, and rerun:
> caldav-event-pusher --calendar uas --eventsfile myevents.json --dry-run # first check changes, then remove the --dry-run
╭────────────── 📝 Changes to 'myevent-2345' ───────────────╮
│  📝  LOCATION  here and there  →  that location           │
│  📝   SUMMARY  My Event 2345   →  My specific Event 2345  │
╰───────────────────────────────────────────────────────────╯
```
trop 0.1.6
Triply Robust Panel (TROP) estimator: weighted TWFE with optional low-rank adjustment.
Requires Python: >=3.9
Keywords: causal-inference, panel-data, factor-models, difference-in-differences, synthetic-control, synthetic-controls, trop, twfe

# TROP: Triply Robust Panel Estimator

`trop` is a Python package implementing the **Triply Robust Panel (TROP)** estimator for average treatment effects (ATEs) in panel data. The core estimator is expressed as a weighted two-way fixed effects (TWFE) objective, with an optional low-rank regression adjustment via a nuclear-norm penalty.


Reference:

> Susan Athey, Guido Imbens, Zhaonan Qu, Davide Viviano (2025).  
> *Triply Robust Panel Estimators*.  
> arXiv:2508.21536.

---

## Links

- **Documentation**: https://ostasovskyi.github.io/TROP-Estimator/
- **Source code**: https://github.com/ostasovskyi/TROP-Estimator

---

## Installation

```
pip install trop
```
taxpr 0.0.2
Jaxpr expression introspection and injection via tags
Requires Python: >=3.13

# Taxpr
[![Run tests](https://github.com/otoomey/taxpr/actions/workflows/run_tests.yml/badge.svg)](https://github.com/otoomey/taxpr/actions/workflows/run_tests.yml)
[![PyPI Version](https://img.shields.io/pypi/v/taxpr.svg)](https://pypi.python.org/pypi/taxpr)

Taxpr is a collection of utilities for performing manipulation of Jaxprs. This is achieved by `tag`-ing specific arrays at trace time, then extracting and manipulating those tags in the final Jaxpr.

> ⚠️ This package is still very experimental, so expect broken code and breaking changes.

The provided routines are designed to work seamlessly with `jit`, `vmap`, `custom_jvp` and cousins.

## Example
The following example shows how you can use taxpr to emulate functions with side effects without violating Jax's pure function rules.
```python
import itertools as it

import jax
import jax.numpy as jnp
from jax._src.core import eval_jaxpr
import taxpr as tx

_state_counter = it.count()

def get_state(shape, dtype):
    count = next(_state_counter)

    def set_state(value):
        return tx.tag(value, op="set", id=count)

    value = jax.numpy.zeros(shape, dtype=dtype)
    return tx.tag(value, op="get", id=count), set_state


def uncurry(fn, *args, **kwargs):
    jaxpr = jax.make_jaxpr(fn)(args, kwargs)
    states = {}

    # iterate through all tags in the jaxpr
    # this recurses all child Jaxprs too

    for params, shape in tx.iter_tags(jaxpr.jaxpr):
        if params["op"] == "get":
            states[params["id"]] = shape

    initial_states = jax.tree.map(
        lambda x: jax.numpy.full_like(x, 0), states
    )

    def injector(states, token, params):
        if params["op"] == "get":
            state = states[params["id"]]
            return state, states
        elif params["op"] == "set": 
            states[params["id"]] = token
            return token, states
        raise ValueError(f"Unknown tag op: {params['op']}")

    # replace the token with a function that performs the state manipulation
    # here we can pass our own context (`initial_states`)

    jaxpr = tx.inject(jaxpr, injector, initial_states)

    def wrapper(states, *args, **kwargs):
        return eval_jaxpr(jaxpr.jaxpr, jaxpr.consts, states, args, kwargs)

    return wrapper, initial_states

################################################

# Usage

def running_sum(x):
    a, set_state = get_state(x.shape, x.dtype)
    sum = set_state(a + x)
    return sum

rsum, state = uncurry(running_sum, jnp.zeros(0))

_, state = rsum(state, jnp.ones(1))
_, state = rsum(state, jnp.ones(1))
_, state = rsum(state, jnp.ones(1))

assert jnp.allclose(next(iter(state.values())), 3)
```
openshift-python-utilities 6.0.16
A utilities repository for https://github.com/RedHatQE/openshift-python-wrapper
Requires Python: ~=3.9
Keywords: Openshift, ocp

# openshift-python-utilities

Pypi: [openshift-python-utilities](https://pypi.org/project/openshift-python-utilities/)  
A utilities repository for [openshift-restclient-python](https://github.com/openshift/openshift-restclient-python)

## Release new version

### requirements

- Export GitHub token

```bash
export GITHUB_TOKEN=<your_github_token>
```

- [release-it](https://github.com/release-it/release-it)

Run the following once (execute outside repository dir for example `~/`):

```bash
sudo npm install --global release-it
npm install --save-dev @release-it/bumper
```

### usage

- Create a release, run from the relevant branch.  
  To create a 4.11 release, run:

```bash
git checkout v4.11
git pull
release-it # Follow the instructions
```

## Installation

From source using [uv](https://github.com/astral-sh/uv).

```
git clone https://github.com/RedHatQE/openshift-python-utilities.git
cd openshift-python-utilities
uv sync
```

## Examples

### Install Operator

```python
from ocp_utilities.operators import install_operator
install_operator(
    admin_client=client,
    name=<operator name>,
    channel=<channel>,
    source=<source>,
)
```