tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/misc/prices-json-exp.py

@@ -0,0 +1,179 @@
+#! /usr/bin/env python
+
+# Experimental module to generate a JSON version of the .prices file.
+
+import sqlite3
+import json
+import time
+import collections
+import os
+
+
+# Set to True to allow export of systems that don't have any station data
+emptySystems = True
+# Set to True to allow export of stations that don't have prices
+emptyStations = True
+
+conn = sqlite3.connect("data/TradeDangerous.db")
+
+
+def collectItemData(db):
+    """
+    Builds a flat, array of item names that serves as a table of items.
+    Station Price Data refers to this table by position in the array.
+    As a result, we also need a mapping for itemID -> tableID
+    """
+    
+    items = []      # table of items
+    itemIdx = {}    # mapping from itemID -> position in items
+    for ID, name in db.execute("SELECT i.item_id, i.name FROM Item AS i"):
+        itemIdx[ID] = len(items)
+        items.append(name)
+    
+    return items, itemIdx
+
+
+def collectSystems(
+            db,
+            itemIdx,
+            withEmptySystems=False,
+            withStations=True,
+            withEmptyStations=False,
+            withPrices=True
+    ):
+    """
+    Build the System -> Station -> Price data from the supplied DB.
+    
+    withEmptySystems:
+        True: include systems with no station data.
+    
+    withStations:
+        False: (implies withEmptySystems=True) don't include station data.
+    
+    withEmptyStations:
+        True: include stations with no price data.
+    
+    withPrices:
+        False: (implies withEmptyStations=True) don't include price data.
+    """
+    
+    systems = collections.defaultdict(dict)
+    if not withStations:
+        withEmptySystems = True
+    
+    for sysID, sys, posX, posY, posZ in db.execute("""
+            SELECT  sys.system_id, sys.name,
+                    sys.pos_x, sys.pos_y, sys.pos_z
+            FROM  System AS sys
+                    LEFT OUTER JOIN Station
+                        USING (system_id)
+            GROUP  BY 1
+            """):
+        systemData = {
+                 'pos': [ posX, posY, posZ ],
+        }
+        if withStations:
+            stations = collectStations(
+                    db, itemIdx,
+                    sysID,
+                    withEmptyStations=withEmptyStations,
+                    withPrices=withPrices,
+            )
+            if not stations and not withEmptySystems:
+                continue
+            if stations:
+                systemData['stn'] = stations
+        systems[sys] = systemData
+    
+    return systems
+
+
+def collectStations(
+            db,
+            itemIdx,
+            sysID,
+            withEmptyStations=False,
+            withPrices=True
+    ):
+    """
+    Populate a station list for a given system, including price data.
+    """
+    stations = {}
+    if not withPrices:
+        withEmptyStations = True
+    for stnID, name, lsFromStar, lastMod in db.execute("""
+            SELECT  stn.station_id, stn.name, stn.ls_from_star,
+                    MAX(si.modified)
+              FROM  Station AS stn
+                    LEFT OUTER JOIN StationItem si
+                        USING (station_id)
+             WHERE  stn.system_id = ?
+             GROUP  BY 1
+            """, [sysID]):
+        if not lastMod and not withEmptyStations:
+            continue
+        stationData = {
+                'ls':   int(lsFromStar),
+        }
+        if lastMod:
+            stationData['ts'] = lastMod
+            if withPrices:
+                buy, sell = collectPriceData(
+                        db, itemIdx,
+                        stnID,
+                )
+                stationData['buy'] = buy
+                stationData['sell'] = sell
+        
+        stations[name] = stationData
+    
+    return stations
+
+
+def collectPriceData(db, itemIdx, stnID):
+    """
+    Collect buying and selling data for a given station. Items reference the
+    position in the itemData array.
+    """
+    
+    buying, selling = [], []
+    
+    for itmID, cr in db.execute("""
+            SELECT  sb.item_id, sb.price
+              FROM  StationBuying AS sb
+             WHERE  station_id = ?
+            """, [stnID]):
+        buying.append([ itemIdx[itmID], cr ])
+    
+    for itmID, cr, units, level in db.execute("""
+            SELECT  ss.item_id, ss.price, ss.units, ss.level
+              FROM  StationSelling AS ss
+             WHERE  station_id = ?
+            """, [stnID]):
+        selling.append([ itemIdx[itmID], cr, units, level ])
+    
+    return buying, selling
+
+
+itemData, itemIdx = collectItemData(conn)
+sysData = collectSystems(
+        conn, itemIdx,
+        withEmptySystems=emptySystems, withEmptyStations=emptyStations
+)
+jsonData = {
+    'src': 'td/json-exp',
+    'time': int(time.time()),
+    'items': itemData,
+    'emptySys': emptySystems,
+    'emptyStn': emptyStations,
+    'sys': sysData,
+}
+
+try:
+    cmdrName = os.environ['CMDR']
+    jsonData['cmdr'] = cmdrName
+except KeyError:
+    pass
+
+print(json.dumps(jsonData, separators=(',',':')))
+

