tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/cli.py

@@ -0,0 +1,136 @@
+# --------------------------------------------------------------------
+# Copyright (C) Oliver 'kfsone' Smith 2014 <oliver@kfs.org>:
+# Copyright (C) Bernd 'Gazelle' Gollesch 2016, 2017
+# Copyright (C) Jonathan 'eyeonus' Jones 2018, 2019
+#
+# You are free to use, redistribute, or even print and eat a copy of
+# this software so long as you include this copyright notice.
+# I guarantee there is at least one bug neither of us knew about.
+# --------------------------------------------------------------------
+# TradeDangerous :: Command Line App :: Main Module
+#
+# TradeDangerous is a powerful set of tools for traders in Frontier
+# Development's game "Elite: Dangerous". It's main function is
+# calculating the most profitable trades between either individual
+# stations or working out "profit runs".
+#
+# I wrote TD because I realized that the best trade run - in terms
+# of the "average profit per stop" was rarely as simple as going
+# Chango -> Dahan -> Chango.
+#
+# E:D's economy is complex; sometimes you can make the most profit
+# by trading one item A->B and flying a second item B->A.
+# But more often you need to fly multiple stations, especially since
+# as you are making money different trade options are coming into
+# your affordable range.
+#
+# END USERS: If you are a user looking to find out how to use TD,
+# please consult the file "README.md".
+#
+# DEVELOPERS: If you are a programmer who wants TD to do something
+# cool, please see the TradeDB and TradeCalc modules. TD is designed
+# to empower other programmers to do cool stuff.
+
+import os
+import sys
+import traceback
+
+from . import commands
+from . import tradeexcept
+from .commands import exceptions
+from .plugins import PluginException
+
+from . import tradedb
+
+if "CPROF" in os.environ:
+    import cProfile
+
+
+def main(argv = None):
+    if not argv:
+        argv = sys.argv
+    if sys.hexversion < 0x30813F0:
+        raise SystemExit(
+            "Sorry: TradeDangerous requires Python 3.8.19 or higher.\n"
+            "For assistance, see:\n"
+            "\tBug Tracker: https://github.com/eyeonus/Trade-Dangerous/issues\n"
+            "\tDocumentation: https://github.com/eyeonus/Trade-Dangerous/wiki\n"
+            "\tEDForum Thread: https://forums.frontier.co.uk/showthread.php/441509\n"
+        )
+    
+    try:
+        try:
+            if "CPROF" in os.environ:
+                cProfile.run("trade(argv)")
+            else:
+                trade(argv)
+        except PluginException as e:
+            print("PLUGIN ERROR: {}".format(e))
+            if 'EXCEPTIONS' in os.environ:
+                raise e
+            sys.exit(1)
+        except tradeexcept.TradeException as e:
+            print("%s: %s" % (argv[0], str(e)))
+            if 'EXCEPTIONS' in os.environ:
+                raise e
+            sys.exit(1)
+    except (UnicodeEncodeError, UnicodeDecodeError):
+        print("-----------------------------------------------------------")
+        print("ERROR: Unexpected unicode error in the wild!")
+        print()
+        print(traceback.format_exc())
+        print(
+            "Please report this bug (http://github.com/eyeonus/Trade-Dangerous/issues). You may be "
+            "able to work around it by using the '-q' parameter. Windows "
+            "users may be able to use 'chcp.com 65001' to tell the console "
+            "you want to support UTF-8 characters."
+        )
+
+def trade(argv):
+    """
+    This method represents the trade command.
+    """
+    cmdIndex = commands.CommandIndex()
+    cmdenv = cmdIndex.parse(argv)
+    
+    # Phase A: preflight/fast validation (must run before any heavy TradeDB load)
+    if (preflight := getattr(cmdenv, "preflight", None)) and callable(preflight):
+        preflight()
+    
+    # Phase B: heavy init + execution
+    tdb = tradedb.TradeDB(cmdenv, load=cmdenv.wantsTradeDB)
+    if cmdenv.usesTradeData:
+        tsc = tdb.tradingStationCount
+        if tsc == 0:
+            raise exceptions.NoDataError(
+                "There is no trading data for ANY station in "
+                "the local database. Please enter or import "
+                "price data."
+            )
+        if tsc == 1:
+            raise exceptions.NoDataError(
+                "The local database only contains trading data "
+                "for one station. Please enter or import data "
+                "for additional stations."
+            )
+        if tsc < 8:
+            cmdenv.NOTE(
+                "The local database only contains trading data "
+                "for {} stations. Please enter or import data "
+                "for additional stations.".format(
+                    tsc
+                )
+            )
+    
+    try:
+        results = cmdenv.run(tdb)
+    except tradeexcept.SimpleAbort as e:
+        cmdenv.console.print(f"\n{e}\n", style="red")
+        sys.exit(1)
+    finally:
+        # always close tdb
+        tdb.close(final=True)
+    
+    if results:
+        results.render()
+

tradedangerous/commands/TEMPLATE.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+import typing
+
+from .commandenv import ResultRow
+from .parsing import ParseArgument  # import specific helpers as needed
+
+from tradedangerous.formatting import RowFormat
+
+if typing.TYPE_CHECKING:
+    from tradedangerous import TradeDB, TradeORM, CommandEnv, CommandResults
+
+
+######################################################################
+# Parser config
+
+help = 'Describe your command briefly here for the top-level --help.'
+name = 'TEMPLATE'       # name of your .py file excluding the _cmd
+epilog = None           # text to print at the bottom of --help
+
+# Whether this command needs a TradeDB instance
+wantsTradeDB = True
+usesTradeData = False
+
+# Parser wiring (keep tuples for consistency with loader)
+arguments = (
+    ParseArgument("name", help="Example positional(s).", type=str, nargs="*"),
+)
+switches = (
+    ParseArgument("--flag", help="Example flag.", action="store_true", default=False),
+)
+
+
+# Runtime API
+
+
+def run(
+        results: CommandResults,
+        cmdenv: CommandEnv,
+        tdb: TradeDB | TradeORM | None,     # choose one
+    ) -> CommandResults | bool | None:      # choose one
+    """
+    Implement code that validates arguments, collects and prepares
+    any data you will need to generate your results for the user.
+    
+    If your command has finished and has no output to generate,
+    return None, otherwise return "results" to be forwarded to
+    the 'render' function.
+    
+    DO NOT print() during 'run', this allows run() functions to
+    be re-used between modules and allows them to be used beyond
+    the trade.py command line - e.g. someone writing a TD GUI
+    will call run() and then render the results themselves.
+    """
+    
+    ### TODO: Implement
+    row = ResultRow(example="ok")
+    results.rows.append(row)
+    return results
+
+
+def render(results: CommandResults, cmdenv: CommandEnv, tdb: TradeDB | TradeORM | None):
+    """
+    If run() returns a truthy value, the trade.py code will then
+    call the corresponding render() function.
+    
+    This is where you should generate any output from your command.
+    """
+    fmt = RowFormat()
+    fmt.addColumn("Example", "<", 10, key=lambda r: getattr(r, "example", ""))
+    if not cmdenv.quiet:
+        hdr, ul = fmt.heading()
+        print(hdr, ul, sep="\n")
+    for row in results.rows:
+        print(fmt.format(row))

tradedangerous/commands/__init__.py

