@@ -6,13 +6,12 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
 WORKDIR /app
 COPY requirements.lock ./
 RUN pip install --no-cache-dir -r requirements.lock
-COPY pyproject.toml README.md LICENSE main.py config.py ./
-COPY plugins ./plugins
-COPY utils ./utils
+COPY pyproject.toml README.md LICENSE ./
+COPY src ./src
 RUN pip install --no-cache-dir --no-deps . \
     && useradd --create-home --uid 10001 bot \
     && mkdir /app/data \
     && chown bot:bot /app/data
 
 USER bot
-CMD ["python", "main.py"]
+CMD ["uploadbot"]
@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/logo.svg" alt="UploadBot logo" width="144" height="144">
+  <img src="docs/logo.svg" alt="UploadBot logo" width="128" height="128">
 </p>
 
 <h1 align="center">UploadBot</h1>
@@ -11,171 +11,81 @@
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-78dba9" alt="MIT license"></a>
 </p>
 
-**Turn Telegram files into shareable links as they stream.** Send a document,
-photo, video, or audio file to the bot and receive a public download URL from
+Send a file to your Telegram bot and get a public download link from
 [File2Share](https://file2share.us). Send a public file URL to receive it on Telegram.
 
+UploadBot passes file chunks straight from Telegram into the upload request.
+Uploading starts before downloading finishes, with bounded buffers and no
+temporary files on the bot host.
+
 ```text
-Telegram -> 512 KiB chunks -> UploadBot -> HTTP PUT -> File2Share
-                                  │
-                         No temporary file
+Telegram -> 512 KiB chunks -> UploadBot -> File2Share -> Download link
 ```
 
-## Why UploadBot?
-
-- **Start uploading immediately.** Telegram chunks feed directly into an
-  asynchronous HTTP upload, without waiting for the full download.
-- **Keep memory bounded.** Backpressure and a configurable concurrency limit
-  keep file size from becoming buffer size.
-- **Stay responsive.** Shared HTTP connections, optional native cryptography and
-  uvloop, progress updates, and cancellable transfers.
-- **Run it your way.** Environment configuration, an optional user allowlist,
-  Docker Compose, and support for custom upload hosts.
-
-## File2Share hosting
-
-The default host is `https://file2share.us`. No hosting account or API key is
-needed. UploadBot streams each file in a single PUT request and returns the
-direct file URL supplied by File2Share.
-
-- Files can be up to **95 MB** (`95000000` bytes).
-- File2Share keeps uploads for **up to 14 days**.
-- The host allows **40 uploads per hour per IP address**.
-- Anyone with the download link can access the file.
-- Programs and web pages such as `.exe`, `.apk`, `.html`, and `.svg` are rejected
-  by the host. Archive those files before sending them.
+## What you get
 
-These are the host's limits, documented in the
-[File2Share command-line guide](https://www.file2share.us/cli). Larger files need
-File2Share's separate chunked upload API, which UploadBot does not implement.
-Increasing `MAX_FILE_SIZE` above 95 MB is rejected when File2Share is selected.
-
-Custom hosts can be configured with `TRANSFER_URL`. They must accept raw PUT
-uploads at `/<filename>` and return a download URL in the response body or the
-`X-Direct-Url` header. Limits and retention depend on the selected host.
+- **Streaming uploads** without a separate download-to-disk step.
+- **Responsive transfers** with progress updates and `/cancel`.
+- **Controlled concurrency** with one transfer per user and a global limit.
+- **Simple hosting** with uv, Docker Compose, and an optional user allowlist.
 
 ## Quick start
 
-Requires **Python 3.11+**, a Telegram bot token from
-[@BotFather](https://t.me/BotFather), and an API ID/hash from
-[my.telegram.org/apps](https://my.telegram.org/apps). The API ID/hash are also
-required for bot accounts because UploadBot uses Telegram's MTProto interface.
+You need [uv](https://docs.astral.sh/uv/getting-started/installation/), Python 3.11+,
+a bot token from [BotFather](https://t.me/BotFather), and an API ID/hash from
+[my.telegram.org/apps](https://my.telegram.org/apps).
 
 ```bash
 git clone https://github.com/IlyaKhalafi/UploadBot.git
 cd UploadBot
-python3 -m venv .venv
-source .venv/bin/activate
-python -m pip install -r requirements.lock
-python -m pip install --no-deps .
 cp .env.example .env
 # Fill in API_ID, API_HASH, and BOT_TOKEN in .env.
-python main.py
+uv sync --locked --no-dev --extra speed
+uv run --no-sync uploadbot
 ```
 
-On Windows, activate with `.venv\Scripts\activate`. The lock includes optional
-speed packages; uvloop is automatically skipped on Windows. For a minimal
-installation without speed extras, use `python -m pip install -r requirements.txt`.
-
-Using [uv](https://docs.astral.sh/uv/)? Install the same locked environment with
-`uv sync --locked --extra speed`, then run `uv run --no-sync python main.py`.
-Startup is noninteractive and works with a service manager.
+No File2Share account or hosting API key is required. For a personal bot, set
+`ALLOWED_USER_IDS` in `.env` to your numeric Telegram user ID.
 
-## Use it
+## Try it
 
-| Send to the bot | Result |
+| Send in a private chat | Result |
 | --- | --- |
-| `/start` or `/help` | Welcome message, file limit, and commands |
-| A document, photo, video, audio, voice message, or animation | Stream to File2Share and return a public download URL |
-| A public HTTP(S) file URL | Ask Telegram to fetch and send the file |
+| A document, photo, video, or audio file | A public download URL |
+| A public HTTP(S) file URL | The file sent back through Telegram |
+| `/start` or `/help` | Commands and the configured file limit |
 | `/cancel` | Stop your active transfer |
 
-The bot operates in private chats. Each user can run one transfer at a time;
-additional requests receive a busy message. Uploaded files are accessible through
-their sharing URL. File2Share removes uploads after up to 14 days.
-
-For URL → Telegram, the URL must point to a file Telegram can fetch without login
-or browser cookies. Telegram imposes its own type and size limits. Signed query
-strings are preserved. The bot host does not download these URLs.
-
-## Configuration
-
-Copy [.env.example](.env.example) to `.env`. Existing environment variables take
-precedence. Keep `.env` and Telegram session files private; both are gitignored.
-
-| Variable | Default | Purpose |
-| --- | --- | --- |
-| `API_ID` | Required | Telegram application API ID |
-| `API_HASH` | Required | Telegram application API hash |
-| `BOT_TOKEN` | Required | Your bot's BotFather token |
-| `TRANSFER_URL` | `https://file2share.us` | Upload host base URL; HTTPS recommended |
-| `MAX_FILE_SIZE` | `95000000` | Maximum Telegram to host file size, in bytes (95 MB) |
-| `MAX_CONCURRENT_TRANSFERS` | `3` | Total active transfers; one per user |
-| `TRANSFER_TIMEOUT` | `1800` | Per-transfer time limit in seconds |
-| `ALLOWED_USER_IDS` | Empty | Comma-separated Telegram user IDs; empty permits everyone |
-| `SESSION_PATH` | `data/uploadbot` | Persistent Telethon session path |
-
-Use `ALLOWED_USER_IDS` for a personal bot. Increasing concurrency trades more
-network connections and bounded per-transfer buffers for more simultaneous work.
-`MAX_FILE_SIZE` applies to files received from Telegram. Telegram controls limits
-when it fetches a URL directly. For custom hosts, set `MAX_FILE_SIZE` to a limit
-that the host supports.
-
-Existing installations should update both settings in `.env`.
-
-```dotenv
-TRANSFER_URL=https://file2share.us
-MAX_FILE_SIZE=95000000
-```
-
-## Docker
+Voice messages and animations work too. File URLs must be accessible to Telegram
+without browser cookies or a login.
 
-Configure `.env` first, then run the following command.
+## Hosting limits
 
-```bash
-docker compose up --build -d
-docker compose logs -f bot
-```
-
-The container runs as a non-root user. A named volume persists the Telegram
-session, and no incoming port is required. Stop with `docker compose down`.
+File2Share accepts **up to 95 MB per request**, keeps files for **up to 14 days**,
+and limits uploads to **40 per hour per IP address**. Anyone with the link can
+download the file. Some file types, including programs and web pages, must be
+archived first. See the [host's API guide](https://www.file2share.us/cli).
 
-## Performance and reliability
+Larger-file uploads through File2Share's separate chunked API are not implemented.
+You can also configure another compatible PUT upload host.
 
-The old flow downloaded a file to disk and then uploaded it using a blocking
-HTTP call. The new flow removes temporary file I/O and starts the upload while
-the Telegram download is still in progress. Memory remains bounded by chunks and
-transport buffers rather than file size. Actual throughput depends on Telegram,
-your network, and the upload host; no universal speed multiplier is claimed.
+## Run with Docker
 
-Uploads use raw PUT requests with a known `Content-Length`. File2Share returns
-the direct download URL in its `X-Direct-Url` response header. HTTP failures,
-incomplete downloads, invalid response URLs, and timeouts are reported as errors.
-Redirects are rejected. Configure the final upload endpoint. Interrupted uploads
-are not resumed or automatically retried; resend the file when ready.
-
-See [the architecture guide](docs/architecture.md) for flow control, cleanup, and
-known limitations, including [local test downloads](docs/architecture.md#local-test-downloads).
-Upgrading an older installation? Read the
-[migration notes](CHANGELOG.md#migrating-from-1x).
-
-## Development
+Configure `.env`, then start the bot.
 
 ```bash
-uv sync --locked --extra dev --extra speed
-uv run --no-sync ruff check .
-uv run --no-sync ruff format --check .
-uv run --no-sync pytest -q
+docker compose up --build -d
+docker compose logs -f bot
 ```
 
-Tests run offline against a local HTTP server and simulated Telegram messages.
-They cover streaming before the download completes, byte integrity, bounded
-Python allocations, HTTP errors, size limits, cancellation, and configuration.
-CI runs on Python 3.11 through 3.14.
+The container runs as a non-root user and persists the Telegram session in a named
+volume. No incoming port is needed.
 
-Read [CONTRIBUTING.md](CONTRIBUTING.md) to report a bug or contribute a fix.
-If UploadBot is useful to you, a GitHub star helps other people discover it.
+## More
 
-## License
+- [Setup and configuration](docs/setup.md) for every setting and custom upload hosts.
+- [How streaming works](docs/architecture.md) for flow control and failure handling.
+- [Contributing](CONTRIBUTING.md) for development commands and tests.
+- [Migration notes](CHANGELOG.md#migrating-from-1x) for older installations.
 
-[MIT](LICENSE).
+MIT licensed. If UploadBot saves you time, a star helps others find it.
@@ -0,0 +1,81 @@
+# Setup and configuration
+
+Use [uv](https://docs.astral.sh/uv/getting-started/installation/) to install the
+environment locked in `uv.lock`. `pyproject.toml` defines the package and its
+dependencies. Running `uv sync --locked --no-dev --extra speed` installs the bot
+with optional native cryptography and uvloop. Skip `--extra speed` for the minimal
+installation. uvloop is automatically omitted on Windows.
+
+Run `uv run --no-sync uploadbot` or `uv run --no-sync python -m uploadbot`.
+Neither command needs virtual environment activation. Run from the project
+directory to load its `.env`, or provide configuration through environment
+variables when running an installed package elsewhere.
+
+## Credentials
+
+Create a bot with [BotFather](https://t.me/BotFather). Get the application API ID
+and hash from [my.telegram.org/apps](https://my.telegram.org/apps). All three
+credentials are needed because UploadBot uses Telegram's MTProto interface.
+
+Copy `.env.example` to `.env` and fill in the credentials. Environment variables
+take precedence over `.env`. Keep the environment file and Telegram session
+private. Both are excluded from Git and Docker build contexts.
+
+## Settings
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `API_ID` | Required | Telegram application API ID |
+| `API_HASH` | Required | Telegram application API hash |
+| `BOT_TOKEN` | Required | Your bot's BotFather token |
+| `TRANSFER_URL` | `https://file2share.us` | Upload host base URL |
+| `MAX_FILE_SIZE` | `95000000` | Maximum Telegram to host file size, in bytes |
+| `MAX_CONCURRENT_TRANSFERS` | `3` | Total active transfers, with one per user |
+| `TRANSFER_TIMEOUT` | `1800` | Time limit for one transfer, in seconds |
+| `ALLOWED_USER_IDS` | Empty | Comma-separated Telegram user IDs; empty permits everyone |
+| `SESSION_PATH` | `data/uploadbot` | Persistent Telethon session path |
+
+For a personal bot, restrict `ALLOWED_USER_IDS` to your own Telegram user ID.
+Increasing concurrency allows more simultaneous work and uses more connections
+and per-transfer buffers. New requests receive a busy reply when all slots are
+occupied. There is no unbounded waiting queue.
+
+`MAX_FILE_SIZE` applies to incoming Telegram files. When a user sends a URL,
+Telegram fetches it directly and imposes its own limits.
+
+## Upload hosts
+
+File2Share accepts a raw PUT upload at `/<filename>` and returns the direct file
+URL in the `X-Direct-Url` response header. Its response body contains a sharing
+page URL. UploadBot prefers the direct URL so it works in download clients.
+
+The default file limit is 95,000,000 bytes. Raising it above that value is rejected
+when File2Share is selected. Files are retained for up to 14 days, and the host
+allows 40 uploads per hour per IP address. Programs and web pages such as `.exe`,
+`.apk`, `.html`, and `.svg` must be archived first. These are host restrictions,
+documented in the [File2Share API guide](https://www.file2share.us/cli).
+
+Custom hosts must accept raw PUT uploads at `/<filename>` and return a URL in the
+`X-Direct-Url` header or a plain URL in the response body. Set `TRANSFER_URL` and
+`MAX_FILE_SIZE` to match the host. HTTPS is recommended. Retention and access
+rules depend on the selected host.
+
+Configure the final endpoint because upload redirects are rejected. Files are
+not automatically retried or resumed after a failure. A local test receiver can
+return loopback URLs that only work on the bot's machine. See
+[local test downloads](architecture.md#local-test-downloads).
+
+## Docker Compose
+
+Compose reads `.env`, runs as a non-root user, and stores the Telegram session in
+a named volume. Uploaded file bytes are not stored in that volume. No incoming
+port is needed for Telegram or File2Share.
+
+```bash
+docker compose up --build -d
+docker compose logs -f bot
+docker compose down
+```
+
+If you change `SESSION_PATH`, keep it under `/app/data` in the container so it
+remains writable and persists in the volume.
@@ -28,17 +28,15 @@ dev = [
 ]
 
 [project.scripts]
-uploadbot = "main:main"
+uploadbot = "uploadbot.app:main"
 
 [project.urls]
 Repository = "https://github.com/IlyaKhalafi/UploadBot"
 Issues = "https://github.com/IlyaKhalafi/UploadBot/issues"
 
-[tool.setuptools]
-py-modules = ["main", "config"]
-
 [tool.setuptools.packages.find]
-include = ["plugins*", "utils*"]
+where = ["src"]
+include = ["uploadbot*"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
@@ -0,0 +1 @@
+"""Stream files between Telegram and public upload hosts."""
@@ -0,0 +1,6 @@
+"""Support python -m uploadbot."""
+
+from uploadbot.app import main
+
+if __name__ == "__main__":
+    main()
@@ -1,14 +1,14 @@
-"""Run UploadBot with python main.py."""
+"""Application startup and Telegram client lifecycle."""
 
 import asyncio
 import logging
 
 import aiohttp
 from telethon import TelegramClient, events
 
-from config import Settings
-from plugins.bot import UploadBot
-from utils.transfer import TransferClient
+from uploadbot.bot import UploadBot
+from uploadbot.config import Settings
+from uploadbot.transfer import TransferClient
 
 
 async def run(settings: Settings) -> None:
 
@@ -9,8 +9,8 @@
 
 from telethon import errors, types
 
-from config import Settings
-from utils.transfer import TransferClient, TransferError, stream_telegram, valid_link
+from uploadbot.config import Settings
+from uploadbot.transfer import TransferClient, TransferError, stream_telegram, valid_link
 
 logger = logging.getLogger(__name__)
 
 
@@ -36,7 +36,7 @@ class Settings:
 
     @classmethod
     def from_env(cls) -> "Settings":
-        load_dotenv(Path(__file__).with_name(".env"))
+        load_dotenv(Path.cwd() / ".env")
         api_id = positive_int("API_ID", "0")
         api_hash = os.environ.get("API_HASH", "").strip()
         bot_token = os.environ.get("BOT_TOKEN", "").strip()
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+"""Stream files between Telegram and public upload hosts."""`