semvec/pypi-packages huggingface dataset:
terra_ui_components 0.0.166
NASA Terra UI Components Library
Requires Python: >=3.8

# Terra UI Components

Intro

### Forking the Repo

Start by [forking the repo](https://github.com/nasa/terra-ui-components/fork) on GitHub, then clone it locally and install dependencies.

```bash
git clone https://github.com/YOUR_GITHUB_USERNAME/components terra-ui-components
cd terra-ui-components
npm install
```

### Developing

Once you've cloned the repo, run the following command.

```bash
npm start
```

This will spin up the dev server. After the initial build, a browser will open automatically. There is currently no hot module reloading (HMR), as browser's don't provide a way to reregister custom elements, but most changes to the source will reload the browser automatically.

### Building

To generate a production build, run the following commands.

```bash
npm run build # to build the Lit components
```

### Creating New Components

To scaffold a new component, run the following command, replacing `terra-tag-name` with the desired tag name.

```bash
npm run create terra-tag-name
```

This will generate source files, a stylesheet, a Jupyter widget, and a docs page for you. When you start the dev server, you'll find the new component in the "Components" section of the sidebar. Do a `git status` to see all the changes this command made.

### Testing Components in Jupyter Lab

Install the `uv` package manager (https://github.com/astral-sh/uv), it's a lightweight tool that makes working with virtual environments and packages much easier.

Then run the following:

-   `uv venv` - create a virtual environment (only have to do this the first time)
-   `source .venv/bin/activate` - activate it
-   `uv pip install -e ".[dev]"` - install dependencies (see pyproject.toml)
-   open base.py and point dependencies to localhost (do not commit these changes) TODO: fix this so we auto-detect local development
-   `npm run start:python` - spins up Jupyter lab and should open the browser for you

For an example of how to use the components in a Jupyter Notebook, open the `/notebooks/playground.ipynb` notebook in Jupyter Lab.

### Publishing to NPM and PyPI

The Lit components are available on NPM at: https://www.npmjs.com/package/@nasa-terra/components
The Python widgets are available on PyPI: https://pypi.org/project/terra_ui_components/

To build a new version and publish it, you can use NPM commands. The Python equivalents will be run automatically for you (see the "scripts" in package.json for details). You will need access to both repositories in order to publish.

```bash
# commit all your changes first
npm version patch # bump the version, you can use "major", "minor", "patch", etc.
npm publish --access=public
```

## License

Terra UI Components were created by the NASA GES DISC team, on top of the amazing library Shoelace.

Shoelace was created by [Cory LaViska](https://twitter.com/claviska) and is available under the terms of the MIT license.
ofmt 1.2.0
Omni formatter. A formatter for everything.
Requires Python: >=3.11

# ofmt

[![Lint](https://github.com/jncraton/ofmt/actions/workflows/lint.yml/badge.svg)](https://github.com/jncraton/ofmt/actions/workflows/lint.yml)
[![Test](https://github.com/jncraton/ofmt/actions/workflows/test.yml/badge.svg)](https://github.com/jncraton/ofmt/actions/workflows/test.yml)
[![Release](https://github.com/jncraton/ofmt/actions/workflows/release.yml/badge.svg)](https://github.com/jncraton/ofmt/actions/workflows/release.yml)
[![PyPI](https://img.shields.io/pypi/v/ofmt)](https://pypi.org/project/ofmt/)

Omni formatter. A formatter for everything.

## Usage

Format specific files:

```sh
uvx ofmt {files}
```

Walk the current working directory:

```sh
uvx ofmt
```

## Formatters

extension | formatter
----------|-----------
c, h, cpp, cc | clang-format
js, ts, jsx, tsx, html, css, json, jsonc | biome
md, yaml, yml | prettier
toml | taplo
sh, bash | shfmt
sql | sqlfluff
py | black

Formatters are downloaded as needed. A bundled `.prettierrc.json` is used when no project-level prettier config is found. A bundled `.sqlfluff` config enforces lowercase keywords by default; after fixing, sqlfluff lints to catch any remaining violations.
kgsim 0.1.16
A library to interact with simulations with.
Requires Python: >=3.11

# PySim
PySim is a package for simply interacting with simulations in a pythonic, object oriented way.

```python
from pysim.dhybridr import TurbSim
from pysim.plotting import show, show_video

s = TurbSim("path/to/simulation")
# examine initial conditions
show(s.B.z[0])
show(s.u.x[0])
# make video of density evolution over simulation
@show_video(name='energy_flux', latex=r'$\rho \mathcal{u}_\perp^2$')
def energy_flux(s, **kwargs) -> np.ndarray:
    return np.array([p*(ux**2+uy**2) for p, ux, uy in zip(s.density, s.u.x, s.u.y)])

energy_flux(s)
```
uselemma-tracing 2.7.0
OpenTelemetry-based tracing module for Lemma
Requires Python: >=3.11
Keywords: instrumentation, llm, monitoring, observability, opentelemetry, tracing

# uselemma-tracing

OpenTelemetry-based tracing for AI agents. Capture inputs, outputs, timing, token usage, and errors — then view everything in [Lemma](https://uselemma.ai).

## Installation

```bash
pip install uselemma-tracing
```

## Quick Start

### 1. Register the tracer provider

Call `register_otel` once when your application starts. It reads `LEMMA_API_KEY` and `LEMMA_PROJECT_ID` from environment variables by default.

```python
from uselemma_tracing import register_otel

register_otel()
```

You can also enable experiment mode globally for the process:

```python
from uselemma_tracing import enable_experiment_mode

enable_experiment_mode()
```

### 2. Wrap your agent

`wrap_agent` creates a root OpenTelemetry span named `ai.agent.run` and records:
- `ai.agent.name`
- `lemma.run_id`
- `ai.agent.input`
- `lemma.is_experiment`

```python
from uselemma_tracing import TraceContext, wrap_agent

def my_agent(ctx: TraceContext, user_message: str):
    result = do_work(user_message)
    ctx.on_complete(result)
    return result

wrapped = wrap_agent("my-agent", my_agent, auto_end_root=True)
result, run_id, span = wrapped("hello")
```

## Export Behavior

- Spans are exported in run-specific batches keyed by `lemma.run_id`.
- A run batch is exported when its top-level `ai.agent.run` span ends.
- `force_flush()` exports remaining runs in separate batches per run.
- Spans with `instrumentation_scope.name == "next.js"` are excluded from export.

## Environment Variables

| Variable           | Description           |
| ------------------ | --------------------- |
| `LEMMA_API_KEY`    | Your Lemma API key    |
| `LEMMA_PROJECT_ID` | Your Lemma project ID |

Both are required unless passed explicitly to `register_otel()`.

## Documentation

- [Tracing Overview](https://docs.uselemma.ai/tracing/overview) — concepts, API reference, and usage patterns

## License

MIT