semvec/pypi-packages huggingface dataset:
asynkets 0.1.4
`asynkets` is a Python library which provides miscellaneous utilities that are useful when writing `asyncio` code.
Requires Python: >=3.8,<4.0


# asynkets

`asynkets` is a Python library which provides miscellaneous utilities that are useful when writing `asyncio` code.

Provided utilities include:

- *`Switch`*: A class that allows waiting for state changes of a switch that can be turned on or off. It provides async methods for waiting until it is in a specific state, and for waiting until it switches to a different state.
- *`EventfulCounter`*: A counter that can be incremented or decremented and has optional minimum and maximum values. It also provides async methods for waiting until some threshold (either low or high) is reached, or until some threshold is reached or left, by leveraging Switches.
- *`Fuse`*: Similar to asyncio's Event, but can only be set once.
- *`Pulse`*: A pulse that can be triggered and waited for. It can also be given a function to call when it is triggered and can be used as an async iterator.
- *`PeriodicPulse`*: A pulse that fires periodically at a specified interval and delay. It can be closed and used as an async iterator like the Pulse class.
- *`ensure_coroutine_function`* and *`ensure_async_iterator`*: return guaranteed async versions of a sync or async function or iterable, respectively. If the function or iterable is synchronous, it will be wrapped to be async; if it is already async, it will be returned as-is.
- *`merge_async_iterables`*: Merges multiple iterables or async iterables into one, yielding items as they are received.


## Installation

`asynkets` is available on PyPI and can be installed with `pip` or your favorite package manager.

```bash
pip install asynkets
```

## Usage

(todo)

## License

The library is provided under the MIT license. See the [LICENSE](LICENSE) file for more information.
usd2gltf 0.3.5
Convert USD to GLTF
Requires Python: >=3.9

# usd2gltf

USD to GLTF/GLB converter

Current version `0.3.5`

## Usage

This package can be incorporated into a DCC tool (like Houdini) or used from the command-line.

### CLI

usage: usd2gltf [-h] [-i INPUT] [-o OUTPUT] [--interpolation INTERPOLATION] [-d] [-f]

Convert incoming USD(z) file to glTF/glb

optional arguments:

- -h, --help show this help message and exit
- -i INPUT, --input INPUT
  - Input USD (.usd, .usdc, .usda, .usdz)
- -o OUTPUT, --output OUTPUT
  - Output glTF (.gltf, .glb)
- --interpolation INTERPOLATION
  - Interpolation of animation (LINEAR, STEP, CUBIC)
- -d, --debug Run in debug mode
- -f, --flatten Flatten all animations into one animation

## Requirements

- usd-core (Or custom Pixar USD build)
- gltflib
- numpy

## Features

- Mesh conversion
  - UV support (TEXCOORD_0, TEXCOORD_1)
  - displayColor support (COLORS_0)
  - Animated skeleton, weights, skinning
  - Normals and tangents supported
- Materials
  - UsdPreviewSurface -> PBRMetallicRoughness
- Camera conversion
- Light conversion
  - Point
  - Spot
  - Directional
- Xform conversion
  - Animated xforms supported
- Animations
  - Allows per object animation or single flat GLTF animation
- Export
  - GLB and GLTF options
- GLTF Extras
osirispy 0.0.13
A small package to read OSIRIS HDF5 Data in python
Requires Python: >=3.7

# OSIRISPY

`osirispy` is a python package for reading simulation
output for the particle-in-cell code OSIRIS. It utilizes the numpy interface to provide
a simple way to readsimulation output.

## Installing osirispy

`osirispy` is available on PyPI. You can install it by running the following
command inside your terminal

```shell
pip install osirispy

pip3 install osirispy
```


## Using osirispy

import the package in python 

```python3
import osirispy as ospy
```

You can use the function `ospy.read()` to read osiris files. It will give a different output based on the type of file that is being opened.

### grid files

Grid files are the output of vdf objects and can have between 1 and 3 dimensions. They can represent charge density, current, E.M. fields, phasespaces, etc... 

`ospy.read("/path/to/grid.h5")` will output a `grid` object when reading a grid-type file.
The data is a numpy array accessible at `grid.data`
The object also contains a list of axis containing the physical dimentions of the grid file at `grid.axis`.


### particle (aka RAW) files

Particle files contain the  output of the RAW diagnostic for a given species at a given time-step. 
RAW files contain information on the quantities `x1`,`x2`,`x3`,`p1`,`p2`,`p3`,`ene`.
`ospy.read(filepath,req_quantitites)` will output a `raw` object with the required quantities specified with a list of strings on the `req_quantities` parameter.

The data is a python dictionary of numpy arrays accessible at grid data. An example is given below:

```python3
# read raw data
rawdata=ospy.read("/path/to/raw.h5",("x1","x2"))
#access x1 array
x1=rawdata.data["x1"]
```

The object also contains a dictionary with the label of each quantity accessible at `raw.label`.


### track  files

Track files contain the output of the tracks diagnostic for a given species . 
Track files contain information on the quantities `t`,`x1`,`x2`,`x3`,`p1`,`p2`,`p3`,`ene`.
`ospy.read(filepath,req_quantitites)` will output a `tracks` object 

The data is a python dictionary of a list of numpy arrays accessible at grid data. An example is given below:

```python3
# read tracks data
trackdata=ospy.read("/path/to/track.h5",("x1","x2"))
#access x1 array of particle i
x1=trackdata.data["x1"][i]
```

The object also contains a dictionary with the label of each quantity accessible at `raw.label`.
micropython-consentiumthings 0.1.6
A micropython package for IoT
Requires Python: >=3.7

# micropython-consentiumthings

Passing tests on ESP 8266 and ESP 32

Developed by Debjyoti Chowdhury from ConsentiumInc


## Installing dependencies and main library

First connect to WiFi with SSID and Psk

```python
import network

ssid = ""
psk = ""

station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid,psk)
station.isconnected()
print(station.ifconfig())

```
Then install dependencies and main module using upip
``` python
>>> import upip
>>> upip.install('micropython-urequests')
>>> upip.install('micropython-consentiumthings', '/lib/')

```

## Examples of How To Use 

Making requests to Consentium IoT server

```python
from ConsentiumThings import ThingsUpdate
import utime

api_key = ""

ssid = ""
psk = ""

board = ThingsUpdate(key=api_key)

board.initWiFi(ssid,psk)

while True:
    sensor_val = [1, 2, 3, 4, 5, 6, 7]
    info_buff = ["a", "b", "c", "d", "e", "f", "g"]
    r = board.sendREST(sensor_val=sensor_val, info_buff=info_buff)
    print(r.text)
    utime.sleep(5)
```