semvec/pypi-packages huggingface dataset:
moviz 0.4.3
Motion visualization tool for humanoid robots
Requires Python: >=3.11
Keywords: robotics, visualization, motion

# mviz

Motion visualization tool for humanoid robots.

## Features

- Motion data visualization
- Robot model visualization  
- Real-time motion playback
- Support for Unitree G1 robot models

## Installation

```bash
pip install mviz
```

### Development setup

```bash
# please use python version >= 3.11
conda create -n mviz python==3.11
pip install -e .
```

## Usage

```bash
mviz
```
twitchio 3.2.1
A powerful, asynchronous Python library for twitch.tv.
Requires Python: >=3.11

![](https://raw.githubusercontent.com/TwitchIO/TwitchIO/main/logo.png)
[![](https://img.shields.io/badge/Python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue.svg)](https://www.python.org)
![Pyright Strict](https://img.shields.io/badge/Pyright-Strict-b8dbb4)
![GitHub License](https://img.shields.io/github/license/PythonistaGuild/twitchio)

A fully featured, powerful async Python library for the Twitch API and EventSub with modern Object-Orientated design
and stateful objects.

TwitchIO provides ease of use when accessing the Twitch API with powerful extensions for chat commands, web-frameworks and overlays 
with hot-reloadable modules to help create and manage bots, backends, websites and other applications on Twitch.

**Features:**

- Modern ``async`` Python using ``asyncio``
- Fully annotated and complies with the ``pyright`` strict type-checker
- Intuitive with ease of use, using modern object orientated design
- Conduit support for scaling and EventSub continuity
- Feature full including extensions for ``chat bots``, running ``routine tasks`` and ``overlays`` on stream
- Easily manage ``OAuth Tokens`` and data
- Built-in ``EventSub`` support via ``Webhook``, ``Websockets`` and ``Conduits``.

### Documentation
[Documentation](https://twitchio.dev/)
   
Getting Started
--------------------------------
[Installing](https://twitchio.dev/en/latest/getting-started/installing.html)

[Quickstart](https://twitchio.dev/en/latest/getting-started/quickstart.html)

[Examples](/examples)

Useful Links
--------------
[Scope/OAuth URL Generator](https://chillymosh.com/tools/twitch/twitch-scopes)

[Twitch API Documentation](https://dev.twitch.tv/docs/)

[Twitch Developer Console](https://dev.twitch.tv/console)

### Support
For support using TwitchIO, please join the official [support server](https://discord.gg/RAKc3HF) on [Discord](https://discord.com/)

[![Discord Banner](https://discordapp.com/api/guilds/490948346773635102/widget.png?style=banner2)](https://discord.gg/RAKc3HF)
django-zato-plugin 4.1.4
Django plugin for Zato
Requires Python: >=3.12

# django-zato-plugin

A client library for invoking Zato services from Django applications.

Zato is an integration platform that orchestrates and automates your to APIs, databases, queues, and other systems.

Learn more here: https://zato.io

With this plugin, Django delegates integration work to Zato - your views call Zato services,
Zato handles the rest. Less code in Django, all integrations in one place.

## Installation

```bash
pip install django-zato-plugin
```

## Configuration

Add to your Django settings:

```python
ZATO_URL = 'http://localhost:17010/django'
ZATO_USERNAME = 'django'
ZATO_PASSWORD = 'password' # Use your Zato password, e.g. from the Zato_Password env. variable
```

## API

The client exposes one method:

**response = client.invoke(service, data=None)**

- **service** - name of the Zato service to invoke (string)
- **data** - request data to send (dict or None)

Returns the response from the Zato service as a dict.

## Usage

Let's say you have a frontend with a cybersecurity automation UI and you want to invoke a couple
of backend services using JSON.

Here's how it would look like:

```python
# views.py
from django.http import JsonResponse
from django_zato import client

def block_ip(request):

    # Extract the request ..
    ip_address = request.POST['ip_address']
    reason = request.POST['reason']

    # .. block on firewall and get the response ..
    firewall_response = client.invoke('firewall.block-ip', {'ip_address': ip_address})
    rule_id = firewall_response['rule_id']

    # .. log incident in SIEM ..
    siem_response = client.invoke('siem.log-incident', {
        'ip_address': ip_address,
        'reason': reason,
        'action': 'blocked',
        'firewall_rule_id': rule_id,
    })

    # .. Extract the response from SIEM ..
    incident_id = siem_response['incident_id']

    # .. and return the response to the frontend.
    return JsonResponse({
        'status': 'ok',
        'firewall_rule_id': rule_id,
        'siem_incident_id': incident_id,
    })
```
monee 1.1.0
Framework for calculating the steady-state energy flow and for solving optimization problems in coupled energy grids (gas, heat, electricity)
Requires Python: >=3.10

<p align="center">

![logo](docs/source/_static/monee-logo.drawio.svg)

</p>

[PyPi](https://pypi.org/project/monee/) | [Docs](https://monee.readthedocs.io)

![lifecycle](https://img.shields.io/badge/lifecycle-maturing-blue.svg)
[![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/Digitalized-Energy-Systems/monee/blob/development/LICENSE)
[![Test mango-python](https://github.com/Digitalized-Energy-Systems/monee/actions/workflows/test-monee.yml/badge.svg)](https://github.com/Digitalized-Energy-Systems/monee/actions/workflows/test-monee.yml)
[![codecov](https://codecov.io/gh/Digitalized-Energy-Systems/monee/graph/badge.svg?token=KSBSBQGNBZ)](https://codecov.io/gh/Digitalized-Energy-Systems/monee)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Digitalized-Energy-Systems_monee&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Digitalized-Energy-Systems_monee)

The python project `monee` (a Modular Network-based Energy Grid Optimization) can be used to calculate the steady-state energy flow of coupled grids (electricity, water (heating), gas). It is also capable to flexibly formulate and solve optimal energy flow problems. For this `monee` currently uses [GEKKO](https://gekko.readthedocs.io/en/latest/) to solve these problems (further integrations are planned).

Further, there are unique key aspects of monee such as:
* Timeseries simulation
* Native support of multi-energy components as P2H/CHP/P2G
* Integration of networkx as main internal datastructure, this enables easy appliance of graph-based approaches.
* Modular component definitions
* Importing of MATPOWER networks
* Restricted import of [pandapower](pandapower.org) and therefore [simbench](simbench.de) networks.

# Installation

The `monee` framework is hosted on pypi, as such you can install it with:

```bash
pip install monee
```

# Examples

## Creating a network (express API)

```python
from monee import mx, run_energy_flow

# create multi-grid container the monee.Network
net = mx.create_multi_energy_network()

# electricity grid
bus_0 = mx.create_bus(net)
bus_1 = mx.create_bus(net)

mx.create_line(net, bus_0, bus_1, 100, r_ohm_per_m=0.00007, x_ohm_per_m=0.00007)
mx.create_ext_power_grid(net, bus_0)
mx.create_power_load(net, bus_1, 0.1, 0)

# water-based district heating grid
junc_0 = mx.create_water_junction(net)
junc_1 = mx.create_water_junction(net)
junc_2 = mx.create_water_junction(net)

mx.create_ext_hydr_grid(net, junc_0)
mx.create_water_pipe(net, junc_0, junc_1, diameter_m=0.12, length_m=100)
mx.create_sink(net, junc_2, mass_flow=1)

# creating connection between el and water grid
mx.create_p2h(net, bus_1, junc_1, junc_2, heat_energy_mw=0.1, diameter_m=0.1, efficiency=0.9)

# execute an energy flow calculating the energy flow for the whole MES
result = run_energy_flow(net)
```