semvec/pypi-packages huggingface dataset:
helixtelemetry 1.0.10
helixtelemetry
Requires Python: >=3.10

# Helix Telemetry

## Overview

Helix Telemetry is a Python package that provides an easy way to use telemetry across processes with support for attribute inheritance. This library simplifies tracking and managing telemetry information in complex Python applications.

## Features

- Cross-process telemetry tracking
- Attribute inheritance support
- Lightweight and easy to integrate
- Designed for flexible observability

## Installation

You can install Helix Telemetry using pip:

```bash
pip install helix-telemetry
```
another-ayx-plugin-cli 2.0.2
Command Line Interface for Alteryx Plugin Development
Requires Python: >=3.8

# Another Alteryx Plugin CLI

A command-line interface tool for developing Alteryx plugins using the Alteryx Python SDK.

## Overview

The Another Alteryx Plugin CLI provides a streamlined workflow for creating, testing, and deploying Alteryx plugins. It helps developers manage their plugin development workspace, generate necessary files, and package their plugins for distribution.

## Features

- Initialize a new Alteryx SDK workspace
- Create new plugins with various input/output configurations
- Generate UI components for plugins
- Generate test files
- Create and install YXI packages
- Update tool help URLs
- Version management and updates

## Installation

```bash
pip install another-ayx-plugin-cli
```

## Requirements

- Python 3.7 or higher
- Node.js (for UI generation)
- NPM (for UI generation)

## Usage

### Initialize a Workspace

```bash
another-ayx-plugin-cli sdk-workspace-init
```

This will prompt you for:
- Package Name
- Tool Category
- Description
- Author
- Company
- Backend Language

### Create a New Plugin

```bash
another-ayx-plugin-cli create-ayx-plugin
```

This will prompt you for:
- Tool Name
- Tool Type
- Output Data Settings
- Description
- Tool Version
- DCM Namespace
- UI Generation Options

### Generate UI Components

```bash
another-ayx-plugin-cli generate-ui [tool-name]
```

### Generate Tests

```bash
another-ayx-plugin-cli generate-tests [tool-name]
```

### Create YXI Package

```bash
another-ayx-plugin-cli create-yxi
```

### Install to Designer

```bash
another-ayx-plugin-cli designer-install
```

## Tool Types

The CLI supports various tool types:
- Single Input Single Output
- Multiple Inputs
- Multiple Outputs
- Input
- Output
- Optional
- Multiple Input Connections

## Development

### Project Structure

```
.
├── ayx_workspace/     # Workspace configuration and models
├── assets/           # Static assets
├── backend/          # Backend code
├── configuration/    # Tool configuration files
├── ui/              # UI components
└── tests/           # Test files
```

### Dependencies

- typer: CLI framework
- pydantic: Data validation
- packaging: Version handling
- jinja2: Template engine
- requests: HTTP client

## License

Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT. See the LICENSE file for details.

## Support

For support, please visit [Alteryx Developer Help](https://help.alteryx.com/developer-help).
botoprune 1.1.0
Reduce the installed size of botocore by removing unnecessary AWS api data.
Requires Python: >=3.9
Keywords: botocore, boto3, boto-prune, botoprune, boto-trim, bototrim

# Botoprune
Botoprune is a Python library used to reduce the installed size of botocore by removing unnecessary AWS api data.

## Using Botoprune

The chief application of this library is in the building of small Docker images. Because docker images are built in layers, any file created in one layer still takes up spaces in the final image. This means that Botoprune must be run in the same RUN instruction that installs boto3/botocore preventing the unnecessary data from being committed to the final layer.

```
# Docker step to install boto3 and remove all API data except s3, ec2, and kms.
RUN pip install --no-cache-dir --no-compile \
        boto3 \
        botoprune && \
    python -m botoprune.whitelist s3 ec2 kms
```

Botoprune also supports more targeted removal of specific services. This offers more control but results in less space savings compared to whitelisting.

```
   # Remove the API data for bedrock, rds, and sts.
   python -m botoprune.remove bedrock rds sts
```
goedge-core-sdk-python 0.1.1
GoEdge Core SDK Python Wrapper
Requires Python: >=3.8

# GoEdge Core SDK Python Wrapper

This project provides a Python wrapper for the GoEdge Core C SDK. It uses `ctypes` to interface with the C library, allowing Python applications to leverage the functionality of the GoEdge ecosystem.

## Project Structure

```
goedge-core-sdk-python/
├───.gitignore
├───poetry.lock
├───pyproject.toml
├───README.md
├───dist/                 # 打包分发文件
├───example/              # 示例代码
│   ├───example_function.py
│   └───example.py
└───src/                  # Python SDK 源码
    └───goedge/
        ├───__init__.py
        ├───core.py
        └───ge_storage.py
```

## Installation

To use this wrapper, you first need to compile the C SDK into a shared library (e.g., `libge-core.so` and `libge-storage.so` on Linux). Then, you can install the Python package using Poetry:

```bash
poetry install
```

## Usage

The following example demonstrates the basic flow of initializing the SDK, registering a device, reporting properties, and shutting down.

```python
# -*- coding: utf-8 -*-

import sys
import os
import time
from goedge.core import (
    core_init, core_exit,
    register_and_online_by_device_name, device_offline,
    report_properties,
    GeDeviceData, GeDeviceCallback,
    GET_PROPERTIES_CALLBACK, SET_PROPERTIES_CALLBACK, CALL_SERVICE_CALLBACK, TRIGGER_COLLECT_CALLBACK,
    GE_TYPE_INT
)

# 1. Define callback functions (implementation omitted for brevity)
# def handle_get_properties(...): ...
# def handle_set_properties(...): ...
# def handle_call_service(...): ...
# def handle_trigger_collect(...): ...

if __name__ == "__main__":
    # 2. Initialize the SDK
    ret = core_init("NodeRED", 4, 7)
    if ret != 0:
        print(f"Failed to initialize SDK, error code: {ret}")
        exit(1)

    # 3. Create and fill the callback structure
    device_callbacks = GeDeviceCallback(...) # Omitted for brevity

    # 4. Register and bring the device online
    product_key = "BSKjAAhUmor"
    device_name = "BSKjAAhUmor"
    dev_handle = register_and_online_by_device_name(product_key, device_name, device_callbacks)

    if dev_handle < 0:
        print(f"Failed to register device, error code: {dev_handle}")
        core_exit()
        exit(1)

    try:
        # 5. Loop to report properties
        count = 0
        while count < 20:
            temp_property = GeDeviceData(
                type=GE_TYPE_INT,
                key=b"temperature",
                value=str(20 + count % 10).encode(),
                timestamp=int(time.time() * 1000)
            )
            report_properties(dev_handle, [temp_property])
            time.sleep(2)
            count += 1
    finally:
        # 6. Take the device offline and exit
        device_offline(dev_handle)
        core_exit()
```