def patch_exe(path_to_exe: str or Path,
version: str,
app_name: str,
wkdir: str or Path,
build_: str):
path_to_exe = Path(path_to_exe)
wkdir = Path(wkdir)
logger.info('patch exe: start')
app_name = app_name
if not path_to_exe.exists():
raise FileNotFoundError(path_to_exe)
if not wkdir.exists():
raise FileNotFoundError(wkdir)
logger.debug('short name: {}'.format(app_name))
logger.debug('version: {}'.format(version))
logger.debug('patching: {}'.format(path_to_exe.abspath()))
cmd = [
'verpatch',
path_to_exe,
'/high',
version,
'/va',
'/pv', version,
'/s', 'product', app_name,
'/s', 'copyright', '2017 etcher',
'/s', 'company', 'etcher',
'/s', 'build', str(build_),
'/s', 'PrivateBuild', str(build_),
'/langid', '1033',
]
run_piped_process(cmd, logger_=logger, cwd=wkdir)
def browse_for_single_miz(self):
init_dir = get_saved_games_path()
p = BrowseDialog.get_existing_file(self, 'Select MIZ file', _filter=['*.miz'], init_dir=init_dir.abspath())
if p:
p = Path(p)
self.single_miz.setText(p.abspath())
Config().single_miz_last = p.abspath()
def single_miz_path(self) -> Path or None:
t = self.single_miz.text()
if len(t) > 3:
p = Path(t)
if p.exists() and p.isfile() and p.ext == '.miz':
return p
return None
def build(env):
logger.info('reading GitVersion output')
version = loads(subprocess.check_output(['gitversion'], cwd='.').decode().rstrip())
logger.debug('gitversion says: {}'.format(version))
logger.info('compiling packed executable')
run_piped_process([
os.path.join(env, 'python.exe'),
'-m', 'PyInstaller',
'--noconfirm',
'--onefile',
'--clean',
'--icon', './src/ui/app.ico',
'--workpath', './build',
'--paths', os.path.join(env, r'Lib\site-packages\PyQt5\Qt\bin'),
'--log-level=WARN',
'--add-data', '{};{}'.format(certifi.where(), '.'),
'--name', global_.APP_SHORT_NAME,
'--distpath', './dist',
'--windowed',
'./src/main.py',
], logger_=logger, cwd='.')
logger.info('patching exe resources')
patch_exe(
path_to_exe=Path('./dist/EMFT.exe'),
version=version.get('SemVer'),
app_name=global_.APP_SHORT_NAME,
wkdir=Path('.'),
build_=version.get('InformationalVersion'),
)
logger.info('all done')
def auto_src_browse(self):
if self.auto_src_path:
init_dir = self.auto_src_path.dirname()
else:
init_dir = get_saved_games_path()
p = BrowseDialog.get_directory(self, 'Select source directory', init_dir=init_dir.abspath())
if p:
p = Path(p)
self.auto_src_le.setText(p.abspath())
Config().auto_source_folder = p.abspath()
self.scan()
def check_cert():
logger.info('certificate: checking')
import certifi
import os
from utils.custom_path import Path
cacert = Path(certifi.where())
# noinspection SpellCheckingInspection
if not cacert.crc32() == 'D069EE01':
raise ImportError('cacert.pem file is corrupted: {}'.format(
cacert.crc32()))
logger.debug('setting up local cacert file to: {}'.format(str(cacert)))
os.environ['REQUESTS_CA_BUNDLE'] = str(cacert)
logger.info('certificate: checked')
def build_requirements(env):
requirements = subprocess.Popen(
[os.path.join(env, 'scripts/pip.exe'), 'freeze'],
stdout=subprocess.PIPE
).stdout.read().decode('utf8')
requirements = requirements.rstrip()
requirements = requirements.replace('\r\n', '\n')
requirements = requirements.replace(r'PyInstaller==3.3.dev0+gb78bfe5',
r'git+https://github.com/132nd-etcher/pyinstaller.git#egg=PyInstaller')
requirements = re.sub(r'SLTP==\d+.\d+.\d+.*\n', r'', requirements)
requirements = re.sub(r'utils==\d+.\d+.\d+.*\n', r'', requirements)
Path('requirements.txt').write_text(requirements)
own_requirements = [
'git+https://github.com/132nd-etcher/sltp.git#egg=sltp',
'git+https://github.com/132nd-etcher/utils.git#egg=utils'
]
Path('own_requirements.txt').write_text('\n'.join(own_requirements))
def _download(self):
def proceed_with_download():
downloader.download(
url=dl_url,
local_file=local_file,
progress_title='Downloading {}'.format(dl_url.split('/').pop()),
progress_text=local_file,
file_size=file_size
)
dl_url, file_size, local_file_name = appveyor.latest_version_download_url(self.selected_branch)
local_file = Path(self.auto_src_path).joinpath(local_file_name).abspath()
if local_file.exists():
I.confirm(text='Local file already exists; do you want to overwrite?', follow_up=proceed_with_download)
else:
proceed_with_download()
def auto_out_browse(self):
if self.auto_out_path:
init_dir = self.auto_out_path.dirname()
else:
init_dir = Path('.')
p = BrowseDialog.get_directory(self, 'Select output directory', init_dir=init_dir.abspath())
if p:
p = Path(p)
self.auto_out_le.setText(p.abspath())
Config().auto_output_folder = p.abspath()
def _scan(self):
if self.auto_src_path:
try:
logger.debug('looking for latest local TRMT version')
self._latest_trmt = natsorted(
[Path(f).abspath() for f in Path(self.auto_src_path).listdir('TRMT_*.miz')]).pop()
except IndexError:
self._latest_trmt = None
self.local_version = None
logger.debug('no local TRMT found')
else:
self.local_version = Path(self._latest_trmt).namebase.replace('TRMT_', '')
logger.debug('latest local TRMT found: {}'.format(self.local_version))
# noinspection PyBroadException
try:
logger.debug('looking for latest remote TRMT version')
self.remote_version, self.remote_branch = appveyor.get_latest_remote_version(self.selected_branch)
except:
logger.debug('no remote TRMT found')
self.remote_version = None
def path(self, value: str or Path):
if isinstance(value, Path):
pass
elif isinstance(value, str):
value = Path(value)
else:
raise TypeError('expected Path or str, got: {}'.format(
type(value)))
self._path = value
def browse_for_single_miz_output_folder(self):
if self.single_miz_output_folder_path:
init_dir = self.single_miz_output_folder_path.dirname()
elif self.single_miz_path:
init_dir = self.single_miz_path.dirname()
else:
init_dir = Path('.')
p = BrowseDialog.get_directory(self, 'Select output directory', init_dir=init_dir.abspath())
if p:
p = Path(p)
self.single_miz_output_folder.setText(p.abspath())
Config().single_miz_output_folder = p.abspath()
def __init__(self):
self.single_group = GroupBox()
self.single_miz = QLineEdit()
self.single_miz.setDisabled(True)
if Config().single_miz_last:
p = Path(Config().single_miz_last)
if p.exists() and p.isfile() and p.ext == '.miz':
self.single_miz.setText(str(p.abspath()))
self.single_miz_browse = PushButton('Browse', self.browse_for_single_miz)
self.single_miz_open = PushButton('Open', self.open_single_miz)
self.single_miz_output_folder = QLineEdit()
self.single_miz_output_folder.setDisabled(True)
if Config().single_miz_output_folder:
p = Path(Config().single_miz_output_folder)
self.single_miz_output_folder.setText(str(p.abspath()))
self.single_miz_output_folder_browse = PushButton('Browse', self.browse_for_single_miz_output_folder)
self.single_miz_output_folder_open = PushButton('Open', self.open_single_miz_output_folder)
self.single_miz_reorder_btn = PushButton('Reorder MIZ file', self.single_reorder)
self.single_miz_reorder_btn.setMinimumHeight(40)
self.single_miz_reorder_btn.setMinimumWidth(400)
self.single_layout = VLayout([
GridLayout(
[
[(Label('Source MIZ'), dict(align='r')), self.single_miz, self.single_miz_browse,
self.single_miz_open],
[(Label('Output folder'), dict(align='r')), self.single_miz_output_folder,
self.single_miz_output_folder_browse,
self.single_miz_output_folder_open],
],
),
self.single_miz_reorder_btn,
])
self.single_group.setLayout(self.single_layout)
def get_saved_games_path():
if Config().saved_games_path is None:
logger.debug('searching for base "Saved Games" folder')
try:
logger.debug('trying "User Shell Folders"')
with winreg.OpenKey(A_REG,
r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders") as aKey:
# noinspection SpellCheckingInspection
base_sg = Path(winreg.QueryValueEx(aKey, "{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}")[0])
except FileNotFoundError:
logger.debug('failed, trying "Shell Folders"')
try:
with winreg.OpenKey(A_REG,
r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders") as aKey:
# noinspection SpellCheckingInspection
base_sg = Path(winreg.QueryValueEx(aKey, "{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}")[0])
except FileNotFoundError:
logger.debug('darn it, another fail, falling back to "~"')
base_sg = Path('~').expanduser().abspath()
Config().saved_games_path = str(base_sg.abspath())
return base_sg
else:
return Path(Config().saved_games_path)
def __init__(self,
path: str or Path,
init_dict: OrderedDict = None,
auto_read=True,
encrypted=False):
self.free = True
self.encrypt = encrypted
if init_dict is None:
self._data = OrderedDict()
else:
if not isinstance(init_dict, OrderedDict):
raise TypeError('expected a OrderedDict, got "{}"'.format(
type(init_dict)))
self._data = init_dict
self._values, self._keys, self._items = None, None, None
self._init_views()
if isinstance(path, Path):
pass
elif isinstance(path, str):
path = Path(path)
else:
raise TypeError('expected a Path or a str, got: {}'.format(
type(path)))
self._path = path
if auto_read:
self.read()
def read_header(path):
path = Path(path)
data = yload(path.text(encoding='utf8'))
return data['header']
def find_latest_trmt(folder: Path or str):
return natsorted(
[Path(f).abspath() for f in Path(folder).listdir('TRMT_*.miz')]).pop()
import os
import subprocess
import sys
from json import loads
import click
from natsort.natsort import natsorted
from utils.custom_logging import make_logger, DEBUG, INFO
from utils.custom_path import Path
__version__ = None
if hasattr(sys, 'frozen'):
__version__ = Path(sys.executable).get_win32_file_info().file_version
elif os.environ.get('APPVEYOR'):
__version__ = loads(
subprocess.check_output([
r'C:\ProgramData\chocolatey\bin\gitversion.exe'
]).decode().rstrip()).get('FullSemVer')
else:
# This is a potential security breach, but I'm leaving it as is as it should only be running scripted
__version__ = loads(
subprocess.check_output(['gitversion'
]).decode().rstrip()).get('FullSemVer')
__guid__ = '4ae6dbb7-5b26-28c6-b797-2272f5a074f3'
__appname__ = 'TEMP'
logger = make_logger(__name__, ch_level=INFO)
def parse_single_result(self) -> Path or None:
if self.exec():
result = self.selectedFiles()[0]
return Path(result)
else:
return None
def parse_multiple_results(self) -> typing.List[Path] or None:
if self.exec():
results = [Path(x) for x in self.selectedFiles()[0]]
return results
else:
return None
def auto_src_path(self) -> Path or None:
t = self.auto_src_le.text()
if len(t) > 3:
return Path(t)
return None
def single_miz_output_folder_path(self) -> Path or None:
t = self.single_miz_output_folder.text()
if len(t) > 3:
return Path(t)
return None
