ferogram 0.5.0b2__tar.gz → 0.5.2__tar.gz

{ferogram-0.5.0b2 → ferogram-0.5.2}/.github/workflows/publish.yml

@@ -146,7 +146,7 @@ jobs:
       - name: Install maturin
         run: pip install maturin
 
-      - name: Fetch Termux libpython3.13 for linking
+      - name: Fetch Termux libpython for linking
         run: |
           TARGET=${{ matrix.target }}
           case "$TARGET" in
@@ -166,21 +166,35 @@ jobs:
           curl -sL "https://packages.termux.dev/apt/termux-main/${DEB_PATH}" -o python.deb
           ar x python.deb
           # data archive may be .tar.xz or .tar.zst depending on Termux version
-          tar xf data.tar.* --wildcards "*/libpython3.13*" 2>/dev/null || true
+          # Don't pin the minor version here - Termux's "python" package always
+          # tracks upstream latest, and older debs fall out of the Packages
+          # index once superseded, so a hardcoded "libpython3.13" wildcard
+          # breaks the moment Termux bumps its default Python.
+          tar xf data.tar.* --wildcards "*/libpython3.*" 2>/dev/null || true
 
           LIB_DIR=/tmp/termux-py/data/data/com.termux/files/usr/lib
-          # Ensure the unversioned name exists for -lpython3.13
-          if [ ! -f "$LIB_DIR/libpython3.13.so" ]; then
-            ln -sf "$(basename $(ls $LIB_DIR/libpython3.13.so* | head -1))" \
-                   "$LIB_DIR/libpython3.13.so"
+          SO_FILE=$(ls "$LIB_DIR"/libpython3.*.so* 2>/dev/null | head -1)
+          if [ -z "$SO_FILE" ]; then
+            echo "::error::No libpython3.*.so found in Termux's python package ($DEB_PATH)"
+            exit 1
           fi
+
+          # Extract "3.14" out of ".../libpython3.14.so"
+          PYVER=$(basename "$SO_FILE" | sed -E 's/^libpython(3\.[0-9]+)\.so.*/\1/')
+          UNVERSIONED="$LIB_DIR/libpython${PYVER}.so"
+          if [ ! -f "$UNVERSIONED" ]; then
+            ln -sf "$(basename "$SO_FILE")" "$UNVERSIONED"
+          fi
+
           echo "TERMUX_LIBDIR=$LIB_DIR" >> $GITHUB_ENV
+          echo "TERMUX_PYVER=$PYVER" >> $GITHUB_ENV
+          echo "Linking against Termux libpython $PYVER ($SO_FILE)"
 
       - name: Build Android wheel
         env:
           ANDROID_NDK_HOME: ${{ steps.ndk.outputs.ndk-path }}
           ANDROID_API_LEVEL: ${{ matrix.api }}
-          PYO3_CROSS_PYTHON_VERSION: "3.13"
+          PYO3_CROSS_PYTHON_VERSION: ${{ env.TERMUX_PYVER }}
         run: |
           NDK_BIN=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
           TARGET=${{ matrix.target }}
@@ -203,11 +217,13 @@ jobs:
           export AR_${TARGET_LOWER}=$NDK_BIN/llvm-ar
           export CARGO_TARGET_${TARGET_UPPER}_LINKER=$NDK_BIN/${CLANG_PREFIX}-clang
 
-          # Link against Termux's real libpython3.13.so (not an empty stub).
-          # This embeds DT_NEEDED: libpython3.13.so in the extension, so
-          # bionic resolves all Python symbols explicitly at dlopen time via
-          # Termux's LD_LIBRARY_PATH - instead of relying on global namespace
-          # propagation, which Android's linker does not guarantee.
+          # Link against Termux's real libpython<version>.so (not an empty
+          # stub). This embeds DT_NEEDED: libpython<version>.so in the
+          # extension, so bionic resolves all Python symbols explicitly at
+          # dlopen time via Termux's LD_LIBRARY_PATH - instead of relying on
+          # global namespace propagation, which Android's linker does not
+          # guarantee. The version is whatever Termux's apt repo currently
+          # ships (see the fetch step above), not a fixed constant.
           export RUSTFLAGS="-L native=$TERMUX_LIBDIR"
 
           maturin build \

{ferogram-0.5.0b2 → ferogram-0.5.2}/CHANGELOG.md

