├── version.txt
├── src
    ├── __init__.py
    ├── logger.py
    ├── app_update.py
    ├── configuration.py
    ├── limited_sets.py
    ├── constants.py
    ├── file_extractor.py
    └── card_logic.py
├── tests
    ├── __init__.py
    ├── test_app_update.py
    ├── test_configuration.py
    └── test_limited_sets.py
├── Tools
    └── TierScraper17Lands
    │   ├── 17LandsTier.css
    │   ├── manifest.json
    │   ├── README.md
    │   └── 17LandsTier.js
├── requirements.txt
├── main.py
├── LICENSE
├── dark_mode.tcl
├── .gitignore
├── release_notes.txt
└── README.md


/version.txt:
--------------------------------------------------------------------------------
1 | 3.10
2 | 


--------------------------------------------------------------------------------
/src/__init__.py:
--------------------------------------------------------------------------------
1 | # src/__init__.py


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
1 | # src/__init__.py


--------------------------------------------------------------------------------
/Tools/TierScraper17Lands/17LandsTier.css:
--------------------------------------------------------------------------------
1 | nav a div div,
2 | nav div div div {
3 |   font-size: 16px !important;
4 |   font-weight: 400 !important;
5 |   line-height: 1.3 !important;
6 | }


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | pyinstaller==5.5; sys_platform == 'win32'
2 | pywin32==306 ; sys_platform == 'win32'
3 | Pillow==9.5.0
4 | pynput==1.7.6
5 | ttkwidgets==0.13.0
6 | numpy==1.24.4
7 | pydantic==1.10.12
8 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | """! @brief Magic the Gathering draft application that utilizes 17Lands data"""
 3 | 
 4 | # Imports
 5 | from src.overlay import start_overlay
 6 | 
 7 | def main():
 8 |     start_overlay()
 9 | 
10 | if __name__ == "__main__":
11 |     main()
12 | 


--------------------------------------------------------------------------------
/Tools/TierScraper17Lands/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "manifest_version": 3,
 3 | 
 4 |   "name": "17Lands Tier Scraper",
 5 |   "description": "Retrieve tier lists from 17Lands",
 6 |   "version": "4.0",
 7 | 
 8 |   "permissions": ["activeTab", "declarativeContent", "storage","scripting","tabs"],
 9 |   "host_permissions": ["*://*/*"],
10 |   "content_scripts": [
11 |    {
12 |      "matches": ["https://www.17lands.com/tier_list/*"],
13 |      "css": ["17LandsTier.css"],
14 |      "js": ["17LandsTier.js"]
15 |    }
16 |    
17 | ]
18 | }


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


--------------------------------------------------------------------------------
/Tools/TierScraper17Lands/README.md:
--------------------------------------------------------------------------------
 1 | # Tier List Download Extension
 2 | 
 3 | ![Tier_lists](https://user-images.githubusercontent.com/96687942/227722851-9f978440-b313-4375-9503-357cd7b2f1df.png)
 4 | 
 5 | ## Steps
 6 | - **Step 1**: Open Chrome
 7 | 
 8 | - **Step 2:** Go to chrome://extensions/
 9 | 
10 | - **Step 3:** Toggle Developer Mode
11 | 
12 | - **Step 4:** Click Load Unpacked
13 |     - Click Update if you've already unpacked the extension
14 | 
15 | - **Step 5:** Select the Tools/TierScraper17Lands folder and click Select Folder
16 | 
17 | - **Step 6:** Go to a 17Lands Tier List page (e.g., https://www.17lands.com/tier_list/58d9427911c74212841c04e223556395)
18 |     - It might take a few seconds for the button to appear
19 | 
20 | - **Step 7:** Enter a label for the tier list
21 | 
22 | - **Step 8:** Click on the Download Tier List button near the top of the window
23 | 
24 | - **Step 9:** Move the downloaded tier list to the Tier folder
25 | 
26 | - **Step 10:** Start the draft in Arena
27 | 
28 | - **Step 11:** Select the tier list option from the bottom of any of the column drop-downs in the settings window
29 |     - The tier list will appear as `Tier# (<Label>)`
30 | 
31 | ![Tier_list_setup](https://user-images.githubusercontent.com/96687942/227722838-1512dd5d-23f3-47fc-bae8-5ea717b97222.png)
32 | 


--------------------------------------------------------------------------------
/dark_mode.tcl:
--------------------------------------------------------------------------------
 1 | #This file is based on azure.tcl by rdbende https://github.com/rdbende/Azure-ttk-theme
 2 | 
 3 | option add *tearOff 0
 4 | 
 5 | array set colors {
 6 |           -fg             "#ffffff"
 7 |           -bg             "#3d3d3d"
 8 |           -disabledfg     "#ffffff"
 9 |           -disabledbg     "#737373"
10 |           -selectfg       "#ffffff"
11 |           -selectbg       "#007fff"
12 |       }
13 |       
14 |       ttk::style configure . \
15 |           -background $colors(-bg) \
16 |           -foreground $colors(-fg) \
17 |           -troughcolor $colors(-bg) \
18 |           -focuscolor $colors(-selectbg) \
19 |           -selectbackground $colors(-selectbg) \
20 |           -selectforeground $colors(-selectfg) \
21 |           -insertcolor $colors(-fg) \
22 |           -insertwidth 1 \
23 |           -fieldbackground $colors(-selectbg) \
24 |           -borderwidth 1 \
25 |           -relief flat
26 | 
27 |       tk_setPalette background [ttk::style lookup . -background] \
28 |           foreground [ttk::style lookup . -foreground] \
29 |           highlightColor [ttk::style lookup . -focuscolor] \
30 |           selectBackground [ttk::style lookup . -selectbackground] \
31 |           selectForeground [ttk::style lookup . -selectforeground] \
32 |           activeBackground [ttk::style lookup . -selectbackground] \
33 |           activeForeground [ttk::style lookup . -selectforeground]
34 |       
35 |       ttk::style map . -foreground [list disabled $colors(-disabledfg)]
36 | 
37 |       option add *Menu.selectcolor $colors(-fg)
38 | 


--------------------------------------------------------------------------------
/src/logger.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import sys
 3 | import logging
 4 | import logging.handlers
 5 | 
 6 | 
 7 | DEBUG_LOG_FOLDER = os.path.join(os.getcwd(), "Debug")
 8 | DEBUG_LOG_FILE = os.path.join(DEBUG_LOG_FOLDER, "debug.log")
 9 | DEBUG_LOGGER_NAME = "debug_log"
10 | 
11 | if not os.path.exists(DEBUG_LOG_FOLDER):
12 |     os.makedirs(DEBUG_LOG_FOLDER)
13 | 
14 | 
15 | class CustomFormatter(logging.Formatter):
16 |     """ """
17 | 
18 |     def __init__(self, fmt="%(asctime)s - %(levelname)s - %(message)s", datefmt='<%m/%d/%Y %H:%M:%S>'):
19 |         logging.Formatter.__init__(self, fmt=fmt, datefmt=datefmt)
20 | 
21 |     def format(self, record):
22 | 
23 |         # Remember the original format
24 |         format_orig = self._style._fmt
25 | 
26 |         if record.levelno == logging.ERROR:
27 |             self._style._fmt = "%(asctime)s - %(levelname)s - %(module)s.%(funcName)s - %(message)s"
28 | 
29 |         # Calling the original formatter once the style has changed
30 |         result = logging.Formatter.format(self, record)
31 | 
32 |         # Restore the original format
33 |         self._style._fmt = format_orig
34 | 
35 |         return result
36 | 
37 | 
38 | # Create the shared logger
39 | shared_logger = logging.getLogger(DEBUG_LOGGER_NAME)
40 | shared_logger.setLevel(logging.DEBUG)
41 | 
42 | # Create a file handler for the shared logger
43 | handlers = {
44 |     logging.handlers.TimedRotatingFileHandler(
45 |         DEBUG_LOG_FILE, when='D', interval=1, backupCount=7, utc=True),
46 |     logging.StreamHandler(sys.stdout),
47 | }
48 | 
49 | formatter = CustomFormatter()
50 | 
51 | for handler in handlers:
52 |     handler.setFormatter(formatter)
53 |     shared_logger.addHandler(handler)
54 | 
55 | 
56 | def create_logger():
57 |     logger = logging.getLogger(DEBUG_LOGGER_NAME)
58 |     return logger
59 | 


--------------------------------------------------------------------------------
/tests/test_app_update.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import os
 3 | import sys
 4 | from src.app_update import AppUpdate
 5 | 
 6 | EXPECTED_OLD_VERSION_STRING = "0307"
 7 | 
 8 | @pytest.fixture
 9 | def app_update():
10 |     return AppUpdate()
11 | 
12 | @pytest.fixture
13 | def invalid_search_location():
14 |     return "http://invalid_location"
15 | 
16 | @pytest.fixture
17 | def valid_search_location_old():
18 |     return "https://api.github.com/repos/bstaple1/MTGA_Draft_17Lands/releases/96565628"
19 | 
20 | @pytest.fixture
21 | def valid_search_location_latest():
22 |     return "https://api.github.com/repos/bstaple1/MTGA_Draft_17Lands/releases/latest"
23 | 
24 | @pytest.fixture
25 | def invalid_input_url():
26 |     return "http://invalid_url"
27 | 
28 | @pytest.fixture
29 | def valid_input_url_zip():
30 |     return "https://github.com/bstaple1/MTGA_Draft_17Lands/releases/download/MTGA_Draft_Tool_V0307/MTGA_Draft_Tool_V0307_Setup.zip"
31 |     
32 | @pytest.fixture
33 | def valid_input_url_exe():
34 |     return "https://github.com/bstaple1/MTGA_Draft_17Lands/releases/download/MTGA_Draft_Tool_V0304/MTGA_Draft_Tool_V0304_Setup.exe"
35 | 
36 | @pytest.fixture
37 | def output_filename():
38 |     return "test_file.exe"
39 |     
40 | def test_retrieve_file_version_latest_success(app_update, valid_search_location_latest):
41 |     version, file_location = app_update.retrieve_file_version(valid_search_location_latest)
42 |     assert isinstance(version, str) and isinstance(float(version), float)
43 |     assert isinstance(file_location, str)
44 |     assert len(file_location) != 0
45 |     
46 | def test_retrieve_file_version_old_success(app_update, valid_search_location_old):
47 |     version, file_location = app_update.retrieve_file_version(valid_search_location_old)
48 |     assert version == EXPECTED_OLD_VERSION_STRING
49 |     
50 | def test_retrieve_file_version_failure(app_update, invalid_search_location):
51 |     version, file_location = app_update.retrieve_file_version(invalid_search_location)
52 |     assert version == ""
53 |     assert file_location == ""
54 | 
55 | @pytest.mark.skipif(sys.platform != "win32", reason="Windows only")
56 | def test_download_file_zip_success(app_update, valid_input_url_zip, output_filename):
57 |     output_location = app_update.download_file(valid_input_url_zip, output_filename)
58 |     assert isinstance(output_location, str) and os.path.exists(output_location)
59 |     
60 | @pytest.mark.skipif(sys.platform != "win32", reason="Windows only")
61 | def test_download_file_exe_success(app_update, valid_input_url_exe, output_filename):
62 |     output_location = app_update.download_file(valid_input_url_exe, output_filename)
63 |     assert isinstance(output_location, str) and os.path.exists(output_location)
64 | 
65 | @pytest.mark.skipif(sys.platform != "win32", reason="Windows only")
66 | def test_download_file_failure(app_update, invalid_input_url, output_filename):
67 |     output_location = app_update.download_file(invalid_input_url, output_filename)
68 |     assert output_location == ""
69 | 


--------------------------------------------------------------------------------
/src/app_update.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import json
 3 | import urllib.request
 4 | import ssl
 5 | import re
 6 | import shutil
 7 | import zipfile
 8 | from typing import Tuple
 9 | from src.logger import create_logger
10 | 
11 | logger = create_logger()
12 | 
13 | DOWNLOADS_FOLDER = os.path.join(os.getcwd(), "Downloads")
14 | 
15 | UPDATE_LATEST_URL = "https://api.github.com/repos/bstaple1/MTGA_Draft_17Lands/releases/latest"
16 | UPDATE_FILENAME = "MTGA_Draft_Tool_Setup.exe"
17 | 
18 | if not os.path.exists(DOWNLOADS_FOLDER):
19 |     os.makedirs(DOWNLOADS_FOLDER)
20 | 
21 | 
22 | class AppUpdate:
23 |     def __init__(self):
24 |         self.version: str = ""
25 |         self.file_location: str = ""
26 |         self.context: ssl.SSLContext = ssl.SSLContext()
27 | 
28 |     def retrieve_file_version(self, search_location: str = UPDATE_LATEST_URL) -> Tuple[str, str]:
29 |         '''Retrieve the file version'''
30 |         self.version = ""
31 |         self.file_location = ""
32 |         try:
33 |             url_data = urllib.request.urlopen(
34 |                 search_location, context=self.context).read()
35 |             url_json = json.loads(url_data)
36 |             self.__process_file_version(url_json)
37 |         except Exception as error:
38 |             logger.error(error)
39 |         return self.version, self.file_location
40 | 
41 |     def download_file(self, input_url: str, output_filename: str = UPDATE_FILENAME) -> str:
42 |         '''Download a file from Github'''
43 |         output_location: str = ""
44 |         try:
45 |             input_filename = os.path.basename(input_url)
46 |             temp_input_location = os.path.join(
47 |                 DOWNLOADS_FOLDER, input_filename)
48 |             temp_output_location = os.path.join(
49 |                 DOWNLOADS_FOLDER, output_filename)
50 | 
51 |             with urllib.request.urlopen(input_url, context=self.context) as response:
52 |                 with open(temp_input_location, 'wb') as file:
53 |                     shutil.copyfileobj(response, file)
54 | 
55 |             if zipfile.is_zipfile(temp_input_location):
56 |                 with zipfile.ZipFile(temp_input_location, 'r') as zip_ref:
57 |                     file = zip_ref.infolist()[0]
58 |                     file.filename = output_filename
59 |                     zip_ref.extract(file, DOWNLOADS_FOLDER)
60 |             else:
61 |                 os.replace(temp_input_location, temp_output_location)
62 | 
63 |             if os.path.exists(temp_output_location):
64 |                 output_location = temp_output_location
65 |         except Exception as error:
66 |             logger.error(error)
67 | 
68 |         return output_location
69 | 
70 |     def __process_file_version(self, release: dict) -> None:
71 |         try:
72 |             filename = release["assets"][0]["name"]
73 |             self.version = re.findall(r"\d+", filename, re.DOTALL)[0]
74 |             self.file_location = release["assets"][0]["browser_download_url"]
75 |         except Exception as error:
76 |             logger.error(error)
77 |         return
78 | 


--------------------------------------------------------------------------------
/tests/test_configuration.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import json
 3 | from typing import Tuple
 4 | from dataclasses import asdict
 5 | 
 6 | # Import the functions to be tested
 7 | from src.configuration import (
 8 |     read_configuration,
 9 |     write_configuration,
10 |     reset_configuration,
11 |     Configuration
12 | )
13 | 
14 | 
15 | @pytest.fixture
16 | def example_configuration():
17 |     # Create an example Configuration object for testing
18 |     config = Configuration()
19 |     config.features.override_scale_factor = 1.5
20 |     config.features.hotkey_enabled = True
21 |     config.features.images_enabled = False
22 |     return config
23 | 
24 | 
25 | def test_read_configuration_existing_file(tmp_path, example_configuration):
26 |     # Create a temporary file for testing
27 |     file_location = tmp_path / "config.json"
28 | 
29 |     # Write the example configuration to the temporary file
30 |     with open(file_location, "w") as f:
31 |         json.dump(example_configuration.dict(), f)
32 | 
33 |     # Test reading the configuration from an existing file
34 |     config, success = read_configuration(file_location)
35 | 
36 |     # Assert that the configuration was successfully read
37 |     assert success is True
38 | 
39 |     # Assert that the returned configuration matches the example configuration
40 |     assert config == example_configuration
41 | 
42 | 
43 | def test_read_configuration_nonexistent_file(tmp_path):
44 |     # Create a temporary file location for testing (nonexistent file)
45 |     file_location = tmp_path / "nonexistent.json"
46 | 
47 |     # Test reading the configuration from a nonexistent file
48 |     config, success = read_configuration(file_location)
49 | 
50 |     # Assert that the configuration was not successfully read
51 |     assert success is False
52 | 
53 |     # Assert that the returned configuration is a new Configuration object
54 |     assert isinstance(config, Configuration)
55 |     assert config == Configuration()
56 | 
57 | 
58 | def test_write_configuration(tmp_path, example_configuration):
59 |     # Create a temporary file for testing
60 |     file_location = tmp_path / "config.json"
61 | 
62 |     # Test writing the configuration
63 |     success = write_configuration(example_configuration, file_location)
64 | 
65 |     # Assert that the configuration was successfully written
66 |     assert success is True
67 | 
68 |     # Read the written configuration file
69 |     with open(file_location, "r") as f:
70 |         written_config = json.load(f)
71 | 
72 |     # Assert that the written configuration matches the example configuration
73 |     assert written_config == example_configuration.dict()
74 | 
75 | 
76 | def test_reset_configuration(tmp_path, example_configuration):
77 |     # Create a temporary file for testing
78 |     file_location = tmp_path / "config.json"
79 | 
80 |     # Write the example configuration to the temporary file
81 |     with open(file_location, "w") as f:
82 |         json.dump(example_configuration.dict(), f)
83 | 
84 |     # Test resetting the configuration
85 |     success = reset_configuration(file_location)
86 | 
87 |     # Assert that the configuration was successfully reset
88 |     assert success is True
89 | 
90 |     # Read the reset configuration file
91 |     with open(file_location, "r") as f:
92 |         reset_config = json.load(f)
93 | 
94 |     # Create a new empty Configuration object
95 |     empty_config = Configuration()
96 | 
97 |     # Assert that the reset configuration matches the empty Configuration object
98 |     assert reset_config == empty_config.dict()
99 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | share/python-wheels/
 24 | *.egg-info/
 25 | .installed.cfg
 26 | *.egg
 27 | MANIFEST
 28 | 
 29 | # PyInstaller
 30 | #  Usually these files are written by a python script from a template
 31 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 32 | *.manifest
 33 | *.spec
 34 | 
 35 | # Installer logs
 36 | pip-log.txt
 37 | pip-delete-this-directory.txt
 38 | 
 39 | # Unit test / coverage reports
 40 | htmlcov/
 41 | .tox/
 42 | .nox/
 43 | .coverage
 44 | .coverage.*
 45 | .cache
 46 | nosetests.xml
 47 | coverage.xml
 48 | *.cover
 49 | *.py,cover
 50 | .hypothesis/
 51 | .pytest_cache/
 52 | cover/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | .pybuilder/
 76 | target/
 77 | 
 78 | # Jupyter Notebook
 79 | .ipynb_checkpoints
 80 | 
 81 | # IPython
 82 | profile_default/
 83 | ipython_config.py
 84 | 
 85 | # pyenv
 86 | #   For a library or package, you might want to ignore these files since the code is
 87 | #   intended to run in multiple environments; otherwise, check them in:
 88 | # .python-version
 89 | 
 90 | # pipenv
 91 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 92 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 93 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 94 | #   install all needed dependencies.
 95 | #Pipfile.lock
 96 | 
 97 | # poetry
 98 | #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
 99 | #   This is especially recommended for binary packages to ensure reproducibility, and is more
100 | #   commonly ignored for libraries.
101 | #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
102 | #poetry.lock
103 | 
104 | # pdm
105 | #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
106 | #pdm.lock
107 | #   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
108 | #   in version control.
109 | #   https://pdm.fming.dev/#use-with-ide
110 | .pdm.toml
111 | 
112 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
113 | __pypackages__/
114 | 
115 | # Celery stuff
116 | celerybeat-schedule
117 | celerybeat.pid
118 | 
119 | # SageMath parsed files
120 | *.sage.py
121 | 
122 | # Environments
123 | .env
124 | .venv
125 | env/
126 | venv/
127 | ENV/
128 | env.bak/
129 | venv.bak/
130 | 
131 | # Spyder project settings
132 | .spyderproject
133 | .spyproject
134 | 
135 | # Rope project settings
136 | .ropeproject
137 | 
138 | # mkdocs documentation
139 | /site
140 | 
141 | # mypy
142 | .mypy_cache/
143 | .dmypy.json
144 | dmypy.json
145 | 
146 | # Pyre type checker
147 | .pyre/
148 | 
149 | # pytype static type analyzer
150 | .pytype/
151 | 
152 | # Cython debug symbols
153 | cython_debug/
154 | 
155 | # PyCharm
156 | #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
157 | #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
158 | #  and can be added to the global gitignore or merged into this file.  For a more nuclear
159 | #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
160 | #.idea/
161 | 


--------------------------------------------------------------------------------
/Tools/TierScraper17Lands/17LandsTier.js:
--------------------------------------------------------------------------------
  1 | const ratings_dict = {"grid-row: 16 / auto;":"NA", //"TBD"
  2 |                      "grid-row: 15 / auto;":"SB", //"SB"
  3 |                      "grid-row: 14 / auto;":"F ", //"F"
  4 |                      "grid-row: 13 / auto;":"D-", //"D-" 
  5 |                      "grid-row: 12 / auto;":"D ", //"D"
  6 |                      "grid-row: 11 / auto;":"D+", //"D+"
  7 |                      "grid-row: 10 / auto;":"C-", //"C-"
  8 |                      "grid-row: 9 / auto;" :"C ",  //"C"
  9 |                      "grid-row: 8 / auto;" :"C+",  //"C+"
 10 |                      "grid-row: 7 / auto;" :"B-",  //"B-"
 11 |                      "grid-row: 6 / auto;" :"B ",  //"B"
 12 |                      "grid-row: 5 / auto;" :"B+",  //"B+"
 13 |                      "grid-row: 4 / auto;" :"A-",  //"A-"
 14 |                      "grid-row: 3 / auto;" :"A ",  //"A"
 15 |                      "grid-row: 2 / auto;" :"A+"}  //"A+"
 16 | const column_prefix = "tier_text tier_bucket "
 17 | const color_ids = ["W","U","B","R","G","M","C","L"]
 18 | 
 19 | window.addEventListener('load', function () {
 20 |         var grid_zone = document.getElementById("sortable_card_tiers_app")
 21 |         var tier_button = document.createElement("button");
 22 |         var tier_label_box = document.createElement("textarea");
 23 |         var label_div = document.createElement("div")
 24 |         var button_div = document.createElement("div")
 25 |         
 26 |         tier_button.setAttribute("id", "tier_button")
 27 |         tier_button.innerHTML = "Download Tier List";
 28 |         
 29 |         tier_label_box.setAttribute("id", "tier_label_box")
 30 |         tier_label_box.setAttribute("rows", 1)
 31 |         tier_label_box.setAttribute("spellcheck", false)
 32 |         tier_label_box.setAttribute("placeholder", "Enter Label Here!")
 33 |         
 34 |         label_div.appendChild(tier_label_box)
 35 |         button_div.appendChild(tier_button)
 36 |         
 37 |         grid_zone.insertBefore(button_div, grid_zone.firstElementChild);
 38 |         grid_zone.insertBefore(label_div, grid_zone.firstElementChild);
 39 |         
 40 |         document.getElementById("tier_button").addEventListener("click", collect_pick_ratings);
 41 | 
 42 | })
 43 | 
 44 | function collect_pick_ratings (){
 45 |     var current_date = new Date(); 
 46 |     var datetime = (current_date.getMonth()+1)  + "/"
 47 |                  + current_date.getDate() + "/" 
 48 |                  + current_date.getFullYear() + " "
 49 |                  + current_date.getHours() + ":"  
 50 |                  + current_date.getMinutes() + ":" 
 51 |                  + current_date.getSeconds();
 52 |     
 53 |     var ratings_obj = new Object;
 54 |     var tier_label = collect_label();
 55 |     var set_name = collect_set_name();
 56 | 
 57 |     ratings_obj.meta = {"collection_date": datetime, "label": tier_label, "set": set_name, "version": 3.0};
 58 |     ratings_obj.ratings = {}
 59 |     
 60 |     for (var i = 0; i < color_ids.length; i++)
 61 |     {
 62 |         ratings_obj = collect_column_ratings(color_ids[i], ratings_obj);
 63 |     }
 64 |         
 65 |     tier_export (ratings_obj);
 66 | }
 67 | 
 68 | function collect_column_ratings (color_id, ratings_obj){
 69 | 
 70 |     try{
 71 |         let table_rows = document.querySelectorAll(`[class^="${column_prefix}"][class*="${color_id}"]`)
 72 |         
 73 |         for(let i = 0; i < table_rows.length; i++)
 74 |         {
 75 |             let row_rating = ratings_dict[table_rows[i].getAttribute("style")];
 76 |             
 77 |             //Iterate through each column in this row
 78 |             let column_items = table_rows[i].children;
 79 |             
 80 |             //Iterate through the items in this column
 81 |             for(let j = 0; j < column_items.length; j++)
 82 |             {
 83 |                 let card_name = column_items[j].getElementsByClassName("tier_card_name");
 84 |                 let card_comment = column_items[j].getElementsByClassName("tier_card_comment");
 85 |                 
 86 |                 card_name = (card_name.length) ? card_name[0].innerHTML : "";
 87 |                 card_comment = (card_comment.length) ? card_comment[0].innerHTML : "";
 88 |                 
 89 |                 let card_dict = {"rating" : row_rating, "comment" : card_comment}
 90 |                 
 91 |                 ratings_obj.ratings[card_name] = card_dict;
 92 |             }
 93 |         }
 94 |     }catch(error){
 95 |         console.log(error);
 96 |     }
 97 |     
 98 |     return ratings_obj;
 99 | }
100 | 
101 | function collect_set_name (){
102 |     var set_name = "";
103 |     
104 |     try{
105 |         let tier_list_element = document.getElementById("sortable_card_tiers_app");
106 |         
107 |         set_name = tier_list_element.dataset.expansion;
108 |     
109 |     }catch(error){
110 |         console.log(error);
111 |     }
112 |     
113 |     return set_name;
114 | }
115 | 
116 | function collect_label (){
117 |     var tier_label = "";
118 |     
119 |     try{
120 |         tier_label = document.querySelector("h2").textContent;
121 |         
122 |         //Check if a label was entered
123 |         custom_label = document.getElementById("tier_label_box").value
124 |         
125 |         if(custom_label.length)
126 |         {
127 |             tier_label = custom_label;
128 |         }
129 |         
130 |     }catch(error){
131 |         console.log(error);
132 |     }
133 |     
134 |     return tier_label;
135 | }
136 | function tier_export (ratings_obj){
137 | 
138 | 	var url = document.URL.split("/");
139 | 
140 |     var filename = `Tier_${ratings_obj.meta.set}_${Date.now().toString()}.txt`
141 | 	
142 | 	var tier_obj = JSON.stringify(ratings_obj , null, 4); //indentation in json format, human readable
143 | 	
144 | 	var vLink = document.createElement('a'),
145 | 	vBlob = new Blob([tier_obj], {type: "octet/stream"}),
146 | 	vName = filename;
147 | 	vUrl = window.URL.createObjectURL(vBlob);
148 | 	vLink.setAttribute('href', vUrl);
149 | 	vLink.setAttribute('download', vName );
150 | 	vLink.click();
151 | }
152 | 
153 | 


--------------------------------------------------------------------------------
/src/configuration.py:
--------------------------------------------------------------------------------
  1 | """This module encompasses functions for reading from, writing to, and resetting the configuration file"""
  2 | import json
  3 | import os
  4 | from pydantic import BaseModel, validator, Field
  5 | from typing import Tuple
  6 | from src import constants
  7 | from src.logger import create_logger
  8 | 
  9 | CONFIG_FILE = os.path.join(os.getcwd(), "config.json")
 10 | 
 11 | logger = create_logger()
 12 | 
 13 | 
 14 | class DeckType(BaseModel):
 15 |     """This class holds the data for the various deck types (Aggro, Mid, and Control)"""
 16 |     distribution: list = Field(
 17 |         default_factory=lambda: [0, 0, 0, 0, 0, 0, 0])
 18 |     maximum_card_count: int = 0
 19 |     recommended_creature_count: int = 0
 20 |     cmc_average: float = 0.0
 21 | 
 22 | 
 23 | class Settings(BaseModel):
 24 |     """This class holds UI settings"""
 25 |     table_width: int = 270
 26 |     column_2: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_2_DEFAULT]
 27 |     column_3: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_3_DEFAULT]
 28 |     column_4: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_4_DEFAULT]
 29 |     column_5: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_5_DEFAULT]
 30 |     column_6: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_6_DEFAULT]
 31 |     column_7: str = constants.COLUMNS_OPTIONS_EXTRA_DICT[constants.COLUMN_7_DEFAULT]
 32 |     deck_filter: str = constants.DECK_FILTER_DEFAULT
 33 |     filter_format: str = constants.DECK_FILTER_FORMAT_COLORS
 34 |     result_format: str = constants.RESULT_FORMAT_WIN_RATE
 35 |     ui_size: str = constants.UI_SIZE_DEFAULT
 36 |     card_colors_enabled: bool = False
 37 |     missing_enabled: bool = True
 38 |     stats_enabled: bool = False
 39 |     auto_highest_enabled: bool = True
 40 |     curve_bonus_enabled: bool = False
 41 |     color_bonus_enabled: bool = False
 42 |     bayesian_average_enabled: bool = False
 43 |     draft_log_enabled: bool = True
 44 |     color_identity_enabled: bool = False
 45 |     current_draft_enabled: bool = True
 46 |     data_source_enabled: bool = True
 47 |     deck_filter_enabled: bool = True
 48 |     refresh_button_enabled: bool = True
 49 |     taken_alsa_enabled: bool = False
 50 |     taken_ata_enabled: bool = False
 51 |     taken_gpwr_enabled: bool = False
 52 |     taken_ohwr_enabled: bool = False
 53 |     taken_gdwr_enabled: bool = False
 54 |     taken_gndwr_enabled: bool = False
 55 |     taken_iwd_enabled: bool = False
 56 |     arena_log_location: str = ""
 57 | 
 58 |     @validator('deck_filter')
 59 |     def validate_deck_filter(cls, value, field):
 60 |         allowed_values = constants.DECK_FILTERS  # List of options
 61 |         field_name = field.name
 62 |         if value not in allowed_values:
 63 |             return cls.__fields__[field_name].default
 64 |         return value
 65 | 
 66 |     @validator('filter_format')
 67 |     def validate_filter_format(cls, value, field):
 68 |         allowed_values = constants.DECK_FILTER_FORMAT_LIST  # List of options
 69 |         field_name = field.name
 70 |         if value not in allowed_values:
 71 |             return cls.__fields__[field_name].default
 72 |         return value
 73 | 
 74 |     @validator('result_format')
 75 |     def validate_result_format(cls, value, field):
 76 |         allowed_values = constants.RESULT_FORMAT_LIST  # List of options
 77 |         field_name = field.name
 78 |         if value not in allowed_values:
 79 |             return cls.__fields__[field_name].default
 80 |         return value
 81 | 
 82 |     @validator('ui_size')
 83 |     def validate_ui_size(cls, value, field):
 84 |         allowed_values = constants.UI_SIZE_DICT  # List of options
 85 |         field_name = field.name
 86 |         if value not in allowed_values:
 87 |             return cls.__fields__[field_name].default
 88 |         return value
 89 | 
 90 | 
 91 | class CardLogic(BaseModel):
 92 |     """This class represents the configuration for card logic within the application"""
 93 |     minimum_creatures: int = 9
 94 |     minimum_noncreatures: int = 6
 95 |     ratings_threshold: int = 500
 96 |     alsa_weight: float = 0.0
 97 |     iwd_weight: float = 0.0
 98 |     deck_mid: DeckType = DeckType(distribution=[
 99 |                                   0, 0, 4, 3, 2, 1, 0], maximum_card_count=23, recommended_creature_count=15, cmc_average=3.04)
