semvec/pypi-packages huggingface dataset:
7rb 0.0.0
Telethon custom emoji By : t.me/goldenxpris.
Requires Python: >=3.6

# 7rb Library

Advanced custom emoji handler for Telethon .

## Installation
```bash
pip install 7rb
```

## Usage

### Basic Setup
```python
import 7rb
from telethon import TelegramClient

client = TelegramClient('session', api_id, api_hash)
```

### Golden Method (Emoji Conversion)
```python
emoji_map = {
    '✨': '5280790529565536648',
    '💃🏻': '5280790529565536648'
}

7rb.Golden(client, emoji_map)
```

### Emoji Extraction
```python
@client.on(events.NewMessage)
async def handler(event):
    emoji_ids = 7rb.Emoji(event.message)
    if emoji_ids:
        print("Found custom emojis:", emoji_ids)
```

## Features
- Convert regular emojis to custom emojis
- Extract custom emoji IDs from messages
- Works with all Telethon send methods
- By : @YoGoLdEn .
USL-USTC-lib 2025.6.3
Some useful functions for USL(ultra-stable laser)
Requires Python: >=3.8

# USL_USTC_lib

## Introduction

USL_USC_lib is a python package for **ultra-stable laser system** researching in **USTC**, it includings many functions for data deal and calculation, like read TCH data and calculate its PSD and Allan deviation.


## Installation

Install from pypi:

`pip install USL-USTC-lib`


## Basic usage

In python:

`import USL_USTC_lib as usl`

## Functions

|Function|Description|
|--|--|
|`plot_data_labview()`|Plot the data's gragh from Labview, including the time domain, PSD and Allan Deviation.|
alectors 2.0.3
transformer-based rl agents for nlp tasks
Requires Python: >=3.13

# alectors

`alectors` is a library providing transformer-based rl agents for nlp tasks, that is extremely customizable, but also comes with sane defaults.

