semvec/pypi-packages huggingface dataset:
simple-xor-encryption 0.0.2
A simple way to xor encryption
Requires Python: >=3.6

# simple_xor_encryption
*yet another useless and random package*
## exemple
```python
from simple_xor_encryption import xor

message = "random test".encode()
key = "SsJt7g".encode()  # key length does not have to match data length

encrypted_message = xor(message, key)
decrypted_message = xor(encrypted_message, key)
print(message == decrypted_message)
```
operacoes-com-listas 0.0.1
Operações matemáticas simples com listas

# OperaÃ§Ãµes simples com listas
DescriÃ§Ã£o:
 - Dobra de valores de uma lista;
 - MÃ©dia aritmÃ©tica de uma lista;
 - Soma itens de uma lista

## Instalation
Use o instalador de pacotes [pip](https://pip.pypa.io/en/stable/) para instalar o operacoes_com_listas
```bash
pip install operacoes_com_listas
```

## Exemplo de uso
```bash
from operacoes_com_listas import *

lista = [1, 2, 3]

print(soma_itens_lista(lista))
print(dobra_lista(lista))
print(media_aritmetica(lista))
```

## Autor
[FÃ¡bio Santos](https://github.com/mr-fabiosantos)

## LicenÃ§a
[MIT]()
Tabaqui 8.1.1
CLI Web browser
Requires Python: >=3.6

# Tabaqui Text Browser

Tabaqui is an unique text web browser: it can open FB2 books. :flushed:

## Tabaqui's license

````
Tabaqui - text web browser
Copyright (C) 2022 Tabaqui
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
````

## Using
````
tabaqui
````

````
#USING IN IDLE/GEANY
from tabaqui.tabaqui8 import start
start()
````

### Embedding

````
from tabaqui.tabaqui8 import Engine
...
parser = Engine()
parser.feed(data)
return parser.data()
````

## Commands:

**DISCLAIMER: FORMS MAY NOT WORK IF SITE USES JAVASCRIPT!**

* `l url` - load a new url (writing **WITHOUT** space)
* `num num` (num is an integer) - show a part of document (first number must be less then second)
* `num` - show a part beginning from line number <num>
* `d<url> <filename>` (url - URL; filename - path for saving) - download file (DO NOT USE SPACE BEFORE URL BUT USE IT BETWEEN PARAMETERS)
* `q` - close the browser
* `B<bm>` - load a bookmark (write without spaces)
* `b<bm> <url>` - add a bookmark (bookmark name **MUST** be written without space)
* `F<name> <data>` - input data to form
* `f<url>` - load the page with the form (url **MUST** be written without space)
* `H<url>` - set homepage to URL url (DO **NOT** ENTER SPACES)
* `R<file>` - open FB2 book (DO **NOT** ENTER SPACES AFTER R LETTER)
* `s<data>` - find data in page (DO **NOT** ENTER SPACES AFTER s LETTER!)
* `p<name> <value>` - create a point named <name> with line <value> (<value> is INT)
* `P<name>` - open line with <name> in current page
* `!<name>` - open the page associated with name at the point with the same name)
aioredlock-py 0.1.5
Secure and efficient distributed locks (Radisson like) implemetation
Requires Python: >=3.7
Keywords: aioredlock_py,redlock,redisson,redis,aioredis,aioredlock,redis-py

# aioredlock-py
[![fury](https://img.shields.io/pypi/v/aioredlock-py.svg)](https://pypi.org/project/aioredlock-py/)
[![licence](https://img.shields.io/github/license/GoodManWEN/aioredlock-py)](https://github.com/GoodManWEN/aioredlock-py/blob/master/LICENSE)
[![pyversions](https://img.shields.io/pypi/pyversions/aioredlock-py.svg)](https://pypi.org/project/aioredlock-py/)
[![Publish](https://github.com/GoodManWEN/aioredlock-py/workflows/Publish/badge.svg)](https://github.com/GoodManWEN/aioredlock-py/actions?query=workflow:Publish)
[![Build](https://github.com/GoodManWEN/aioredlock-py/workflows/Build/badge.svg)](https://github.com/GoodManWEN/aioredlock-py/actions?query=workflow:Build)
[![Docs](https://readthedocs.org/projects/aioredlock-py/badge/?version=latest)](https://readthedocs.org/projects/aioredlock-py/)

Secure and efficient distributed locks (Redisson like) implemetation. Ensure efficient performance with biased locking's implementation, can load more than 1k/s of concurrent requests with default parameter settings.

## Requirements
- aioredis>=2.0.0

## Install

    pip install aioredlock-py

## Feature
- Ensure reliability with context manager.
- Use lua scripts to ensure atomicity on lock release.
- Notification prompt you to cancel the following execution if acquisition fails
- Reliable in high concurrency.

## Documentation
https://aioredlock-py.readthedocs.io

## Basic usage
```python
import asyncio
import aioredis
from aioredlock_py import Redisson

async def single_thread(redis):
    for _ in range(10):
        async with Redisson(redis, key="no1") as lock:
            if not lock:
                # If the lock still fails after several attempts, `__aenter__` 
                # will return None to prompt you to cancel the following execution
                return 'Do something, failed to acquire lock' # raise ...
            # else 
            # Service logic protected by Redisson
            await redis.incr("foo")

async def test_long_term_occupancy(redis):
    async with Redisson(redis, key="no1", ex=10) as lock:
        if not lock: return;
        # Service logic protected by Redisson
        await redis.set("foo", 0)
        # By default, a lock is automatically released if no action is 
        # taken for 20 seconds after redisson holds it. Let's assume that 
        # your service logic takes a long time (30s in this case) to process,
        # you don't need to worry about it causing chaos, because there's 
        # background threads help you automatically renew legally held locks.
        await asyncio.sleep(30)
        await redis.incr("foo")


async def main():
    redis = aioredis.from_url("redis://localhost")
    await redis.delete("redisson:no1")
    await redis.set("foo", 0)
    await asyncio.gather(*(single_thread(redis) for _ in range(20)))
    assert int(await redis.get("foo")) == 200
    # test_long_term_occupancy(redis)

asyncio.run(main())
```