def __init__(self, parent, api: API_SIX, dd: list, cv: list,
main_fleet: list, is_realrun: bool):
super().__init__()
self.parent = parent
self.api = api
self.escort_DD = dd
self.escort_CV = cv
self.main_fleet = main_fleet # main fleet (6SS)
self.battle_fleet = set() # ships that on battle
self.logger = get_logger(QLOGS.TAB_THER)
self.is_running: bool = True
self.qsettings = QSettings(wgv_data.get_qsettings_file(),
QSettings.IniFormat)
if self.qsettings.contains(QKEYS.THER_REPAIRS):
self.repair_levels: list = list(
map(int, self.qsettings.value(QKEYS.THER_REPAIRS)))
else:
self.repair_levels: list = [2]
# Used for pre-battle
self.map_data: dict = {}
self.user_data: dict = {}
self.helper = None
self.boat_pool: set = set() # host existing boats
self.curr_node: str = '0'
self.curr_sub_map: str = '0'
self.final_fleet: list = [] # fill up required number of boats
self.tickets: int = 0
self.user_ships: dict = wgv_data.get_processed_userShipVo()
self.pre_sortie = PreSortieCheck(self.api, is_realrun)
self.logger.info("Init E6...")
def __init__(self, tab_thermopylae, api: API_SIX, user_ships: dict,
map_data: dict):
self.api = api
self.tab_thermopylae = tab_thermopylae
self.logger = get_logger(QLOGS.TAB_THER)
self.user_ships = user_ships
self.map_data = map_data
self.qsettings = QSettings(get_qsettings_file(), QSettings.IniFormat)
if self.qsettings.contains(QKEYS.CONN_THER_RTY):
self.reconnection_limit = self.qsettings.value(QKEYS.CONN_THER_RTY,
type=int)
else:
self.reconnection_limit = 3
if self.qsettings.contains(QKEYS.THER_BOSS_RTY):
self.boss_retry_limit = list(
map(int, self.qsettings.value(QKEYS.THER_BOSS_RTY)))
else:
self.boss_retry_limit = [3, 5, 10]
if self.qsettings.contains(QKEYS.THER_BOSS_STD):
self.boss_retry_standard = list(
map(int, self.qsettings.value(QKEYS.THER_BOSS_STD)))
else:
self.boss_retry_standard = [1, 2, 2]
if self.qsettings.contains(QKEYS.THER_SHIP_STARS):
self.ship_star: dict = self.qsettings.value(QKEYS.THER_SHIP_STARS)
else:
self.ship_star: dict = {}
self.boss_retry_count: list = [0, 0, 0]
self.points: int = 10
self.adjutant_info: dict = {} # level, curr_exp, exp_cap
def __init__(self, api: API_SIX, is_realrun: bool):
self.api: API_SIX = api
self.is_realrun = is_realrun
self.logger = get_logger(QLOGS.TAB_THER)
self.final_fleet: list = []
self.sub_map_id: str = ""
self.map_data: dict = {}
self.user_data: dict = {}
self.fleet_info: dict = {}
def show_graph(self, start_idx: int, end_idx: int, title: str) -> None:
try:
self.read_csv()
fig = go.Figure()
for i in range(start_idx, end_idx):
fig.add_trace(
go.Scatter(x=self.resource_data[0],
y=self.resource_data[i],
name=CONST.CSV_HEADER[i]))
fig.update_layout(title=title)
if get_color_option() == "qdarkstyle":
# self.setStyleSheet(get_color_scheme())
fig.layout.template = pio.templates["plotly_dark"]
else:
pass
# self.browser.setHtml(fig.to_html(include_plotlyjs='cdn'))
# self.show()
fig.show()
except FileNotFoundError as e:
logger = get_logger('DATAGRAPH')
logger.debug('===================================')
logger.debug(e)
logger.debug('===================================')
import os
import sys
from PyQt5.QtCore import QSize, Qt, QThreadPool, QSettings
from PyQt5.QtWidgets import (QWidget, QTabWidget, QGridLayout, QTabBar, QLabel)
from src.data import get_qsettings_file
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from src.gui.tabs.advance_functions import TabAdvanceFunctions
from src.gui.tabs.tab_thermopylae import TabThermopylae
from src.gui.tabs.tab_ship import TabShips
from src.gui.tabs.tab_expedition import TabExpedition
logger = get_logger(QLOGS.TABS)
def get_data_path(relative_path: str) -> str:
# This needs to be in current file
bundle_dir = getattr(sys, '_MEIPASS',
os.path.abspath(os.path.dirname(__file__)))
res = os.path.join(bundle_dir, relative_path)
return relative_path if not os.path.exists(res) else res
class TabBar(QTabBar):
def tabSizeHint(self, index: int) -> QSize:
size = QTabBar.tabSizeHint(self, index)
w = int(self.width() / self.count())
return QSize(w, size.height())
from typing import Union
from cryptography.fernet import Fernet
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
logger = get_logger(QLOGS.FUNC)
class Encryptor:
def __init__(self):
pass
@staticmethod
def gen_key() -> bytes:
return Fernet.generate_key()
@staticmethod
def save_key(key: bytes, path: str) -> None:
with open(path, 'wb') as f:
f.write(key)
@staticmethod
def load_key(path: str) -> bytes:
with open(path, 'rb') as f:
key = f.read()
return key
@staticmethod
def encrypt_str(key: bytes, string: str):
import urllib.request
from PyQt5.QtWidgets import QMessageBox, QWidget
from packaging import version
from src import utils as wgv_utils
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from src.func.worker import CallbackWorker
from src.gui.custom_widgets import QtWaitingSpinner
logger = get_logger(QLOGS.LOGIN)
class WGViewerVersionCheck:
"""
Check if user's client version is up-to-date.
This class is only instantiated during LogIn, and it is deleted after LogIn checking complete.
"""
def __init__(self):
self.latest_ver = None
self.is_check_finished = False
self.loading_screen = QtWaitingSpinner(self)
self.bee = CallbackWorker(self.fetch_version, (), self.fetch_finished)
self.bee.terminate()
try:
self.loading_screen.start()
self.bee.start()
except urllib.error.HTTPError as e:
logger.error(e)
QVBoxLayout, QHBoxLayout,
QDockWidget, QWidget, QLabel, QLineEdit, QMessageBox, QCheckBox, QLayout
)
from src import data as wgv_data
from src import utils as wgv_utils
from src.func import qsettings_keys as QKEYS
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from .resource_model import ResourceTableModel
from .align_list_view import BathListView, BuildListView, DevListView, ExpListView, TaskListView
from .constants import TASK_TYPE
from .timer_helper import get_tasks_countdowns, _calc_left_time
from .constants import EXP_LABEL_L, EXP_LABEL_R
logger = get_logger(QLOGS.SIDE_DOCK)
def get_data_path(relative_path: str) -> str:
# This needs to be in current file
bundle_dir = getattr(sys, '_MEIPASS', os.path.abspath(os.path.dirname(__file__)))
res = os.path.join(bundle_dir, relative_path)
return relative_path if not os.path.exists(res) else res
class SideDock(QDockWidget):
"""
Side Dock/Panel, named "Navy Base Overview", displays all important data of the user.
This is the first coded QWidget of WGViewer (even before LoginForm).
"""
sig_resized = pyqtSignal()
import sys
from PyQt5.QtCore import Qt, pyqtSlot
from PyQt5.QtWidgets import (QWidget, QLineEdit, QVBoxLayout, QGridLayout,
QScrollArea, QHeaderView, QTableView)
from src import data as wgv_data
from src.wgr import WGR_API
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from .ships.delegate import ShipTableDelegate
from .ships.model import ShipModel
from .ships.proxy_model import ShipSortFilterProxyModel
from .ships.top_checkbox import TopCheckboxes
logger = get_logger(QLOGS.TAB_SHIP)
def get_data_path(relative_path: str) -> str:
# This needs to be in current file
bundle_dir = getattr(sys, '_MEIPASS',
os.path.abspath(os.path.dirname(__file__)))
res = os.path.join(bundle_dir, relative_path)
return relative_path if not os.path.exists(res) else res
class TabShips(QWidget):
def __init__(self, tab_name: str, is_realrun: bool):
super().__init__()
logger.info("Creating Ships Tab...")
self.api = WGR_API(wgv_data.load_cookies())
from PyQt5.QtCore import QSettings
from requests import exceptions
from requests.utils import cookiejar_from_dict
from time import sleep
from urllib.request import Request, build_opener, HTTPCookieProcessor
from urllib.error import URLError
from http.client import HTTPResponse
from src.data import get_qsettings_file
from src.func import qsettings_keys as QKEYS
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from src.gui.login.helper import LoginHelper
logger = get_logger(QLOGS.API)
class WGR_API:
"""
Warship Girls (R) - API
"""
def __init__(self, cookies: dict):
self.server = cookies['server']
self.channel = cookies['channel']
self.cookies = cookies['cookies']
self.hlp = LoginHelper()
qsettings = QSettings(get_qsettings_file(), QSettings.IniFormat)
if qsettings.contains(QKEYS.CONN_API_RTY) is True:
self.max_retry = qsettings.value(QKEYS.CONN_API_RTY, type=int)
import ast
import re
from typing import Callable
from PyQt5.QtCore import Qt, QSortFilterProxyModel, QModelIndex, QRegExp
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QCheckBox
from src import data as wgv_data
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from . import constant as SCONST
logger = get_logger(QLOGS.DATA)
class ShipSortFilterProxyModel(QSortFilterProxyModel):
def __init__(self, *args, **kwargs):
QSortFilterProxyModel.__init__(self, *args, **kwargs)
self.name_reg = None
self.lock_opt = None
self.level_opt = None
self.mod_opt = None
self.type_size_opt = None
self.rarity_opt = None
self.marry_opt = None
self.country_opt = None
self.checkboxes_opt = {}
# LESSON: Unlike C++, Python have no reference to a variable, so following will create self.all_opts points
# to [None, ...] which will remain unchanged and will fail filtering self.all_opts = [self.name_reg, ...]
from PyQt5.QtCore import QRegExp
from PyQt5.QtGui import QColor, QFont, QRegExpValidator
from PyQt5.QtWidgets import QWidget, QGridLayout, QCheckBox, QComboBox, QLabel, QLineEdit, QSpinBox
from src.utils import repair_id_to_text, repair_text_to_id
from src.func import qsettings_keys as QKEYS
from src.func import logger_names as QLOGS
from src.func.log_handler import get_logger
from src.gui.custom_widgets import QHLine
HEADER1: int = 20
HEADER2: int = 15
HEADER3: int = 12
logger = get_logger(QLOGS.SETTINGS)
def create_qcombobox(choices: list, idx: int = 0) -> QComboBox:
c = QComboBox()
c.addItems(choices)
c.setCurrentIndex(idx)
return c
def create_qlabel(text: str, font_size: int = -1) -> QLabel:
l = QLabel()
l.setText(text)
if font_size != -1:
font = QFont('consolas', font_size)
else:
