semvec/pypi-packages huggingface dataset:
odoo-addon-converter 18.0.7.2.0
Odoo addon to convert records to and from plain data structures
Requires Python: >=3.11
Keywords: odoo

=========
Converter
=========

.. |maturity| image:: https://img.shields.io/badge/maturity-Stable-green.png
    :target: https://odoo-community.org/page/development-status
    :alt: Stable
.. |license| image:: https://img.shields.io/badge/licence-AGPL--3-blue.svg
    :target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
    :alt: License: AGPL-3
.. |ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff
.. |prettier| image:: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
    :target: https://github.com/prettier/prettier
    :alt: Prettier

|maturity| |license| |ruff| |prettier|

Convert odoo records to/from plain data structures.

section *schema-validation* need to be installed if validation is needed.
zalando-kubectl 1.34.4.376
Kubectl wrapper in Python with OAuth token auth
Requires Python: >=3.11

# Zalando Kubectl

## Description

[![PyPI Downloads](https://img.shields.io/pypi/dw/zalando-kubectl.svg)](https://pypi.python.org/pypi/zalando-kubectl/)

[![Latest PyPI version](https://img.shields.io/pypi/v/zalando-kubectl.svg)](https://pypi.python.org/pypi/zalando-kubectl/)
[![License](https://img.shields.io/pypi/l/zalando-kubectl.svg)](https://pypi.python.org/pypi/zalando-kubectl/)

Kubernetes CLI (kubectl) wrapper in Python with OAuth token authentication.

This wrapper script `zkubectl` serves as a drop-in replacement for the
`kubectl` binary:

-   it downloads the current `kubectl` binary from Google
-   it generates a new `~/.kube/config` with an OAuth Bearer token
    acquired via [zign](https://pypi.python.org/pypi/stups-zign).
-   it passes through commands to the `kubectl` binary

## User Facing documentation

- https://cloud.docs.zalando.net/reference/zkubectl/
- https://cloud.docs.zalando.net/howtos/install-tools/

## Contribute

### Setup project

- It's recommended to use [uv](https://github.com/astral-sh/uv) for the project.

Go to the project dir and install dependencies with uv

``` bash
$ cd <project-path>
$ uv sync
```

- [Optional] install pre-commit hooks

```bash
$ pre-commit install
```

- [Optional] The project uses [ruff](https://docs.astral.sh/ruff/) for
code formatting, configure your editor to use it.


### Unit Tests

Run unit tests with Docker:

``` bash
docker build --build-arg PYTHON_VERSION=3.10 --build-arg PACKAGE_NAME=zalando_kubectl -f Dockerfile.test .
docker build --build-arg PYTHON_VERSION=3.11 --build-arg PACKAGE_NAME=zalando_kubectl -f Dockerfile.test .
docker build --build-arg PYTHON_VERSION=3.12 --build-arg PACKAGE_NAME=zalando_kubectl --build-arg DEBIAN_DISTRO=bullseye -f Dockerfile.test .
docker build --build-arg PYTHON_VERSION=3.13 --build-arg PACKAGE_NAME=zalando_kubectl --build-arg DEBIAN_DISTRO=bullseye -f Dockerfile.test .
```

### Run Locally

via uv

``` bash
$ uv run zkubectl
```

Or first activate the virtualenv

```bash
$ source .venv/bin/activate
$ zkubectl login playground
```

### Use as `kubectl` plugin

The project exposes scripts that use the `kubectl` plugin format

You can see which ones are available in the scripts section of [pyproject.toml](pyproject.toml)

In order for `kubectl` to detect the subcommands provided by the script, they must be in the PATH, so you need first to activate the virtualenv

```bash
$ source .venv/bin/activate
$ kubectl login playground
```
maphub 0.2.16
A Python wrapper for the MapHub API
Requires Python: >=3.12

# MapHub

[![PyPI Version](https://img.shields.io/pypi/v/maphub.svg)](https://pypi.org/project/maphub/)
[![PyPI Downloads](https://img.shields.io/pypi/dm/maphub.svg?label=PyPI%20downloads)](
https://pypi.org/project/maphub/)


## Installation
### pip
```sh 
pip install maphub
```

## Usage

### Python package
This example demonstrates how to upload a Map from the local path to a MapHub folder with the name `France`.
```python 
from maphub import MapHubClient

client = MapHubClient(api_key="your-api-key")
personal_workspace = client.workspace.get_personal_workspace()
root_folder = client.folder.get_root_folder(personal_workspace["id"])
france_folder = client.folder.create_folder("France", root_folder["folder"]["id"])

client.maps.upload_map(
    map_name="France Population",
    folder_id=france_folder['id'],
    public=False,
    path="path/to/GIS/data.gpkg"
)
```

> **Note**: The direct endpoint methods (e.g., `client.create_project()`, `client.upload_map()`) are deprecated and will be removed in a future version. Use the endpoint classes instead (e.g., `client.folder.create_folder()`, `client.map.upload_map()`).

### CLI
The MapHub CLI provides a command-line interface for interacting with the MapHub API. It allows you to authenticate with an API key and upload maps to your folders.

#### Authentication
Before using the CLI, you need to authenticate with your MapHub API key:

```sh
maphub auth YOUR_API_KEY
```

This will save your API key to `~/.maphub/config.json` for future use.

#### Uploading Maps
To upload a GIS file to your root folder:

```sh
maphub upload path/to/your/file.gpkg
```

The map name will be extracted from the file name (without extension).

To upload a GIS file to a specific folder:

```sh
maphub upload path/to/your/file.gpkg --folder-id YOUR_FOLDER_ID
```

If you don't specify a folder ID, the map will be uploaded to your root folder.

To upload a GIS file with a custom map name:

```sh
maphub upload path/to/your/file.gpkg --map-name "My Custom Map Name"
```

If you don't specify a map name, it will be extracted from the file name (without extension).

#### Cloning Maps and Folders
To clone a folder from MapHub to your local machine:

```sh
maphub clone FOLDER_ID
```

This will clone the folder to the current directory.

To specify an output directory:

```sh
maphub clone FOLDER_ID --output path/to/output/directory
```

#### Pulling Changes
To pull the latest changes from MapHub to your local clone:

```sh
maphub pull
```

This command should be run from within a directory that was previously cloned. It will update any maps that have changed on the server.

#### Pushing Changes
To push your local changes back to MapHub:

```sh
maphub push
```

This command should be run from within a directory that was previously cloned. It will upload any maps that have changed locally.
agent-sessions 0.1.0
Discover and inspect local AI coding agent sessions
Requires Python: >=3.11
Keywords: agent, ai, claude, codex, discovery, sessions

# agent-sessions

Discover and inspect local AI coding agent sessions (Claude Code, Codex, Pi).

> Looking for a ready-made solution for supervising your agents? Check out [Tether](https://github.com/larsderidder/tether).

```python
from agent_sessions import discover_sessions, get_session_detail, RunnerType

# Find all recent sessions
sessions = discover_sessions()
for s in sessions:
    print(f"{s.runner_type.value}: {s.directory} ({s.message_count} messages)")

# Filter by agent type
claude_sessions = discover_sessions(runner_type=RunnerType.CLAUDE_CODE)

# Filter by project directory
project_sessions = discover_sessions(directory="/home/user/my-project")

# Load full message history
detail = get_session_detail(sessions[0].id, sessions[0].runner_type)
for msg in detail.messages:
    print(f"[{msg.role}] {msg.content[:80]}")
```

## What it discovers

| Agent | Session location | Format |
|-------|-----------------|--------|
| Claude Code | `~/.claude/projects/` | JSONL per session |
| Codex | `~/.codex/sessions/` | JSONL rollout files |
| Pi | `~/.pi/agent/sessions/` | JSONL per session |

Each provider also detects whether sessions are currently running by inspecting the process table.

## Install

```bash
pip install agent-sessions
```

## License

MIT
stacklet.client.sinistral 0.5.34
Sinistral CLI
Requires Python: <4,>=3.10.2

# Sinistral CLI

## Setup

```
$ just install
```

Create a config file at `~/.stacklet/sinistral/config.json`:

```json
{
  "api": "https://api.sinistral.stacklet.io",
  "region": "us-east-1",
  "cognito_client_id": "5bogrjv9om1tjhfsd1c8d2kouo",
  "cognito_user_pool_id": "us-east-1_F4Ca4BFQS",
  "idp_id": "idp-4a301a48-cd63-4c6c-caf7-419c5b0ee737",
  "auth_url": "https://auth.sinistral.stacklet.io"
}
```

Login with a cognito user:

```
$ sinistral login --username $USER --password $PASSWORD
```

Or, login with SSO:

```
$ sinistral login
```

Run your first command:

```
$ sinistral projects list
```

Python client:

```python
from stacklet.client.sinistral.client import sinistral_client

sinistral = sinistral_client()
policy_client = sinistral.client('policies')
print(policy_client.list())
```
megadetector-utils 10.0.18
Utility code associated with the MegaDetector project.
Requires Python: <3.14,>=3.9
Keywords: camera traps, conservation, wildlife, ai, megadetector

# megadetector-utils

This package is a pip-installable version of <b>just the utility code</b> from the [MegaDetector](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector) repository.  In other words, this package contains everything in the [megadetector](https://pypi.org/project/megadetector/) package <i>except</i> the PyTorch/YOLO dependencies.  If you want to run MegaDetector, you don't want the megadetector-utils package.  If you just want to use the tools for, e.g., postprocessing, manipulating large sets of camera trap images, etc., this package may be useful; it's a much quicker install than the megadetector package.

Version numbers are generally synchronized with the megadetector package.

## Installation

Install with:

`pip install megadetector-utils`

## Package reference

See [megadetector.readthedocs.io](https://megadetector.readthedocs.io).

## Contact

Contact <a href="cameratraps@lila.science">cameratraps@lila.science</a> with questions.

## Gratuitous animal picture

<img src="https://github.com/agentmorris/MegaDetector/raw/main/images/orinoquia-thumb-web_detections.jpg"><br/>Image credit University of Minnesota, from the [Orinoquía Camera Traps](http://lila.science/datasets/orinoquia-camera-traps/) data set.
goad-py 1.1.12
Physical optics light scattering computation
Requires Python: >=3.11

<div align="center">

<!-- badges: start -->
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Crates.io](https://img.shields.io/crates/v/goad)](https://crates.io/crates/goad)
[![docs.rs](https://img.shields.io/docsrs/goad)](https://docs.rs/goad)
[![PyPI](https://img.shields.io/pypi/v/goad-py)](https://pypi.org/project/goad-py/)
<!-- badges: end -->

</div>

# GOAD - Geometric Optics with Aperture Diffraction

GOAD is a Rust-based physical-optics hybrid light scattering model based on geometric optics with aperture diffraction. It computes the 2D Mueller matrix by using geometric optics and a polygon clipping algorithm to compute the electric field on the particle surface. The surface field is then mapped to the far-field on the basis of the electromagnetic equivalence theorem, which takes the form of a vector surface integral diffraction equation. Green's theorem is used to reduce the surface integral to a line integral around the contours of outgoing beam cross sections, which leads to fast computations compared to some other methods. Compared to the [PBT](https://github.com/hballington12/pbt) method, GOAD uses a beam clipping algorithm instead of ray backtracing on a meshed geometry, which makes the computation more accurate and faster if the particle has smooth planar surfaces.

<div align="center">

> **📖 Reference Paper**
> If you use this code in your work, please cite:
> [A Light Scattering Model for Large Particles with Surface Roughness](https://doi.org/10.1016/j.jqsrt.2024.109054)
> *H. Ballington, E. Hesse*
> [JQSRT, 2024](https://www.journals.elsevier.com/journal-of-quantitative-spectroscopy-and-radiative-transfer)

</div>

---

For documentation, see the [wiki](https://hballington12.github.io/goad/).