semvec/pypi-packages huggingface dataset:
zapped 0.1.7
A string manipulation tool for crazed maniacs including built in typed tuple returns.
Requires Python: >=3.13


# Zapper

[![pypi version](https://img.shields.io/pypi/v/zapped.svg)](https://pypi.org/project/zapped/)

A string manipulation tool for crazed maniacs including built in typed tuple returns.

## Installation

```bash
pip install zapped
```

With [`uv`](https://docs.astral.sh/uv/):

```bash
uv tool install zapped
```
l2f 2.0.18
Python bindings for the L2F (Learning to Fly) Simulator
Requires Python: >=3.8

# L2F: Learning to Fly Simulator


```
pip install l2f
```

This repo contains Python bindings for the simulator introduced in [Learning to Fly in Seconds](https://arxiv.org/abs/2311.13081).

Please check the [example](./examples/test.py) for how to use it.

## CUDA

For the CUDA usage please refer to [rl-tools/l2f-benchmark](https://github.com/rl-tools/l2f-benchmark)


## Getting Started

Install UIServer (forwards states to HTML/JS UI) and the foundation-policy (a general quadrotor policy)

```
pip install l2f ui-server foundation-policy
```


Run the UIServer
```
ui-server
```
Navigate to [http://localhost:13337](http://localhost:13337)
This is run separately from the client code such that you can keep the browser open, without windows popping up and going away when re-running your code. Also the camera perspective is maintained across runs.

Then run e.g.:

```python
from copy import copy
import numpy as np
import asyncio, websockets, json
import l2f
from l2f import vector8 as vector
from foundation_policy import QuadrotorPolicy

policy = QuadrotorPolicy()
device = l2f.Device()
rng = vector.VectorRng()
env = vector.VectorEnvironment()
ui = l2f.UI()
params = vector.VectorParameters()
state = vector.VectorState()
observation = np.zeros((env.N_ENVIRONMENTS, env.OBSERVATION_DIM), dtype=np.float32)
next_state = vector.VectorState()

vector.initialize_rng(device, rng, 0)
vector.initialize_environment(device, env)
vector.sample_initial_parameters(device, env, params, rng)
vector.sample_initial_state(device, env, params, state, rng)

async def main():
    uri = "ws://localhost:13337/backend"
    async with websockets.connect(uri) as websocket:
        handshake = json.loads(await websocket.recv(uri))
        assert(handshake["channel"] == "handshake")
        namespace = handshake["data"]["namespace"]
        ui.ns = namespace
        ui_message = vector.set_ui_message(device, env, ui)
        parameters_message = vector.set_parameters_message(device, env, params, ui)
        await websocket.send(ui_message)
        await websocket.send(parameters_message)
        policy.reset()
        for _ in range(500):
            vector.observe(device, env, params, state, observation, rng)
            action = policy.evaluate_step(observation[:, :22])
            dts = vector.step(device, env, params, state, action, next_state, rng)
            state.assign(next_state)
            ui_state = copy(state)
            for i, s in enumerate(ui_state.states):
                s.position[0] += i * 0.1 # Spacing for visualization
            state_action_message = vector.set_state_action_message(device, env, params, ui, ui_state, action)
            await websocket.send(state_action_message)
            await asyncio.sleep(dts[-1])

if __name__ == "__main__":
    asyncio.run(main())
```
taichi-big-float 0.1.3
Multiprecision type extension for taichi
Requires Python: >=3.8

# taichi-bigfloat
This is a module which makes arbitrary precision GPU accelerated computations possible using Taichi. It has 2 main functionalities: the supports_bigfloat decorator, and the make_float_t function which dynamically creates the high precision float module for the required precision with all the attached functions. This is a generalization of the [float192](https://github.com/balazs-szalai/taichi-float192) module for arbitrary sized float types. It only contains the most basic mathematical function everything else has to be implemenented from scratch.
scarabee 0.1.0
A lattice physics code for LWR analysis.
Requires Python: >=3.9
Keywords: lattice physics, reactor physics, neutron transport, LWR

# Scarabée
[![Documentation Status](https://readthedocs.org/projects/scarabee/badge/?version=latest)](https://scarabee.readthedocs.io/en/latest/?badge=latest)
[![License](https://img.shields.io/badge/License-GPLv3-brightgreen)](https://github.com/HunterBelanger/scarabee/blob/master/LICENSE)

Scarabée is a simplified lattice physics code for light water reactor (LWR)
neutronics calculations. It currently has the following features:

* Resonance self-shielding according to Carlvik's 2-term rational approximation
* 1D Annular pin cell collision probabilities solver for fixed-source and k-eigenvalue problems
* 2D Method of characteristics solver for fixed-source and k-eigenvalue problems
* Finite difference diffusion solver for 1D, 2D, and 3D fixed-source and k-eigenvalue problems
* Nodal expansion method diffusion solver for 3D k-eigenvalue problems
* PWR lattice calculations with depletion

This project closely follows the methods outlined in *Methods of Steady-State
Reactor Physics in Nuclear Design* by Stamm'ler and Abbate, and *Lattice
Physics Computations* by Knott and Yamamoto, from the *Handbook of Nuclear
Engineering*, edited by D. Cacuci, and *Applied Reactor Physics* by Hébert.

Scarabée uses a custom HDF5 formated nuclear data library which is easy and
intuitive to understand. The `data` directory contains a helper library and
scripts to generate a multi-group nuclear data library with the FRENDY nuclear
data processing code. FRENDY is free/open-source software, and can be downloaded
[here](https://rpg.jaea.go.jp/main/en/program_frendy/). Currently, only FRENDY
is supported, due to its advanced multi-group processing features.
rosdep2 0.26.0.2a0
rosdep - enhanced with lovely quality of life improvements
Requires Python: >=3.7

rosdep
------
[![Build status](https://github.com/ros-infrastructure/rosdep/actions/workflows/ci.yaml/badge.svg?branch=master&event=push)](https://github.com/ros-infrastructure/rosdep/actions/workflows/ci.yaml?query=branch%3Amaster+event%3Apush)
[![codecov](https://codecov.io/gh/ros-infrastructure/rosdep/branch/master/graph/badge.svg)](https://codecov.io/gh/ros-infrastructure/rosdep)

rosdep is a command-line tool for installing system dependencies. For *end-users*, rosdep helps you install system dependencies for software that you are building from source. For *developers*, rosdep simplifies the problem of installing system dependencies on different platforms. Instead of having to figure out which debian package on Ubuntu Oneiric contains Boost, you can just specify a dependency on 'boost'.

Includes support for pip alternatives like uv, and extra command line options to make integration with automated build systems more convenient

* Runs `apt` and `pip` installs in a single command
* Adds `--reinstall` option to the `check` command (to produce a list of all resolved dependencies, per installer)
* Supports use of `uv` (and others) via environment variable `ROSDEP_PIP_CMD="uv pip"`
* Supports pip package version specification in `rosdep.yaml`

[rosdep Users/Developers Guide](http://docs.ros.org/independent/api/rosdep/html/)