semvec/pypi-packages huggingface dataset:
py_sma_modbus 0.2.0
This package can be used to read values from a SMA inverter through Modbus TCP.
Requires Python: <4.0,>=3.12

# py-sma-modbus

This project is based on [maluramichael py-sma-modbus](https://github.com/maluramichael/py-sma-modbus) and [StefanLSA py-sma-modbus2](https://github.com/StefanLSA/py-sma-modbus2) with the goal to make it more slim and available as a package.

If you prefer to use the functionality through a cli, I encourage you to use one of the above mentioned projects.
This implementation is intended to be used as part of a larger code-base.

The solution is tested on my local sma inverter for some registers.
I cannot guarantee full functionality and use this package, as always, on your own risk.

## Example

```python
from py_sma_modbus.modbus import Modbus
from py_sma_modbus.registers import Register

wr = Modbus(ipAdress="ip-address of the inverter, e.g. 192.168.178.12", ipPort=502, modbusUnit=3)

wr.poll_register(30535)
wr.poll_register(30531)

responses: list[Register] = wr.run()

for response in responses:
    print(response.value)
```
wea-display-schema 1.0.0
wea-display Data-Model Objects

[![Build Status](https://github.com/wea-tools/wea-display-schema/workflows/CI/badge.svg)](https://github.com/wea-tools/wea-display-schema/actions)

[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)

# wea-display-schema

wea-display Data-Model Objects

wea显示数据模型对象

## Installation

```console
pip install wea-display-schema
```

## QuickStart

```python
import wea_display_schema

```

## API Documentation

[Geometry Schema](https://wea-tools.github.io/wea-display-schema/geometry.html)

[Display Schema](https://wea-tools.github.io/wea-display-schema/display.html)

## Local Development

1. Clone this repo locally

```console
git clone git@github.com:wea-tools/wea-display-schema

# or

git clone https://github.com/wea-tools/wea-display-schema
```

2. Install dependencies:

```console
cd wea-display-schema
pip install -r dev-requirements.txt
pip install -r requirements.txt
```

3. Run Tests:

```console
python -m pytest tests/
```

4. Generate Documentation:

```python
python ./docs.py
```
axcontrol 0.1.6
AxControl is a Windows 10/11 UI Automation tool developed by aubex Gmbh, Hockenheim.
Requires Python: >=3.10

# axcontrol - aubex control

This project is a Windows UI automation tool that provides users some helpers and tools and allows to generate Python code for UI interactions by simply clicking on elements in any application. It uses UI Automation to detect controls, highlights them in real-time, and generates corresponding Python code for interacting with these controls.

## Features

- Real-time control detection and highlighting
- Code generation for UI interactions
- Modular architecture for easy extension and maintenance

## Requirements

- Python 3.10+
- tkinter
- pyperclip
- uiautomation
- pynput

## Installation

`pip install axcontrol` 

## Project Structure

- `main.py`: The entry point of the application
- `gui.py`: GUI-related code
- `listeners/input.py`: Mouse and keyboard event handling
- `control_finder.py`: Control finding and highlighting logic
- `code_generator.py`: Code generation and file writing
- `clipboard_utils.py`: Clipboard-related functions

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the APACHE2 License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

- Thanks to the creators of the `uiautomation`, the other dependencies and of course the `Python community` for making `axcontrol` possible.
avcheck 0.1.2
Python library to interact with AvCheck API
Requires Python: >=3.6

# AvCheck Python Library

## Overview
A Python library to interact with the AvCheck API. This library provides methods to retrieve service information, get task data, and create new tasks.

## Installation
```sh
pip install avcheck
```

## Usage
```python
from avcheck import AvCheckClient, AvCheckException, InvalidInputException

api_key = "your_api_key"
client = AvCheckClient(api_key)

# Get service information
try:
    service_info = client.get_service_info()
    print(service_info)
except AvCheckException as e:
    print(f"Error: {e}")

# Get task data
try:
    task_data = client.get_task_data("task_id")
    print(task_data)
except InvalidInputException as e:
    print(f"Invalid Input: {e}")
except AvCheckException as e:
    print(f"Error: {e}")

# Create a new task
try:
    task_id = client.create_new_task(file_path="path/to/file")
    print(f"New task created with ID: {task_id}")
except InvalidInputException as e:
    print(f"Invalid Input: {e}")
except AvCheckException as e:
    print(f"Error: {e}")

# Get engines status
try:
    engines_status = client.get_engines_status(task_data)
    print(engines_status)
except AvCheckException as e:
    print(f"Error: {e}")

# Get file detection status
try:
    file_detection_status = client.get_file_detection_status(task_data, "file_name")
    print(file_detection_status)
except AvCheckException as e:
    print(f"Error: {e}")

# Check if a specific engine detected a threat
try:
    detected = client.did_engine_detect(task_data, "engine_name", "file_name")
    print(detected)
except AvCheckException as e:
    print(f"Error: {e}")

# Extract array from data
try:
    array_data = client.extract_array_from_data(task_data, "key")
    print(array_data)
except AvCheckException as e:
    print(f"Error: {e}")

# Get all engines
try:
    all_engines = client.get_all_engines(service_info)
    print(all_engines)
except AvCheckException as e:
    print(f"Error: {e}")

# Get engine by name
try:
    engine_details = client.get_engine_by_name(service_info, "avast")
    print(engine_details)
except AvCheckException as e:
    print(f"Error: {e}")

# Get engines by type
try:
    type_3_engines = client.get_engines_by_type(service_info, 3)
    print(type_3_engines)
except AvCheckException as e:
    print(f"Error: {e}")

# Check if an engine is available
try:
    is_available = client.is_engine_available(service_info, "avast")
    print(is_available)
except AvCheckException as e:
    print(f"Error: {e}")

# Get engine names
try:
    engine_names = client.get_engine_names(service_info)
    print(engine_names['shortname'])
    print(engine_names['longname'])
except AvCheckException as e:
    print(f"Error: {e}")
```

## License
MIT License
```