"""

global cache

global cachedir

global cfgtree

global usrtree

cfgtree = configtree

usrtree = userconfig

cachedir = directory

if not os.path.exists(directory):

# Someone nuked the cache directory! Bastards!

os.makedirs(directory)

if not os.path.isfile(filename):

# No cache database is currently present, initialize a new one please.

initCacheDatabase(filename)

global cache

cursor = cache.cursor()

cursor.execute("SELECT updateAfter FROM updateTimers WHERE timer = ?", [timer])

res = cursor.fetchone()

if res:

(t, ) = res

return t > time.time()

else:

global cache

cursor = cache.cursor()

# Does the timer exist?

cursor.execute("SELECT * FROM updateTimers WHERE timer = ?", [timer])

if cursor.fetchone():

cursor.execute("UPDATE updateTimers SET updateAfter = ? WHERE timer = ?", [time, timer])

else:

cursor.execute("INSERT INTO updateTimers (timer, updateAfter) VALUES (?, ?)", [timer, time])

global cachedir

cache = getCache("Outposts")

if cache:

# All right! We already got a list of outposts, we're golden.

return ElementTree.parse(cachedir + '/' + cache)

else:

# No outposts are cached, pull a new list from the servers.

class VoidKey:

def __init__(self): self.keyID = 'void'

def getInfo(self): return {}

def getPrefix(self): return "eve"

(cachedUntil, filename) = fetchPage(VoidKey(), "ConquerableStationList.xml.aspx")

putCache("Outposts", cachedUntil, filename)

global cachedir

print("")

print(" Processing key: " + key.note)

assetCache = getCache(key.keyID + "/AssetList")

locationsCache = getCache(key.keyID + "/Locations")

if assetCache:

# Good, a cached version was found. Use that shit!

print(" AssetList: \tCACHED")

return buildContainers(assetCache, locationsCache)

else:

# No cached version was found, dial the API servers!

print(" AssetList: \tNOT CACHED")

# Turns out the Locations are on a different cache timer than the

# AssetLists. Effectively, you can have an old AssetList, with a

# new Location list, missing names and causing crashes.

# I'm caching the Locations with the AssetLists to avoid this -

# after all, a list of Locations is useless if it doesn't match

# the AssetList, no matter how old the AssetList is.

# The fix is simple: I cache the Locations on the same timer as

# the assetlist.

(cachedUntil, assetFile) = fetchPage(key, 'AssetList.xml.aspx')

(_, locationsFile) = fetchPage(key, 'Locations.xml.aspx',

{'IDs' : ','.join(containerIDs(assetFile))})

putCache(key.keyID + "/AssetList", cachedUntil, assetFile)

putCache(key.keyID + "/Locations", cachedUntil, locationsFile)

tree = ElementTree.parse(cachedir + '/' + assetlist)

containerTypes = [3293, 3296, 3297, 3465, 3466,

3467, 11488, 11489, 11490, 16041,

16042, 16043, 16044, 16045, 17363,

17364, 17365, 17366, 17367, 17368]

containerTypes = map(str, containerTypes)

# Grab the non-empty items.

containers = [{'itemID': item.get('itemID'),

'typeID': item.get('typeID')}

for item in tree.iter('row')

if list(item)

and item.get('typeID') in containerTypes]

# Turns out the AssetList will include corp offices as items. If you don't own the

# station, the Locations call will fail with error 135. This is a fix: Ignore all offices.

global cfgtree

global usrtree

global cachedir

assets = ElementTree.parse(cachedir + '/' + assetlist)

locations = ElementTree.parse(cachedir + '/' + locations)

# Fetch the patterns from both the config and the userconfig.

patterns = [re.compile(pattern.text)

for pattern in cfgtree.iter('pattern')];

usrpatterns = [re.compile(pattern.text)

for pattern in usrtree.iter('pattern')]

patterns = patterns + usrpatterns

containers = [container.Container(item.get('itemID'),

item.get('itemName'))

for item in locations.iter('row')

if any(map(lambda p: p.match(item.get('itemName')),

patterns))]

for c in containers:

c.addContents(assets)

"""

global cache

cursor = cache.cursor()

cursor.execute("SELECT cachedUntil, file FROM apiCache WHERE cacheName = ?", [cacheName])

res = cursor.fetchone()

if not res: return None

now = time.time()

(timeout, filename) = res

if now > timeout: return None

global cache

cursor = cache.cursor()

cursor.execute("SELECT * FROM apiCache WHERE cacheName = ?",

[cacheName])

if cursor.fetchone():

# Update the row if a previous version is cached.

cursor.execute("UPDATE apiCache SET cachedUntil = ?, file = ? WHERE cacheName = ?",

[cachedUntil, filename, cacheName])

else:

# Insert a row if no previous verion is cached.

cursor.execute("INSERT INTO apiCache (cacheName, cachedUntil, file) VALUES (?, ?, ?)",

[cacheName, cachedUntil, filename])

prefix = key.getPrefix()

info = {}

info.update(key.getInfo())

info.update(additional_info)

conn = httplib.HTTPSConnection("api.eveonline.com")

conn.request("GET", "/" + prefix + "/" + page + "?" + urllib.urlencode(info))

response = conn.getresponse()

if not response.status == 200:

print("")

print("ERROR! ({})".format(page))

print("EVE Online API Servers returned:")

print("\t{} - {}".format(response.status, response.reason))

sys.exit()

body = response.read()

filename = key.keyID + '.' + page

# Dump the page to a file - brutal but effective, and it makes my job easier.

f = open(cachedir + '/' + filename, 'w')

