semvec/pypi-packages huggingface dataset:
winerp 1.5.0
Websocket based IPC for discord.py bots
License: MIT
Requires Python: >=3.6

# winerp
An IPC based on Websockets. Fast, Stable, and easy-to-use, for inter-communication between your processes or discord.py bots.


### Key Features

 - **Fast** with minimum recorded response time being `< 2ms`
 - Lightweight, Stable and Easy to integrate.
 - No limitation on number of connected clients. 

## Installation
Stable:
```py
pip install -U winerp
```
Main branch (can be unstable/buggy):
```py
pip install git+https://www.github.com/BlackThunder01001/winerp
```

### Working:
This library uses a central server for communication between multiple clients. You can connect a large number of clients for sharing data, and data can be shared between any connected client.

1) Import the library:
```py
import winerp
```

2) Initialize winerp client:
```py
ipc_client = winerp.Client(local_name = "my-cool-app", port=8080)
```

3) Start the client:
```py
await ipc_client.start()
# or
asyncio.create_task(ipc_client.start())
```

- Registering routes:
```py
@ipc_client.route
async def route_name(source, user_name):
    return f"Hello {user_name}"
```

- Requesting data from another client:
```py
user_name = await ipc_client.request(route="fetch_user_name", source="another-cool-bot", user_id = 123)
```

- Sending *information* type data to other clients:
```py
data = [1, 2, 3, 4]
await ipc_client.inform(data, destinations=["another-cool-bot"])
```

## Example Usage:

Start the server on terminal using `$ winerp --port 8080`. You can also start the server using `winerp.Server`

### Client 1 (`some-random-bot`):
```py
import winerp
import discord
from discord.ext.commands import Bot
bot = Bot(command_prefix="!", intents=discord.Intents.all())

bot.ipc = winerp.Client(local_name = "some-random-bot", port=8080)

@bot.command()
async def request(ctx):
    # Fetching data from a client named "another-bot" using route "get_some_data"
    data = await bot.ipc.request("get_some_data", source = "another-bot")
    await ctx.send(data)


@bot.ipc.route()
async def get_formatted_data(source, user_id = None):
    return f"<@{user_id}>"


@bot.ipc.event
async def on_winerp_ready():
    print("Winerp Client is ready for connections")

bot.loop.create_task(bot.ipc.start())
bot.run("TOKEN")
```

### Client 2 (`another-bot`)
```py
import winerp
import discord
from discord.ext.commands import Bot
bot = Bot(command_prefix="?", intents=discord.Intents.all())

bot.ipc = winerp.Client(local_name = "another-bot", port=8080)

@bot.command()
async def format(ctx):
    # Fetching data from a client named "some-random-bot" using route "get_formatted_data"
    data = await bot.ipc.request("get_formatted_data", source = "some-random-bot", user_id = ctx.author.id)
    await ctx.send(data)


@bot.ipc.route()
async def get_some_data(source):
    return "You are very cool"


bot.loop.create_task(bot.ipc.start())
bot.run("TOKEN")
```
sloslsoododldl-sosoajajk 2
A Python module for creating a single instance of an application on Windows.
License: MIT
Requires Python: >=3.7.0


📦 SingleInstance (Windows)
=======================

This is a software module designed for use with Python that allows for the creation of a single instance of an application on the Windows operating system.
When running an application on Windows, multiple instances of the same application can be created unintentionally, which can cause issues for the user and the system as a whole.
This module provides a solution to this problem by ensuring that only one instance of the application is running at any given time.
The module is designed to be easy to use and integrate into Python applications, providing developers with a simple way to ensure that their applications are running as intended.
With this module, developers can avoid potential issues caused by multiple instances of their application running simultaneously, resulting in a more stable and reliable application.
By using this module, developers can improve the user experience of their applications, providing a more seamless and efficient experience for their users.
Whether developing a new application or improving an existing one, this module is an essential tool for any developer working with Python on the Windows operating system.

Installation
-----

```
If you want to use the SingleInstance module in your Python application, you can easily install it via pip:

## pip install singleinstance

This will download and install the SingleInstance module and any dependencies it requires,
making it available for use in your Python application.
```

Usage
-----

