def newFit(self, shipID, name=None):
try:
ship = es_Ship(getItem(shipID))
except ValueError:
ship = es_Citadel(getItem(shipID))
fit = es_Fit(ship)
fit.name = name if name is not None else "New %s" % fit.ship.item.name
fit.damagePattern = self.pattern
fit.targetResists = self.targetResists
fit.character = self.character
fit.booster = self.booster
eds_queries.save(fit)
self.recalc(fit)
return fit.ID
def build(self):
""" Build object. Assumes proper and valid item already set """
self.__charge = None
self.__dps = None
self.__volley = None
self.__miningyield = None
self.__itemModifiedAttributes = ModifiedAttributeDict()
self.__chargeModifiedAttributes = ModifiedAttributeDict()
if len(self.abilities) != len(self.item.effects):
self.__abilities = []
for ability in self.__getAbilities():
self.__abilities.append(ability)
if self.__item:
self.__itemModifiedAttributes.original = self.__item.attributes
self.__itemModifiedAttributes.overrides = self.__item.overrides
self.__slot = self.__calculateSlot(self.__item)
chargeID = self.getModifiedItemAttr("fighterAbilityLaunchBombType")
if chargeID is not None:
charge = getItem(int(chargeID))
self.__charge = charge
self.__chargeModifiedAttributes.original = charge.attributes
self.__chargeModifiedAttributes.overrides = charge.overrides
def appendModule(self, fitID, itemID):
fit = getFit(fitID)
item = getItem(itemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
return False
if m.item.category.name == "Subsystem":
fit.modules.freeSlot(m.getModifiedItemAttr("subSystemSlot"))
if m.fits(fit):
m.owner = fit
numSlots = len(fit.modules)
fit.modules.append(m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eds_queries.commit()
return numSlots != len(fit.modules)
else:
return None
def changeModule(self, fitID, position, newItemID):
fit = getFit(fitID)
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
item = getItem(newItemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eds_queries.commit()
return True
else:
return None
def addCargo(self, fitID, itemID, amount=1, replace=False):
"""
Adds cargo via typeID of item. If replace = True, we replace amount with
given parameter, otherwise we increment
"""
if fitID is None:
return False
fit = getFit(fitID)
item = getItem(itemID)
cargo = None
# adding from market
for x in fit.cargo.find(item):
if x is not None:
# found item already in cargo, use previous value and remove old
cargo = x
fit.cargo.remove(x)
break
if cargo is None:
# if we don't have the item already in cargo, use default values
cargo = es_Cargo(item)
fit.cargo.append(cargo)
if replace:
cargo.amount = amount
else:
cargo.amount += amount
self.recalc(fit)
eds_queries.commit()
return True
def addDrone(self, fitID, itemID):
if fitID is None:
return False
fit = getFit(fitID)
item = getItem(itemID, eager=("attributes", "group.category"))
if item.category.name == "Drone":
drone = None
for d in fit.drones.find(item):
if d is not None and d.amountActive == 0 and d.amount < max(
5, fit.extraAttributes["maxActiveDrones"]):
drone = d
break
if drone is None:
drone = es_Drone(item)
if drone.fits(fit) is True:
fit.drones.append(drone)
else:
return False
drone.amount += 1
eds_queries.commit()
self.recalc(fit)
return True
else:
return False
def addImplant(self, charID, itemID):
char = getCharacter(charID)
if char.ro:
logger.error("Trying to add implant to read-only character")
return
implant = es_Implant(getItem(itemID))
char.implants.append(implant)
eds_queries.commit()
def setAmmo(self, fitID, ammoID, modules):
if fitID is None:
return
fit = getFit(fitID)
ammo = getItem(ammoID) if ammoID else None
for mod in modules:
if mod.isValidCharge(ammo):
mod.charge = ammo
self.recalc(fit)
def init(self):
"""Initialize cargo from the database and validate"""
self.__item = None
if self.itemID:
self.__item = getItem(self.itemID)
if self.__item is None:
logger.error("Item (id: %d) does not exist", self.itemID)
return
self.__itemModifiedAttributes = ModifiedAttributeDict()
self.__itemModifiedAttributes.original = self.__item.attributes
self.__itemModifiedAttributes.overrides = self.__item.overrides
def init(self):
"""Initialize a module from the database and validate"""
self.__item = None
self.__charge = None
# we need this early if module is invalid and returns early
self.__slot = self.dummySlot
if self.itemID:
self.__item = getItem(self.itemID)
if self.__item is None:
logger.error("Item (id: %d) does not exist", self.itemID)
return
if self.isInvalid:
logger.error("Item (id: %d) is not a Module", self.itemID)
return
if self.chargeID:
self.__charge = getItem(self.chargeID)
self.build()
def init(self):
self.__item = None
if self.itemID:
self.__item = getItem(self.itemID)
if self.__item is None:
logger.error("Item (id: %d) does not exist", self.itemID)
return
if self.isInvalid:
logger.error("Item (id: %d) is not an Implant", self.itemID)
return
self.build()
def getItem(self, identity, *args, **kwargs):
"""Get item by its ID or name"""
try:
if isinstance(identity, e_Item):
item = identity
elif isinstance(identity, int):
item = getItem(identity, *args, **kwargs)
elif isinstance(identity, basestring):
# We normally lookup with string when we are using import/export
# features. Check against overrides
identity = conversions.all.get(identity, identity)
item = getItem(identity, *args, **kwargs)
elif isinstance(identity, float):
id = int(identity)
item = getItem(id, *args, **kwargs)
else:
raise TypeError(
"Need Item object, integer, float or string as argument")
except:
logger.error("Could not get item: %s", identity)
raise
return item
def addBooster(self, fitID, itemID):
if fitID is None:
return False
fit = getFit(fitID)
item = getItem(itemID, eager="attributes")
try:
booster = es_Booster(item)
except ValueError:
return False
fit.boosters.append(booster)
self.recalc(fit)
return True
def addFighter(self, fitID, itemID):
if fitID is None:
return False
fit = getFit(fitID)
item = getItem(itemID, eager=("attributes", "group.category"))
if item.category.name == "Fighter":
fighter = None
'''
for d in fit.fighters.find(item):
if d is not None and d.amountActive == 0 and d.amount < max(5, fit.extraAttributes["maxActiveDrones"]):
drone = d
break
'''
if fighter is None:
fighter = es_Fighter(item)
used = fit.getSlotsUsed(fighter.slot)
total = fit.getNumSlots(fighter.slot)
standardAttackActive = False
for ability in fighter.abilities:
if (ability.effect.isImplemented
and ability.effect.handlerName
== u'fighterabilityattackm'):
# Activate "standard attack" if available
ability.active = True
standardAttackActive = True
else:
# Activate all other abilities (Neut, Web, etc) except propmods if no standard attack is active
if (ability.effect.isImplemented
and standardAttackActive is False
and ability.effect.handlerName !=
u'fighterabilitymicrowarpdrive'
and ability.effect.handlerName !=
u'fighterabilityevasivemaneuvers'):
ability.active = True
if used >= total:
fighter.active = False
if fighter.fits(fit) is True:
fit.fighters.append(fighter)
else:
return False
eds_queries.commit()
self.recalc(fit)
return True
else:
return False
def displayFit(self, event):
selection = self.fittingsTreeCtrl.GetSelection()
fit = json.loads(self.fittingsTreeCtrl.GetPyData(selection))
list = []
for item in fit['items']:
try:
cargo = Cargo(getItem(item['type']['id']))
cargo.amount = item['quantity']
list.append(cargo)
except:
pass
self.parent.fitView.fitSelection = selection
self.parent.fitView.update(list)
def OnImport(self, event):
dlg = wx.FileDialog(self,
"Import pyfa override file",
wildcard="pyfa override file (*.csv)|*.csv",
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
if (dlg.ShowModal() == wx.ID_OK):
path = dlg.GetPath()
with open(path, 'rb') as csvfile:
spamreader = csv.reader(csvfile)
for row in spamreader:
itemID, attrID, value = row
item = getItem(int(itemID))
attr = getAttributeInfo(int(attrID))
item.setOverride(attr, float(value))
self.itemView.updateItems(True)
def addImplant(self, fitID, itemID, recalc=True):
if fitID is None:
return False
fit = getFit(fitID)
item = getItem(itemID, eager="attributes")
try:
implant = es_Implant(item)
except ValueError:
return False
fit.implants.append(implant)
if recalc:
self.recalc(fit)
return True
def init(self):
self.__attr = None
self.__item = None
if self.attrID:
self.__attr = getAttributeInfo(self.attrID)
if self.__attr is None:
logger.error("Attribute (id: %d) does not exist", self.attrID)
return
if self.itemID:
self.__item = getItem(self.itemID)
if self.__item is None:
logger.error("Item (id: %d) does not exist", self.itemID)
return
def init(self):
"""Initialize a drone from the database and validate"""
self.__item = None
if self.itemID:
self.__item = getItem(self.itemID)
if self.__item is None:
logger.error("Item (id: %d) does not exist", self.itemID)
return
if self.isInvalid:
logger.error("Item (id: %d) is not a Drone", self.itemID)
return
self.build()
def project(self, fitID, thing):
if fitID is None:
return
fit = getFit(fitID)
if isinstance(thing, int):
thing = getItem(thing, eager=("attributes", "group.category"))
if isinstance(thing, es_Fit):
if thing in fit.projectedFits:
return
fit.__projectedFits[thing.ID] = thing
# this bit is required -- see GH issue # 83
sqlAlchemy.saveddata_session.flush()
sqlAlchemy.saveddata_session.refresh(thing)
elif thing.category.name == "Drone":
drone = None
for d in fit.projectedDrones.find(thing):
if d is None or d.amountActive == d.amount or d.amount >= 5:
drone = d
break
if drone is None:
drone = es_Drone(thing)
fit.projectedDrones.append(drone)
drone.amount += 1
elif thing.category.name == "Fighter":
fighter = es_Fighter(thing)
fit.projectedFighters.append(fighter)
elif thing.group.name == "Effect Beacon":
module = es_Module(thing)
module.state = State.ONLINE
fit.projectedModules.append(module)
else:
module = es_Module(thing)
module.state = State.ACTIVE
if not module.canHaveState(module.state, fit):
module.state = State.OFFLINE
fit.projectedModules.append(module)
eds_queries.commit()
self.recalc(fit)
return True
def build(self):
""" Build object. Assumes proper and valid item already set """
self.__charge = None
self.__dps = None
self.__volley = None
self.__miningyield = None
self.__itemModifiedAttributes = ModifiedAttributeDict()
self.__itemModifiedAttributes.original = self.__item.attributes
self.__itemModifiedAttributes.overrides = self.__item.overrides
self.__chargeModifiedAttributes = ModifiedAttributeDict()
chargeID = self.getModifiedItemAttr("entityMissileTypeID")
if chargeID is not None:
charge = getItem(int(chargeID))
self.__charge = charge
self.__chargeModifiedAttributes.original = charge.attributes
self.__chargeModifiedAttributes.overrides = charge.overrides
def isAmmo(self, itemID):
return getItem(itemID).category.name == "Charge"
def fetchPrices(cls, prices):
"""Fetch all prices passed to this method"""
# Dictionary for our price objects
priceMap = {}
# Check all provided price objects, and add invalid ones to dictionary
for price in prices:
if not price.isValid:
priceMap[price.typeID] = price
if len(priceMap) == 0:
return
# Set of items which are still to be requested from this service
toRequest = set()
# Compose list of items we're going to request
for typeID in priceMap:
# Get item object
item = getItem(typeID)
# We're not going to request items only with market group, as eve-central
# doesn't provide any data for items not on the market
if item is not None and item.marketGroupID:
toRequest.add(typeID)
# Do not waste our time if all items are not on the market
if len(toRequest) == 0:
return
# This will store POST data for eve-central
data = []
# Base request URL
baseurl = "https://eve-central.com/api/marketstat"
data.append(("usesystem", 30000142)) # Use Jita for market
for typeID in toRequest: # Add all typeID arguments
data.append(("typeid", typeID))
# Attempt to send request and process it
try:
network = Network.getInstance()
data = network.request(baseurl, network.PRICES, data)
xml = minidom.parse(data)
types = xml.getElementsByTagName("marketstat").item(
0).getElementsByTagName("type")
# Cycle through all types we've got from request
for type_ in types:
# Get data out of each typeID details tree
typeID = int(type_.getAttribute("id"))
sell = type_.getElementsByTagName("sell").item(0)
# If price data wasn't there, set price to zero
try:
percprice = float(
sell.getElementsByTagName("percentile").item(
0).firstChild.data)
except (TypeError, ValueError):
percprice = 0
# Fill price data
priceobj = priceMap[typeID]
priceobj.price = percprice
priceobj.time = time.time() + VALIDITY
priceobj.failed = None
# delete price from working dict
del priceMap[typeID]
# If getting or processing data returned any errors
except TimeoutError:
# Timeout error deserves special treatment
for typeID in priceMap.keys():
priceobj = priceMap[typeID]
priceobj.time = time.time() + TIMEOUT
priceobj.failed = True
del priceMap[typeID]
except:
# all other errors will pass and continue onward to the REREQUEST delay
pass
# if we get to this point, then we've got an error. Set to REREQUEST delay
for typeID in priceMap.keys():
priceobj = priceMap[typeID]
priceobj.time = time.time() + REREQUEST
priceobj.failed = True
def getSkillDescription(self, itemID):
return getItem(itemID).description
def addImplant(self, setID, itemID):
getImplantSet(setID).implants.append(es_Implant(getItem(itemID)))
eds_queries.commit()
