semvec/pypi-packages huggingface dataset:
streamlit-arborist 0.3.0
Streamlit component for creating tree views
Requires Python: >=3.9

# streamlit-arborist

[![CI - Test, Build and Release](https://github.com/gabriel-msilva/streamlit-arborist/actions/workflows/test-build-release.yaml/badge.svg)](https://github.com/gabriel-msilva/streamlit-arborist/actions/workflows/test-build-release.yaml)
![PyPI - Version](https://img.shields.io/pypi/v/streamlit-arborist)
![PyPI - License](https://img.shields.io/pypi/l/streamlit-arborist)

_streamlit-arborist_ is a [Streamlit](https://streamlit.io) component based on
[react-arborist](https://github.com/brimdata/react-arborist) for visualizing
hierarchical data structures as interactive tree views.

- Demo application: [st-arborist-example.streamlit.app](https://st-arborist-example.streamlit.app/)
- Documentation: [streamlit-arborist.readthedocs.io](https://streamlit-arborist.readthedocs.io/)

## Installation

```sh
pip install streamlit-arborist
```

## Basic usage

A minimal `app.py` file with sample data:

```python
from streamlit_arborist import tree_view

data = [
   {
      "id": "1",
      "name": "Parent 1",
      "children": [
         {"id": "1.1", "name": "Child 1"},
         {"id": "1.2", "name": "Child 2"}
      ]
   },
   {
      "id": "2",
      "name": "Parent 2",
      "children": [
         {"id": "2.1", "name": "Child 3"},
         {"id": "2.2", "name": "Child 4"}
      ]
   }
]

tree_view(data)
```

Run Streamlit:

```sh
streamlit run app.py
```

## Development

This repository is based on
[streamlit/component-template](https://github.com/streamlit/component-template) template.
Find details about
[custom components](https://docs.streamlit.io/develop/concepts/custom-components)
in Streamlit documentation.

The development environment requires
[uv](https://docs.astral.sh/uv/getting-started/installation/)
and [Node.js + npm](https://nodejs.org/en/download/current) installed.

### Setup

Install the `dev` Python environment defined in [pyproject.toml](./pyproject.toml)
and `npm` packages in [streamlit_arborist/frontend](./streamlit_arborist/frontend/):

```sh
make setup
```

### Running

While developing the frontend, you must set the environment variable `STREAMLIT_ARBORIST_DEV=true`.
(this is done in `make` commands)

1. Run the [app/example.py](./app/example.py) app file with Streamlit:

   ```sh
   make backend
   ```

2. Start the component's frontend server:

   ```sh
   make frontend
   ```

Open the app running at <http://localhost:8501>.

### Build

Build the React frontend at `streamlit_arborist/frontend/build/` directory and the Python
package wheels at `dist/`.

```sh
make build
```

### Documentation

The documentation files are located in [docs/](./docs/) directory and written with
[Sphinx](https://www.sphinx-doc.org/en/).

```sh
make docs
```
gcal-sdk 0.1.0
A clean, typed Python SDK for the Google Calendar API v3
Requires Python: >=3.10
Keywords: api, calendar, google, sdk

# gcal-sdk

A clean, typed Python SDK for the Google Calendar API v3. Built on top of `google-api-python-client` with Pydantic v2 models.

## Installation

```bash
pip install gcal-sdk
```

## Authentication

The SDK loads OAuth credentials from default paths:

- `~/secrets/google-oauth/credentials.json` — OAuth client credentials
- `~/secrets/google-oauth/token.json` — refresh token + access token

These paths can be overridden when creating the client.

## Usage

```python
from datetime import datetime, timezone, timedelta
from gcal_sdk import GCalClient

client = GCalClient()

# List upcoming events
events = client.events.list("primary", time_min=datetime.now(timezone.utc))
for event in events:
    print(f"{event.summary} — {event.start}")

# Create an event
start = datetime.now(timezone.utc) + timedelta(hours=1)
end = start + timedelta(hours=1)
new_event = client.events.create(
    "primary",
    summary="Team meeting",
    start=start,
    end=end,
)
print(f"Created: {new_event.html_link}")

# Update an event
updated = client.events.patch(
    "primary",
    event_id=new_event.id,
    summary="Updated team meeting",
)

# Delete an event
client.events.delete("primary", event_id=new_event.id)

# List calendars
calendars = client.calendars.list()
for cal in calendars:
    print(f"{cal.summary} (primary={cal.primary})")

# Get primary calendar
primary = client.calendars.get("primary")

# Check free/busy
busy = client.freebusy.query(
    calendar_ids=["primary"],
    time_min=datetime.now(timezone.utc),
    time_max=datetime.now(timezone.utc) + timedelta(days=1),
)
```

## Development

```bash
# Install in dev mode
pip install -e ".[dev]"

# Run tests (requires valid OAuth tokens)
pytest
```

## License

MIT
ladybug-display-schema 1.0.0
Ladybug-display Data-Model Objects

[![Build Status](https://github.com/ladybug-tools/ladybug-display-schema/workflows/CI/badge.svg)](https://github.com/ladybug-tools/ladybug-display-schema/actions)

[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)

# ladybug-display-schema

Ladybug-display Data-Model Objects

## Installation

```console
pip install ladybug-display-schema
```

## QuickStart

```python
import ladybug_display_schema

```

## API Documentation

[Geometry Schema](https://ladybug-tools.github.io/ladybug-display-schema/geometry.html)

[Display Schema](https://ladybug-tools.github.io/ladybug-display-schema/display.html)

## Local Development

1. Clone this repo locally

```console
git clone git@github.com:ladybug-tools/ladybug-display-schema

# or

git clone https://github.com/ladybug-tools/ladybug-display-schema
```

2. Install dependencies:

```console
cd ladybug-display-schema
pip install -r dev-requirements.txt
pip install -r requirements.txt
```

3. Run Tests:

```console
python -m pytest tests/
```

4. Generate Documentation:

```python
python ./docs.py
```
romanisim 0.13.0
Nancy Grace Roman Space Telescope WFI Simulator
Requires Python: >=3.11

[![CI](https://github.com/spacetelescope/romanisim/actions/workflows/ci.yml/badge.svg)](https://github.com/spacetelescope/romanisim/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/spacetelescope/romanisim/branch/main/graph/badge.svg?token=pkoLtQOa2v)](https://codecov.io/gh/spacetelescope/romanisim)

# romanisim: an image simulator for Roman

romanisim is a Galsim-based simulator of imaging data from the Wide
Field Instrument (WFI) on the Nancy Grace Roman Space Telescope
(pronounced roman-eye-sim, stylized Roman I-Sim). It uses
[Galsim](https://galsim-developers.github.io/GalSim/_build/html/overview.html)
to render astronomical scenes,
[WebbPSF](https://galsim-developers.github.io/GalSim/_build/html/overview.html)
to model the point spread function, and
[CRDS](https://github.com/spacetelescope/crds) to access the
calibration information needed to produce realistic WFI images.

The simulator starts by producing an idealized scene with Galsim and a
PSF, and then proceeds to simulate the various noise sources and
instrumental systematics imprinted by the system. One major feature
is a fairly faithful implementation of up-the-ramp sampling and
ramp-fitting, so that romanisim can produce realistic L1 images ("raw" sets
of up the ramp samples like those that will be delivered from the telescope) and
L2 images (calibrated images of astronomical flux per pixel).

> **Warning**
> romanisim is under active developement. Its output has not been formally validated; only limited testing has been performed. For this reason, use of romanisim for preparation of ROSES proposals is not advised. Other packages like galsim's roman package or STIPS may better serve such purposes.

## Documentation

See the full romanisim [documentation](https://romanisim.readthedocs.org) at readthedocs.

## Installation

    pip install romanisim

should do most of what you want. Then

    romanisim-make-image out.asdf

will render a test image. See the
[documentation](https://romanisim.readthedocs.org) for more
information about simulating scenes you're actually interested in!

## Contributing

romanisim is intended to support the community in understanding and
analyzing imaging from Roman. If there are features you want to use or
see, file an
[issue](https://github.com/spacetelescope/romanisim/issues), or better
yet, make a pull request!
appletree 0.5.5
A high-Performance Program simuLatEs and fiTs REsponse of xEnon.
Requires Python: <3.13,>=3.8

# Appletree

A high-Performance Program simuLatEs and fiTs REsponse of xEnon.

[![DOI](https://zenodo.org/badge/534803881.svg)](https://zenodo.org/badge/latestdoi/534803881)
[![Test package](https://github.com/XENONnT/appletree/actions/workflows/pytest.yml/badge.svg?branch=master)](https://github.com/XENONnT/appletree/actions/workflows/pytest.yml)
[![Coverage Status](https://coveralls.io/repos/github/XENONnT/appletree/badge.svg?branch=master&kill_cache=1)](https://coveralls.io/github/XENONnT/appletree?branch=master&kill_cache=1)
[![PyPI version shields.io](https://img.shields.io/pypi/v/appletree.svg)](https://pypi.python.org/pypi/appletree/)
[![Readthedocs Badge](https://readthedocs.org/projects/appletree/badge/?version=latest)](https://appletree.readthedocs.io/en/latest/?badge=latest)
[![CodeFactor](https://www.codefactor.io/repository/github/xenonnt/appletree/badge)](https://www.codefactor.io/repository/github/xenonnt/appletree)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/appletree/master.svg)](https://results.pre-commit.ci/latest/github/XENONnT/appletree/master)

## Installation and Set-Up

### Regular installation:

With cpu support:

```
pip install appletree jax[cpu]
```

With CUDA Toolkit 11.2 support:

```
pip install appletree jax[cuda]==0.3.15 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

With CUDA Toolkit 12.1 support:

```
pip install appletree jax[cuda12_pip] -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

### Developer setup:

Clone the repository:

```
git clone https://github.com/XENONnT/appletree
cd appletree
```

To install the package and requirements in your environment, add `--user` in the above commands.

To install appletree in editable mode, insert `--editable` argument after `install` in the above `pip install` commands.

For example, to install in your environment and in editable mode with CUDA Toolkit 12.1 support:

```
pip install --editable . jax[cuda]==0.3.15 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html --user
```

Then you are now good to go!

## Usage

The best way to start with the `appletree` package is to have a look at the tutorial `notebooks`.

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.
cereeberus 0.1.10
A Python package for Reeb graphs
Requires Python: >=3.7

# ceREEBerus

ceREEBerus is a Python package that allows you to perform various operations and analysis on Reeb graphs. The main goal of this package is to implement the available theoretical work on the Reeb graph interleaving distance and its variants for use in applied and machine learning contexts.

## Features

- Generate Reeb graphs from input data
- Visualize Reeb graphs in a clear and intuitive way
- Perform topological analysis on Reeb graphs
- Extract critical points and features from Reeb graphs
- Apply various algorithms and techniques to analyze Reeb graphs

## Installation

You can either update the latest version from pip using

```
pip install cereeberus
```

or to work with the most up to date version, you can clone the repo and install with

```{sh}
git clone git@github.com:MunchLab/ceREEBerus.git
cd ceREEBerus
pip install .
```

## Documentation

Find the documentation for ceREEBerus [here](https://munchlab.github.io/ceREEBerus/).

## Collaborators

The code is a compilation of work done by [Elizabeth Munch](http://www.elizabethmunch.com) with her research group and collaborators. People who have contributed to ceREEBerus include:

- [Danielle Barnes](https://github.com/barnesd8)
- [Elena Wang](https://elenaxwang.com)
- [Ishika Ghosh](https://www.ishikaghosh.com/)

## Contact Information

- [Liz Munch](http://www.elizabethmunch.com): [muncheli@msu.edu](mailto:muncheli@msu.edu)
lambast 0.1.2
Los Alamos Model Bias Assessment and Statistical Toolkit
Requires Python: >=3.10

# LAMBAST - Los Alamos Model Bias Assessment and Statistical Toolkit

## Installation

You can install LAMBAST with

    pip install lambast

## Use

Simply `import lambast.<module>` in your python script.

### Overview

LAMBAST consists currently of 3 modules:

- detection_methods
- generate_data
- utils

Each of these modules can be explored using `help` from the python REPL, for
example:

```python-repl
>>> from lambast import generate_data
>>> help(generate_data)
>>> help(generate_data.copulas)
```

### Examples

See the `lambast/examples` directory for examples on how to use lambast.
ratiocinating-machine 0.0.1
A Machine that ratiocinates.
Requires Python: >=3.10
Keywords: ratiocinating-machine

# Raticinating Machine
A Machine that ratiocinates.
<pre>
  pip install ratiocinating-machine
</pre>
Then:
```Python
  # Python
  import ratiocinating_machine
```
Or:
<pre>
  uvx ratiocinating-machine [ARGUMENT] [OPTION]
</pre>
.
pythermite 0.5.0
Python object indexer for ETL, search for anything by anything
Requires Python: >=3.11
Keywords: index, search, storage, ETL, ELT, searchmeta

# PyThermite

PyThermite is a **performance-centered, native Python object indexer and graph datastore**.  
It allows you to index arbitrary Python objects, filter them by attributes and nested attributes, navigating graph-style relationships — all with **O(1)** lookups on attributes and **O(log n)** range queries.

---

## Core Design Principles

- **Python-first design**  
  Classes are the best way to enforce types. Class methods are the best way to mutate contents and communicate changes to a third-party datastore.

- **100% dynamic schema**  
  No schema or types are enforced at the datastore or query level. You can load any Python object, indexing all attributes.

- **Indexable schema objects**  
  Data objects are `Indexable` types. Updates made to the object immediately reflect on the `Index`.

- **Constant-time updates**  
  Unlike other data stores, schema updates are **O(1)** with no restructuring needed. This encourages iterative loading, filtering, mutating, and exporting.

---

## Features

- In-memory indexing of arbitrary Python objects
- Filter and query with attribute lookups or composable expressions
- Graph-style traversal from root nodes
- Perfect for ad-hoc migrations, analytics, and breaking down JSON

---

## Basic Usage

```py
from PyThermite import Index, Indexable, QueryExpr as Q

class Person(Indexable):
    name: str
    age: int
    employer: 'Store'
    wage: int

    def change_salary(self, amount: int):
        self.wage += amount


class Store(Indexable):
    name: str
    address: str
    owner: Person


person_index = Index()

big_python_store = Store(
    name="Big Python Store",
    address="123 Python St",
)

alice = Person(name="Alice", age=30, employer=big_python_store, wage=70000)
bob = Person(name="Bob", age=25, employer=big_python_store, wage=50000)

person_index.add_object_many([bob, alice])

is_30 = person_index.reduced_query(Q.eq("age", 30))
assert len(is_30.collect()) == 1
assert is_30.collect()[0].name == "Alice"
del is_30

high_wage = person_index.reduced_query(Q.gt("wage", 60000))
assert len(high_wage.collect()) == 1
assert high_wage.collect()[0].name == "Alice"
del high_wage

person: Person
for person in person_index.reduced_query(Q.lt("wage", 55_000)).collect():
    print(f"{person.name} works at {person.employer.name} and earns ${person.wage}")
    person.change_salary(10_000)

high_wage = person_index.reduced_query(Q.ge("wage", 60000))
assert len(high_wage.collect()) == 2
assert {p.name for p in high_wage.collect()} == {"Alice", "Bob"}
del high_wage

# nested queries
employees = person_index.reduced_query(
    Q.eq("employer.name", "Big Python Store")
).collect()
assert len(employees) == 2
assert {e.name for e in employees} == {"Alice", "Bob"}
```

## Installation

```bash
pip install pythermite