semvec/pypi-packages huggingface dataset:
pypokeapi 1.0.0
A simple python wrapper for PokeAPI with many built in functions.
Requires Python: >=3.10

# pypokeapi

A simple Python wrapper for "PokeAPI" built using the requests library. 


# dependencies

- Python [requests library](https://requests.readthedocs.io/en/latest/)


# Functions 
- Pokemon Search
- Species Search
- Get ability 
- Get type
- Get a list of pokemon

# License

This project uses the [GPL-3.0-or-later](https://spdx.org/licenses/GPL-3.0-or-later.html) license
ptrnets 0.1.1
Easy access to pretrained models for system identification
Requires Python: >=3.8,<3.11

# ptrnets

[![Release](https://img.shields.io/github/v/release/sacadena/ptrnets)](https://img.shields.io/github/v/release/sacadena/ptrnets)
[![Build status](https://img.shields.io/github/actions/workflow/status/sacadena/ptrnets/main.yml?branch=master)](https://github.com/sacadena/ptrnets/actions/workflows/main.yml?query=branch%3AMain)
[![codecov](https://codecov.io/gh/sacadena/ptrnets/branch/master/graph/badge.svg)](https://codecov.io/gh/sacadena/ptrnets)
[![Commit activity](https://img.shields.io/github/commit-activity/m/sacadena/ptrnets)](https://img.shields.io/github/commit-activity/m/sacadena/ptrnets)
[![License](https://img.shields.io/github/license/sacadena/ptrnets)](https://img.shields.io/github/license/sacadena/ptrnets)

Collection of pretrained networks in pytorch readily available for transfer learning tasks like neural system identification.

## Installation

```bash
pip install ptrnets
```

## Usage
Find a list of all available models like this:

```python
from ptrnets import AVAILABLE_MODELS

print(AVAILABLE_MODELS)
```

Import a model like this:

```python
from ptrnets import simclr_resnet50x2

model = simclr_resnet50x2(pretrained=True)
```
You can access intermediate representations in two ways:

### Probing the model
You can conveniently access intermediate representations of a forward pass using the `ptrnets.utils.mlayer.probe_model` function Example:
```python 
import torch
from ptrnets import resnet50
from ptrnets.utils.mlayer import probe_model

model = resnet50(pretrained=True)
available_layers = [name for name, _ in model.named_modules()]
layer_name = "layer2.1"
assert layer_name in available_layers, f"Layer {layer_name} not available. Choose from {available_layers}"

model_probe = probe_model(model, layer_name)

x = torch.rand(1, 3, 224, 224)
output = model_probe(x)
```

**Note**: if the input is not large enough to do a full forward pass through the network, you might need to use a `try-except` block to catch the `RuntimeError`.

### Clipping the model

`ptrnets.utils.mlayer.clip_model` creates a copy of the model up to a specific layer. Because the model is smaller, a forward pass can run faster. 
However, the output is only guaranteed to be the same as the original model's if the architecture is fully sequential up until that layer. 

Example:
```python
import torch
from ptrnets import vgg16
from ptrnets.utils.mlayer import clip_model, probe_model

model = vgg16(pretrained=True)
available_layers = [name for name, _ in model.named_modules()]
layer_name = "features.18"
assert layer_name in available_layers, f"Layer {layer_name} not available. Choose from {available_layers}"

model_clipped = clip_model(model, layer_name)  # Creates new model up to the layer

x = torch.rand(1, 3, 224, 224)
output = model_clipped(x)

assert torch.allclose(output, probe_model(model, layer_name)(x)), "Output of clipped model is not the same as the original model"
```

## Contributing
Pull requests are welcome. 
Please see instructions [here](https://github.com/sacadena/ptrnets/blob/master/CONTRIBUTING.rst).
streamlit-plotly-mapboxEvents 0.1.4
A Streamlit component that integrates Plotly's interactive Mapbox visualizations, enabling bidirectional communication between the map and Streamlit. It allows for seamless rendering of Mapbox plots within Streamlit applications while supporting event handling, such as click, select, hover, and relayout events, to facilitate dynamic interactions and data updates.
Requires Python: >=3.6

The Plotly Mapbox component for Streamlit is a powerful tool that brings the rich functionality of Plotly's Mapbox visualizations to Streamlit applications. It provides a seamless integration between Plotly's interactive Mapbox plots and Streamlit's intuitive app development framework. With this component, you can effortlessly render Mapbox visualizations within your Streamlit app, enabling users to explore and interact with geospatial data in a highly engaging manner.

One of the key features of this component is its ability to handle various events triggered by user interactions with the Mapbox plot. It supports click, select, hover, and relayout events, allowing you to capture and respond to user actions in real-time. When an event occurs, such as clicking on a marker or selecting a region, the component communicates the event data back to Streamlit, enabling you to update other elements of your app or perform further data analysis based on the user's interactions.

The component offers flexibility in customizing the appearance and behavior of the Mapbox plot. You can easily control the plot's height, width, and initial zoom level to suit your app's layout and requirements. Additionally, you can enable or disable specific event types depending on your use case, giving you fine-grained control over the interactivity of the plot.

By leveraging the power of Plotly's Mapbox visualizations and the simplicity of Streamlit's app development framework, this component empowers you to create stunning and interactive geospatial applications with ease. Whether you're building dashboards, data exploration tools, or location-based services, the Plotly Mapbox component for Streamlit provides a seamless and efficient way to integrate interactive maps into your Streamlit apps, enhancing the user experience and facilitating data-driven decision-making.
observe-http-sender 1.3.3
A Python class to send events to an Observe Inc Datastream via the HTTP API endpoint
Requires Python: >=3.7
Keywords: observeinc,http,ingest

# Python Class for Sending Data to ObserveInc HTTP Endpoint

Version/Date: 1.3.3 2024-3-16

## Description:

This is a python class to send events to an Observe Inc Datastream via the [HTTP API endpoint](https://docs.observeinc.com/en/latest/content/data-ingestion/endpoints/http.html).

## Using this Python Class

### Usage: Manual

You will need to put this with any other code and import the class as needed.
1. Instantiate a copy of the `ObserveHttpSender` object
1. Submit JSON dictionary payload(s) via the `post_observation` method.
1. Call the `flush` method to ensure any non batched payload data is flushed to Observe.

### Usage: With pip3

    pip3 install observe-http-sender

Once installed you can start python try the following.

#### Python Test:

    from observe_http_sender import ObserveHttpSender 
    help(ObserveHttpSender)

### Getting Started:

The arguments needed to initialize an Observer:

* OBSERVE_URL -- The base Observe customer URL - required (Example: https://154418444508.observeinc.com/)
* OBSERVE_TOKEN -- The configured Datastream API Token - required

#### Python Usage:

    from observe_http_sender import ObserveHttpSender

    # Setup Observer and its logging level.
    observer = ObserveHttpSender(OBSERVE_URL,OBSERVE_TOKEN)
    observer.log.setLevel(logging.INFO)

### Logging

You may use logging by setting up a logger in your code from the `import logging` module.

    logging.basicConfig(format='%(asctime)s %(name)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S %z')
    logger = logging.getLogger(u"OBSERVE_EXAMPLE")
    logger.setLevel(logging.INFO)

You may set a different logging level for the `ObserveHttpSender` class.

    # Setup Observer and its logging level.
    observer = ObserveHttpSender(OBSERVE_CUSTOMER,OBSERVE_TOKEN,OBSERVE_DOMAIN)
    observer.log.setLevel(logging.INFO)
    
# Notes:

* The `check_connectivity` method that is optional but recommended before attempting to submit large amounts of data to Observe. See example.py for use and docstrings on the method for details.
* You MUST call the method `flush` before your code completes to ensure all remaining non batch posted data is sent to Observe.
* Methods `get_pop_empty_fields` and `set_pop_empty_fields`. Defaults to True to remove empty/null fields from payloads to save ingestion cost.
* Methods `get_payload_json_format` and `set_payload_json_format`. Defaults to True to post payload in format `application/json`. False will post the payload in format `text/plain` Set this at instantiation for text payloads.
* Methods `get_post_path` and `set_post_path`. Defaults to None append an optional path segment example `/orca/alerts`. This will show in the Datastream EXTRAS field as `path`.

# Example Usage:

The included python script `example-postcsv.py` takes a csv file with a header row and posts it to Observe in JSON format.

Usage: 

    python3 example-postcsv.py data/sample-authevents.csv
fig2latex 0.0.1
fig2latex is a Python utility for converting figures to LaTeX format. This utility simplifies the process of including figures in LaTeX documents by generating the necessary LaTeX code.
Requires Python: >=3.5

fig2latex
=========

Introduction
------------
`fig2latex` is a Python utility for converting figures to LaTeX format. This utility simplifies the process of including
figures in LaTeX documents by generating the necessary LaTeX code.

Installation
------------
You can install `fig2latex` via pip:
pip install fig2latex

Usage
-----

```python
from pathlib import Path
from fig2latex import fig2latex

# Example usage:
figure_path = Path("example.png")
label = "fig:example"
caption = "Example Figure"
latex_code = fig2latex(figure_path, label=label, caption=caption)
print(latex_code)
```


Convert a figure to LaTeX format.

- Parameters:
  - figure_path (Path): Path to the figure file.
  - label (str, optional): Label for the figure.
  - caption (str, optional): Caption for the figure.
  - centered (bool, optional): Whether to center the figure. Default is True.
  - text_width (float, optional): Width of the figure as a fraction of text width.
  - placement (str, optional): LaTeX placement specifier for the figure.

- Returns:
  - str: LaTeX representation of the figure.

- Example:
  ```python
  fig2latex(Path("example.png"), label="fig:example", caption="Example Figure")
  ```

  Output:
  ```latex
  \begin{figure}
  \includegraphics{example.png}
  \caption{Example Figure}
  \label{fig:example}
  \end{figure}
  ```

License
-------
This project is licensed under the MIT License. See the LICENSE file for details.
```
baki 0.0.0
Backup wrapper for restic
Requires Python: >3.10
Keywords: backup

# Baki

> A backup / restore wrapper for restic.

I just needed a tool to abstract the usage of restic.


## Getting Started

To get a local copy up and running follow these simple steps.


### Installation

Run the following command:

```sh
pip install baki
```


## Contact

Kanelis Elias - [@email](mailto:e.kanelis@voidbuffer.com)
PyVDLib 1.1.0
A library to make it easy to use the body tracking information from Virtual Desktop in Python
Requires Python: >=3.8

# PyVDLib

A library to make it easy to use the body tracking information from Virtual Desktop in Python

## Installation

PyVDLib can be installed with `pip install pyvdlib` and imported with `import PyVDLib`

## Usage

`AwaitVirtualDesktopSyncEvent(timeout)`
- timeout (optional) The duration in milliseconds to wait before timing out (default is 1000 ms).

Performs a blocking wait, halting the execution until an update is received from Virtual Desktop's event synchronization pulse, or until the specified timeout duration is reached.

`GetVirtualDesktopBodyDict()`

Returns a dict with the following keys:

- FaceIsValid (bool)
- IsEyeFollowingBlendshapesValid (bool)
- ExpressionWeights (dict of 70 floats, keys from 0-69)
- ExpressionConfidences (dict of 2 floats, keys from 0-1)
- LeftEyeIsValid (bool)
- RightEyeIsValid (bool)
- LeftEyePose (pose)
- RightEyePose (pose)
- LeftEyeConfidence (float)
- RightEyeConfidence (float)
- LeftHandActive (bool)
- RightHandActive (bool)
- LeftHandJointStates (dict of 26 FingerJointState's, keys from 0-25)
- RightHandJointStates (dict of 26 FingerJointState's, keys from 0-25)
- LeftAimState (HandTrackingAimState)
- RightAimState (HandTrackingAimState)
- BodyTrackingCalibrated (bool)
- BodyTrackingHighFidelity (bool)
- BodyTrackingConfidence (float)
- BodyJoints (dict of 84 BodyJointLocation's, keys from 0-83)
- SkeletonJoints (dict of 84 SkeletonJoints's, keys from 0-83)
- SkeletonChangedCount (Uint32)

### Quaternion
`x: float`
`y: float`
`z: float`
`w: float`

### Vector3
`x: float`
`y: float`
`z: float`

### Pose
`Orientation: Quaternion`
`Position: Vector3`

### FingerJointState
`Pose: Pose`
`Radius: float`
`AngularVelocity: Vector3`
`LinearVelocity: Vector3`

### HandTrackingAimState
`AimStatus: np.uint64`
`AimPose: Pose`
`PinchStrengthIndex: float`
`PinchStrengthMiddle: float`
`PinchStrengthRing: float`
`PinchStrengthLittle: float`

### BodyJointLocation
`LocationFlags: np.uint64`
`Pose: Pose`

The active joint locations.

Location flags function similarly to a boolean, but instead of being 0 or 1, they are either 0 or 15. These flags include bits for position and orientation, as well as a valid and tracked bit. As it currently stands, these are either all activated or all deactivated.

### SkeletonJoint
`Joint: np.uint32`
`ParentJoint: np.uint32`
`Pose: Pose`

A static T-Pose of the users proportions.

List of joint mappings can be found here: [LINK](https://developer.oculus.com/documentation/unity/move-body-tracking/)