@@ -0,0 +1,244 @@
+from .commandenv import CommandEnv
+from textwrap import TextWrapper
+
+import argparse  # For parsing command line args.
+import os
+import pathlib
+import sys
+
+from . import exceptions
+from . import parsing
+
+from . import buildcache_cmd
+from . import buy_cmd
+from . import export_cmd
+from . import import_cmd
+from . import local_cmd
+from . import market_cmd
+from . import nav_cmd
+from . import olddata_cmd
+from . import rares_cmd
+from . import run_cmd
+from . import sell_cmd
+from . import shipvendor_cmd
+from . import station_cmd
+from . import trade_cmd
+from . import update_cmd
+
+from tradedangerous import version
+from tradedangerous.tradeenv import ENV_DEFAULTS
+
+
+thismodule = sys.modules[__name__]
+
+commandIndex = {
+    cmd[0:cmd.find('_cmd')]: getattr(thismodule, cmd)
+    for cmd in thismodule.__dir__() if cmd.endswith("_cmd")
+}
+
+######################################################################
+# Helpers
+
+
+class HelpAction(argparse.Action):
+    """
+        argparse action helper for printing the argument usage,
+        because Python 3.4's argparse is ever-so subtly very broken.
+    """
+    
+    def __call__(self, parser, namespace, values, option_string = None):
+        raise exceptions.UsageError(
+                f"TradeDangerous v{version.__version__} help",
+                parser.format_help()
+        )
+
+
+def addArguments(group, options, required, topGroup = None):
+    """
+        Registers a list of options to the specified group. Nodes
+        are either an instance of ParseArgument or a list of
+        ParseArguments. The list form is considered to be a
+        mutually exclusive group of arguments.
+    """
+    for option in options:
+        if isinstance(option, parsing.MutuallyExclusiveGroup):
+            exGrp = (topGroup or group).add_mutually_exclusive_group()
+            parsing.registerParserHelpers(exGrp)
+            addArguments(exGrp, option.arguments, required, topGroup = group)
+        else:
+            assert required not in option.kwargs
+            if option.args[0][0] == '-':
+                group.add_argument(*(option.args), required = required, **(option.kwargs))
+            elif required:
+                group.add_argument(*(option.args), **(option.kwargs))
+            else:
+                group.add_argument(*(option.args), nargs = '?', **(option.kwargs))
+
+
+def _findFromFile(cmd, prefix = '.tdrc'):
+    if cmd:
+        # check the current directory, fall back to home
+        filename = f'{prefix}_{cmd}'
+        for dirname in '.', os.path.expanduser('~'):
+            cmdPath = pathlib.Path(dirname) / filename
+            if cmdPath.exists():
+                return cmdPath.resolve()
+    return None
+
+
+class CommandIndex:
+    
+    def usage(self, argv):
+        """
+            Generate the outlying usage text for TD.
+            This tells the user the list of current
+            commands, generated programatically,
+            and the outlying command functionality.
+        """
+        
+        text = (
+            "Usage: {prog} <command>\n\n"
+            "Where <command> is one of:\n\n"
+                .format(prog = argv[0])
+        )
+        
+        # Figure out the pre-indentation
+        cmdFmt = '  {:<12s}  '
+        cmdFmtLen = len(cmdFmt.format(''))
+        tw = TextWrapper(
+                subsequent_indent = ' ' * (cmdFmtLen + 1),
+                width = 78,
+                drop_whitespace = True,
+                expand_tabs = True,
+                fix_sentence_endings = True,
+                break_long_words = False,
+                break_on_hyphens = True,
+                )
+        
+        lastCmdName = None
+        for cmdName, cmd in sorted(commandIndex.items()):
+            tw.initial_indent = cmdFmt.format(cmdName)
+            text += tw.fill(cmd.help) + "\n"
+            lastCmdName = cmdName
+        
+        text += (
+            "\n"
+            f"Version {version.__version__}\n"
+            f"For additional help on a specific command, such as '{lastCmdName}' use\n"
+            f"  {argv[0]} {lastCmdName} -h"
+            )
+        return text
+    
+    def parse(self, argv, fromfile_prefix = '+'):
+        if len(argv) <= 1 or argv[1] == '--help' or argv[1] == '-h':
+            raise exceptions.UsageError(
+                    "TradeDangerous provides a set of trade database "
+                    "facilities for Elite:Dangerous.", self.usage(argv))
+        
+        cmdName, cmdModule = argv[1].casefold(), None
+        try:
+            cmdModule = commandIndex[cmdName]
+        except KeyError:
+            pass
+        
+        if not cmdModule:
+            candidates = []
+            for name, module in commandIndex.items():
+                if name.startswith(cmdName):
+                    candidates.append([name, module])
+            if not candidates:
+                raise exceptions.CommandLineError(
+                        f"Unrecognized command, '{cmdName}'",
+                        self.usage(argv)
+                )
+            if len(candidates) > 1:
+                candidate_names = ', '.join(c[0] for c in candidates)
+                raise exceptions.CommandLineError(
+                        f"Ambiguous command, '{cmdName}', could match: {candidate_names}",
+                        self.usage(argv)
+                )
+            argv[1] = cmdName = candidates[0][0]
+            cmdModule = candidates[0][1]
+        
+        class ArgParser(argparse.ArgumentParser):
+            def error(self, message):
+                raise exceptions.CommandLineError(message, self.format_usage())
+        
+        parser = ArgParser(
+                    description = f"TradeDangerous v{version.__version__}: {cmdName}",
+                    add_help = False,
+                    allow_abbrev = True,
+                    epilog = f"Version {version.__version__}.\nUse {argv[0]} {argv[1]} -h for more help",
+                    fromfile_prefix_chars = fromfile_prefix,
+                )
+        parser.set_defaults(_editing = False)
+        parsing.registerParserHelpers(parser)
+        
+        subParsers = parser.add_subparsers(title = 'Command Options')
+        subParser = subParsers.add_parser(cmdModule.name,
+                                    help = cmdModule.help,
+                                    add_help = False,
+                                    epilog = cmdModule.epilog,
+                                    )
+        parsing.registerParserHelpers(subParser)
+        
+        arguments = cmdModule.arguments
+        if arguments:
+            argParser = subParser.add_argument_group('Required Arguments')
+            addArguments(argParser, arguments, True)
+        
+        switches = cmdModule.switches
+        if switches:
+            switchParser = subParser.add_argument_group('Optional Switches')
+            addArguments(switchParser, switches, False)
+        
+        # Arguments common to all subparsers.
+        stdArgs = subParser.add_argument_group('Common Switches')
+        stdArgs.add_argument('--help', '-h',
+                    help = 'Show this help message and exit.',
+                    action = HelpAction, nargs = 0,
+                )
+        stdArgs.add_argument('--debug', '-w',
+                    help = 'Enable/raise level of diagnostic output.',
+                    default = 0, required = False, action = 'count',
+                )
+        stdArgs.add_argument('--detail', '-v',
+                    help = 'Increase level of detail in output.',
+                    default = 0, required = False, action = 'count',
+                )
+        stdArgs.add_argument('--color', '-c',
+                    help = 'Add color to output for enhanced readability.',
+                    default = False, action = 'store_true',
+                )
+        stdArgs.add_argument('--quiet', '-q',
+                    help = 'Reduce level of detail in output.',
+                    default = 0, required = False, action = 'count',
+                )
+        stdArgs.add_argument('--db',
+                    help = 'Specify location of the SQLite database.',
+                    default = None, dest = 'dbFilename', type = str,
+                )
+        stdArgs.add_argument('--cwd', '-C',
+                    help = 'Change the working directory file accesses are made from.',
+                    type = str, required = False,
+                )
+        stdArgs.add_argument('--link-ly', '-L',
+                    help = 'Maximum lightyears between systems to be considered linked.',
+                    type = float,
+                    default = ENV_DEFAULTS['maxSystemLinkLy'], dest = 'maxSystemLinkLy',
+                )
+        
+        fromfilePath = _findFromFile(cmdModule.name)
+        if fromfilePath:
+            argv.insert(2, f'{fromfile_prefix}{fromfilePath}')
+        
+        # Parse argv; optionally swallow unknown args/switches if the module allows it.
+        accept_unknown = getattr(cmdModule, 'acceptUnknown', False)
+        if accept_unknown:
+            properties, _unknown = parser.parse_known_args(argv[1:])
+        else:
+            properties = parser.parse_args(argv[1:])
+        
+        parsed = CommandEnv(vars(properties), argv, cmdModule)
+        parsed.DEBUG0("Command line was: {}", argv)
+        return parsed