@@ -1,3 +1,110 @@
+## 0.5.2 (2026-07-17)
+
+- Added `Client.get_chat_photos(peer, limit)`: photo/avatar history for groups and channels (`get_profile_photos` only ever worked for users). Current photo comes from the chat's full info, so it survives message deletion; older photos come from `messageActionChatEditPhoto` search history.
+- Added fast re-auth support: `sign_out()` captures a `future_auth_token` when Telegram returns one and persists it via a new `DcConnection.get_future_auth_token`/`set_future_auth_token` pair (rides along in the existing session blob, no new session format code needed here). `request_login_code()` replays it automatically, so a returning session can skip code entry entirely (`auth.sentCodeSuccess`).
+- MTProto handshake fix upstream (dc-tagged `p_q_inner_data` was being rejected by Telegram with RPC 444 outside DC2), pulled in transitively via `ferogram-mtsender`.
+- Layer Upgrade to 228
+## 0.5.1 (2026-06-29)
+
+## What's Changed
+
+### Message API Improvements
+
+- `Message.reply()` now creates a proper quoted reply using `reply_to=self.id`.
+- Added `Message.respond()` for sending messages to the same chat without replying.
+- Added `pin()`, `forward_to()`, `get_sender()`, `get_chat()`, and `get_reply_message()` helpers.
+- Added `reply_photo()` and `reply_document()` convenience methods.
+- Improved `delete()` to correctly handle channels and supergroups.
+
+### Client Enhancements
+
+- Added `reply_to` support to `send_message()`, `send_photo()`, and `send_document()`.
+- Added `Client.get_user()` and `Client.get_chat()` helpers.
+- `edit_message()` now accepts `reply_markup`.
+- `pin_message()` now supports a `notify` parameter.
+- Improved `delete_messages_in()` for channel-aware message deletion.
+- Improved sent message extraction fallback behavior with warning logging and preserved context.
+
+### Update Improvements
+
+- Added convenience methods to `CallbackQuery`:
+  - `respond()`
+  - `reply()`
+  - `edit_message_text()`
+  - `get_sender()`
+
+- Added convenience methods to `InlineQuery`:
+  - `answer()`
+  - `get_sender()`
+
+- Added sender/entity helpers for additional update types, including:
+  - `InlineSend`
+  - `UserStatus`
+  - `ChatAction`
+  - `JoinRequest`
+  - `ParticipantUpdate`
+  - `MessageReaction`
+  - `ChatBoost`
+  - `ShippingQuery`
+  - `PreCheckoutQuery`
+
+### Dispatch Improvements
+
+- `_dispatch()` now binds `_client` for all update types.
+- Added `_client` support to remaining update wrappers, including `RawUpdate`.
+- Improved sent message extraction fallback handling.
+
+## 0.5.0 (2026-06-28)
+
+### Architecture
+
+The Rust dependency has changed from the monolithic `ferogram` crate to five focused crates from the ferogram core:
+
+- `ferogram-mtsender` - MTProto sender, message framing, and acknowledgement
+- `ferogram-session` - session storage (file, sqlite, libsql, memory, string)
+- `ferogram-connect` - TCP/TLS transport and DC routing
+- `ferogram-tl-types` - generated TL type definitions
+- `ferogram-crypto` - AES-IGE, Diffie-Hellman, and SHA helpers
+
+These five crates form the battle-tested lower layer of ferogram. They change rarely and are stable across minor versions. All high-level logic (message parsing, update dispatch, peer resolution, serialization, deserialization) now lives in Python. This split means the compiled extension is smaller and faster to build, and Python-side behaviour can be updated without recompiling the Rust extension.
+
+The compiled extension now uses `abi3-py39` (was `abi3-py313`), so a single wheel runs on Python 3.9 and later.
+
+### Added
+
+- **`TransferHandle`** - pause, resume, and cancel any upload or download in flight. Create a `TransferHandle`, pass it to `upload_with_progress` or `download_with_progress`, then call `.pause()`, `.resume()`, or `.cancel()` from any coroutine. `.progress()` returns a dict with `done`, `total`, `elapsed_ms`, `percent`, `speed_bps`, `eta_secs`, `speed_human`, and `bytes_human`.
+- **`TransferCancelled` exception** - raised when a `TransferHandle` is cancelled mid-transfer.
+- **`keyboards` module** - `InlineKeyboard`, `InlineButton`, `ReplyKeyboard`, `ReplyButton`, `RemoveKeyboard`, and `ForceReply` are now pure Python and importable from `ferogram` directly.
+- **`types` module** - all entity types (`User`, `Message`, `Chat`, `Dialog`, `ChatMember`, `UserFull`, `Authorization`, `ForumTopic`, `BotInfo`, `InviteLinkMember`, `ReadParticipant`, `AdminLogEvent`, `StickerSetInfo`, `BroadcastStats`, `MegagroupStats`, `NotifySettings`) moved from Rust to Python dataclasses. The public API is identical.
+- **`updates` module** - update wrapper types (`NewMessage`, `EditedMessage`, `MessageDeletion`, `CallbackQuery`, `InlineQuery`, `InlineSend`, `UserStatus`, `ParticipantUpdate`, `JoinRequest`, `MessageReaction`, `PollVote`, `BotStopped`, `ShippingQuery`, `PreCheckoutQuery`, `ChatBoost`, `RawUpdate`) moved from Rust to Python dataclasses.
+- **`rich` module** - `send_rich_message`, `edit_rich_message`, `send_rich_message_draft`, and `get_rich_message` via a `_RichMixin`. Supports Telegram rich text blocks including headers, tables, collages, task lists, footnotes, math, time stamps, and custom emoji via Markdown or HTML input.
+- **Automatic TL codegen at build time** - `build.rs` now runs `ferogram/raw/codegen.py` during `maturin develop` / `pip install .`. Set `FEROGRAM_SKIP_CODEGEN=1` to skip if you only changed Rust. The codegen uses the same Python interpreter maturin selected.
+- **`DcConnection` and `srp_calculate`** exposed from the Rust extension for use by the pure-Python `Client` class.
+- **`LAYER` constant** exported from `ferogram.raw.generated._tl_schema` and used automatically in `invokeWithLayer` wrappers.
+- **`all_updates` filter** - replaces the old `all` filter (which shadowed the built-in).
+- **`filters` improvements** - all filters now unwrap `NewMessage` / `EditedMessage` wrapper objects before inspecting the inner `Message`. Previously filters broke when the dispatcher passed wrapper objects instead of bare messages.
+
+### Changed
+
+- `Message`, `User`, `Chat`, and all entity types are now Python dataclasses instead of PyO3 structs. They serialize to / from the TL dict representation in Python. No change to the public API.
+- `CallbackQuery`, `InlineQuery`, and all update types are now Python dataclasses.
+- `InlineKeyboard`, `ReplyKeyboard`, and related keyboard builders are now pure Python (`ferogram/keyboards.py`). Previously they were Rust structs.
+- Filters rewritten to correctly unwrap update wrapper objects. `reply` filter now checks `reply_to_msg_id`; `forwarded` checks `forward_from_id`; `media` checks the `media` field directly.
+- `codegen.py` doubled in size (321 to 691 lines): now generates specialized `to_bytes()` methods using `struct.pack` inline and a CID-dispatch `from_bytes()` router, producing faster serialization and deserialization than the previous schema-dict approach.
+- `ferogram-py` version bump to 0.5.0. Core crates pinned to `ferogram-*` 0.6.3.
+
+### Removed
+
+- Direct dependency on the monolithic `ferogram` crate. The five focused crates replace it.
+- `hex` crate dependency (was `0.4`, now unused).
+- `all` filter removed and replaced with `all_updates` to avoid shadowing Python's built-in `all`.
+
+
+## 0.4.1 (2026-06-03)
+
+Patch release. No API changes. Identical to 0.4.0 except for dependency pins and minor internal fixes.
+
+
 ## 0.4.0 (2026-06-01)
 
 ### Added
