mt5cli 0.1.0__py3-none-any.whl

mt5cli/__init__.py

@@ -0,0 +1,12 @@
+"""mt5cli: Command-line tool for MetaTrader 5."""
+
+from importlib.metadata import version
+
+from .cli import detect_format, export_dataframe
+
+__version__ = version(__package__) if __package__ else None
+
+__all__ = [
+    "detect_format",
+    "export_dataframe",
+]

mt5cli/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for running mt5cli as a module via ``python -m mt5cli``."""
+
+from mt5cli.cli import main
+
+main()

mt5cli/cli.py

@@ -0,0 +1,752 @@
+"""Command-line interface for MetaTrader 5 data export."""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import StrEnum
+from pathlib import Path  # noqa: TC003
+from typing import TYPE_CHECKING, Annotated, cast
+
+import click
+import typer
+from pdmt5 import Mt5Config, Mt5DataClient
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+TIMEFRAME_MAP: dict[str, int] = {
+    "M1": 1,
+    "M2": 2,
+    "M3": 3,
+    "M4": 4,
+    "M5": 5,
+    "M6": 6,
+    "M10": 10,
+    "M12": 12,
+    "M15": 15,
+    "M20": 20,
+    "M30": 30,
+    "H1": 16385,
+    "H2": 16386,
+    "H3": 16387,
+    "H4": 16388,
+    "H6": 16390,
+    "H8": 16392,
+    "H12": 16396,
+    "D1": 16408,
+    "W1": 32769,
+    "MN1": 49153,
+}
+
+TICK_FLAG_MAP: dict[str, int] = {
+    "ALL": 1,
+    "INFO": 2,
+    "TRADE": 4,
+}
+
+_FORMAT_EXTENSIONS: dict[str, str] = {
+    ".csv": "csv",
+    ".json": "json",
+    ".parquet": "parquet",
+    ".pq": "parquet",
+    ".db": "sqlite3",
+    ".sqlite": "sqlite3",
+    ".sqlite3": "sqlite3",
+}
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+
+class OutputFormat(StrEnum):
+    """Supported output file formats."""
+
+    csv = "csv"
+    json = "json"
+    parquet = "parquet"
+    sqlite3 = "sqlite3"
+
+
+class LogLevel(StrEnum):
+    """Logging verbosity levels."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+
+# ---------------------------------------------------------------------------
+# Click parameter types
+# ---------------------------------------------------------------------------
+
+
+class _DateTimeType(click.ParamType):
+    """Click parameter type for ISO 8601 datetime strings."""
+
+    name = "DATETIME"
+
+    def convert(
+        self,
+        value: object,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
+    ) -> datetime:
+        """Convert a string value to a timezone-aware datetime.
+
+        Args:
+            value: Raw value from the command line.
+            param: Click parameter instance.
+            ctx: Click context.
+
+        Returns:
+            Parsed datetime.
+        """
+        if isinstance(value, datetime):
+            return value
+        try:
+            return parse_datetime(str(value))
+        except ValueError as exc:
+            self.fail(str(exc), param, ctx)
+
+
+class _TimeframeType(click.ParamType):
+    """Click parameter type for MT5 timeframe values."""
+
+    name = "TIMEFRAME"
+
+    def convert(
+        self,
+        value: object,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
+    ) -> int:
+        """Convert a string or integer value to a timeframe integer.
+
+        Args:
+            value: Raw value from the command line.
+            param: Click parameter instance.
+            ctx: Click context.
+
+        Returns:
+            Integer timeframe value.
+        """
+        if isinstance(value, int):
+            return value
+        try:
+            return parse_timeframe(str(value))
+        except ValueError as exc:
+            self.fail(str(exc), param, ctx)
+
+
+class _TickFlagsType(click.ParamType):
+    """Click parameter type for MT5 tick copy flags."""
+
+    name = "FLAGS"
+
+    def convert(
+        self,
+        value: object,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
+    ) -> int:
+        """Convert a string or integer value to a tick flags integer.
+
+        Args:
+            value: Raw value from the command line.
+            param: Click parameter instance.
+            ctx: Click context.
+
+        Returns:
+            Integer tick flag value.
+        """
+        if isinstance(value, int):
+            return value
+        try:
+            return parse_tick_flags(str(value))
+        except ValueError as exc:
+            self.fail(str(exc), param, ctx)
+
+
+DATETIME_TYPE = _DateTimeType()
+TIMEFRAME_TYPE = _TimeframeType()
+TICK_FLAGS_TYPE = _TickFlagsType()
+
+# ---------------------------------------------------------------------------
+# Export context
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class _ExportContext:
+    """Shared context data passed from the callback to each subcommand."""
+
+    output: Path
+    output_format: str
+    table: str
+    config: Mt5Config
+
+
+# ---------------------------------------------------------------------------
+# Public utility functions
+# ---------------------------------------------------------------------------
+
+
+def detect_format(
+    output_path: Path,
+    explicit_format: str | None = None,
+) -> str:
+    """Detect the output format from a file extension or explicit format string.
+
+    Args:
+        output_path: Path to the output file.
+        explicit_format: Explicitly specified format, if any.
+
+    Returns:
+        The detected format string.
+
+    Raises:
+        ValueError: If the format cannot be determined.
+    """
+    if explicit_format is not None:
+        return explicit_format
+    suffix = output_path.suffix.lower()
+    if suffix in _FORMAT_EXTENSIONS:
+        return _FORMAT_EXTENSIONS[suffix]
+    msg = (
+        f"Cannot detect format from extension '{suffix}'."
+        " Use --format to specify the output format."
+    )
+    raise ValueError(msg)
+
+
+def export_dataframe(
+    df: pd.DataFrame,
+    output_path: Path,
+    output_format: str,
+    table_name: str = "data",
+) -> None:
+    """Export a pandas DataFrame to the specified file format.
+
+    Args:
+        df: DataFrame to export.
+        output_path: Path to the output file.
+        output_format: Output format (csv, json, parquet, or sqlite3).
+        table_name: Table name for SQLite3 output.
+
+    Raises:
+        ValueError: If the output format is not supported.
+    """
+    if output_format == "csv":
+        df.to_csv(output_path, index=False)
+    elif output_format == "json":
+        df.to_json(
+            output_path,
+            orient="records",
+            date_format="iso",
+            indent=2,
+        )
+    elif output_format == "parquet":
+        df.to_parquet(output_path, index=False)
+    elif output_format == "sqlite3":
+        with sqlite3.connect(output_path) as conn:
+            df.to_sql(  # type: ignore[reportUnknownMemberType]
+                table_name,
+                conn,
+                if_exists="replace",
+                index=False,
+            )
+    else:
+        msg = f"Unsupported output format: {output_format}"
+        raise ValueError(msg)
+
+
+def parse_datetime(value: str) -> datetime:
+    """Parse an ISO 8601 datetime string to a timezone-aware datetime.
+
+    Args:
+        value: ISO 8601 datetime string (e.g., '2024-01-01' or
+            '2024-01-01T12:00:00+00:00').
+
+    Returns:
+        Parsed datetime with UTC timezone if no timezone is specified.
+
+    Raises:
+        ValueError: If the string cannot be parsed.
+    """
+    try:
+        dt = datetime.fromisoformat(value)
+    except ValueError:
+        msg = f"Invalid datetime format: '{value}'. Use ISO 8601 format."
+        raise ValueError(msg) from None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt
+
+
+def parse_timeframe(value: str) -> int:
+    """Parse a timeframe string or integer value.
+
+    Args:
+        value: Timeframe name (e.g., 'M1', 'H1', 'D1') or integer value.
+
+    Returns:
+        Integer timeframe value.
+
+    Raises:
+        ValueError: If the timeframe is invalid.
+    """
+    upper = value.upper()
+    if upper in TIMEFRAME_MAP:
+        return TIMEFRAME_MAP[upper]
+    try:
+        return int(value)
+    except ValueError:
+        valid = ", ".join(TIMEFRAME_MAP)
+        msg = f"Invalid timeframe: '{value}'. Use one of: {valid}, or an integer."
+        raise ValueError(msg) from None
+
+
+def parse_tick_flags(value: str) -> int:
+    """Parse tick flags string or integer value.
+
+    Args:
+        value: Tick flag name (ALL, INFO, TRADE) or integer value.
+
+    Returns:
+        Integer tick flag value.
+
+    Raises:
+        ValueError: If the flag is invalid.
+    """
+    upper = value.upper()
+    if upper in TICK_FLAG_MAP:
+        return TICK_FLAG_MAP[upper]
+    try:
+        return int(value)
+    except ValueError:
+        valid = ", ".join(TICK_FLAG_MAP)
+        msg = f"Invalid tick flags: '{value}'. Use one of: {valid}, or an integer."
+        raise ValueError(msg) from None
+
+
+# ---------------------------------------------------------------------------
+# Typer application
+# ---------------------------------------------------------------------------
+
+app = typer.Typer(
+    name="mt5cli",
+    help="Export MetaTrader5 data to CSV, JSON, Parquet, or SQLite3.",
+)
+
+
+def _get_export_context(ctx: typer.Context) -> _ExportContext:
+    return cast("_ExportContext", ctx.obj)
+
+
+def _execute_export(
+    ctx: typer.Context,
+    fetch_fn: Callable[[Mt5DataClient], pd.DataFrame],
+) -> None:
+    """Execute the common connect-fetch-export-shutdown workflow.
+
+    Args:
+        ctx: Typer context carrying shared options.
+        fetch_fn: Callable that receives a connected client and returns a
+            DataFrame.
+    """
+    export_ctx = _get_export_context(ctx)
+    client = Mt5DataClient(config=export_ctx.config)
+    client.initialize_and_login_mt5()
+    try:
+        df = fetch_fn(client)
+        export_dataframe(
+            df=df,
+            output_path=export_ctx.output,
+            output_format=export_ctx.output_format,
+            table_name=export_ctx.table,
+        )
+        logger.info(
+            "Exported %d rows to %s (%s)",
+            len(df),
+            export_ctx.output,
+            export_ctx.output_format,
+        )
+    finally:
+        client.shutdown()
+
+
+@app.callback()
+def _callback(  # pyright: ignore[reportUnusedFunction]
+    ctx: typer.Context,
+    output: Annotated[
+        Path,
+        typer.Option("--output", "-o", help="Output file path."),
+    ],
+    fmt: Annotated[
+        OutputFormat | None,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format (auto-detected from extension if omitted).",
+        ),
+    ] = None,
+    table: Annotated[
+        str,
+        typer.Option(help="Table name for SQLite3 output."),
+    ] = "data",
+    login: Annotated[
+        int | None,
+        typer.Option(help="Trading account login."),
+    ] = None,
+    password: Annotated[
+        str | None,
+        typer.Option(help="Trading account password."),
+    ] = None,
+    server: Annotated[
+        str | None,
+        typer.Option(help="Trading server name."),
+    ] = None,
+    path: Annotated[
+        str | None,
+        typer.Option(help="Path to MetaTrader5 terminal EXE file."),
+    ] = None,
+    timeout: Annotated[
+        int | None,
+        typer.Option(help="Connection timeout in milliseconds."),
+    ] = None,
+    log_level: Annotated[
+        LogLevel,
+        typer.Option("--log-level", help="Logging level."),
+    ] = LogLevel.WARNING,
+) -> None:
+    """Configure shared options for all export commands.
+
+    Raises:
+        typer.BadParameter: If the output format cannot be determined.
+    """
+    logging.basicConfig(level=getattr(logging, log_level.value))
+    try:
+        output_format = detect_format(
+            output,
+            explicit_format=fmt.value if fmt is not None else None,
+        )
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+    ctx.obj = _ExportContext(
+        output=output,
+        output_format=output_format,
+        table=table,
+        config=Mt5Config(
+            path=path,
+            login=login,
+            password=password,
+            server=server,
+            timeout=timeout,
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Subcommands
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def rates_from(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+    timeframe: Annotated[
+        int,
+        typer.Option(
+            click_type=TIMEFRAME_TYPE,
+            help="Timeframe (e.g., M1, H1, D1, or integer).",
+        ),
+    ],
+    date_from: Annotated[
+        datetime,
+        typer.Option(
+            click_type=DATETIME_TYPE,
+            help="Start date in ISO 8601 format.",
+        ),
+    ],
+    count: Annotated[int, typer.Option(help="Number of records.")],
+) -> None:
+    """Export rates from a start date."""
+    _execute_export(
+        ctx,
+        lambda c: c.copy_rates_from_as_df(
+            symbol=symbol,
+            timeframe=timeframe,
+            date_from=date_from,
+            count=count,
+        ),
+    )
+
+
+@app.command()
+def rates_from_pos(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+    timeframe: Annotated[
+        int,
+        typer.Option(
+            click_type=TIMEFRAME_TYPE,
+            help="Timeframe.",
+        ),
+    ],
+    start_pos: Annotated[int, typer.Option(help="Start position (0 = current bar).")],
+    count: Annotated[int, typer.Option(help="Number of records.")],
+) -> None:
+    """Export rates from a start position."""
+    _execute_export(
+        ctx,
+        lambda c: c.copy_rates_from_pos_as_df(
+            symbol=symbol,
+            timeframe=timeframe,
+            start_pos=start_pos,
+            count=count,
+        ),
+    )
+
+
+@app.command()
+def rates_range(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+    timeframe: Annotated[
+        int,
+        typer.Option(
+            click_type=TIMEFRAME_TYPE,
+            help="Timeframe.",
+        ),
+    ],
+    date_from: Annotated[
+        datetime,
+        typer.Option(click_type=DATETIME_TYPE, help="Start date."),
+    ],
+    date_to: Annotated[
+        datetime,
+        typer.Option(click_type=DATETIME_TYPE, help="End date."),
+    ],
+) -> None:
+    """Export rates for a date range."""
+    _execute_export(
+        ctx,
+        lambda c: c.copy_rates_range_as_df(
+            symbol=symbol,
+            timeframe=timeframe,
+            date_from=date_from,
+            date_to=date_to,
+        ),
+    )
+
+
+@app.command()
+def ticks_from(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+    date_from: Annotated[
+        datetime,
+        typer.Option(click_type=DATETIME_TYPE, help="Start date."),
+    ],
+    count: Annotated[int, typer.Option(help="Number of ticks.")],
+    flags: Annotated[
+        int,
+        typer.Option(
+            click_type=TICK_FLAGS_TYPE,
+            help="Tick flags (ALL, INFO, TRADE, or integer).",
+        ),
+    ],
+) -> None:
+    """Export ticks from a start date."""
+    _execute_export(
+        ctx,
+        lambda c: c.copy_ticks_from_as_df(
+            symbol=symbol,
+            date_from=date_from,
+            count=count,
+            flags=flags,
+        ),
+    )
+
+
+@app.command()
+def ticks_range(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+    date_from: Annotated[
+        datetime,
+        typer.Option(click_type=DATETIME_TYPE, help="Start date."),
+    ],
+    date_to: Annotated[
+        datetime,
+        typer.Option(click_type=DATETIME_TYPE, help="End date."),
+    ],
+    flags: Annotated[
+        int,
+        typer.Option(click_type=TICK_FLAGS_TYPE, help="Tick flags."),
+    ],
+) -> None:
+    """Export ticks for a date range."""
+    _execute_export(
+        ctx,
+        lambda c: c.copy_ticks_range_as_df(
+            symbol=symbol,
+            date_from=date_from,
+            date_to=date_to,
+            flags=flags,
+        ),
+    )
+
+
+@app.command()
+def account_info(ctx: typer.Context) -> None:
+    """Export account information."""
+    _execute_export(ctx, lambda c: c.account_info_as_df())
+
+
+@app.command()
+def terminal_info(ctx: typer.Context) -> None:
+    """Export terminal information."""
+    _execute_export(ctx, lambda c: c.terminal_info_as_df())
+
+
+@app.command()
+def symbols(
+    ctx: typer.Context,
+    group: Annotated[
+        str | None,
+        typer.Option(help="Symbol group filter (e.g., *USD*)."),
+    ] = None,
+) -> None:
+    """Export symbol list."""
+    _execute_export(
+        ctx,
+        lambda c: c.symbols_get_as_df(group=group),
+    )
+
+
+@app.command()
+def symbol_info(
+    ctx: typer.Context,
+    symbol: Annotated[str, typer.Option(help="Symbol name.")],
+) -> None:
+    """Export symbol details."""
+    _execute_export(
+        ctx,
+        lambda c: c.symbol_info_as_df(symbol=symbol),
+    )
+
+
+@app.command()
+def orders(
+    ctx: typer.Context,
+    symbol: Annotated[str | None, typer.Option(help="Symbol filter.")] = None,
+    group: Annotated[str | None, typer.Option(help="Group filter.")] = None,
+    ticket: Annotated[int | None, typer.Option(help="Ticket filter.")] = None,
+) -> None:
+    """Export active orders."""
+    _execute_export(
+        ctx,
+        lambda c: c.orders_get_as_df(
+            symbol=symbol,
+            group=group,
+            ticket=ticket,
+        ),
+    )
+
+
+@app.command()
+def positions(
+    ctx: typer.Context,
+    symbol: Annotated[str | None, typer.Option(help="Symbol filter.")] = None,
+    group: Annotated[str | None, typer.Option(help="Group filter.")] = None,
+    ticket: Annotated[int | None, typer.Option(help="Ticket filter.")] = None,
+) -> None:
+    """Export open positions."""
+    _execute_export(
+        ctx,
+        lambda c: c.positions_get_as_df(
+            symbol=symbol,
+            group=group,
+            ticket=ticket,
+        ),
+    )
+
+
+@app.command()
+def history_orders(
+    ctx: typer.Context,
+    date_from: Annotated[
+        datetime | None,
+        typer.Option(click_type=DATETIME_TYPE, help="Start date."),
+    ] = None,
+    date_to: Annotated[
+        datetime | None,
+        typer.Option(click_type=DATETIME_TYPE, help="End date."),
+    ] = None,
+    group: Annotated[str | None, typer.Option(help="Group filter.")] = None,
+    symbol: Annotated[str | None, typer.Option(help="Symbol filter.")] = None,
+    ticket: Annotated[int | None, typer.Option(help="Order ticket.")] = None,
+    position: Annotated[int | None, typer.Option(help="Position ticket.")] = None,
+) -> None:
+    """Export historical orders."""
+    _execute_export(
+        ctx,
+        lambda c: c.history_orders_get_as_df(
+            date_from=date_from,
+            date_to=date_to,
+            group=group,
+            symbol=symbol,
+            ticket=ticket,
+            position=position,
+        ),
+    )
+
+
+@app.command()
+def history_deals(
+    ctx: typer.Context,
+    date_from: Annotated[
+        datetime | None,
+        typer.Option(click_type=DATETIME_TYPE, help="Start date."),
+    ] = None,
+    date_to: Annotated[
+        datetime | None,
+        typer.Option(click_type=DATETIME_TYPE, help="End date."),
+    ] = None,
+    group: Annotated[str | None, typer.Option(help="Group filter.")] = None,
+    symbol: Annotated[str | None, typer.Option(help="Symbol filter.")] = None,
+    ticket: Annotated[int | None, typer.Option(help="Order ticket.")] = None,
+    position: Annotated[int | None, typer.Option(help="Position ticket.")] = None,
+) -> None:
+    """Export historical deals."""
+    _execute_export(
+        ctx,
+        lambda c: c.history_deals_get_as_df(
+            date_from=date_from,
+            date_to=date_to,
+            group=group,
+            symbol=symbol,
+            ticket=ticket,
+            position=position,
+        ),
+    )
+
+
+def main() -> None:
+    """Run the mt5cli CLI."""
+    app()

mt5cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: mt5cli
+Version: 0.1.0
+Summary: Command-line tool for MetaTrader 5
+Project-URL: Repository, https://github.com/dceoy/mt5cli.git
+Author-email: dceoy <dceoy@users.noreply.github.com>
+Maintainer-email: dceoy <dceoy@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: <3.14,>=3.11
+Requires-Dist: click>=8.1.0
+Requires-Dist: pdmt5>=0.2.3
+Requires-Dist: pyarrow>=19.0.0
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+# mt5cli
+
+[![CI/CD](https://github.com/dceoy/mt5cli/actions/workflows/ci.yml/badge.svg)](https://github.com/dceoy/mt5cli/actions/workflows/ci.yml)
+
+Command-line tool for exporting MetaTrader 5 data to CSV, JSON, Parquet, and SQLite3.
+
+Built on top of [pdmt5](https://github.com/dceoy/pdmt5), a pandas-based data handler for MetaTrader 5.
+
+## Features
+
+- **Multi-format export**: CSV, JSON, Parquet, and SQLite3 output formats
+- **Auto-detection**: Format detection from file extensions
+- **Comprehensive data access**: Rates, ticks, account info, symbols, orders, positions, and trading history
+- **Flexible timeframes**: Named timeframes (M1, H1, D1, etc.) and numeric values
+- **Connection management**: Optional credentials, server, and timeout configuration
+
+## Installation
+
+```bash
+pip install -U mt5cli MetaTrader5
+```
+
+## Usage
+
+```bash
+# Export account information to CSV
+mt5cli -o account.csv account-info
+
+# Export EURUSD M1 rates to Parquet
+mt5cli -o rates.parquet rates-from --symbol EURUSD --timeframe M1 \
+  --date-from 2024-01-01 --count 1000
+
+# Export ticks to JSON
+mt5cli -o ticks.json ticks-from --symbol EURUSD \
+  --date-from 2024-01-01 --count 500 --flags ALL
+
+# Export symbols to SQLite3 with custom table name
+mt5cli -o data.db --table symbols symbols --group "*USD*"
+
+# Export with connection credentials
+mt5cli --login 12345 --password mypass --server MyBroker-Demo \
+  -o positions.csv positions
+```
+
+Run as a Python module:
+
+```bash
+python -m mt5cli -o account.csv account-info
+```
+
+## Commands
+
+| Command          | Description                        |
+| ---------------- | ---------------------------------- |
+| `rates-from`     | Export rates from a start date     |
+| `rates-from-pos` | Export rates from a start position |
+| `rates-range`    | Export rates for a date range      |
+| `ticks-from`     | Export ticks from a start date     |
+| `ticks-range`    | Export ticks for a date range      |
+| `account-info`   | Export account information         |
+| `terminal-info`  | Export terminal information        |
+| `symbols`        | Export symbol list                 |
+| `symbol-info`    | Export symbol details              |
+| `orders`         | Export active orders               |
+| `positions`      | Export open positions              |
+| `history-orders` | Export historical orders           |
+| `history-deals`  | Export historical deals            |
+
+## Requirements
+
+- Python 3.11+
+- Windows OS (MetaTrader 5 requirement)
+- MetaTrader 5 platform installed
+
+## Development
+
+```bash
+git clone https://github.com/dceoy/mt5cli.git
+cd mt5cli
+uv sync
+```
+
+## License
+
+[MIT](LICENSE)

mt5cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mt5cli/__init__.py,sha256=OPh4k17J0bseeZEcr81tMBq1gCU57D25sfHmS86E7SE,261
+mt5cli/__main__.py,sha256=9bRiqj9W8GmXw2imj5Xa7GxnvNBfIV4O9h-q5WTD2Po,112
+mt5cli/cli.py,sha256=7d9is4ZfM9YSk30vfEyRPJjFwxXp3NHk5vMBnl4Sv68,19758
+mt5cli-0.1.0.dist-info/METADATA,sha256=yKmbsMBB_1LsAr1fQ3toFuw0ahMES-ozqJ8yOk1AQ3g,3524
+mt5cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mt5cli-0.1.0.dist-info/entry_points.txt,sha256=JaoS82nFTu2PMePNXofpIv4hUwsUbUI7PFH1AHtt06c,43
+mt5cli-0.1.0.dist-info/licenses/LICENSE,sha256=UWFWn4nTWvSPYJEOmGN3LaX3lhK4rJ7fYoX92ruXg3A,1073
+mt5cli-0.1.0.dist-info/RECORD,,

mt5cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mt5cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mt5cli = mt5cli.cli:main

mt5cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daichi Narushima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.