tradedangerous/commands/buildcache_cmd.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+import typing
+
+from .exceptions import CommandLineError
+from .parsing import ParseArgument
+
+from tradedangerous.db.lifecycle import ensure_fresh_db
+
+if typing.TYPE_CHECKING:
+    from tradedangerous import CommandEnv, CommandResults, TradeDB
+
+
+######################################################################
+# Parser config
+
+help = 'Build TradeDangerous cache file from sources'
+name = 'buildcache'
+epilog = (
+        'TD will normally do this for you automatically whenever '
+        'it detects changes to one or more source file; most end-'
+        'users will never need to use this command.\n'
+        'N.B. This process is destructive: '
+        'any data in the .db that is not reflected in the '
+        'source files will be lost.'
+)
+wantsTradeDB = False  # Cause we're about to frak with it.
+arguments = [
+]
+switches = [
+    ParseArgument(
+        '--sql', default = None, dest = 'sqlFilename',
+        help = 'Specify SQL script to execute.',
+    ),
+    ParseArgument(
+        '--prices', default = None, dest = 'pricesFilename',
+        help = 'Specify the prices file to load.',
+    ),
+    ParseArgument(
+        '--force', '-f', default = False, action = 'store_true',
+        dest = 'force',
+        help = 'Overwrite existing file',
+    ),
+    ParseArgument(
+        '--ignore-unknown', '-i',
+        default = False, action = 'store_true',
+        dest = 'ignoreUnknown',
+        help = (
+            "Data for systems, stations and items that are not "
+            "recognized is reported as warning but skipped."
+        ),
+    ),
+]
+
+######################################################################
+# Helpers
+
+######################################################################
+# Perform query and populate result set
+
+
+def run(results: CommandResults, cmdenv: CommandEnv, tdb: TradeDB) -> bool:
+    """
+    BRUTE-FORCE rebuild of the cache/database.
+    
+    Semantics preserved:
+      - If DB exists and --force not given => error
+      - SQL file must exist
+      - Performs a full destructive rebuild
+    
+    Implementation change:
+      - Delegates to tradedangerous.db.lifecycle.ensure_fresh_db with mode='force'
+        so all backend-specific checks and rebuild steps run via the central path.
+    """
+    # Deprecation note: keep short and visible but non-fatal.
+    print("NOTE: 'buildcache' is deprecated. Prefer 'update' or importer plugins. "
+          "Proceeding with a forced rebuild via db.lifecycle.ensure_fresh_db().")
+    
+    # Honor legacy safety: require --force to overwrite an existing DB file.
+    if not cmdenv.force and tdb.dbPath.exists():
+        raise CommandLineError(
+            f"SQLite3 database '{tdb.dbFilename}' already exists.\n"
+            "Either remove the file first or use the '-f/--force' option."
+        )
+    
+    # Ensure the SQL source exists (buildCache ultimately relies on this path).
+    if not tdb.sqlPath.exists():
+        raise CommandLineError(f"SQL File does not exist: {tdb.sqlFilename}")
+    
+    # Force a rebuild through the lifecycle helper (works for both backends).
+    ensure_fresh_db(
+        backend=tdb.engine.dialect.name if getattr(tdb, "engine", None) else "sqlite",
+        engine=getattr(tdb, "engine", None),
+        data_dir=tdb.dataPath,
+        metadata=None,
+        mode="force",
+        tdb=tdb,
+        tdenv=cmdenv,
+        rebuild=True,
+    )
+    
+    # We've done everything, there is no work for the caller to do.
+    return False