semvec/pypi-packages huggingface dataset:
caplena 2.1.2
Python Library for Caplena REST API.
Requires Python: >=3.8
Keywords: caplena, api, nlp, customer feedback

[![PyPI version](https://badge.fury.io/py/caplena.svg)](https://badge.fury.io/py/caplena)
[![Downloads](https://static.pepy.tech/personalized-badge/caplena?period=month&units=international_system&left_color=black&right_color=brightgreen&left_text=downloads/month)](https://pepy.tech/project/caplena)

# Caplena Python Library

The Caplena Python library provides convenient access to the Caplena REST API from applications written in the Python programming language.

## Documentation

To learn more about what you can use Caplena for and for how to create your own API key, please see [our main website](https://caplena.com/).

To learn more about the REST API that constitutes the basis for this project, take a look at our [REST API docs](https://caplena.com/docs/developers/).

To view the Python API docs and refernces, head over to our [SDK documentation](https://caplena.com/docs/sdk/python/).

## Installation

### Minimum Version

We recommend using the latest version of Python. Caplena supports Python 3.8 and newer.

### Dependencies

The following distributions will be installed automatically when installing Caplena.

- [Requests](https://docs.python-requests.org/en/latest/) is an elegant and simple HTTP library for Python.
- [Typing Extensions](https://github.com/python/typing/tree/master/typing_extensions) enables use of new type system features on older Python versions.

### Installing Caplena

Within your Python environment of choice, use the following command to install Caplena:

```sh
$ pip install caplena
```

Caplena is now installed.

## Development

To use `caplena-python` in a development environment, we recommend you to set up a development virtualenv. Once done, you
can run the following command to install all required dependencies:

```sh
make install
```

Run all tests:

```sh
make test
```

Run all tests in watch mode:

```sh
make test-watch
```

Run the formatter:

```sh
make fmt
```

Run the linter:

```sh
make lint
```

Build the Sphinx SDK docs:

```sh
make build-docs
```

The Sphinx generated documentation is automatically generated and uploaded to our [developer documentation portal](https://caplena.com/docs/sdk/python/), using Github Actions.

Build the Python package:

```sh
make build-sdk
```

Publish the Python package:

```sh
make publish-sdk
```

Show all supported commands:

```sh
make help
```
pysymbolcheck 2.12.0
ELF symbol check
Requires Python: >=3.10

# Purpose

This tool does check compiled elf-files (and all dependencies) against given rules.
Objectives are

* check for discouraged functions (e.g. strcpy)
* check for combinations of symbols (e.g. mutex and pthreads)

## Usage

```shell
usage: pysymbolcheck [-h] [--libpath LIBPATH] rules file

Eval symbols of a binary against given rules

positional arguments:
  rules              Path to a rule file
  file               File to parse

optional arguments:
  -h, --help         show this help message and exit
  --libpath LIBPATH  ":" separated path to lookup libraries
```

## Rule file format

a rule file consists of a json-array, like this

```json
[]
```

within this __n__ element of the following can be added

```json
{ "severity": "error", "id": "A_Unique_ID", "msg": "some message", "rule", "<rule>" }
```

for __severity__ it is advised to use only **info**, **warning** or **error**

## Rule definition

A rule can consist of any logical combined operation such as

```text
((A && B) || (C && D )) && !E
```

to get the needed information following keywords are implemented

| keyword     |  variables  |                                                          purpose |            example |
| ----------- | :---------: | ---------------------------------------------------------------: | -----------------: |
| AVAILABLE() | symbol-name | check if a symbol is defined in the binary or any referenced lib | AVAILABLE(strncpy) |
| USED()      | symbol-name |                  check if a symbol is used by some binary or lib |      USED(strncpy) |
| SIZE()      | symbol-name |                                get the size in bytes of a symbol |      SIZE(strncpy) |
| TYPE()      | symbol-name |                                get the type in bytes of a symbol |      TYPE(strncpy) |
| &&          |    n.a.     |                                                      logical and |             A && B |
| \|\|        |    n.a.     |                                                       logical or |          A \|\| B  |
| !           |    n.a.     |                                                     not operator |                 !A |
tqdx 0.1.5
JAX compatible progress bars for scan and fori_loop.
Requires Python: >=3.9

<div align="center">
    <img src="https://github.com/huterguier/tqdx/blob/main/images/tqdx.gif" width="200">
</div>

# tqdx
Adds `tqdm` progress bars to `jax.lax.scan` and `jax.lax.fori_loop`. Progress bars commonly used in Python, such as tqdm, are not compatible with JAX's jit-compiled functions due to restrictions on side effects like printing. `tqdx` addresses this limitation by using callbacks to update progress bars created on the host.

```python
import tqdx

...
carry, ys = tqdx.scan(f, init, xs)
```
```
Processing: 100%|███████████████████████████████████████████| 50/50 [02:38<00:00,  3.20s/it]
```
## Features

- **Progress bars for JAX**: See the progress of your computations when using `jax.lax.scan` and `jax.lax.fori_loop`.
- **Works with `jax.jit`**: Progress bars show up even inside jit-compiled code.
- **Minimal syntax change**: Just replace your calls to `jax.lax.scan` and `jax.lax.fori_loop` with `tqdx.scan` and `tqdx.fori_loop`.
- **No extra dependencies**: Only requires JAX and tqdm.

## Usage
The following example demonstrates how to use `tqdx` with `jax.lax.scan` and `jax.lax.fori_loop`. You can arbitrarily nest these functions, and the progress bars will still work correctly.
```python
import jax
import tqdx
from time import sleep

def step(carry, x):
    def body_fun(i, val):
        jax.debug.callback(lambda: sleep(0.5))
        return val + i
    jax.debug.callback(lambda: sleep(0.5))
    carry = tqdx.fori_loop(0, 10, body_fun, carry)
    return carry, x + 1

def f(xs):
    return tqdx.scan(step, 0, xs)


xs = jax.numpy.arange(10)
result, _ = jax.jit(f)(xs)
```
```
100%|███████████████████████████████████████████████████████| 10/10 [00:05<00:00,  2.00it/s]
100%|███████████████████████████████████████████████████████| 10/10 [00:05<00:00,  2.00it/s]
 40%|████████████████████                                     | 2/5 [00:11<00:16,  5.51s/it]
 70%|██████████████████████████████████████                  | 7/10 [00:03<00:05,  2.00it/s]
```


## Installation

```bash
pip install tqdx
```
choreopath 1.2.0
Transform human movement into generative art. Track body poses from video and create SVG visualizations of motion trajectories
Requires Python: <3.13,>=3.12

# choreopath

Transform human movement into generative art. A Python tool that uses MediaPipe
to track body poses from video and creates SVG visualizations of motion trajectories -
perfect for pen plotters, laser cutters, and digital art.

## Features

- Track 33 body landmarks using [MediaPipe](https://ai.google.dev/edge/mediapipe/solutions/guide) Pose
- Process video files with [OpenCV](https://opencv.org) to extract tracking data
- Export tracking data to CSV with coordinates and visibility scores
- Generate SVG visualizations with hierarchical body part grouping, ready to be used in Inkscape
- Analyze tracking data quality with detailed reports
- Create animated visualizations of pose tracking
- Command-line interface

## Installation

choreopath is pushed to Pypi at each new release. You can `pip install choreopath` to install it. Beware though, some versions of Python are incompatible with it as MediaPipe isn't currently available for Python >=3.13.

Instead, it is suggested to use [uv](https://docs.astral.sh/uv/) and run choreopath like this:

`uvx --python 3.12 choreopath`

## Usage

### Track poses from video

```bash
choreopath track video.mp4 tracking_data.csv
```

### Track with custom confidence thresholds

```bash
choreopath track video.mp4 tracking_data.csv --min-detection-confidence 0.7 --min-tracking-confidence 0.7
```

### Generate SVG visualization

```bash
choreopath draw tracking_data.csv output.svg
```

### Generate SVG with custom dimensions

```bash
choreopath draw tracking_data.csv output.svg --width 1920 --height 1080 --min-visibility 0.7
```

### Generate an overlay video

```bash
choreopath overlay video.mp4 video-overlay.mp4
```

### Analyze tracking data

```bash
choreopath analyze tracking_data.csv --animation output.mp4 --fps 30
```

## Origin Story

This project was created when working on a generative art project. I used
generated videos of dancers to create SVG that I could then plot using a pen plotter.

See example files:

[original video](examples/fall-recovery-4.mp4)
[overlay video](examples/fall-recovery-4-overlay.mp4)
[animated tracking data](examples/fall-recovery-4-animation.mp4)
[examples/fall-recovery-4.svg](https://github.com/marcw/choreopath/blob/main/examples/fall-recovery-4.svg)

## Development

- Use `uv`
- Run smoke test by using `make smoke-test`

## Changelog

See [CHANGELOG.md](CHANGELOG.md).

## License

This software is under a MIT license. See [LICENSE.md](LICENSE.md).
test123test234 1.0.5
Example.com
Requires Python: >=3.9
Keywords: Example.com, api, brand, logo, colors

# Example.com Python SDK

## Overview

This is an **example** API to demonstrate features of the OpenAPI specification. # Introduction This API definition is intended to to be a good starting point for describing your API in [OpenAPI/Swagger format](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md). It also demonstrates features of the [create-openapi-repo](https://github.com/Redocly/create-openapi-repo) tool and the [Redoc](https://github.com/Redocly/Redoc) documentation engine. Beyond the standard OpenAPI syntax, we use a few  [vendor extensions](https://github.com/Redocly/Redoc/blob/master/docs/redoc-vendor-extensions.md). # OpenAPI Specification The goal of The OpenAPI Specification is to define a standard, language-agnostic interface to REST APIs which allows both humans and computers to discover and understand the capabilities of the service without access to source code, documentation, or through network traffic inspection. When properly defined via OpenAPI, a consumer can  understand and interact with the remote service with a minimal amount of implementation logic. Similar to what interfaces have done for lower-level programming, OpenAPI removes the guesswork in calling the service. 

## Installation

```bash
pip install test123test234
```

## Configuration

```python
import test123test234
from test123test234.rest import ApiException

# Create configuration with API key
configuration = test123test234.Configuration()
configuration.api_key['api-key'] = 'your_api_key_here'

# Create API client
api_client = test123test234.ApiClient(configuration)
api_instance = test123test234.BrandsApi(api_client)
```

## Example Request

```python
# Get brand data by domain
try:
    domain_request = test123test234.DomainRequest(domain="example.com")
    response = api_instance.by_domain(domain_request)
    
    # Access brand data
    print(f"Brand: {response.brand.name}")
    print(f"Logo: {response.images.logos[0].url}")
    print(f"Primary Color: {response.colors.primary[0].hex}")
except ApiException as e:
    print(f"Exception: {e}")
```

## API Endpoints

Class | Method | Description
------------ | ------------- | -------------
*EchoApi* | **echo** | Echo test


## Models

List of available API Models

[Example.com Models](http://localhost:4321/docs/api-docs/models)

## Authentication

Authentication schemes defined for the API:

[Example.com Authentication Documentation](http://localhost:4321/docs/authentication)


### api_key

- **Type**: API key
- **API key parameter name**: api_key
- **Location**: HTTP header