semvec/pypi-packages huggingface dataset:
Linkify-Linkedlist 0.1.2
A Python library to convert arrays to linked lists
Requires Python: >=3.6

# Linkify

`Linkify` is a Python library that converts arrays into linked lists. This library provides a simple way to create and manipulate linked lists using standard array data.

## Installation

You can install the `Linkify` library using pip:

```bash
pip install Linkify-Linkedlist
```
## Usage
- Creating a Linked List from an Array

```
from Linkify import LinkedList

# Create a linked list from an array
arr = [1, 2, 3, 4, 5]
linked_list = LinkedList.from_array(arr)

# Display the linked list with arrows
print(linked_list.display())  # Output: 1 -> 2 -> 3 -> 4 -> 5
```
- Appending Elements

```
from Linkify import LinkedList

# Create an empty linked list
linked_list = LinkedList()

# Append elements
linked_list.append(10)
linked_list.append(20)

# Display the linked list
print(linked_list.display())  # Output: 10 -> 20
```
- Use Case

Imagine you are developing a task management system where tasks are frequently added and removed. Using a linked list for storing these tasks can be more efficient compared to arrays, especially for operations that involve frequent insertions and deletions.

```
from Linkify import LinkedList

# Initial list of tasks
tasks = ['Task 1', 'Task 2', 'Task 3']

# Convert the list of tasks to a linked list
task_list = LinkedList.from_array(tasks)

# Add a new task
task_list.append('Task 4')

# Display the updated task list
print(task_list.display())  # Output: Task 1 -> Task 2 -> Task 3 -> Task 4

# Suppose Task 1 is completed, you can remove it from the list (implementation needed)
# task_list.remove('Task 1')  # Assume you have implemented a remove method

# Display the list after removal
print(task_list.display())  # Output might be: Task 2 -> Task 3 -> Task 4
```
## License

This project is licensed under the MIT License - see the LICENSE file for details.
zetta-backend-toolkit 0.1.4
Un toolkit Backend para FastAPI
Requires Python: >=3.10

# FastAPI Toolkit 

FastAPI Toolkit is a set of tools to enhance the development of applications with FastAPI. It includes middleware for logging, request rate limiting, and more.

## Installation

You can install the package using pip:

  

```bash

pip  install  zetta-backend-toolkit

```

### Logger Middleware

To use the logging middleware, simply add it to your FastAPI application:

  

```python
from fastapi import FastAPI
from zetta-backend-toolkit.logger_middleware import LoggerMiddleware

app = FastAPI()

app.add_middleware(LoggerMiddleware)

@app.get("/")
async def read_root():
	return {"message": "Hello World"}

```

  

### Rate Limiting Middleware

To limit the number of requests per IP:

  

```python
from fastapi import FastAPI
from zetta-backend-toolkit.rate_limit_middleware import RateLimitMiddleware

app = FastAPI()

app.add_middleware(RateLimitMiddleware, max_requests=5, period=60)

@app.get("/")
async def read_root():
	return {"message": "Hello World"}

```
### Translation  Middleware

To translate requests and responses using googletrans: 
```python
from fastapi import FastAPI, Request
from zetta-backend-toolkit.translation_middleware import TranslationMiddleware

app = FastAPI()

app.add_middleware(TranslationMiddleware, target_language="en")

@app.post("/translate")
async def translate_text(request: Request):
    body = await request.body()
    return {"translated_text": body.decode("utf-8")}
```

Project Information

Name: fastapi-toolkit

Version: 0.1.0

Author: Gonzalo Geraci

Author's Email: gonza.geraci@gmail.com

Description: A Backend toolkit for FastAPI

Project URL: https://github.com/gonzageraci/FastAPI-toolkit

Requires Python: >=3.10

Dependencies:

- fastapi
  

### Contribute

Contributions are welcome. Please open an issue or a pull request on the GitHub repository.

  

### License

This project is licensed under the MIT License. See the LICENSE file for more details.

  

Contact

Author: Gonzalo Geraci

Email: gonza.geraci@gmail.com

GitHub: https://www.github.com/gonzageraci
litlyx-sender 0.1.0
A Python library for sending events to LitLyx
Requires Python: >=3.6

# LitLyx Sender

LitLyx Sender is a Python library for easily sending events to the LitLyx platform.

## Installation

You can install LitLyx Sender using pip:

```
pip install litlyx-sender
```

## Usage

Here's a basic example of how to use LitLyx Sender:

```python
from litlyx_sender import LitLyxSender

# Create a sender instance
sender = LitLyxSender()

# Send a simple event
sender.send_event(name="test_event", metadata={"test": "value"})

# Use the decorator
@sender.event_decorator(name="decorated_event", metadata={"decorated": True})
def example_function():
    print("This is an example function.")

example_function()
```

## Configuration

You can configure the LitLyxSender with custom default values:

```python
sender = LitLyxSender(
    url="https://custom.litlyx.com/event",
    default_pid="custom_pid",
    default_name="custom_event",
    default_metadata={"custom": "metadata"},
    default_website="custom.website.com",
    default_user_agent="CustomApp/1.0"
)
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
wapchita 0.1.8
Python SDK para la API de Wapchita https://wapchita.com/.
Requires Python: >=3.11

### Python SDK para la API de Wapchita https://wapchita.com/.
- PyPI: https://pypi.org/project/wapchita/

### Quickstart
- Settear variable de entorno.
```bash
WAP_URL_BASE=https://api.name.uy
```