f.write(body)

f.close()

# All right - I'll need a timer on the cache.

root = ElementTree.fromstring(body)

currentTime = time.strptime(root.findtext("currentTime"),

"%Y-%m-%d %H:%M:%S")

cachedUntil = time.strptime(root.findtext("cachedUntil"),

"%Y-%m-%d %H:%M:%S")

time_left = time.mktime(cachedUntil) - time.mktime(currentTime)

db = sql.connect(filename)

apiQuery = """

marketQuery = """

updateQuery = """

cursor = db.cursor()

cursor.execute(apiQuery)

cursor.execute(marketQuery)

cursor.execute(updateQuery)

global cache

global cfgtree

values = {}

cursor = cache.cursor()

marketCacheTime = cfgtree.findtext(".//valuation/cachetime")

# Look at the market expression, find determine which systems

# we need data for.

systems = getMarketSystems(cfgtree.find(".//valuation/value"))

refresh = {}

for (systemName, systemID) in systems: refresh[systemID] = []

# Pick out the itemIDs we need to fetch from eve-central

for typeID in typeIDs:

if not hasMarketGroup(typeID):

# No reason to query market data for items without a market group.

continue

for (systemName, systemID) in systems:

cursor.execute("SELECT cachedUntil " +

"FROM marketCache " +

"WHERE typeID = ? AND systemID = ?",

[typeID, systemID])

result = cursor.fetchone()

if not result:

refresh[systemID] += [typeID]

continue

(cachedUntil, ) = result

if time.time() > cachedUntil:

refresh[systemID] += [typeID]

continue

updateHappened = False

# Query EVE-Central.com for the missing itemIDs.

for (systemName, systemID) in systems:

if not refresh[systemID]: continue

responsetree = marketStat(refresh[systemID], systemID)

# All right, we have the new market prices. Put them in the cache.

for elm in responsetree.findall(".//type"):

# Build a dict, keep the info handy.

info = {'cacheTime' : time.time() + float(marketCacheTime),

'typeID' : elm.get('id'),

'systemID' : systemID,

'buy' : elm.findtext('buy/max'),

'sell' : elm.findtext('sell/min'),

'median' : elm.findtext('all/median')}

# We're updating the cache database. Good. I love SQL - it's so nice and wonderful.

# I'm trying to keep the SQL simple, so I'm using multiple queries. Sue me.

cursor.execute("SELECT typeID, systemID FROM marketCache WHERE typeID = :typeID AND systemID = :systemID",

info)

if cursor.fetchone():

# Update the row if a previous version is cached.

cursor.execute("UPDATE marketCache " +

"SET cachedUntil = :cacheTime, buy = :buy, sell = :sell, median = :median " +

"WHERE typeID = :typeID AND systemID = :systemID ",

info)

else:

# Insert a row if no previous verion is cached.

cursor.execute("INSERT INTO marketCache (typeID, cachedUntil, systemID, buy, sell, median) " +

"VALUES (:typeID, :cacheTime, :systemID, :buy, :sell, :median)",

info)

updateHappened = True

if updateHappened:

cache.commit()

# Cache is up to date, evaluate the pricing expressions and return the results.

cursor = db.cursor()

cursor.execute("SELECT marketGroupID FROM invTypes WHERE typeID = ?", [typeID])

(marketGroupID, ) = cursor.fetchone()

cursor = db.cursor()

systemIDs = set([])

for e in elm.findall('.//query'):

cursor.execute("SELECT solarSystemID " +

"FROM mapSolarSystems " +

"WHERE solarSystemName = ?",

[e.get('system')])

(systemID, ) = cursor.fetchone()

systemIDs.add((e.get('system'), systemID))

params = {"hours" : 72,

"usesystem" : systemID}

typestr = '&'.join(map(lambda typeID: "typeid=" + typeID, typeIDs))

conn = httplib.HTTPConnection("api.eve-central.com")

conn.request("POST", "/api/marketstat",

urllib.urlencode(params) + '&' + typestr)

response = conn.getresponse()

global cache

global cfgtree

root = cfgtree.find('.//valuation/value/*')

def __apply(f):

def __(x, y):

acc = {}

for typeID in set(x.keys() + y.keys()):

if typeID not in x or not x[typeID]:

acc[typeID] = y[typeID]

continue

if typeID not in y or not y[typeID]:

acc[typeID] = x[typeID]

continue

acc[typeID] = f(x[typeID], y[typeID])

return acc

return __

def __min(elm):

children = map(internal, list(elm))

return reduce(__apply(min), children, {})

def __max(elm):

children = map(internal, list(elm))

return reduce(__apply(max), children, {})

def __avg(elm):

children = map(internal, list(elm))

return reduce(__apply(lambda x, y: (x + y) / 2),

children, {})

def __query(elm):

results = {}

cursor = db.cursor()

cursor.execute("SELECT solarSystemID " +

"FROM mapSolarSystems " +

"WHERE solarSystemName = ?",

[elm.get('system')])

systemID = cursor.fetchone()[0]

cursor = cache.cursor()

for typeID in typeIDs:

# Deathly super-super-hack! Don't do this, EVER!

cursor.execute("SELECT " + elm.get('stat') + " FROM marketCache WHERE typeID = ? AND systemID = ?",

[typeID, systemID])

dbres = cursor.fetchone()

if dbres:

(value, ) = dbres

results[typeID] = float(value)

else:

results[typeID] = None

return results

functions = {'min' : __min,

'max' : __max,

'avg' : __avg,

'query' : __query}

def internal(elm):

return functions[elm.tag](elm)