tgparser-cli 0.1.0__py3-none-any.whl

tgparser/storage/sqlite.py

@@ -0,0 +1,118 @@
+"""SQLite storage for parsed messages — optional dependency (sqlite3 built-in)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+from pathlib import Path
+
+from tgparser.models.message import Message
+
+logger = logging.getLogger("tgparser")
+
+# SQLite table schema
+CREATE_TABLE_SQL = """
+CREATE TABLE IF NOT EXISTS messages (
+    id          INTEGER NOT NULL,
+    channel     TEXT NOT NULL,
+    date        TEXT NOT NULL,
+    author      TEXT,
+    text        TEXT NOT NULL,
+    media_urls  TEXT,          -- JSON array stored as text
+    reactions   TEXT,          -- JSON object stored as text
+    is_forwarded INTEGER DEFAULT 0,
+    raw_source  TEXT DEFAULT 'unknown',
+    saved_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (id, channel)
+);
+"""
+
+CREATE_METADATA_SQL = """
+CREATE TABLE IF NOT EXISTS metadata (
+    channel TEXT PRIMARY KEY,
+    last_message_id INTEGER NOT NULL,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+"""
+
+
+def _ensure_tables(db: sqlite3.Connection) -> None:
+    db.execute(CREATE_TABLE_SQL)
+    db.execute(CREATE_METADATA_SQL)
+    db.commit()
+
+
+def _get_connection(db_path: Path) -> sqlite3.Connection:
+    """Open a connection and ensure tables exist."""
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    db = sqlite3.connect(str(db_path))
+    db.row_factory = sqlite3.Row
+    _ensure_tables(db)
+    return db
+
+
+def save_messages(db_path: Path, messages: list[Message]) -> None:
+    """Insert *messages* into the SQLite database, ignoring duplicates (id+channel)."""
+    db = _get_connection(db_path)
+    try:
+        for m in messages:
+            db.execute(
+                """
+                INSERT OR IGNORE INTO messages
+                    (id, channel, date, author, text, media_urls, reactions,
+                     is_forwarded, raw_source)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    m.id,
+                    m.channel,
+                    m.date.isoformat(),
+                    m.author,
+                    m.text,
+                    json.dumps(m.media_urls, ensure_ascii=False),
+                    json.dumps(m.reactions, ensure_ascii=False) if m.reactions else None,
+                    int(m.is_forwarded),
+                    m.raw_source,
+                ),
+            )
+        db.commit()
+    finally:
+        db.close()
+
+
+def get_last_message_id(db_path: Path, channel: str) -> int | None:
+    """Return the highest message id stored for *channel*, or ``None``."""
+    db = _get_connection(db_path)
+    try:
+        row = db.execute(
+            "SELECT last_message_id FROM metadata WHERE channel = ?", (channel,)
+        ).fetchone()
+        if row is not None:
+            return row["last_message_id"]
+        # Fallback: scan messages table
+        row = db.execute(
+            "SELECT MAX(id) AS max_id FROM messages WHERE channel = ?", (channel,)
+        ).fetchone()
+        return row["max_id"] if row and row["max_id"] is not None else None
+    finally:
+        db.close()
+
+
+def update_last_message_id(db_path: Path, channel: str, last_id: int) -> None:
+    """Update (or insert) the last message id metadata for *channel*."""
+    db = _get_connection(db_path)
+    try:
+        db.execute(
+            """
+            INSERT INTO metadata (channel, last_message_id, updated_at)
+            VALUES (?, ?, datetime('now'))
+            ON CONFLICT(channel) DO UPDATE SET
+                last_message_id = excluded.last_message_id,
+                updated_at = excluded.updated_at
+            """,
+            (channel, last_id),
+        )
+        db.commit()
+    finally:
+        db.close()

tgparser/storage/writer.py

