semvec/pypi-packages huggingface dataset:
dlgram 2.3.61
Fork of pyrogram. Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots
Requires Python: ~=3.9
Keywords: async, dlgram, library, mtproto, pyrofork, pyrogram, python, telegram, telegram-api, telegram-bot, telegram-client

# Pygram

<p align="center">
  <b>Elegant, modern, and fully asynchronous Telegram MTProto framework for Python</b>
</p>

---

## Introduction

**Pygram** is a modern, elegant, and fully asynchronous MTProto API framework for Telegram, designed for both **user accounts** and **bots**. It provides a clean and intuitive Python interface to interact with Telegram’s core API, while still exposing powerful low-level capabilities when you need them.

Whether you're building automation tools, chat utilities, music bots, or full‑fledged Telegram clients, Pygram gives you the flexibility, performance, and developer experience you expect from a modern framework.

---

## Quick Example

```python
from pyrogram import Client, filters

app = Client("my_account")


@app.on_message(filters.private)
async def hello(client, message):
    await message.reply("Hello from Pygram!")


app.run()
```

---

## Key Features

* 🚀 Ready to Use – Install with pip and start immediately
* 🧠 Easy & Intuitive – Clean, Pythonic API
* ✨ Elegant – Developer‑friendly abstractions
* ⚡ Fast – Powered by TgCrypto (C based)
* 🧩 Type‑hinted – Excellent IDE support
* 🔄 Fully Asynchronous – Async-first design
* 🛠 Powerful – Full Telegram API access

---

## Installation

```bash
pip3 install pygram
```

Or install the latest development version directly from GitHub:

```bash
pip3 install git+https://github.com/growxupdate/pygram.git
```

---

> Pygram is built for developers who want speed, clarity, and full control over Telegram’s MTProto API.
WebRequest 0.1.0
Like `requests`, but shittier.

### WebRequest  [![Build Status](https://travis-ci.org/fake-name/WebRequest.svg?branch=master)](https://travis-ci.org/fake-name/WebRequest)[![Coverage Status](https://img.shields.io/coveralls/fake-name/WebRequest.svg)](https://coveralls.io/r/fake-name/WebRequest)

Like the `requests` library, but less good.

Provides convenience functions for writing web-scrapers and other web-interactive
things. Built-in support for working through CloudFlare's garbage JS browser
checks without any intervention, as well as some other [garbage web-application 
firewalls](https://sucuri.net/website-firewall/) that seem intent on 
breaking the internet.

Built-in user-agent randomization. Support for fetching rendered content via 
headless chrome. Built on top of my [ChromeController](https://github.com/fake-name/ChromeController) 
project, so it can avoid some of the [spectacularly stupid design 
decisions](https://github.com/seleniumhq/selenium-google-code-issue-archive/issues/141) in selenium.

Default support for compressed transfers. 

Basically, the overall goal is to have a simple library that acts *as much as 
possible* like a "real" browser. Ideally, it should be indistinguishable from 
an actual browser from the perspective of the remote HTTP(s) server.

Other useful bits:

API wrappers for 2captcha.com and anticaptcha.com which include automatic local 
reverse-proxy spinup for reflecting recaptcha requests through your local host 
address. This involves spinning up a transient SOCKS5 proxy, setting up a limited 
duration port-forward (10 minutes, via UPnP), and actual synchronous captcha 
solving calls.

The proxy setup/UPnP setup functions are generic enough that they should be 
useful for any captcha-solver-related tasks. If you'd like support for another 
solver site (and are willing to throw a few bucks of credit on a solver site to 
me), I can probably add that other site too.


Q: Why  
A: Because I started writing horrible web-scraper things in 2008, when the 
    requests library wasn't really a thing.  

Q: Why *still*, then?  
A: Anger and spite, mostly.  

Q: No, really, *why*  
A: Ok, Because I want to download the internet, and idiots post stuff, and then
    try to "protect" it from scraping with stupid jerberscript bullshit.

## Note: If your non-interactive webite requires me to execute javascript to view it, FUCK YOU, you are a horrible person who is actively ruining the internet.

License:
WTFPL
okap 0.1.2
Python SDK for OKAP (Open Key Access Protocol) - Secure API key delegation
Requires Python: >=3.10
Keywords: ai, anthropic, api-keys, oauth, okap, openai, security

<p align="center">
  <img src="https://raw.githubusercontent.com/openkeyprotocol/okap/main/logo.png" alt="OKAP Logo" width="120">
</p>

# OKAP Python SDK

Python SDK for [OKAP](https://github.com/openkeyprotocol/okap) (Open Key Access Protocol) - Secure API key delegation.

## Installation

```bash
pip install okap
```

For vault server functionality:
```bash
pip install okap[vault]
```

## Quick Start

### For Apps (Requesting Access)

```python
from okap import OkapClient

# Connect to user's vault
client = OkapClient(
    vault_url="https://vault.example.com",
    app_name="My AI App"
)

# Request access to OpenAI
token = client.request_access(
    provider="openai",
    models=["gpt-4", "gpt-4o-mini"],
    capabilities=["chat"],
    monthly_limit=10.00,  # $10/month max
    reason="For AI-powered features"
)

# Use with OpenAI SDK - just change base_url
from openai import OpenAI

ai = OpenAI(
    api_key=token.token,
    base_url=token.base_url  # Points to vault proxy
)

response = ai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

### For Vaults (Hosting Keys)

```python
from okap.vault import OkapVault, MemoryStorage
from fastapi import FastAPI

app = FastAPI()
vault = OkapVault(
    storage=MemoryStorage(),
    base_url="https://vault.example.com"
)

# Add your API keys
vault.add_key("openai", "sk-...")
vault.add_key("anthropic", "sk-ant-...")

@app.post("/okap/request")
def handle_request(request: dict):
    from okap.models import AccessRequest
    req = AccessRequest.model_validate(request)
    
    # In production, show approval UI to user first!
    # For demo, auto-approve:
    return vault.approve_request(req)
```

## Features

- **Secure delegation**: Master keys never leave the vault
- **Usage limits**: Set spend caps and rate limits per app
- **Expiration**: Tokens auto-expire
- **Revocable**: Revoke access instantly
- **Provider agnostic**: Works with OpenAI, Anthropic, Google, etc.

## Models

### AccessRequest
```python
from okap import AccessRequest

request = AccessRequest(
    provider="openai",
    models=["gpt-4"],
    capabilities=["chat", "embeddings"],
    limits=Limits(monthly_spend=10.00),
    expires="2025-03-01",
    reason="For my cool app"
)
```

### OkapToken
```python
from okap import OkapToken

# Returned after approval
token = OkapToken(
    token="okap_abc123...",
    base_url="https://vault.example.com/v1/openai",
    provider="openai",
    models=["gpt-4"],
    expires_at=datetime(2025, 3, 1)
)
```

## Error Handling

```python
from okap import OkapClient
from okap.errors import AccessDeniedError, VaultError

try:
    token = client.request_access(provider="openai")
except AccessDeniedError as e:
    print(f"User denied access: {e}")
except VaultError as e:
    print(f"Vault error: {e}")
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check .
```

## License

MIT
ds-otbi-dmdata-upd 0.0.3
Update Sample Data on Fusion OTBI Data Models
Requires Python: >=3.8

# ds-otbi-dmdata-upd
Fusion OTBI Data Models Sample Data Update

This script is used to update the sample data on the BIP report models. 
It takes the instance, credentials and the file containing the list of data models as its input.
It traverses through each of the data model and updates the sample data.