346 lines
13 KiB
Python
346 lines
13 KiB
Python
# =============================================================================
|
|
# Copyright (C) 2014 Ryan Holmes
|
|
#
|
|
# This file is part of pyfa.
|
|
#
|
|
# pyfa is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# pyfa is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with pyfa. If not, see <http://www.gnu.org/licenses/>.
|
|
# =============================================================================
|
|
|
|
|
|
import re
|
|
import os
|
|
import threading
|
|
import xml.dom
|
|
import xml.parsers.expat
|
|
from codecs import open
|
|
|
|
from bs4 import UnicodeDammit
|
|
from logbook import Logger
|
|
|
|
from eos import db
|
|
from eos.const import ImplantLocation
|
|
from service.fit import Fit as svcFit
|
|
from service.port.dna import exportDna, importDna, importDnaAlt
|
|
from service.port.eft import (
|
|
exportEft, importEft, importEftCfg,
|
|
isValidDroneImport, isValidFighterImport, isValidCargoImport,
|
|
isValidImplantImport, isValidBoosterImport)
|
|
from service.port.esi import exportESI, importESI
|
|
from service.port.multibuy import exportMultiBuy
|
|
from service.port.shared import IPortUser, UserCancelException, processing_notify
|
|
from service.port.shipstats import exportFitStats
|
|
from service.port.xml import importXml, exportXml
|
|
from service.port.muta import parseMutant, parseDynamicItemString, fetchDynamicItem
|
|
|
|
|
|
pyfalog = Logger(__name__)
|
|
|
|
# 2017/04/05 NOTE: simple validation, for xml file
|
|
RE_XML_START = r'<\?xml\s+version="1.0"[^<>]*\?>'
|
|
|
|
|
|
class Port:
|
|
"""Service which houses all import/export format functions"""
|
|
instance = None
|
|
__tag_replace_flag = True
|
|
|
|
@classmethod
|
|
def getInstance(cls):
|
|
if cls.instance is None:
|
|
cls.instance = Port()
|
|
|
|
return cls.instance
|
|
|
|
@classmethod
|
|
def set_tag_replace(cls, b):
|
|
cls.__tag_replace_flag = b
|
|
|
|
@classmethod
|
|
def is_tag_replace(cls):
|
|
# might there is a person who wants to hold tags.
|
|
# (item link in EVE client etc. When importing again to EVE)
|
|
return cls.__tag_replace_flag
|
|
|
|
@staticmethod
|
|
def backupFits(path, iportuser):
|
|
pyfalog.debug("Starting backup fits thread.")
|
|
|
|
def backupFitsWorkerFunc(path, iportuser):
|
|
success = True
|
|
try:
|
|
iportuser.on_port_process_start()
|
|
backedUpFits = Port.exportXml(svcFit.getInstance().getAllFits(), iportuser)
|
|
backupFile = open(path, "w", encoding="utf-8")
|
|
backupFile.write(backedUpFits)
|
|
backupFile.close()
|
|
except UserCancelException:
|
|
success = False
|
|
# Send done signal to GUI
|
|
# wx.CallAfter(callback, -1, "Done.")
|
|
flag = IPortUser.ID_ERROR if not success else IPortUser.ID_DONE
|
|
iportuser.on_port_processing(IPortUser.PROCESS_EXPORT | flag,
|
|
"User canceled or some error occurrence." if not success else "Done.")
|
|
|
|
threading.Thread(
|
|
target=backupFitsWorkerFunc,
|
|
args=(path, iportuser)
|
|
).start()
|
|
|
|
@staticmethod
|
|
def importFitsThreaded(paths, iportuser):
|
|
# type: (tuple, IPortUser) -> None
|
|
"""
|
|
:param paths: fits data file path list.
|
|
:param iportuser: IPortUser implemented class.
|
|
:rtype: None
|
|
"""
|
|
pyfalog.debug("Starting import fits thread.")
|
|
|
|
def importFitsFromFileWorkerFunc(paths, iportuser):
|
|
iportuser.on_port_process_start()
|
|
success, result = Port.importFitFromFiles(paths, iportuser)
|
|
flag = IPortUser.ID_ERROR if not success else IPortUser.ID_DONE
|
|
iportuser.on_port_processing(IPortUser.PROCESS_IMPORT | flag, result)
|
|
|
|
threading.Thread(
|
|
target=importFitsFromFileWorkerFunc,
|
|
args=(paths, iportuser)
|
|
).start()
|
|
|
|
@staticmethod
|
|
def importFitFromFiles(paths, iportuser=None):
|
|
"""
|
|
Imports fits from file(s). First processes all provided paths and stores
|
|
assembled fits into a list. This allows us to call back to the GUI as
|
|
fits are processed as well as when fits are being saved.
|
|
returns
|
|
"""
|
|
|
|
sFit = svcFit.getInstance()
|
|
|
|
fit_list = []
|
|
try:
|
|
for path in paths:
|
|
if iportuser: # Pulse
|
|
msg = "Processing file:\n%s" % path
|
|
pyfalog.debug(msg)
|
|
processing_notify(iportuser, IPortUser.PROCESS_IMPORT | IPortUser.ID_UPDATE, msg)
|
|
# wx.CallAfter(callback, 1, msg)
|
|
|
|
with open(path, "rb") as file_:
|
|
srcString = file_.read()
|
|
dammit = UnicodeDammit(srcString)
|
|
srcString = dammit.unicode_markup
|
|
|
|
if len(srcString) == 0: # ignore blank files
|
|
pyfalog.debug("File is blank.")
|
|
continue
|
|
|
|
try:
|
|
importType, makesNewFits, fitsImport = Port.importAuto(srcString, path, iportuser=iportuser)
|
|
fit_list += fitsImport
|
|
except xml.parsers.expat.ExpatError:
|
|
pyfalog.warning("Malformed XML in:\n{0}", path)
|
|
return False, "Malformed XML in %s" % path
|
|
|
|
# IDs = [] # NOTE: what use for IDs?
|
|
numFits = len(fit_list)
|
|
for idx, fit in enumerate(fit_list):
|
|
# Set some more fit attributes and save
|
|
fit.character = sFit.character
|
|
fit.damagePattern = sFit.pattern
|
|
fit.targetProfile = sFit.targetProfile
|
|
if len(fit.implants) > 0:
|
|
fit.implantLocation = ImplantLocation.FIT
|
|
else:
|
|
useCharImplants = sFit.serviceFittingOptions["useCharacterImplantsByDefault"]
|
|
fit.implantLocation = ImplantLocation.CHARACTER if useCharImplants else ImplantLocation.FIT
|
|
db.save(fit)
|
|
# IDs.append(fit.ID)
|
|
if iportuser: # Pulse
|
|
pyfalog.debug("Processing complete, saving fits to database: {0}/{1}", idx + 1, numFits)
|
|
processing_notify(
|
|
iportuser, IPortUser.PROCESS_IMPORT | IPortUser.ID_UPDATE,
|
|
"Processing complete, saving fits to database\n(%d/%d) %s" % (idx + 1, numFits, fit.ship.name)
|
|
)
|
|
|
|
except UserCancelException:
|
|
return False, "Processing has been canceled.\n"
|
|
except (KeyboardInterrupt, SystemExit):
|
|
raise
|
|
except Exception as e:
|
|
pyfalog.critical("Unknown exception processing: {0}", path)
|
|
pyfalog.critical(e)
|
|
# TypeError: not all arguments converted during string formatting
|
|
# return False, "Unknown Error while processing {0}" % path
|
|
return False, "Unknown error while processing {}\n\n Error: {} {}".format(
|
|
path, type(e).__name__, getattr(e, 'message', ''))
|
|
|
|
return True, fit_list
|
|
|
|
@staticmethod
|
|
def importFitFromBuffer(bufferStr, activeFit=None):
|
|
# type: (str, object) -> object
|
|
# TODO: catch the exception?
|
|
# activeFit is reserved?, bufferStr is unicode? (assume only clipboard string?
|
|
sFit = svcFit.getInstance()
|
|
importType, makesNewFits, importData = Port.importAuto(bufferStr, activeFit=activeFit)
|
|
|
|
if makesNewFits:
|
|
for fit in importData:
|
|
fit.character = sFit.character
|
|
fit.damagePattern = sFit.pattern
|
|
fit.targetProfile = sFit.targetProfile
|
|
if len(fit.implants) > 0:
|
|
fit.implantLocation = ImplantLocation.FIT
|
|
else:
|
|
useCharImplants = sFit.serviceFittingOptions["useCharacterImplantsByDefault"]
|
|
fit.implantLocation = ImplantLocation.CHARACTER if useCharImplants else ImplantLocation.FIT
|
|
db.save(fit)
|
|
return importType, importData
|
|
|
|
@classmethod
|
|
def importAuto(cls, string, path=None, activeFit=None, iportuser=None):
|
|
# type: (Port, str, str, object, IPortUser) -> object
|
|
lines = string.splitlines()
|
|
# Get first line and strip space symbols of it to avoid possible detection errors
|
|
firstLine = ''
|
|
for line in lines:
|
|
line = line.strip()
|
|
if line:
|
|
firstLine = line
|
|
break
|
|
|
|
# If XML-style start of tag encountered, detect as XML
|
|
if re.search(RE_XML_START, firstLine):
|
|
return "XML", True, cls.importXml(string, iportuser)
|
|
|
|
# If JSON-style start, parse as CREST/JSON
|
|
if firstLine[0] == '{':
|
|
return "JSON", True, (cls.importESI(string),)
|
|
|
|
# If we've got source file name which is used to describe ship name
|
|
# and first line contains something like [setup name], detect as eft config file
|
|
if re.match("^\s*\[.*\]", firstLine) and path is not None:
|
|
filename = os.path.split(path)[1]
|
|
shipName = filename.rsplit('.')[0]
|
|
return "EFT Config", True, cls.importEftCfg(shipName, lines, iportuser)
|
|
|
|
# If no file is specified and there's comma between brackets,
|
|
# consider that we have [ship, setup name] and detect like eft export format
|
|
if re.match("^\s*\[.*,.*\]", firstLine):
|
|
return "EFT", True, (cls.importEft(lines),)
|
|
|
|
# Check if string is in DNA format
|
|
dnaPattern = "\d+(:\d+(;\d+))*::"
|
|
if re.match(dnaPattern, firstLine):
|
|
return "DNA", True, (cls.importDna(string),)
|
|
dnaChatPattern = "<url=fitting:(?P<dna>{})>(?P<fitName>[^<>]+)</url>".format(dnaPattern)
|
|
m = re.search(dnaChatPattern, firstLine)
|
|
if m:
|
|
return "DNA", True, (cls.importDna(m.group("dna"), fitName=m.group("fitName")),)
|
|
m = re.search(r"DNA:(?P<dna>\d+(:\d+(\*\d+)?)*)", firstLine)
|
|
if m:
|
|
return "DNA", True, (cls.importDnaAlt(m.group("dna")),)
|
|
|
|
if activeFit is not None:
|
|
|
|
# Try to import mutated item from network
|
|
dynData = parseDynamicItemString(string)
|
|
if dynData is not None:
|
|
itemData = fetchDynamicItem(dynData)
|
|
if itemData is not None:
|
|
baseItem, mutaplasmidItem, mutations = itemData
|
|
return "FittingItem", False, ((baseItem, mutaplasmidItem, mutations),)
|
|
|
|
# Try to import mutated module
|
|
try:
|
|
baseItem, mutaplasmidItem, mutations = parseMutant(lines)
|
|
except (KeyboardInterrupt, SystemExit):
|
|
raise
|
|
except:
|
|
pass
|
|
else:
|
|
if baseItem is not None:
|
|
return "FittingItem", False, ((baseItem, mutaplasmidItem, mutations),)
|
|
# Try to import into one of additions panels
|
|
isDrone, droneData = isValidDroneImport(string)
|
|
if isDrone:
|
|
return "AdditionsDrones", False, (droneData,)
|
|
isFighter, fighterData = isValidFighterImport(string)
|
|
if isFighter:
|
|
return "AdditionsFighters", False, (fighterData,)
|
|
isImplant, implantData = isValidImplantImport(string)
|
|
if isImplant:
|
|
return "AdditionsImplants", False, (implantData,)
|
|
isBooster, boosterData = isValidBoosterImport(string)
|
|
if isBooster:
|
|
return "AdditionsBoosters", False, (boosterData,)
|
|
isCargo, cargoData = isValidCargoImport(string)
|
|
if isCargo:
|
|
return "AdditionsCargo", False, (cargoData,)
|
|
|
|
# EFT-related methods
|
|
@staticmethod
|
|
def importEft(lines):
|
|
return importEft(lines)
|
|
|
|
@staticmethod
|
|
def importEftCfg(shipname, lines, iportuser=None):
|
|
return importEftCfg(shipname, lines, iportuser)
|
|
|
|
@classmethod
|
|
def exportEft(cls, fit, options, callback=None):
|
|
return exportEft(fit, options, callback=callback)
|
|
|
|
# DNA-related methods
|
|
@staticmethod
|
|
def importDna(string, fitName=None):
|
|
return importDna(string, fitName=fitName)
|
|
|
|
@staticmethod
|
|
def importDnaAlt(string, fitName=None):
|
|
return importDnaAlt(string, fitName=fitName)
|
|
|
|
@staticmethod
|
|
def exportDna(fit, options, callback=None):
|
|
return exportDna(fit, options, callback=callback)
|
|
|
|
# ESI-related methods
|
|
@staticmethod
|
|
def importESI(string):
|
|
return importESI(string)
|
|
|
|
@staticmethod
|
|
def exportESI(fit, exportCharges, callback=None):
|
|
return exportESI(fit, exportCharges, callback=callback)
|
|
|
|
# XML-related methods
|
|
@staticmethod
|
|
def importXml(text, iportuser=None):
|
|
return importXml(text, iportuser)
|
|
|
|
@staticmethod
|
|
def exportXml(fits, iportuser=None, callback=None):
|
|
return exportXml(fits, iportuser, callback=callback)
|
|
|
|
# Multibuy-related methods
|
|
@staticmethod
|
|
def exportMultiBuy(fit, options, callback=None):
|
|
return exportMultiBuy(fit, options, callback=callback)
|
|
|
|
@staticmethod
|
|
def exportFitStats(fit, callback=None):
|
|
return exportFitStats(fit, callback=callback)
|