```
To use SingleInstance, simply import the module and create an instance of the "SingleInstance" class with a unique mutex name:

## import singleinstance

## singleinstance.lock('ExampleApplicationNameMutex')

This will create a new mutex with the specified name. 
If another instance of the application is already running, 
the "SingleInstance" object will raise a "SystemExit" exception and terminate the new instance.
```

License
-------

This software is open source, meaning it can be freely used, modified,
and distributed in source code or binary form for commercial or non-commercial purposes.
Users have the right to access and modify the source code and distribute modified or
unmodified versions of the software in any manner.
py-ocpi 0.3.1
Python Implementation of OCPI
License: MIT
Requires Python: >=3.9,<4.0
Keywords: ocpi


.. image:: https://img.shields.io/pypi/v/py-ocpi.svg?style=flat
   :target: https://pypi.org/project/py-ocpi/
.. image:: https://pepy.tech/badge/py-ocpi/month
   :target: https://pepy.tech/project/py-ocpi
.. image:: https://github.com/TECHS-Technological-Solutions/ocpi/actions/workflows/pypi.yaml/badge.svg?style=svg
   :target: https://github.com/TECHS-Technological-Solutions/ocpi/actions?query=workflow:pypi
.. image:: https://coveralls.io/repos/github/TECHS-Technological-Solutions/ocpi/badge.svg
   :target: https://coveralls.io/github/TECHS-Technological-Solutions/ocpi
   
Introduction
============

This Library is a Python implementation of the Open Charge Point Interface (OCPI)


Getting Started
===============

Installation
------------

install Py-OCPI like this:

.. code-block:: bash

    pip install py-ocpi


How Does it Work?
-----------------

Modules that communicate with central system will use crud for retrieving required data. the data that is retrieved from central system may
not be compatible with OCPI protocol. So the data will be passed to adapter to make it compatible with schemas defined by OCPI. User only needs to
modify crud and adapter based on central system architecture.

Example
-------

https://github.com/TECHS-Technological-Solutions/ocpi/blob/830dba5fb3bbc7297326a4963429d7a9f850f28d/examples/v_2_2_1.py#L1-L205

Documents
---------

Check the `Documentation <https://techs-technological-solutions.github.io/ocpi/>`_


License
=======

This project is licensed under the terms of the MIT license.
single-instance-win 1.0.2
A Python module for creating a single instance of an application on Windows.
License: MIT
Requires Python: >=3.6.0


📦 SingleInstance (Windows)
=======================

This is a software module designed for use with Python that allows for the creation of a single instance of an application on the Windows operating system.
When running an application on Windows, multiple instances of the same application can be created unintentionally, which can cause issues for the user and the system as a whole.
This module provides a solution to this problem by ensuring that only one instance of the application is running at any given time.
The module is designed to be easy to use and integrate into Python applications, providing developers with a simple way to ensure that their applications are running as intended.
With this module, developers can avoid potential issues caused by multiple instances of their application running simultaneously, resulting in a more stable and reliable application.
By using this module, developers can improve the user experience of their applications, providing a more seamless and efficient experience for their users.
Whether developing a new application or improving an existing one, this module is an essential tool for any developer working with Python on the Windows operating system.

Installation
-----

```
If you want to use the SingleInstance module in your Python application, you can easily install it via pip:

pip install singleinstance

This will download and install the SingleInstance module and any dependencies it requires,
making it available for use in your Python application.
```

Usage
-----

```
To use SingleInstance, simply import the module and create an instance of the "SingleInstance" class with a unique mutex name:

import singleinstance

singleinstance.lock('ExampleApplicationNameMutex')

This will create a new mutex with the specified name. 
If another instance of the application is already running, 
the "SingleInstance" object will raise a "SystemExit" exception and terminate the new instance.
```

License
-------

This software is open source, meaning it can be freely used, modified,
and distributed in source code or binary form for commercial or non-commercial purposes.
Users have the right to access and modify the source code and distribute modified or
unmodified versions of the software in any manner.
ListDash 0.0.1
returns the dashes based on the length of the biggest length character
License: MIT
Keywords: dir-organise

The Library That Returns The Dashes Based On The Length Of The Biggest Length Character

Functions
---------

- dashByLength(list)
  - Show Dashes Based On Length


Change Log
==========

0.0.1 (16/04/2023)
-------------------
- New Release