tradedangerous/misc/progress.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+from contextlib import contextmanager
+import typing
+
+from rich.progress import (
+        Progress as RichProgress,
+        TaskID,
+        ProgressColumn,
+        BarColumn, DownloadColumn, MofNCompleteColumn, SpinnerColumn,
+        TaskProgressColumn, TextColumn, TimeElapsedColumn, TimeRemainingColumn,
+        TransferSpeedColumn
+)
+
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Optional, Type  # noqa
+
+
+class BarStyle:
+    """ Base class for Progress bar style types. """
+    def __init__(self, width: int = 10, prefix: Optional[str] = None, *, add_columns: Optional[Iterable[ProgressColumn]]):
+        self.columns = [SpinnerColumn(), TextColumn("[progress.description]{task.description}"), BarColumn(bar_width=width)]
+        if add_columns:
+            self.columns.extend(add_columns)
+
+
+class CountingBar(BarStyle):
+    """ Creates a progress bar that is counting M/N items to completion. """
+    def __init__(self, width: int = 10, prefix: Optional[str] = None):
+        my_columns = [MofNCompleteColumn(), TimeElapsedColumn()]
+        super().__init__(width, prefix, add_columns=my_columns)
+
+
+class DefaultBar(BarStyle):
+    """ Creates a simple default progress bar with a percentage and time elapsed. """
+    def __init__(self, width: int = 10, prefix: Optional[str] = None):
+        my_columns = [TaskProgressColumn(), TimeElapsedColumn()]
+        super().__init__(width, prefix, add_columns=my_columns)
+
+
+class LongRunningCountBar(BarStyle):
+    """ Creates a progress bar that is counting M/N items to completion with a time-remaining counter """
+    def __init__(self, width: int = 10, prefix: Optional[str] = None):
+        my_columns = [MofNCompleteColumn(), TimeElapsedColumn(), TimeRemainingColumn()]
+        super().__init__(width, prefix, add_columns=my_columns)
+
+
+class ElapsedBar(BarStyle):
+    """ Creates a progress bar that is just showing something will take time. """
+    def __init__(self, width: int = 10, prefix: Optional[str] = None):
+        my_columns = [TimeElapsedColumn()]
+        super().__init__(width, prefix, add_columns=my_columns)
+
+
+class TransferBar(BarStyle):
+    """ Creates a progress bar representing a data transfer, which shows the amount of
+        data transferred, speed, and estimated time remaining. """
+    def __init__(self, width: int = 16, prefix: Optional[str] = None):
+        my_columns = [DownloadColumn(), TransferSpeedColumn(), TimeRemainingColumn()]
+        super().__init__(width, prefix, add_columns=my_columns)
+
+
+class Progress:
+    """
+    Facade around the rich Progress bar system to help transition away from
+    TD's original basic progress bar implementation.
+    """
+    def __init__(self,
+                 max_value: Optional[float] = None,
+                 width: Optional[int] = None,
+                 start: float = 0,
+                 prefix: Optional[str] = None,
+                 label: Optional[str] = None,
+                 *,
+                 style: Optional[Type[BarStyle]] = None,  # pylint:disable=deprecated-typing-alias
+                 show: bool = True,
+                 ) -> None:
+        """
+            :param max_value: Last value we can reach (100%).
+            :param width:     How wide to make the bar itself.
+            :param start:     Override initial value to non-zero.
+            :param prefix:    Text to print between the spinner and the bar.
+            :param style:     Bar-style factory to use for styling.
+            :param show:      If False, disables the bar entirely.
+        """
+        self.show = bool(show)
+        if not show:
+            return
+        
+        if style is None:
+            style = DefaultBar
+        
+        self.max_value = 0 if max_value is None else max(max_value, start)
+        self.value = start
+        self.prefix = prefix or ""
+        self.label = label or "Working..."
+        self.width = width or 25
+        # The 'Progress' itself is a view for displaying the progress of tasks. So we construct it
+        # and then create a task for our job.
+        style_instance = style(width=self.width, prefix=self.prefix)
+        self.progress = RichProgress(
+            # What fields to display.
+            *style_instance.columns,
+            # Hide it once it's finished, update it for us, 4x a second
+            transient=True, auto_refresh=True, refresh_per_second=5
+        )
+        
+        # Now we add an actual task to track progress on.
+        self.task = self.progress.add_task(self.label, total=max_value, start=True)
+        if self.value:
+            self.progress.update(self.task, advance=self.value)
+        
+        # And show the task tracker.
+        self.progress.start()
+    
+    def __enter__(self):
+        """ Context manager.
+            
+            Example use:
+                
+                import time
+                import tradedangerous.progress
+                
+                # Progress(max_value=100, width=32, style=progress.CountingBar)
+                with progress.Progress(100, 32, style=progress.CountingBar) as prog:
+                    for i in range(100):
+                        prog.increment(1)
+                        time.sleep(3)
+        """
+        return self
+    
+    def __exit__(self, *args, **kwargs):
+        self.clear()
+    
+    def increment(self, value: Optional[float] = None, description: Optional[str] = None, *, progress: Optional[float] = None) -> None:
+        """
+        Increase the progress of the bar by a given amount.
+        
+        :param value:  How much to increase the progress by.
+        :param description: If set, replaces the task description.
+        :param progress: Instead of increasing by value, set the absolute progress to this.
+        """
+        if not self.show:
+            return
+        if description:
+            self.prefix = description
+            self.progress.update(self.task, description=description, refresh=True)
+        
+        bump = False
+        if not value and progress is not None and self.value != progress:
+            self.value = progress
+            bump = True
+        elif value:
+            self.value += value              # Update our internal count
+            bump = True
+        
+        if self.value >= self.max_value:  # Did we go past the end? Increase the end.
+            self.max_value += value * 2
+            self.progress.update(self.task, description=self.prefix or self.label, total=self.max_value)
+            bump = True
+        
+        if bump and self.max_value > 0:
+            self.progress.update(self.task, description=self.prefix or self.label, completed=self.value)
+    
+    def clear(self) -> None:
+        """ Remove the current progress bar, if any. """
+        # These two shouldn't happen separately, but incase someone tinkers, test each
+        # separately and shut them down.
+        if not self.show:
+            return
+        
+        if self.task:
+            self.progress.remove_task(self.task)
+            self.task = None
+        
+        if self.progress:
+            self.progress.stop()
+            self.progress = None
+    
+    @contextmanager
+    def sub_task(self, description: str, max_value: Optional[int] = None, width: int = 25):
+        if not self.show:
+            yield
+            return
+        task = self.progress.add_task(description, total=max_value, start=True, width=width)
+        try:
+            yield task
+        finally:
+            self.progress.remove_task(task)
+    
+    def update_task(self, task: TaskID, advance: float | int, description: Optional[str] = None):
+        if self.show:
+            self.progress.update(task, advance=advance, description=description)