100 |     deck_aggro: DeckType = DeckType(distribution=[
101 |                                     0, 2, 5, 3, 0, 0, 0], maximum_card_count=24, recommended_creature_count=17, cmc_average=2.40)
102 |     deck_control: DeckType = DeckType(distribution=[
103 |                                       0, 0, 3, 2, 2, 1, 0], maximum_card_count=22, recommended_creature_count=10, cmc_average=3.68)
104 | 
105 | 
106 | class Features(BaseModel):
107 |     """This class represents a collection of features that can be enabled or disabled within the overlay"""
108 |     override_scale_factor: float = 0.0
109 |     hotkey_enabled: bool = True
110 |     images_enabled: bool = True
111 | 
112 | 
113 | class CardData(BaseModel):
114 |     """This class holds the data used for building a card list from the local Arena files"""
115 |     database_size: int = 0
116 | 
117 | 
118 | class Configuration(BaseModel):
119 |     """This class groups together the data stored in the config.json file"""
120 |     settings: Settings = Field(default_factory=lambda: Settings())
121 |     card_logic: CardLogic = Field(default_factory=lambda: CardLogic())
122 |     features: Features = Field(default_factory=lambda: Features())
123 |     card_data: CardData = Field(default_factory=lambda: CardData())
124 | 
125 | 
126 | def read_configuration(file_location: str = CONFIG_FILE) -> Tuple[Configuration, bool]:
127 |     '''function is responsible for reading the contents of file and storing it as a Configuration object'''
128 |     config_object = Configuration()
129 |     success = False
130 | 
131 |     try:
132 |         with open(file_location, 'r', encoding="utf8", errors="replace") as data:
133 |             config_data = json.loads(data.read())
134 | 
135 |         config_object = Configuration.parse_obj(config_data)
136 |         success = True
137 |     except (FileNotFoundError, json.JSONDecodeError) as error:
138 |         logger.error(error)
139 | 
140 |     return config_object, success
141 | 
142 | 
143 | def write_configuration(config_object: Configuration, file_location: str = CONFIG_FILE) -> bool:
144 |     '''function is responsible for writing the contents of a Configuration object to a specified file location'''
145 |     success = False
146 | 
147 |     try:
148 |         with open(file_location, 'w', encoding="utf8", errors="replace") as data:
149 |             json.dump(config_object.dict(), data, ensure_ascii=False, indent=4)
150 |         success = True
151 |     except (FileNotFoundError, TypeError, OSError) as error:
152 |         logger.error(error)
153 | 
154 |     return success
155 | 
156 | 
157 | def reset_configuration(file_location: str = CONFIG_FILE) -> bool:
158 |     '''function is responsible for reseting the contents of a Configuration object to a specified file location'''
159 |     config_object = Configuration()
160 |     success = False
161 |     try:
162 |         with open(file_location, 'w', encoding="utf8", errors="replace") as data:
163 |             json.dump(config_object.dict(), data, ensure_ascii=False, indent=4)
164 |         success = True
165 |     except (FileNotFoundError, TypeError, OSError) as error:
166 |         logger.error(error)
167 | 
168 |     return success
169 | 
170 | 
171 | if not os.path.exists(CONFIG_FILE):
172 |     reset_configuration(CONFIG_FILE)
173 | 


--------------------------------------------------------------------------------
/tests/test_limited_sets.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | import os
  3 | import json
  4 | from src.limited_sets import LimitedSets, SetInfo, SetDictionary
  5 | 
  6 | # Test data
  7 | SETS_FILE_LOCATION = os.path.join(os.getcwd(), "Temp", "unit_test_sets.json")
  8 | CHECKED_SETS_COMBINED = {
  9 |     "March of the Machine" : SetInfo(arena=["MOM", "MUL"],scryfall=["MOM", "MUL"],seventeenlands=["MOM"]),
 10 |     "March of the Machine: The Aftermath": SetInfo(arena=["MUL", "MOM", "MAT"],scryfall=["MUL", "MOM", "MAT"],seventeenlands=["MAT"]),
 11 |     "Shadows over Innistrad Remastered": SetInfo(arena=["SIR", "SIS"],scryfall=["SIR", "SIS"],seventeenlands=["SIR"]),
 12 |     "Phyrexia: All Will Be One": SetInfo(arena=["ONE"],scryfall=["ONE"],seventeenlands=["ONE"]), 
 13 |     "Alchemy: Phyrexia": SetInfo(arena=["ONE"],scryfall=["YONE", "ONE"],seventeenlands=["Y23ONE"]), 
 14 |     "The Brothers' War": SetInfo(arena=["BRO", "BRR", "BOT"],scryfall=["BRO", "BRR", "BOT"],seventeenlands=["BRO"]), 
 15 |     "Alchemy: The Brothers' War": SetInfo(arena=["BRO", "BRR", "BOT"],scryfall=["YBRO", "BRO", "BRR", "BOT"],seventeenlands=["Y23BRO"]),
 16 |     "CORE": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["CORE"],start_date="2021-03-26"),
 17 | }
 18 | 
 19 | CHECKED_SETS_SCRYFALL = {
 20 |     "March of the Machine" : SetInfo(arena=["MOM", "MUL"],scryfall=["MOM", "MUL"],seventeenlands=["MOM"]),
 21 |     "March of the Machine: The Aftermath": SetInfo(arena=["MUL", "MOM", "MAT"],scryfall=["MUL", "MOM", "MAT"],seventeenlands=["MAT"]),
 22 |     "Shadows over Innistrad Remastered": SetInfo(arena=["SIR", "SIS"],scryfall=["SIR", "SIS"],seventeenlands=["SIR"]),
 23 |     "Phyrexia: All Will Be One": SetInfo(arena=["ONE"],scryfall=["ONE"],seventeenlands=["ONE"]), 
 24 |     "Alchemy: Phyrexia": SetInfo(arena=["ONE"],scryfall=["YONE", "ONE"],seventeenlands=["Y23ONE"]), 
 25 |     "The Brothers' War": SetInfo(arena=["BRO", "BRR", "BOT"],scryfall=["BRO", "BRR", "BOT"],seventeenlands=["BRO"]), 
 26 |     "Alchemy: The Brothers' War": SetInfo(arena=["BRO", "BRR", "BOT"],scryfall=["YBRO", "BRO", "BRR", "BOT"],seventeenlands=["Y23BRO"]),
 27 | }
 28 | 
 29 | CHECKED_SETS_17LANDS = {
 30 |     "MOM" : SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["MOM"],start_date="2023-04-18"),
 31 |     "MAT": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["MAT"],start_date="2023-05-09"),
 32 |     "SIR": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["SIR"],start_date="2023-03-21"),
 33 |     "ONE": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["ONE"],start_date="2023-02-07"),
 34 |     "Y23ONE": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["Y23ONE"],start_date="2023-02-28"),
 35 |     "BRO": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["BRO"],start_date="2022-11-15"),
 36 |     "Y23BRO": SetInfo(arena=["ALL"],scryfall=[],seventeenlands=["Y23BRO"],start_date="2022-12-13"),
 37 | }
 38 | 
 39 | TEST_SETS = {
 40 |     "Test1" : SetInfo(arena=["aDfafdfasdf"],scryfall=[],seventeenlands=["ggdgdgsge"],start_date="111111111"),
 41 |     "Test2" : SetInfo(arena=[""],scryfall=["12345abdf"],seventeenlands=[""]),
 42 | }
 43 | 
 44 | INVALID_SETS = {
 45 |     "Test1" : {"arena" : "aDfafdfasdf", "scryfall" : []},
 46 |     "Test2" : {"arena" : [""], "scryfall" : [12345]},
 47 |     "Test3" : {"start_date" : ["111111111"]},
 48 | }
 49 | 
 50 | @pytest.fixture
 51 | def limited_sets():
 52 |     return LimitedSets(SETS_FILE_LOCATION)
 53 | 
 54 | def check_for_sets(sets_data, check_data):
 55 |     for key in check_data:
 56 |         assert key in sets_data
 57 |         assert check_data[key] == sets_data[key]
 58 | 
 59 | def test_retrieve_limited_sets_success(limited_sets):
 60 |     if os.path.exists(SETS_FILE_LOCATION):
 61 |         os.remove(SETS_FILE_LOCATION)
 62 |         assert os.path.exists(SETS_FILE_LOCATION) == False
 63 |     
 64 |     output_sets = limited_sets.retrieve_limited_sets()
 65 |     
 66 |     assert type(output_sets) == SetDictionary
 67 |     assert len(output_sets.data) > 0
 68 |     assert os.path.exists(SETS_FILE_LOCATION)
 69 |     
 70 |     check_for_sets(output_sets.data, CHECKED_SETS_COMBINED)
 71 | 
 72 | def test_retrieve_scryfall_sets_success(limited_sets):
 73 |     output_sets = limited_sets.retrieve_scryfall_sets()
 74 |     
 75 |     assert type(output_sets) == SetDictionary
 76 |     assert len(output_sets.data) > 0
 77 |     
 78 |     check_for_sets(output_sets.data, CHECKED_SETS_SCRYFALL)
 79 | 
 80 | def test_retrieve_17lands_sets_success(limited_sets):
 81 |     output_sets = limited_sets.retrieve_17lands_sets()
 82 |     
 83 |     assert type(output_sets) == SetDictionary
 84 |     assert len(output_sets.data) > 0
 85 |     
 86 |     check_for_sets(output_sets.data, CHECKED_SETS_17LANDS)
 87 | 
 88 | def test_write_sets_file_success(limited_sets):
 89 |     if os.path.exists(SETS_FILE_LOCATION):
 90 |         os.remove(SETS_FILE_LOCATION)
 91 |         assert os.path.exists(SETS_FILE_LOCATION) == False
 92 |     
 93 |     test_data = SetDictionary(data=CHECKED_SETS_COMBINED)
 94 |     
 95 |     result = limited_sets.write_sets_file(test_data)
 96 |     
 97 |     assert result == True
 98 |     assert os.path.exists(SETS_FILE_LOCATION) == True
 99 | 
100 | def test_read_sets_file_success(limited_sets):
101 |     assert os.path.exists(SETS_FILE_LOCATION) == True
102 |     
103 |     output_sets, result = limited_sets.read_sets_file()
104 |     
105 |     assert result == True
106 |     assert type(output_sets) == SetDictionary
107 |     assert len(output_sets.data) > 0
108 |     
109 |     check_for_sets(output_sets.data, CHECKED_SETS_COMBINED)
110 |     
111 | def test_write_sets_file_append_success(limited_sets):
112 |     if os.path.exists(SETS_FILE_LOCATION):
113 |         os.remove(SETS_FILE_LOCATION)
114 |         assert os.path.exists(SETS_FILE_LOCATION) == False
115 |     
116 |     #Remove checked sets
117 |     test_data = SetDictionary(data=CHECKED_SETS_COMBINED)
118 |     del test_data.data["March of the Machine"]
119 |     del test_data.data["Alchemy: The Brothers' War"]
120 |     
121 |     #Add a test set
122 |     for key, value in TEST_SETS.items():
123 |         test_data.data[key] = value
124 |     
125 |     result = limited_sets.write_sets_file(test_data)
126 |     
127 |     assert result == True
128 |     assert os.path.exists(SETS_FILE_LOCATION) == True
129 |     
130 |     output_sets = limited_sets.retrieve_limited_sets()
131 |     
132 |     assert type(output_sets) == SetDictionary
133 |     assert len(output_sets.data) > 0
134 |     
135 |     check_for_sets(output_sets.data, CHECKED_SETS_COMBINED)
136 |     
137 |     #Confirm that the added test sets remain
138 |     check_for_sets(output_sets.data, TEST_SETS)
139 |     
140 | def test_write_sets_file_fail_wrong_type(limited_sets):
141 |     if os.path.exists(SETS_FILE_LOCATION):
142 |         os.remove(SETS_FILE_LOCATION)
143 |         assert os.path.exists(SETS_FILE_LOCATION) == False
144 |                                   
145 |     test_data = {}
146 |     
147 |     result = limited_sets.write_sets_file(test_data)
148 |     
149 |     assert result == False
150 |     assert os.path.exists(SETS_FILE_LOCATION) == False
151 |     
152 | def test_read_sets_file_fail_invalid_fields(limited_sets):
153 |     if os.path.exists(SETS_FILE_LOCATION):
154 |         os.remove(SETS_FILE_LOCATION)
155 |         assert os.path.exists(SETS_FILE_LOCATION) == False
156 |                                   
157 |     test_data = INVALID_SETS
158 |     
159 |     expected_result = SetDictionary()
160 |     
161 |     with open(SETS_FILE_LOCATION, 'w', encoding="utf-8", errors="replace") as file:
162 |         json.dump(test_data, file, ensure_ascii=False, indent=4)
163 | 
164 |     output_sets, result = limited_sets.read_sets_file()
165 |     
166 |     assert result == False
167 |     assert output_sets == expected_result 
168 | 


--------------------------------------------------------------------------------
/src/limited_sets.py:
--------------------------------------------------------------------------------
  1 | import copy
  2 | import datetime
  3 | import json
  4 | import re
  5 | import ssl
  6 | import time
  7 | import os
  8 | import urllib.request
  9 | from typing import Dict, List, Tuple
 10 | from pydantic import BaseModel, Field
 11 | from src import constants
 12 | from src.logger import create_logger
 13 | 
 14 | logger = create_logger()
 15 | 
 16 | 
 17 | class SetInfo(BaseModel):
 18 |     arena: List[str] = Field(default_factory=list)
 19 |     scryfall: List[str] = Field(default_factory=list)
 20 |     seventeenlands: List[str] = Field(default_factory=list)
 21 |     start_date: str = ""
 22 | 
 23 | 
 24 | class SetDictionary(BaseModel):
 25 |     data: Dict[str, SetInfo] = Field(default_factory=dict)
 26 | 
 27 | 
 28 | CUSTOM_SETS = {
 29 |     "dbl": SetInfo(arena=["VOW", "MID"], scryfall=["VOW", "MID"], seventeenlands=["DBL"]),
 30 |     "sir": SetInfo(arena=["SIR", "SIS"], scryfall=["SIR", "SIS"], seventeenlands=["SIR"]),
 31 |     "mat": SetInfo(arena=["MUL", "MOM", "MAT"], scryfall=["MUL", "MOM", "MAT"], seventeenlands=["MAT"]),
 32 | }
 33 | 
 34 | TOTAL_SCRYFALL_SETS = 50
 35 | SET_ARENA_CUBE_START_OFFSET_DAYS = -25
 36 | TEMP_LIMITED_SETS = os.path.join("Temp", "temp_set_list.json")
 37 | 
 38 | 
 39 | def shift_date(start_date, shifted_days, string_format, next_dow=None):
 40 |     '''Shifts a date by a certain number of days'''
 41 |     shifted_date_string = ""
 42 |     shifted_date = datetime.date.min
 43 |     try:
 44 |         shifted_date = start_date + datetime.timedelta(days=shifted_days)
 45 | 
 46 |         if next_dow and (0 <= next_dow <= 6):
 47 |             # Shift the date to the next specified day of the week (0 = Monday, 6 = Sunday)
 48 |             shifted_date += datetime.timedelta(
 49 |                 (next_dow - shifted_date.weekday()) % 7)
 50 | 
 51 |         shifted_date_string = shifted_date.strftime(
 52 |             string_format) if string_format else ""
 53 | 
 54 |     except Exception as error:
 55 |         logger.error(error)
 56 | 
 57 |     return shifted_date, shifted_date_string
 58 | 
 59 | 
 60 | class LimitedSets:
 61 |     def __init__(self, sets_file_location: str = TEMP_LIMITED_SETS):
 62 |         self.sets_file_location: str = sets_file_location
 63 |         self.limited_sets: SetDictionary()
 64 |         self.sets_scryfall = SetDictionary()
 65 |         self.sets_17lands = SetDictionary()
 66 |         self.context: ssl.SSLContext = ssl.SSLContext()
 67 | 
 68 |     def retrieve_limited_sets(self) -> SetDictionary:
 69 |         '''Retrieve a list of sets from 17Lands and Scryfall
 70 | 
 71 |             Set fields
 72 |            . "arena" : The codes for the sets retrieved from the temp_card_data.json.
 73 |                - This is the primary way that this application builds the card dataset
 74 |                - Key word "ALL" can be used (e.g., "arena" : ["ALL"]) if all Arena cards are required (e.g., if you're builing a cube dataset)
 75 |            . "scryfall" : The codes for the sets retrieved using the scryfall API
 76 |                - Example: https://api.scryfall.com/cards/search?order=set&unique=prints&q=e%3AMID
 77 |                - This is the secondary way that this application builds the card dataset, in the event that there's an issue temp_card_data.json
 78 |                - It's not feasible to download data for every card listed on Scryfall so the all keyword can't be used with this field
 79 |            . "17Lands" : The code for the data listed on the https://www.17lands.com/card_ratings page
 80 |                - The dataset file name uses the set code from this field (e.g., MAT_PremierDraft_Data.json)
 81 |                - When searching the Arena player log, the application uses this set code to link the event set to the card dataset
 82 |                    - Examples:
 83 |                         - CubeDraft_Arena_20220812 -> CUBE_PremierDraft_Data.json
 84 |                         - PremierDraft_BRO_20221115 -> BRO_PremierDraft_Data.json
 85 |         '''
 86 |         self.limited_sets = SetDictionary()
 87 | 
 88 |         self.retrieve_17lands_sets()
 89 |         self.retrieve_scryfall_sets()
 90 | 
 91 |         self.__assemble_limited_sets()
 92 | 
 93 |         return self.limited_sets
 94 | 
 95 |     def retrieve_scryfall_sets(self, retries: int = 3, wait: int = 5) -> SetDictionary:
 96 |         '''Retrieve a list of Magic sets using the Scryfall API'''
 97 |         self.sets_scryfall = SetDictionary()
 98 | 
 99 |         while retries:
100 |             try:
101 |                 url = "https://api.scryfall.com/sets"
102 |                 url_data = urllib.request.urlopen(
103 |                     url, context=self.context).read()
104 |                 set_json_data = json.loads(url_data)
105 | 
106 |                 self.__process_scryfall_sets(set_json_data["data"])
107 | 
108 |                 while set_json_data["has_more"]:
109 |                     url = set_json_data["next_page"]
110 |                     url_data = urllib.request.urlopen(
111 |                         url, context=self.context).read()
112 |                     set_json_data = json.loads(url_data)
113 |                     self.__process_scryfall_sets(set_json_data["data"])
114 | 
115 |                 break
116 | 
117 |             except Exception as error:
118 |                 logger.error(error)
119 | 
120 |             retries -= 1
121 | 
122 |             if retries:
123 |                 time.sleep(wait)
124 | 
125 |         return self.sets_scryfall
126 | 
127 |     def retrieve_17lands_sets(self, retries: int = 3, wait: int = 5) -> SetDictionary:
128 |         '''Retrieve the list of sets that are supported by 17Lands'''
129 |         self.sets_17lands = SetDictionary()
130 |         while retries:
131 |             try:
132 |                 url = "https://www.17lands.com/data/filters"
133 |                 url_data = urllib.request.urlopen(
134 |                     url, context=self.context).read()
135 |                 set_json_data = json.loads(url_data)
136 | 
137 |                 self.__process_17lands_sets(set_json_data)
138 |                 break
139 | 
140 |             except Exception as error:
141 |                 logger.error(error)
142 | 
143 |             retries -= 1
144 | 
145 |             if retries:
146 |                 time.sleep(wait)
147 | 
148 |         return self.sets_17lands
149 | 
150 |     def read_sets_file(self) -> Tuple[SetDictionary, bool]:
151 |         '''Read the sets file and build the sets object'''
152 |         self.limited_sets = SetDictionary()
153 |         success = False
154 |         try:
155 |             with open(self.sets_file_location, 'r', encoding="utf-8", errors="replace") as json_file:
156 |                 json_data = json.loads(json_file.read())
157 | 
158 |             sets_object = SetDictionary.parse_obj(json_data)
159 | 
160 |             if not sets_object.data:
161 |                 return self.limited_sets, success
162 | 
163 |             sets_to_remove = []
164 |             for set_name, set_info in sets_object.data.items():
165 |                 self.limited_sets.data[set_name] = set_info
166 |                 set_code = set_info.seventeenlands[0]
167 |                 if set_code in self.sets_17lands.data:
168 |                     sets_to_remove.append(set_code)
169 | 
170 |             for set_code in sets_to_remove:
171 |                 del self.sets_17lands.data[set_code]
172 | 
173 |             success = True
174 |         except (FileNotFoundError, json.JSONDecodeError) as error:
175 |             logger.error(error)
176 | 
177 |         return self.limited_sets, success
178 | 
179 |     def write_sets_file(self, sets_object: SetDictionary) -> bool:
180 |         '''Write the sets object data to a local file'''
181 |         success = False
182 |         try:
183 |             if type(sets_object) != SetDictionary:
184 |                 raise TypeError("sets_object must be of type SetDictionary")
185 | 
186 |             # Create the directory if it's missing
187 |             os.makedirs(os.path.dirname(
188 |                 self.sets_file_location), exist_ok=True)
189 | 
190 |             with open(self.sets_file_location, 'w', encoding="utf-8", errors="replace") as file:
191 |                 json.dump(sets_object.dict(), file,
192 |                           ensure_ascii=False, indent=4)
193 | 
194 |             success = True
195 |         except (FileNotFoundError, TypeError, OSError) as error:
196 |             logger.error(error)
197 | 
198 |         return success
199 | 
200 |     def __assemble_limited_sets(self) -> None:
201 |         '''Retrieve a stored set dataset and append any missing set that are listed on 17Lands'''
202 | 
203 |         # Retrieve a stored sets dataset from the Temp folder
204 |         self.limited_sets, _ = self.read_sets_file()
205 | 
206 |         if self.sets_17lands:
207 |             # Add any missing sets to the dataset
208 |             self.limited_sets = self.__append_limited_sets()
209 | 
210 |             # store the modified dataset in the Temp folder
211 |             self.write_sets_file(self.limited_sets)
212 | 
213 |         return
214 | 
215 |     def __append_limited_sets(self) -> SetDictionary:
216 |         '''Create a list of sets using lists collected from 17Lands and Scryfall'''
217 |         temp_dict = SetDictionary()
218 |         if self.sets_scryfall.data and self.sets_17lands.data:
219 |             set_codes_to_remove = []
220 |             # If the application is able to collect the set list from Scryfall and 17Lands, then it will use the 17Lands list to filter the Scryfall list
221 |             for code in self.sets_17lands.data:
222 |                 for set_name, set_fields in self.sets_scryfall.data.items():
223 |                     set_code = set_fields.seventeenlands[0]
224 |                     if set_code == code:
225 |                         temp_dict.data[set_name] = set_fields
226 |                         set_codes_to_remove.append(code)
227 |                         break
228 | 
229 |             # Remove the set codes from self.sets_17lands
230 |             for code in set_codes_to_remove:
231 |                 del self.sets_17lands.data[code]
232 | 
233 |         # Insert any 17Lands sets that were not collected from Scryfall
234 |         temp_dict.data.update(self.sets_17lands.data)
235 |         temp_dict.data.update(self.limited_sets.data)
236 | 
237 |         return temp_dict
238 | 
239 |     def __process_17lands_sets(self, data: dict):
240 |         '''Parse json data from the 17lands filters page'''
241 |         try:
242 |             for card_set in data["expansions"]:
243 |                 self.sets_17lands.data[card_set.upper()] = SetInfo(arena=[constants.SET_SELECTION_ALL],
244 |                                                                    scryfall=[],
245 |                                                                    seventeenlands=[card_set.upper()])
246 |             for card_set, date_string in data["start_dates"].items():
247 |                 if card_set.upper() in self.sets_17lands.data:
248 |                     self.sets_17lands.data[card_set.upper()].start_date = date_string.split('T')[
249 |                         0]
250 | 
251 |         except Exception as error:
252 |             logger.error(error)
253 | 
254 |         return
255 | 
256 |     def __process_scryfall_sets(self, data: Dict):
257 |         '''Parse the Scryfall set list data to extract information for sets that are supported by Arena
258 |            - Scryfall lists all Magic sets (paper and digital), so the application needs to filter out non-Arena sets
259 |            - The application will only display sets that have been released
260 | 
261 |            This process links the bonus sheets to the main sets by checking for a "parent_set_code" field and linking the set to its parent.
262 |            - Examples:
263 |               - "mul" is linked to "mom" because "mul" has a "parent_set_code" of "mom"
264 |               - "sis" isn't linked to "sir" because "sis" doens't have a "parent_set_code"
265 |            - If the set has linked sets that can't be identified using the process above, then they need to be added to the CUSTOM_SETS dictionary
266 |         '''
267 |         counter = len(self.sets_scryfall.data)
268 |         side_sets = {}
269 |         for card_set in data:
270 |             try:
271 | 
272 |                 set_name = card_set["name"]
273 |                 set_code = card_set["code"]
274 | 
275 |                 if set_code in CUSTOM_SETS:
276 |                     # Only retrieve the last X sets + CUBE
277 |                     if counter >= TOTAL_SCRYFALL_SETS:
278 |                         break
279 |                     counter += 1
280 |                     self.sets_scryfall.data[set_name] = copy.deepcopy(
281 |                         CUSTOM_SETS[set_code])
282 |                 elif card_set["set_type"] in constants.SUPPORTED_SET_TYPES:
283 |                     # Only retrieve the last X sets + CUBE
284 |                     if counter >= TOTAL_SCRYFALL_SETS:
285 |                         break
286 |                     if card_set["set_type"] == constants.SET_TYPE_ALCHEMY:
287 |                         self.sets_scryfall.data[set_name] = self.__process_scryfall_sets_alchemy(
288 |                             set_code, card_set)
289 |                     elif (card_set["set_type"] == constants.SET_TYPE_MASTERS) and (not card_set["digital"]):
290 |                         continue
291 |                     else:
292 |                         self.sets_scryfall.data[set_name] = SetInfo(
293 |                             arena=[set_code.upper()],
294 |                             scryfall=[set_code.upper()],
295 |                             seventeenlands=[set_code.upper()]
296 |                         )
297 |                     counter += 1
298 |                 elif (card_set["set_type"] == constants.SET_TYPE_MASTERPIECE and
299 |                       "parent_set_code" in card_set):
300 |                     # Add the supplementary sets (i.e., mystic archives, retro artifacts)
301 |                     parent_code = card_set["parent_set_code"].upper()
302 |                     if parent_code in side_sets:
303 |                         side_sets[parent_code].append(set_code.upper())
304 |                     else:
305 |                         side_sets[parent_code] = [set_code.upper()]
306 | 
307 |             except Exception as error:
308 |                 logger.error(error)
309 | 
310 |         # Add side sets
311 |         for card_sets in self.sets_scryfall.data.values():
312 |             try:
313 |                 card_set = card_sets.arena[0]
314 |                 if card_set in side_sets:
315 |                     card_sets.arena.extend(side_sets[card_set])
316 |                     card_sets.scryfall.extend(side_sets[card_set])
317 |             except Exception:
318 |                 pass
319 | 
320 |         # Insert the cube set
321 |         self.sets_scryfall.data["Arena Cube"] = SetInfo(
322 |             arena=[constants.SET_SELECTION_ALL],
323 |             scryfall=[],
324 |             seventeenlands=["CUBE"],
325 |             start_date=shift_date(
326 |                 datetime.date.today(), SET_ARENA_CUBE_START_OFFSET_DAYS, "%Y-%m-%d")[1]
327 |         )
328 | 
329 |         return
330 | 
331 |     def __process_scryfall_sets_alchemy(self, set_code: str, data: Dict) -> SetInfo:
332 |         '''Process Scryfall sets for Alchemy specific information'''
333 |         set_entry = SetInfo()
334 |         if ("parent_set_code" in data) and ("block_code" in data):
335 |             set_entry.arena = [data["parent_set_code"].upper()]
336 |             set_entry.scryfall = [
337 |                 set_code.upper(), data["parent_set_code"].upper()]
338 |             set_entry.seventeenlands = [
339 |                 f"{data['block_code'].upper()}{data['parent_set_code'].upper()}"]
340 | 
341 |         elif ("block_code" in data) and (re.findall(r"^[yY]\d{2}$", data["block_code"], re.DOTALL)):
342 |             parent_code = re.findall(
343 |                 r"^[yY](\w{3})$", set_code, re.DOTALL)
344 | 
345 |             if parent_code:
346 |                 set_entry.arena = [parent_code[0].upper()]
347 |                 set_entry.seventeenlands = [
348 |                     f"{data['block_code'].upper()}{parent_code[0].upper()}"]
349 |                 set_entry.scryfall = [set_code.upper(), parent_code[0].upper()]
350 | 
351 |             else:
352 |                 set_entry = SetInfo(
353 |                     arena=[set_code.upper()],
354 |                     scryfall=[set_code.upper()],
355 |                     seventeenlands=[set_code.upper()]
356 |                 )
357 |         else:
358 |             set_entry = SetInfo(
359 |                 arena=[set_code.upper()],
360 |                 scryfall=[set_code.upper()],
361 |                 seventeenlands=[set_code.upper()]
362 |             )
363 |         return set_entry
364 | 


