tradedangerous 10.13.10__tar.gz → 10.14.2__tar.gz

{tradedangerous-10.13.10 → tradedangerous-10.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tradedangerous
-Version: 10.13.10
+Version: 10.14.2
 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
@@ -19,6 +19,9 @@ Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: appJar
+Requires-Dist: pysimdjson
 
 
 ----------

tradedangerous-10.14.2/pyproject.toml

@@ -0,0 +1,9 @@
+[tool.semantic_release.branches.main]
+match = "(main|master|release/v1)"
+prerelease_token = "rc"
+prerelease = false
+
+[tool.semantic_release]
+version_variables = [
+    "tradedangerous/version.py:__version__",
+]

{tradedangerous-10.13.10 → tradedangerous-10.14.2}/setup.py

@@ -27,7 +27,7 @@ exec(open("tradedangerous/version.py").read())  # pylint: disable=W0122
 
 setup(name = package,
         version = __version__,  # pylint: disable=E0602
-        install_requires = ["requests", "appJar"],
+        install_requires = ["requests", "appJar", "pysimdjson"],
         setup_requires = ["pytest-runner"],
         tests_require = ["pytest"],
         packages = ['tradedangerous', 'tradedangerous.commands', 'tradedangerous.mfd', 'tradedangerous.mfd.saitek', 'tradedangerous.misc', 'tradedangerous.plugins'],

tradedangerous-10.14.2/tests/test_bootstrap_commands.py

@@ -0,0 +1,53 @@
+import unittest
+
+
+class TestBootstrapCommands(unittest.TestCase):
+    def test_import_commands(self):
+        from tradedangerous import commands
+        
+        self.assertIn('buildcache', commands.commandIndex)
+        self.assertIn('buy', commands.commandIndex)
+
+
+    def test_import_buildcache_cmd(self):
+        from tradedangerous.commands import buildcache_cmd
+    
+    def test_import_buy(self):
+        from tradedangerous.commands import buy_cmd
+    
+    def test_import_import_cmd(self):
+        from tradedangerous.commands import import_cmd
+    
+    def test_import_local_cmd(self):
+        from tradedangerous.commands import local_cmd
+    
+    def test_import_market_cmd(self):
+        from tradedangerous.commands import market_cmd
+    
+    def test_import_nav_cmd(self):
+        from tradedangerous.commands import nav_cmd
+    
+    def test_import_olddata_cmd(self):
+        from tradedangerous.commands import olddata_cmd
+    
+    def test_import_rares_cmd(self):
+        from tradedangerous.commands import rares_cmd
+    
+    def test_import_run_cmd(self):
+        from tradedangerous.commands import run_cmd
+    
+    def test_import_sell_cmd(self):
+        from tradedangerous.commands import sell_cmd
+    
+    def test_import_shipvendor_cmd(self):
+        from tradedangerous.commands import shipvendor_cmd
+    
+    def test_import_station_cmd(self):
+        from tradedangerous.commands import station_cmd
+    
+    def test_import_update_cmd(self):
+        from tradedangerous.commands import update_cmd
+        
+    def test_import_update_gui(self):
+        from tradedangerous.commands import update_gui
+

tradedangerous-10.14.2/tests/test_bootstrap_plugins.py

@@ -0,0 +1,27 @@
+import pytest
+
+class TestBootstrapPlugins(object):
+    def test_import_traded(self):
+        import tradedangerous as td
+    
+    def test_import_plugins(self):
+        from tradedangerous import plugins
+    
+    def test_import_plugins_eddblink(self):
+        from tradedangerous.plugins import eddblink_plug
+    
+    @pytest.mark.skip("edapi requires secrets and stuff")
+    def test_import_plugins_edapi(self):
+        from tradedangerous.plugins import edapi_plug
+    
+    def test_import_plugins_edcd(self):
+        from tradedangerous.plugins import edcd_plug
+    
+    def test_import_plugins_edmc_batch(self):
+        from tradedangerous.plugins import edmc_batch_plug
+    
+    def test_import_plugins_journal(self):
+        from tradedangerous.plugins import journal_plug
+    
+    def test_import_plugins_netlog(self):
+        from tradedangerous.plugins import netlog_plug

tradedangerous-10.14.2/tests/test_cache.py

@@ -0,0 +1,39 @@
+import pytest
+from collections import namedtuple
+
+from tradedangerous import cache
+
+FakeFile = namedtuple('FakeFile', ['name'])
+
+class TestCache(object):
+    def test_parseSupply(self):
+        fil = FakeFile('faked-file.prices')
+        reading = '897H'
+        demandUnits, demandLevel = cache.parseSupply(
+            fil,
+            10,
+            'demand',
+            reading)
+        
+        assert demandUnits == 897
+        assert demandLevel == 3
+    
+    def test_parseSupply_bad_level(self):
+        fil = FakeFile('faked-file.prices')
+        reading = '897X'
+        with pytest.raises(cache.SupplyError, match='Unrecognized level suffix'):
+            cache.parseSupply(
+                fil,
+                10,
+                'demand',
+                reading)
+    
+    def test_parseSupply_bad_units(self):
+        fil = FakeFile('faked-file.prices')
+        reading = '-10H'
+        with pytest.raises(cache.SupplyError, match='Unrecognized units/level value'):
+            cache.parseSupply(
+                fil,
+                10,
+                'demand',
+                reading)

tradedangerous-10.14.2/tests/test_commands.py

@@ -0,0 +1,42 @@
+#! /usr/bin/env python
+# pytest
+
+from __future__ import absolute_import, with_statement, print_function, division, unicode_literals
+import sys
+import pytest
+from tradedangerous import commands
+from tradedangerous.commands.exceptions import UsageError, CommandLineError
+
+@pytest.fixture
+def cmd():
+    return commands.CommandIndex()
+
+prog = "trade.py"
+
+class TestCommands(object):
+    
+    def test_dashh(self, cmd):
+        with pytest.raises(UsageError):
+            cmd.parse([prog, '-h'])
+    
+    def test_local_dashh(self, cmd):
+        with pytest.raises(UsageError):
+            cmd.parse([prog, 'local', '-h'])
+    
+    def test_invalid_cmd(self, cmd):
+        with pytest.raises(CommandLineError):
+            cmd.parse([prog, 'fnarg'])
+    
+    def test_local_no_args(self, cmd):
+        with pytest.raises(CommandLineError):
+            cmd.parse([prog, 'local'])
+    
+    def test_local_dashv(self, cmd):
+        with pytest.raises(CommandLineError):
+            cmd.parse([prog, 'local', '-v'])
+    
+    def test_local_validsys(self, cmd):
+        cmd.parse([prog, 'local', 'ibootis'])
+    
+    def test_local_validsys_dashv(self, cmd):
+        cmd.parse([prog, 'local', 'ibootis', '-v'])

tradedangerous-10.14.2/tests/test_fs.py

@@ -0,0 +1,44 @@
+
+from shutil import rmtree
+from pathlib import Path
+import pytest
+
+from tradedangerous import fs, TradeEnv
+
+def setup_module():
+    tdenv = TradeEnv()
+    p = Path(tdenv.tmpDir)
+    if p.exists() and p.is_dir():
+        rmtree(tdenv.tmpDir)
+    fs.ensurefolder(tdenv.tmpDir)
+
+@pytest.fixture
+def tdenv():
+    return TradeEnv()
+
+
+class TestFS(object):
+    
+    def test_copy(self, tdenv):
+        src = fs.pathify(tdenv.templateDir, 'TradeDangerous.sql')
+        dst = fs.pathify(tdenv.tmpDir, src.name)
+        fs.copy(src, dst)
+        assert dst.exists() and dst.is_file()
+    
+    def test_ensureflag(self, tdenv):
+        self.result = False
+        flagfile = fs.pathify(tdenv.tmpDir, 'flagtest')
+        if flagfile.exists():
+            flagfile.unlink()
+        
+        def action():
+            self.result = True
+        
+        flag = fs.ensureflag(flagfile, action)
+        assert self.result == True
+    
+    def test_copyallfiles(self, tdenv):
+        setup_module()
+        fs.copyallfiles(tdenv.templateDir, tdenv.tmpDir)
+        test = Path(tdenv.tmpDir, 'Added.csv')
+        assert test.exists() and test.is_file()

tradedangerous-10.14.2/tests/test_peek.py

@@ -0,0 +1,110 @@
+import os
+import random
+
+import pytest
+
+from tradedangerous.tradedb import Trade, TradeDB, Station, System
+from .helpers import copy_fixtures
+
+ORIGIN='Shinrarta Dezhra'
+#tdb = None
+
+def setup_module():
+    copy_fixtures()
+
+def route_to_closest(tdb:TradeDB, origin, destinations, maxLy=15):
+    closest = min(destinations, key=lambda candidate: candidate.distanceTo(origin))
+    print("Closest:", closest.name(), closest.distanceTo(origin))
+    route = tdb.getRoute(origin, closest, maxLy)
+    if not route:
+        print("No route found.")
+    else:
+        print("Route:", ", ".join(system.name() for system, distance in route))
+    return route
+
+def should_skip() -> bool:
+    return False # os.getenv("CI") != None
+
+
+class TestPeek(object):
+    """
+    Tests based on https://github.com/eyeonus/Trade-Dangerous/wiki/Python-Quick-Peek
+    """
+
+    @pytest.mark.skipif(should_skip(), reason="does not work with CI")
+    def test_quick_origin(self, tdb:TradeDB):
+        # Look up a particular system
+        origin = tdb.lookupSystem(ORIGIN)
+        
+        assert 55.71875 == origin.posX
+        assert 17.59375 == origin.posY
+        assert 27.15625, origin.posZ
+        
+        stations = origin.stations
+        assert len(stations) == 5
+        for station in stations:
+            assert isinstance(station, Station)
+        
+        # Look up a station
+        abe1 = tdb.lookupStation("Abraham Lincoln")
+        assert isinstance(abe1, Station)
+
+
+        # Look up a station in a particular system
+        sol = tdb.lookupSystem("sol")
+        abe2 = tdb.lookupStation("Abraham Lincoln", sol)
+        
+        assert abe1 == abe2
+    
+    @pytest.mark.skipif(should_skip(), reason="does not work with CI")
+    def test_quick_lookupPlace(self, tdb):
+        # Look up a system or station using the flexible naming mechanism
+        phoenix = tdb.lookupPlace("dunyach")
+        assert str(type(phoenix)) == "<class 'tradedangerous.tradedb.Station'>"  # tell me what type of thing "phoenix" is...
+        
+        sol = tdb.lookupPlace("@sol")
+        assert str(type(sol)) == "<class 'tradedangerous.tradedb.System'>"
+        
+        lave = tdb.lookupPlace("stein")
+        assert isinstance(lave, System)
+        
+        abe = tdb.lookupPlace("sol/hamlinc")
+        assert isinstance(abe, Station)
+
+    @pytest.mark.skipif(should_skip(), reason="does not work with CI")
+    def test_quick_five(self, tdb):
+        systemTable = tdb.systemByID.values()
+        visitMe = random.sample(list(systemTable), 5)
+        origin = tdb.lookupPlace(ORIGIN)
+        # Call distanceTo(origin) on every member of visitMe and
+        # then retrieve the one with the lowest distance.
+        closest = min(visitMe, key=lambda candidate: candidate.distanceTo(origin))
+        print("{start} -> {dest}: {dist:.2f} ly".format(
+            start=origin.name(), dest=closest.name(),
+            dist=origin.distanceTo(closest),
+        ))
+        route = tdb.getRoute(origin, closest, 15)
+        if not route:
+            print("Shame, couldn't find a route.")
+        else:
+            # Route is a list of Systems. Turn it into a list of
+            # System names...
+            routeNames = [ system.name() for system, distance in route ]
+            print("Route:", routeNames)
+        
+        route_to_closest(tdb, origin, visitMe)
+        route_to_closest(tdb, origin, visitMe, 20)
+        
+        # lets change origin
+        origin = tdb.lookupSystem("Toolfa")
+        route_to_closest(tdb, origin, visitMe)
+    
+    @pytest.mark.skipif(should_skip(), reason="does not work with CI")
+    def test_three_different(self, tdb):
+        # lets try a different route:
+        sol = tdb.lookupSystem("sol")
+        lhs = tdb.lookupSystem("lhs 380")
+        bhr = tdb.lookupSystem("bhritzameno")
+        
+        result = route_to_closest(tdb, sol, [ lhs, bhr ])
+ 

tradedangerous-10.14.2/tests/test_tools.py

@@ -0,0 +1,13 @@
+import pytest
+
+from tradedangerous import tools
+from .helpers import copy_fixtures
+
+
+def setup_module():
+    copy_fixtures()
+
+
+class TestTools(object):
+    def test_derp(self, capsys):
+        tools.test_derp()

tradedangerous-10.14.2/tests/test_trade.py

@@ -0,0 +1,84 @@
+import pytest
+
+from tradedangerous.cli import trade
+from tradedangerous.commands.exceptions import UsageError
+from .helpers import copy_fixtures, regex_findin, remove_fixtures
+
+PROG = "trade"
+
+
+def setup_module():
+    copy_fixtures()
+
+
+def teardown_module():
+    remove_fixtures()
+
+
+class TestTrade(object):
+    def test_local_help(self):
+        with pytest.raises(UsageError):
+            trade([PROG, "local", "-h"])
+
+    def test_local_sol(self, capsys):
+        trade([PROG, "local", "--ly=10", "--detail", "sol"])
+        captured = capsys.readouterr()
+        assert "Sol       0" in captured.out
+        assert "Ehrlich City" in captured.out
+
+    def test_sell(self, capsys):
+        trade([PROG, "sell", "--near=sol", "hydrogen fuel"])
+        captured = capsys.readouterr()
+        assert "Sol/Mars High" in captured.out
+
+    def test_buy(self, capsys):
+        trade([PROG, "buy", "--near=sol", "hydrogen fuel"])
+        captured = capsys.readouterr()
+        assert "Cost      Units DistLy Age/days" in captured.out
+
+    def test_export_station(self, capsys):
+        trade([PROG, "export", "-T", "System"])
+        captured = capsys.readouterr()
+        assert "NOTE: Export Table 'System'" in captured.out
+        # TODO: check that System.csv has a fresh date
+
+    def test_station_remove(self, capsys):
+        # "Dekker's Yard"
+        trade([PROG, "station", "-rm", "sol/dekkers"])
+        captured = capsys.readouterr()
+        assert regex_findin(r"NOTE: Sol/Dekker's Yard \(#\d+\) removed", captured.out)
+
+    def test_station_add(self, capsys):
+        # "Dekker's Yard"
+        trade([
+            PROG, "station", "--add", "--ls-from-star=5",
+            "--market=Y",
+            "--black-market=?",
+            "--outfitting=?",
+            "--pad-size=s",
+            "--rearm=?",
+            "--refuel=Y",
+            "--repair=?",
+            "--no-export",
+            "sol/Dangerous Delight"])
+        captured = capsys.readouterr()
+        assert regex_findin(r"NOTE: Sol/Dangerous Delight \(#\d+\) added", captured.out)
+
+    def test_nav(self, capsys):
+        trade([PROG, "nav", "--ly-per=50", "sol", "Shinrarta Dezhra"])
+        captured = capsys.readouterr()
+        assert "System            JumpLy" in captured.out
+        assert "Shinrarta Dezhra   47" in captured.out
+
+    def test_market(self, capsys):
+        trade([PROG, "market", "sol/abr"])
+        captured = capsys.readouterr()
+        assert regex_findin("Item[ ]{3,}Buying Selling[ ]{2,}Supply", captured.out)
+        assert "Hydrogen Fuel" in captured.out
+        assert regex_findin("Water[ ]{3,}323", captured.out)
+
+    @pytest.mark.slow
+    def test_import_edcd(self, capsys):
+        trade([PROG, "import", "-P=edcd", "--opt=commodity"])
+        captured = capsys.readouterr()
+        assert regex_findin(r"NOTE: Found \d+ item\(s\)", captured.out)

tradedangerous-10.14.2/tests/test_trade_import_eddblink.py

@@ -0,0 +1,58 @@
+import os
+
+import pytest
+
+from tradedangerous.cli import trade
+from tradedangerous.plugins import eddblink_plug as module
+from .helpers import copy_fixtures, tdfactory
+
+PROG = "trade"
+
+
+@pytest.fixture
+def td():
+    copy_fixtures()
+    tdb, tdenv = tdfactory()
+    yield tdb, tdenv
+    # this will happen when the fixture goes out of use
+    tdb.close()
+
+
+class TestTradeImportEddblink(object):
+    def test_create_instance(self, monkeypatch, td):
+        tdb, tdenv = td
+        plug = module.ImportPlugin(tdb, tdenv)
+        assert module.UPGRADES == "modules.json"
+        assert os.path.join('data', 'eddb') in str(plug.dataPath)
+
+        monkeypatch.setitem(os.environ, 'TD_EDDB', '/my/testdir')
+        plug = module.ImportPlugin(tdb, tdenv)
+        assert os.path.join('my', 'testdir') in str(plug.dataPath)
+
+    def test_upgrades(self, capsys, td):
+        tdb, tdenv = td
+        plug = module.ImportPlugin(tdb, tdenv)
+        assert module.UPGRADES == "modules.json"
+        assert os.path.join('data', 'eddb') in str(plug.dataPath)
+        plug.downloadFile(module.UPGRADES, plug.upgradesPath)
+        assert (plug.dataPath / plug.upgradesPath).is_file()
+    
+    @pytest.mark.superslow
+    def test_import_clean(self, capsys):
+        trade([PROG, "import", "-P=eddblink", '--opt=clean,skipvend,force'])
+        captured = capsys.readouterr()
+        # with capsys.disabled():
+        #     print("Here")
+        #     print(captured.out)
+        #     print("to Here")
+        assert "NOTE: Import completed." in captured.out
+
+    @pytest.mark.superslow
+    def test_import_upgrade(self, capsys):
+        trade([PROG, "import", "-P=eddblink", '--opt=upgrade'])
+        captured = capsys.readouterr()
+        with capsys.disabled():
+            print("Here")
+            print(captured.out)
+            print("to Here")
+        assert "NOTE: Import completed." in captured.out

tradedangerous-10.14.2/tests/test_trade_run.py

@@ -0,0 +1,64 @@
+import io
+
+import pytest
+
+from tradedangerous.cli import trade
+
+from .helpers import copy_fixtures, regex_findin, replace_stdin
+
+PROG = "trade"
+
+
+def setup_module():
+    copy_fixtures()
+
+
+class TestTradeRun(object):
+    def test_run1(self, capsys):
+        trade([PROG, "run", "--capacity=10", "--credits=10000", "--from=sol/abr", "--jumps-per=3", "--ly-per=10.5", "--no-planet"])
+        captured = capsys.readouterr()
+        assert "Sol/Abraham Lincoln: 10 x Hydrogen Fuel," in captured.out
+        assert "Sol/Burnell Station: 2 x Silver," in captured.out
+        assert "560cr (213/ton)" in captured.out
+    
+    @pytest.mark.slow
+    def test_run2(self, capsys):
+        trade([
+            PROG, "run", "-vv", "--progress", "--empty=82",
+            "--cap=212", "--jumps=4", "--cr=2153796", "--from=sol/abr",
+            "--hops=6", "--ls-m=8000", "--sup=10000",
+            "--pad=L", "--ly=25", "--prune-hop=3", "--prune-sc=40"])
+        captured = capsys.readouterr()
+        assert regex_findin(r"=> est [\d\s,]+cr total", captured.out)
+    
+    @pytest.mark.slow
+    def test_run3(self, capsys):
+        """Testing --checklist
+        """
+        # monkeypatch.setattr('sys.stdin', io.StringIO('100'))
+        STEPS = 37
+        with replace_stdin(io.StringIO('\n' * STEPS)):
+            trade([
+                PROG, "run", "-vv", "--progress", "--empty=82", "--checklist",
+                "--cap=212", "--jumps=4", "--cr=2153796", "--from=sol/abr",
+                "--hops=6", "--ls-m=8000", "--sup=10000",
+                "--pad=L", "--ly=25", "--prune-hop=3", "--prune-sc=40"])
+        captured = capsys.readouterr()
+        # with capsys.disabled():
+        #      print("Here")
+        #      print(captured.out)
+        #      print("to Here")
+        assert "BEGINNING CHECKLIST FOR Sol/Abraham Lincoln -> LHS 449/Fisher Point" in captured.out
+        assert "35 : Sell 212 x Polymers"
+    
+    def test_run4(self, capsys):
+        trade([PROG, "run", "--capacity=10", "--credits=10000", "--from=sol/abr", "--jumps-per=3", "--ly-per=10.5", "--start-jumps=2"])
+        captured = capsys.readouterr()
+        # with capsys.disabled():
+        #      print("Here")
+        #      print(captured.out)
+        #      print("to Here")
+        assert "Sol/Haberlandt Survey -> Sol/Durrance Camp" in captured.out
+        assert "  Sol/Haberlandt Survey: 5 x Reactive Armour," in captured.out
+        assert "  Sol/Ehrlich City: 10 x Building Fabricators," in captured.out
+        assert "  Sol/Durrance Camp +10 925cr (728/ton)"

tradedangerous-10.14.2/tests/test_utils.py

@@ -0,0 +1,27 @@
+import pytest
+
+from tradedangerous import utils
+from tradedangerous import TradeEnv
+
+
+class TestUtils(object):
+    # TODO: Test 'von' etc.
+    
+    def test_titleFixup_s(self):
+        assert "Smith's" == utils.titleFixup("smith's")
+    
+    def test_titleFixup_mc(self):
+        assert 'McDonald' == utils.titleFixup('mcdonald')
+        assert 'McKilroy' == utils.titleFixup('mckilroy')
+    
+    def test_titleFixup_mac(self):
+        assert 'MacNair' == utils.titleFixup('macnair')
+        # Needs to be > 3 characters after Mac
+        assert 'Macnai' == utils.titleFixup('macnai')
+
+
+    def test_checkForOcrDerp(self, capsys):
+        tdenv = TradeEnv()
+        utils.checkForOcrDerp(tdenv, 'some', 'Aquire0')
+        captured = capsys.readouterr()
+        assert "Ignoring 'some/Aquire0' because it looks like OCR derp." in captured.out

{tradedangerous-10.13.10 → tradedangerous-10.14.2}/tradedangerous/cache.py

@@ -285,12 +285,12 @@ def getStationByNameIndex(cur):
     """ Build station index in STAR/Station notation """
     cur.execute("""
             SELECT station_id,
-                    UPPER(system.name) || '/' || UPPER(station.name)
+                    system.name || '/' || station.name
               FROM System
                    INNER JOIN Station
                       USING (system_id)
         """)
-    return { name: ID for (ID, name) in cur }
+    return { name.upper(): ID for (ID, name) in cur }
 
 
 def getItemByNameIndex(cur):