tradedangerous/plugins/__init__.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+from textwrap import TextWrapper
+import importlib
+import typing
+
+
+if typing.TYPE_CHECKING:
+    from tradedangerous import TradeDB, TradeEnv
+
+
+__all__ = [
+    'PluginException',
+    'PluginBase',
+    'ImportPluginBase',
+    'load',
+]
+
+
+class PluginException(Exception):
+    """
+    Base class for exceptions thrown by plugins.
+    """
+
+
+class PluginBase:
+    """
+    Base class for plugin implementation.
+    
+    To implement a plugin, create a file in the plugins directory
+    called "mypluginname_plug.py". This file should implement
+    plugin classes derived from the appropriate plugins base,
+    e.g. for an import pluggin:
+        
+        import plugins
+        
+        class ImportPlugin(plugins.ImportPluginBase):
+            # your implementation here
+    """
+    
+    def __init__(self, tdb: TradeDB, tdenv: TradeEnv) -> None:
+        """
+        Parameters:
+            tdb
+                Instance of TradeDB
+            tdenv
+                Instance of TradeEnv
+        """
+        self.tdb = tdb
+        self.tdenv = tdenv
+        self.options: dict[str, typing.Any] = {}
+        
+        pluginOptions: dict[str, typing.Any] = getattr(self, "pluginOptions", {})
+        
+        for opt in tdenv.pluginOptions or {}:
+            equals = opt.find('=')
+            if equals < 0:
+                key, value = opt, True
+            else:
+                key, value = opt[:equals], opt[equals+1:]
+            keyName = key.lower()
+            if keyName not in pluginOptions:
+                if keyName == "help":
+                    raise SystemExit(self.usage())
+                
+                if not pluginOptions:
+                    raise PluginException(
+                        "This plugin does not support any options."
+                    )
+                
+                raise PluginException(
+                    "Unknown plugin option: '{}'.\n"
+                    "\n"
+                    "Valid options for this plugin:\n"
+                    "  {}.\n"
+                    "\n"
+                    "Use '--opt=help' for details.\n"
+                    .format(
+                        opt,
+                        ', '.join(
+                            opt for opt in sorted(pluginOptions.keys())
+                )))
+            self.options[key.lower()] = value
+
+
+    def usage(self):
+        tw = TextWrapper(
+                width=78,
+                drop_whitespace=True,
+                expand_tabs=True,
+                fix_sentence_endings=True,
+                break_long_words=True,
+                break_on_hyphens=True,
+        )
+        
+        assert self.__doc__, "Plugin class requires a docstring to define usage()"
+        text = tw.fill(self.__doc__.strip()) + "\n\n"
+        
+        options = getattr(self, "pluginOptions", None)
+        if not options:
+            return text + "This plugin does not support any options.\n"
+        
+        tw.subsequent_indent=' ' * 24
+        text += "Options supported by this plugin:\n"
+        for opt in sorted(options.keys()):
+            text += f"--opt={opt:<12}  "
+            text += tw.fill(options[opt].strip()) + "\n"
+        text += "\n"
+        text += "You can also chain options together, e.g.:\n"
+        text += f"  --opt={','.join(list(options.keys())[:3])}\n"
+        
+        return text
+
+
+    def getOption(self, key: str) -> typing.Any:
+        """ Case-sensitive plugin-option lookup. """
+        return self.options.get(key.lower(), None)
+
+
+    def run(self) -> bool:
+        """
+        Plugin must implement: Execute the plugin's logic.
+        
+        Called by the parent module before it does any validation
+        of arguments and before it does any processing work.
+        
+        Return True to allow the calling module to continue working,
+        e.g. if your plugin simply changes the tdenv.
+        
+        Return False if you have completed work and the calling
+        module can finish.
+        """
+        raise NotImplementedError
+
+
+    def finish(self) -> bool:
+        """
+        Plugin may need to implement: Called after all preparation
+        work has been done by the sub-command invoking the plugin.
+        
+        Return False if you have completed all neccessary work.
+        Returning True will allow the sub-command to finish its
+        normal workflow after you return.
+        """
+        raise NotImplementedError
+
+
+class ImportPluginBase(PluginBase):
+    """
+    Base class for import plugins.
+    
+    Called by "import" as soon as argument parsing has been done.
+    
+    An import plugin implements "run()" and "finish()".
+    
+    On entry to the "import" function, before the database has
+    been loaded or the cache file generated, the plugin's
+    "run()" member is invoked.
+    
+    This function can do as much or as little work as you need.
+    
+    When you are done, return True to allow "import" to continue,
+    e.g. for example a plugin that simply sets the cmdenv.url to
+    a specific download would return True.
+    
+    On the other hand, if you complete all the import work
+    relevant to your plugin, return None or False and the command
+    will early-out.
+    
+    "finish()" will then be called before the import command
+    tries to import the data. This gives you an opportunity to
+    modify, parse or even import the data yourself.
+    
+    Returning False from finish() ends processing, the import
+    command will rebuild the main .prices file and exit. This
+    allows you to write a plugin that does its own processing
+    of a custom .prices format, for example.
+    
+    Returning True will allow the import command to proceed
+    with import as normal. This allows, for example, a plugin
+    that pre-processes the .prices file before import is called.
+    """
+    
+    defaultImportFile = "import.prices"
+    
+    def __init__(self, tdb: TradeDB, tdenv: TradeEnv) -> None:
+        """
+        Parameters:
+            tdb
+                Instance of TradeDB
+            tdenv
+                Instance of TradeEnv
+        """
+        super().__init__(tdb, tdenv)
+
+
+    def run(self) -> bool:
+        """
+        Plugin Must Implement:
+        
+        Called immediately on entry to the import_cmd.run() function.
+        This means that you have no database access via the tdb object.
+        
+        If you need to access data from the .db file, you should put
+        that code in the "finish()" object.
+        
+        Returns:
+            True if you want the "import" command to continue (e.g.
+            to reach the call to "finish()",
+            False or None to early out after your return.
+        """
+        raise NotImplementedError
+
+
+    def finish(self) -> bool:
+        """
+        Plugin Must Implement:
+        
+        Called after import has rebuilt the cache, loaded the DB data
+        into it's TradeDB instance, done any downloads and checked for
+        the presence of cmdenv.filename, but before it has tried to
+        import the .prices data.
+        
+        Returns:
+            True if you want the "import" command to continue and
+            try to import the .prices data,
+            False or None to early out after your return.
+        """
+        raise NotImplementedError
+
+
+def load(pluginName: str, typeName: str):
+    """
+    Attempt to load a plugin and find the specified plugin
+    class within it.
+    """
+    
+    # Check if a file matching this name exists.
+    moduleName = f"{__name__}.{pluginName.lower()}_plug"
+    try:
+        importedModule = importlib.import_module(moduleName)
+    except ImportError as e:
+        raise PluginException(f"Unable to load plugin '{pluginName}': {e}") from e
+    
+    pluginClass = getattr(importedModule, typeName, None)
+    if not pluginClass:
+        raise PluginException(f"{pluginName} plugin does not provide a {typeName}.")
+    
+    return pluginClass
+