--------------------------------------------------------------------------------
/release_notes.txt:
--------------------------------------------------------------------------------
  1 | ===================== RELEASE NOTES 3.10 =====================
  2 | * Application updates will no longer reset the settings
  3 | * The visibility of the Current Draft display, Deck Source options, Deck filter options, and Refresh button can now be toggled in the settings menu
  4 | * Columns 2-7 are now fully configurable
  5 | * Table columns can no longer be resized manually
  6 | * Opening duplicate windows is no longer possible
  7 | * Colorless cards now have their own row color
  8 | * Fixed a bug that caused incorrect row colors with the color identity setting
  9 | * Fixed a seald card pool duplication bug
 10 | * Added an About window (Help->About) that has links to Github and 17Lands
 11 | * The Taken Cards window will automatically open when a sealed event is detected
 12 | * Replaced the "Powered by 17Lands" label with a label displaying the Github project name
 13 | * Modified the debug log entries
 14 | * Adjusting the grades so that the mean is now a weak C+ instead of a C
 15 | 
 16 | ===================== RELEASE NOTES 3.09 =====================
 17 | * Bug Fix: Fixed a Scryfall data parsing affected double-sided cards (Issue #30)
 18 | 
 19 | * Modifications: 
 20 | ** Linked the MOM and MUL sets to the MAT set (Issue #31)
 21 | ** Updated the sort order of identifiable sets in the set list to match 17Lands (MAT will be listed after MOM)
 22 | ** Improved troubleshooting by displaying the Arena ID for unidentified cards
 23 | 
 24 | * New Feature: Added the ability to create a temporary set list file at ./Temp/temp_set_list.json for filling in missing sets
 25 | 
 26 | ===================== RELEASE NOTES 3.08 =====================
 27 | * Bug Fix: Fixed a Chrome extension issue that was preventing users from downloading their own tier lists while logged in to 17Lands (Issue #28)
 28 | 
 29 | * Modifications:
 30 | ** Added retries to the set list download process
 31 | ** Users can now set the Arena log path through File->Open instead of using the -f CLI argument
 32 | ** The application will now store the Arena log path in the config.json file
 33 | ** Renamed the Chrome extension to "17Lands Tier Scraper"
 34 | 
 35 | * New Feature: The Chrome extension will now download the tier list comments
 36 | ** The comments are listed at the bottom of the card tooltip
 37 | ** An asterisk next to the tier list grade will denote a card comment (*C+)
 38 | 
 39 | ===================== RELEASE NOTES 3.07 =====================
 40 | * Bug Fix: Fixing an Arena database parsing issue
 41 | * Modified Feature: Linking the Shadows of the Past set to the Shadows over Innistrad Remastered set
 42 | * Modified Feature: Making some adjustments to the UI elements
 43 | 
 44 | ===================== RELEASE NOTES 3.06 =====================
 45 | * Bug Fixes:
 46 | ** Some of the meld cards were missing from the BRO set
 47 | ** Opening the Deck Suggester would freeze the application if the user had a diverse card pool
 48 | ** The CMC was calculated incorrectly for some of the BRO artifact creatures
 49 | 
 50 | * Modified Feature: Modified the auto filter logic
 51 | 
 52 | ===================== RELEASE NOTES 3.05 =====================
 53 | * Bug Fix: Removing problematic sections from the TierScraper17Lands manifest
 54 | 
 55 | * Modified Feature: For all of the tables, the application will now retain the table sort order between picks and UI changes (enhancement #19)
 56 | 
 57 | * Modified Feature: The application will now synchronize the Scryfall set list with the 17Lands set list
 58 | 
 59 | * Modified Feature: Changed Games Not Drawn Win Rate to Games Not Seen Win Rate
 60 | ===================== RELEASE NOTES 3.04 =====================
 61 | * Bug Fixes:
 62 | ** Fixing the application auto-update feature - users will need to re-download the executable
 63 | ** Fixing the DMU/Y23DMU set download issues by adding support for the local Arena files that were modified in a recent Arena update
 64 | ** Modifying the Scryfall API processing logic (backup)
 65 | ** Fixing an image display issue with the card tooltips
 66 | 
 67 | * New Feature: Added a UI Size setting in the settings menu
 68 | 
 69 | ===================== RELEASE NOTES 3.03 =====================
 70 | * Bug Fix: The application will use the UTF-8 codec when reading the Arena player.log file (Issue #17)
 71 | 
 72 | * Bug Fix: Made some changes to address some text color and scaling issues (Issue #15)
 73 | ** The dark mode theme is disabled for Mac users
 74 | ** The config.json file has a scale_factor field that can be used to scale the application
 75 | 
 76 | * Data Update: Added Games Drawn Win Rate and Number of Games Drawn data
 77 | 
 78 | * Modified Feature: The application will now set the row colors based on a card's mana cost, ignoring kicker and ability costs (Issue #16)
 79 | 
 80 | * Modified Feature: The Auto filter is now capable of identifying decks with 3-colors
 81 | 
 82 | * New Feature: The new Enable Color Identity setting can be used to toggle a card's listed colors
 83 | ** Enabling the setting will display a card's mana cost AND ability/kicker costs
 84 | 
 85 | * New Feature: The Taken Cards window now has card-type filters (i.e., Creature, Lands, Instants/Sorceries, and Other)
 86 | 
 87 | ===================== RELEASE NOTES 3.02 =====================
 88 | * Data Update: Added support for the Arena Cube
 89 | ** The set option is located at the bottom of the set list
 90 | 
 91 | * New Feature: Added card grades (see the Win Rate Grades section of the README)
 92 | 
 93 | * New Feature: Chrome extension now adds a label text box to the tier list page
 94 | 
 95 | * Modified Feature: Modified the card rating calculation (see the Win Rate Ratings section of the README)
 96 | 
 97 | * Modified Feature: The set list will no longer contain unreleased sets
 98 | ** The application will automatically list a set once it's released
 99 | 
100 | * Modified Feature: Tier list data will now be displayed as grades
101 | 
102 | * Modified Features: Removed/disabled the curve and color bonuses
103 | ** These features will be readded once they are modified to function with the new ratings/grades/win rate options
104 | 
105 | * UI Updates:
106 | ** The tooltips will no longer appear outside of the bounds of the screen
107 | ** The Set Data window will now display the status during the build process
108 | ** Fixed various table formatting issues
109 | 
110 | ===================== RELEASE NOTES 3.01 =====================
111 | * Bug Fix: The application can now re-detect an active draft if Arena is closed mid-draft (Issue #13)
112 | 
113 | * Bug Fix: The Copy to Clipboard buttons will now work with Arena and Sealeddeck.tech
114 | 
115 | * Data Update: The application now supports the remastered Amonkhet and Kaladesh sets
116 | 
117 | * Data Update: The application will now collect all of the fields listed on the www.17lands.com/card_ratings page (excluding rarity,# Seen, and #Picked)
118 | 
119 | * UI Updates: 
120 | ** The application is now using a dark mode theme
121 | ** The tooltip has been reworked to better display the card data
122 | ** The row colors can now be toggled using the Enable Card Colors setting (default: disabled)
123 | ** The Taken table layout has been reworked
124 | ** The ratings feature can now be toggled using the Win Rate Format setting (default: percentage)
125 | ** Three configurable columns have been added (default: disabled)
126 | ** The Deck Filter drop-down has been detached from the column drop-downs and now sets the filter value for all of the fields in a table (no more All GIHWR or All ALSA)
127 | ** Tables can be sorted by clicking on the column header
128 | 
129 | 
130 | ===================== RELEASE NOTES 2.96 =====================
131 | * Bug Fix: The application will now support back-to-back drafts
132 | 
133 | * Modified Feature: The application can now parse the reformatted card files that were modified in a recent Arena update
134 | ** The application can now build data sets using local files instead of Scryfall data
135 | 
136 | ===================== RELEASE NOTES 2.95 =====================
137 | * Bug Fix: The application can now read tier list files created using the Chrome extension (Issue #12)
138 | ** The downloaded tier lists need to be placed in the new Tier folder
139 | 
140 | * Bug Fix: The deck suggester will now correctly calculate the deck ratings
141 | 
142 | * New Feature: Added support for multiple tier lists per set (Issue #12)
143 | ** Tier lists will appear as Tier# (<Label>) in the drop-downs (i.e., Tier0 (Test), Tier1 (HBG), etc.).
144 | 
145 | * Modified Feature: The tier scraper extension will now automatically populate the Set and Label fields with data collected from the tier list page
146 | ** Follow the revised steps in ./Tools/TierScraper17Lands/README.txt
147 | 
148 | * Documentation Change: Added a Tier List Ratings note to the Card Logic section of the README
149 | 
150 | ===================== RELEASE NOTES 2.91 =====================
151 | * New Feature: For the filter drop-downs, users can use the Deck Filter Format setting to switch between the color combinations (i.e., UB, BG, WUG, etc.) and the guild/shard/clan names (i.e., Dimir, Golgari, Bant, etc.)
152 | 
153 | * Modified Feature: The application will store the card localization data in a temp file to speed up the set download process
154 | 
155 | * Modified Feature: The card tooltips will no longer list the names of the other card sides
156 | ** The tooltip will display all of the images for double-sided cards, but not for Specialize cards 
157 | 
158 | * Bug Fix: The application will no longer list the Crimson Vow set as Double Feature
159 | 
160 | * Documentation Change: Added a Card Ratings note to the Card Logic section of the README. This note summarizes how the card ratings are calculated
161 | 
162 | ===================== RELEASE NOTES 2.87 =====================
163 | * New Feature: Added support for Alchemy drafts
164 | ** Alchemy sets added to the set drop-down in the Set Data window.
165 | ** The Alchemy drafts will be listed as Y##<base set> (e.g. Y22SNC).
166 | ** For Alchemy drafts, the application will list the Alchemy data sets, denoted by a [Y##] prefix, and the base data sets.
167 | 
168 | ===================== RELEASE NOTES 2.86 =====================
169 | * Modified Feature: The application will now build data sets that include alternate card art, Alchemy cards, and cards with Alchemy revisions.
170 | ** The tooltips for the alternate art cards will display the original card art.
171 | 
172 | * Modified Feature: Added support for non-standard drafts (draft events, competitions, etc.)
173 | ** The application will parse all non-standard drafts as premier drafts, excluding the MWM bot draft.
174 | 
175 | * Modified Feature: The application will primarily build data sets using local files instead of Scryfall.
176 | ** Scryfall will be used as a backup in case there is an issue with the local files.
177 | 
178 | * UI Change: Added a window to remind users that 17Lands only updates their card data once a day.
179 | 
180 | ===================== RELEASE NOTES 2.85 =====================
181 | * Bug Fix: The downloaded sets will now be visible in the Set Data window
182 | 
183 | * Bug Fix: The Bayesian average feature will now work with the "ALL GIHWR" filter
184 | 
185 | * Modified Feature: Debug logs will now use UTC timestamps
186 | 
187 | * Modified Feature: Disabling the Draft Log by default
188 | 
189 | ===================== RELEASE NOTES 2.84 =====================
190 | * New Feature: Data Source drop-down for selecting data set (i.e. Premier, Quick, Sealed, etc.)
191 | 
192 | * New Feature: Enable/Disable draft log (Settings menu option)
193 | 
194 | * New Feature: Enable/Disable Bayesian average (Settings menu option)
195 | 
196 | * New Feature: Data set now includes Number of Games In Hand (GIH) * visible in card tooltip
197 | 
198 | * Modified Feature: The file search logic will now search multiple drives (Issue #7)
199 | 
200 | * UI Changes:
201 | ** Settings menu option taken out of Data drop-down
202 | ** Application is no longer resizable 
203 | 
204 | * File Changes: 
205 | ** Sets will now be stored in the Sets folder
206 | ** Debug logs will be stored in the Debug folder
207 | 
208 | ===================== RELEASE NOTES 2.83 =====================
209 | * New Feature: If Scryfall doesn't have the card Arena IDs, then the tool will retrieve the IDs from local Arena files
210 | 
211 | * Modified Feature: The tool will fill out incomplete data sets from 17Lands (Issue #6)
212 | 
213 | * Modified Feature: Scrollbar added to Set Data window
214 | 
215 | ===================== RELEASE NOTES 2.82 =====================
216 | * New Feature: Using Bayesian average for small data sets
217 | 
218 | * New Feature: Added support for sealed (BO1) and traditional sealed (BO3)
219 | 
220 | * Modified Feature: Disabling the color bonus and curve bonus by default
221 | 
222 | * Note: When downloading the Streets of New Capenna set, use ID 80152 for the first couple of weeks
223 | 
224 | ===================== RELEASE NOTES 2.81 =====================
225 | * Modified Feature: Auto Highest Rated * the auto filter will now display the highest rated pick rating of the two leading color pairs
226 | ** Replaces the questionably useful Auto Averaging feature that averaged the ratings of the two leading color pairs
227 | ** Addresses an issue where highly rated cards that matched one color pair were listed below mediocre cards that matched the pivot color
228 |     
229 | * New UI Feature: Data Source Field * there is now a data source field on the main window that lists the source of the card data (i.e. QuickDraft, PremierDraft, TradDraft data files)
230 | ** If the user is playing a NEO premier draft, then the application will pull data from NEO_PremierDraft_Data.json and list "PremierDraft" as the data source
231 | 
232 | * New Feature: Data file verification * the application will check to see if the data file (e.g. NEO_PremierDraft_Data.json) is structuraly valid.
233 | ** If a file isn't valid, then it won't be listed in the Set Data window
234 | 
235 | ===================== RELEASE NOTES 2.80 =====================
236 | * New Feature: Auto Averaging * see the card logic and settings sections of the README
237 | 
238 | * New Feature: Color Bonus * see the card logic and settings sections of the README
239 | 
240 | * New Feature: Curve Bonus * see the card logic and settings sections of the README
241 | 
242 | * Modified Feature: Moved the 17Lands notice information to the main window
243 | 
244 | * Modified Feature: Changed the minimize/maximize hotkey from Ctrl+F to Ctrl+G and added a note to the main window
245 | 
246 | * Bug Fixes:
247 | ** The auto filter logic has been reworked (Issue #3) * see the card logic section of the README
248 | ** The tool will no longer fail to calculate pick ratings due to incomplete 17Lands data (Issue#2 a continuation of Issue#1)
249 | ** The tool will not generate an extra log file while drafting
250 | 
251 | ===================== RELEASE NOTES 2.73 =====================
252 | * New Feature: Added settings options for hiding the missing cards and deck stats tables
253 | 
254 | * New Feature: Settings will be saved between restarts
255 | 
256 | * Modified Feature: After pick 15, the auto filter will now remain at "All Decks" until there's a clear leading color pair
257 | 
258 | * Bug Fixes:
259 | ** Clicking on the reset config drop-down option will no longer prevent the deck suggester from working
260 | ** * Reset config has been replaced with a default settings button in the settings window
261 | ** Picking basic lands will no longer prevent the deck suggester from suggesting decks with non-basic lands
262 | ** Picking basic lands will no longer prevent the taken cards window from listing all of the taken cards
263 | ** Incomplete 17Lands data will no longer result in inaccurate pick ratings (Issue #1) 
264 | 
265 | ===================== RELEASE NOTES 2.72 =====================
266 | 
267 | * Modified Feature: Added input checks and retry logic to the download set process
268 | 
269 | * Bug Fix: The application now supports the Kamigawa traditional draft
270 | 
271 | * Note: When downloading the Kamigawa set, ID 79418 is no longer required (use the default 0)
272 | 
273 | ===================== RELEASE NOTES 2.71 =====================
274 | 
275 | * New Feature: Added support for MWM bot draft
276 | 
277 | * Bug Fix: Restarting is no longer required when playing consecutive drafts
278 | 
279 | 
280 | ===================== RELEASE NOTES 2.70 =====================
281 | 
282 | * New Feature: Tier List 
283 | ** Follow the instructions in Tools/TierScraper17Lands/README.txt
284 | ** Added a Tier drop-down option to the filters
285 | ** Downloading the set is still required
286 | 
287 | * UI Change: Added 17Lands startup and embargo notices so that the application is compliant with the 17Lands usage guidelines (https://www.17lands.com/usage_guidelines)
288 | 
289 | * Feature Note: Use ID 79418 when downloading the Kamigawa: Neon Dynasty set
290 | 
291 | * Bug Fix: The application will no longer generate excessive log entries after a quick draft has ended
292 | 
293 | * Bug Fix: The application will no longer get stuck if the draft includes basic lands


--------------------------------------------------------------------------------
/src/constants.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import getpass
  3 | 
  4 | FONT_SANS_SERIF = "Arial"
  5 | FONT_MONO_SPACE = "Courier"
  6 | 
  7 | BASIC_LANDS = ["Island", "Mountain", "Swamp", "Plains", "Forest"]
  8 | 
  9 | CARD_COLOR_SYMBOL_WHITE = "W"
 10 | CARD_COLOR_SYMBOL_BLACK = "B"
 11 | CARD_COLOR_SYMBOL_BLUE = "U"
 12 | CARD_COLOR_SYMBOL_RED = "R"
 13 | CARD_COLOR_SYMBOL_GREEN = "G"
 14 | CARD_COLOR_SYMBOL_NONE = "NC"
 15 | 
 16 | CARD_COLORS = [
 17 |     CARD_COLOR_SYMBOL_WHITE,
 18 |     CARD_COLOR_SYMBOL_BLACK,
 19 |     CARD_COLOR_SYMBOL_BLUE,
 20 |     CARD_COLOR_SYMBOL_RED,
 21 |     CARD_COLOR_SYMBOL_GREEN
 22 | ]
 23 | 
 24 | CARD_COLOR_LABEL_WHITE = "White"
 25 | CARD_COLOR_LABEL_BLACK = "Black"
 26 | CARD_COLOR_LABEL_BLUE = "Blue"
 27 | CARD_COLOR_LABEL_RED = "Red"
 28 | CARD_COLOR_LABEL_GREEN = "Green"
 29 | CARD_COLOR_LABEL_NC = "NC"
 30 | 
 31 | LIMITED_TYPE_UNKNOWN = 0
 32 | LIMITED_TYPE_DRAFT_PREMIER_V1 = 1
 33 | LIMITED_TYPE_DRAFT_PREMIER_V2 = 2
 34 | LIMITED_TYPE_DRAFT_QUICK = 3
 35 | LIMITED_TYPE_DRAFT_TRADITIONAL = 4
 36 | LIMITED_TYPE_SEALED = 5
 37 | LIMITED_TYPE_SEALED_TRADITIONAL = 6
 38 | 
 39 | URL_17LANDS = "https://www.17lands.com"
 40 | 
 41 | IMAGE_17LANDS_SITE_PREFIX = "/static/images/"
 42 | 
 43 | DATA_FIELD_17LANDS_OHWR = "opening_hand_win_rate"
 44 | DATA_FIELD_17LANDS_NGOH = "opening_hand_game_count"
 45 | DATA_FIELD_17LANDS_GPWR = "win_rate"
 46 | DATA_FIELD_17LANDS_NGP = "game_count"
 47 | DATA_FIELD_17LANDS_GIHWR = "ever_drawn_win_rate"
 48 | DATA_FIELD_17LANDS_IWD = "drawn_improvement_win_rate"
 49 | DATA_FIELD_17LANDS_ALSA = "avg_seen"
 50 | DATA_FIELD_17LANDS_GIH = "ever_drawn_game_count"
 51 | DATA_FIELD_17LANDS_ATA = "avg_pick"
 52 | DATA_FIELD_17LANDS_NGND = "never_drawn_game_count"
 53 | DATA_FIELD_17LANDS_GNSWR = "never_drawn_win_rate"
 54 | DATA_FIELD_17LANDS_GDWR = "drawn_win_rate"
 55 | DATA_FIELD_17LANDS_NGD = "drawn_game_count"
 56 | DATA_FIELD_17LANDS_IMAGE = "url"
 57 | DATA_FIELD_17LANDS_IMAGE_BACK = "url_back"
 58 | 
 59 | 
 60 | DATA_FIELD_GIHWR = "gihwr"
 61 | DATA_FIELD_OHWR = "ohwr"
 62 | DATA_FIELD_GPWR = "gpwr"
 63 | DATA_FIELD_ALSA = "alsa"
 64 | DATA_FIELD_IWD = "iwd"
 65 | DATA_FIELD_ATA = "ata"
 66 | DATA_FIELD_NGP = "ngp"
 67 | DATA_FIELD_NGOH = "ngoh"
 68 | DATA_FIELD_GIH = "gih"
 69 | DATA_FIELD_GNSWR = "gnswr"
 70 | DATA_FIELD_NGND = "ngnd"
 71 | DATA_FIELD_GDWR = "gdwr"
 72 | DATA_FIELD_NGD = "ngd"
 73 | DATA_FIELD_WHEEL = "wheel"
 74 | 
 75 | DATA_SECTION_IMAGES = "image"
 76 | DATA_SECTION_RATINGS = "ratings"
 77 | 
 78 | DATA_FIELD_CMC = "cmc"
 79 | DATA_FIELD_COLORS = "colors"
 80 | DATA_FIELD_NAME = "name"
 81 | DATA_FIELD_TYPES = "types"
 82 | DATA_FIELD_DECK_COLORS = "deck_colors"
 83 | DATA_FIELD_COUNT = "count"
 84 | DATA_FIELD_DISABLED = "disabled"
 85 | DATA_FIELD_RARITY = "rarity"
 86 | DATA_FIELD_MANA_COST = "mana_cost"
 87 | 
 88 | DATA_FIELDS_LIST = [DATA_FIELD_GIHWR,
 89 |                     DATA_FIELD_OHWR,
 90 |                     DATA_FIELD_GPWR,
 91 |                     DATA_FIELD_GNSWR,
 92 |                     DATA_FIELD_ALSA,
 93 |                     DATA_FIELD_ATA,
 94 |                     DATA_FIELD_IWD,
 95 |                     DATA_FIELD_NGP,
 96 |                     DATA_FIELD_NGOH,
 97 |                     DATA_FIELD_GIH,
 98 |                     DATA_FIELD_NGND,
 99 |                     DATA_FIELD_GDWR,
100 |                     DATA_FIELD_NGD]
101 | 
102 | DATA_SET_FIELDS = [DATA_FIELD_GIHWR,
103 |                    DATA_FIELD_OHWR,
104 |                    DATA_FIELD_GPWR,
105 |                    DATA_FIELD_ALSA,
106 |                    DATA_FIELD_IWD,
107 |                    DATA_FIELD_CMC,
108 |                    DATA_FIELD_COLORS,
109 |                    DATA_FIELD_NAME,
110 |                    DATA_FIELD_TYPES,
111 |                    DATA_FIELD_MANA_COST,
112 |                    DATA_SECTION_IMAGES,
113 |                    DATA_FIELD_DECK_COLORS]
114 | 
115 | FILTER_OPTION_ALL_DECKS = "All Decks"
116 | FILTER_OPTION_AUTO = "Auto"
117 | FILTER_OPTION_TIER = "TIER"
118 | 
119 | FIELD_LABEL_ATA = "ATA: Average Taken At"
120 | FIELD_LABEL_ALSA = "ALSA: Average Last Seen At"
121 | FIELD_LABEL_IWD = "IWD: Improvement When Drawn"
122 | FIELD_LABEL_OHWR = "OHWR: Opening Hand Win Rate"
123 | FIELD_LABEL_GPWR = "GPWR: Games Played Win Rate"
124 | FIELD_LABEL_GIHWR = "GIHWR: Games In Hand Win Rate"
125 | FIELD_LABEL_GNSWR = "GNSWR: Games Not Seen Win Rate"
126 | FIELD_LABEL_COLORS = "COLORS: Card Colors"
127 | FIELD_LABEL_DISABLED = "DISABLED: Remove Column"
128 | FIELD_LABEL_COUNT = "COUNT: Total Card Count"
129 | FIELD_LABEL_WHEEL = "WHEEL: Probability of Wheeling"
130 | FIELD_LABEL_GDWR = "GDWR: Games Drawn Win Rate"
131 | 
132 | DATA_SET_VERSION_3 = 3.0
133 | 
134 | WIN_RATE_OPTIONS = [DATA_FIELD_GIHWR, DATA_FIELD_OHWR,
135 |                     DATA_FIELD_GPWR, DATA_FIELD_GNSWR, DATA_FIELD_GDWR]
136 | NON_COLORS_OPTIONS = WIN_RATE_OPTIONS + \
137 |     [DATA_FIELD_IWD, DATA_FIELD_ALSA, DATA_FIELD_ATA]
138 | DECK_COLORS = [FILTER_OPTION_ALL_DECKS, CARD_COLOR_SYMBOL_WHITE, CARD_COLOR_SYMBOL_BLUE, CARD_COLOR_SYMBOL_BLACK, CARD_COLOR_SYMBOL_RED,
139 |                CARD_COLOR_SYMBOL_GREEN, "WU", "WB", "WR", "WG", "UB", "UR", "UG", "BR", "BG", "RG", "WUB", "WUR", "WUG", "WBR", "WBG", "WRG", "UBR", "UBG", "URG", "BRG"]
140 | COLUMN_OPTIONS = NON_COLORS_OPTIONS
141 | DECK_FILTERS = [FILTER_OPTION_AUTO] + DECK_COLORS
142 | 
143 | COLUMN_2_DEFAULT = FIELD_LABEL_GIHWR
144 | COLUMN_3_DEFAULT = FIELD_LABEL_DISABLED
145 | COLUMN_4_DEFAULT = FIELD_LABEL_DISABLED
146 | COLUMN_5_DEFAULT = FIELD_LABEL_DISABLED
147 | COLUMN_6_DEFAULT = FIELD_LABEL_DISABLED
148 | COLUMN_7_DEFAULT = FIELD_LABEL_DISABLED
149 | 
150 | DECK_FILTER_DEFAULT = FILTER_OPTION_AUTO
151 | 
152 | UI_SIZE_DEFAULT = "100%"
153 | 
154 | DRAFT_LOG_PREFIX = "DraftLog_"
155 | DRAFT_LOG_FOLDER = os.path.join(os.getcwd(), "Logs")
156 | 
157 | TIER_FOLDER = os.path.join(os.getcwd(), "Tier")
158 | TIER_FILE_PREFIX = "Tier_"
159 | 
160 | DRAFT_DETECTION_CATCH_ALL = ["Draft", "draft"]
161 | 
162 | DRAFT_START_STRING_EVENT_JOIN = "[UnityCrossThreadLogger]==> Event_Join "
163 | DRAFT_START_STRING_BOT_DRAFT = "[UnityCrossThreadLogger]==> BotDraft_DraftStatus "
164 | 
165 | DRAFT_START_STRINGS = [DRAFT_START_STRING_EVENT_JOIN,
166 |                        DRAFT_START_STRING_BOT_DRAFT]
167 | 
168 | DATA_SOURCES_NONE = {"None": ""}
169 | 
170 | DECK_FILTER_FORMAT_NAMES = "Names"
171 | DECK_FILTER_FORMAT_COLORS = "Colors"
172 | DECK_FILTER_FORMAT_SET_NAMES = "Set Names"
173 | 
174 | DECK_FILTER_FORMAT_LIST = [DECK_FILTER_FORMAT_COLORS, DECK_FILTER_FORMAT_NAMES]
175 | 
176 | RESULT_FORMAT_WIN_RATE = "Percentage"
177 | RESULT_FORMAT_RATING = "Rating"
178 | RESULT_FORMAT_GRADE = "Grade"
179 | 
180 | RESULT_FORMAT_LIST = [RESULT_FORMAT_WIN_RATE,
181 |                       RESULT_FORMAT_RATING, RESULT_FORMAT_GRADE]
182 | 
183 | LOCAL_DATA_FOLDER_PATH_WINDOWS = os.path.join(
184 |     "Wizards of the Coast", "MTGA", "MTGA_Data")
185 | LOCAL_DATA_FOLDER_PATH_OSX = os.path.join(
186 |     "Library", "Application Support", "com.wizards.mtga")
187 | LOCAL_DATA_FOLDER_PATH_LINUX = next(filter(os.path.exists, [
188 |     # Steam
189 |     os.path.join(os.path.expanduser("~"), ".local", "share", "Steam", "steamapps", "common", "MTGA", "MTGA_Data"),
190 | 
191 |     # Lutris
192 |     os.path.join(os.path.expanduser("~"), "Games", "magic-the-gathering-arena", "drive_c", "Program Files", "Wizards of the Coast", "MTGA", "MTGA_Data"),
193 | 
194 |     # Bottles
195 |     os.path.join(os.path.expanduser("~"), ".var", "app", "com.usebottles.bottles", "data", "bottles", "bottles", "MTG-Arena", "drive_c", "Program Files", "Wizards of the Coast", "MTGA", "MTGA_Data")
196 |     ]), None)
197 | 
198 | LOCAL_DOWNLOADS_DATA = os.path.join("Downloads", "Raw")
199 | 
200 | LOCAL_DATA_FILE_PREFIX_CARDS = "Raw_cards_"
201 | LOCAL_DATA_FILE_PREFIX_DATABASE = "Raw_CardDatabase_"
202 | 
203 | LOCAL_DATABASE_TABLE_LOCALIZATION = "Localizations"
204 | LOCAL_DATABASE_TABLE_ENUMERATOR = "Enums"
205 | LOCAL_DATABASE_TABLE_CARDS = "Cards"
206 | 
207 | LOCAL_DATABASE_LOCALIZATION_COLUMN_ID = "LocId"
208 | LOCAL_DATABASE_LOCALIZATION_COLUMN_FORMAT = "Formatted"
209 | LOCAL_DATABASE_LOCALIZATION_COLUMN_TEXT = "enUS"
210 | 
211 | LOCAL_DATABASE_ENUMERATOR_COLUMN_ID = "LocId"
212 | LOCAL_DATABASE_ENUMERATOR_COLUMN_TYPE = "Type"
213 | LOCAL_DATABASE_ENUMERATOR_COLUMN_VALUE = "Value"
214 | 
215 | LOCAL_DATABASE_ENUMERATOR_TYPE_COLOR = "Color"
216 | LOCAL_DATABASE_ENUMERATOR_TYPE_CARD_TYPES = "CardType"
217 | 
218 | LOCAL_DATABASE_LOCALIZATION_QUERY = f"""SELECT
219 |                                             A.{LOCAL_DATABASE_LOCALIZATION_COLUMN_ID}, 
220 |                                             A.{LOCAL_DATABASE_LOCALIZATION_COLUMN_FORMAT}, 
221 |                                             A.{LOCAL_DATABASE_LOCALIZATION_COLUMN_TEXT}
222 |                                         FROM {LOCAL_DATABASE_TABLE_LOCALIZATION} A INNER JOIN(
223 |                                             SELECT 
224 |                                                 {LOCAL_DATABASE_LOCALIZATION_COLUMN_ID},
225 |                                                 min({LOCAL_DATABASE_LOCALIZATION_COLUMN_FORMAT}) AS MIN_FORMAT 
226 |                                             FROM {LOCAL_DATABASE_TABLE_LOCALIZATION} 
227 |                                             GROUP BY {LOCAL_DATABASE_LOCALIZATION_COLUMN_ID}) 
228 |                                         B ON A.{LOCAL_DATABASE_LOCALIZATION_COLUMN_ID} = B.{LOCAL_DATABASE_LOCALIZATION_COLUMN_ID} 
229 |                                         AND A.{LOCAL_DATABASE_LOCALIZATION_COLUMN_FORMAT} = B.MIN_FORMAT"""
230 | 
231 | LOCAL_DATABASE_ENUMERATOR_QUERY = f"""SELECT
232 |                                         {LOCAL_DATABASE_ENUMERATOR_COLUMN_ID},
233 |                                         {LOCAL_DATABASE_ENUMERATOR_COLUMN_TYPE},
234 |                                         {LOCAL_DATABASE_ENUMERATOR_COLUMN_VALUE}
235 |                                       FROM {LOCAL_DATABASE_TABLE_ENUMERATOR}
236 |                                       WHERE {LOCAL_DATABASE_ENUMERATOR_COLUMN_TYPE} 
237 |                                       IN ('{LOCAL_DATABASE_ENUMERATOR_TYPE_COLOR}', 
238 |                                           '{LOCAL_DATABASE_ENUMERATOR_TYPE_CARD_TYPES}')"""
239 | 
240 | LOCAL_DATABASE_CARDS_QUERY = f"SELECT * FROM {LOCAL_DATABASE_TABLE_CARDS}"
241 | 
242 | LOCAL_CARDS_KEY_SET = "expansioncode"
243 | LOCAL_CARDS_KEY_DIGITAL_RELEASE_SET = "digitalreleaseset"
244 | LOCAL_CARDS_KEY_GROUP_ID = "grpid"
245 | LOCAL_CARDS_KEY_TOKEN = "istoken"
246 | LOCAL_CARDS_KEY_LINKED_FACES = "linkedfacegrpids"
247 | LOCAL_CARDS_KEY_LINKED_FACE_TYPE = "linkedfacetype"
248 | LOCAL_CARDS_KEY_TYPES = "types"
249 | LOCAL_CARDS_KEY_TITLE_ID = "titleid"
250 | LOCAL_CARDS_KEY_CMC = "cmc"
251 | LOCAL_CARDS_KEY_COLOR_ID = "coloridentity"
252 | LOCAL_CARDS_KEY_CASTING_COST = "oldschoolmanatext"
253 | LOCAL_CARDS_KEY_RARITY = "rarity"
254 | LOCAL_CARDS_KEY_PRIMARY = "isprimarycard"
255 | 
256 | SETS_FOLDER = os.path.join(os.getcwd(), "Sets")
257 | SET_FILE_SUFFIX = "Data.json"
258 | 
259 | CARD_RATINGS_BACKOFF_DELAY_SECONDS = 30
260 | CARD_RATINGS_INTER_DELAY_SECONDS = 1
261 | CARD_RATINGS_ATTEMPT_MAX = 5
262 | 
263 | SCRYFALL_REQUEST_BACKOFF_DELAY_SECONDS = 5
264 | SCRYFALL_REQUEST_ATTEMPT_MAX = 5
265 | 
266 | PLATFORM_ID_OSX = "darwin"
267 | PLATFORM_ID_WINDOWS = "win32"
268 | PLATFORM_ID_LINUX = "linux"
269 | 
270 | LOG_NAME = "Player.log"
271 | 
272 | LOG_LOCATION_WINDOWS = os.path.join('Users', getpass.getuser(
273 | ), "AppData", "LocalLow", "Wizards Of The Coast", "MTGA", LOG_NAME)
274 | LOG_LOCATION_OSX = os.path.join(
275 |     "Library", "Logs", "Wizards of the Coast", "MTGA", LOG_NAME)
276 | 
277 | DEFAULT_GIHWR_AVERAGE = 0.0
278 | 
279 | WINDOWS_DRIVES = ["C:/", "D:/", "E:/", "F:/"]
280 | WINDOWS_PROGRAM_FILES = ["Program Files", "Program Files (x86)"]
281 | 
282 | LIMITED_TYPE_STRING_DRAFT_PREMIER = "PremierDraft"
283 | LIMITED_TYPE_STRING_DRAFT_QUICK = "QuickDraft"
284 | LIMITED_TYPE_STRING_DRAFT_BOT = "BotDraft"
285 | LIMITED_TYPE_STRING_DRAFT_TRAD = "TradDraft"
286 | LIMITED_TYPE_STRING_SEALED = "Sealed"
287 | LIMITED_TYPE_STRING_TRAD_SEALED = "TradSealed"
288 | 
289 | LIMITED_TYPE_LIST = [
290 |     LIMITED_TYPE_STRING_DRAFT_PREMIER,
291 |     LIMITED_TYPE_STRING_DRAFT_QUICK,
292 |     LIMITED_TYPE_STRING_DRAFT_TRAD,
293 |     LIMITED_TYPE_STRING_SEALED,
294 |     LIMITED_TYPE_STRING_TRAD_SEALED]
295 | 
296 | SET_TYPE_EXPANSION = "expansion"
297 | SET_TYPE_ALCHEMY = "alchemy"
298 | SET_TYPE_MASTERS = "masters"
299 | SET_TYPE_MASTERPIECE = "masterpiece"
300 | SET_TYPE_CORE = "core"
301 | SET_TYPE_DRAFT_INNOVATION = "draft_innovation"
302 | 
303 | SET_LIST_ARENA = "arena"
304 | SET_LIST_SCRYFALL = "scryfall"
305 | SET_LIST_17LANDS = "17Lands"
306 | 
307 | SET_LIST_FIELDS = [SET_LIST_ARENA, SET_LIST_SCRYFALL, SET_LIST_17LANDS]
308 | 
309 | SET_START_DATE = "start_date"
310 | 
311 | SET_START_DATE_DEFAULT = "2019-1-1"
312 | 
313 | SET_SELECTION_ALL = "ALL"
314 | SET_SELECTION_CUBE = "CUBE"
315 | 
316 | SET_RELEASE_OFFSET_DAYS = -7
317 | SET_LIST_COUNT_MAX = 50
318 | 
319 | SET_ARENA_CUBE_START_OFFSET_DAYS = -25
320 | 
321 | SUPPORTED_SET_TYPES = [SET_TYPE_EXPANSION, SET_TYPE_ALCHEMY,
322 |                        SET_TYPE_MASTERS, SET_TYPE_CORE, SET_TYPE_DRAFT_INNOVATION]
323 | 
324 | TABLE_STYLE = "Treeview"
325 | 
326 | TEMP_FOLDER = os.path.join(os.getcwd(), "Temp")
327 | TEMP_LOCALIZATION_FILE = os.path.join(TEMP_FOLDER, "temp_localization.json")
328 | TEMP_CARD_DATA_FILE = os.path.join(TEMP_FOLDER, "temp_card_data.json")
329 | 
330 | BW_ROW_COLOR_ODD_TAG = "bw_odd"
331 | BW_ROW_COLOR_EVEN_TAG = "bw_even"
332 | CARD_ROW_COLOR_WHITE_TAG = "white_card"
333 | CARD_ROW_COLOR_RED_TAG = "red_card"
334 | CARD_ROW_COLOR_BLUE_TAG = "blue_card"
335 | CARD_ROW_COLOR_BLACK_TAG = "black_card"
336 | CARD_ROW_COLOR_GREEN_TAG = "green_card"
337 | CARD_ROW_COLOR_GOLD_TAG = "gold_card"
338 | CARD_ROW_COLOR_COLORLESS_TAG = "colorless_card"
339 | 
340 | LETTER_GRADE_A_PLUS = "A+"
341 | LETTER_GRADE_A = "A "
342 | LETTER_GRADE_A_MINUS = "A-"
343 | LETTER_GRADE_B_PLUS = "B+"
344 | LETTER_GRADE_B = "B "
345 | LETTER_GRADE_B_MINUS = "B-"
346 | LETTER_GRADE_C_PLUS = "C+"
347 | LETTER_GRADE_C = "C "
348 | LETTER_GRADE_C_MINUS = "C-"
349 | LETTER_GRADE_D_PLUS = "D+"
350 | LETTER_GRADE_D = "D "
351 | LETTER_GRADE_D_MINUS = "D-"
352 | LETTER_GRADE_F = "F "
353 | LETTER_GRADE_NA = "NA"
354 | LETTER_GRADE_SB = "SB"
355 | 
356 | CARD_TYPE_CREATURE = "Creature"
357 | CARD_TYPE_PLANESWALKER = "Planeswalker"
358 | CARD_TYPE_INSTANT = "Instant"
359 | CARD_TYPE_SORCERY = "Sorcery"
360 | CARD_TYPE_ENCHANTMENT = "Enchantment"
361 | CARD_TYPE_ARTIFACT = "Artifact"
362 | CARD_TYPE_LAND = "Land"
363 | 
364 | CARD_TYPE_SELECTION_ALL = "All Cards"
365 | CARD_TYPE_SELECTION_CREATURES = "Creatures"
366 | CARD_TYPE_SELECTION_NONCREATURES = "Noncreatures"
367 | CARD_TYPE_SELECTION_NON_LANDS = "Non-Lands"
368 | 
369 | TABLE_MISSING = "missing"
370 | TABLE_PACK = "pack"
371 | TABLE_COMPARE = "compare"
372 | TABLE_TAKEN = "taken"
373 | TABLE_SUGGEST = "suggest"
374 | TABLE_STATS = "stats"
375 | TABLE_SETS = "sets"
376 | 
377 | CARD_RARITY_COMMON = "common"
378 | CARD_RARITY_UNCOMMON = "uncommon"
379 | CARD_RARITY_RARE = "rare"
380 | CARD_RARITY_MYTHIC = "mythic"
381 | 
382 | # Dictionaries
383 | # Used to identify the limited type based on log string
384 | LIMITED_TYPES_DICT = {
385 |     LIMITED_TYPE_STRING_DRAFT_PREMIER: LIMITED_TYPE_DRAFT_PREMIER_V1,
386 |     LIMITED_TYPE_STRING_DRAFT_QUICK: LIMITED_TYPE_DRAFT_QUICK,
387 |     LIMITED_TYPE_STRING_DRAFT_TRAD: LIMITED_TYPE_DRAFT_TRADITIONAL,
388 |     LIMITED_TYPE_STRING_DRAFT_BOT: LIMITED_TYPE_DRAFT_QUICK,
389 |     LIMITED_TYPE_STRING_SEALED: LIMITED_TYPE_SEALED,
390 |     LIMITED_TYPE_STRING_TRAD_SEALED: LIMITED_TYPE_SEALED_TRADITIONAL,
391 | }
392 | 
393 | COLOR_NAMES_DICT = {
394 |     CARD_COLOR_SYMBOL_WHITE: CARD_COLOR_LABEL_WHITE,
395 |     CARD_COLOR_SYMBOL_BLUE: CARD_COLOR_LABEL_BLUE,
396 |     CARD_COLOR_SYMBOL_BLACK: CARD_COLOR_LABEL_BLACK,
397 |     CARD_COLOR_SYMBOL_RED: CARD_COLOR_LABEL_RED,
398 |     CARD_COLOR_SYMBOL_GREEN: CARD_COLOR_LABEL_GREEN,
399 |     "WU": "Azorius",
400 |     "UB": "Dimir",
401 |     "BR": "Rakdos",
402 |     "RG": "Gruul",
403 |     "WG": "Selesnya",
404 |     "WB": "Orzhov",
405 |     "BG": "Golgari",
406 |     "UG": "Simic",
407 |     "UR": "Izzet",
408 |     "WR": "Boros",
409 |     "WUR": "Jeskai",
410 |     "UBG": "Sultai",
411 |     "WBR": "Mardu",
412 |     "URG": "Temur",
413 |     "WBG": "Abzan",
414 |     "WUB": "Esper",
415 |     "UBR": "Grixis",
416 |     "BRG": "Jund",
417 |     "WRG": "Naya",
418 |     "WUG": "Bant",
419 | }
420 | 
421 | CARD_COLORS_DICT = {
422 |     CARD_COLOR_LABEL_WHITE: CARD_COLOR_SYMBOL_WHITE,
423 |     CARD_COLOR_LABEL_BLACK: CARD_COLOR_SYMBOL_BLACK,
424 |     CARD_COLOR_LABEL_BLUE: CARD_COLOR_SYMBOL_BLUE,
425 |     CARD_COLOR_LABEL_RED: CARD_COLOR_SYMBOL_RED,
426 |     CARD_COLOR_LABEL_GREEN: CARD_COLOR_SYMBOL_GREEN,
427 |     CARD_COLOR_LABEL_NC: "",
428 | }
429 | 
430 | PLATFORM_LOG_DICT = {
431 |     PLATFORM_ID_OSX: LOG_LOCATION_OSX,
432 |     PLATFORM_ID_WINDOWS: LOG_LOCATION_WINDOWS,
433 | }
434 | 
435 | WIN_RATE_FIELDS_DICT = {
436 |     DATA_FIELD_GIHWR: DATA_FIELD_GIH,
437 |     DATA_FIELD_OHWR: DATA_FIELD_NGOH,
438 |     DATA_FIELD_GPWR: DATA_FIELD_NGP,
439 |     DATA_FIELD_GNSWR: DATA_FIELD_NGND,
440 |     DATA_FIELD_GDWR: DATA_FIELD_NGD,
441 | }
442 | 
443 | DATA_FIELD_17LANDS_DICT = {
444 |     DATA_FIELD_GIHWR: DATA_FIELD_17LANDS_GIHWR,
445 |     DATA_FIELD_OHWR: DATA_FIELD_17LANDS_OHWR,
446 |     DATA_FIELD_GPWR: DATA_FIELD_17LANDS_GPWR,
447 |     DATA_FIELD_ALSA: DATA_FIELD_17LANDS_ALSA,
448 |     DATA_FIELD_IWD: DATA_FIELD_17LANDS_IWD,
449 |     DATA_FIELD_ATA: DATA_FIELD_17LANDS_ATA,
450 |     DATA_FIELD_NGP: DATA_FIELD_17LANDS_NGP,
451 |     DATA_FIELD_NGOH: DATA_FIELD_17LANDS_NGOH,
452 |     DATA_FIELD_GIH: DATA_FIELD_17LANDS_GIH,
453 |     DATA_FIELD_GNSWR: DATA_FIELD_17LANDS_GNSWR,
454 |     DATA_FIELD_NGND: DATA_FIELD_17LANDS_NGND,
455 |     DATA_FIELD_GDWR: DATA_FIELD_17LANDS_GDWR,
456 |     DATA_FIELD_NGD: DATA_FIELD_17LANDS_NGD,
457 |     DATA_SECTION_IMAGES: [DATA_FIELD_17LANDS_IMAGE,
458 |                           DATA_FIELD_17LANDS_IMAGE_BACK]
459 | }
460 | 
461 | COLUMNS_OPTIONS_MAIN_DICT = {
462 |     FIELD_LABEL_ATA: DATA_FIELD_ATA,
463 |     FIELD_LABEL_ALSA: DATA_FIELD_ALSA,
464 |     FIELD_LABEL_IWD: DATA_FIELD_IWD,
465 |     FIELD_LABEL_OHWR: DATA_FIELD_OHWR,
466 |     FIELD_LABEL_GPWR: DATA_FIELD_GPWR,
467 |     FIELD_LABEL_GIHWR: DATA_FIELD_GIHWR,
468 |     FIELD_LABEL_GDWR: DATA_FIELD_GDWR,
469 |     FIELD_LABEL_GNSWR: DATA_FIELD_GNSWR,
470 |     FIELD_LABEL_COLORS: DATA_FIELD_COLORS,
471 | }
472 | 
473 | COLUMNS_OPTIONS_EXTRA_DICT = {
474 |     FIELD_LABEL_DISABLED: DATA_FIELD_DISABLED,
475 |     FIELD_LABEL_ATA: DATA_FIELD_ATA,
476 |     FIELD_LABEL_ALSA: DATA_FIELD_ALSA,
477 |     FIELD_LABEL_IWD: DATA_FIELD_IWD,
478 |     FIELD_LABEL_OHWR: DATA_FIELD_OHWR,
479 |     FIELD_LABEL_GPWR: DATA_FIELD_GPWR,
480 |     FIELD_LABEL_GIHWR: DATA_FIELD_GIHWR,
481 |     FIELD_LABEL_GDWR: DATA_FIELD_GDWR,
482 |     FIELD_LABEL_GNSWR: DATA_FIELD_GNSWR,
483 |     FIELD_LABEL_COLORS: DATA_FIELD_COLORS,
484 | }
485 | 
486 | STATS_HEADER_CONFIG = {"Colors": {"width": .19, "anchor": "w"},
487 |                        "1": {"width": .11, "anchor": "c"},
488 |                        "2": {"width": .11, "anchor": "c"},
489 |                        "3": {"width": .11, "anchor": "c"},
490 |                        "4": {"width": .11, "anchor": "c"},
491 |                        "5": {"width": .11, "anchor": "c"},
492 |                        "6+": {"width": .11, "anchor": "c"},
493 |                        "Total": {"width": .15, "anchor": "c"}}
494 | 
495 | ROW_TAGS_BW_DICT = {
496 |     BW_ROW_COLOR_ODD_TAG: (FONT_SANS_SERIF, "#3d3d3d", "#e6ecec"),
497 |     BW_ROW_COLOR_EVEN_TAG: (FONT_SANS_SERIF, "#333333", "#e6ecec"),
498 | }
499 | 
500 | ROW_TAGS_COLORS_DICT = {
501 |     CARD_ROW_COLOR_WHITE_TAG: (FONT_SANS_SERIF, "#E9E9E9", "#000000"),
502 |     CARD_ROW_COLOR_RED_TAG: (FONT_SANS_SERIF, "#FF6C6C", "#000000"),
503 |     CARD_ROW_COLOR_BLUE_TAG: (FONT_SANS_SERIF, "#6078c6", "#000000"),
504 |     CARD_ROW_COLOR_BLACK_TAG: (FONT_SANS_SERIF, "#BFBFBF", "#000000"),
505 |     CARD_ROW_COLOR_GREEN_TAG: (FONT_SANS_SERIF, "#60BC68", "#000000"),
506 |     CARD_ROW_COLOR_GOLD_TAG: (FONT_SANS_SERIF, "#F0BE26", "#000000"),
507 |     CARD_ROW_COLOR_COLORLESS_TAG: (FONT_SANS_SERIF, "#8e9eae", "#000000"),
508 | }
509 | 
510 | GRADE_ORDER_DICT = {
511 |     LETTER_GRADE_A_PLUS: 14,
512 |     LETTER_GRADE_A: 13,
513 |     LETTER_GRADE_A_MINUS: 12,
514 |     LETTER_GRADE_B_PLUS: 11,
515 |     LETTER_GRADE_B: 10,
516 |     LETTER_GRADE_B_MINUS: 9,
517 |     LETTER_GRADE_C_PLUS: 8,
518 |     LETTER_GRADE_C: 7,
519 |     LETTER_GRADE_C_MINUS: 6,
520 |     LETTER_GRADE_D_PLUS: 5,
521 |     LETTER_GRADE_D: 4,
522 |     LETTER_GRADE_D_MINUS: 3,
523 |     LETTER_GRADE_F: 2,
524 |     LETTER_GRADE_SB: 1,
525 |     LETTER_GRADE_NA: 0
526 | }
527 | 
528 | TIER_CONVERSION_RATINGS_GRADES_DICT = {
529 |     LETTER_GRADE_A_PLUS: 5.0,
530 |     LETTER_GRADE_A: 4.6,
531 |     LETTER_GRADE_A_MINUS: 4.2,
532 |     LETTER_GRADE_B_PLUS: 3.8,
533 |     LETTER_GRADE_B: 3.5,
534 |     LETTER_GRADE_B_MINUS: 3.1,
535 |     LETTER_GRADE_C_PLUS: 2.7,
536 |     LETTER_GRADE_C: 2.3,
537 |     LETTER_GRADE_C_MINUS: 1.9,
538 |     LETTER_GRADE_D_PLUS: 1.5,
539 |     LETTER_GRADE_D: 1.2,
540 |     LETTER_GRADE_D_MINUS: 0.8,
541 |     LETTER_GRADE_F: 0.4
542 | }
543 | 
544 | GRADE_DEVIATION_DICT = {
545 |     LETTER_GRADE_A_PLUS: 2.00,
546 |     LETTER_GRADE_A: 1.67,
547 |     LETTER_GRADE_A_MINUS: 1.33,
548 |     LETTER_GRADE_B_PLUS: 1,
549 |     LETTER_GRADE_B: 0.67,
550 |     LETTER_GRADE_B_MINUS: 0.33,
551 |     LETTER_GRADE_C_PLUS: 0,
552 |     LETTER_GRADE_C: -0.33,
553 |     LETTER_GRADE_C_MINUS: -0.67,
554 |     LETTER_GRADE_D_PLUS: -1.00,
555 |     LETTER_GRADE_D: -1.33,
556 |     LETTER_GRADE_D_MINUS: -1.67
557 | }
558 | 
559 | CARD_TYPE_DICT = {
560 |     CARD_TYPE_SELECTION_ALL: ([CARD_TYPE_CREATURE, CARD_TYPE_PLANESWALKER, CARD_TYPE_INSTANT, CARD_TYPE_SORCERY, CARD_TYPE_ENCHANTMENT, CARD_TYPE_ARTIFACT, CARD_TYPE_LAND], True, False, True),
561 |     CARD_TYPE_SELECTION_CREATURES: ([CARD_TYPE_CREATURE], True, False, True),
562 |     CARD_TYPE_SELECTION_NONCREATURES: ([CARD_TYPE_CREATURE], False, False, True),
563 |     CARD_TYPE_SELECTION_NON_LANDS: ([CARD_TYPE_CREATURE, CARD_TYPE_PLANESWALKER, CARD_TYPE_INSTANT, CARD_TYPE_SORCERY, CARD_TYPE_ENCHANTMENT, CARD_TYPE_ARTIFACT], True, False, True),
564 | }
565 | 
566 | TABLE_PROPORTIONS = [
567 |     (1,),
568 |     (.75, .25),
569 |     (.60, .20, .20),
570 |     (.46, .18, .18, .18)
571 | ]
572 | 
573 | WHEEL_COEFFICIENTS = [
574 |     [-0.46, 7.97, -27.43, 26.61],
575 |     [-0.33, 6.31, -23.12, 23.86],
576 |     [-0.19, 4.39, -17.06, 17.71],
577 |     [-0.06, 2.27, -9.22, 9.43],
578 |     [0.08, 0.15, -1.88, 2.36],
579 |     [0.25, -2.65, 9.76, -11.21],
580 | ]
581 | 
582 | CARD_RARITY_DICT = {
583 |     1: CARD_RARITY_COMMON,
584 |     2: CARD_RARITY_COMMON,
585 |     3: CARD_RARITY_UNCOMMON,
586 |     4: CARD_RARITY_RARE,
587 |     5: CARD_RARITY_MYTHIC,
588 | }
589 | 
590 | UI_SIZE_DICT = {
591 |     "80%": 0.8,
592 |     "90%": 0.9,
593 |     "100%": 1.0,
594 |     "110%": 1.1,
595 |     "120%": 1.2,
596 |     "130%": 1.3,
597 |     "140%": 1.4,
598 |     "150%": 1.5,
599 |     "160%": 1.6,
600 |     "170%": 1.7,
601 |     "180%": 1.8,
602 |     "190%": 1.9,
603 |     "200%": 2.0,
604 |     "210%": 2.1,
605 |     "220%": 2.2,
606 |     "230%": 2.3,
607 |     "240%": 2.4,
608 |     "250%": 2.5
609 | }
610 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | > ⚠️ **Important Notice**  
  2 | >
  3 | > This fan project is _not affiliated with or endorsed by [17Lands](https://17lands.com/)_.
  4 | >
  5 | > _**No longer maintained, functional, or updated as of June 2023.**_
  6 | >
  7 | > Members of the community have continued supporting this project through [GitHub forks](https://github.com/bstaple1/MTGA_Draft_17Lands/forks).  
  8 | > If you're interested in exploring further, consider trying one of these forks **at your own risk**.
  9 | >
 10 | > Thank you for your interest and support!
 11 | 
 12 | # MTGA_Draft_17Lands
 13 | Magic: The Gathering Arena draft tool that utilizes 17Lands data.
 14 | 
 15 | **This application will automatically support new sets as soon as the sets are released on Arena _and_ the data is available on the [17Lands card ratings](https://www.17lands.com/card_ratings) page.**
 16 | 
 17 | **Supported Events:** Premier Draft, Traditional Draft, Quick Draft, Sealed, and Traditional Sealed
 18 |   
 19 | ![Premier_Draft](https://github.com/bstaple1/MTGA_Draft_17Lands/assets/96687942/9d7283ff-cb8b-46f9-8d72-7bf531d707b1)
 20 | 
 21 | # Table of Contents
 22 | 
 23 | - [Run Steps: Windows Executable](#run-steps-windows-executable-windows-only)
 24 | - [Run Steps: Python (Windows/Mac/Linux)](#run-steps-python-windowsmaclinux)
 25 | - [Build Steps: setup.exe](#build-steps-setupexe-windows-only)
 26 | - [UI Features](#ui-features)
 27 | - [Menu Features](#menu-features)
 28 | - [Additional Features](#additional-features)
 29 | - [Settings](#settings)
 30 | - [Card Logic](#card-logic)
 31 | - [Troubleshooting](#troubleshooting)
 32 | 
 33 | 
 34 | ## Run Steps: Windows Executable (Windows Only)
 35 | - **Step 1:** Download the latest zip file from the [releases page](https://github.com/bstaple1/MTGA_Draft_17Lands/releases).
 36 | 
 37 | - **Step 2:** Unzip and double-click the exe file to start the installation. 
 38 | 
 39 | - **Step 3:** (Optional) Go to the installed folder and right-click the executable (`MTGA_Draft_Tool.exe`), click properties, compatibility tab, and check Run this program as an administrator.
 40 |     - This step is only required if the application is installed in a directory with write restrictions (i.e., `Program Files` and `Program Files (x86)`).
 41 |     - This step isn't necessary if the application is installed in the main directory of a drive (i.e., `C:/` or `D:/`) or the `Users/<Username>/` directory
 42 | 
 43 | - **Step 4:** In Arena, go to Adjust Options, Account, and then check the Detailed Logs (Plugin Support) check box.
 44 | 
 45 | - **Step 5:** Double-click `MTGA_Draft_Tool.exe` to start the program.
 46 | 
 47 | - **Step 6:** Download the sets that you plan on using (`Data->Add Sets`).
 48 |     - Event datasets can be used for different events (e.g., you can use the premier draft dataset for a sealed event).
 49 |     - Quick draft players should consider using the premier draft dataset when quick draft initially becomes available.
 50 |     
 51 | - **Step 7:** Configure the tool through the [Settings window](#settings).
 52 |     - Users that are new to 17Lands might find the [Win Rate Grades](#card-logic) (`Win Rate Format: Grade`) more useful than the win rate percentages.
 53 |     - The [UI Size](#ui-size) setting can be used to adjust the image and text size.
 54 | 
 55 | - **Step 8:** Start the draft in Arena.
 56 |     - The Arena log doesn't list P1P1 for premier and traditional drafts until after P1P2.
 57 |     	- The [Card Compare](#card-compare) feature can be used as a substitute for P1P1.
 58 |     - The sealed card pool can be found in the [Taken Cards window](#taken-cards).
 59 | 
 60 | 
 61 | ## Run Steps: Python (Windows/Mac/Linux)
 62 | - **Step 1:** [Download](https://github.com/bstaple1/MTGA_Draft_17Lands/archive/refs/heads/main.zip) and unzip the `MTGA_Draft_17Lands-main.zip` file or clone the repository.
 63 |     - Some recent Python-related bug fixes have been made since the 3.10 release. Please download the code from the [main branch](https://github.com/bstaple1/MTGA_Draft_17Lands/archive/refs/heads/main.zip) instead of the 3.10 release.
 64 | 
 65 | - **Step 2:** Download and install Python 3.11.
 66 |     - [Windows](https://www.python.org/downloads/windows/).
 67 |     - [Mac](https://www.python.org/downloads/macos/).
 68 |     - [Linux](https://wiki.python.org/moin/BeginnersGuide/Download#Linux).
 69 | 
 70 | 
 71 | - **Step 3:** Confirm that you're running Python 3.11 by opening the terminal, entering ```python --version```, and checking for a ```Python 3.11.*``` result.
 72 | 
 73 | - **Step 4:** Install the Python package installer Pip by entering ```python -m ensurepip --upgrade```.
 74 | 
 75 | - **Step 5:** Open the terminal and install the Python dependencies by entering ```pip install -r requirements.txt```.
 76 | 
 77 | - **Step 6:**
 78 |     - (Mac Only) Install web certificates by going to `/Applications/Python 3.##/` and double-clicking the file `Install Certificates.command`.
 79 |     - (Linux only) [Install Tk](https://tkdocs.com/tutorial/install.html#installlinux)
 80 | 
 81 | - **Step 7:** In Arena, go to Adjust Options, Account, and then check the Detailed Logs (Plugin Support) check box.
 82 | 
 83 | - **Step 8:** Start the application by opening the terminal and entering ```python main.py```.
 84 | 
 85 | - **Step 9:** If the application asks you for the location of the Arena player log, then click `File->Open` and select the log file from one of the following locations:
 86 |     - **Windows:** {drive}/Users/{username}/AppData/LocalLow/Wizards Of The Coast/MTGA/Player.log
 87 |     - **Mac:** {username}/Library/Logs/Wizards Of The Coast/MTGA/Player.log
 88 |     - **Bottles (Linux):** /home/{username}/.var/app/com.usebottles.bottles/data/bottles/bottles/MTG-Arena/drive_c/users/{username}/AppData/LocalLow/Wizards Of The Coast/MTGA/Player.log
 89 |     - **Lutris (Linux):** /home/{username}/Games/magic-the-gathering-arena/drive_c/users/{username}/AppData/LocalLow/Wizards Of The Coast/MTGA/Player.log
 90 | 
 91 | - **Step 10:** (Mac Only) Set Arena to window mode.
 92 | 
 93 | - **Step 11:** Download the sets that you plan on using (`Data->Add Sets`).
 94 |     - Event datasets can be used for different events (e.g., you can use the premier draft dataset for a sealed event).
 95 |     - Select `Arena Cube` and adjust the start date to download the data from the most recent Arena Cube event.
 96 |     - Quick draft players should consider using the premier draft dataset when quick draft initially becomes available.
 97 |     
 98 | - **Step 12:** Configure the tool through the [Settings window](#settings).
 99 |     - Users that are new to 17Lands might find the [Win Rate Grades](#card-logic) (`Win Rate Format: Grade`) more useful than the win rate percentages.
100 |     - The [UI Size](#ui-size) setting can be used to adjust the image and text size.
101 | 
102 | - **Step 13:** Start the draft in Arena.
103 |     - The Arena log doesn't list P1P1 for premier and traditional drafts until after P1P2.
104 |     	- The [Card Compare](#card-compare) feature can be used as a substitute for P1P1.
105 |     - The sealed card pool can be found in the [Taken Cards window](#taken-cards).
106 | 
107 | 
108 | ## Build Steps: setup.exe (Windows Only)
109 | - **Step 1:** Download and install Python 3.11.
110 | 
111 | - **Step 2:** Install the Python package installer Pip by opening the terminal and entering ```python -m ensurepip --upgrade```.
112 | 
113 | - **Step 3:** Open the terminal and enter ```pip install -r requirements.txt```.
114 | 
115 | - **Step 4:** [Download Inno Setup](https://jrsoftware.org/isdl.php#stable)
116 | 
117 | - **Step 5:** Build MTGA_Draft_Tool.exe by opening the terminal and entering ```pyinstaller main.py --onefile --noconsole -n MTGA_Draft_Tool --clean```
118 |     - Move the `MTGA_Draft_Tool.exe` file from the `dist` folder to the main `MTGA_Draft_17Lands` folder.
119 |     
120 | - **Step 6:** Open `Installer.iss` in Inno Setup and click Build->Compile.
121 |     - In the `{app}` folder, rename the mysetup.exe file to `setup.exe` and move the file to the main `MTGA_Draft_17Lands` folder.
122 | 
123 | ## UI Features
124 | 
125 | - **Current Draft:** Lists the current draft type (i.e., Premier, Quick, or Traditional) that the application has identified.
126 |     - In the Arena logs, P1P1 doesn't appear for Premier and Traditional drafts until after P1P2.
127 |     - You can hide this feature by deselecting `Enable Current Draft Display` in the [Settings window](#settings)
128 | 
129 | - **Data Source:** Lists the current draft type (i.e., Premier, Quick, or Traditional) from which the application is pulling the card data.
130 |     - The application will attempt to pull data for the current draft type and set (e.g., data from NEO_PremierDraft_Data.json for a Premier Draft). If the user hasn't downloaded the data file for the current draft type and set, then the application will attempt to use a different data file from the same set (e.g., NEO_QuickDraft_Data.json if NEO_PremierDraft_Data.json isn't available).
131 |     - This field will display "None" if the application is unable to find a valid data file for the current draft type and set.
132 |     - You can hide this feature by deselecting `Enable Data Source Options` in the [Settings window](#settings)
133 |   
134 | - **Deck Filter:** A drop-down that lists all of the available deck color permutations that you can use to filter the deck card ratings.
135 |     - The percentage next to the number represents the win rate for that color combination. These percentage values are collected from the [color ratings page on 17Lands](https://www.17lands.com/color_ratings). If there are no values, then that means the sample size was too small to determine the win rate (unpopular deck combination).
136 |     - The `All Decks` option lists the combined rating across all of the deck color combinations
137 |         -The `Auto` option will keep the filter at `All Decks` for the first 15 picks and then switch over to the filter that best matches your taken cards. See the Auto Highest Rating note in the Card Logic section.
138 |     - You can hide this feature by deselecting `Enable Deck Filter Options` in the [Settings window](#settings)
139 |     
140 | - **Refresh Button:** Trigger a log read.
141 |     - The application will automatically read new log entries, so this button is not required unless you are using an outdated operating system (Windows 7 or 8).
142 |     - You can hide this feature by deselecting `Enable Refresh Button` in the [Settings window](#settings) 
143 |     
144 | - **Pack / Pick Table:** This table displays the cards included in the current pack.  
145 |     - If a dataset is missing `Data Source: None` or an unrecognized card is listed, this table will show a number under the name column. 
146 | 	
147 | - **Missing Cards Table:** This table displays the cards missing from a pack that has already been seen. 
148 |     - The user's chosen card will have an asterisk next to the name.
149 |     - You can hide this feature by deselecting `Enable Missing Cards` in the [Settings window](#settings) 
150 | 	
151 | - **Draft Stats Table:** This table lists the card distribution and total for creatures, noncreatures, and all cards that were taken during the draft.
152 |     - The numbered columns represent the cost of the card (cmc).
153 |     - You can hide this feature by deselecting `Enable Draft Stats` in the [Settings window](#settings)
154 | 
155 | ## Menu Features
156 | 
157 | ![Settings_Dark](https://github.com/bstaple1/MTGA_Draft_17Lands/assets/96687942/642a0795-e407-410e-b8d6-6332f3083ac7)
158 | ![Settings_Colors](https://github.com/bstaple1/MTGA_Draft_17Lands/assets/96687942/90c6b3df-0ade-4f32-a1be-b2ef40cedc32)
159 | 
160 | 
161 | - **Read Draft Logs:** Read the log file from a draft by selecting `File->Open`. Select a file that has the following naming scheme `DraftLog_<Set>_<Draft Type>_<Draft_ID>.log` file to read the file.
162 | 
163 | - **Download Set Data:** Get to the Add Sets window by selecting `Data->Add Sets`. Enter the set information and click on the ADD SET button to begin downloading the set data.
164 |     - The download can take several minutes.
165 |     - 17Lands will timeout the request if too many requests are made within a short period of time.
166 |     
167 | - <a id="taken-cards">**List Taken Cards:** Get to the Taken Cards window by selecting `Cards->Taken Cards`. </a>
168 |     - This table lists the cards that were taken by the user throughout the draft.
169 | 
170 | - **List Suggested Decks:** Get to the Suggested Decks window by selecting `Cards->Suggest Decks`. 
171 |     - This table displays a 40-card deck created by the application using the cards you have obtained during the event. In certain cases, multiple decks may be shown if the application is able to create them.
172 |     - It is possible for the application to be unable to generate any decks if this option is selected before the event concludes or if an insufficient number of creatures were chosen.
173 |         - The application constructs decks according to various criteria, including the Games in Hand Win Rate of each card. The rating indicated represents the combined Games in Hand Win Rate of all cards in the deck.
174 | 
175 | - <a id="card-compare">**Card Compare:** Get to the Card Compare window by selecting `Cards->Compare Cards`. You will be able to compare the cards you have entered using this window. </a>
176 |     - This feature can be used to quickly compare cards for P1P1 of the Premier and Traditional drafts.
177 | 	
178 |     
179 | ## Additional Features
180 | 
181 | - **Hotkey:** The user can use the hotkey `CTRL+G` to toggle between minimizing and maximizing the main application window.
182 |     - This feature doesn't work on Mac.
183 |     - You need to run the executable as an administrator for this feature to work in Arena.
184 | 
185 | - **Top-Level Window:** The main application window, and subsequent windows, will act as an overlay and remain above all other windows, including the Arena screen.
186 | 
187 | - **Tier List:** A tier list can be added to the drop-downs by following the instructions in [tier list README](https://github.com/bstaple1/MTGA_Draft_17Lands/tree/main/Tools/TierScraper17Lands#tier-list-download-extension).
188 | 
189 | - **Card Tooltips:** Clicking on any card row will display a tooltip that contains the card images (back and front) and the 17Lands data.
190 | 	
191 | ## Settings
192 | 
193 | - **Columns 2-7:** Set the field for columns 2-7 of the pack table, missing table, and compare table. 
194 | 
195 | - **Deck Filter Format:** Switch the Deck Filter to either the color permutations (i.e., UB, BG, WUG, etc.) or the guild/shard/clan names (i.e., Dimir, Golgari, Bant, etc.).
196 | 
197 | - **Win Rate Format:** Switch the results for the win rate fields (such as GIHWR, OHWR, GPWR, etc.) to percentage (17Lands values), ratings (5-point rating scale) or grades (A+ to F). See the Win Rate Ratings section for more details.
198 | 
199 | - **Enable Current Draft Display:** Toggle the visibility of the Current Draft indicator in the main window.
200 | 
201 | - **Enable Data Source Options:** Toggle the visibility of the Data Source drop-down in the main window.
202 | 
203 | - **Enable Deck Filter Options:** Toggle the visibility of the Deck Filter drop-down in the main window.
204 | 
205 | - **Enable Refresh Button:** Toggle the visibility of the Refresh button drop-down in the main window.
206 | 
207 | - **Enable Row Colors:** Sets the row color to the card color.
208 | 
209 | - **Enable Color Identity:** Once activated, the Colors field will showcase the mana symbols representing both the mana cost and abilities of a card, such as kicker, activated abilities, and more.
210 | 
211 | - **Enable Draft Stats:** Displays the draft stats table and drop-down in the main window.
212 | 
213 | - **Enable Missing Cards:** Displays the missing cards table in the main window.
214 | 
215 | - **Enable Highest Rated:** Enables the highest rated card logic for the `Auto` filter. See the auto highest rating note in the [Card Logic](#card-logic) section.
216 | 
217 | - **Enable Bayesian Average:** Enables the Bayesian average logic for all win rate fields. See the Bayesian average note in the [Card Logic](#card-logic) section.
218 |     - **As of September 2023, this feature has become obsolete. The 17Lands endpoint no longer provides win rate data for cards with fewer than 500 samples.**
219 | 
220 | - **Enable Draft Log:** Records the draft in a log file within the `./Logs` folder.
221 | 
222 | - <a id="ui-size">**UI Size:** Increase or decrease the size of the application text and images.</a>
223 | 
224 | ## Card Logic
225 | 
226 | - **Win Rate Grades:** Using the non-zero GIHWR values, the application will calculate the mean and standard deviation. Based on the number of standard deviations from the mean, it will then assign a letter grade.
227 |     - Example: If the mean win rate for the set is 56.8% and the standard deviation is 4.68, then a card with a win rate of 62% will have a letter grade of B+ since it's between 1 standard deviation (`56.8 + 1 * 4.68 = 61.48%`) and 1.33 standard deviations (`56.8 + 1.33 * 4.68 = 63.02%`) from the mean (see the table below).
228 | 
229 | 
230 | | Letter Grade     | Standard Deviations|
231 | |:----------------:|:------------------:|
232 | | A+               | >= 2.00            |
233 | | A                | >= 1.67            |
234 | | A-               | >= 1.33            |
235 | | B+               | >= 1.00            |
236 | | B                | >= 0.67            |
237 | | B-               | >= 0.33            |
238 | | C+               | >= 0               |
239 | | C                | >= -0.33           |
240 | | C-               | >= -0.67           |
241 | | D+               | >= -1.00           |
242 | | D                | >= -1.33           |
243 | | D-               | >= -1.67           |
244 | | F                | <  -1.67           |
245 | 
246 | - **Win Rate Ratings:** The application will calculate the mean and standard deviation to identify an upper and lower limit (-1.67 to 2.00 standard deviations from the mean) and perform the following calculation to determine a card's rating: `((card_gihwr - lower_limit) / (upper_limit - lower_limit)) * 5.0`
247 |     - Example: If the calculated mean and standard deviation for a set are 56.8% and 4.68, then the upper limit will be `56.8 + 2.00 * 4.68 = 66.16%`, the lower limit will be `56.8 - 1.67 * 4.68 = 48.98%`, and the resulting rating for a card with a win rate of 62% will be `(((62 - 48.98) / (66.16 - 48.98)) * 5.0 = 3.7)`
248 | 
249 | - <a id="bayesian-average">**Bayesian Average:** When this feature is activated, the win rate data is subjected to a Bayesian average calculation that takes into account specific assumptions  (e.g., an anticipated range of 40-60% with a mean of 50%). This Bayesian average considers both prior assumptions and observed data, providing a more reliable estimation of the win rate, particularly in cases where sample sizes are small (less than 200 samples) or data availability is limited. A comprehensive explanation can be found [here](https://github.com/bstaple1/MTGA_Draft_17Lands/issues/5#issuecomment-1075193138).</a>
250 |     - Enabled: The application will apply this calculation to all win rate data. However, the adjustment made by the calculation will gradually diminish as the sample count, such as the number of games in hand for the Games in Hand Win Rate, reaches 200. As the sample size increases, the Bayesian average will be more influenced by the observed data rather than the prior assumptions, resulting in a more reliable estimation of the win rate.
251 |     - Disabled: The application will not apply this calculation to the win rate data.
252 |     - **As of September 2023, this feature has become obsolete. The 17Lands endpoint no longer provides win rate data for cards with fewer than 500 samples.**
253 | 
254 | - **Auto Highest Rating:** If the `Auto` filter is set, and the user has taken at least 16 cards, then the application will try and determine the leading color combination from the taken cards. If the tool is unable to identify a definitive leading color pair, then it will display the highest win rate of the top two color combinations for each win rate field (e.g., GIHWR, OHWR, etc.). The filter label will display both color combinations separated by a slash (e.g., `Auto (WB/UBG)`).
255 |     - Example: If the user has taken primarily black, blue, and green cards, and Generous Visitor has a BG win rate of 66% and a UB rating of 15%, then the displayed win rate will be 66%.
256 |         
257 | - **Deck Suggester:** The deck suggester will create multiple decks (Aggro, Mid, and Control) for each viable color combination using a pool of cards with the highest win rates. It will follow generic deck building requirements. The suggester will assess and rate each deck, selecting the highest-rated one for each viable color combination. The deck suggester will NOT identify card synergies and build an intentionally synergistic deck. 
258 |     - Deck Building Requirements:
259 |         - Aggro Deck:
260 |             - The deck must have a minimum of 9 creatures and should have no less than 17 creatures.
261 |             - The deck should include a minimum of two 1-drops, five 2-drops, and three 3-drops.
262 |             - The average CMC (Converted Mana Cost)  of all of the creatures must be 2.40 or less.
263 |             - The deck has 16 lands.
264 |         - Mid Deck:
265 |             - The deck must have a minimum of 9 creatures and should have no less than 15 creatures.
266 |             - The deck should include a minimum of four 2-drops, three 3-drops, two 4-drops, and one 5-drop.
267 |             - The average CMC of all of the creatures must be 3.04 or less.
268 |             - The deck has 17 lands.
269 |         - Control Deck:
270 |             - The deck must have a minimum of 9 creatures and should have no less than 10 creatures.
271 |             - The deck should include a minimum of three 2-drops, two 3-drops, two 4-drops, and one 5-drop.
272 |             - The average CMC of all of the creatures must be 3.68 or less.      
273 |             - The deck has 18 lands.
274 |     - Notes:
275 |         - The CMC average and land requirements were derived from this [article](https://strategy.channelfireball.com/all-strategy/mtg/channelmagic-articles/how-many-lands-do-you-need-to-consistently-hit-your-land-drops/).
276 |         - The deck distribution and CMC requirements may occasionally lead to the inclusion of cards that have lower performance or are considered less effective.
277 |             Example: If the user possesses a pool of white and blue cards and the available 3-drops are Acquisition Octopus (53.7% win rate for WU) and Guardians of Oboro (50.7% win rate for WU), the deck suggester will include both of these cards to meet the 3-drop requirement for each deck archetype.
278 |         - The rating is determined by calculating the combined GIHWR of all the cards and then subtracting penalties for not meeting the deck requirements.
279 |         - The NEO creature sagas count as creatures.
280 | 
281 | ## Troubleshooting
282 | 
283 | - **Some cards are missing from the Taken Cards window:** Due to Arena creating a new player log after every restart, the application cannot track cards that were picked and seen prior to a restart. However, players who engage in drafting sessions spanning multiple days or sessions can still utilize this tool to access the current pack data. It should be noted that this application may not have access to information regarding previous packs and picks, resulting in some missing data.
284 | 
285 | - **The application can't generate set or debug files:** Windows users might need to run the application as an administrator if the application is installed in directory with restricted write access.
286 | 
287 | - **My sealed card pool is missing after restarting Arena:** Arena creates a new player log after every restart, so you will need to open up your sealed event session log by clicking `File->Open` and selecting the `DraftLog_<Set>_Sealed` file if you want to see your sealed card pool. Keep in mind that opening a log file will prevent the application from reading the Arena player log. Therefore, if you wish to initiate a new Arena event, you'll need to restart the application.
288 | 
289 | - **The tables are displaying a win rate of 0% or NA:** The application will display a card win rate value of 0% or NA if that win rate field has fewer than 500* samples (e.g., GIHWR will be 0% or NA if the number of games in hand is less than 500*). Users should consider using the premier draft dataset or downloading a [tier list](https://github.com/bstaple1/MTGA_Draft_17Lands/tree/main/Tools/TierScraper17Lands#tier-list-download-extension) for events that have a low player count.
290 |   - ***As of September 2023, the 17Lands endpoint no longer provides win rate data for cards with fewer than 500 samples.**
291 | 
292 | - **CTRL+G doesn't do anything:** If you're a Mac user, then this shortcut isn't available. If you're a Windows user, then you need to run the application as an administrator.
293 | 
294 | - **The set download process is taking 5+ minutes and I'm seeing _Collecting 17Lands Data - Request Failed_ multiple times:** If you attempt to download too many sets within a short period of time, 17Lands will impose rate-limiting on your connection. Therefore, when downloading multiple sets, it is advisable to wait at least 10 minutes between each set.
295 | 


--------------------------------------------------------------------------------
/src/file_extractor.py:
--------------------------------------------------------------------------------
   1 | """This module contains the functions and classes that are used for building the set files and communicating with platforms"""
   2 | from enum import Enum
   3 | from urllib.parse import quote as urlencode
   4 | from typing import Tuple
   5 | import sys
   6 | import os
   7 | import time
   8 | import json
   9 | import urllib.request
  10 | import datetime
  11 | import ssl
  12 | import itertools
  13 | import re
  14 | import sqlite3
  15 | import copy
  16 | from src import constants
  17 | from src.logger import create_logger
  18 | 
  19 | logger = create_logger()
  20 | 
  21 | if not os.path.exists(constants.SETS_FOLDER):
  22 |     os.makedirs(constants.SETS_FOLDER)
  23 | 
  24 | if not os.path.exists(constants.TIER_FOLDER):
  25 |     os.makedirs(constants.TIER_FOLDER)
  26 | 
  27 | if not os.path.exists(constants.TEMP_FOLDER):
  28 |     os.makedirs(constants.TEMP_FOLDER)
  29 | 
  30 | 
  31 | class Result(Enum):
  32 |     '''Enumeration class for file integrity results'''
  33 |     VALID = 0
  34 |     ERROR_MISSING_FILE = 1
  35 |     ERROR_UNREADABLE_FILE = 2
  36 | 
  37 | 
  38 | def initialize_card_data(card_data):
  39 |     card_data[constants.DATA_FIELD_DECK_COLORS] = {}
  40 |     for color in constants.DECK_COLORS:
  41 |         card_data[constants.DATA_FIELD_DECK_COLORS][color] = {
  42 |             x: 0.0 for x in constants.DATA_FIELD_17LANDS_DICT if x != constants.DATA_SECTION_IMAGES}
  43 | 
  44 | 
  45 | def check_set_data(set_data, ratings_data):
  46 |     '''Run through 17Lands card list and determine if there are any cards missing from the assembled set file'''
  47 |     for rated_card in ratings_data:
  48 |         try:
  49 |             card_found = False
  50 |             for card_id in set_data:
  51 |                 card_name = set_data[card_id][constants.DATA_FIELD_NAME].replace(
  52 |                     "///", "//")
  53 |                 if rated_card == card_name:
  54 |                     card_found = True
  55 |                     break
  56 |             if not card_found:
  57 |                 logger.error("Card %s Missing", rated_card)
  58 | 
  59 |         except Exception as error:
  60 |             logger.error(error)
  61 | 
  62 | 
  63 | def decode_mana_cost(encoded_cost):
  64 |     '''Parse the raw card mana_cost field and return the cards cmc and color identity list'''
  65 |     decoded_cost = ""
  66 |     cmc = 0
  67 |     if encoded_cost:
  68 |         cost_string = re.sub(r"\(|\)", "", encoded_cost)
  69 | 
  70 |         sections = cost_string[1:].split("o")
  71 |         for section in sections:
  72 |             cmc += int(section) if section.isnumeric() else 1
  73 | 
  74 |         decoded_cost = "".join(f"{{{x}}}" for x in sections)
  75 | 
  76 |     return decoded_cost, cmc
  77 | 
  78 | 
  79 | def retrieve_local_set_list(sets):
  80 |     '''Scans the Sets folder and returns a list of valid set files'''
  81 |     file_list = []
  82 |     main_sets = [v.seventeenlands[0] for k, v in sets.items()]
  83 |     for file in os.listdir(constants.SETS_FOLDER):
  84 |         try:
  85 |             name_segments = file.split("_")
  86 |             if len(name_segments) == 3:
  87 | 
  88 |                 if ((name_segments[0].upper() in main_sets) and
  89 |                     (name_segments[1] in constants.LIMITED_TYPES_DICT) and
  90 |                         (name_segments[2] == constants.SET_FILE_SUFFIX)):
  91 | 
  92 |                     set_name = list(sets.keys())[list(
  93 |                         main_sets).index(name_segments[0].upper())]
  94 |                     result, json_data = check_file_integrity(
  95 |                         os.path.join(constants.SETS_FOLDER, file))
  96 |                     if result == Result.VALID:
  97 |                         if json_data["meta"]["version"] == 1:
  98 |                             start_date, end_date = json_data["meta"]["date_range"].split(
  99 |                                 "->")
 100 |                         else:
 101 |                             start_date = json_data["meta"]["start_date"]
 102 |                             end_date = json_data["meta"]["end_date"]
 103 |                         file_list.append(
 104 |                             (set_name, name_segments[1], start_date, end_date))
 105 |         except Exception as error:
 106 |             logger.error(error)
 107 | 
 108 |     return file_list
 109 | 
 110 | 
 111 | def search_arena_log_locations(input_location=None):
 112 |     '''Searches local directories for the location of the Arena Player.log file'''
 113 |     log_location = ""
 114 |     try:
 115 |         paths = []
 116 | 
 117 |         if input_location:
 118 |             paths.extend(input_location)
 119 | 
 120 |         if sys.platform == constants.PLATFORM_ID_OSX:
 121 |             paths.extend([os.path.join(os.path.expanduser(
 122 |                 '~'), constants.LOG_LOCATION_OSX)])
 123 |         else:
 124 |             path_list = [constants.WINDOWS_DRIVES,
 125 |                          [constants.LOG_LOCATION_WINDOWS]]
 126 |             paths.extend([os.path.join(*x)
 127 |                          for x in itertools.product(*path_list)])
 128 | 
 129 |         for file_path in paths:
 130 |             if file_path:
 131 |                 logger.info("Arena Log: Searching File Path %s", file_path)
 132 |                 if os.path.exists(file_path):
 133 |                     log_location = file_path
 134 |                     break
 135 | 
 136 |     except Exception as error:
 137 |         logger.error(error)
 138 |     return log_location
 139 | 
 140 | 
 141 | def retrieve_arena_directory(log_location):
 142 |     '''Searches the Player.log file for the Arena install location (windows only)'''
 143 |     arena_directory = ""
 144 |     try:
 145 |         # Retrieve the arena directory
 146 |         with open(log_location, 'r', encoding="utf-8", errors="replace") as log_file:
 147 |             line = log_file.readline()
 148 |             location = re.findall(r"'(.*?)/Managed'", line, re.DOTALL)
 149 |             if location and os.path.exists(location[0]):
 150 |                 arena_directory = location[0]
 151 | 
 152 |     except Exception as error:
 153 |         logger.error(error)
 154 |     return arena_directory
 155 | 
 156 | 
 157 | def search_local_files(paths, file_prefixes):
 158 |     '''Generic function that's used for searching local directories for a file'''
 159 |     file_locations = []
 160 |     for file_path in paths:
 161 |         try:
 162 |             if os.path.exists(file_path):
 163 |                 for prefix in file_prefixes:
 164 |                     files = [filename for filename in os.listdir(
 165 |                         file_path) if filename.startswith(prefix)]
 166 | 
 167 |                     for file in files:
 168 |                         file_location = os.path.join(file_path, file)
 169 |                         file_locations.append(file_location)
 170 | 
 171 |         except Exception as error:
 172 |             logger.error(error)
 173 | 
 174 |     return file_locations
 175 | 
 176 | 
 177 | def extract_types(type_line):
 178 |     '''Parses a type string and returns a list of card types'''
 179 |     types = []
 180 |     if constants.CARD_TYPE_CREATURE in type_line:
 181 |         types.append(constants.CARD_TYPE_CREATURE)
 182 | 
 183 |     if constants.CARD_TYPE_PLANESWALKER in type_line:
 184 |         types.append(constants.CARD_TYPE_PLANESWALKER)
 185 | 
 186 |     if constants.CARD_TYPE_LAND in type_line:
 187 |         types.append(constants.CARD_TYPE_LAND)
 188 | 
 189 |     if constants.CARD_TYPE_INSTANT in type_line:
 190 |         types.append(constants.CARD_TYPE_INSTANT)
 191 | 
 192 |     if constants.CARD_TYPE_SORCERY in type_line:
 193 |         types.append(constants.CARD_TYPE_SORCERY)
 194 | 
 195 |     if constants.CARD_TYPE_ENCHANTMENT in type_line:
 196 |         types.append(constants.CARD_TYPE_ENCHANTMENT)
 197 | 
 198 |     if constants.CARD_TYPE_ARTIFACT in type_line:
 199 |         types.append(constants.CARD_TYPE_ARTIFACT)
 200 | 
 201 |     return types
 202 | 
 203 | 
 204 | def check_date(date):
 205 |     '''Checks a date string and returns false if the date is in the future'''
 206 |     result = True
 207 |     try:
 208 |         parts = date.split("-")
 209 |         year = int(parts[0])
 210 |         month = int(parts[1])
 211 |         day = int(parts[2])
 212 |         hour = 0
 213 | 
 214 |         if datetime.datetime(year=year, month=month, day=day, hour=hour) > datetime.datetime.now():
 215 |             result = False
 216 | 
 217 |     except Exception:
 218 |         result = False
 219 |     return result
 220 | 
 221 | 
 222 | def check_file_integrity(filename):
 223 |     '''Extracts data from a file to determine if it's formatted correctly'''
 224 |     result = Result.VALID
 225 |     json_data = {}
 226 | 
 227 |     try:
 228 |         with open(filename, 'r', encoding="utf-8", errors="replace") as json_file:
 229 |             json_data = json_file.read()
 230 |     except FileNotFoundError:
 231 |         return Result.ERROR_MISSING_FILE, json_data
 232 | 
 233 |     try:
 234 |         json_data = json.loads(json_data)
 235 | 
 236 |         if json_data.get("meta"):
 237 |             meta = json_data["meta"]
 238 |             version = meta.get("version")
 239 |             if version == 1:
 240 |                 meta.get("date_range", "").split("->")
 241 |             else:
 242 |                 meta.get("start_date")
 243 |                 meta.get("end_date")
 244 |         else:
 245 |             return Result.ERROR_UNREADABLE_FILE, json_data
 246 | 
 247 |         cards = json_data.get("card_ratings")
 248 |         if isinstance(cards, dict) and len(cards) >= 100:
 249 |             for card in cards.values():
 250 |                 card.get(constants.DATA_FIELD_NAME)
 251 |                 card.get(constants.DATA_FIELD_COLORS)
 252 |                 card.get(constants.DATA_FIELD_CMC)
 253 |                 card.get(constants.DATA_FIELD_TYPES)
 254 |                 card.get("mana_cost")
 255 |                 card.get(constants.DATA_SECTION_IMAGES)
 256 |                 deck_colors = card.get(constants.DATA_FIELD_DECK_COLORS, {}).get(
 257 |                     constants.FILTER_OPTION_ALL_DECKS, {})
 258 |                 deck_colors.get(constants.DATA_FIELD_GIHWR)
 259 |                 deck_colors.get(constants.DATA_FIELD_ALSA)
 260 |                 deck_colors.get(constants.DATA_FIELD_IWD)
 261 |                 break
 262 |         else:
 263 |             return Result.ERROR_UNREADABLE_FILE, json_data
 264 | 
 265 |     except json.JSONDecodeError:
 266 |         return Result.ERROR_UNREADABLE_FILE, json_data
 267 | 
 268 |     return result, json_data
 269 | 
 270 | 
 271 | class FileExtractor:
 272 |     '''Class that handles the creation of set files and the retrieval of platform information'''
 273 | 
 274 |     def __init__(self, directory):
 275 |         self.selected_sets = []
 276 |         self.set_list = []
 277 |         self.draft = ""
 278 |         self.session = ""
 279 |         self.start_date = ""
 280 |         self.end_date = ""
 281 |         self.directory = directory
 282 |         self.context = ssl.SSLContext()
 283 |         self.card_ratings = {}
 284 |         self.combined_data = {
 285 |             "meta": {"collection_date": str(datetime.datetime.now())}}
 286 |         self.card_dict = {}
 287 |         self.deck_colors = constants.DECK_COLORS
 288 |         self.sets_17lands = []
 289 | 
 290 |     def clear_data(self):
 291 |         '''Clear stored set information'''
 292 |         self.combined_data = {
 293 |             "meta": {"collection_date": str(datetime.datetime.now())}}
 294 |         self.card_dict = {}
 295 |         self.card_ratings = {}
 296 | 
 297 |     def select_sets(self, sets):
 298 |         '''Public function that's used for setting class variables'''
 299 |         self.selected_sets = sets
 300 | 
 301 |     def set_draft_type(self, draft_type):
 302 |         '''Public function that's used for setting class variables'''
 303 |         self.draft = draft_type
 304 | 
 305 |     def set_start_date(self, start_date):
 306 |         '''Sets the start data in a set file'''
 307 |         result = False
 308 |         if check_date(start_date):
 309 |             result = True
 310 |             self.start_date = start_date
 311 |             self.combined_data["meta"]["start_date"] = self.start_date
 312 |         return result
 313 | 
 314 |     def set_end_date(self, end_date):
 315 |         '''Sets the end date in a set file'''
 316 |         result = False
 317 |         if check_date(end_date):
 318 |             result = True
 319 |             self.end_date = end_date
 320 |             self.combined_data["meta"]["end_date"] = self.end_date
 321 |         return result
 322 | 
 323 |     def set_version(self, version):
 324 |         '''Sets the version in a set file'''
 325 |         self.combined_data["meta"]["version"] = version
 326 | 
 327 |     def download_card_data(self, ui_root, progress_bar, status, database_size):
 328 |         '''Wrapper function for starting the set file download/creation process'''
 329 |         result = False
 330 |         result_string = ""
 331 |         temp_size = 0
 332 |         try:
 333 |             result, result_string, temp_size = self._download_expansion(
 334 |                 ui_root, progress_bar, status, database_size)
 335 | 
 336 |         except Exception as error:
 337 |             logger.error(error)
 338 |             result_string = error
 339 | 
 340 |         return result, result_string, temp_size
 341 | 
 342 |     def _download_expansion(self, ui_root, progress_bar, status, database_size):
 343 |         ''' Function that performs the following steps:
 344 |             1. Build a card data file from local Arena files (stored as temp_card_data.json in the Temp folder)
 345 |                - The card sets contains the Arena IDs, card name, mana cost, colors, etc.
 346 |             1A. Collect the card data from Scryfall if it's unavailable locally (fallback)
 347 |             2. Collect the card_ratings data from scryfall
 348 |             3. Build a set file by combining the card data and the card ratings
 349 |         '''
 350 |         result = False
 351 |         result_string = ""
 352 |         temp_size = 0
 353 |         try:
 354 |             while True:
 355 |                 progress_bar['value'] = 5
 356 |                 ui_root.update()
 357 | 
 358 |                 result, result_string, temp_size = self._retrieve_local_arena_data(
 359 |                     ui_root, status, database_size)
 360 | 
 361 |                 if not result:
 362 |                     result, result_string = self._retrieve_scryfall_data(
 363 |                         ui_root, status)
 364 |                     if not result:
 365 |                         break
 366 | 
 367 |                 progress_bar['value'] = 10
 368 |                 status.set("Collecting 17Lands Data")
 369 |                 ui_root.update()
 370 | 
 371 |                 if not self.retrieve_17lands_data(self.selected_sets.seventeenlands,
 372 |                                                   self.deck_colors,
 373 |                                                   ui_root,
 374 |                                                   progress_bar,
 375 |                                                   progress_bar['value'],
 376 |                                                   status):
 377 |                     result = False
 378 |                     result_string = "Couldn't Collect 17Lands Data"
 379 |                     break
 380 | 
 381 |                 matching_only = True if constants.SET_SELECTION_ALL in self.selected_sets.arena else False
 382 | 
 383 |                 if not matching_only:
 384 |                     self._initialize_17lands_data()
 385 | 
 386 |                 status.set("Building Data Set File")
 387 |                 ui_root.update()
 388 |                 self._assemble_set(matching_only)
 389 |                 check_set_data(
 390 |                     self.combined_data["card_ratings"], self.card_ratings)
 391 |                 break
 392 | 
 393 |         except Exception as error:
 394 |             logger.error(error)
 395 |             result_string = error
 396 | 
 397 |         return result, result_string, temp_size
 398 | 
 399 |     def _retrieve_local_arena_data(self, root, status, previous_database_size):
 400 |         '''Builds a card data file from raw Arena files'''
 401 |         result_string = "Couldn't Collect Local Card Data"
 402 |         result = False
 403 |         self.card_dict = {}
 404 |         database_size = 0
 405 |         status.set("Searching Local Files")
 406 |         root.update()
 407 |         if sys.platform == constants.PLATFORM_ID_OSX:
 408 |             directory = os.path.join(os.path.expanduser('~'),
 409 |                                      constants.LOCAL_DATA_FOLDER_PATH_OSX) if not self.directory else self.directory
 410 |             paths = [os.path.join(directory, constants.LOCAL_DOWNLOADS_DATA)]
 411 |         elif sys.platform == constants.PLATFORM_ID_LINUX:
 412 |             if constants.LOCAL_DATA_FOLDER_PATH_LINUX:
 413 |                 directory = constants.LOCAL_DATA_FOLDER_PATH_LINUX
 414 |                 paths = [os.path.join(directory, constants.LOCAL_DOWNLOADS_DATA)]
 415 |         else:
 416 |             if not self.directory:
 417 |                 path_list = [constants.WINDOWS_DRIVES, constants.WINDOWS_PROGRAM_FILES, [
 418 |                     constants.LOCAL_DATA_FOLDER_PATH_WINDOWS]]
 419 |                 paths = [os.path.join(*x)
 420 |                          for x in itertools.product(*path_list)]
 421 |             else:
 422 |                 paths = [os.path.join(
 423 |                     self.directory, constants.LOCAL_DOWNLOADS_DATA)]
 424 | 
 425 |         arena_database_locations = search_local_files(
 426 |             paths, [constants.LOCAL_DATA_FILE_PREFIX_DATABASE])
 427 | 
 428 |         while True:
 429 |             try:
 430 |                 if not arena_database_locations:
 431 |                     logger.error("Can't Locate Local Files")
 432 |                     break
 433 | 
 434 |                 current_database_size = os.path.getsize(
 435 |                     arena_database_locations[0])
 436 | 
 437 |                 if current_database_size != previous_database_size:
 438 |                     logger.info(
 439 |                         "Local File Change Detected %d, %d",
 440 |                         current_database_size, previous_database_size)
 441 |                     logger.info(
 442 |                         "Local Database Data: Searching File Path %s",
 443 |                         arena_database_locations[0])
 444 |                     status.set("Retrieving Localization Data")
 445 |                     root.update()
 446 |                     result, card_text, card_enumerators, raw_card_data = self._retrieve_local_database(
 447 |                         arena_database_locations[0])
 448 | 
 449 |                     if not result:
 450 |                         break
 451 | 
 452 |                     status.set("Building Temporary Card Data File")
 453 |                     root.update()
 454 |                     result = self._assemble_stored_data(
 455 |                         card_text, card_enumerators, raw_card_data)
 456 | 
 457 |                     if not result:
 458 |                         break
 459 | 
 460 |                 # Assemble information for local data set
 461 |                 status.set("Retrieving Temporary Card Data")
 462 |                 root.update()
 463 |                 result = self._retrieve_stored_data(
 464 |                     self.selected_sets.arena)
 465 | 
 466 |                 database_size = current_database_size
 467 | 
 468 |             except Exception as error:
 469 |                 logger.error(error)
 470 |             break
 471 | 
 472 |         if not result:
 473 |             logger.error(result_string)
 474 | 
 475 |         return result, result_string, database_size
 476 | 
 477 |     def _retrieve_local_cards(self, data):
 478 |         '''Function that retrieves pertinent card data from raw Arena files'''
 479 |         result = False
 480 |         card_data = {}
 481 |         try:
 482 |             for card in data:
 483 |                 # Making all of the keys lowercase
 484 |                 card = {k.lower(): v for k, v in card.items()}
 485 |                 try:
 486 |                     card_set = card[constants.LOCAL_CARDS_KEY_SET]
 487 |                     if ((card[constants.LOCAL_CARDS_KEY_DIGITAL_RELEASE_SET]) and
 488 |                        (re.findall(r"^[yY]\d{2}$", card_set, re.DOTALL))):
 489 |                         card_set = card[constants.LOCAL_CARDS_KEY_DIGITAL_RELEASE_SET]
 490 |                     if card_set not in card_data:
 491 |                         card_data[card_set] = {}
 492 |                     if card[constants.LOCAL_CARDS_KEY_TOKEN]:
 493 |                         # Skip tokens
 494 |                         continue
 495 |                     if not card[constants.LOCAL_CARDS_KEY_TITLE_ID]:
 496 |                         # Skip cards that don't have titles
 497 |                         continue
 498 |                     group_id = card[constants.LOCAL_CARDS_KEY_GROUP_ID]
 499 | 
 500 |                     card_data[card_set][group_id] = {
 501 |                         constants.DATA_FIELD_NAME: [card[constants.LOCAL_CARDS_KEY_TITLE_ID]],
 502 |                         constants.DATA_FIELD_CMC: 0,
 503 |                         constants.DATA_FIELD_MANA_COST: "",
 504 |                         constants.LOCAL_CARDS_KEY_PRIMARY: 1,
 505 |                         constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE: 0,
 506 |                         constants.DATA_FIELD_TYPES: [],
 507 |                         constants.DATA_FIELD_RARITY: "",
 508 |                         constants.DATA_SECTION_IMAGES: []}
 509 | 
 510 |                     mana_cost, cmc = decode_mana_cost(
 511 |                         card[constants.LOCAL_CARDS_KEY_CASTING_COST]) if card[constants.LOCAL_CARDS_KEY_CASTING_COST] else ("", 0)
 512 |                     card_data[card_set][group_id][constants.DATA_FIELD_CMC] = cmc
 513 |                     card_data[card_set][group_id][constants.DATA_FIELD_MANA_COST] = mana_cost
 514 |                     card_data[card_set][group_id][constants.DATA_FIELD_TYPES].extend([int(
 515 |                         x) for x in card[constants.LOCAL_CARDS_KEY_TYPES].split(',')] if card[constants.LOCAL_CARDS_KEY_TYPES] else [])
 516 |                     card_data[card_set][group_id][constants.DATA_FIELD_COLORS] = [int(
 517 |                         x) for x in card[constants.LOCAL_CARDS_KEY_COLOR_ID].split(',')] if card[constants.LOCAL_CARDS_KEY_COLOR_ID] else []
 518 | 
 519 |                     card_data[card_set][group_id][constants.DATA_FIELD_RARITY] = constants.CARD_RARITY_DICT[card[constants.LOCAL_CARDS_KEY_RARITY]
 520 |                                                                                                             ] if card[constants.LOCAL_CARDS_KEY_RARITY] in constants.CARD_RARITY_DICT else constants.CARD_RARITY_COMMON
 521 |                     card_data[card_set][group_id][constants.LOCAL_CARDS_KEY_PRIMARY] = card[constants.LOCAL_CARDS_KEY_PRIMARY]
 522 |                     card_data[card_set][group_id][constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE] = card[constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE]
 523 | 
 524 |                     self._process_linked_faces(
 525 |                         card, card_data, card_set, group_id)
 526 | 
 527 |                     result = True
 528 |                 except Exception as error:
 529 |                     logger.error(
 530 |                         f"Card Read Error: {error}, {card}")
 531 |                     break
 532 |         except Exception as error:
 533 |             logger.error(error)
 534 | 
 535 |         return result, card_data
 536 | 
 537 |     def _process_linked_faces(self, card, card_data, card_set, group_id):
 538 |         ''''''
 539 |         try:
 540 | 
 541 |             if card[constants.LOCAL_CARDS_KEY_LINKED_FACES]:
 542 |                 linked_ids = [
 543 |                     int(x) for x in card[constants.LOCAL_CARDS_KEY_LINKED_FACES].split(',')]
 544 |                 for linked_id in linked_ids:
 545 |                     if linked_id < group_id:
 546 |                         if (not card[constants.LOCAL_CARDS_KEY_PRIMARY] and
 547 |                                 card_data[card_set][linked_id][constants.LOCAL_CARDS_KEY_PRIMARY]):
 548 |                             # Add types to previously seen linked cards
 549 |                             types = [int(x) for x in card[constants.LOCAL_CARDS_KEY_TYPES].split(
 550 |                                 ',')] if card[constants.LOCAL_CARDS_KEY_TYPES] else []
 551 |                             card_data[card_set][linked_id][constants.LOCAL_CARDS_KEY_TYPES].extend(
 552 |                                 types)
 553 | 
 554 |                             # Use the lowest mana cost/CMC for dual-faced cards (e.g., 4 for Dusk /// Dawn)
 555 |                             if (card[constants.LOCAL_CARDS_KEY_CASTING_COST] and
 556 |                                 card_data[card_set][linked_id][constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE] and
 557 |                                     card_data[card_set][linked_id][constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE] == 6):
 558 | 
 559 |                                 mana_cost, cmc = decode_mana_cost(
 560 |                                     card[constants.LOCAL_CARDS_KEY_CASTING_COST])
 561 |                                 if cmc < card_data[card_set][linked_id][constants.DATA_FIELD_CMC]:
 562 |                                     card_data[card_set][linked_id][constants.DATA_FIELD_CMC] = cmc
 563 |                                     card_data[card_set][linked_id][constants.DATA_FIELD_MANA_COST] = mana_cost
 564 | 
 565 |                         elif card[constants.LOCAL_CARDS_KEY_PRIMARY]:
 566 |                             # Retrieve types from previously seen linked cards
 567 |                             card_data[card_set][group_id][constants.LOCAL_CARDS_KEY_TYPES].extend(
 568 |                                 card_data[card_set][linked_id][constants.LOCAL_CARDS_KEY_TYPES])
 569 | 
 570 |                             # Use the lowest cmc for dual-faced cards (e.g., 4 for Dusk /// Dawn)
 571 |                             if (card[constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE] and
 572 |                                     card[constants.LOCAL_CARDS_KEY_LINKED_FACE_TYPE] == 6):
 573 | 
 574 |                                 if card_data[card_set][linked_id][constants.DATA_FIELD_CMC] < card_data[card_set][group_id][constants.DATA_FIELD_CMC]:
 575 |                                     card_data[card_set][group_id][constants.DATA_FIELD_CMC] = card_data[
 576 |                                         card_set][group_id][constants.DATA_FIELD_CMC]
 577 |                                     card_data[card_set][group_id][constants.DATA_FIELD_MANA_COST] = card_data[
 578 |                                         card_set][group_id][constants.DATA_FIELD_MANA_COST]
 579 | 
 580 |         except Exception as error:
 581 |             logger.error(error)
 582 | 
 583 |     def _retrieve_local_database(self, file_location):
 584 |         '''Retrieves localization and enumeration data from an Arena database'''
 585 |         result = False
 586 |         card_text = {}
 587 |         card_enumerators = {}
 588 |         card_data = {}
 589 |         try:
 590 |             # Open Sqlite3 database
 591 |             while True:
 592 |                 connection = sqlite3.connect(file_location)
 593 |                 connection.row_factory = sqlite3.Row
 594 |                 cursor = connection.cursor()
 595 | 
 596 |                 rows = [dict(row) for row in cursor.execute(
 597 |                     constants.LOCAL_DATABASE_LOCALIZATION_QUERY)]
 598 | 
 599 |                 if not rows:
 600 |                     break
 601 | 
 602 |                 result, card_text = self._retrieve_local_card_text(rows)
 603 | 
 604 |                 if not result:
 605 |                     break
 606 | 
 607 |                 rows = [dict(row) for row in cursor.execute(
 608 |                     constants.LOCAL_DATABASE_ENUMERATOR_QUERY)]
 609 | 
 610 |                 if not rows:
 611 |                     break
 612 | 
 613 |                 result, card_enumerators = self._retrieve_local_card_enumerators(
 614 |                     rows)
 615 | 
 616 |                 if not result:
 617 |                     break
 618 | 
 619 |                 rows = [dict(row) for row in cursor.execute(
 620 |                     constants.LOCAL_DATABASE_CARDS_QUERY)]
 621 | 
 622 |                 result, card_data = self._retrieve_local_cards(rows)
 623 |                 break
 624 | 
 625 |         except Exception as error:
 626 |             result = False
 627 |             logger.error(error)
 628 | 
 629 |         return result, card_text, card_enumerators, card_data
 630 | 
 631 |     def _retrieve_local_card_text(self, data):
 632 |         '''Returns a dict containing localization data'''
 633 |         result = True
 634 |         card_text = {}
 635 |         try:
 636 |             # Retrieve the title (card name) for each of the collected arena IDs
 637 |             card_text = {x[constants.LOCAL_DATABASE_LOCALIZATION_COLUMN_ID]                         : x[constants.LOCAL_DATABASE_LOCALIZATION_COLUMN_TEXT] for x in data}
 638 | 
 639 |         except Exception as error:
 640 |             result = False
 641 |             logger.error(error)
 642 | 
 643 |         return result, card_text
 644 | 
 645 |     def _retrieve_local_card_enumerators(self, data):
 646 |         '''Returns a dict containing card enumeration data'''
 647 |         result = True
 648 |         card_enumerators = {constants.DATA_FIELD_COLORS: {},
 649 |                             constants.DATA_FIELD_TYPES: {}}
 650 |         try:
 651 |             for row in data:
 652 |                 if row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_TYPE] == constants.LOCAL_DATABASE_ENUMERATOR_TYPE_CARD_TYPES:
 653 |                     card_enumerators[constants.DATA_FIELD_TYPES][row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_VALUE]
 654 |                                                                  ] = row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_ID]
 655 |                 elif row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_TYPE] == constants.LOCAL_DATABASE_ENUMERATOR_TYPE_COLOR:
 656 |                     card_enumerators[constants.DATA_FIELD_COLORS][row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_VALUE]
 657 |                                                                   ] = row[constants.LOCAL_DATABASE_ENUMERATOR_COLUMN_ID]
 658 | 
 659 |         except Exception as error:
 660 |             result = False
 661 |             logger.error(error)
 662 | 
 663 |         return result, card_enumerators
 664 | 
 665 |     def _assemble_stored_data(self, card_text, card_enumerators, card_data):
 666 |         '''Creates a temporary card data file from data collected from local Arena files'''
 667 |         result = False
 668 |         try:
 669 |             for card_set in card_data:
 670 |                 for card in card_data[card_set]:
 671 |                     try:
 672 |                         card_data[card_set][card][constants.DATA_FIELD_NAME] = " // ".join(
 673 |                             card_text[x] for x in card_data[card_set][card][constants.DATA_FIELD_NAME])
 674 |                         card_data[card_set][card][constants.DATA_FIELD_TYPES] = list(set(
 675 |                             [card_text[card_enumerators[constants.DATA_FIELD_TYPES][x]] for x in card_data[card_set][card][constants.DATA_FIELD_TYPES]]))
 676 |                         card_data[card_set][card][constants.DATA_FIELD_COLORS] = [
 677 |                             constants.CARD_COLORS_DICT[card_text[card_enumerators[constants.DATA_FIELD_COLORS][x]]] for x in card_data[card_set][card][constants.DATA_FIELD_COLORS]]
 678 |                         if constants.CARD_TYPE_CREATURE in card_data[card_set][card][constants.DATA_FIELD_TYPES]:
 679 |                             index = card_data[card_set][card][constants.DATA_FIELD_TYPES].index(
 680 |                                 constants.CARD_TYPE_CREATURE)
 681 |                             card_data[card_set][card][constants.DATA_FIELD_TYPES].insert(
 682 |                                 0, card_data[card_set][card][constants.DATA_FIELD_TYPES].pop(index))
 683 |                         result = True
 684 |                     except Exception:
 685 |                         pass
 686 | 
 687 |             if result:
 688 |                 # Store all of the processed card data
 689 |                 with open(constants.TEMP_CARD_DATA_FILE, 'w', encoding="utf-8", errors="replace") as json_file:
 690 |                     json.dump(card_data, json_file)
 691 | 
 692 |         except Exception as error:
 693 |             result = False
 694 |             logger.error(error)
 695 | 
 696 |         return result
 697 | 
 698 |     def _retrieve_stored_data(self, set_list):
 699 |         '''Retrieves card data from the temp_card_data.json file stored in the Temp folder'''
 700 |         result = False
 701 |         self.card_dict = {}
 702 |         try:
 703 |             with open(constants.TEMP_CARD_DATA_FILE, 'r', encoding="utf-8", errors="replace") as data:
 704 |                 json_file = data.read()
 705 |                 json_data = json.loads(json_file)
 706 | 
 707 |             if constants.SET_SELECTION_ALL in set_list:
 708 |                 for card_data in json_data.values():
 709 |                     self.card_dict.update(card_data.copy())
 710 |             else:
 711 |                 for search_set in set_list:
 712 |                     matching_sets = list(
 713 |                         filter(lambda x, ss=search_set: ss in x, json_data))
 714 |                     for match in matching_sets:
 715 |                         self.card_dict.update(json_data[match].copy())
 716 | 
 717 |             if self.card_dict:
 718 |                 result = True
 719 | 
 720 |         except Exception as error:
 721 |             result = False
 722 |             logger.error(error)
 723 | 
 724 |         return result
 725 | 
 726 |     def _retrieve_scryfall_data(self, root, status):
 727 |         '''Use the Scryfall API to retrieve the set data needed for building a card set file*
 728 |            - This is a fallback feature feature that's used in case there's an issue with the local Arena files
 729 |         '''
 730 |         result = False
 731 |         self.card_dict = {}
 732 |         result_string = "Couldn't Retrieve Card Data"
 733 |         url = ""
 734 |         for card_set in self.selected_sets.scryfall:
 735 |             retry = constants.SCRYFALL_REQUEST_ATTEMPT_MAX
 736 |             while retry:
 737 |                 try:
 738 |                     status.set("Collecting Scryfall Data")
 739 |                     root.update()
 740 |                     url = "https://api.scryfall.com/cards/search?order=set&unique=prints&q=e" + \
 741 |                         urlencode(':', safe='') + f"{card_set}"
 742 |                     url_data = urllib.request.urlopen(
 743 |                         url, context=self.context).read()
 744 | 
 745 |                     set_json_data = json.loads(url_data)
 746 | 
 747 |                     result, result_string = self._process_scryfall_data(
 748 |                         set_json_data["data"])
 749 | 
 750 |                     while set_json_data["has_more"]:
 751 |                         url = set_json_data["next_page"]
 752 |                         url_data = urllib.request.urlopen(
 753 |                             url, context=self.context).read()
 754 |                         set_json_data = json.loads(url_data)
 755 |                         result, result_string = self._process_scryfall_data(
 756 |                             set_json_data["data"])
 757 | 
 758 |                     if self.card_dict:
 759 |                         result = True
 760 |                         break
 761 | 
 762 |                 except Exception as error:
 763 |                     logger.error(url)
 764 |                     logger.error(error)
 765 | 
 766 |                 if not result:
 767 |                     retry -= 1
 768 | 
 769 |                     if retry:
 770 |                         attempt_count = constants.CARD_RATINGS_ATTEMPT_MAX - retry
 771 |                         status.set(
 772 |                             f"""Collecting Scryfall Data - Request Failed ({attempt_count}/{constants.SCRYFALL_REQUEST_ATTEMPT_MAX}) - Retry in {constants.SCRYFALL_REQUEST_BACKOFF_DELAY_SECONDS} seconds""")
 773 |                         root.update()
 774 |                         time.sleep(
 775 |                             constants.SCRYFALL_REQUEST_BACKOFF_DELAY_SECONDS)
 776 |         return result, result_string
 777 | 
 778 |     def _initialize_17lands_data(self):
 779 |         '''Initialize the 17Lands data by setting the fields to 0 in case there are gaps in the downloaded card data'''
 780 |         for data in self.card_dict.values():
 781 |             initialize_card_data(data)
 782 | 
 783 |     def retrieve_17lands_data(self, sets, deck_colors, root, progress, initial_progress, status):
 784 |         '''Use the 17Lands endpoint to download the card ratings data for all of the deck filter options'''
 785 |         self.card_ratings = {}
 786 |         current_progress = 0
 787 |         result = False
 788 |         url = ""
 789 |         for set_code in sets:
 790 |             for color in deck_colors:
 791 |                 retry = constants.CARD_RATINGS_ATTEMPT_MAX
 792 |                 result = False
 793 |                 while retry:
 794 | 
 795 |                     try:
 796 |                         status.set(f"Collecting {color} 17Lands Data")
 797 |                         root.update()
 798 |                         url = f"https://www.17lands.com/card_ratings/data?expansion={set_code}&format={self.draft}&start_date={self.start_date}&end_date={self.end_date}"
 799 | 
 800 |                         if color != constants.FILTER_OPTION_ALL_DECKS:
 801 |                             url += "&colors=" + color
 802 |                         url_data = urllib.request.urlopen(
 803 |                             url, context=self.context).read()
 804 | 
 805 |                         set_json_data = json.loads(url_data)
 806 |                         self._process_17lands_data(color, set_json_data)
 807 |                         result = True
 808 |                         break
 809 |                     except Exception as error:
 810 |                         logger.error(url)
 811 |                         logger.error(error)
 812 |                         retry -= 1
 813 | 
 814 |                         if retry:
 815 |                             attempt_count = constants.CARD_RATINGS_ATTEMPT_MAX - retry
 816 |                             status.set(
 817 |                                 f"""Collecting {color} 17Lands Data - Request Failed ({attempt_count}/{constants.CARD_RATINGS_ATTEMPT_MAX}) - Retry in {constants.CARD_RATINGS_BACKOFF_DELAY_SECONDS} seconds""")
 818 |                             root.update()
 819 |                             time.sleep(
 820 |                                 constants.CARD_RATINGS_BACKOFF_DELAY_SECONDS)
 821 | 
 822 |                 if result:
 823 |                     current_progress += (3 /
 824 |                                          len(self.selected_sets.seventeenlands))
 825 |                     progress['value'] = current_progress + initial_progress
 826 |                     root.update()
 827 |                 else:
 828 |                     break
 829 |                 time.sleep(constants.CARD_RATINGS_INTER_DELAY_SECONDS)
 830 | 
 831 |         return result
 832 | 
 833 |     def _assemble_set(self, matching_only):
 834 |         '''Combine the 17Lands ratings and the card data to form the complete set data'''
 835 |         self.combined_data["card_ratings"] = {}
 836 |         for card, card_data in self.card_dict.items():
 837 |             if self._process_card_data(card_data):
 838 |                 self.combined_data["card_ratings"][card] = card_data
 839 |             elif not matching_only:
 840 |                 self.combined_data["card_ratings"][card] = card_data
 841 | 
 842 |     def retrieve_17lands_color_ratings(self):
 843 |         '''Use 17Lands endpoint to collect the data from the color_ratings page'''
 844 |         try:
 845 |             url = f"https://www.17lands.com/color_ratings/data?expansion={self.selected_sets.seventeenlands[0]}&event_type={self.draft}&start_date={self.start_date}&end_date={self.end_date}&combine_splash=true"
 846 |             url_data = urllib.request.urlopen(url, context=self.context).read()
 847 | 
 848 |             color_json_data = json.loads(url_data)
 849 |             self._process_17lands_color_ratings(color_json_data)
 850 | 
 851 |         except Exception as error:
 852 |             logger.error(url)
 853 |             logger.error(error)
 854 | 
 855 |     def _process_17lands_data(self, colors, cards):
 856 |         '''Parse the 17Lands json data to extract the card ratings'''
 857 |         result = True
 858 | 
 859 |         for card in cards:
 860 |             try:
 861 |                 card_data = {constants.DATA_SECTION_RATINGS: [],
 862 |                              constants.DATA_SECTION_IMAGES: []}
 863 |                 color_data = {colors: {}}
 864 |                 for key, value in constants.DATA_FIELD_17LANDS_DICT.items():
 865 |                     if key == constants.DATA_SECTION_IMAGES:
 866 |                         for field in value:
 867 |                             if field in card and len(card[field]):
 868 |                                 image_url = f"{constants.URL_17LANDS}{card[field]}" if card[field].startswith(
 869 |                                     constants.IMAGE_17LANDS_SITE_PREFIX) else card[field]
 870 |                                 card_data[constants.DATA_SECTION_IMAGES].append(
 871 |                                     image_url)
 872 |                     elif value in card:
 873 |                         if (key in constants.WIN_RATE_OPTIONS) or (key == constants.DATA_FIELD_IWD):
 874 |                             color_data[colors][key] = round(
 875 |                                 float(card[value]) * 100.0, 2) if card[value] else 0.0
 876 |                         elif ((key == constants.DATA_FIELD_ATA) or
 877 |                               (key == constants.DATA_FIELD_ALSA)):
 878 |                             color_data[colors][key] = round(
 879 |                                 float(card[value]), 2)
 880 |                         else:
 881 |                             color_data[colors][key] = int(card[value])
 882 | 
 883 |                 card_name = card[constants.DATA_FIELD_NAME]
 884 | 
 885 |                 if card_name not in self.card_ratings:
 886 |                     self.card_ratings[card_name] = card_data
 887 | 
 888 |                 self.card_ratings[card_name][constants.DATA_SECTION_RATINGS].append(
 889 |                     color_data)
 890 | 
 891 |             except Exception as error:
 892 |                 result = False
 893 |                 logger.error(error)
 894 | 
 895 |         return result
 896 | 
 897 |     def _process_17lands_color_ratings(self, colors):
 898 |         '''Parse the 17Lands json data to collect the color ratings'''
 899 |         color_ratings_dict = {
 900 |             "Mono-White": "W",
 901 |             "Mono-Blue": "U",
 902 |             "Mono-Black": "B",
 903 |             "Mono-Red": "R",
 904 |             "Mono-Green": "G",
 905 |             "(WU)": "WU",
 906 |             "(UB)": "UB",
 907 |             "(BR)": "BR",
 908 |             "(RG)": "RG",
 909 |             "(GW)": "GW",
 910 |             "(WB)": "WB",
 911 |             "(BG)": "BG",
 912 |             "(GU)": "GU",
 913 |             "(UR)": "UR",
 914 |             "(RW)": "RW",
 915 |             "(WUR)": "WUR",
 916 |             "(UBG)": "UBG",
 917 |             "(BRW)": "BRW",
 918 |             "(RGU)": "RGU",
 919 |             "(GWB)": "GWB",
 920 |             "(WUB)": "WUB",
 921 |             "(UBR)": "UBR",
 922 |             "(BRG)": "BRG",
 923 |             "(RGW)": "RGW",
 924 |             "(GWU)": "GWU",
 925 |         }
 926 | 
 927 |         try:
 928 |             self.combined_data["color_ratings"] = {}
 929 |             for color in colors:
 930 |                 games = color["games"]
 931 |                 if not color["is_summary"] and (games > 5000):
 932 |                     color_name = color["color_name"]
 933 |                     winrate = round(
 934 |                         (float(color["wins"])/color["games"]) * 100, 1)
 935 | 
 936 |                     color_label = [
 937 |                         x for x in color_ratings_dict if x in color_name]
 938 | 
 939 |                     if color_label:
 940 | 
 941 |                         processed_colors = color_ratings_dict[color_label[0]]
 942 | 
 943 |                         if processed_colors not in self.combined_data["color_ratings"]:
 944 |                             self.combined_data["color_ratings"][processed_colors] = winrate
 945 | 
 946 |         except Exception as error:
 947 |             logger.error(error)
 948 | 
 949 |     def _process_scryfall_data(self, data):
 950 |         '''Parse json data from the Scryfall API to extract pertinent card data'''
 951 |         result = False
 952 |         result_string = "Scryfall Data Unavailable"
 953 |         for card_data in data:
 954 |             try:
 955 |                 if "arena_id" not in card_data:
 956 |                     continue
 957 | 
 958 |                 arena_id = card_data["arena_id"]
 959 | 
 960 |                 card_name = card_data[constants.DATA_FIELD_NAME]
 961 | 
 962 |                 if card_data["layout"] == "transform":
 963 |                     card_name = card_name.split(" // ")[0]
 964 | 
 965 |                 self.card_dict[arena_id] = {
 966 |                     constants.DATA_FIELD_NAME: card_name,
 967 |                     constants.DATA_FIELD_CMC: card_data[constants.DATA_FIELD_CMC],
 968 |                     constants.DATA_FIELD_COLORS: card_data["color_identity"],
 969 |                     constants.DATA_FIELD_TYPES: extract_types(card_data["type_line"]),
 970 |                     constants.DATA_FIELD_MANA_COST: 0,
 971 |                     constants.DATA_SECTION_IMAGES: [],
 972 |                 }
 973 | 
 974 |                 if "card_faces" in card_data:
 975 |                     self.card_dict[arena_id][constants.DATA_FIELD_MANA_COST] = card_data["card_faces"][0][constants.DATA_FIELD_MANA_COST]
 976 |                     self.card_dict[arena_id][constants.DATA_SECTION_IMAGES].append(
 977 |                         card_data["card_faces"][0]["image_uris"]["normal"])
 978 |                     self.card_dict[arena_id][constants.DATA_SECTION_IMAGES].append(
 979 |                         card_data["card_faces"][1]["image_uris"]["normal"])
 980 | 
 981 |                 else:
 982 |                     self.card_dict[arena_id][constants.DATA_FIELD_MANA_COST] = card_data[constants.DATA_FIELD_MANA_COST]
 983 |                     self.card_dict[arena_id][constants.DATA_SECTION_IMAGES] = [
 984 |                         card_data["image_uris"]["normal"]]
 985 | 
 986 |                 result = True
 987 | 
 988 |             except Exception as error:
 989 |                 logger.error(error)
 990 |                 result_string = error
 991 | 
 992 |         return result, result_string
 993 | 
 994 |     def _process_card_data(self, card):
 995 |         '''Link the 17Lands card ratings with the card data'''
 996 |         result = False
 997 |         try:
 998 |             card_name = card[constants.DATA_FIELD_NAME].replace("///", "//")
 999 |             matching_cards = [
1000 |                 x for x in self.card_ratings if x == card_name]
1001 |             if matching_cards:
1002 |                 ratings_card_name = matching_cards[0]
1003 |                 deck_colors = self.card_ratings[ratings_card_name][constants.DATA_SECTION_RATINGS]
1004 | 
1005 |                 card[constants.DATA_SECTION_IMAGES] = self.card_ratings[ratings_card_name][constants.DATA_SECTION_IMAGES]
1006 |                 card[constants.DATA_FIELD_DECK_COLORS] = {}
1007 |                 for color in self.deck_colors:
1008 |                     card[constants.DATA_FIELD_DECK_COLORS][color] = {
1009 |                         x: 0.0 for x in constants.DATA_FIELD_17LANDS_DICT if x != constants.DATA_SECTION_IMAGES}
1010 |                 result = True
1011 |                 for deck_color in deck_colors:
1012 |                     for key, value in deck_color.items():
1013 |                         for field in value:
1014 |                             card[constants.DATA_FIELD_DECK_COLORS][key][field] = value[field]
1015 | 
1016 |         except Exception as error:
1017 |             logger.error(error)
1018 | 
1019 |         return result
1020 | 
1021 |     def export_card_data(self):
1022 |         '''Build the file for the set data'''
1023 |         result = True
1024 |         try:
1025 |             output_file = "_".join(
1026 |                 (self.selected_sets.seventeenlands[0], self.draft, constants.SET_FILE_SUFFIX))
1027 |             location = os.path.join(constants.SETS_FOLDER, output_file)
1028 | 
1029 |             with open(location, 'w', encoding="utf-8", errors="replace") as file:
1030 |                 json.dump(self.combined_data, file)
1031 | 
1032 |             # Verify that the file was written
1033 |             write_data = check_file_integrity(location)
1034 | 
1035 |             if write_data[0] != Result.VALID:
1036 |                 result = False
1037 | 
1038 |         except Exception as error:
1039 |             logger.error(error)
1040 |             result = False
1041 | 
1042 |         return result
1043 | 


--------------------------------------------------------------------------------
/src/card_logic.py:
--------------------------------------------------------------------------------
   1 | """This module contains the functions that are used for processing the collected cards"""
   2 | from itertools import combinations
   3 | from dataclasses import dataclass, field
   4 | import logging
   5 | import math
   6 | import copy
   7 | import numpy
   8 | from src import constants
   9 | from src.logger import create_logger
  10 | 
  11 | logger = create_logger()
  12 | 
  13 | 
  14 | @dataclass
  15 | class DeckMetrics:
  16 |     cmc_average: float = 0.0
  17 |     creature_count: int = 0
  18 |     noncreature_count: int = 0
  19 |     total_cards: int = 0
  20 |     total_non_land_cards: int = 0
  21 |     distribution_creatures: list = field(
  22 |         default_factory=lambda: [0, 0, 0, 0, 0, 0, 0])
  23 |     distribution_noncreatures: list = field(
  24 |         default_factory=lambda: [0, 0, 0, 0, 0, 0, 0])
  25 |     distribution_all: list = field(
  26 |         default_factory=lambda: [0, 0, 0, 0, 0, 0, 0])
  27 | 
  28 | 
  29 | @dataclass
  30 | class SetMetrics:
  31 |     mean: float = 0.0
  32 |     standard_deviation: float = 0.0
  33 | 
  34 | 
  35 | class CardResult:
  36 |     """This class processes a card list and produces results based on a list of fields (i.e., ALSA, GIHWR, COLORS, etc.)"""
  37 | 
  38 |     def __init__(self, set_metrics, tier_data, configuration, pick_number):
  39 |         self.metrics = set_metrics
  40 |         self.tier_data = tier_data
  41 |         self.configuration = configuration
  42 |         self.pick_number = pick_number
  43 | 
  44 |     def return_results(self, card_list, colors, fields):
  45 |         """This function processes a card list and returns a list with the requested field results"""
  46 |         return_list = []
  47 |         wheel_sum = 0
  48 |         if constants.DATA_FIELD_WHEEL in fields.values():
  49 |             wheel_sum = self.__retrieve_wheel_sum(card_list)
  50 | 
  51 |         for card in card_list:
  52 |             try:
  53 |                 selected_card = copy.deepcopy(card)
  54 |                 selected_card["results"] = ["NA"] * len(fields)
  55 | 
  56 |                 for count, option in enumerate(fields.values()):
  57 |                     if constants.FILTER_OPTION_TIER in option:
  58 |                         selected_card["results"][count] = self.__process_tier(
  59 |                             card, option)
  60 |                     elif option == constants.DATA_FIELD_COLORS:
  61 |                         selected_card["results"][count] = self.__process_colors(
  62 |                             card)
  63 |                     elif option == constants.DATA_FIELD_WHEEL:
  64 |                         selected_card["results"][count] = self.__process_wheel_normalized(
  65 |                             card, wheel_sum)
  66 |                     elif option in card:
  67 |                         selected_card["results"][count] = card[option]
  68 |                     else:
  69 |                         selected_card["results"][count] = self.__process_filter_fields(
  70 |                             card, option, colors)
  71 | 
  72 |                 return_list.append(selected_card)
  73 |             except Exception as error:
  74 |                 logger.error(error)
  75 |         return return_list
  76 | 
  77 |     def __process_tier(self, card, option):
  78 |         """Retrieve tier list rating for this card"""
  79 |         result = "NA"
  80 |         try:
  81 |             card_name = card[constants.DATA_FIELD_NAME].split(" // ")
  82 |             if card_name[0] in self.tier_data[option][constants.DATA_SECTION_RATINGS]:
  83 |                 tier_data = self.tier_data[option][constants.DATA_SECTION_RATINGS][card_name[0]]
  84 |                 result = tier_data["rating"]
  85 |                 # Append an asterisk to denote a comment
  86 |                 result = "*" + result if tier_data["comment"] else result
  87 |         except Exception as error:
  88 |             logger.error(error)
  89 | 
  90 |         return result
  91 | 
  92 |     def __process_colors(self, card):
  93 |         """Retrieve card colors based on color identity (includes kicker, abilities, etc.) or mana cost"""
  94 |         result = "NA"
  95 | 
  96 |         try:
  97 |             if self.configuration.settings.color_identity_enabled:
  98 |                 result = "".join(card[constants.DATA_FIELD_COLORS])
  99 |             elif constants.CARD_TYPE_LAND in card[constants.DATA_FIELD_TYPES]:
 100 |                 # For lands, the card mana cost can't be used to identify the card colors
 101 |                 result = "".join(card[constants.DATA_FIELD_COLORS])
 102 |             else:
 103 |                 result = "".join(
 104 |                     list(card_colors(card[constants.DATA_FIELD_MANA_COST]).keys()))
 105 |         except Exception as error:
 106 |             logger.error(error)
 107 | 
 108 |         return result
 109 | 
 110 |     def __retrieve_wheel_sum(self, card_list):
 111 |         """Calculate the sum of all wheel percentage values for the card list"""
 112 |         total_sum = 0
 113 | 
 114 |         for card in card_list:
 115 |             total_sum += self.__process_wheel(card)
 116 | 
 117 |         return total_sum
 118 | 
 119 |     def __process_wheel(self, card):
 120 |         """Calculate wheel percentage"""
 121 |         result = 0
 122 | 
 123 |         try:
 124 |             if self.pick_number <= len(constants.WHEEL_COEFFICIENTS):
 125 |                 # 0 is treated as pick 1 for PremierDraft P1P1
 126 |                 self.pick_number = max(self.pick_number, 1)
 127 |                 alsa = card[constants.DATA_FIELD_DECK_COLORS][constants.FILTER_OPTION_ALL_DECKS][constants.DATA_FIELD_ALSA]
 128 |                 coefficients = constants.WHEEL_COEFFICIENTS[self.pick_number - 1]
 129 |                 # Exclude ALSA values below 2
 130 |                 result = round(numpy.polyval(coefficients, alsa),
 131 |                                1) if alsa >= 2 else 0
 132 |                 result = max(result, 0)
 133 |         except Exception as error:
 134 |             logger.error(error)
 135 | 
 136 |         return result
 137 | 
 138 |     def __process_wheel_normalized(self, card, total_sum):
 139 |         """Calculate the normalized wheel percentage using the sum of all percentages within the card list"""
 140 |         result = 0
 141 | 
 142 |         try:
 143 |             result = self.__process_wheel(card)
 144 | 
 145 |             result = round((result / total_sum)*100, 1) if total_sum > 0 else 0
 146 |         except Exception as error:
 147 |             logger.error(error)
 148 | 
 149 |         return result
 150 | 
 151 |     def __process_filter_fields(self, card, option, colors):
 152 |         """Retrieve win rate result based on the application settings"""
 153 |         result = "NA"
 154 | 
 155 |         try:
 156 |             rated_colors = []
 157 |             for color in colors:
 158 |                 if constants.DATA_FIELD_DECK_COLORS in card \
 159 |                         and color in card[constants.DATA_FIELD_DECK_COLORS] \
 160 |                         and option in card[constants.DATA_FIELD_DECK_COLORS][color]:
 161 |                     if option in constants.WIN_RATE_OPTIONS:
 162 |                         rating_data = self.__format_win_rate(card,
 163 |                                                              option,
 164 |                                                              constants.WIN_RATE_FIELDS_DICT[option],
 165 |                                                              color)
 166 |                         rated_colors.append(rating_data)
 167 |                     else:  # Field that's not a win rate (ALSA, IWD, etc)
 168 |                         result = card[constants.DATA_FIELD_DECK_COLORS][color][option]
 169 |             if rated_colors:
 170 |                 result = sorted(
 171 |                     rated_colors, key=field_process_sort, reverse=True)[0]
 172 |         except Exception as error:
 173 |             logger.error(error)
 174 | 
 175 |         return result
 176 | 
 177 |     def __format_win_rate(self, card, winrate_field, winrate_count, color):
 178 |         """The function will return a grade, rating, or win rate depending on the application's Result Format setting"""
 179 |         result = 0
 180 |         # Produce a result that matches the Result Format setting
 181 |         if self.configuration.settings.result_format == constants.RESULT_FORMAT_RATING:
 182 |             result = self.__card_rating(
 183 |                 card, winrate_field, winrate_count, color)
 184 |         elif self.configuration.settings.result_format == constants.RESULT_FORMAT_GRADE:
 185 |             result = self.__card_grade(
 186 |                 card, winrate_field, winrate_count, color)
 187 |         else:
 188 |             result = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color][winrate_field],
 189 |                                         card[constants.DATA_FIELD_DECK_COLORS][color][winrate_count],
 190 |                                         self.configuration.settings.bayesian_average_enabled)
 191 | 
 192 |         return result
 193 | 
 194 |     def __card_rating(self, card, winrate_field, winrate_count, color):
 195 |         """The function will take a card's win rate and calculate a 5-point rating"""
 196 |         result = 0
 197 |         try:
 198 |             winrate = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color][winrate_field],
 199 |                                          card[constants.DATA_FIELD_DECK_COLORS][color][winrate_count],
 200 |                                          self.configuration.settings.bayesian_average_enabled)
 201 | 
 202 |             deviation_list = list(constants.GRADE_DEVIATION_DICT.values())
 203 |             upper_limit = self.metrics.mean + \
 204 |                 self.metrics.standard_deviation * deviation_list[0]
 205 |             lower_limit = self.metrics.mean + \
 206 |                 self.metrics.standard_deviation * deviation_list[-1]
 207 | 
 208 |             if (winrate != 0) and (upper_limit != lower_limit):
 209 |                 result = round(
 210 |                     ((winrate - lower_limit) / (upper_limit - lower_limit)) * 5.0, 1)
 211 |                 result = min(result, 5.0)
 212 |                 result = max(result, 0)
 213 | 
 214 |         except Exception as error:
 215 |             logger.error(error)
 216 |         return result
 217 | 
 218 |     def __card_grade(self, card, winrate_field, winrate_count, color):
 219 |         """The function will take a card's win rate and assign a letter grade based on the number of standard deviations from the mean"""
 220 |         result = constants.LETTER_GRADE_NA
 221 |         try:
 222 |             winrate = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color][winrate_field],
 223 |                                          card[constants.DATA_FIELD_DECK_COLORS][color][winrate_count],
 224 |                                          self.configuration.settings.bayesian_average_enabled)
 225 | 
 226 |             if ((winrate != 0) and (self.metrics.standard_deviation != 0)):
 227 |                 result = constants.LETTER_GRADE_F
 228 |                 for grade, deviation in constants.GRADE_DEVIATION_DICT.items():
 229 |                     standard_score = (
 230 |                         winrate - self.metrics.mean) / self.metrics.standard_deviation
 231 |                     if standard_score >= deviation:
 232 |                         result = grade
 233 |                         break
 234 | 
 235 |         except Exception as error:
 236 |             logger.error(error)
 237 |         return result
 238 | 
 239 | 
 240 | def field_process_sort(field_value):
 241 |     """This function collects the numeric order of a letter grade for the purpose of sorting"""
 242 |     processed_value = field_value
 243 | 
 244 |     try:
 245 |         # Remove the tier asterisks before sorting
 246 |         if isinstance(field_value, str):
 247 |             field_value = field_value.replace('*', '')
 248 |         if field_value in constants.GRADE_ORDER_DICT:
 249 |             processed_value = constants.GRADE_ORDER_DICT[field_value]
 250 |     except ValueError:
 251 |         pass
 252 |     return processed_value
 253 | 
 254 | 
 255 | def format_tier_results(value, old_format, new_format):
 256 |     """This function converts the tier list ratings, from old tier lists, back to letter grades"""
 257 |     new_value = value
 258 |     try:
 259 |         # ratings to grades
 260 |         if (old_format == constants.RESULT_FORMAT_RATING) and (new_format == constants.RESULT_FORMAT_GRADE):
 261 |             new_value = constants.LETTER_GRADE_NA
 262 |             for grade, threshold in constants.TIER_CONVERSION_RATINGS_GRADES_DICT.items():
 263 |                 if value > threshold:
 264 |                     new_value = grade
 265 |                     break
 266 |     except Exception as error:
 267 |         logger.error(error)
 268 | 
 269 |     return new_value
 270 | 
 271 | 
 272 | def deck_card_search(deck, search_colors, card_types, include_types, include_colorless, include_partial):
 273 |     """This function retrieves a subset of cards that meet certain criteria (type, color, etc.)"""
 274 |     card_color_sorted = {}
 275 |     main_color = ""
 276 |     combined_cards = []
 277 |     for card in deck:
 278 |         try:
 279 |             colors = list(card_colors(
 280 |                 card[constants.DATA_FIELD_MANA_COST]).keys())
 281 | 
 282 |             if constants.CARD_TYPE_LAND in card[constants.DATA_FIELD_TYPES]:
 283 |                 colors = card[constants.DATA_FIELD_COLORS]
 284 | 
 285 |             if colors and (set(colors) <= set(search_colors)):
 286 |                 main_color = colors[0]
 287 | 
 288 |                 if ((include_types and any(x in card[constants.DATA_FIELD_TYPES] for x in card_types)) or
 289 |                    (not include_types and not any(x in card[constants.DATA_FIELD_TYPES] for x in card_types))):
 290 | 
 291 |                     if main_color not in card_color_sorted:
 292 |                         card_color_sorted[main_color] = []
 293 | 
 294 |                     card_color_sorted[main_color].append(card)
 295 | 
 296 |             elif set(search_colors).intersection(colors) and include_partial:
 297 |                 for color in colors:
 298 |                     if ((include_types and any(x in card[constants.DATA_FIELD_TYPES] for x in card_types)) or
 299 |                        (not include_types and not any(x in card[constants.DATA_FIELD_TYPES] for x in card_types))):
 300 | 
 301 |                         if color not in card_color_sorted:
 302 |                             card_color_sorted[color] = []
 303 | 
 304 |                         card_color_sorted[color].append(card)
 305 | 
 306 |             if not colors and include_colorless:
 307 | 
 308 |                 if ((include_types and any(x in card[constants.DATA_FIELD_TYPES] for x in card_types)) or
 309 |                    (not include_types and not any(x in card[constants.DATA_FIELD_TYPES] for x in card_types))):
 310 | 
 311 |                     combined_cards.append(card)
 312 |         except Exception as error:
 313 |             logger.error(error)
 314 | 
 315 |     for key, value in card_color_sorted.items():
 316 |         if key in search_colors:
 317 |             combined_cards.extend(value)
 318 | 
 319 |     return combined_cards
 320 | 
 321 | 
 322 | def deck_metrics(deck):
 323 |     """This function determines the total CMC, count, and distribution of a collection of cards"""
 324 |     metrics = DeckMetrics()
 325 |     cmc_total = 0
 326 |     try:
 327 | 
 328 |         metrics.total_cards = len(deck)
 329 | 
 330 |         for card in deck:
 331 |             if any(x in [constants.CARD_TYPE_CREATURE]
 332 |                    for x in card[constants.DATA_FIELD_TYPES]):
 333 |                 metrics.creature_count += 1
 334 |                 metrics.total_non_land_cards += 1
 335 |                 cmc_total += card[constants.DATA_FIELD_CMC]
 336 | 
 337 |                 index = int(
 338 |                     min(card[constants.DATA_FIELD_CMC],
 339 |                         len(metrics.distribution_creatures) - 1))
 340 |                 metrics.distribution_creatures[index] += 1
 341 |             else:
 342 |                 if constants.CARD_TYPE_LAND not in card[constants.DATA_FIELD_TYPES]:
 343 |                     cmc_total += card[constants.DATA_FIELD_CMC]
 344 |                     metrics.total_non_land_cards += 1
 345 |                     index = int(
 346 |                         min(card[constants.DATA_FIELD_CMC],
 347 |                             len(metrics.distribution_noncreatures) - 1))
 348 |                     metrics.distribution_noncreatures[index] += 1
 349 |                 metrics.noncreature_count += 1
 350 | 
 351 |             index = int(
 352 |                 min(card[constants.DATA_FIELD_CMC],
 353 |                     len(metrics.distribution_all) - 1))
 354 |             metrics.distribution_all[index] += 1
 355 | 
 356 |         metrics.cmc_average = (cmc_total / metrics.total_non_land_cards
 357 |                                if metrics.total_non_land_cards
 358 |                                else 0.0)
 359 | 
 360 |     except Exception as error:
 361 |         logger.error(error)
 362 | 
 363 |     return metrics
 364 | 
 365 | 
 366 | def option_filter(deck, option_selection, metrics, configuration):
 367 |     """This function returns a list of colors based on the deck filter option"""
 368 |     filtered_color_list = [option_selection]
 369 |     try:
 370 |         if constants.FILTER_OPTION_AUTO in option_selection:
 371 |             filtered_color_list = auto_colors(deck, 5, metrics, configuration)
 372 |         else:
 373 |             filtered_color_list = [option_selection]
 374 |     except Exception as error:
 375 |         logger.error(error)
 376 |     return filtered_color_list
 377 | 
 378 | 
 379 | def deck_colors(deck, colors_max, metrics, configuration):
 380 |     """This function determines the prominent colors for a collection of cards"""
 381 |     colors_result = {}
 382 |     try:
 383 |         threshold = metrics.mean - 0.33 * metrics.standard_deviation
 384 |         colors = calculate_color_affinity(
 385 |             deck, constants.FILTER_OPTION_ALL_DECKS, threshold, configuration)
 386 | 
 387 |         # Modify the dictionary to include ratings
 388 |         color_list = list(
 389 |             map((lambda x: {"color": x, "rating": colors[x]}), colors.keys()))
 390 | 
 391 |         # Sort the list by decreasing ratings
 392 |         color_list = sorted(
 393 |             color_list, key=lambda k: k["rating"], reverse=True)
 394 | 
 395 |         # Remove extra colors beyond limit
 396 |         color_list = color_list[0:colors_max]
 397 | 
 398 |         # Return colors
 399 |         sorted_colors = list(map((lambda x: x["color"]), color_list))
 400 | 
 401 |         # Create color permutation
 402 |         color_combination = []
 403 | 
 404 |         for count in range(colors_max + 1):
 405 |             if count > 1:
 406 |                 color_combination.extend(combinations(sorted_colors, count))
 407 |             else:
 408 |                 color_combination.extend((sorted_colors))
 409 | 
 410 |         # Convert tuples to list of strings
 411 |         color_strings = [''.join(tups) for tups in color_combination]
 412 |         color_strings = [x for x in color_strings if len(x) <= colors_max]
 413 | 
 414 |         color_strings = list(set(color_strings))
 415 | 
 416 |         color_dict = {}
 417 |         for color_string in color_strings:
 418 |             for color in color_string:
 419 |                 if color_string not in color_dict:
 420 |                     color_dict[color_string] = 0
 421 |                 color_dict[color_string] += colors[color]
 422 | 
 423 |         for color_option in constants.DECK_COLORS:
 424 |             for key, value in color_dict.items():
 425 |                 if (len(key) == len(color_option)) and set(key).issubset(color_option):
 426 |                     colors_result[color_option] = value
 427 | 
 428 |         # Recalculate values based on the filtered win rates
 429 |         for color in colors_result:
 430 |             base_rating = calculate_color_rating(deck,
 431 |                                                  color,
 432 |                                                  threshold,
 433 |                                                  configuration)
 434 |             curve_factor = calculate_curve_factor(deck,
 435 |                                                   color,
 436 |                                                   configuration)
 437 |             colors_result[color] = base_rating * curve_factor
 438 | 
 439 |         # Add All Decks as a baseline
 440 |         colors_result[constants.FILTER_OPTION_ALL_DECKS] = calculate_color_rating(deck,
 441 |                                                                                   constants.FILTER_OPTION_ALL_DECKS,
 442 |                                                                                   metrics.mean,
 443 |                                                                                   configuration)
 444 |         colors_result = dict(
 445 |             sorted(colors_result.items(), key=lambda item: item[1], reverse=True))
 446 |     except Exception as error:
 447 |         logger.error(error)
 448 | 
 449 |     return colors_result
 450 | 
 451 | 
 452 | def auto_colors(deck, colors_max, metrics, configuration):
 453 |     """When the Auto deck filter is selected, this function identifies the prominent color pairs from the collected cards"""
 454 |     try:
 455 |         deck_colors_list = [constants.FILTER_OPTION_ALL_DECKS]
 456 |         colors_dict = {}
 457 |         deck_length = len(deck)
 458 |         if deck_length > 15:
 459 |             colors_dict = deck_colors(deck, colors_max, metrics, configuration)
 460 |             colors = list(colors_dict.keys())
 461 |             auto_select_threshold = max(70 - deck_length, 25)
 462 |             if len(colors) >= 2:
 463 |                 if (colors_dict[colors[0]] - colors_dict[colors[1]]) > auto_select_threshold:
 464 |                     deck_colors_list = colors[0:1]
 465 |                 elif configuration.settings.auto_highest_enabled:
 466 |                     deck_colors_list = colors[0:2]
 467 | 
 468 |     except Exception as error:
 469 |         logger.error(error)
 470 | 
 471 |     return deck_colors_list
 472 | 
 473 | 
 474 | def calculate_color_rating(cards, color_filter, threshold, configuration):
 475 |     """This function identifies the main deck colors based on the GIHWR of the collected cards"""
 476 |     rating = 0
 477 | 
 478 |     for card in cards:
 479 |         try:
 480 |             if color_filter in card[constants.DATA_FIELD_DECK_COLORS]:
 481 |                 gihwr = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIHWR],
 482 |                                            card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIH],
 483 |                                            configuration.settings.bayesian_average_enabled)
 484 |                 if gihwr > threshold:
 485 |                     rating += gihwr - threshold
 486 |         except Exception as error:
 487 |             logger.error(error)
 488 |     return rating
 489 | 
 490 | 
 491 | def sort_cards_win_rate(cards, filter_order, bayesian_enabled):
 492 |     """This function will acquire a non-zero win rate for each card and sort the cards by the win rate (highest to lowest)"""
 493 |     for card in cards:
 494 |         card["results"] = [0]
 495 |         try:
 496 |             for color_filter in filter_order:
 497 |                 win_rate = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIHWR],
 498 |                                               card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIH],
 499 |                                               bayesian_enabled)
 500 |                 if win_rate:
 501 |                     card["results"] = [win_rate]
 502 |                     break
 503 | 
 504 |         except Exception as error:
 505 |             logger.error(error)
 506 | 
 507 |     sorted_cards = sorted(
 508 |         cards, key=lambda k: k["results"][0], reverse=True)
 509 | 
 510 |     return sorted_cards
 511 | 
 512 | 
 513 | def calculate_curve_factor(deck, color_filter, configuration):
 514 |     """This function will assign a rating to a collection of cards based on how well they meet the deck building requirements"""
 515 |     curve_levels = [.10, .10, .10, .10, .15,
 516 |                     .15, .15, .20, .20, .20,
 517 |                     .25, .25, .25, .30, .30,
 518 |                     .30, .30, .40, .40, .40]
 519 | 
 520 |     curve_start = 15
 521 |     pick_number = len(deck)
 522 |     index = max(pick_number - curve_start, 0)
 523 |     curve_level = 0.0
 524 |     curve_factor = 0.0
 525 |     base_curve_factor = 1.0
 526 |     minimum_creature_count = configuration.card_logic.minimum_creatures
 527 | 
 528 |     try:
 529 |         filtered_cards = deck_card_search(
 530 |             deck,
 531 |             color_filter,
 532 |             constants.CARD_TYPE_DICT[constants.CARD_TYPE_SELECTION_NON_LANDS][0],
 533 |             True,
 534 |             True,
 535 |             False)
 536 |         deck_info = deck_metrics(filtered_cards)
 537 |         curve_level = curve_levels[int(
 538 |             min(index, len(curve_levels) - 1))]
 539 | 
 540 |         if deck_info.total_cards < configuration.card_logic.deck_control.maximum_card_count:
 541 |             curve_factor -= ((configuration.card_logic.deck_control.maximum_card_count - deck_info.creature_count)
 542 |                              / configuration.card_logic.deck_control.maximum_card_count) * curve_level
 543 |         elif deck_info.creature_count < minimum_creature_count:
 544 |             curve_factor = (deck_info.creature_count
 545 |                             / minimum_creature_count) * curve_level
 546 |         else:
 547 |             curve_factor = curve_level
 548 | 
 549 |     except Exception as error:
 550 |         logger.error(error)
 551 | 
 552 |     return base_curve_factor + curve_factor
 553 | 
 554 | 
 555 | def calculate_color_affinity(deck_cards, color_filter, threshold, configuration):
 556 |     """This function identifies the main deck colors based on the GIHWR of the collected cards"""
 557 |     colors = {}
 558 | 
 559 |     for card in deck_cards:
 560 |         try:
 561 |             if color_filter in card[constants.DATA_FIELD_DECK_COLORS]:
 562 |                 gihwr = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIHWR],
 563 |                                            card[constants.DATA_FIELD_DECK_COLORS][color_filter][constants.DATA_FIELD_GIH],
 564 |                                            configuration.settings.bayesian_average_enabled)
 565 |                 if gihwr > threshold:
 566 |                     mana_colors = card_colors(
 567 |                         card[constants.DATA_FIELD_MANA_COST])
 568 |                     for color in mana_colors:
 569 |                         if color not in colors:
 570 |                             colors[color] = 0
 571 |                         colors[color] += (gihwr - threshold)
 572 |         except Exception as error:
 573 |             logger.error(error)
 574 |     return colors
 575 | 
 576 | 
 577 | def row_color_tag(mana_cost):
 578 |     """This function selects the color tag for a table row based on a card's mana cost"""
 579 |     colors = list(card_colors(mana_cost).keys())
 580 | 
 581 |     row_tag = constants.CARD_ROW_COLOR_COLORLESS_TAG
 582 |     if len(colors) > 1:
 583 |         row_tag = constants.CARD_ROW_COLOR_GOLD_TAG
 584 |     elif constants.CARD_COLOR_SYMBOL_RED in colors:
 585 |         row_tag = constants.CARD_ROW_COLOR_RED_TAG
 586 |     elif constants.CARD_COLOR_SYMBOL_BLUE in colors:
 587 |         row_tag = constants.CARD_ROW_COLOR_BLUE_TAG
 588 |     elif constants.CARD_COLOR_SYMBOL_BLACK in colors:
 589 |         row_tag = constants.CARD_ROW_COLOR_BLACK_TAG
 590 |     elif constants.CARD_COLOR_SYMBOL_WHITE in colors:
 591 |         row_tag = constants.CARD_ROW_COLOR_WHITE_TAG
 592 |     elif constants.CARD_COLOR_SYMBOL_GREEN in colors:
 593 |         row_tag = constants.CARD_ROW_COLOR_GREEN_TAG
 594 |     return row_tag
 595 | 
 596 | 
 597 | def calculate_mean(cards, bayesian_enabled):
 598 |     """The function calculates the mean win rate of a collection of cards"""
 599 |     card_count = 0
 600 |     card_sum = 0
 601 |     mean = 0
 602 |     for card in cards:
 603 |         try:
 604 |             winrate = calculate_win_rate(cards[card][constants.DATA_FIELD_DECK_COLORS][constants.FILTER_OPTION_ALL_DECKS][constants.DATA_FIELD_GIHWR],
 605 |                                          cards[card][constants.DATA_FIELD_DECK_COLORS][constants.FILTER_OPTION_ALL_DECKS][constants.DATA_FIELD_GIH],
 606 |                                          bayesian_enabled)
 607 | 
 608 |             if winrate == 0:
 609 |                 continue
 610 | 
 611 |             card_sum += winrate
 612 |             card_count += 1
 613 | 
 614 |         except Exception as error:
 615 |             logger.error(error)
 616 | 
 617 |     mean = float(card_sum / card_count) if card_count else 0
 618 | 
 619 |     return mean
 620 | 
 621 | 
 622 | def calculate_standard_deviation(cards, mean, bayesian_enabled):
 623 |     """The function calculates the standard deviation from the win rate of a collection of cards"""
 624 |     standard_deviation = 0
 625 |     card_count = 0
 626 |     sum_squares = 0
 627 |     for card in cards:
 628 |         try:
 629 |             winrate = calculate_win_rate(cards[card][constants.DATA_FIELD_DECK_COLORS][constants.FILTER_OPTION_ALL_DECKS][constants.DATA_FIELD_GIHWR],
 630 |                                          cards[card][constants.DATA_FIELD_DECK_COLORS][constants.FILTER_OPTION_ALL_DECKS][constants.DATA_FIELD_GIH],
 631 |                                          bayesian_enabled)
 632 | 
 633 |             if winrate == 0:
 634 |                 continue
 635 | 
 636 |             squared_deviations = (winrate - mean) ** 2
 637 | 
 638 |             sum_squares += squared_deviations
 639 |             card_count += 1
 640 | 
 641 |         except Exception as error:
 642 |             logger.error(error)
 643 | 
 644 |     # Find the variance
 645 |     variance = (sum_squares / (card_count - 1)) if card_count > 2 else 0
 646 | 
 647 |     standard_deviation = math.sqrt(variance)
 648 | 
 649 |     return standard_deviation
 650 | 
 651 | 
 652 | def ratings_limits(cards, bayesian_enabled):
 653 |     """The function identifies the upper and lower win rates from a collection of cards"""
 654 |     upper_limit = 0
 655 |     lower_limit = 100
 656 | 
 657 |     for card in cards:
 658 |         for color in constants.DECK_COLORS:
 659 |             try:
 660 |                 if color in cards[card][constants.DATA_FIELD_DECK_COLORS]:
 661 |                     gihwr = calculate_win_rate(cards[card][constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIHWR],
 662 |                                                cards[card][constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIH],
 663 |                                                bayesian_enabled)
 664 |                     if gihwr > upper_limit:
 665 |                         upper_limit = gihwr
 666 |                     if gihwr < lower_limit and gihwr != 0:
 667 |                         lower_limit = gihwr
 668 |             except Exception as error:
 669 |                 logger.error(error)
 670 | 
 671 |     return upper_limit, lower_limit
 672 | 
 673 | 
 674 | def calculate_win_rate(winrate, count, bayesian_enabled):
 675 |     """The function will modify a card's win rate by applying the Bayesian Average algorithm or by zeroing a value with a low sample size"""
 676 |     calculated_winrate = 0.0
 677 |     try:
 678 |         calculated_winrate = winrate
 679 | 
 680 |         if bayesian_enabled:
 681 |             win_count = winrate * count
 682 |             # Bayesian average calculation
 683 |             calculated_winrate = (win_count + 1000) / (count + 20)
 684 |             calculated_winrate = round(calculated_winrate, 2)
 685 |         else:
 686 |             # Drop values that have fewer than 200 samples (same as 17Lands card_ratings page)
 687 |             if count < 200:
 688 |                 calculated_winrate = 0.0
 689 |     except Exception as error:
 690 |         logger.error(error)
 691 |     return calculated_winrate
 692 | 
 693 | 
 694 | def deck_color_stats(deck, color):
 695 |     """The function will identify the number of creature and noncreature cards in a collection of cards"""
 696 |     creature_count = 0
 697 |     noncreature_count = 0
 698 | 
 699 |     try:
 700 |         creature_cards = deck_card_search(
 701 |             deck, color, [constants.CARD_TYPE_CREATURE], True, True, False)
 702 |         noncreature_cards = deck_card_search(
 703 |             deck, color, [constants.CARD_TYPE_CREATURE], False, True, False)
 704 |         noncreature_cards = deck_card_search(
 705 |             noncreature_cards, color,
 706 |             [constants.CARD_TYPE_INSTANT,
 707 |              constants.CARD_TYPE_SORCERY,
 708 |              constants.CARD_TYPE_ARTIFACT,
 709 |              constants.CARD_TYPE_ENCHANTMENT,
 710 |              constants.CARD_TYPE_PLANESWALKER], True, True, False)
 711 | 
 712 |         creature_count = len(creature_cards)
 713 |         noncreature_count = len(noncreature_cards)
 714 | 
 715 |     except Exception as error:
 716 |         logger.error(error)
 717 | 
 718 |     return creature_count, noncreature_count
 719 | 
 720 | 
 721 | def card_cmc_search(deck, offset, starting_cmc, cmc_limit, remaining_count):
 722 |     """The function will use recursion to search through a collection of cards and produce a list of cards with a mean CMC that is below a specific limit"""
 723 |     cards = []
 724 |     unused = []
 725 |     try:
 726 |         for count, card in enumerate(deck[offset:]):
 727 |             card_cmc = card[constants.DATA_FIELD_CMC]
 728 | 
 729 |             if card_cmc + starting_cmc <= cmc_limit:
 730 |                 card_cmc += starting_cmc
 731 |                 current_offset = offset + count
 732 |                 current_remaining = int(max(remaining_count - 1, 0))
 733 |                 if current_remaining == 0:
 734 |                     cards.append(card)
 735 |                     unused.extend(deck[current_offset + 1:])
 736 |                     break
 737 |                 elif current_offset > (len(deck) - remaining_count):
 738 |                     unused.extend(deck[current_offset:])
 739 |                     break
 740 |                 else:
 741 |                     current_offset += 1
 742 |                     cards, skipped = card_cmc_search(
 743 |                         deck, current_offset, card_cmc, cmc_limit, current_remaining)
 744 |                     if cards:
 745 |                         cards.append(card)
 746 |                         unused.extend(skipped)
 747 |                         break
 748 |                     else:
 749 |                         unused.append(card)
 750 |             else:
 751 |                 unused.append(card)
 752 |     except Exception as error:
 753 |         logger.error(error)
 754 | 
 755 |     return cards, unused
 756 | 
 757 | 
 758 | def deck_rating(deck, deck_type, color, threshold, bayesian_enabled):
 759 |     """The function will produce a deck rating based on the combined GIHWR value for each card with a GIHWR value above a certain threshold"""
 760 |     rating = 0
 761 |     try:
 762 |         # Combined GIHWR of the cards
 763 |         for card in deck:
 764 |             try:
 765 |                 gihwr = calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIHWR],
 766 |                                            card[constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIH],
 767 |                                            bayesian_enabled)
 768 |                 if gihwr > threshold:
 769 |                     rating += gihwr
 770 |             except Exception:
 771 |                 pass
 772 | 
 773 |         # Deck contains the recommended number of creatures
 774 |         recommended_creature_count = deck_type.recommended_creature_count
 775 |         filtered_cards = deck_card_search(
 776 |             deck, color, [constants.CARD_TYPE_CREATURE], True, True, False)
 777 | 
 778 |         if len(filtered_cards) < recommended_creature_count:
 779 |             rating -= (recommended_creature_count - len(filtered_cards)) * 50
 780 | 
 781 |         # Average CMC of the creatures is below the ideal cmc average
 782 |         cmc_average = deck_type.cmc_average
 783 |         total_cards = len(filtered_cards)
 784 |         total_cmc = 0
 785 | 
 786 |         for card in filtered_cards:
 787 |             total_cmc += card[constants.DATA_FIELD_CMC]
 788 | 
 789 |         cmc = total_cmc / total_cards
 790 | 
 791 |         if cmc > cmc_average:
 792 |             rating -= 500
 793 | 
 794 |         # Cards fit distribution
 795 |         minimum_distribution = deck_type.distribution
 796 |         distribution = [0, 0, 0, 0, 0, 0, 0]
 797 |         for card in filtered_cards:
 798 |             index = int(min(card[constants.DATA_FIELD_CMC],
 799 |                         len(minimum_distribution) - 1))
 800 |             distribution[index] += 1
 801 | 
 802 |     except Exception as error:
 803 |         logger.error(error)
 804 | 
 805 |     rating = int(rating)
 806 | 
 807 |     return rating
 808 | 
 809 | 
 810 | def copy_deck(deck, sideboard):
 811 |     """The function will produce a deck/sideboard list that is formatted in such a way that it can be copied to Arena and Sealdeck.tech"""
 812 |     deck_copy = ""
 813 |     try:
 814 |         # Copy Deck
 815 |         deck_copy = "Deck\n"
 816 |         # identify the arena_id for the cards
 817 |         for card in deck:
 818 |             deck_copy += f"{card[constants.DATA_FIELD_COUNT]} {card[constants.DATA_FIELD_NAME]}\n"
 819 | 
 820 |         # Copy sideboard
 821 |         if sideboard is not None:
 822 |             deck_copy += "\nSideboard\n"
 823 |             for card in sideboard:
 824 |                 deck_copy += f"{card[constants.DATA_FIELD_COUNT]} {card[constants.DATA_FIELD_NAME]}\n"
 825 | 
 826 |     except Exception as error:
 827 |         logger.error(error)
 828 | 
 829 |     return deck_copy
 830 | 
 831 | 
 832 | def stack_cards(cards):
 833 |     """The function will produce a list consisting of unique cards and the number of copies of each card"""
 834 |     deck = {}
 835 |     deck_list = []
 836 |     for card in cards:
 837 |         try:
 838 |             name = card[constants.DATA_FIELD_NAME]
 839 |             if name not in deck:
 840 |                 deck[name] = {constants.DATA_FIELD_COUNT: 1}
 841 |                 for data_field in constants.DATA_SET_FIELDS:
 842 |                     if data_field in card:
 843 |                         deck[name][data_field] = card[data_field]
 844 |             else:
 845 |                 deck[name][constants.DATA_FIELD_COUNT] += 1
 846 |         except Exception as error:
 847 |             logger.error(error)
 848 |     # Convert to list format
 849 |     deck_list = list(deck.values())
 850 | 
 851 |     return deck_list
 852 | 
 853 | 
 854 | def card_colors(mana_cost):
 855 |     """The function parses a mana cost string and returns a list of mana symbols"""
 856 |     colors = {}
 857 |     try:
 858 |         for color in constants.CARD_COLORS:
 859 |             if color in mana_cost:
 860 |                 if color not in colors:
 861 |                     colors[color] = 1
 862 |                 else:
 863 |                     colors[color] += 1
 864 | 
 865 |     except Exception as error:
 866 |         logger.error(error)
 867 |     return colors
 868 | 
 869 | 
 870 | def color_splash(cards, colors, splash_threshold, configuration):
 871 |     """The function will parse a list of cards to determine if there are any cards that might justify a splash"""
 872 |     color_affinity = {}
 873 |     splash_color = ""
 874 |     try:
 875 |         # Calculate affinity to rank colors based on splash threshold (minimum GIHWR)
 876 |         color_affinity = calculate_color_affinity(
 877 |             cards, colors, splash_threshold, configuration)
 878 | 
 879 |         # Modify the dictionary to include ratings
 880 |         color_affinity = list(
 881 |             map((lambda x: {"color": x, "rating": color_affinity[x]}), color_affinity.keys()))
 882 |         # Remove the current colors
 883 |         filtered_colors = color_affinity[:]
 884 |         for color in color_affinity:
 885 |             if color["color"] in colors:
 886 |                 filtered_colors.remove(color)
 887 |         # Sort the list by decreasing ratings
 888 |         filtered_colors = sorted(
 889 |             filtered_colors, key=lambda k: k["rating"], reverse=True)
 890 | 
 891 |         if filtered_colors:
 892 |             splash_color = filtered_colors[0]["color"]
 893 |     except Exception as error:
 894 |         logger.error(error)
 895 |     return splash_color
 896 | 
 897 | 
 898 | def mana_base(deck):
 899 |     """The function will identify the number of lands that are needed to fill out a deck"""
 900 |     maximum_deck_size = 40
 901 |     combined_deck = []
 902 |     mana_types = {"Swamp": {"color": constants.CARD_COLOR_SYMBOL_BLACK, constants.DATA_FIELD_COUNT: 0},
 903 |                   "Forest": {"color": constants.CARD_COLOR_SYMBOL_GREEN, constants.DATA_FIELD_COUNT: 0},
 904 |                   "Mountain": {"color": constants.CARD_COLOR_SYMBOL_RED, constants.DATA_FIELD_COUNT: 0},
 905 |                   "Island": {"color": constants.CARD_COLOR_SYMBOL_BLUE, constants.DATA_FIELD_COUNT: 0},
 906 |                   "Plains": {"color": constants.CARD_COLOR_SYMBOL_WHITE, constants.DATA_FIELD_COUNT: 0}}
 907 |     total_count = 0
 908 |     try:
 909 |         number_of_lands = 0 if maximum_deck_size < len(
 910 |             deck) else maximum_deck_size - len(deck)
 911 | 
 912 |         # Go through the cards and count the mana types
 913 |         for card in deck:
 914 |             if constants.CARD_TYPE_LAND in card[constants.DATA_FIELD_TYPES]:
 915 |                 # Subtract symbol for lands
 916 |                 for mana_type in mana_types.values():
 917 |                     mana_type[constants.DATA_FIELD_COUNT] -= (1 if (mana_type["color"] in card[constants.DATA_FIELD_COLORS])
 918 |                                                               else 0)
 919 |             else:
 920 |                 # Increase count for abilities that are not part of the mana cost
 921 |                 mana_count = card_colors(card[constants.DATA_FIELD_MANA_COST])
 922 |                 # for color in card[constants.DATA_FIELD_COLORS]:
 923 |                 #    mana_count[color] = (
 924 |                 #        mana_count[color] + 1) if color in mana_count else 1
 925 | 
 926 |                 for mana_type in mana_types.values():
 927 |                     color = mana_type["color"]
 928 |                     mana_type[constants.DATA_FIELD_COUNT] += mana_count[color] if color in mana_count else 0
 929 | 
 930 |         for land in mana_types.values():
 931 |             land[constants.DATA_FIELD_COUNT] = max(
 932 |                 land[constants.DATA_FIELD_COUNT], 0)
 933 |             total_count += land[constants.DATA_FIELD_COUNT]
 934 | 
 935 |         # Sort by lowest count
 936 |         mana_types = dict(
 937 |             sorted(mana_types.items(), key=lambda t: t[1][constants.DATA_FIELD_COUNT]))
 938 |         # Add x lands with a distribution set by the mana types
 939 |         total_lands = number_of_lands
 940 |         for land in mana_types:
 941 |             if not total_lands or not mana_types[land][constants.DATA_FIELD_COUNT]:
 942 |                 continue
 943 | 
 944 |             land_count = int(math.ceil(
 945 |                 (mana_types[land][constants.DATA_FIELD_COUNT] / total_count) * number_of_lands))
 946 | 
 947 |             land_count = min(land_count, total_lands)
 948 |             total_lands -= land_count
 949 | 
 950 |             if land_count:
 951 |                 card = {constants.DATA_FIELD_COLORS: mana_types[land]["color"],
 952 |                         constants.DATA_FIELD_TYPES: constants.CARD_TYPE_LAND,
 953 |                         constants.DATA_FIELD_CMC: 0,
 954 |                         constants.DATA_FIELD_NAME: land,
 955 |                         constants.DATA_FIELD_MANA_COST: mana_types[land]["color"],
 956 |                         constants.DATA_FIELD_COUNT: land_count}
 957 |                 combined_deck.append(card)
 958 | 
 959 |     except Exception as error:
 960 |         logger.error(error)
 961 |     return combined_deck
 962 | 
 963 | 
 964 | def suggest_deck(taken_cards, metrics, configuration):
 965 |     """The function will analyze the list of taken cards and produce several viable decks based on specific criteria"""
 966 |     colors_max = 5
 967 |     maximum_card_count = 22
 968 |     sorted_decks = {}
 969 |     try:
 970 |         deck_types = {"Mid": configuration.card_logic.deck_mid,
 971 |                       "Aggro": configuration.card_logic.deck_aggro,
 972 |                       "Control": configuration.card_logic.deck_control}
 973 |         # Identify the top color combinations
 974 |         colors = deck_colors(taken_cards, colors_max, metrics, configuration)
 975 |         filtered_colors = []
 976 | 
 977 |         colors.pop(constants.FILTER_OPTION_ALL_DECKS, None)
 978 | 
 979 |         # Collect color stats and remove colors that don't meet the minimum requirements
 980 |         for color in colors:
 981 |             creature_count, noncreature_count = deck_color_stats(
 982 |                 taken_cards, color)
 983 |             if ((creature_count >= configuration.card_logic.minimum_creatures) and
 984 |                (noncreature_count >= configuration.card_logic.minimum_noncreatures) and
 985 |                (creature_count + noncreature_count >= maximum_card_count)):
 986 |                 filtered_colors.append(color)
 987 | 
 988 |         decks = {}
 989 |         threshold = metrics.mean - 0.33 * metrics.standard_deviation
 990 |         for color in filtered_colors:
 991 |             for key, value in deck_types.items():
 992 |                 deck, sideboard_cards = build_deck(
 993 |                     value, taken_cards, color, metrics, configuration)
 994 |                 rating = deck_rating(
 995 |                     deck, value, color, threshold, configuration.settings.bayesian_average_enabled)
 996 |                 if rating >= configuration.card_logic.ratings_threshold:
 997 | 
 998 |                     if ((color not in decks) or
 999 |                             (color in decks and rating > decks[color]["rating"])):
1000 |                         decks[color] = {}
1001 |                         decks[color]["deck_cards"] = stack_cards(deck)
1002 |                         decks[color]["sideboard_cards"] = stack_cards(
1003 |                             sideboard_cards)
1004 |                         decks[color]["rating"] = rating
1005 |                         decks[color]["type"] = key
1006 |                         decks[color]["deck_cards"].extend(mana_base(deck))
1007 | 
1008 |         sorted_colors = sorted(
1009 |             decks, key=lambda x: decks[x]["rating"], reverse=True)
1010 |         for color in sorted_colors:
1011 |             sorted_decks[color] = decks[color]
1012 |     except Exception as error:
1013 |         logger.error(error)
1014 | 
1015 |     return sorted_decks
1016 | 
1017 | 
1018 | def build_deck(deck_type, cards, color, metrics, configuration):
1019 |     """The function will build a deck list that meets specific criteria"""
1020 |     minimum_distribution = deck_type.distribution
1021 |     maximum_card_count = deck_type.maximum_card_count
1022 |     maximum_deck_size = 40
1023 |     cmc_average = deck_type.cmc_average
1024 |     recommended_creature_count = deck_type.recommended_creature_count
1025 |     deck_list = []
1026 |     unused_creature_list = []
1027 |     sideboard_list = cards[:]  # Copy by value
1028 |     try:
1029 |         for card in cards:
1030 |             card["results"] = [calculate_win_rate(card[constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIHWR],
1031 |                                                   card[constants.DATA_FIELD_DECK_COLORS][color][constants.DATA_FIELD_GIH],
1032 |                                                   configuration.settings.bayesian_average_enabled)]
1033 | 
1034 |         # identify a splashable color
1035 |         splash_threshold = metrics.mean + \
1036 |             2.33 * metrics.standard_deviation
1037 |         color += (color_splash(cards, color, splash_threshold, configuration))
1038 | 
1039 |         card_colors_sorted = deck_card_search(
1040 |             cards, color, [constants.CARD_TYPE_CREATURE], True, True, False)
1041 |         card_colors_sorted = sorted(
1042 |             card_colors_sorted, key=lambda k: k["results"][0], reverse=True)
1043 | 
1044 |         # Identify creatures that fit distribution
1045 |         distribution = [0, 0, 0, 0, 0, 0, 0]
1046 |         used_count = 0
1047 |         used_cmc_combined = 0
1048 |         for card in card_colors_sorted:
1049 |             index = int(min(card[constants.DATA_FIELD_CMC],
1050 |                         len(minimum_distribution) - 1))
1051 |             if distribution[index] < minimum_distribution[index]:
1052 |                 deck_list.append(card)
1053 |                 sideboard_list.remove(card)
1054 |                 distribution[index] += 1
1055 |                 used_count += 1
1056 |                 used_cmc_combined += card[constants.DATA_FIELD_CMC]
1057 |             else:
1058 |                 unused_creature_list.append(card)
1059 | 
1060 |         # Go back and identify remaining creatures that have the highest base rating but don't push average above the threshold
1061 |         unused_cmc_combined = cmc_average * recommended_creature_count - used_cmc_combined
1062 | 
1063 |         unused_creature_list.sort(key=lambda x: x["results"][0], reverse=True)
1064 | 
1065 |         # Identify remaining cards that won't exceed recommeneded CMC average
1066 |         cmc_cards, unused_creature_list = card_cmc_search(
1067 |             unused_creature_list, 0, 0, unused_cmc_combined, recommended_creature_count - used_count)
1068 | 
1069 |         for card in cmc_cards:
1070 |             deck_list.append(card)
1071 |             sideboard_list.remove(card)
1072 | 
1073 |         total_card_count = len(deck_list)
1074 | 
1075 |         if len(cmc_cards) == 0:
1076 |             for card in unused_creature_list:
1077 |                 if total_card_count >= recommended_creature_count:
1078 |                     break
1079 | 
1080 |                 deck_list.append(card)
1081 |                 sideboard_list.remove(card)
1082 |                 total_card_count += 1
1083 | 
1084 |         card_colors_sorted = deck_card_search(sideboard_list, color, [
1085 |             constants.CARD_TYPE_CREATURE,
1086 |             constants.CARD_TYPE_INSTANT,
1087 |             constants.CARD_TYPE_SORCERY,
1088 |             constants.CARD_TYPE_ENCHANTMENT,
1089 |             constants.CARD_TYPE_ARTIFACT,
1090 |             constants.CARD_TYPE_PLANESWALKER], True, True, False)
1091 | 
1092 |         card_colors_sorted = sorted(
1093 |             card_colors_sorted, key=lambda k: k["results"][0], reverse=True)
1094 | 
1095 |         # Add remaining non-land cards
1096 |         for card in card_colors_sorted:
1097 |             if total_card_count >= maximum_card_count:
1098 |                 break
1099 | 
1100 |             deck_list.append(card)
1101 |             sideboard_list.remove(card)
1102 |             total_card_count += 1
1103 | 
1104 |         # Add in special lands if they have a win rate that is at least 0.33 standard deviations from the mean (C-)
1105 |         land_cards = deck_card_search(
1106 |             sideboard_list, color, [constants.CARD_TYPE_LAND], True, True, False)
1107 |         land_cards = [
1108 |             x for x in land_cards if x[constants.DATA_FIELD_NAME] not in constants.BASIC_LANDS]
1109 |         land_cards = sorted(
1110 |             land_cards, key=lambda k: k["results"][0], reverse=True)
1111 |         for card in land_cards:
1112 |             if total_card_count >= maximum_deck_size:
1113 |                 break
1114 | 
1115 |             if card["results"][0] >= metrics.mean - 0.33 * metrics.standard_deviation:
1116 |                 deck_list.append(card)
1117 |                 sideboard_list.remove(card)
1118 |                 total_card_count += 1
1119 | 
1120 |     except Exception as error:
1121 |         logger.error(error)
1122 |     return deck_list, sideboard_list
1123 | 


--------------------------------------------------------------------------------