@@ -0,0 +1,214 @@
+"""Serialize Message lists to structured formats (JSON, CSV, TXT, SQLite)."""
+
+from __future__ import annotations
+
+import csv
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Literal
+
+from tgparser.models.message import Message
+
+logger = logging.getLogger("tgparser")
+
+OutputFormat = Literal["json", "csv", "txt", "sqlite"]
+
+
+def save_messages(
+    messages: list[Message],
+    output_dir: str | Path,
+    channel_name: str,
+    fmt: OutputFormat = "json",
+    db_path: str | Path | None = None,
+) -> Path | None:
+    """Persist *messages* to a file and return its path.
+
+    File name is auto-generated: ``<channel>_<timestamp>.<ext>``.
+    Creates *output_dir* if it does not exist.
+
+    For ``sqlite`` format the result is written into an SQLite database;
+    in that case *db_path* must be provided and the return value is ``None``.
+
+    Args:
+        messages: List of parsed messages.
+        output_dir: Directory to write the output file.
+        channel_name: Channel slug used in the file name.
+        fmt: ``"json"``, ``"csv"``, ``"txt"`` or ``"sqlite"``.
+        db_path: Path to the SQLite database file (required for ``sqlite``).
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    if fmt == "sqlite":
+        if db_path is None:
+            raise ValueError("db_path is required for sqlite format")
+        _write_sqlite(Path(db_path), messages)
+        logger.info("Saved %d messages → sqlite:%s", len(messages), db_path)
+        return None
+
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_channel = channel_name.lstrip("@").replace("/", "_")
+    filename = f"{safe_channel}_{ts}.{fmt}"
+    filepath = output_dir / filename
+
+    if fmt == "json":
+        _write_json(filepath, messages)
+    elif fmt == "csv":
+        _write_csv(filepath, messages)
+    elif fmt == "txt":
+        _write_txt(filepath, messages)
+    else:
+        raise ValueError(f"Unsupported format: {fmt}")
+
+    logger.info("Saved %d messages → %s", len(messages), filepath)
+    return filepath
+
+
+def save_messages_incremental(
+    messages: list[Message],
+    output_dir: str | Path,
+    channel_name: str,
+    fmt: OutputFormat = "json",
+    db_path: str | Path | None = None,
+) -> Path | None:
+    """Incremental variant -- only appends messages that are newer than the last stored ID.
+
+    For file-based formats (json/csv/txt) the whole list is re-written each time,
+    but only *new* messages (those with id > last saved id for that channel)
+    are included.  For sqlite the new messages are inserted directly.
+
+    The last message id is persisted in a small state file ``<channel>_state.json``
+    inside *output_dir* (for file formats) or in the sqlite metadata table.
+    """
+    last_id = get_last_message_id(output_dir, channel_name, db_path)
+
+    if last_id is not None:
+        new_messages = [m for m in messages if m.id > last_id]
+        if not new_messages:
+            logger.info("No new messages for '%s' (last id = %d)", channel_name, last_id)
+            return None
+        logger.info("%d new messages (out of %d) for '%s'", len(new_messages), len(messages), channel_name)
+    else:
+        new_messages = messages
+
+    result = save_messages(new_messages, output_dir, channel_name, fmt, db_path)
+
+    # persist the new last id
+    if new_messages:
+        _save_last_message_id(output_dir, channel_name, max(m.id for m in new_messages))
+
+    return result
+
+
+def get_last_message_id(
+    output_dir: str | Path,
+    channel_name: str,
+    db_path: str | Path | None = None,
+) -> int | None:
+    """Return the last persisted message id for *channel_name*, or ``None``."""
+    if db_path is not None:
+        from tgparser.storage.sqlite import get_last_message_id as _sqlite_last_id
+        return _sqlite_last_id(Path(db_path), channel_name)
+
+    state_file = Path(output_dir) / f"{channel_name.lstrip('@').replace('/', '_')}_state.json"
+    if state_file.exists():
+        try:
+            data = json.loads(state_file.read_text(encoding="utf-8"))
+            return data.get("last_message_id")
+        except Exception:
+            logger.warning("Could not read state file %s", state_file)
+    return None
+
+
+# ------------------------------------------------------------------
+# Internal writers
+# ------------------------------------------------------------------
+
+
+def _write_json(filepath: Path, messages: list[Message]) -> None:
+    data = []
+    for m in messages:
+        data.append(
+            {
+                "id": m.id,
+                "channel": m.channel,
+                "date": m.date.isoformat(),
+                "author": m.author,
+                "text": m.text,
+                "media_urls": m.media_urls,
+                "reactions": m.reactions,
+                "is_forwarded": m.is_forwarded,
+                "raw_source": m.raw_source,
+            }
+        )
+    filepath.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _write_csv(filepath: Path, messages: list[Message]) -> None:
+    fieldnames = [
+        "id",
+        "channel",
+        "date",
+        "author",
+        "text",
+        "media_urls",
+        "reactions",
+        "is_forwarded",
+        "raw_source",
+    ]
+    with filepath.open("w", newline="", encoding="utf-8") as fh:
+        writer = csv.DictWriter(fh, fieldnames=fieldnames)
+        writer.writeheader()
+        for m in messages:
+            writer.writerow(
+                {
+                    "id": m.id,
+                    "channel": m.channel,
+                    "date": m.date.isoformat(),
+                    "author": m.author or "",
+                    "text": m.text,
+                    "media_urls": "|".join(m.media_urls),
+                    "reactions": json.dumps(m.reactions, ensure_ascii=False) if m.reactions else "",
+                    "is_forwarded": m.is_forwarded,
+                    "raw_source": m.raw_source,
+                }
+            )
+
+
+def _write_txt(filepath: Path, messages: list[Message]) -> None:
+    """Write messages as a plain-text file separated by blank lines."""
+    lines: list[str] = []
+    for m in messages:
+        lines.append(f"--- Message #{m.id} ---")
+        lines.append(f"Channel: {m.channel}")
+        lines.append(f"Date:    {m.date.isoformat()}")
+        lines.append(f"Author:  {m.author or '—'}")
+        if m.media_urls:
+            lines.append(f"Media:   {', '.join(m.media_urls)}")
+        if m.reactions:
+            reactions_str = ", ".join(f"{k}: {v}" for k, v in m.reactions.items())
+            lines.append(f"Reactions: {reactions_str}")
+        if m.is_forwarded:
+            lines.append("Forwarded: yes")
+        lines.append("")
+        lines.append(m.text)
+        lines.append("")  # blank line separator
+    filepath.write_text("\n".join(lines), encoding="utf-8")
+
+
+def _write_sqlite(db_path: Path, messages: list[Message]) -> None:
+    """Delegate to the sqlite writer module."""
+    from tgparser.storage.sqlite import save_messages as _sqlite_save
+    _sqlite_save(db_path, messages)
+
+
+def _save_last_message_id(output_dir: Path, channel_name: str, last_id: int) -> None:
+    """Persist the last saved message id for incremental parsing."""
+    safe_channel = channel_name.lstrip("@").replace("/", "_")
+    state_file = output_dir / f"{safe_channel}_state.json"
+    state_file.write_text(
+        json.dumps({"last_message_id": last_id}, indent=2),
+        encoding="utf-8",
+    )

tgparser/utils.py

@@ -0,0 +1,69 @@
+"""Logging setup and retry helpers."""
+
+import logging
+import time
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+# Module-level logger — consumers do `from tgparser.utils import logger`
+logger = logging.getLogger("tgparser")
+
+
+def setup_logging(level: int = logging.INFO, fmt: str | None = None) -> None:
+    """Configure root tgparser logger.
+
+    Call once at CLI entry point. Default format includes timestamp and level.
+    """
+    if fmt is None:
+        fmt = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(fmt))
+    logger.addHandler(handler)
+    logger.setLevel(level)
+
+
+def retry(
+    max_attempts: int = 3,
+    base_delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    exceptions: tuple[type[BaseException], ...] = (Exception,),
+) -> Callable[[F], F]:
+    """Decorator: exponential backoff retry.
+
+    Args:
+        max_attempts: Total attempts before giving up.
+        base_delay: Initial wait in seconds.
+        backoff_factor: Multiplier for each subsequent attempt.
+        exceptions: Exception types to catch and retry.
+    """
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            last_exc: BaseException | None = None
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as exc:
+                    last_exc = exc
+                    if attempt == max_attempts:
+                        raise
+                    delay = base_delay * (backoff_factor ** (attempt - 1))
+                    logger.warning(
+                        "Retry %d/%d after %.1fs: %s",
+                        attempt,
+                        max_attempts,
+                        delay,
+                        exc,
+                    )
+                    time.sleep(delay)
+            # Should never reach here, but keep type-checker happy
+            assert last_exc is not None
+            raise last_exc
+
+        return wrapper  # type: ignore[return-value]
+
+    return decorator

tgparser_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: tgparser-cli
+Version: 0.1.0
+Summary: Telegram channel parser — extract messages from open (MTProto) and closed (web) channels
+Author: borodatych
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/borodatych/tgparser
+Project-URL: Repository, https://github.com/borodatych/tgparser
+Project-URL: Bug Tracker, https://github.com/borodatych/tgparser/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: telethon>=1.35
+Requires-Dist: playwright>=1.45
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: lxml>=5.2
+Requires-Dist: click>=8.1
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.2; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# TgParser
+
+**Telegram-канал парсер** — утилита для извлечения сообщений из открытых (MTProto API) и закрытых (Web HTML) Telegram-каналов.
+
+[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
+
+---
+
+## Возможности
+
+- **Авторизация** через QR-код (Web) или MTProto (Telethon) с сохранением сессии
+- **Парсинг открытых каналов** — прямое чтение через MTProto API (Telethon)
+- **Парсинг закрытых каналов** — чтение через web-версию Telegram (Playwright + BeautifulSoup)
+- **Обход защиты от копирования** — автоматическое снятие CSS `user-select: none`, блокировки контекстного меню
+- **Вывод данных** в JSON, CSV, plain-text или SQLite
+- **Инкрементальный парсинг** — сохранение только новых сообщений
+- **CLI-интерфейс** на базе Click
+
+---
+
+## Установка
+
+### Из исходного кода
+
+```bash
+# Клонировать репозиторий
+git clone https://github.com/borodatych/tgparser.git
+cd tgparser
+
+# Создать виртуальное окружение
+python -m venv .venv
+source .venv/bin/activate  # Linux/macOS
+.venv\Scripts\activate     # Windows
+
+# Установить пакет с dev-зависимостями
+pip install -e ".[dev]"
+
+# Установить Playwright браузеры (требуется для web-парсера)
+playwright install chromium
+```
+
+### Через pip (после релиза)
+
+```bash
+pip install tgparser-cli
+playwright install chromium
+```
+
+---
+
+## Настройка
+
+### 1. Переменные окружения
+
+Скопируйте `.env.example` в `.env` и заполните:
+
+```bash
+cp .env.example .env
+```
+
+Обязательные переменные:
+
+| Переменная | Описание |
+|-----------|----------|
+| `API_ID` | API ID из [my.telegram.org](https://my.telegram.org/apps) |
+| `API_HASH` | API Hash оттуда же |
+| `PHONE_NUMBER` | Номер телефона для MTProto-авторизации (в международном формате) |
+
+### 2. Конфигурационный файл (опционально)
+
+Создайте `config.yaml` в корне проекта:
+
+```yaml
+parsing:
+  scroll_delay_ms: 1500    # задержка между скроллами (web-парсер)
+  max_messages: 1000       # лимит сообщений за один запуск
+  rate_limit_sleep: 30     # пауза при FloodWait (сек)
+
+storage:
+  output_dir: data/output
+  session_dir: data/sessions
+```
+
+---
+
+## Использование
+
+### Авторизация
+
+```bash
+# Web-авторизация (QR-код) — для закрытых каналов
+tgparser auth
+
+# Принудительная переавторизация
+tgparser auth --force
+
+# MTProto-авторизация — для открытых каналов
+tgparser auth --type mtproto
+```
+
+### Парсинг открытого канала (MTProto)
+
+```bash
+tgparser parse open @channel_username
+```
+
+Опции:
+- `--limit N` — максимум сообщений (по умолчанию 100)
+- `--since YYYY-MM-DD` — фильтр по дате (сообщения не старше указанной)
+- `--until YYYY-MM-DD` — фильтр по дате (сообщения не новее указанной)
+- `--offset N` — смещение от последнего сообщения
+
+### Парсинг закрытого канала (Web)
+
+```bash
+tgparser parse closed https://t.me/channel_username
+```
+
+Опции:
+- `--limit N` — максимум сообщений
+- `--since YYYY-MM-DD` — фильтр по дате
+- `--until YYYY-MM-DD` — фильтр по дате
+
+> **Примечание:** Для закрытых каналов требуется предварительная web-авторизация (`tgparser auth`).
+
+### Экспорт
+
+```bash
+# Вывод в консоль (plain-text)
+tgparser export --input data/output/messages.json
+
+# Сохранение в JSON
+tgparser export --input data/output/messages.json --format json --output data/output/export.json
+
+# Сохранение в CSV
+tgparser export --input data/output/messages.json --format csv --output data/output/export.csv
+
+# Сохранение в SQLite
+tgparser export --input data/output/messages.json --format sqlite --output data/output/export.db
+
+# Инкрементальный экспорт (только новые сообщения)
+tgparser export --input data/output/messages.json --incremental
+```
+
+---
+
+## Примеры
+
+### Сохранить 50 последних сообщений из открытого канала в JSON
+
+```bash
+tgparser parse open @python_news --limit 50 --format json --output data/output/python_news.json
+```
+
+### Сохранить сообщения из закрытого канала за последнюю неделю
+
+```bash
+tgparser parse closed https://t.me/private_channel --since 2025-01-01
+```
+
+### Экспортировать в CSV с инкрементальным режимом
+
+```bash
+tgparser parse open @tech_news --format csv --output data/output/tech_news.csv
+tgparser export --input data/output/tech_news.csv --incremental
+```
+
+---
+
+## Структура проекта
+
+```
+tgparser/
+├── src/
+│   └── tgparser/
+│       ├── auth/          # Модули авторизации (web, mtproto)
+│       ├── parsers/       # Парсеры (mtproto_parser, web_parser)
+│       ├── storage/       # Вывод и хранение (JSON, CSV, TXT, SQLite)
+│       ├── models/        # Модели данных (Message)
+│       ├── cli.py         # CLI-интерфейс (Click)
+│       ├── config.py      # Загрузка конфигурации
+│       └── utils.py       # Вспомогательные функции
+├── tests/                 # Тесты (pytest)
+├── data/
+│   ├── output/            # Результаты парсинга
+│   └── sessions/          # Сохранённые сессии
+├── docs/                  # Документация
+├── config.yaml            # Конфигурация (опционально)
+├── .env                   # Секреты (не в git)
+├── pyproject.toml         # Настройки проекта
+└── README.md              # Этот файл
+```
+
+---
+
+## Разработка
+
+### Запуск тестов
+
+```bash
+pytest tests/ -v
+```
+
+### Линтинг и форматирование
+
+```bash
+ruff check src/ tests/
+ruff format src/ tests/
+```
+
+### Сборка пакета
+
+```bash
+python -m build
+```
+
+---
+
+## Совместимость
+
+- **Python**: 3.11, 3.12
+- **ОС**: Windows, Linux, macOS
+- **Браузер**: Chromium (устанавливается через `playwright install chromium`)
+
+---
+
+## Планы
+
+- [x] Авторизация (Web + MTProto)
+- [x] Парсинг открытых каналов (MTProto)
+- [x] Парсинг закрытых каналов (Web)
+- [x] Обход защиты от копирования
+- [x] Вывод (JSON, CSV, TXT, SQLite)
+- [x] Инкрементальный парсинг
+- [ ] Поддержка Telegram Premium (MTProto)
+- [ ] Парсинг комментариев
+- [ ] GUI-интерфейс
+
+Полный roadmap: [docs/roadmap.md](docs/roadmap.md)
+
+---
+
+## Лицензия
+
+Проект распространяется под лицензией MIT. Подробнее — в файле [LICENSE](LICENSE).

tgparser_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+tgparser/__init__.py,sha256=Vpr2-J37aNd7YiTv5ga5gkVZsiOjAHgdrbV5HKZ74UY,68
+tgparser/cli.py,sha256=TOvql_bjQEs50HWW_-Uq9vQXp9kLaTSGvh6MXB-L21w,19027
+tgparser/config.py,sha256=dQur3V71C9ggqx6H7AmbaZ7XYhOkoQR-ZMAtjmPO9rY,1517
+tgparser/utils.py,sha256=B_Za4zStyIo0RVfCMvdGMjGLcE6fh5FsMxljnQU6738,2242
+tgparser/auth/__init__.py,sha256=vchOklgNfhFazEffESB6JtY6RbeG7ZzN4umv1-2NVuc,192
+tgparser/auth/mtproto_auth.py,sha256=30t83WfxmEXNsH7LJ4jdgbIJlBSH0AXyUG5XKromO5o,4601
+tgparser/auth/web_auth.py,sha256=bGUmONnFP-z4iwps5z5ugIV5HDeOD1_7eKDojohrWKw,9700
+tgparser/models/__init__.py,sha256=GXI-G4Xb-SlTkGdWvDbtPPd1ThR6oAlp3hwjDWr4Hgs,20
+tgparser/models/message.py,sha256=c9vtVEX1E3jNnjPmXhq5B9whiyAwyk7yomU2woT_9yg,935
+tgparser/parsers/__init__.py,sha256=vqT0updFmmGfAbm-6fDx9MidnLPzj7C-3GhGY70bR7Y,230
+tgparser/parsers/mtproto_parser.py,sha256=xVn4_CGiSuTE4w7TMMpVyWIM5aS0GkR4dVw-vRuk6Ak,9274
+tgparser/parsers/web_parser.py,sha256=fxL5cvNWYntcPLVFUP2L7vPr3slwkM3pa5EVtYveQB0,20811
+tgparser/storage/__init__.py,sha256=17ab-FheD4tvlwkLqJH2IJfDLMbX9XmhsD87voe0IlY,315
+tgparser/storage/sqlite.py,sha256=JCSGxzytosgqsfGfKVuemOTwl0z2Yt_jsp6g0QbsPQg,3808
+tgparser/storage/writer.py,sha256=twy0h0FOStNWDNW59f1wwcBw5A8Z9ACZsGVCp3PByDQ,7701
+tgparser_cli-0.1.0.dist-info/licenses/LICENSE,sha256=ZQu7QqFT2Yn7EV-MCiWJMxcZMZVZJTttK1GtKvbWrYI,1088
+tgparser_cli-0.1.0.dist-info/METADATA,sha256=y1Iy7XhZZdbX5CaWEPvyX6P59LvzwNneHxuGisywJ_A,9553
+tgparser_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tgparser_cli-0.1.0.dist-info/entry_points.txt,sha256=lz_j2icS6b8n1OW-yHSJnHrv1O2gfY7gG6JkzMJXe3E,47
+tgparser_cli-0.1.0.dist-info/top_level.txt,sha256=CrqdcWZYa02HSazR16Jda-jA2q2cmyScRmm6pW4jR14,9
+tgparser_cli-0.1.0.dist-info/RECORD,,