semvec/pypi-packages huggingface dataset:
ubersmith-api 1.0.2
Version-specific Python 3 wrapper for the Ubersmith API
Requires Python: >=3.10
Keywords: api, wrapper, ubersmith, client

# Python Ubersmith
[![Pypi](https://img.shields.io/pypi/v/ubersmith-api)](https://pypi.org/project/ubersmith-api)
[![MIT licensed](https://img.shields.io/badge/license-MIT-green.svg)](https://raw.githubusercontent.com/bnassif/ubersmith-api/main/LICENSE)
![GitHub Release Date](https://img.shields.io/github/release-date/bnassif/ubersmith-api)

A fully-featured API wrapper for the [Ubersmith](https://ubersmith.com/) API

Python wrappers exist on PyPI and across GitHub for interacting with the Ubersmith API, but each of them fails to provide full compatibility.

In comes `ubersmith-api`...

## Overview

At its core, this package provides a generic API wrapper class, `UbersmithClient` which allows for uncontrolled calls to an Ubersmith instance.

Built atop this wrapper, a templating suite is available for generating classes for each API section in Ubersmith, specific to each Ubersmith version to maximize compatibility.

## Installation

```bash
# PyPi Installation
pip install ubersmith-api
# GitHub Installation
pip install git+'https://github.com/bnassif/ubersmith-api.git'
```

## Getting Started

### Instantiating the Base Client
```python
from ubersmith import *

config = UbersmithConfig(
    host='target-hostname-or-address',
    username='username-to-use',
    password='api-token-for-user',
)

client = UbersmithClient(config)
```

### Making Calls

```python
response_obj = client.request(
    'uber.method_get',
    data={
        'method_name': 'client.get',
    },
    #raw=True,
)
```

By default, the `request()` method will parse the response from the API, checking for HTTP error codes, as well as error messages from Ubersmith itself. If no errors are found, the returned `data` field is returned.

Alternatively, you can parse `raw=True` to return the `requests.Response` object for manual parsing and error checking.

### Shipped Methods
The `UbersmithClient` class comes with three (3) core methods shipped.  
These offer a simplified entrypoint to gathering parsed information of an Ubersmith system.

```python
# Get system information: calls `uber.system_info`
sys_info = client.system_info()

# Get all available methods: calls `uber.method_list`
all_methods = client.method_list()

# Get details of one method: calls `uber.method_get`
method_details = client.method_get('client.get')
```

## Future Compatibility

**NOTE**: 

Additional code is shipped in this repository, along with version-specific schemas for the Ubersmith API.  
These features will be enabled in later releases of the package.

## License
MIT - Feel free to use, extend, and contribute.
posthog-otel-exporter 0.1.0
Export OpenTelemetry-compatible events to PostHog.
Requires Python: >=3.10

# posthog-otel-exporter

## Overview

`posthog-otel-exporter` is an OpenTelemetry SpanExporter for Python that sends trace events to [PostHog](https://posthog.com/). This allows you to analyze and visualize your application's traces and events in PostHog.

## Installation

```bash
pip install posthog-otel-exporter
```

## Configuration

You need a PostHog project API key and endpoint. These can be provided as arguments or via environment variables:

- `POSTHOG_API_KEY`: Your PostHog project API key
- `POSTHOG_ENDPOINT`: Your PostHog instance endpoint (e.g., `https://app.posthog.com`)

## Usage with OpenTelemetry

Below is an example of how to use `PosthogSpanExporter` with OpenTelemetry's tracing SDK:

```python
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from posthog_otel_exporter.exporter import PosthogSpanExporter

# Set up the tracer provider
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Configure the Posthog exporter (API key and endpoint can also be set via env vars)
exporter = PosthogSpanExporter(
    posthog_api_key="<your-posthog-api-key>",
    posthog_endpoint="<your-posthog-endpoint>"
)

# Add the exporter to the span processor
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Example span
with tracer.start_as_current_span("example-span") as span:
    span.add_event("event-name", {"key": "value"})
```

### Environment Variables

Alternatively, set the following environment variables:

```bash
export POSTHOG_API_KEY="<your-posthog-api-key>"
export POSTHOG_ENDPOINT="<your-posthog-endpoint>"
```

Then initialize the exporter without arguments:

```python
exporter = PosthogSpanExporter()
```

## License and Contributions

This project is distributed under the [MIT License](./LICENSE).

Contributions are welcome and encouraged, and should follow the guidelines in [CONTRIBUTING.md](./CONTRIBUTING.md).
goro 0.5.1
A TUI-based tool for managing multiple Git repositories in one place with an intuitive interface
Requires Python: >=3.8

# Goro — Git Ops Repo Orchestrator (v0.5.0)

**Goro** (Git Ops Repo Orchestrator) is a blazing-fast **Textual TUI** for managing and syncing **dozens of Git repositories at once** — think *lazygit, but for your entire workspace*.

![Goro screenshot/demo](https://i.ibb.co/CKQYvzCp/goro.png)  
<!-- *TODO: (replace the link above with your own screenshot or short GIF)* -->

### Install

```bash
pip install goro          # or
uv tool install goro
```

### Run

```bash
goro                      # launches the interactive TUI instantly
```

### Core Features

- Manually add any repository path (even weird ones like %APPDATA%, client folders, external drives…)- Bulk sync (`add → commit → pull → push`) for selected or all repos
- Live status grid with branch, ahead/behind, and dirty indicators
- Add, edit, rename, and remove repositories interactively
- Real-time command output with progress bars
- Full CLI fallback (`goro sync-all`, `goro status my-repo`, etc.)
- Cross-platform (Windows • macOS • Linux)

### TUI Quick Keys

| Key       | Action                     |
|-----------|----------------------------|
| `a`       | Add repository             |
| `s` / `S` | Sync selected • all repos  |
| `t`       | Show detailed git status   |
| `F2`      | Edit / rename repository   |
| `c`       | Clear logs                 |
| `q`       | Quit                       |

### Full CLI Reference & Changelog
→ https://gitlab.com/user4302_Projects/coding/python/textual/goro/-/blob/main/CHANGELOG.md

### Project Homes

| Platform   | Purpose                                  | Link                                                                      |
|------------|-------------------------------------------|---------------------------------------------------------------------------|
| **GitLab** | Source of truth • Issues • MRs • CI/CD    | https://gitlab.com/user4302_Projects/coding/python/textual/goro           |
| **GitHub** | Mirror for discoverability & extra stars  | https://github.com/user4302/goro                              |

> **Please file issues and feature requests on GitLab** — that’s where I actively track and fix everything.  
> GitHub mirror is kept in sync automatically.

**License** — MIT  
**Built with** — Textual • Typer • uv • Hatch • Python 3.8+

⭐ **Star on whichever platform you prefer** — every star helps!  
(If you star both, I won’t complain 😉)
eoxelements 0.2.15
Jupyter notebook wrapper for EOxElements web components
Requires Python: >=3.8

# EOxElements Jupyter

A minimal Python package for using [EOxElements web components](https://github.com/EOX-A/EOxElements/) inside Jupyter Notebooks. Inspired by ipyleaflet and ipyopenlayers, this package provides a simple API for inclduing EOxElements.

## Features
- Easy-to-use Python wrappers for EOxElements web components
- Version pinning for JS components via CDN
- Designed for use in Jupyter Notebooks

## Installation

```bash
pip install eoxelements
```

> **Note:** In Jupyter, you might need to restart the kernel/server before continuing after installing.

## Usage

```python
from eoxelements import EOxMapWithControl

# Define map layers
map_layers = [
    {
        "type": "Tile",
        "properties": {"id": "osm", "title": "OSM"},
        "source": {"type": "OSM"},
    }
]

# Create and display the widget
m = EOxMapWithControl(layers=map_layers)
display(m)
```

## Development & Release Automation
- JS component versions are pinned in `eoxelements/_version.py` and updated via CI/CD.
- Publishing to PyPI is automated using GitHub Actions (`.github/workflows/publish.yml`).

## License
MIT
PiQR 0.1.6
A Python library for generating and displaying QR codes.
Requires Python: >=3.8

# Project Title

QR generator tool that returns either a PNG, postscript file, or a postscript object of an input string

## Description

I created this QR generator tool with the express purpose of generating custom QR codes for PDFs without the need for an adobe subscription. The returned postscript data can be used to place into a prewritten postscript file and then converted into a PDF using ghostscript. 

## Getting Started

### Dependencies

* In order to generate a QR image you will require both cv2 and numpy
  ```sh
  pip install opencv-contrib-python
  pip install numpy
  ```

### Installing

* Clone the repo
  ```sh
  git clone https://github.com/PimpDiCaprio/PiQR.git
  ```
* Installing with pip
  ```sh
  pip install PiQR
  ```

### Executing program

* How to run the program
* Step-by-step bullets
```
from PiQR import PiQR

# define the input string for the qr code
qr_string = 'Test Input'

# generate qr binary for the input string
qr_output = PiQR.generate_qr(qr_string, correction_level='Medium')

# the following options are available for displaying or saving the qr code

# display the qr code
PiQR.show_png(qr_output)

# save the qr as a png
PiQR.make_png(qr_output, 'test.png')

# write a postscript file containing the qr
PiQR.write_ps(qr_output, 'test.ps')

# return a postscript object in string form for placement into a ps file
ps_string = PiQR.return_ps(qr_output)

```

## Author

  PimpDiCaprio
  info@aperturesoftware.us

## Version History

* 0.1.1
    * Import Name Fixes
* 0.1.0
    * Initial Release
* 0.1.2
    * Update to module size designation in qr_ps
* 0.1.3
    * Fixed broken byte conversion for Alphanumeric QR generation
* 0.1.4
    * Update to data_analysis, added json storage for the dictionaries to clean up the code
* 0.1.5
    * Fixed broken project upload
* 0.1.6
    * Fixed missing json file

## License

This project is licensed under the MIT License - see the LICENSE.md file for details

## Acknowledgments

Inspiration, code snippets, etc.
* [Thonky's QR Code Tutorial](https://www.thonky.com/qr-code-tutorial/introduction)
* [General Resource QR Wiki](https://en.wikipedia.org/wiki/QR_code)
* [QR Creation Tool with Steps](https://www.nayuki.io/page/creating-a-qr-code-step-by-step)