@@ -20,7 +127,7 @@
 - **`flood_sleep_threshold` kwarg on `Client`** - maps to the `AutoSleep` retry policy in the Rust core. Flood waits under this value are slept through automatically; waits above it are raised as exceptions.
 - **`download_with_progress(peer, msg_id, path, on_progress)`** - download media with a progress callback `on_progress(done, total)`.
 - **`upload_with_progress(path, on_progress)`** - upload a file with a progress callback. Returns a handle string accepted by `send_file`.
-- **`ferogram` 0.6.0 as core dependency** - includes `Client.channel_kind_of(channel_id)` which backs the new `Message` methods above.
+- **ferogram 0.6.0 as core dependency** - includes `Client.channel_kind_of(channel_id)` which backs the new `Message` methods above.
 
 ### Changed
 
@@ -62,9 +169,6 @@ the votes graph as a JSON string. The old `get_poll_results(peer, msg_id, poll_h
 is kept for backward compat but is deprecated; the `poll_hash` parameter is ignored
 because ferogram 0.5.0 dropped the underlying API call it relied on.
 
----
-
-# Changelog
 
 ## 0.2.3 (2026-05-14)
 
@@ -124,7 +228,6 @@ Ten new methods for managing group and channel members.
 
 `get_poll_results(peer, msg_id, poll_hash)` was in Rust but had no Python wrapper. Now exposed. Fetches and caches the latest poll results from Telegram.
 
----
 
 ## 0.2.2
 

{ferogram-0.5.0b2 → ferogram-0.5.2}/Cargo.lock

@@ -392,9 +392,9 @@ checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
 [[package]]
 name = "ferogram-connect"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90734b153432187e49e05b3b79737b2ac69cd3647b1dc2f572dd63cdeeeea048"
+checksum = "54211f9669f8bb7db8101d952514784311a1e135c01eb04d8732d465cdb2aa73"
 dependencies = [
  "ferogram-crypto",
  "ferogram-mtproto",
@@ -409,9 +409,9 @@ dependencies = [
 
 [[package]]
 name = "ferogram-crypto"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bfa17a936160758b481d56f5674644290fa372165c2a416b21068ae484aed5"
+checksum = "0e9b1bf8c53553a3fa8acbfdc0f9f9ede749f786a5d62c26c57a4dd20b793b4d"
 dependencies = [
  "aes",
  "ctr",
@@ -427,9 +427,9 @@ dependencies = [
 
 [[package]]
 name = "ferogram-mtproto"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb92042988257514b90ed249214747225388bb38806f904c25c4659ec70f2051"
+checksum = "007456e26302ca4a2f63019ed88c2055705ecf7752f823520d41aa2f8803b42e"
 dependencies = [
  "ferogram-crypto",
  "ferogram-tl-types",
@@ -441,9 +441,9 @@ dependencies = [
 
 [[package]]
 name = "ferogram-mtsender"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde7ed2cd881032574626cda99d8fce73e32e4d884c843444d488fb608364e20"
+checksum = "4fb2d34f025b0c6369d42f08317e3ded5bb8aa83bdec48fd443a4cc26fa4c9cf"
 dependencies = [
  "ferogram-connect",
  "ferogram-crypto",
@@ -457,7 +457,7 @@ dependencies = [
 
 [[package]]
 name = "ferogram-py"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "base64 0.22.1",
  "ferogram-connect",
@@ -474,9 +474,9 @@ dependencies = [
 
 [[package]]
 name = "ferogram-session"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "307cfc80221fd742fa87af28bc629cb7acc9e6c89ceb7fa823068fb9df581989"
+checksum = "c29506aee6e38e3f62623f28f17dfa470f347a87f65030313bf62f9b8dd12dd1"
 dependencies = [
  "base64 0.22.1",
  "libsql",
@@ -488,24 +488,24 @@ dependencies = [
 
 [[package]]
 name = "ferogram-tl-gen"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe1bc77068bf406a6407dd9810fe80b70d9df18ce9069b2d5100b943f8caa638"
+checksum = "501f1b96b5981e83d8328391dc6aa31df208dd8662f2b814117a345e570060ae"
 dependencies = [
  "ferogram-tl-parser",
 ]
 
 [[package]]
 name = "ferogram-tl-parser"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f092429c003263fa28e33f3090c41aedb2a7462fbc7b8f82172b0bf92ec1a205"
+checksum = "d7337bdfb8be8eee3155a1af8ead1c34c2cfc2de738428574b1661d2094a7389"
 
 [[package]]
 name = "ferogram-tl-types"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad3ec63abcbf0592390d400f73679d2149f9441c6c5ee8e9288b83ad32f76085"
+checksum = "61d5a7ed4c2996730a9a35d06a33abaadc246dd828ba1ab5727bd5bbd8699a95"
 dependencies = [
  "ferogram-tl-gen",
  "ferogram-tl-parser",

{ferogram-0.5.0b2 → ferogram-0.5.2}/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name        = "ferogram-py"
-version     = "0.5.0"
+version     = "0.5.2"
 edition     = "2024"
-description = "Python bindings for ferogram (Rust MTProto)"
+description = "Python MTProto client based on ferogram (Rust MTProto)"
 build       = "build.rs"
 license     = "MIT OR Apache-2.0"
 readme = "README.md"
@@ -12,11 +12,11 @@ name       = "_ferogram"
 crate-type = ["cdylib"]
 
 [dependencies]
-ferogram-mtsender   = { version = "0.6.3" }
-ferogram-session    = { version = "0.6.3", features = ["sqlite-session", "libsql-session"] }
-ferogram-connect    = { version = "0.6.3" }
-ferogram-tl-types   = { version = "0.6.3" }
-ferogram-crypto     = { version = "0.6.3" }
+ferogram-mtsender   = { version = "0.6.4" }
+ferogram-session    = { version = "0.6.4", features = ["sqlite-session", "libsql-session"] }
+ferogram-connect    = { version = "0.6.4" }
+ferogram-tl-types   = { version = "0.6.4" }
+ferogram-crypto     = { version = "0.6.4" }
 getrandom           = "0.2"
 base64              = "0.22"
 pyo3                = { version = "0.24", features = ["extension-module", "abi3-py39"] }

{ferogram-0.5.0b2 → ferogram-0.5.2}/FEATURES.md

@@ -387,6 +387,7 @@ await client.upload_with_progress(path, on_progress=None)
 await client.edit_chat_photo(peer, path)
 await client.delete_profile_photos()
 await client.get_profile_photos(peer, limit=100)
+await client.get_chat_photos(peer, limit=100)
 ```
 
 Important current behavior:
@@ -642,6 +643,11 @@ await client.get_authorizations()
 await client.terminate_session(hash)
 ```
 
+`sign_out()` captures a `future_auth_token` when Telegram provides one, and
+`request_login_code()` replays it automatically on the next login. When
+that succeeds, Telegram authorizes the session immediately, no code entry
+needed - check for `"_": "auth.sentCodeSuccess"` on the returned dict.
+
 ## Bot management
 
 ```python

ferogram-0.5.2/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: ferogram
+Version: 0.5.2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
+Summary: A modern, elegant, asynchronous MTProto framework for building Telegram user clients and bots in Python.
+Keywords: telegram,mtproto,rust,client,bot,ferogram
+Author-email: Ankit Chaubey <ankitchaubey.dev@gmail.com>
+License: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Author, https://github.com/ankit-chaubey
+Project-URL: Documentation, https://github.com/ankit-chaubey/ferogram-py#readme
+Project-URL: Homepage, https://github.com/ankit-chaubey/ferogram-py
+Project-URL: Source, https://github.com/ankit-chaubey/ferogram-py
+Project-URL: Tracker, https://github.com/ankit-chaubey/ferogram-py/issues
+
+<div align="center">
+  
+# ferogram-py
+
+![PyPI](https://img.shields.io/pypi/v/ferogram?style=flat-square&logo=pypi&logoColor=white&color=7C3AED)
+![Python](https://img.shields.io/pypi/pyversions/ferogram?style=flat-square&logo=python&logoColor=FFD43B&color=3B82F6)
+![Downloads](https://img.shields.io/pepy/dt/ferogram?style=flat-square&color=14B8A6)
+![License](https://img.shields.io/badge/License-MIT%20%7C%20Apache--2.0-64748B?style=flat-square)
+![Telegram](https://img.shields.io/badge/Telegram-FerogramChat-06B6D4?style=flat-square&logo=telegram&logoColor=white)
+
+**A modern, elegant, asynchronous MTProto framework for building Telegram user clients and bots in Python.**
+
+</div>
+
+Powered by a high-performance [Rust core](https://github.com/ankit-chaubey/ferogram) that takes care of networking, encryption, TL parsing, and session management so you can focus on writing clean, idiomatic Python.
+
+---
+
+## Why ferogram-py?
+
+Most of the heavy lifting in an MTProto client happens behind the scenes; networking, encryption, TL parsing, and keeping up with updates. ferogram-py lets a Rust core handle all of that, while exposing a clean, Pythonic API.
+
+For most applications, the high-level API is all you'll need. But if you want to use a brand-new Telegram feature or need something more advanced, you can always drop down to the raw MTProto API and invoke requests directly.
+
+The goal is to stay out of your way: simple things should be simple, and advanced things should still be possible.
+
+> Quick API reference: [FEATURES.md](./FEATURES.md)
+
+---
+
+## Install
+
+```bash
+pip install ferogram
+```
+
+<details>
+<summary>Building from source</summary>
+
+```bash
+make dev      # editable install into .venv (builds the Rust extension)
+make build    # release wheel for this machine
+make codegen  # regenerate TL code without a Rust rebuild
+make test     # run tests
+make clean    # wipe .venv, target, dist, generated/
+```
+
+On Termux: `pkg install rust clang python` first.
+Rust-only change, don't want to wait on codegen: `FEROGRAM_SKIP_CODEGEN=1 maturin develop`
+
+</details>
+
+---
+
+## Quick start
+
+**Bot:**
+
+```python
+from ferogram import Client, filters
+
+app = Client("mybot", api_id=0, api_hash="", bot_token="123:TOKEN")
+
+@app.on_message(filters.command("start"))
+async def start(client, message):
+    await message.reply("Hello!")
+
+app.run()
+```
+
+**User:**
+
+```python
+import asyncio
+from ferogram import Client
+
+app = Client("myaccount", api_id=0, api_hash="", phone="+1234567890")
+
+async def main():
+    async with app as client:
+        await client.send_message("me", "logged in")
+
+asyncio.run(main())
+```
+
+Credentials also work from env vars: `API_ID`, `API_HASH`, `BOT_TOKEN`.
+
+## Logging
+
+```python
+import ferogram.logging as fero_log
+
+fero_log.setup()           # INFO to stderr
+fero_log.setup(level=10)   # DEBUG
+```
+
+## Architecture
+
+![architecture](https://github.com/ankit-chaubey/ferogram-py/blob/main/assets/architecture.svg)
+
+The compiled extension (`_ferogram.so`) stays deliberately small: networking, encryption, session storage, and MTProto internals live in Rust. Everything you touch day to day, the client, handlers, filters, is plain Python and can change without a recompile.
+
+<details>
+<summary>Prebuilt Wheels for your platform</summary>
+
+Wheels ship prebuilt for Linux (x86_64, aarch64), macOS (x86_64, arm64), Windows (x86_64), and Android/Termux (aarch64, x86_64). `pip install ferogram` grabs the right one on its own.
+
+</details>
+
+---
+
+## License
+
+This project is dual-licensed under:
+
+- MIT License
+- Apache License 2.0
+
+You may choose either license.
+
+You are free to use, modify, and distribute this software, including for commercial use, provided the original license and copyright notice are included.
+
+See [`LICENSE-MIT`](https://github.com/ankit-chaubey/ferogram-py/blob/main/LICENSE-MIT) and [`LICENSE-APACHE`](https://github.com/ankit-chaubey/ferogram-py/blob/main/LICENSE-APACHE) for full details.
+
+---
+
+## Developer
+
+Developed by [Ankit Chaubey](https://github.com/ankit-chaubey)
+
+Don't forget to explore the Rust engine powering ferogram-py: [`ferogram`](https://github.com/ankit-chaubey/ferogram). Thanks for being part of the journey.
+
+Join the ferogram community! Questions, discussions, bugs report and feedback are always welcome. As the project grows, we'll eventually split Python and Rust discussions into dedicated spaces.
+
+ - Channel (releases & announcements):  [@Ferogram](https://t.me/Ferogram)
+
+ - (questions & discussion): [@FerogramChat](https://t.me/FerogramChat)
+

ferogram-0.5.2/README.md

@@ -0,0 +1,137 @@
+<div align="center">
+  
+# ferogram-py
+
+![PyPI](https://img.shields.io/pypi/v/ferogram?style=flat-square&logo=pypi&logoColor=white&color=7C3AED)
+![Python](https://img.shields.io/pypi/pyversions/ferogram?style=flat-square&logo=python&logoColor=FFD43B&color=3B82F6)
+![Downloads](https://img.shields.io/pepy/dt/ferogram?style=flat-square&color=14B8A6)
+![License](https://img.shields.io/badge/License-MIT%20%7C%20Apache--2.0-64748B?style=flat-square)
+![Telegram](https://img.shields.io/badge/Telegram-FerogramChat-06B6D4?style=flat-square&logo=telegram&logoColor=white)
+
+**A modern, elegant, asynchronous MTProto framework for building Telegram user clients and bots in Python.**
+
+</div>
+
+Powered by a high-performance [Rust core](https://github.com/ankit-chaubey/ferogram) that takes care of networking, encryption, TL parsing, and session management so you can focus on writing clean, idiomatic Python.
+
+---
+
+## Why ferogram-py?
+
+Most of the heavy lifting in an MTProto client happens behind the scenes; networking, encryption, TL parsing, and keeping up with updates. ferogram-py lets a Rust core handle all of that, while exposing a clean, Pythonic API.
+
+For most applications, the high-level API is all you'll need. But if you want to use a brand-new Telegram feature or need something more advanced, you can always drop down to the raw MTProto API and invoke requests directly.
+
+The goal is to stay out of your way: simple things should be simple, and advanced things should still be possible.
+
+> Quick API reference: [FEATURES.md](./FEATURES.md)
+
+---
+
+## Install
+
+```bash
+pip install ferogram
+```
+
+<details>
+<summary>Building from source</summary>
+
+```bash
+make dev      # editable install into .venv (builds the Rust extension)
+make build    # release wheel for this machine
+make codegen  # regenerate TL code without a Rust rebuild
+make test     # run tests
+make clean    # wipe .venv, target, dist, generated/
+```
+
+On Termux: `pkg install rust clang python` first.
+Rust-only change, don't want to wait on codegen: `FEROGRAM_SKIP_CODEGEN=1 maturin develop`
+
+</details>
+
+---
+
+## Quick start
+
+**Bot:**
+
+```python
+from ferogram import Client, filters
+
+app = Client("mybot", api_id=0, api_hash="", bot_token="123:TOKEN")
+
+@app.on_message(filters.command("start"))
+async def start(client, message):
+    await message.reply("Hello!")
+
+app.run()
+```
+
+**User:**
+
+```python
+import asyncio
+from ferogram import Client
+
+app = Client("myaccount", api_id=0, api_hash="", phone="+1234567890")
+
+async def main():
+    async with app as client:
+        await client.send_message("me", "logged in")
+
+asyncio.run(main())
+```
+
+Credentials also work from env vars: `API_ID`, `API_HASH`, `BOT_TOKEN`.
+
+## Logging
+
+```python
+import ferogram.logging as fero_log
+
+fero_log.setup()           # INFO to stderr
+fero_log.setup(level=10)   # DEBUG
+```
+
+## Architecture
+
+![architecture](https://github.com/ankit-chaubey/ferogram-py/blob/main/assets/architecture.svg)
+
+The compiled extension (`_ferogram.so`) stays deliberately small: networking, encryption, session storage, and MTProto internals live in Rust. Everything you touch day to day, the client, handlers, filters, is plain Python and can change without a recompile.
+
+<details>
+<summary>Prebuilt Wheels for your platform</summary>
+
+Wheels ship prebuilt for Linux (x86_64, aarch64), macOS (x86_64, arm64), Windows (x86_64), and Android/Termux (aarch64, x86_64). `pip install ferogram` grabs the right one on its own.
+
+</details>
+
+---
+
+## License
+
+This project is dual-licensed under:
+
+- MIT License
+- Apache License 2.0
+
+You may choose either license.
+
+You are free to use, modify, and distribute this software, including for commercial use, provided the original license and copyright notice are included.
+
+See [`LICENSE-MIT`](https://github.com/ankit-chaubey/ferogram-py/blob/main/LICENSE-MIT) and [`LICENSE-APACHE`](https://github.com/ankit-chaubey/ferogram-py/blob/main/LICENSE-APACHE) for full details.
+
+---
+
+## Developer
+
+Developed by [Ankit Chaubey](https://github.com/ankit-chaubey)
+
+Don't forget to explore the Rust engine powering ferogram-py: [`ferogram`](https://github.com/ankit-chaubey/ferogram). Thanks for being part of the journey.
+
+Join the ferogram community! Questions, discussions, bugs report and feedback are always welcome. As the project grows, we'll eventually split Python and Rust discussions into dedicated spaces.
+
+ - Channel (releases & announcements):  [@Ferogram](https://t.me/Ferogram)
+
+ - (questions & discussion): [@FerogramChat](https://t.me/FerogramChat)