> source code: [https://erga.apotheke.earth/apotheke/alectors](https://erga.apotheke.earth/apotheke/alectors)  
> license: [GPLv3 or later](https://gnu.org/licenses/gpl-3.0.html)  

## Why "alectors"?

The word lector has deep etymological roots in language. Derived from the Latin *legere* ("to read"), it originally referred to someone who read aloud, to an audience, students, or even in religious ceremonies.  
The term nowdays survives mostly in an academic setting, where a lecturer is typically tied to teaching, or discussing ideas with an audience. Typical modern uses of the word are "lecturer" in English, "λέκτορας" in Greek, and "lektor" in Polish.  
However, adding the prefix α- changes the word's meaning entirely. An *alector* (*ἀλέκτωρ*) means "cock" (rooster) in Greek. This juxtaposition s very funny, hence the name.

## Description

Modern NLP solutions like GPTs and BERTs have made great strides in language processing and generation, however they fall short of actual decision making.

As an example, consider an LLM trying to play a game of chess.

While it may be able to make valid moves, and even provide a justification, it still lacks any *true* capacity to calculate the optimal position; it is a word generator, and so the best thing it can do is convince itself that it makes sense.
It lacks a reward incentive during training, and even worse, rather LLMs rely on static token distributions without real-time feedback.

`alectors` tries to address this gap by shifting the focus to reinforcement learning in place of supervised pretraining. An *alector* learns to generate *actions* based on natural language.

The way we approach this is by using pretrained encoders in specialized language environments.

### Mechanism

In essence, we can describe any environment using natural language; some environments lend themselves to this type of description better, and this description of the state is then given to a pretrained encoder, that parses it and spits out a layer of vector embeddings[^1].

This *vector representation of the natural language description of the state* is then passed to the agent, and used in traditional rl ways (ppo, sac, etc)

The agent therefore trains on natural language reinforcement learning, without the need of any pretraining/finetuning as is the case for LLMs.

## Supported Architectures

The currently supported architecture is PPO. Plans exist to include SAC, GRPO, and maybe DDQN. As we add them to `telestes` they will be almost automatically imported here[^2].

[^1]: for our purpose we care about the token embeddings, so we throw the [CLS] token away.
[^2]: modulo some tweaks in `learn()` and `choose_action()`, to include the encoder in the functions.
gemini-agent-helper 0.1.1
Add your description here
Requires Python: >=3.8

# 🤖 gemini\_helper

**Use Gemini API with OpenAI Agent SDK easily!**
This package allows students and developers to use free Gemini models (like `gemini-2.0-flash`) with the powerful [OpenAI Agent SDK](https://github.com/openai/openai-agents).

---

## 🚀 Installation

Using [uv](https://github.com/astral-sh/uv) (recommended):

```bash
uv add gemini-agent-helper
```

Or via pip:

```bash
pip install gemini-agent-helper
```

---

## ⚙️ Environment Setup

Create a `.env` file in your project root and add your Gemini API key:

```env
GEMINI_API_KEY=your_gemini_api_key_here
```

> 📌 You can get your key from [Google AI Studio](https://makersuite.google.com/app/apikey)

---

## 💡 How to Use

### ✅ Default (uses `gemini-2.0-flash`)

```python
from gemini_helper.core import get_gemini_model

model = get_gemini_model()
```

### ⚡ Custom model (like `gemini-1.0-pro`)

```python
model = get_gemini_model("gemini-1.0-pro")
```

---

## 💻 Full Example

```python
from gemini_helper.core import get_gemini_model
from agents import Agent, Runner

model = get_gemini_model()

agent = Agent(
    name="Helper",
    instructions="You are a helpful assistant",
    model=model
)

result = Runner.run_sync(agent, input="What is Python?")
print(result.final_output, end="")  
```

---

## 📆 Features

* 🔐 Secure API key handling via `.env`
* 🔄 Compatible with OpenAI Agent SDK
* 💸 No need for OpenAI's paid API – fully free using Gemini
* ⚙️ Optional model switching (e.g. `gemini-1.0-pro`, `gemini-2.0-pro`)
* 🧹 Easy to integrate into agent-based workflows

---

## 🛠️ Dependencies

This package depends on:

* `openai-agent-sdk`
* `python-dotenv`

These are automatically installed with the package.

---

## 🧑‍💻 Author

Made with ❤️ by **Huriya Syed**
Empowering students to build free agents using Gemini + OpenAI SDK.

---

## 📬 Contact / Support

Feel free to open an issue or connect with me on [LinkedIn](https://www.linkedin.com/in/huriya-syed-598371281/)
Or email me at: **[huriyasyed462@gmail.com](mailto:huriyasyed462@gmail.com)**
ctfd-downloader 1.0.1
A tool to download challenges, files, and metadata from a CTFd instance and output them into an organized directory.
Requires Python: >=3.6

# Python CTFd Downloader
A script to download all the challenges and files from the CTFd instance.

## Installation

### Using Pip

```pip install ctfd-downloader```
    
#### Generate Access Token

In order to interact with the CTFd API, you'll need to create an Access Token. You can do this by browsing to the Settings page under your profile in the top-right corner of the page, then click on the Access Tokens tab. After inputting an expiration date, click on Generate to create a new token.

#### Run The Downloader

```ctfd-downloader -u http://ctf.url -n ctf_name -o /home/user/Desktop/ -t access_token```

You can use the `--update` flag to update an existing repository with new challenges without redownloading everything.

#### Formatter

There is also another script, which you can use to add a check mark emoji on any completed writeups in the main README file. You can do this by adding writeups to challenge README files under a `## Solution` header.

```
# Example Challenge README

<autogenerated challenge description>

## Solution

My solution
```

Run the formatter just by pointing it at the directory of the repo.

```
python format.py ./ctfd_repo/
```
teenygrad 0.1.0
Teenygrad JIT compiler.
Requires Python: >=3.7

# teenygrad

This is the Python package for the `teenygrad` interop module. It provides Python bindings and utilities for using `teenygrad` from Python.

## Installation

You can install this package using pip (after publishing to PyPI):

```bash
pip install teenygrad
```

## Usage

```python
import teenygrad
# Your code here
```

## Development

- Place your Python source code in the `teenygrad/` directory.
- Update `pyproject.toml` and `setup.cfg` as needed for packaging.