ferogram 0.5.1__tar.gz → 0.5.2__tar.gz

{ferogram-0.5.1 → 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.1 → ferogram-0.5.2}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 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

{ferogram-0.5.1 → 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.1"
+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.1 → ferogram-0.5.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name        = "ferogram-py"
-version     = "0.5.1"
+version     = "0.5.2"
 edition     = "2024"
 description = "Python MTProto client based on ferogram (Rust MTProto)"
 build       = "build.rs"
@@ -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.1 → 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)

{ferogram-0.5.1 → ferogram-0.5.2}/ferogram/__init__.py

@@ -26,6 +26,7 @@ if _main_file:
         )
 
 from .client import Client, StopPropagation, ContinuePropagation, TransferHandle, TransferCancelled
+from .client import TransferLimits, available_qualities
 from . import filters
 
 # Session classes stay in Rust
@@ -59,7 +60,7 @@ from .updates import (
 __all__ = [
     # Core
     "Client", "filters", "StopPropagation", "ContinuePropagation",
-    "TransferHandle", "TransferCancelled",
+    "TransferHandle", "TransferCancelled", "TransferLimits", "available_qualities",
     # Session (Rust)
     "FileSession", "MemorySession", "StringSession",
     "SqliteSession", "LibSqlSession", "CustomSession",