tradedangerous 11.2.1__py3-none-any.whl → 11.3.0__py3-none-any.whl

tradedangerous/cache.py

@@ -30,14 +30,17 @@ import sqlite3
 import sys
 import typing
 
+from functools import partial as partial_fn
+from .fs import file_line_count
 from .tradeexcept import TradeException
+from tradedangerous.misc.progress import Progress, CountingBar
 from . import corrections, utils
 from . import prices
 
 
 # For mypy/pylint type checking
 if typing.TYPE_CHECKING:
-    from typing import Any, Optional, TextIO
+    from typing import Any, Callable, Optional, TextIO  # noqa
     
     from .tradeenv import TradeEnv
 
@@ -777,11 +780,14 @@ def deprecationCheckItem(importPath, lineNo, line):
     )
 
 
-def processImportFile(tdenv, db, importPath, tableName):
+def processImportFile(tdenv, db, importPath, tableName, *, line_callback: Optional[Callable] = None, call_args: Optional[dict] = None):
     tdenv.DEBUG0(
         "Processing import file '{}' for table '{}'",
         str(importPath), tableName
     )
+    call_args = call_args or {}
+    if line_callback:
+        line_callback = partial_fn(line_callback, **call_args)
     
     fkeySelectStr = (
         "("
@@ -870,6 +876,8 @@ def processImportFile(tdenv, db, importPath, tableName):
         uniqueIndex = {}
         
         for linein in csvin:
+            if line_callback:
+                line_callback()
             if not linein:
                 continue
             lineNo = csvin.line_num
@@ -977,25 +985,34 @@ def buildCache(tdb, tdenv):
         tempDB.executescript(sqlScript)
     
     # import standard tables
-    for (importName, importTable) in tdb.importTables:
-        try:
-            processImportFile(tdenv, tempDB, Path(importName), importTable)
-        except FileNotFoundError:
-            tdenv.DEBUG0(
-                "WARNING: processImportFile found no {} file", importName
-            )
-        except StopIteration:
-            tdenv.NOTE(
-                "{} exists but is empty. "
-                "Remove it or add the column definition line.",
-                importName
-            )
-    
-    tempDB.commit()
+    with Progress(max_value=len(tdb.importTables) + 1, prefix="Importing", width=25, style=CountingBar) as prog:
+        for importName, importTable in tdb.importTables:
+            import_path = Path(importName)
+            import_lines = file_line_count(import_path, missing_ok=True)
+            with prog.sub_task(max_value=import_lines, description=importTable) as child:
+                prog.increment(value=1)
+                call_args = {'task': child, 'advance': 1}
+                try:
+                    processImportFile(tdenv, tempDB, import_path, importTable, line_callback=prog.update_task, call_args=call_args)
+                except FileNotFoundError:
+                    tdenv.DEBUG0(
+                        "WARNING: processImportFile found no {} file", importName
+                    )
+                except StopIteration:
+                    tdenv.NOTE(
+                        "{} exists but is empty. "
+                        "Remove it or add the column definition line.",
+                        importName
+                    )
+        prog.increment(1)
+
+        with prog.sub_task(description="Save DB"):
+            tempDB.commit()
     
     # Parse the prices file
     if pricesPath.exists():
-        processPricesFile(tdenv, tempDB, pricesPath)
+        with Progress(max_value=None, width=25, prefix="Processing prices file"):
+            processPricesFile(tdenv, tempDB, pricesPath)
     else:
         tdenv.NOTE(
                 "Missing \"{}\" file - no price data.",

tradedangerous/formatting.py

@@ -8,8 +8,7 @@ import itertools
 import typing
 
 if typing.TYPE_CHECKING:
-    from typing import Any, Optional
-    from collections.abc import Callable
+    from typing import Any, Callable, Optional  # noqa
 
 
 class ColumnFormat:

tradedangerous/fs.py

@@ -1,10 +1,10 @@
 """This module should handle filesystem related operations
 """
 from shutil import copy as shcopy
-from os import makedirs
+from os import makedirs, PathLike
 from pathlib import Path
 
-__all__ = ['copy', 'copyallfiles', 'touch', 'ensurefolder']
+__all__ = ['copy', 'copyallfiles', 'touch', 'ensurefolder', 'file_line_count']
 
 def pathify(*args):
     if len(args) > 1 or not isinstance(args[0], Path):
@@ -99,3 +99,39 @@ def ensurefolder(folder):
     except FileExistsError:
         pass
     return folderPath.resolve()
+
+
+def file_line_count(from_file: PathLike, buf_size: int = 128 * 1024, *, missing_ok: bool = False) -> int:
+    """ counts the number of newline characters in a given file. """
+    if not isinstance(from_file, Path):
+        from_file = Path(from_file)
+
+    if missing_ok and not from_file.exists():
+        return 0
+
+    # Pre-allocate a buffer so that we aren't putting pressure on the garbage collector.
+    buf = bytearray(buf_size)
+
+    # Capture it's counting method, so we don't have to keep looking that up on
+    # large files.
+    counter = buf.count
+
+    total = 0
+    with from_file.open("rb") as fh:
+        # Capture the 'readinto' method to avoid lookups.
+        reader = fh.readinto
+
+        # read into the buffer and capture the number of bytes fetched,
+        # which will be 'size' until the last read from the file.
+        read = reader(buf)
+        while read == buf_size:  # nominal case for large files
+            total += counter(b'\n')
+            read = reader(buf)
+
+        # when 0 <= read < buf_size we're on the last page of the
+        # file, so we need to take a slice of the buffer, which creates
+        # a new object, thus we also have to lookup count. it's trivial
+        # but if you have to do it 10,000x it's definitely not a rounding error.
+        return total + buf[:read].count(b'\n')
+
+

tradedangerous/misc/progress.py

@@ -1,71 +1,179 @@
-import sys
+from rich.progress import (
+        Progress as RichProgress,
+        TaskID,
+        ProgressColumn,
+        BarColumn, DownloadColumn, MofNCompleteColumn, SpinnerColumn, 
+        TaskProgressColumn, TextColumn, TimeElapsedColumn, TimeRemainingColumn,
+        TransferSpeedColumn
+)
+from contextlib import contextmanager
+
+from typing import Iterable, Optional, Union, 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 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:
     """
-    Helper class that describes a simple text-based progress bar.
+    Facade around the rich Progress bar system to help transition away from
+    TD's original basic progress bar implementation.
     """
-    
-    def __init__(self, maxValue, width, start=0, prefix=""):
+    def __init__(self,
+                 max_value: Optional[float] = None,
+                 width: Optional[int] = None,
+                 start: float = 0,
+                 prefix: Optional[str] = None,
+                 *,
+                 style: Optional[Type[BarStyle]] = None,
+                 show: bool = True,
+                 ) -> None:
         """
-        Arguments:
-            maxValue
-                Last value we can reach (100%).
-            width
-                Number of '='s characters for 100%
-            start
-                Initial value
-            prefix
-                Something to print infront of the progress bar
+            :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.start = start
-        self.maxValue = maxValue
-        self.width = width
+        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.progress = -1
-        self.prefix = prefix
-        self.textLen = 0
-        self.mask = '\r' + self.prefix + "[{{:<{width}}}]".format(width=width)
+        self.prefix = prefix or ""
+        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("Working...", total=max_value, start=True)
+        if self.value:
+            self.progress.update(self.task, advance=self.value)
 
-    def increment(self, value, postfix=""):
-        """
-        Increment the progress bar's internal counter by 'value',
-        and if this changes the progress step, re-draw the bar.
-        
-        Attributes:
-            value
-                The amount to increment the internal counter by
-            postfix [optional]
-                String or callable to print after the bar
+        # And show the task tracker.
+        self.progress.start()
+
+    def __enter__(self):
+        """ Context manager.
         
-        Returns:
-            False if the progress bar did not redraw,
-            True if the progress bar was redrawn,
+            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)
         """
-        self.value = min(self.maxValue, self.value + value)
-        progress = int(self.width * (self.value - self.start) / self.maxValue)
-        if progress == self.progress:
-            return False
-        
-        if callable(postfix):
-            postfixText = postfix(self.value, self.maxValue)
-        else:
-            postfixText = postfix
-        text = self.mask.format("="*progress) + postfixText + " "
-        sys.stdout.write(text)
-        sys.stdout.flush()
-        
-        self.progress = progress
-        self.textLen = len(text)
-        
-        return True
+        return self
 
+    def __exit__(self, *args, **kwargs):
+        self.clear()
 
-    def clear(self):
+    def increment(self, value: Optional[float] = None, description: Optional[str] = None, *, progress: Optional[float] = None) -> None:
         """
-        Remove the current progress bar, if any
+        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 self.textLen:
-            fin = "\r{:{width}}\r".format('', width=self.textLen)
-            sys.stdout.write(fin)
-            sys.stdout.flush()
+        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, total=self.max_value)
+            bump = True
+
+        if bump and self.max_value > 0:
+            self.progress.update(self.task, description=self.prefix, 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: Union[float, int], description: Optional[str] = None):
+        if self.show:
+            self.progress.update(task, advance=advance, description=description)

tradedangerous/plugins/eddblink_plug.py

@@ -4,19 +4,18 @@ https://elite.tromador.com/ to update the Database.
 """
 from __future__ import annotations
 
+from email.utils import parsedate_to_datetime
 from pathlib import Path
+from .. fs import file_line_count
 from .. import plugins, cache, transfers
 from ..misc import progress as pbar
 from ..plugins import PluginException
 
-import certifi
 import csv
 import datetime
-from email.utils import parsedate_to_datetime
 import os
 import requests
 import sqlite3
-import ssl
 import typing
 
 
@@ -26,41 +25,12 @@ if typing.TYPE_CHECKING:
 
 # Constants
 BASE_URL = os.environ.get('TD_SERVER') or "https://elite.tromador.com/files/"
-CONTEXT=ssl.create_default_context(cafile=certifi.where())
 
 
 class DecodingError(PluginException):
     pass
 
 
-def _file_line_count(from_file: Path, bufsize: int = 128 * 1024) -> int:
-    """ counts the number of newline characters in a given file. """
-    # Pre-allocate a buffer so we aren't putting pressure on the garbage collector.
-    buf = bytearray(bufsize)
-    
-    # Capture it's counting method, so we don't have to keep looking that up on
-    # large files.
-    counter = buf.count
-    
-    total = 0
-    with from_file.open("rb") as fh:
-        # Capture the 'readinto' method to avoid lookups.
-        reader = fh.readinto
-
-        # read into the buffer and capture the number of bytes fetched,
-        # which will be 'size' until the last read from the file.
-        read = reader(buf)
-        while read == bufsize:  # nominal case for large files
-            total += counter(b'\n')
-            read = reader(buf)
-
-        # when 0 <= read < bufsize we're on the last page of the
-        # file, so we need to take a slice of the buffer, which creates
-        # a new object and thus we also have to lookup count. it's trivial
-        # but if you have to do it 10,000x it's definitely not a rounding error.
-        return total + buf[:read].count(b'\n')
-
-
 def _count_listing_entries(tdenv: TradeEnv, listings: Path) -> int:
     """ Calculates the number of entries in a listing file by counting the lines. """
     if not listings.exists():
@@ -68,7 +38,7 @@ def _count_listing_entries(tdenv: TradeEnv, listings: Path) -> int:
         return 0
     
     tdenv.DEBUG0(f"Getting total number of entries in {listings}...")
-    count = _file_line_count(listings)
+    count = file_line_count(listings)
     if count <= 1:
         if count == 1:
             tdenv.DEBUG0("Listing count of 1 suggests nothing but a header")
@@ -101,7 +71,6 @@ class ImportPlugin(plugins.ImportPluginBase):
     """
     Plugin that downloads data from eddb.
     """
-    
     pluginOptions = {
         'item':         "Update Items using latest file from server. (Implies '-O system,station')",
         'rare':         "Update RareItems using latest file from server. (Implies '-O system,station')",
@@ -213,12 +182,16 @@ class ImportPlugin(plugins.ImportPluginBase):
         """
         listings_path = Path(self.dataPath, listings_file).absolute()
         from_live = listings_path != Path(self.dataPath, self.listingsPath).absolute()
-        self.tdenv.NOTE("Processing market data from {}: Start time = {}. Live = {}", listings_file, self.now(), from_live)
         
+        self.tdenv.NOTE("Checking listings")
         total = _count_listing_entries(self.tdenv, listings_path)
         if not total:
+            self.tdenv.NOTE("No listings")
             return
 
+        self.tdenv.NOTE("Processing market data from {}: Start time = {}. Live = {}", listings_file, self.now(), from_live)
+
+        db = self.tdb.getDB()
         stmt_unliven_station = """UPDATE StationItem SET from_live = 0 WHERE station_id = ?"""
         stmt_flush_station   = """DELETE from StationItem WHERE station_id = ?"""
         stmt_add_listing     = """
@@ -235,20 +208,25 @@ class ImportPlugin(plugins.ImportPluginBase):
         """
         
         # Fetch all the items IDS
-        db = self.tdb.getDB()
         item_lookup = _make_item_id_lookup(self.tdenv, db.cursor())
         station_lookup = _make_station_id_lookup(self.tdenv, db.cursor())
         last_station_update_times = _collect_station_modified_times(self.tdenv, db.cursor())
         
         cur_station = None
+        is_debug = self.tdenv.debug > 0
         self.tdenv.DEBUG0("Processing entries...")
-        with listings_path.open("r", encoding="utf-8", errors="ignore") as fh:
-            prog = pbar.Progress(total, 50)
-
-            cursor: Optional[sqlite3.Cursor] = db.cursor()
+        
+        # Try to find a balance between doing too many commits where we fail
+        # to get any benefits from constructing transactions, and blowing up
+        # the WAL and memory usage by making massive transactions.
+        max_transaction_items, transaction_items = 32 * 1024, 0
+        with pbar.Progress(total, 40, prefix="Processing", style=pbar.LongRunningCountBar) as prog,\
+              listings_path.open("r", encoding="utf-8", errors="ignore") as fh:
+            cursor = db.cursor()
+            cursor.execute("BEGIN TRANSACTION")
             
             for listing in csv.DictReader(fh):
-                prog.increment(1, postfix = lambda value, total: f" {(value / total * 100):.0f}% {value} / {total}")
+                prog.increment(1)
                 
                 station_id = int(listing['station_id'])
                 if station_id not in station_lookup:
@@ -258,16 +236,21 @@ class ImportPlugin(plugins.ImportPluginBase):
                 
                 if station_id != cur_station:
                     # commit anything from the previous station, get a new cursor
-                    db.commit()
-                    cur_station, skip_station, cursor = station_id, False, db.cursor()
+                    if transaction_items >= max_transaction_items:
+                        cursor.execute("COMMIT")
+                        transaction_items = 0
+                        cursor.execute("BEGIN TRANSACTION")
+                    cur_station, skip_station = station_id, False
                     
                     # Check if listing already exists in DB and needs updated.
                     last_modified: int = int(last_station_update_times.get(station_id, 0))
                     if last_modified:
                         # When the listings.csv data matches the database, update to make from_live == 0.
                         if listing_time == last_modified and not from_live:
-                            self.tdenv.DEBUG1(f"Marking {cur_station} as no longer 'live' (old={last_modified}, listing={listing_time}).")
+                            if is_debug:
+                                self.tdenv.DEBUG1(f"Marking {cur_station} as no longer 'live' (old={last_modified}, listing={listing_time}).")
                             cursor.execute(stmt_unliven_station, (cur_station,))
+                            transaction_items += 1
                             skip_station = True
                             continue
 
@@ -278,8 +261,10 @@ class ImportPlugin(plugins.ImportPluginBase):
                             continue
                         
                         # The data from the import file is newer, so we need to delete the old data for this station.
-                        self.tdenv.DEBUG1(f"Deleting old listing data for {cur_station} (old={last_modified}, listing={listing_time}).")
+                        if is_debug:
+                            self.tdenv.DEBUG1(f"Deleting old listing data for {cur_station} (old={last_modified}, listing={listing_time}).")
                         cursor.execute(stmt_flush_station, (cur_station,))
+                        transaction_items += 1
                         last_station_update_times[station_id] = listing_time
                 
                 # station skip lasts until we change station id.
@@ -299,20 +284,24 @@ class ImportPlugin(plugins.ImportPluginBase):
                 supply_units = int(listing['supply'])
                 supply_level = int(listing.get('supply_bracket') or '-1')
                 
-                self.tdenv.DEBUG1(f"Inserting new listing data for {station_id}.")
+                if is_debug:
+                    self.tdenv.DEBUG1(f"Inserting new listing data for {station_id}.")
                 cursor.execute(stmt_add_listing, (
                         station_id, item_id, listing_time, from_live,
                         demand_price, demand_units, demand_level,
                         supply_price, supply_units, supply_level,
                 ))
-            
-        prog.clear()
-        
-        # Do a final commit to be sure
-        db.commit()
-        
-        self.tdenv.NOTE("Optimizing database...")
-        db.execute("VACUUM")
+                transaction_items += 1
+
+        # These will take a little while, which has four steps, so we'll make it a counter.
+        with pbar.Progress(1, 40, prefix="Saving"):
+            # Do a final commit to be sure
+            cursor.execute("COMMIT")
+
+        if self.getOption("optimize"):
+            with pbar.Progress(1, 40, prefix="Optimizing"):
+                db.execute("VACUUM")
+
         self.tdb.close()
         
         self.tdenv.NOTE("Finished processing market data. End time = {}", self.now())

tradedangerous/templates/TradeDangerous.sql

@@ -92,10 +92,9 @@ CREATE TABLE Station
    UNIQUE (station_id),
 
    FOREIGN KEY (system_id) REFERENCES System(system_id)
-    ON UPDATE CASCADE
     ON DELETE CASCADE
- );
-CREATE INDEX idx_station_by_system ON Station (system_id, station_id);
+ ) WITHOUT ROWID;
+CREATE INDEX idx_station_by_system ON Station (system_id);
 CREATE INDEX idx_station_by_name ON Station (name);
 
 
@@ -226,11 +225,45 @@ CREATE TABLE StationItem
     ON UPDATE CASCADE ON DELETE CASCADE,
   FOREIGN KEY (item_id) REFERENCES Item(item_id)
     ON UPDATE CASCADE ON DELETE CASCADE
-);
+) WITHOUT ROWID;
 CREATE INDEX si_mod_stn_itm ON StationItem(modified, station_id, item_id);
 CREATE INDEX si_itm_dmdpr ON StationItem(item_id, demand_price) WHERE demand_price > 0;
 CREATE INDEX si_itm_suppr ON StationItem(item_id, supply_price) WHERE supply_price > 0;
 
+-- Not used yet
+CREATE TABLE IF NOT EXISTS StationDemand
+(
+    station_id      INTEGER NOT NULL,
+    item_id         INTEGER NOT NULL,
+    price           INTEGER NOT NULL,
+    units           INTEGER NOT NULL,
+    level           INTEGER NOT NULL,
+    modified        INTEGER NOT NULL,
+    from_live       INTEGER NOT NULL DEFAULT 0,
+    CONSTRAINT pk_StationDemand PRIMARY KEY (station_id, item_id),
+    CONSTRAINT fk_StationDemand_station_id_Station FOREIGN KEY (station_id) REFERENCES Station (station_id) ON DELETE CASCADE,
+    CONSTRAINT fk_StationDemand_item_id_Item       FOREIGN KEY (item_id)    REFERENCES Item    (item_id)    ON DELETE CASCADE
+) WITHOUT ROWID;
+DELETE FROM StationDemand;
+CREATE INDEX idx_StationDemand_item ON StationDemand (item_id);
+
+-- Not used yet
+CREATE TABLE IF NOT EXISTS StationSupply
+(
+    station_id      INTEGER NOT NULL,
+    item_id         INTEGER NOT NULL,
+    price           INTEGER NOT NULL,
+    units           INTEGER NOT NULL,
+    level           INTEGER NOT NULL,
+    modified        INTEGER NOT NULL,
+    from_live       INTEGER NOT NULL DEFAULT 0,
+    CONSTRAINT pk_StationSupply PRIMARY KEY (station_id, item_id),
+    CONSTRAINT fk_StationSupply_station_id_Station FOREIGN KEY (station_id) REFERENCES Station (station_id) ON DELETE CASCADE,
+    CONSTRAINT fk_StationSupply_item_id_Item       FOREIGN KEY (item_id)    REFERENCES Item    (item_id)    ON DELETE CASCADE
+) WITHOUT ROWID;
+DELETE FROM StationSupply;
+CREATE INDEX idx_StationSupply_item ON StationSupply (item_id);
+
 CREATE VIEW StationBuying AS
 SELECT  station_id,
         item_id,

tradedangerous/tradecalc.py

@@ -930,176 +930,173 @@ class TradeCalc:
                     odyssey = odyssey,
                 )
         
-        prog = pbar.Progress(len(routes), 25)
-        connections = 0
-        getSelling = self.stationsSelling.get
-        for route in routes:
-            if tdenv.progress:
-                prog.increment(1)
-            tdenv.DEBUG1("Route = {}", route.text(lambda x, y: y))
-            
-            srcStation = route.lastStation
-            startCr = credits + int(route.gainCr * safetyMargin)
-            
-            srcSelling = getSelling(srcStation.ID, None)
-            srcSelling = tuple(
-                values for values in srcSelling
-                if values[1] <= startCr
-            )
-            if not srcSelling:
-                tdenv.DEBUG1("Nothing sold/affordable - next.")
-                continue
-            
-            if goalSystem:
-                origSystem = route.firstSystem
-                srcSystem = srcStation.system
-                srcDistTo = srcSystem.distanceTo
-                goalDistTo = goalSystem.distanceTo
-                origDistTo = origSystem.distanceTo
-                srcGoalDist = srcDistTo(goalSystem)
-                srcOrigDist = srcDistTo(origSystem)
-                origGoalDist = origDistTo(goalSystem)
-            
-            if unique:
-                uniquePath = route.route
-            elif loopInt:
-                pos_from_end = 0 - loopInt
-                uniquePath = route.route[pos_from_end:-1]
-            
-            stations = (d for d in station_iterator(srcStation)
-              if (d.station != srcStation) and
-                (d.station.blackMarket == 'Y' if reqBlackMarket else True) and
-                (d.station not in uniquePath if uniquePath else True) and
-                (d.station in restrictStations if restrictStations else True) and
-                (d.station.dataAge and d.station.dataAge <= maxAge if maxAge else True) and
-                (((d.system is not srcSystem) if bool(tdenv.unique) else (d.system is goalSystem or d.distLy < srcGoalDist)) if goalSystem else True)
-            )
-            
-            if tdenv.debug >= 1:
+        with pbar.Progress(max_value=len(routes), width=25, show=tdenv.progress) as prog:
+            connections = 0
+            getSelling = self.stationsSelling.get
+            for route_no, route in enumerate(routes):
+                prog.increment(progress=route_no)
+                tdenv.DEBUG1("Route = {}", route.text(lambda x, y: y))
                 
-                def annotate(dest):
-                    tdenv.DEBUG1(
-                        "destSys {}, destStn {}, jumps {}, distLy {}",
-                        dest.system.dbname,
-                        dest.station.dbname,
-                        "->".join(jump.text() for jump in dest.via),
-                        dest.distLy
-                    )
-                    return True
-                
-                stations = (d for d in stations if annotate(d))
-            
-            for dest in stations:
-                dstStation = dest.station
+                srcStation = route.lastStation
+                startCr = credits + int(route.gainCr * safetyMargin)
                 
-                connections += 1
-                items = self.getTrades(srcStation, dstStation, srcSelling)
-                if not items:
+                srcSelling = getSelling(srcStation.ID, None)
+                srcSelling = tuple(
+                    values for values in srcSelling
+                    if values[1] <= startCr
+                )
+                if not srcSelling:
+                    tdenv.DEBUG1("Nothing sold/affordable - next.")
                     continue
-                trade = fitFunction(items, startCr, capacity, maxUnits)
                 
-                multiplier = 1.0
-                # Calculate total K-lightseconds supercruise time.
-                # This will amortize for the start/end stations
-                dstSys = dest.system
-                if goalSystem and dstSys is not goalSystem:
-                    dstGoalDist = goalDistTo(dstSys)
-                    # Biggest reward for shortening distance to goal
-                    score = 5000 * origGoalDist / dstGoalDist
-                    # bias towards bigger reductions
-                    score += 50 * srcGoalDist / dstGoalDist
-                    # discourage moving back towards origin
-                    if dstSys is not origSystem:
-                        score += 10 * (origDistTo(dstSys) - srcOrigDist)
-                    # Gain per unit pays a small part
-                    score += (trade.gainCr / trade.units) / 25
-                else:
-                    score = trade.gainCr
-                if lsPenalty:
-                    # [kfsone] Only want 1dp
+                if goalSystem:
+                    origSystem = route.firstSystem
+                    srcSystem = srcStation.system
+                    srcDistTo = srcSystem.distanceTo
+                    goalDistTo = goalSystem.distanceTo
+                    origDistTo = origSystem.distanceTo
+                    srcGoalDist = srcDistTo(goalSystem)
+                    srcOrigDist = srcDistTo(origSystem)
+                    origGoalDist = origDistTo(goalSystem)
+                
+                if unique:
+                    uniquePath = route.route
+                elif loopInt:
+                    pos_from_end = 0 - loopInt
+                    uniquePath = route.route[pos_from_end:-1]
+                
+                stations = (d for d in station_iterator(srcStation)
+                if (d.station != srcStation) and
+                    (d.station.blackMarket == 'Y' if reqBlackMarket else True) and
+                    (d.station not in uniquePath if uniquePath else True) and
+                    (d.station in restrictStations if restrictStations else True) and
+                    (d.station.dataAge and d.station.dataAge <= maxAge if maxAge else True) and
+                    (((d.system is not srcSystem) if bool(tdenv.unique) else (d.system is goalSystem or d.distLy < srcGoalDist)) if goalSystem else True)
+                )
+                
+                if tdenv.debug >= 1:
                     
-                    cruiseKls = int(dstStation.lsFromStar / 100) / 10
-                    # Produce a curve that favors distances under 1kls
-                    # positively, starts to penalize distances over 1k,
-                    # and after 4kls starts to penalize aggressively
-                    # http://goo.gl/Otj2XP
+                    def annotate(dest):
+                        tdenv.DEBUG1(
+                            "destSys {}, destStn {}, jumps {}, distLy {}",
+                            dest.system.dbname,
+                            dest.station.dbname,
+                            "->".join(jump.text() for jump in dest.via),
+                            dest.distLy
+                        )
+                        return True
                     
-                    # [eyeonus] As aadler pointed out, this goes into negative
-                    # numbers, which causes problems.
-                    # penalty = ((cruiseKls ** 2) - cruiseKls) / 3
-                    # penalty *= lsPenalty
-                    # multiplier *= (1 - penalty)
+                    stations = (d for d in stations if annotate(d))
+                
+                for dest in stations:
+                    dstStation = dest.station
                     
-                    # [eyeonus]:
-                    # (Keep in mind all this ignores values of x<0.)
-                    # The sigmoid: (1-(25(x-1))/(1+abs(25(x-1))))/4
-                    # ranges between 0.5 and 0 with a drop around x=1,
-                    # which makes it great for giving a boost to distances < 1Kls.
-                    #
-                    # The sigmoid: (-1-(50(x-4))/(1+abs(50(x-4))))/4
-                    # ranges between 0 and -0.5 with a drop around x=4,
-                    # making it great for penalizing distances > 4Kls.
-                    #
-                    # The curve: (-1+1/(x+1)^((x+1)/4))/2
-                    # ranges between 0 and -0.5 in a smooth arc,
-                    # which will be used for making distances
-                    # closer to 4Kls get a slightly higher penalty
-                    # then distances closer to 1Kls.
-                    #
-                    # Adding the three together creates a doubly-kinked curve
-                    # that ranges from ~0.5 to -1.0, with drops around x=1 and x=4,
-                    # which closely matches ksfone's intention without going into
-                    # negative numbers and causing problems when we add it to
-                    # the multiplier variable. ( 1 + -1 = 0 )
-                    #
-                    # You can see a graph of the formula here:
-                    # https://goo.gl/sn1PqQ
-                    # NOTE: The black curve is at a penalty of 0%,
-                    # the red curve at a penalty of 100%, with intermediates at
-                    # 25%, 50%, and 75%.
-                    # The other colored lines show the penalty curves individually
-                    # and the teal composite of all three.
+                    connections += 1
+                    items = self.getTrades(srcStation, dstStation, srcSelling)
+                    if not items:
+                        continue
+                    trade = fitFunction(items, startCr, capacity, maxUnits)
                     
-                    def sigmoid(x):
-                        return x / (1 + abs(x))
+                    multiplier = 1.0
+                    # Calculate total K-lightseconds supercruise time.
+                    # This will amortize for the start/end stations
+                    dstSys = dest.system
+                    if goalSystem and dstSys is not goalSystem:
+                        dstGoalDist = goalDistTo(dstSys)
+                        # Biggest reward for shortening distance to goal
+                        score = 5000 * origGoalDist / dstGoalDist
+                        # bias towards bigger reductions
+                        score += 50 * srcGoalDist / dstGoalDist
+                        # discourage moving back towards origin
+                        if dstSys is not origSystem:
+                            score += 10 * (origDistTo(dstSys) - srcOrigDist)
+                        # Gain per unit pays a small part
+                        score += (trade.gainCr / trade.units) / 25
+                    else:
+                        score = trade.gainCr
+                    if lsPenalty:
+                        # [kfsone] Only want 1dp
+                        
+                        cruiseKls = int(dstStation.lsFromStar / 100) / 10
+                        # Produce a curve that favors distances under 1kls
+                        # positively, starts to penalize distances over 1k,
+                        # and after 4kls starts to penalize aggressively
+                        # http://goo.gl/Otj2XP
+                        
+                        # [eyeonus] As aadler pointed out, this goes into negative
+                        # numbers, which causes problems.
+                        # penalty = ((cruiseKls ** 2) - cruiseKls) / 3
+                        # penalty *= lsPenalty
+                        # multiplier *= (1 - penalty)
+                        
+                        # [eyeonus]:
+                        # (Keep in mind all this ignores values of x<0.)
+                        # The sigmoid: (1-(25(x-1))/(1+abs(25(x-1))))/4
+                        # ranges between 0.5 and 0 with a drop around x=1,
+                        # which makes it great for giving a boost to distances < 1Kls.
+                        #
+                        # The sigmoid: (-1-(50(x-4))/(1+abs(50(x-4))))/4
+                        # ranges between 0 and -0.5 with a drop around x=4,
+                        # making it great for penalizing distances > 4Kls.
+                        #
+                        # The curve: (-1+1/(x+1)^((x+1)/4))/2
+                        # ranges between 0 and -0.5 in a smooth arc,
+                        # which will be used for making distances
+                        # closer to 4Kls get a slightly higher penalty
+                        # then distances closer to 1Kls.
+                        #
+                        # Adding the three together creates a doubly-kinked curve
+                        # that ranges from ~0.5 to -1.0, with drops around x=1 and x=4,
+                        # which closely matches ksfone's intention without going into
+                        # negative numbers and causing problems when we add it to
+                        # the multiplier variable. ( 1 + -1 = 0 )
+                        #
+                        # You can see a graph of the formula here:
+                        # https://goo.gl/sn1PqQ
+                        # NOTE: The black curve is at a penalty of 0%,
+                        # the red curve at a penalty of 100%, with intermediates at
+                        # 25%, 50%, and 75%.
+                        # The other colored lines show the penalty curves individually
+                        # and the teal composite of all three.
+                        
+                        def sigmoid(x):
+                            return x / (1 + abs(x))
+                        
+                        boost = (1 - sigmoid(25 * (cruiseKls - 1))) / 4
+                        drop = (-1 - sigmoid(50 * (cruiseKls - 4))) / 4
+                        try:
+                            penalty = (-1 + 1 / (cruiseKls + 1) ** ((cruiseKls + 1) / 4)) / 2
+                        except OverflowError:
+                            penalty = -0.5
+                        
+                        multiplier += (penalty + boost + drop) * lsPenalty
                     
-                    boost = (1 - sigmoid(25 * (cruiseKls - 1))) / 4
-                    drop = (-1 - sigmoid(50 * (cruiseKls - 4))) / 4
-                    try:
-                        penalty = (-1 + 1 / (cruiseKls + 1) ** ((cruiseKls + 1) / 4)) / 2
-                    except OverflowError:
-                        penalty = -0.5
+                    score *= multiplier
                     
-                    multiplier += (penalty + boost + drop) * lsPenalty
-                
-                score *= multiplier
-                
-                dstID = dstStation.ID
-                try:
-                    # See if there is already a candidate for this destination
-                    btd = bestToDest[dstID]
-                except KeyError:
-                    # No existing candidate, we win by default
-                    pass
-                else:
-                    bestRoute = btd[1]
-                    bestScore = btd[5]
-                    # Check if it is a better option than we just produced
-                    bestTradeScore = bestRoute.score + bestScore
-                    newTradeScore = route.score + score
-                    if bestTradeScore > newTradeScore:
-                        continue
-                    if bestTradeScore == newTradeScore:
-                        bestLy = btd[4]
-                        if bestLy <= dest.distLy:
+                    dstID = dstStation.ID
+                    try:
+                        # See if there is already a candidate for this destination
+                        btd = bestToDest[dstID]
+                    except KeyError:
+                        # No existing candidate, we win by default
+                        pass
+                    else:
+                        bestRoute = btd[1]
+                        bestScore = btd[5]
+                        # Check if it is a better option than we just produced
+                        bestTradeScore = bestRoute.score + bestScore
+                        newTradeScore = route.score + score
+                        if bestTradeScore > newTradeScore:
                             continue
-                
-                bestToDest[dstID] = (
-                    dstStation, route, trade, dest.via, dest.distLy, score
-                )
-        
-        prog.clear()
-        
+                        if bestTradeScore == newTradeScore:
+                            bestLy = btd[4]
+                            if bestLy <= dest.distLy:
+                                continue
+                    
+                    bestToDest[dstID] = (
+                        dstStation, route, trade, dest.via, dest.distLy, score
+                    )
+            
         if connections == 0:
             raise NoHopsError(
                 "No destinations could be reached within the constraints."

tradedangerous/transfers.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from collections import deque
 from pathlib import Path
+from urllib.parse import urlparse, unquote
+
 from .tradeexcept import TradeException
 from .misc import progress as pbar
 from . import fs
@@ -16,7 +17,7 @@ import requests
 if typing.TYPE_CHECKING:
     import os  # for PathLike
     from .tradeenv import TradeEnv
-    from typing import Optional, Union
+    from typing import Callable, Optional, Union  # noqa
 
 
 ######################################################################
@@ -38,15 +39,21 @@ def makeUnit(value):
         unitSize /= 1024
     return None
 
+
+def get_filename_from_url(url: str) -> str:
+    """ extracts just the filename from a url. """
+    return Path(unquote(urlparse(url).path)).name
+
+
 def download(
             tdenv:      TradeEnv,
             url:        str,
             localFile:  os.PathLike,
             headers:    Optional[dict] = None,
             backup:     bool = False,
-            shebang:    Optional[str] = None,
+            shebang:    Optional[Callable] = None,
             chunkSize:  int = 4096,
-            timeout:    int = 90,
+            timeout:    int = 30,
             *,
             length:     Optional[Union[int, str]] = None,
             session:    Optional[requests.Session] = None,
@@ -55,20 +62,11 @@ def download(
     Fetch data from a URL and save the output
     to a local file. Returns the response headers.
     
-    tdenv:
-        TradeEnv we're working under
-    
-    url:
-        URL we're fetching (http, https or ftp)
-    
-    localFile:
-        Name of the local file to open.
-    
-    headers:
-        dict() of additional HTTP headers to send
-    
-    shebang:
-        function to call on the first line
+    :param tdenv:       TradeEnv we're working under
+    :param url:         URL we're fetching (http, https or ftp)
+    :param localFile:   Name of the local file to open.
+    :param headers:     dict() of additional HTTP headers to send
+    :param shebang:     function to call on the first line
     """
     tdenv.NOTE("Requesting {}".format(url))
 
@@ -108,24 +106,14 @@ def download(
             tdenv.NOTE("Downloading {} {}ed data", transfer, encoding)
     tdenv.DEBUG0(str(req.headers).replace("{", "{{").replace("}", "}}"))
     
-    # Figure out how much data we have
-    if length and not tdenv.quiet:
-        progBar = pbar.Progress(length, 20)
-    else:
-        progBar = None
-    
     actPath = Path(localFile)
     fs.ensurefolder(tdenv.tmpDir)
     tmpPath = Path(tdenv.tmpDir, "{}.dl".format(actPath.name))
     
-    histogram = deque()
-    
     fetched = 0
-    lastTime = started = time.time()
-    spinner, spinners = 0, [
-        '.    ', '..   ', '...  ', ' ... ', '  ...', '   ..', '    .'
-    ]
-    with tmpPath.open("wb") as fh:
+    started = time.time()
+    filename = get_filename_from_url(url)
+    with pbar.Progress(max_value=length, width=25, prefix=filename, style=pbar.CountingBar, show=not tdenv.quiet) as prog, tmpPath.open("wb") as fh:
         for data in req.iter_content(chunk_size=chunkSize):
             fh.write(data)
             fetched += len(data)
@@ -134,29 +122,11 @@ def download(
                 tdenv.DEBUG0("Checking shebang of {}", bangLine)
                 shebang(bangLine)
                 shebang = None
-            if progBar:
-                now = time.time()
-                deltaT = max(now - lastTime, 0.001)
-                lastTime = now
-                if len(histogram) >= 15:
-                    histogram.popleft()
-                histogram.append(len(data) / deltaT)
-                progBar.increment(
-                    len(data),
-                    postfix=lambda value, goal: \
-                            " {:>7s} [{:>7s}/s] {:>3.0f}% {:1s}".format(
-                            makeUnit(value),
-                            makeUnit(sum(histogram) / len(histogram)),
-                            (fetched * 100. / length),
-                            spinners[spinner]
-                        )
-                )
-                if deltaT > 0.200:
-                    spinner = (spinner + 1) % len(spinners)
+            if prog:
+                prog.increment(len(data))
         tdenv.DEBUG0("End of data")
+
     if not tdenv.quiet:
-        if progBar:
-            progBar.clear()
         elapsed = (time.time() - started) or 1
         tdenv.NOTE(
             "Downloaded {} of {}ed data {}/s",
@@ -197,17 +167,13 @@ def get_json_data(url, *, timeout: int = 90):
         jsData = req.content
     else:
         totalLength = int(totalLength)
-        progBar = pbar.Progress(totalLength, 25)
+        filename = get_filename_from_url(url)
+        progBar = pbar.Progress(totalLength, 25, prefix=filename)
+
         jsData = bytes()
         for data in req.iter_content():
             jsData += data
-            progBar.increment(
-                len(data),
-                postfix=lambda value, goal: \
-                " {}/{}".format(
-                    makeUnit(value),
-                    makeUnit(goal),
-            ))
+            progBar.increment(len(data))
         progBar.clear()
     
     return json.loads(jsData.decode())

tradedangerous/version.py

@@ -12,5 +12,5 @@
 """just keeper of current version"""
 
 # TODO: remember to update tests when version changes
-__version__ = '11.2.1'
+__version__ = '11.3.0'
 

{tradedangerous-11.2.1.dist-info → tradedangerous-11.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tradedangerous
-Version: 11.2.1
+Version: 11.3.0
 Summary: Trade-Dangerous is a set of powerful trading tools for Elite Dangerous, organized around one of the most powerful trade run optimizers available.
 Home-page: https://github.com/eyeonus/Trade-Dangerous
 Author: eyeonus

{tradedangerous-11.2.1.dist-info → tradedangerous-11.3.0.dist-info}/RECORD

@@ -1,27 +1,27 @@
 trade.py,sha256=Skqy0bC47g1KujuYrVwa3T8AfJ9NoLLOZcVjjxJ2daQ,1769
 tradegui.py,sha256=q2HdIdoyeLUpeF2X0hVIGn7sU6T4zOzq1HN0zGvZdyE,788
 tradedangerous/__init__.py,sha256=bwsbE_GyCNsuyGDKnfXAg0RD-ewsWHliySJ5QfCK7h8,1166
-tradedangerous/cache.py,sha256=N7z1e2fov003wIh_aHkw1pdByKDPt3FkDZiH_EEPdMc,36080
+tradedangerous/cache.py,sha256=0Pyvh5XYrNzC7Pj7KzDIioI-Xhydx7JGUXZGcrO1org,37225
 tradedangerous/cli.py,sha256=dLekZ3MTbn9XcSGtE532qZF3iSnsb5G-ddQyErwTv9o,4559
 tradedangerous/corrections.py,sha256=_WLgo1IBWoskrrPFeshRwCOeJ2BeJb_x4tDQ0JdAo-s,1340
 tradedangerous/csvexport.py,sha256=_19bGVnCGJPzvx_8DzLGOs4rqx8Asn7eCVdXKdKu92E,8653
 tradedangerous/edscupdate.py,sha256=To7hL2FuR4A7A4gJfvow_jGl6mlD7aP-Drv1rEkwy-I,17310
 tradedangerous/edsmupdate.py,sha256=9IANIASA8ZKnZsLPBRAh7IArDRsa0jriL2UwjqKJ1fI,14928
-tradedangerous/formatting.py,sha256=K3XL_mZJ4cAiTTTmJmTXK7ePYzzsSxg7EoBVFh7gj60,6931
-tradedangerous/fs.py,sha256=_5OJHIRy_M-WFHEZO4g2EIgqDxdrz4s8tcdDmgG7NME,2494
+tradedangerous/formatting.py,sha256=R8GX2Zya1xazLOOBIWlLqUEjIESZJO41UlvhZDbyY4Q,6908
+tradedangerous/fs.py,sha256=41yUdriBSv-rinGEmxjBTKyKH4-RA2bIO4sKCMIwvUA,3861
 tradedangerous/gui.py,sha256=DFsF5zATr-lyJShL6t5kPKvcLLJYkICurzBz0WBa-oQ,43676
 tradedangerous/jsonprices.py,sha256=GJ07fbZSNX5U_6lczWTSk6mWwme_weJbXgE8zcZBnpY,7225
 tradedangerous/mapping.py,sha256=Bf2G8LzP1Bat5k3hFs9XyeI1z3tfUpfeh4nuLP2QJuQ,4122
 tradedangerous/prices.py,sha256=JqiDVrtvvPd5pqE3HdwOHOuFgdAbOR-pt0GLD3ZIXM8,7425
 tradedangerous/submit-distances.py,sha256=xL7fwdbVrb05-zWNH-9nyYBDtV4bfUfP7OBx3NMBc34,11749
 tradedangerous/tools.py,sha256=pp-4WtA12SVaaQHFJFOMTF7EDFRCU2mQeOhC4xoXmEk,1331
-tradedangerous/tradecalc.py,sha256=A7peEMiaCjlwFvReSq3E7_Ar0shUoFedQi83ZmOc7uY,42075
+tradedangerous/tradecalc.py,sha256=GlJZ9UwkoQUoayqUGVwlefhQvs-1SxYB5Y6Vkr31nSg,42753
 tradedangerous/tradedb.py,sha256=mitKkS4MczivDK_K7A-IC94hkObUmGWFhwIrh_ts9qw,72282
 tradedangerous/tradeenv.py,sha256=o956HN7-7uzIcNi9vI4zh-L1z5jwBioVARyhhiAlsRQ,11885
 tradedangerous/tradeexcept.py,sha256=aZ-Y31MbkjF7lmAzBAbaMsPPE7FEEfuf4gaX2GvriDk,368
-tradedangerous/transfers.py,sha256=NdPNzrpa5YuZeo2wBK6X8sy1VyFUaAXb0EtASyVXsuQ,6885
+tradedangerous/transfers.py,sha256=s0fRWDZCsL-VYm5E4ceTMKcUelcvzcOUelsfg6TjYI8,6000
 tradedangerous/utils.py,sha256=PUPvAEqUyxYGqqQa0b_yfLAvq8YVUxK6HfdS-CxM-Lo,5186
-tradedangerous/version.py,sha256=FcS0iiOYPOsVvc2lrO3dCSzLkb3qmtanvTPMfHGFupM,646
+tradedangerous/version.py,sha256=Lf6tzJrBdghRB7hsnuyfhzDziiCbZ8EhcNAAsCHjmVs,646
 tradedangerous/commands/TEMPLATE.py,sha256=MOE69xsZPHPIMBQ-LXicfsOlCZdy-2gPX_nlnwYYil8,2026
 tradedangerous/commands/__init__.py,sha256=3gz2cnXNZNkV1gtZh0dOnCRxBkQHbeIyysRe3bM2WEE,9516
 tradedangerous/commands/buildcache_cmd.py,sha256=jhNSqHX_xX43SiSUMFiKtWpB9v4oeZ0sqfNq6DCrjUs,2181
@@ -58,11 +58,11 @@ tradedangerous/misc/edsc.py,sha256=SN_da9qZ7H8ozibyhoFVB8nAvwBDPF3Z_PMlt70J2Ro,1
 tradedangerous/misc/edsm.py,sha256=equDwO1SY3QTsoJIb3LjiHes4C8Dejaap_TMpYlCm8o,2910
 tradedangerous/misc/importeddbstats.py,sha256=iLAcrFzdwiMm_MnUuaHcT_xGgZF8pfEEd1qljhhWJTU,1787
 tradedangerous/misc/prices-json-exp.py,sha256=Fpm62ugP35ZBqnRs6ekYfS3GoDFYmvLD3b3SFJfaMOI,4944
-tradedangerous/misc/progress.py,sha256=NKvKP1OSCTpItc1CNxDuEH2A1oGJ6aWSyCdPSAjsG9E,2120
+tradedangerous/misc/progress.py,sha256=pWBHPA8Xc5uzjufAwCn7mkTrz7UbwSpY46o2BgEi7HU,7058
 tradedangerous/plugins/__init__.py,sha256=TL-OIptlqNENKhoFqkFeBJn_vSw8L0pVaDJgjhaTj7A,7860
 tradedangerous/plugins/edapi_plug.py,sha256=5nqBYmjUceAt-KTfiBn7IEl443R1SsGLDmfVXgbcyms,42262
 tradedangerous/plugins/edcd_plug.py,sha256=JuDtuEM_mN9Sz2H09-qYizM-9N3cuNjgvQy7Y-wHwKw,14412
-tradedangerous/plugins/eddblink_plug.py,sha256=-TerJ_jKOHVuqS6P-ehKlwYDJsNNBEvu1nlpCNBsWn0,21414
+tradedangerous/plugins/eddblink_plug.py,sha256=V58hRCfjeZ7t3aAIgdzbS5VdO5l39A-9_QKbY7KNJ48,21209
 tradedangerous/plugins/edmc_batch_plug.py,sha256=rrP_lFFxWsba8DPEo0WF2EdCiMoRC7tCT8z62MIvtIo,4173
 tradedangerous/plugins/journal_plug.py,sha256=5HMyoxQ7z42qj7NiL8rDxSyTN9gKikoQjyWzJLD-SYQ,23746
 tradedangerous/plugins/netlog_plug.py,sha256=yUl47l9xt3kGj9oSiY_FZaDGdnQj63oa9MBtSeIy1Zo,13469
@@ -70,10 +70,10 @@ tradedangerous/plugins/spansh_plug.py,sha256=FiIS9cN2_8VKDrAj8yvkdy1NIni2kEc0ECq
 tradedangerous/templates/Added.csv,sha256=8o54civQCcS9y7_DBo0GX196XWRbbREQqKDYTKibsgQ,649
 tradedangerous/templates/Category.csv,sha256=8xwUDcBZE25T6x6dZGlRUMTCqeDLt3a9LXU5h6hRHV8,250
 tradedangerous/templates/RareItem.csv,sha256=F1RhRnTD82PiwrVUO-ai2ErGH2PTqNnQaDw5mcgljXs,10483
-tradedangerous/templates/TradeDangerous.sql,sha256=VlQK7QGtEi2brGtWaIZDvKmbJ_vLocD4CJ8h_6kKptU,7808
-tradedangerous-11.2.1.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-tradedangerous-11.2.1.dist-info/METADATA,sha256=Cyyx7ogtQbyTfD5sFCcXMD63dGvDlASdlqDN99ICMHs,4435
-tradedangerous-11.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tradedangerous-11.2.1.dist-info/entry_points.txt,sha256=lrA7U9JHOcNuam2WEK4Hmc3vQ3mrJfsbJCE74qd9au8,62
-tradedangerous-11.2.1.dist-info/top_level.txt,sha256=JEoOVAhg5GfXZ4kHpNontu0RVzek_7P9_jp93f3Pqn8,16
-tradedangerous-11.2.1.dist-info/RECORD,,
+tradedangerous/templates/TradeDangerous.sql,sha256=S9TH1bp0dfJLv90T6lTQ-TD8w8YGEZRMyUn8J1W4G3k,9330
+tradedangerous-11.3.0.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+tradedangerous-11.3.0.dist-info/METADATA,sha256=ctub0LqxjEV1nSRKjKmOwkDrXNnEmGtfae8X8vx87Jk,4435
+tradedangerous-11.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tradedangerous-11.3.0.dist-info/entry_points.txt,sha256=lrA7U9JHOcNuam2WEK4Hmc3vQ3mrJfsbJCE74qd9au8,62
+tradedangerous-11.3.0.dist-info/top_level.txt,sha256=JEoOVAhg5GfXZ4kHpNontu0RVzek_7P9_jp93f3Pqn8,16
+tradedangerous-11.3.0.dist-info/RECORD,,