semvec/pypi-packages huggingface dataset:
PythonOverlayLib 1.2
Python library designed to create customizable overlays for desktop applications. It uses PyQt5 to draw shapes such as circles, rectangles, and lines on a transparent window that stays on top of other windows.

# PythonOverlayLib

The Overlay Library is a Python library designed to create customizable overlays for desktop applications. It uses PyQt5 to draw shapes such as circles, rectangles, and lines on a transparent window that stays on top of other windows. This can be useful for a variety of applications, such as highlighting specific areas of the screen, drawing annotations, or creating custom HUDs for games.

## Features

- **Customizable Shapes**: The library supports drawing of various shapes including circles, rectangles, and lines. Each shape can be customized with its own position, size, color, and thickness.

- **Transparent Overlay**: The overlay is completely transparent, allowing you to see the underlying windows while still displaying the drawn shapes.

- **Always on Top**: The overlay window stays on top of other windows, ensuring that the drawn shapes are always visible.

- **Dynamic Drawing**: The library supports dynamic drawing through a callback function. This function is called at a regular interval and should return a list of shapes to be drawn. This allows the overlay to be updated dynamically based on your application's state.

## Usage

To use the Overlay Library, you need to create an instance of the [`Overlay`](https://github.com/LUXTACO/PythonOverlayLib/blob/main/overlay_lib/overlay.py#L48) class, passing a callback function that returns a list of shapes to be drawn. You can then call the [`spawn`](https://github.com/LUXTACO/PythonOverlayLib/blob/main/overlay_lib/overlay.py#L54) method to create the overlay window.

Here's a basic example:

```python
import overlay_lib
from overlay_lib import Vector2D, RgbaColor, SkDrawCircle

def callback():
    return [SkDrawCircle(Vector2D(960, 540), 10, RgbaColor(255, 255, 255, 255), 1)]

overlay = overlay_lib.Overlay(
    drawlistCallback=callback,
    refreshTimeout=1
)

overlay.spawn()
```

In this example, the callback function returns a list containing a single circle, which is drawn at the center of the screen. The `refreshTimeout` parameter determines how often the callback function is called, in milliseconds.

## Installation

To install the Overlay Library, you can use pip:

```bash
pip install PythonOverlayLib
```

## Contributing

Contributions are welcome! Please feel free to submit a pull request.

## License

This project is licensed under the terms of the Apache License 2.0 license.
pyaiplayer 0.1.3
A tool to let human play game against AI model

# pyaiplayer
A tool to let human play game against AI model.

Today there are quite many python RL(reinforcement learning) models that can play arcade game, e.g. stree fighter. Models are trained in an internal environment, such as gym-retro environment, and it is not inter-actable (you cannot interact with the environment via your mouse or keyboard), which means human cannot play with/against the model you trained. It will be interesting and exciting that human can play with/against the model you trained, that's why I invented this library and share it with you guys.

You can refer to test_human_vs_ai.py which is an example for main function.

There are not too many code in this library, it is more like a reference, if you are trying to do similar thing, i.e. create a human vs AI inter-actable gym-retro environment.
You may find some answer when you encounter technical problems and difficulties.

API (very simple, just two lines):
env = EnvironmentWrapper(env, model)
#env is grm-retro environment, normally created by retro.make method.
#model is the model you trained.

# then, play
env.play()
# keyboard ASDW + jkluio + b (SELECT) + n(START)
# press t to save current state as file saved_state.state
# Force close the window whenever you want.
amzn-btlx-celery-tasks 1.0.0
Minimal Coral interface for when you can't use a prepackaged client.
Requires Python: >=3.8

# amzn-btlx-celery-tasks

Task definitions that can be invoked from anywhere but are executed on the Celery worker.

This needs to be a separate package because of Celery... mainly, we want to be able to import
the headers to our tasks to make it easy to invoke functions, but we don't want any of the dependencies
they use.
bangpg 0.1.1
This packeges implements a faster alternative `to_sql()` method for PostgreSQL that support COPY FROM.
Requires Python: >=3.6

# Bang PG
> As fast as a bullet 

This packeges implements a faster alternative `to_sql()` method for PostgreSQL that support `COPY FROM`.

There are two ways to use it:

1. 

```python
import bangpg
bangpg.to_sql(df, 'table', engine,  if_exists='append', index=False)

```

2.

```python
import bangpg
df.to_sql('table', engine,  if_exists='append', index=False, method=bangpg.psql_insert_copy)

```




references: https://pandas.pydata.org/docs/user_guide/io.html#io-sql-method
vs-api-elastic-history 0.0.1
Biblioteca adpatação do langchain para uso mais fácil das ferramentas de histórico
Requires Python: >=3.12

# Biblioteca de HistÃ³rico de Mensagens

Uma biblioteca Python para gerenciar e adaptar histÃ³ricos de mensagens usando LangChain e Elasticsearch. Esta biblioteca fornece ferramentas para armazenar, recuperar e processar histÃ³ricos de mensagens, facilitando a construÃ§Ã£o de aplicaÃ§Ãµes que requerem capacidades sofisticadas de manipulaÃ§Ã£o de mensagens.

## Funcionalidades

- **Armazenamento de Mensagens**: Armazene e indexe mensagens no Elasticsearch para uma recuperaÃ§Ã£o eficiente.
- **RecuperaÃ§Ã£o de Mensagens**: Recupere mensagens com opÃ§Ãµes de consulta flexÃ­veis.
- **IntegraÃ§Ã£o com LangChain**: Utilize o LangChain para processamento e anÃ¡lise avanÃ§ada de mensagens.
- **FÃ¡cil de Usar**: API simples para operaÃ§Ãµes comuns em histÃ³ricos de mensagens.

## InstalaÃ§Ã£o

Para instalar a biblioteca, use o pip:

```sh
pip install vs-api-elastic-history