semvec/pypi-packages huggingface dataset:
ai-controller 0.1.0
AI-Agent (Auto-Code Executor) is a Python module that dynamically executes Python functions based on textual input. It leverages a language model (LLM) to match the input text with function descriptions and then executes the corresponding function from a specified file.
Requires Python: >3.10

# AI-Agent (Auto-Code Executor)

AI-Agent (Auto-Code Executor) is a Python module that dynamically executes Python functions based on textual input. It leverages a language model (LLM) to match the input text with function descriptions and then executes the corresponding function from a specified file.

## Features

- **Dynamic Function Execution**: Executes Python functions based on descriptive input text.
- **AST Parsing**: Uses Abstract Syntax Tree (AST) to extract function names and descriptions.
- **LLM Integration**: Utilizes a language model to find and execute the appropriate function.
- **Flexible Module Loading**: Imports functions from any Python file at runtime.

## Installation

Install the module using pip:


## Usage Example

from ai_agent import Controller

input_text = "what is 10+90?"
controller = Controller(input_text, 'sample.py')

result = controller.execute()
print(result) 


```bash
pip install ai-controller
pygstudio 1.0.3
A simple format with tools to help build games easily with pygame.
Requires Python: >=3.8

# Pygstudio

A template to make games easier like what you see in game engines like Unity and Roblox.

## How to use pygstudio
- To create your own pygstudio project, type in your terminal:
`pygstudio create [NAME]` or `python -m pygstudio create [NAME] -o [DESTINATION]`.
This will make a new pygstudio template in your directory / destination.

## What can you do with pygstudio?
1. Easy configuration - Each file are provided with comments to help you guide in building your game. You can also edit the code if you don't like the code.
2. Easy access - Your scripts can access various things like the globals, components and assets by putting these lines of code: `import globals` `import components` `pygame.image.load("assets/mypicture.png")` (an example of using assets). Example:
```
# scripts/npc.py
import pygame, random
import globals, components

for i in range(10):
    npc_character_image = pygame.image.load("assets/smol_npc.png")
    new_npc = components.characters.NPC(npc_character_image, (random.random() * 100, random.random() * 1000))   # NPC(image, position)
    globals.npcs.append(new_npc)
    new_npc.start_being_npc()
```
3. Threaded scripts - Make a script easily by making a file/package inside the `scripts` directory. 

Instead of this monstrosity:
```
import threading

def fire_function_every_3_seconds(): ...   # takes 15 lines of code
def handle_physics(): ...   # takes 300 lines of code 
def handle_network(): ...   # takes 258 lines of code

threading.Thread(daemon=True, target=fire_function_every_3_seconds).start()
threading.Thread(daemon=True, target=handle_physics).start()
threading.Thread(daemon=True, target=handle_network).start()
```
You can now put them in their separate files and they will be executed independently.
```
# scripts/loop.py
...     # the entire `fire_function_every_3_seconds` code
```
```
# scripts/physics.py
...     # the entire `handle_physics` code
```
```
# scripts/network.py
...     # the entire `handle_network` code
```

## Template
The file structure of pygstudio follows (where `NAME` is your project name): 

_(Version 1.0)_
```
[NAME]/
- [NAME].py
- globals.py
- engine.py
- script_manager.py
- assets/
- scripts/
- components/
    - __init__.py
```

## About
Hello, I am only a developer making this project. If you wish to improve this project, you may fork this repository and add me in the credits of your repository. I will still continue improving this project but I cannot guarantee that I can repond to all your issues as I am only a student in a university.

This project is licensed.
paddle-webhook-signature-verifier 1.0.2
A Python package for verifying Paddle webhook signature
Requires Python: >=3.6

# Paddle webhook signature verifier for Python
A Python package for verifying Paddle webhook signatures. Official Paddle SDKs are only available for PHP and Node.js. This packagage helps server side verification of Paddle webhook signatures if you are using a Python based backend framework like Django, Flask, FastAPI, etc.

## Installation
```bash
pip install paddle-webhook-signature-verifier
```

## Usage
### FastAPI example
```Python
from fastapi import FastAPI, Request, Header, HTTPException
from paddle_webhook_signature_verifier import WebhookHandler

app = FastAPI()
handler = WebhookHandler(secret_key=b'your_secret_key')

@app.post("/webhook")
async def webhook(request: Request, paddle_signature: str = Header(None)):
    try:
        body_bytes = await request.body()
        handler.verify_paddle_signature(paddle_signature, body_bytes)
        return {"status": "ok"}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
```
### Flask example
```Python
from flask import Flask, request, abort
from paddle_webhook_signature_verifier import WebhookHandler

app = Flask(__name__)
handler = WebhookHandler(secret_key=b'your_secret_key')

@app.route("/webhook", methods=["POST"])
def webhook():
    try:
        paddle_signature = request.headers.get("Paddle-Signature")
        body_bytes = request.get_data()
        handler.verify_paddle_signature(paddle_signature, body_bytes)
        return {"status": "ok"}, 200
    except ValueError as e:
        abort(400, description=str(e))
```
### Django example
```Python
from django.http import JsonResponse
from paddle_webhook_signature_verifier import WebhookHandler

handler = WebhookHandler(secret_key=b'your_secret_key')

def webhook(request):
    try:
        paddle_signature = request.headers.get("Paddle-Signature")
        body_bytes = request.body
        handler.verify_paddle_signature(paddle_signature, body_bytes)
        return JsonResponse({"status": "ok"})
    except ValueError as e:
        return JsonResponse({"error": str(e)}, status=400)
```

## Contributing
Contributions are welcome! Please fork the repository and submit a pull request with your improvements.

## License
This project is licensed under the MIT License. See the LICENSE file for more details

## Contact
For any questions or suggestions, feel free to open an issue or contact the maintainer at aneesh.arora.aa@gmail.com
LLMscreen 1.0.0
A package for filtering abstracts using OpenAI models.
Requires Python: >=3.6
Keywords: abstract filtering, OpenAI, systematic reviews, research

LLMscreen is a package that allows users to filter and process research abstracts 
                         based on given criteria using OpenAI's language models. It supports both simple 
                         and zeroshot approaches for inclusion criteria and provides detailed outputs 
                         including probabilities and perplexity scores.