semvec/pypi-packages huggingface dataset:
detection-dataset-annotator 0.1.8
A slight annotator of detection datasets
Requires Python: >=3.8
Keywords: dataset, annotator, yolo

# detection-dataset-annotator

A slight annotator of detection datasets

![logo](https://raw.githubusercontent.com/trucomanx/DetectionDatasetAnnotator/main/screenshot.png)

## 1. Installing

To install the package from [PyPI](https://pypi.org/project/detection-dataset-annotator/), follow the instructions below:


```bash
pip install --upgrade detection-dataset-annotator
```

Execute `which detection-dataset-annotator` to see where it was installed, probably in `/home/USERNAME/.local/bin/detection-dataset-annotator`.

### Using

To start the project generator, use the command below:

```bash
detection-dataset-project
```

To start the annotator, use the command below:

```bash
detection-dataset-annotator
```

## 2. More information

If you want more information go to [doc](https://github.com/trucomanx/DetectionDatasetAnnotator/blob/main/doc) directory.

## 3. Buy me a coffee

If you find this tool useful and would like to support its development, you can buy me a coffee!  
Your donations help keep the project running and improve future updates.  

[☕ Buy me a coffee](https://ko-fi.com/trucomanx) 

## 4. License

This project is licensed under the GPL license. See the `LICENSE` file for more details.
iflow-mcp_sidharthrajaram_mcp-sse 0.1.0
SSE-based MCP Server and Client
Requires Python: >=3.13

# SSE-based Server and Client for [MCP](https://modelcontextprotocol.io/introduction)

[![smithery badge](https://smithery.ai/badge/@sidharthrajaram/mcp-sse)](https://smithery.ai/server/@sidharthrajaram/mcp-sse)

This demonstrates a working pattern for SSE-based MCP servers and standalone MCP clients that use tools from them. Based on an original discussion [here](https://github.com/modelcontextprotocol/python-sdk/issues/145).

## Usage

**Note**: Make sure to supply `ANTHROPIC_API_KEY` in `.env` or as an environment variable.

```
uv run weather.py

uv run client.py http://0.0.0.0:8080/sse
```

```
Initialized SSE client...
Listing tools...

Connected to server with tools: ['get_alerts', 'get_forecast']

MCP Client Started!
Type your queries or 'quit' to exit.

Query: whats the weather like in Spokane?

I can help you check the weather forecast for Spokane, Washington. I'll use the get_forecast function, but I'll need to use Spokane's latitude and longitude coordinates.

Spokane, WA is located at approximately 47.6587° N, 117.4260° W.
[Calling tool get_forecast with args {'latitude': 47.6587, 'longitude': -117.426}]
Based on the current forecast for Spokane:

Right now it's sunny and cold with a temperature of 37°F and ...
```

## Why?

This means the MCP server can now be some running process that agents (clients) connect to, use, and disconnect from whenever and wherever they want. In other words, an SSE-based server and clients can be decoupled processes (potentially even, on decoupled nodes). This is different and better fits "cloud-native" use-cases compared to the STDIO-based pattern where the client itself spawns the server as a subprocess.

### Installing via Smithery

To install SSE-based Server and Client for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@sidharthrajaram/mcp-sse):

```bash
npx -y @smithery/cli install @sidharthrajaram/mcp-sse --client claude
```

### Server

`weather.py` is a SSE-based MCP server that presents some tools based on the National Weather Service APIs. Adapted from the MCP docs' [example STDIO server implementation.](https://modelcontextprotocol.io/quickstart/server)

By default, server runs on 0.0.0.0:8080, but is configurable with command line arguments like:

```
uv run weather.py --host <your host> --port <your port>
```

### Client

`client.py` is a MCP Client that connects to and uses tools from the SSE-based MCP server. Adapted from the MCP docs' [example STDIO client implementation.](https://modelcontextprotocol.io/quickstart/client)

By default, client connects to SSE endpoint provided in the command line argument like:

```
uv run client.py http://0.0.0.0:8080/sse
```
iflow-mcp_sshtunnelvision_mcp-tool-server 0.1.0
Add your description here
Requires Python: >=3.13

# MCP Tool Server for Logo Generation

This server provides logo generation capabilities using FAL AI, with tools for image generation, background removal, and automatic scaling.

## Demo

[![MCP Tool Server Demo](https://img.youtube.com/vi/Miemu1xEZng/0.jpg)](https://www.youtube.com/watch?v=Miemu1xEZng)

## Installation

1. Install `uv` (Universal Virtualenv):

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Create and activate a virtual environment:

```bash
uv venv
source .venv/bin/activate  # On Unix/macOS
# or
.venv\Scripts\activate     # On Windows
```

3. Install dependencies:

```bash
uv pip install -r requirements.txt
```

4. Set up your environment variables:
   - Create a `.env` file in the root directory
   - Add your FAL AI API key:

```bash
FAL_KEY=your_fal_ai_key_here
```

## Running the Server

Start the server with:

```bash
python run_server.py
```

The server will be available at `http://127.0.0.1:7777`

### Troubleshooting

If you encounter a `FileNotFoundError` on Windows when running the server, make sure you're running the command from the root directory of the project. If the issue persists, try updating to the latest version of the repository which includes fixes for Windows compatibility.

For Windows users specifically:

1. Make sure you've activated your virtual environment with `.venv\Scripts\activate`
2. Run the server from the root directory of the project with `python run_server.py`
3. If you see any path-related errors, please report them in the issues section of the repository

## Cursor IDE Configuration

1. Open Cursor Settings
2. Navigate to the MCP section
3. Add the following configuration:
   - URL: `http://127.0.0.1:7777/sse`
   - Connection Type: `SSE`
   - Enable the connection

## Notes

- Always reference `@logo-creation.mdc` in your Cursor Composer for consistent results
- Steps are defined in `@logo-creation.mdc` but tools can be used independently
- All generated logos will be saved in the `downloads` directory
- Each logo is automatically generated in three sizes:
  - Original size
  - 32x32 pixels
  - 128x128 pixels
- All logos maintain transparency in their final PNG format
- Prompts created by agent are informed by examples and prompt structure seen in server.py. You can customize the prompt structure by editing the server.py file.
- You can use the generate_image tool to generate any image you want, not just logos

## Requirements

- Python 3.8+
- FAL AI API key (required for image generation)
- Active internet connection

## References

- [Cursor MCP Documentation](https://docs.cursor.com/context/model-context-protocol)
- [Model Context Protocol Introduction](https://modelcontextprotocol.io/introduction)
- [FAL AI Dashboard](https://fal.ai/dashboard)

---

If you find this tool helpful, you can [buy me a coffee](https://buymeacoffee.com/sshtunnelvision) ☕️ to support development!
lazarus-receipts-middleware 1.0.2
Drop-in middleware for Lazarus Receipts - FastAPI
Requires Python: >=3.9
Keywords: audit, fastapi, lazarus, middleware, receipts

# lazarus-receipts-middleware (Python)

Drop-in FastAPI middleware for Lazarus Receipts.

## Installation

```bash
pip install lazarus-receipts-middleware[fastapi]
```

## Quick Start

```python
from fastapi import FastAPI
from lazarus_receipts_middleware import LazarusReceiptsMiddleware

app = FastAPI()
app.add_middleware(LazarusReceiptsMiddleware)

@app.get("/")
def root():
    return {"hello": "world"}
```

Receipts are written to `./receipts/receipts.ndjson` by default.

## Configuration

```python
app.add_middleware(
    LazarusReceiptsMiddleware,
    output_path="./my-receipts/audit.ndjson"
)
```

## Receipt Format

```json
{
  "ts": "2024-01-15T10:30:00.000Z",
  "request": {"method": "GET", "path": "/api/users"},
  "response": {"status": 200},
  "receipt_hash": "abc123...",
  "merkle": null,
  "proof": null
}
```

## License

Apache 2.0
xaal.schemas 0.6
xAAL devices build from schemas
Keywords: xaal, home-automation

xaal.schemas
============

Introduction
------------
This package contains stuffs to build some code from the schemas. Right now,
it mainly contains the "devices.py" module which is generated via the builder
script.

This module contains a function that return an instance for each dev-type.
For example, if you want to use a lamp.basic, you can simply write something
like this. 

.. code-block:: python

    from xaal.schemas import devices
    from xaal.lib import tools

    lamp = devices.lamp()
    lamp.address = tools.get_random_uuid()


WARNING
-------
This package will be updated regulary (that mainly why this files isn't in 
xaal.lib package), so don't modify the files unless you really know what 
you do. 

If your device isn't in this package, please send us a email to add a schema
or use the xaal.lib.Device API directly. (don't tweak devices.py)

TODO
----
Right now xaal.lib.Attribute doesn't support type checking (You know, it's
Python anyway..) but I think we should provide some default type checking,
in devices module.
xaal.monitor 0.5.2
xAAL devices Monitor Lib
Keywords: xaal, monitor

xaal.monitor
============
This package is a library for monitoring the xAAL devices on the network. It provides a easy way to get the list of devices and their status
(attributes, description, metadata, etc...). It also provides a simple way to subscribe to events.

This package is used by a lot of xAAL programs like: The dashboard, the REST API, the Home Assistant plugin...

Usage
-----
.. code:: python

    from xaal.monitor import Monitor
    from xaal.schemas import devices
    from xaal.lib import Engine

    def on_event(ev_type, device):
        print("Event type: %s from device %s" % (ev_type, device))

    dev = devices.hmi()
    eng = Engine()
    eng.add_device(dev)
    mon = Monitor(dev)
    mon.subscribe(on_event)
    eng.run()
xaal.tools 0.7.1
xAAL devices tools
Keywords: xaal, tools


xaal.tools
==========
A collection of tools for working with the xAAL bus.

This package contains the following tools:
  - xaal-isalive
  - xaal-info
  - xaal-walker
  - xaal-dumper
  - xaal-log
  - xaal-querydb
  - xaal-cleandb
  - xaal-send
  - xaal-tail
  - xaal-pkgrun
  - xaal-keygen
  - xaal-uuidgen
  - xaal-shell

Usage
-----
All tools have a help option (-h) that can be used to get more information about. For example:

  .. code:: shell

    Usage: xaal-isalive [options]

    Options:
    -h, --help      show this help message and exit
    -c              disable color
    -l              Enable logging
    -a MCAST_ADDR   Multicast address
    -p MCAST_PORT   Multicast port
    -t FILTER_TYPE  only show given device type


Details
-------

xaal-isalive
~~~~~~~~~~~~
This tool is used to check if a device is alive on the xAAL bus, by sending a isAlive request to the devices

xaal-info
~~~~~~~~~
This tool is used to get information about a device, by requesting description / attributes / metadata.

xaal-walker
~~~~~~~~~~~
This tool is used to walk the xAAL bus and get information about all devices.

xaal-dumper
~~~~~~~~~~~
This tool is used to dump messages from the xAAL bus.

xaal-log
~~~~~~~~
This tool is used to log attributes changed.

xaal-querydb
~~~~~~~~~~~~
This tool is used to query the metadata database.

xaal-cleandb
~~~~~~~~~~~~
This tool is used to clean the metadata database.

xaal-send
~~~~~~~~~
This tool is used to send a message (request) on the xAAL bus.

xaal-tail
~~~~~~~~~
This tool provide a tail-like event logging.

xaal-pkgrun
~~~~~~~~~~~
This tool is used to run packages (for example a gateway). It will load the package and run it.
Example: xaal-pkgrun owm knx

xaal-keygen
~~~~~~~~~~~
This tool is used to generate a key for the xAAL bus.

xaal-uuidgen
~~~~~~~~~~~~
This tool is used to generate a UUID.

xaal-shell
~~~~~~~~~~
This tool is used to start a ipython interpreter with xAAL tools loaded.
xaal.legacytools 0.3.2
xAAL devices tools (legacy)
Keywords: xaal, tools

xaal.legacytools
================
This is a collection of tools for xAAL Bus. It is a legacy version of the tools that are now part of the xAAL project.
Checkout https://pypi.org/project/xaal.tools/ for the latest version.

This sets of tools provides the same functionalities but use the a much simpler API (no asyncio). This is provided for
compatibility with older systems and learning purposes.
xaal.owm 0.3.2
xAAL devices for OpenWeather Map
Keywords: xaal, own, weather

xaal.owm
========
This package is a OpenWeatherMap gateway for xAAL. It provides a way to get weather information from OpenWeatherMap and send it to xAAL network.


Config & Run
------------
Edit the configuration file `owm.ini` to set your OpenWeatherMap API key and the city you want to get weather information from.

.. code-block:: ini

    [config]
    api_key   = xxxx
    place     = "Brest,FR"
    temperature   = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    humidity      = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    pressure      = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
xaal.dummy 0.3.2
xAAL dummy devices
Keywords: xaal

xaal.dummy
==========
This package provides some dummy (fake) devices for the xAAL Project. It is intended to be used for testing purposes.

Usage
-----
Run the module to see the available devices and how to run them.

  .. code:: bash

    python -m xaal.dummy
    ================= xAAL dummy devices =================

    This package contains some fake lamps, power_relay, and bots:
        - lamp:         a simple lamp implementation
        - lamp_minimal: a simple lamp using schema devices
        - power_relay:  a power relay
        - temperature:  a fake temperature sensor
        - autobot:      a bot than send turn_on/off and  set_brightness
        - asyncbot:     same as autobot with asyncio


    To run a module simply call: python -m xaal.dummy.module
    Example: python -m xaal.dummy.lamp 8e1495cc-b98b-11eb-8432-d6bd5fe18736

    All modules accept their address (uuid) as argument. Autobot uuid is the
    lamp's address to switch.

Here a simple example to run a lamp:

  .. code:: bash

    python -m xaal.dummy.lamp 8e1495cc-b98b-11eb-8432-d6bd5fe18736
xaal.htu21d 0.1.2
xAAL devices for I2C HTU21D sensors
Keywords: xaal, i2c sensors


xAAL support for HTU21D sensors
===============================
HTU21D combine a temperature and humidity sensors in a single package.
You can find some breakboard for less than 5$ on ebay. 

This program simply export the temperature & humidity on the xAAL bus.

We tested this on a Raspberry PI 3, but it should work with any device
that has a I2C bus. 

Original HTU21D Python module come from the weather station project:
https://github.com/raspberrypi/weather-station/blob/master/HTU21D.py
xaal.warp10 0.2.3
xAAL logger for warp10
Keywords: xaal, warp10

xaal.warp10
===========
This provide a warp10 (https://www.warp10.io/) logger for xAAL. It will log all xAAL messages to a warp10 instance.


Install & Run
-------------
You can install it using pip :

.. code-block:: bash

    $ pip install xaal.warp10

Then you can run it :

.. code-block:: bash

    $ python -m xaal.warp10
    # or
    $ xaal-pkgrun warp10


Config
------

.. code-block:: ini

    [config]
    url   = http://warp10:8080/api/v0/update
    topic = xaal-lab
    token = nI6H6KKxy3QSTxmfe0_lQyaBI0aV3gR4r5niVAKlaUb32cxIemlU7Vpb8AYhOkgZMz.bi...


Grafana
-------
You can use Grafana to display warp10 series, for example :

.. code-block::

    [
    'xxxxxxxx_key_xxxxx'
    '~xaal-home.thermometer.basic.temperature'
    { 'devid' '2f31c921-01b2-4097-bfae-5753dde2cd42' }
    $startISO $endISO
    ]
    FETCH
    'salon ' RENAME
    { 'devid' ''  '.app' '' } RELABEL
xaal.influxdb 0.1.3
xAAL device for InfluxDB logging
Keywords: xaal, influxdb


xaal.influxdb
=============
xaal.influxdb is an InfluxDB logger for xAAL. It can either log all values seen
on the bus, or log specific devices. 

For a full description of the protocol check out http://xaal.tk



Dependencies
~~~~~~~~~~~~
xaal.lib depends on :
- ujson
- pysodium
- configobj

But ujson compiled by hand (with pip install ie), will lead in a slow startup.
I'm unable to know exactly why. Using package distribution is really recommended.
If you can't, simply use json in place.
xaal.fauxmo 0.2.3
xAAL to Wemo fake emulations
Keywords: xaal, wemo, alexa

xaal.fauxmo
===========
This is a simple implementation of a Fauxmo device for the xAAL protocol. It allows you to control xAAL devices with an Amazon Echo.
The device can be :

- a simple power relay
- a lamp
- a scenario
- anything that support on/off commands

You can group multiple devices under the same name to control them all at once.

Usage
-----

The configuration (`fauxmo.ini`) file looks like this :

  .. code:: yaml

    [devices]
    [[lampe ambiance]]
        targets = e19d5ea8-c838-11ea-82a8-9cebe88e1963,
        port = 49001

    [[luminaires séjour]]
        targets = e19d5ea8-c838-11ea-82a8-9cebe88e1963,6265eb30-8c59-11e9-98b1-b827ebe99201,
        port = 49003

    [[volet salle de bain]]
        targets = e4b05165-be5d-46d5-acd0-4da7be1158ed,
        port = 49004

Device name are the name that will be used to control the device with the Amazon Echo.
The `targets` field is a list of xAAL device UUIDs that will be controlled.

Note
----
Fauxmo version 0.8 cause errors while getting _latest_action. I stick w/ 0.6 version
right now. It looks like Fauxmo had some work done. I need to check if nested async
is still needed.
xaal.alexa 0.1.2
xAAL devices for Amazon Alexa
Keywords: xaal, alexa

xaal.alexa
==========
This package provides a xAAL gateway for all Alexa devices associated to an account. 
Right now, the gateway supports TTS. 


Install
=======
- Download the remote script: https://github.com/thorsten-gehrig/alexa-remote-control
- Edit / run the remote script
- Try the gateway: python -m xaal.alexa
- Edit the config file to add Alexa Echo devices (or Group) (find them w/ alexa-remote-control.sh -a)
  You can omit the address.
- re-run the gateway
- done


Notes
=====
The gateway provides a special Alexa (virtual) device called LastAlexa. This is the 
lattest used device. 


Usage
=====
You can trigger a xAAL scenario throught the xaal.fauxmo package. And use the LastAlexa
device to answer to the user throught the scenario.
loducode-utils 0.0.25
Basic components for the development of loducode s.a.s.
Keywords: utils, loducode_utils, loducode

# Loducode utils

Basic components for the development of loducode s.a.s.

### install

`pip install loducode_utils==0.0.23`

## functionalities

- **Admin**
    - AuditAdmin
    - AuditStackedInline
    - AuditTabularInline
- **Models**
    - Audit
    - City  
- **Tasks**
    - send_mail_task(email, subject, message)
- **Urls Api**
    - /api/token/
    - /api/logout/
    - /api/forget/
- **Utils**
    - PaginatedListView
- **Views api**
    - ObtainCustomAuthToken
    - LogoutView
    - ForgetPasswordView

## Commands

- python setup.py sdist bdist_wheel
- twine upload --repository pypi dist/loducode_utils-0.0.25*

entrar a la carpeta loducode_utils y correr
- django-admin makemessages
- django-admin compilemessages

####Version 0.0.24
- update requirements  

####Version 0.0.23
- update requirements  

####Version 0.0.18
- change models  

####Version 0.0.18
- implment get_user_model()

####Version 0.0.17
- Migration 0004

####Version 0.0.16
- Migration 0003
- uuid for audit
- support for user customs
- new field in city > active

####Version 0.0.15
- Migration 0002

####Version 0.0.14
- Import export cities

####Version 0.0.13
- Change translate state for departament

####Version 0.0.11
- bug save user in save model audit

####Version 0.0.10
- add locale es-en
- bug _ translate apps.py

####Version 0.0.9
- add apps.py

####Version 0.0.8
- change translation model payment record
- new view data epayco

####Version 0.0.7
new model payment record

####Version 0.0.6
model city in admin fixxed register

####Version 0.0.5

- model city in admin
- migrations initials city
xaal.zwave 0.2.2
xAAL gateway for Zwave
Keywords: xaal, zwave


xaal.zwave
==========
This package provides a gateway to connect Zwave devices to the xAAL.
It uses the openzwave library to communicate with the Zstick.
As the openzwave library is outdated, it is recommended to use an old
version of Python (tested w/ 3.8.12) to run this gateway.


Install & Config
----------------
- Install the gateway as usual, *pip install xaal.zwave*
- Plug the Zstick
- Run the gateway w/ *python -m xaal.zwave*
- Change the serial port in the config file *zwave.ini* if needed.
- The gateway will detect all paired products with the Zstick so, no
  addtionnal config is needed

Products
--------
- Supported products are in products/, feel free to add (and submit)
  your own devices.
xaal.yeelight 0.3.2
xAAL gateway for Yeelight devices
Keywords: xaal, yeelight

xaal.yeelight
=============
This package provides a xAAL gateway for Yeelight lights. It support most of the Yeelight lights and bulbs.
You have to enable local control on your Yeelight device to use this package. You can do this by enabling
the "LAN Control" option in the Yeelight app.

The gateway detects the Yeelight devices on the network and creates a xAAL device for each of them. Check
*yeelight.ini* after the first run to see the devices created.


Notes
-----
This gateway doesn't use the asyncio API provides by the Yeelight library. Instead, it use gevent. This code
is a bit old, and need some refactoring to use the asyncio API. But it works well for now.
xaal.tuya 0.3.1
xAAL support for Tuya protocol / Smart Life App
Keywords: xaal, tuya

xaal.tuya
=========
This package provides a gateway to control Tuya devices from xAAL network.

Tuya protocol is the common protocol used in cheap chinese outlets, smart plugs,
and RGB lamps. It use the cloud base "Smart Life" mobile application (Android/IOS).

This protocol isn't really reliable. If you can, avoid the use of Smart Life APP
when this gateway is running. This should be ok, but attributes can be out of
sync. The gateway polls devices state every 45 seconds but due to socket error,
this can be a little longuer.


The complete guide to extract keys is there:
https://github.com/codetheweb/tuyapi/blob/master/docs/SETUP.md

Notes :
The main issue is that tuya devices close every connection after 10 seconds.

Supported devices
-----------------
The gateway supports: PowerRelays (from 1 to x relais), SmartPlugs (same as relais
but with a single power-meter), lamps and RGB lamps

Configuration samples
---------------------

- Dimmer Lamp / LSC Smart filament

.. code-block::

   [[device_id]]
    ip = 192.168.1.x
    key = xxxxxxxxxxxxxxxx
    type = lamp_dimmer
    white_temp = 1800, 2700  # for LSC
    addr = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

- RGB Lamp / LSC RGB1

.. code-block::

   [[device_id]]
    ip = 192.168.1.x
    key = xxxxxxxxxxxxxxxx
    type = lamp_rgb
    white_temp = 1800, 2700  # for LSC
    white_temp = 3000, 6500  # for Utorch LE7
    addr = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

- Alphawise dumb single outlet

.. code-block::

  [[device_id]]
    ip = 192.168.1.x
    key = xxxxxxxxxxxxxxxx
    type = powerrelay

- SmartPlug (single outlet) / BW-SHP6

.. code-block::

  [[device_id]]
    ip = 192.168.1.x
    key = xxxxxxxxxxxxxxxx
    type = smartplug

- SmartPlug (dual outlet) / BW-SHP7

.. code-block::

  [[device_id]]
    ip = 192.168.1.x
    key = xxxxxxxxxxxxxxxx
    type = smartplug
    dps = 1, 2               # <= 2 outlets
    pmeter_dps = 18, 19, 20  # <= dps for current / power / voltage
xaal.sensfloor 0.2.2
xAAL devices for Future Shape SensFloor
Keywords: xaal, Sense Floor


xaal.sensfloor
==============
This is a gateway for Future Shape Sensfloor to xAAL. It use the websocket API provided by the Sensfloor.

https://future-shape.com/en/system/


WARNINGs
--------
- Sensfloor is only compliant w/ socketio 5.0.0 (won't work on 5.5.*)
- Due to mess in engineio signal handler, the GW is unable to call eng.shutdown()
  => This is enought for me right now, but still be carefull.
  => This bug raise a RuntineError on exit.. but not on console/self.shutdown()