semvec/pypi-packages huggingface dataset:
iap-messenger 1.5.6
Messaging service package for IA PARC
Requires Python: >=3.10

# iap_messenger


[![PyPI version](https://badge.fury.io/py/iaparc-inference.svg)](https://badge.fury.io/py/iaparc-inference)
![PyPI - License](https://img.shields.io/pypi/l/iaparc-inference)


The IA Parc inference plugin allows developers to easily integrate their inference pipeline into IA Parc's production module.   


## Installation

```bash
pip install iaparc-inference
```

## Usage

* If your inference pipeline support batching:
  
    ```python
    from iap_messenger import MsgListener, Message

    # Define a callback to query your inference pipeline
    # To load your model only once it is recommended to use a class:
    class MyModel:
        def __init__(self, model_path: str):
            ## Load your model in pytorch, tensorflow or any other backend
        
        def batch_query(msgs: list[Message]) -> list[Message]:
            ''' execute your pipeline on a batch input
                Note:   "parameters" is an optional argument.
                        It can be used to handle URL's query parameters
                        It's a list of key(string)/value(string) dictionaries
            '''

    if __name__ == '__main__':
        # Initiate your model class
        my_model = MyModel("path/to/my/model")

        # Initiate IAParc listener
        listener = MsgListener(my_model.batch_query)
        # Start the listener
        listener.run()

    ```
* If your inference pipeline **do not** support batching:
  
    ```python
    from iap_messenger import MsgListener, Message

    # Define a callback to query your inference pipeline
    # To load your model only once it is recommended to use a class:
    class MyModel:
        def __init__(self, model_path: str):
            ## Load your model in pytorch, tensorflow or any other backend
        
        def single_query(msg: Message) -> Message:
            ''' execute your pipeline on a single input
                Note:   "parameters" is an optional argument.
                        It can be used to handle URL's query parameters
                        It's a key(string)/value(string) dictionary
            '''

    if __name__ == '__main__':
        # Initiate your model class
        my_model = MyModel("path/to/my/model")

        # Initiate IAParc listener
        listener = MsgListener(my_model.single_query, batch=1)  # Note that batch size is forced to 1 here
        # Start the listener
        listener.run()

## Features
* Dynamic batching
* Autoscalling 
* Support both synchronous and asynchronous queries
* Data agnostic


## License
This project is licensed under the Apache License Version 2.0  - see the Apache [LICENSE](https://www.apache.org/licenses/LICENSE-2.0) file for details.
moat-kv-gpio 0.12.7
1wire connector for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

============
MoaT-kv-gpio
============

MoaT-kv-gpio is a link between GPIO pins and MoaT-kv.

It will

* monitor inputs as specified

* write values that it reads from them to some KV entry

* monitor a KV entry and write any updates to GPIO

* work with MoaT-KV's runner system, either centrally or distributed
moat-box 0.2.3
MoaT support for managing containers
Requires Python: >=3.8
Keywords: MoaT

########
MoaT-Box
########

This module manages boxes, i.e. things you can put other things into.

"Box" is meant to be inclusive. A room is a box. So is a cupboard, or a row
of books. Boxes can be nested, with locations.

Boxes are typed. You can put a cupboard into a room but not vice versa.

Boxes are labelled. A box can have an arbitrary number of labels, though
most of the time it'll have one, or at most two: one with a barcode and a
box number, one with a text that describes the content, or at least reminds
the owner of it.
moat-kv-cal 0.1.7
Calendar management for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

===========
MoaT-KV-Cal
===========

MoaT-KV-Cal is a calendar extension to MoaT-KV.

It can monitor a calendar (or specific entries thereof), publish pending
entries, set alerts, control that they are acknowledged, and escalate
if/when they are not.
moat-link 0.2.43
Message exchange between MoaT instances
Requires Python: >=3.8
Keywords: MoaT

+++++++++
MoaT Link
+++++++++

Moat-Link is a library that distributes messages between several possible
back-ends, channel arrangements or encodings.

The associated server links these backends into one coherent system,
provide message history, documentation, and whatnot.

Rationale
+++++++++

Often, services have differing ideas how to encode "their" messages.
For instance, Home Assistant likes JSON, except for boolean content which
is encoded as "ON" and "OFF". On the other hand, encodings like msgpack_ or
CBOR_ replace the overhead of textual analysis and repeated division by ten
with typed binary data.


.. _aiomqtt: https://github.com/sbtinstruments/aiomqtt
.. _CBOR: https://cbor.io/
.. _msgpack: https://msgpack.org.

MoaT-KV supported this usecase via its own MQTT server, which is based on
hbmqtt. Unfortunately hbmqtt is unsupported, high-overhead, and doesn't
support MQTT 5. MoaT-KV adds its own overhead and doesn't support
non-retained messages.

Structure
+++++++++

MoaT-Link consists of a couple of related services.

Server
------

The main server records messages in its history, affords redundancy,
can re-supply the MQTT server with retained state, and so on.

Translator
----------

Translators send and receive messages from other channels or topics.

For instance, Home Assistant's default of device state/cmd/control in one
single hierarchy doesn't always mesh well with other systems' ideas.

Errors
------

MoaT-Link supports error handling and recovery.

Web view
--------

Last but not least, we want a HTML front-end for introspection and
debugging.


Message Encoding
++++++++++++++++

MoaT-Link supports various encodings, most notably CBOR and msgpack. Its
native default is CBOR because, unlike msgpack, CBOR's extensions are
simply normal (but tagged) data structures and thus are introspectable.
moat-util 0.61.0
Utility code for the rest of MoaT
Requires Python: >=3.12
Keywords: MoaT

====================
Utilities for Python
====================

This is a Python "util" submodule with code that I habitually use in so
many projects that I decided to split it off into its own git archive.

Feel free to extend and embrace. Patches welcome.


Features
========

A few. Read the code and the subpackages' documentation; I didn't get
around to documenting all of that yet.


License
=======

No restrictions. CC0 / public domain / MIT / GPLv3 / whatever, as long as
you don't want anybody (i.e. the author(s)) to pay for the effects of any
bugs, features or "features" which this code might or might not have.

Please contribute any enhancements.


Dependencies
============

A few. Notable:

* anyio, version 3. Required for `ValueEvent`, `spawn` (obviously) and
  `as_service`.

* ruyaml. This is a fork of ruamel.yaml which is a fork of pyyaml.
  Fixes some bugs and has a more reasonable API. Required for
  `yload`/`yprint`/`yformat`.

* asyncclick, required for `main_`/`wrap_main`.

* Optionally: msgpack.

MoaT does not depend on:

* cbor2. Our implementation is shared with a version running on
  MicroPython and thus needs to be minimal. Also, we want to support
  efficient async streaming.


CBOR tags
=========

see `ref:../common/cbor.rst`.


Paths
=====

MoaT uses `Path` objects as hierarchical object accessors.

A Path is a list of text strings and/or integers that identify an object or
subroutine. For instance, `moat.micro` may connect to an external node
named "ext" with three binary outputs, so you'd call ``"ext" -> 1 -> "set"
(True)`` to turn the second port on.

Since that's somewhat awkward, MoaT paths are typically entered and
displayed as single strings with dots as separators, ``ext:1.set`` in this
case. There's also a secondary representation that uses slashes (``ext/:1/set``)
for interfacing with the file system or MQTT.

See ``pydoc moat.util.path.Path`` for details.
moat-label 0.2.3
MoaT support for printing labels
Requires Python: >=3.8
Keywords: MoaT

##########
MoaT-Label
##########

This module handles label printing.

Labels contain some text and one or two barcodes. One code is a simple
2-of-5 numeric code that takes up as little space as possible. The other is
a Datamatrix code that contains an arbitrary link.

Labels are printed on sheets, then attached to boxes and/or things. A label
can be on one box and/or one thing.
moat-kv 0.71.21
A distributed no-master key-value store
Requires Python: >=3.8
Keywords: MoaT

=======
MoaT-KV
=======

Welcome to `MoaT-KV <https://github.com/MoaT/moat-kv>`__!

MoaT-KV is a master-less distributed key-value storage system. It
circumvents the CAP theorem (you can't have all of consistency, availablilty,
and fault tolerance) using the assumption that a key is typically changed
by one node only. It is thus resistant to partitioning and intended to be
always-on; it will not block or lose updates, even in a partitioned
network.

MoaT-KV comes with several batteries included:

* Basic user management, pattern-based ACLs

* Strong typing, code- and/or `JSON Schema`-based

* Data mangling

* Background code execution

* Seamless recovery even if only one master is running

The underlying communication is based on MQTT. A Serf back-end is also
available. Others are easy to implement.

MoaT-KV was originally called "distkv".

API
===

MoaT-KV offers an efficient msgpack-based interface to access data and to
change internal settings. Most configuration is stored inside MoaT-KV
itself.

Stored data are **not** forced to be strings or binary sequences, but can
be anything that `MsgPack` supports. Keys to storage are multi-level and
support string, integer/float, and tuple keys.


Non-Features
============

MoaT-KV does not support data partitioning. Every node stores the whole
data set and can instantly deliver mostly-uptodate data.

MoaT-KV does not have a disk-based storage backend. Periodic snapshots and
event logs can be used to quickly restore a system, if necessary.

Status
======

MoaT-KV is mostly stable. There are a lot of corner cases that don't
have tests yet.

TODOs:
* some services (esp. command line tools and runners) are under-tested
* there's no good API for errors

TODO
====

* clean up some of the more egregious command line mistakes

* create a page for showcase-ing subprojects (knx owfs akumuli …)

* improve Home Assistant integration
moat-kv-wago 0.8.6
1wire connector for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

============
Moat-KV-Wago
============

MoaT-KV-Wago is a link between WAGO controllers and MoaT-KV.

It will

* add all discovered wago ports

* monitor inputs as specified

* write values that it reads from them to some MoaT-KV entry

* monitor a MoaT-KV entry and write any updates to wago

* work with MoaT-KV's runner system, either centrally or distributed
moat-kv-knx 0.12.4
1wire connector for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

===========
MoaT-KV-KNX
===========

MoaT-KV-KNX is a link between KNX buses and MoaT-KV.

It will

* query and monitor inputs as specified

* write values that it reads from them to some entry in MoaT-KV

* monitor a MoaT-KV entry and write any updates to KNX

* work with MoaT-KV's runner system, either centrally or distributed


Warning
=======

Currently this will only work with MoaT's fork of XKNX because we're using
AnyIO and some other improvements.
moat-kv-akumuli 0.8.9
Akumuli storage connector for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

===========
DistAkumuli
===========

DistAkumuli is a simple link between Akumuli and DistKV.

It will update an Akumuli series whenever a DistKV value changes.
moat-mqtt 0.42.13
Async MQTT broker and client, with optional MoaT-KV support
Requires Python: >=3.8
Keywords: MoaT

MoaT-MQTT
=========

``MoaT-MQTT`` is an open source `MQTT`_ 3.1.1 client and broker
implementation. It is a fork of `hbmqtt`_ with support for `anyio`_ and
`MoaT-KV`_.

MoaT-MQTT provides a straightforward API based on coroutines, making it easy
to write highly concurrent applications.

.. _anyio: https://github.com/agronholm/anyio
.. _MoaT-KV: https://github.com/M-o-a-T/moat-kv
.. _hbmqtt: https://github.com/beerfactory/hbmqtt

Deprecation Notice
------------------

``MoaT-MQTT`` will be retired because by now, broker support for MQTT 5 is
nearly universal.

The designated replacement is `mqttproto`_.

Features
--------

MoaT-MQTT implements the full set of `MQTT 3.1.1`_ protocol specifications and provides the following features:

- Support for QoS 0, QoS 1 and QoS 2 messages flows
- Client auto-reconnection
- Authentication via password file (more methods can be added through a plugin system)
- Basic ``$SYS`` topics
- TCP and websocket support
- SSL support over TCP and websocket
- Plugin system
- Optional: Storage of retained messages in MoaT-KV

Build status
------------

TODO.

Project status
--------------

TODO.

Getting started
---------------

MoaT-MQTT is available on `Pypi <https://pypi.python.org/pypi/moat-mqtt>`_ and can installed simply using ``pip`` :
::

    $ pip install moat-mqtt

Documentation is available on `Read the Docs`_.

Bug reports, patches and suggestions welcome! Just `open an issue`_.

.. image:: https://badges.gitter.im/Join%20Chat.svg
    :target: https://gitter.im/beerfactory/moat-mqtt?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
    :alt: 'Join the chat at https://gitter.im/beerfactory/moat-mqtt'

.. _MQTT: http://www.mqtt.org
.. _MQTT 3.1.1: http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html
.. _mqttproto: https://github.com/agronholm/mqttproto/
.. _Read the Docs: http://moat-mqtt.readthedocs.org/
.. _open an issue: https://github.com/M-o-a-T/moat-mqtt/issues/new

Moat-MQTT? DistMQTT? MoaT-KV? Whatever?
---------------------------------------

MoaT-MQTT is a Python package that includes a stand-alone MQTT server, as
well as basic client scripts. It is based on hbmqtt and was previously
named "DistMQTT".

`MoaT-KV <https://github.com/M-o-a-T/moat-kv>`_ is a distributed key-value
storage system. It uses the MoaT-MQTT client library as its connector to
an MQTT server, preferably Mosquitto or some other low-latency broker.
It was previously named "DistKV".

A MoaT-MQTT server can hook into MoaT-KV so that some messages are persisted,
translated (i.e. store msgpack messages encoding `True` and `False`, instead of
the strings "on" and "off" (or "ON" and "OFF" or "1" and "0" or …)), filtered
(e.g. the client can only modify existing messages but not add any), et al..
moat-kv-inv 0.22.10
Inventory management for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

=======
DistInv
=======

DistInv is a link between DistKV and your network infrastructure.

DistInv knows about hosts, ports, VLANs, (sub)networks, cables.

It stores

   * which VLAN a network is in
   * which network a host belongs to
   * which port is plugged into what
   * which groups a host belongs to
   * where a host is located

This allows you to

   * record which systems are where (surprisingly difficult …)
   * auto-generate (part of) your Ansible inventory
   * display which VLANs need to be configured on a switch port
   * generate a network link path from A to B
   * auto-update DNS entries when hosts are added, moved, or modified
moat-kv-ow 0.9.13
1wire connector for MoaT-KV
Requires Python: >=3.8
Keywords: MoaT

==========
MoaT-KV-OW
==========

This is a link between 1wire and MoaT-KV.

It will

* add all discovered 1wire devices

* poll these devices as specified

* write values that it reads from 1wire to some MoaT-KV entry

* monitor a MoaT-KV entry and write any updates to 1wire

* work with MoaT-KV's runner system, either centrally or distributed
geofileops 0.11.0
Python toolbox to process large vector files faster.
Requires Python: >=3.10

# geofileops 

[![Actions Status](https://github.com/geofileops/geofileops/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/geofileops/geofileops/actions/workflows/tests.yml?query=workflow%3ATests) 
[![Coverage Status](https://codecov.io/gh/geofileops/geofileops/branch/main/graph/badge.svg)](https://codecov.io/gh/geofileops/geofileops)
[![PyPI version](https://img.shields.io/pypi/v/geofileops.svg)](https://pypi.org/project/geofileops)
[![Conda version](https://anaconda.org/conda-forge/geofileops/badges/version.svg)](https://anaconda.org/conda-forge/geofileops)
[![DOI](https://zenodo.org/badge/203202318.svg)](https://zenodo.org/doi/10.5281/zenodo.10340100)

Geofileops is a python toolbox to process large vector files faster.

Most typical GIS operations are available: e.g.
[buffer](https://geofileops.readthedocs.io/en/stable/api/geofileops.apply.html#geofileops.buffer), 
[dissolve](https://geofileops.readthedocs.io/en/stable/api/geofileops.apply.html#geofileops.dissolve),
[difference](https://geofileops.readthedocs.io/en/stable/api/geofileops.apply.html#geofileops.difference), 
[intersection](https://geofileops.readthedocs.io/en/stable/api/geofileops.apply.html#geofileops.intersection), 
[union](https://geofileops.readthedocs.io/en/stable/api/geofileops.apply.html#geofileops.union),... 

The spatial operations are tested on geopackage and shapefile input files, but
geopackage is recommended as it will give better performance. General 
[layer](https://geofileops.readthedocs.io/en/stable/reference.html#general-layer-operations)
and [file operations](https://geofileops.readthedocs.io/en/stable/reference.html#general-file-operations) can be used on the file formats supported by 
[GDAL](https://gdal.org/).

The full documentation is available on [readthedocs](https://geofileops.readthedocs.io).

Different techniques are used under the hood to be able to process large files as fast
as possible:

* process data in batches
* subdivide/merge complex geometries on the fly
* process data in different passes
* use all available CPU cores

The following chart gives an impression of the speed improvement that can be expected
when processing larger files. The [benchmarks](https://github.com/geofileops/geobenchmark)
typically use input file(s) with 500K polygons, ran on a Windows PC with 12 cores and include I/O.

![Geo benchmark](https://github.com/geofileops/geobenchmark/blob/main/results_vector_ops/GeoBenchmark.png)
ssebidethon 0.1.1
A lightweight interpreted programming language
Requires Python: >=3.8
Keywords: interpreter, programming-language, lexer, parser

# Ssebidethon

A lightweight interpreted programming language built in Python, featuring arithmetic operations, variables, conditionals, and loops.

## Installation

### From PyPI 
```bash
pip install ssebidethon
```

### From Source
```bash
git clone https://github.com/ssebide/ssebidethon.git
cd ssebidethon
pip install -e .
```

### Standalone Executable
Download the latest release from the [Releases](https://github.com/ssebide/ssebidethon/releases) page.

## Usage

### Interactive Shell
```bash
# If installed via pip
ssebidethon

# Or run as module
python -m ssebidethon

# Or run directly from source
python shell.py
```

### Example Session
```
Ssebidethon v0.1.0
Type 'exit' to quit.

>>> 5 + 3
8
>>> make x = 10
{'x': 10}
>>> x * 2
20
>>> exit
Goodbye!
```

## Language Features

### Arithmetic
```
5 + 3          # 8
10 - 4         # 6
6 * 7          # 42
20 / 4         # 5.0
(2 + 3) * 4    # 20
```

### Variables
```
make x = 10
make y = x * 2
x + y          # 30
```

### Comparisons
```
5 > 3          # 1 (true)
5 < 3          # 0 (false)
5 ?= 5         # 1 (equality check)
5 >= 5         # 1
5 <= 3         # 0
```

### Boolean Logic
```
1 and 1        # 1
1 and 0        # 0
1 or 0         # 1
not 0          # 1
```

### Conditionals
```
if x > 5 do x * 2
if x > 10 do 100 elif x > 5 do 50 else do 0
```

### Loops
```
while x > 0 do make x = x - 1
```

## Development

### Project Structure
```
ssebidethon/
├── __init__.py      # Package exports
├── __main__.py      # Module entry point
├── shell.py         # Interactive REPL
├── lexer.py         # Tokenizer
├── tokens.py        # Token definitions
├── parse.py         # Parser (AST generation)
├── interpreter.py   # Tree-walking interpreter
└── data.py          # Variable storage
```

### Building from Source
```bash
# Install build tools
pip install build

# Build the package
python -m build

# Install locally
pip install dist/ssebidethon-0.1.0-py3-none-any.whl
```


## License

MIT
automaton 3.3.0
Friendly state machines for python.
Requires Python: >=3.8

=========
Automaton
=========

.. image:: https://img.shields.io/pypi/v/automaton.svg
    :target: https://pypi.org/project/automaton/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/automaton.svg
    :target: https://pypi.org/project/automaton/
    :alt: Downloads

Friendly state machines for python. The goal of this library is to provide
well documented state machine classes and associated utilities. The state
machine pattern (or the implemented variation there-of) is a commonly
used pattern and has a multitude of various usages. Some of the usages
for this library include providing state & transition validation and
running/scheduling/analyzing the execution of tasks.

* Free software: Apache license
* Documentation: https://docs.openstack.org/automaton/latest/
* Source: https://opendev.org/openstack/automaton
* Bugs: https://bugs.launchpad.net/automaton