semvec/pypi-packages huggingface dataset:
projectkiwi3 0.1.8
This module is a means for interfacing with projectkiwi.io using python.

# Projectkiwi3 Client

This package adds a basic python interface for the projectkiwi api. 

- :notebook: [Take a look at this example notebook for some application ideas!](https://colab.research.google.com/drive/1N600vZSQHPro3gx8nM-nH6iv5I--PjMw?usp=sharing)

### Installation
```
pip install projectkiwi3
```


### Getting Started

Retrieve your projectkiwi API key here: https://projectkiwi.io/developer
```python
import projectkiwi3

client = projectkiwi3.Client("YOUR_API_KEY")

# list all our projects
projects = client.getProjects()
```

<br />

---

<br />

#### Reading Annotations
```python
project = projects[0]

# get current annotations
annotations = client.getAnnotations(project.id)
```

#### Adding Annotations
```python
# get labels
newLabel = client.addLabel(project.id, "demo label", "rgb(3, 186, 252)")

# create new annotation
newAnnotation = client.addAnnotation(
    project.id, 
    coordinates=[[-123.4, 56.789012]], 
    shape="Point", 
    labelId=newLabel.id
    confidence=1.0
)

print(newAnnotation)
# id=553971 sub='google-oauth2|115859123295676188590' shape='Point' createdAt='2024-09-05T18:47:17.529Z' confidence=1.0 labelId=3 label=Label(id=3, name='demo label', color='rgb(3, 186, 252)', active=True, modifiedAt='2024-07-15T20:29:59.697Z') coordinates=[[-123.4, 56.789012]]
```

<br />

---

<br />

#### Working with labeling Queues
Labeling Queues allow us to break up larger labeling tasks in to bite size portions, easily digestible for both humans and GPUs.
```python
import matplotlib.pyplot as plt

# list out all labeling queues in the project
labelingQueues = client.getLabelingQueues(project.id)

# let's just pick out the latest one
labelingQueue = labelingQueues[-1]

# find imagery layer to use - every geotiff you upload creates an imagery layer
imageryLayer = client.getAllImagery(project.id)[-1]

# Preview an image for a single task within the labeling queue
task = labelingQueue.labelingTasks[-1]
img = client.getImageForTask(imageryLayer, task.coordinates)
plt.imshow(img)
plt.show()
```

![preview image](imgs/imgPreview.png "Preview Image")
meta-only 0
Is a a project running in a Meta-internal environment?
Requires Python: >=3.10

# meta-only

Is a a project running in a Meta-internal environment?

[![version](https://img.shields.io/pypi/v/meta-only.svg)](https://pypi.org/project/meta-only)
[![license](https://img.shields.io/pypi/l/meta-only.svg)](https://github.com/amyreese/meta-only/blob/main/LICENSE)


Install
-------

```shell-session
$ pip install meta-only
```


Usage
-----

```py
import meta_only
```


License
-------

meta-only is copyright Amethyst Reese, and licensed under the MIT license.
plastexdepgraph 0.0.5
Dependency graph plugin for plasTeX.
Requires Python: >=3.7

# plasTeX dependency graphs

This is a [plasTeX](https://github.com/plastex/plastex/) plugin allowing
to build dependency graphs.

Needs graphviz and its dev libraries. If you have a user-friendly OS, it is
as simple as `sudo apt install graphviz libgraphviz-dev`. See https://pygraphviz.github.io/documentation/stable/install.html otherwise.

You can use this package with plasTeX using `\usepackage{depgraph}`.
Note that the
[Lean blueprint package](https://github.com/PatrickMassot/leanblueprint)
automatically loads this packages and transmit options.

## Options

When loading the package inside the tex file, you can give the following
arguments:
* title: the title of the dependency graph.
        The default value is Dependencies.
* dep_by: optional level for dependency graph generation, for instance chapter
        or part.
        The default value is to generate one graph for the whole document
* thms: optional list of theorem types to include into the report,
        separated by +.
        The default value is: definition+lemma+proposition+theorem+corollary
* nonreducedgraph: keep all edges in the dependency, even transitively
        redundant ones.
* tpl: template file for dependency graph, relative to the current
  directory

For instance you could write 
```latex
\usepackage[thms=dfn+lem+prop+thm+cor]{depgraph}
```
if you like short environment names.

This package will also consider optional information contained in the document
userdata dictionary. Such information could be added by other packages who
want to influence the dependency graph. For instance the 
[Lean blueprint plugin](https://github.com/PatrickMassot/leanblueprint)
does that.

* `document.userdata['dep_graph']['shapes']` can be a dictionary whose keys are node
  kinds as strings and whose values are strings descripting graphviz shapes
  (see https://graphviz.org/doc/info/shapes.html).
  By default, everything uses an ellipse except definition which uses a box.

* `document.userdata['dep_graph']['colorizer']` can be a function taking as input
  a plasTeX node and outputting a CSS color for the boundary of graph nodes.

* `document.userdata['dep_graph']['fillcolorizer']` can be a function taking as
  input a plasTeX node and outputting a CSS color for the interior of graph
  nodes.

* `document.userdata['dep_graph']['stylerizer']` can be a function taking as input
  a plasTeX node and outputting a graphviz style
  (see https://graphviz.org/docs/attr-types/style/).

* `document.userdata['dep_graph']['legend']` can be a list whose entries are pairs
  made of a visual description and an explanation.
  The default value is:
  [('Boxes', 'definitions'), ('Ellipses', 'theorems and lemmas')]
  Additional entries can also refer to colors.

* `document.userdata['dep_graph']['extra_modal_links']` can be a list of Jinja2
  templates used to render extra links at the bottom of the modal appearing
  when clicking on graph nodes.
  The default value is an empty list.
erroranalysis 0.5.5
Core error analysis APIs
Requires Python: >=3.7

# Error Analysis SDK for Python

### This package has been tested with Python 3.7, 3.8, 3.9, 3.10 and 3.11

The error analysis sdk enables users to get a deeper understanding of machine learning model errors. When evaluating a machine learning model, aggregate accuracy is not sufficient and single-score evaluation may hide important conditions of inaccuracies. Use Error Analysis to identify cohorts with higher error rates and diagnose the root causes behind these errors.

Highlights of the package include:

- The error heatmap to investigate how one or two input features impact the error rate across cohorts
- The decision tree surrogate model trained on errors to discover cohorts with high error rates across multiple features. Investigate indicators such as error rate, error coverage, and data representation for each discovered cohort.

Please see the main documentation website:
https://erroranalysis.ai/

Auto-generated sphinx API documentation can be found here:
https://erroranalysis.ai/raiwidgets.html

The open source code can be found here:
https://github.com/microsoft/responsible-ai-widgets
huuid 0.9.0
library to convert uuids forth and back to a human-readable and pronounceable format
Requires Python: <4,>=3.7
Keywords: TeX, LaTeX, Markdown, HTML markdown2html, latex2mathml

# huuid - human UUIDs
python3-library to convert uuids forth and back to a human-readable and pronounceable format

## What is `huuid`

`hhuid` does a bijective transformation from uuids to a format that can be read, pronounced and typed a lot better than the default formats.
No Information is lost in the mapping.

Here is an example-output of the `demo.py` in the `tests`-folder:

```
generated uuid:          f3ad6cef-2732-4b18-97dd-137a459eb656
human-readable:          tapratnaz-vorjonfif-Tezjozdin-sejgipneh
Afer back-translation:   f3ad6cef-2732-4b18-97dd-137a459eb656
--- other usecases: ---
first 32bit human-readable:  tapratnaz
generated 32bit-Password:    Sunmuhnud
generated 64bit-Password:    Vezvegdum-ladzibkal
```

## How to use `huuid`

Install it using pip:

`pip install huuid`

or just put the folder `huuid` in your project-root. (Jep, just that one file - that's all!)

Then in python import it in your code with

`import huuid`

and convert any uuid-object or uuid-string to a huuid-string with

`huuid.uuid2human(myUuidObject)`

Optionally you can limit the huuid-string to the 32, 64 or 96 bit:

`huuid.uuid2human(myUuidObject, 64)`

Convert it back to a uuid-string with

`huuid.human2uuid(myUuidObject)`

## Background

The hexadecimal representation of the UUID is translated to letters that have an unambiguous pronounciation. The 2nd, and then every third letter is a vowel, the other ones are consonants which makes up a well pronounced word that sounds like it is made up of syllables.

There are 5 vowels and 16 consonants (just unambiguous ones) being used, and (only) for the first letter capitals are allowed.
(And a capital-C additional to the 16 chosen unambiguous consonants to reach 32bit with 9 letters)

With this pattern there are a little more than 2^32 possibilities to generate a word with 9 letters.
4 "Words" hit the 128bit of UUIDs (>10^38).

## Dependencies

This only uses the python3-modules `uuid` and `math`.

## Credits

This is highly inspired by

https://arxiv.org/html/0901.4016

published by Daniel Shawcross Wilkerson
and its implementation:

https://github.com/dsw/proquint
synexa 0.1.1
Python client for Synexa AI API
Requires Python: >=3.8

# Synexa Python Client

This is a Python client for [Synexa AI](https://synexa.ai). It lets you run AI models from your Python code or Jupyter notebook.

## Requirements

- Python 3.8+

## Installation

```sh
pip install synexa
```

## Authentication

Before running any Python scripts that use the API, you need to set your Synexa API key in your environment:

```sh
export SYNEXA_API_KEY=your-api-key
```

Alternatively, you can pass the API key directly when creating a client:

```python
client = synexa.Synexa(api_key="your-api-key")
```

## Usage

Here's a simple example of how to use the client:

```python
import synexa

# Run a model
output = synexa.run(
    "black-forest-labs/flux-schnell",
    input={"prompt": "An astronaut riding a rainbow unicorn, cinematic, dramatic"}
)

# Save the generated image
for i, img in enumerate(output):
    with open(f'output_{i}.webp', 'wb') as f:
        f.write(img.read())
```

### Async Support

The client supports both synchronous and asynchronous operations. By default, it will wait for the prediction to complete (up to 60 seconds). You can modify this behavior:

```python
# Don't wait for completion
output = synexa.run(
    "black-forest-labs/flux-schnell",
    input={"prompt": "An astronaut riding a rainbow unicorn"},
    wait=False
)

# Wait with custom timeout (in seconds)
output = synexa.run(
    "black-forest-labs/flux-schnell",
    input={"prompt": "An astronaut riding a rainbow unicorn"},
    wait=30
)
```

### Error Handling

The client will raise exceptions for various error conditions:

- `ModelError`: Raised when the prediction fails
- `TimeoutError`: Raised when the prediction doesn't complete within the specified timeout
- `ValueError`: Raised when required parameters are missing or invalid
- `httpx.HTTPError`: Raised for HTTP-related errors

Example error handling:

```python
from synexa import ModelError

try:
    output = synexa.run(
        "black-forest-labs/flux-schnell",
        input={"prompt": "An astronaut riding a rainbow unicorn"}
    )
except ModelError as e:
    print(f"Prediction failed: {e}")
    if e.prediction:
        print(f"Prediction ID: {e.prediction['id']}")
```

## License

MIT License