From b89f55c675c4e5017bb58dfd4c9e16075c675c16 Mon Sep 17 00:00:00 2001 From: DarkPhoenix Date: Tue, 26 Aug 2014 22:59:23 +0400 Subject: [PATCH] Remove obsolete scripts --- eos/utils/scripts/eveCacheToDb.py | 350 ------------------ eos/utils/scripts/riskItems.py | 565 ------------------------------ 2 files changed, 915 deletions(-) delete mode 100755 eos/utils/scripts/eveCacheToDb.py delete mode 100755 eos/utils/scripts/riskItems.py diff --git a/eos/utils/scripts/eveCacheToDb.py b/eos/utils/scripts/eveCacheToDb.py deleted file mode 100755 index 49d7ff7aa..000000000 --- a/eos/utils/scripts/eveCacheToDb.py +++ /dev/null @@ -1,350 +0,0 @@ -#!/usr/bin/env python -#=============================================================================== -# Copyright (C) 2010 Anton Vorobyov -# Copyright (C) 2010 Diego Duclos -# -# This file is part of eos. -# -# eos is free software: you can redistribute it and/or modify -# it under the terms of the GNU Lesser General Public License as published by -# the Free Software Foundation, either version 2 of the License, or -# (at your option) any later version. -# -# eos 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 Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public License -# along with eos. If not, see . -#=============================================================================== - -''' -This script pulls data out of EVE cache and makes a database dump. To get most of the data, -you need to just log into game; however, for some special data sometimes you need to dump -it by executing corresponding action in game, for example - open market tree to get data for -invmarketgroups table. -Reverence library by Entity is used, check http://wiki.github.com/ntt/reverence/ for info -As reverence uses the same Python version as EVE client (2.x series), script cannot be converted to python3 -Example commands to run the script under Linux with default eve paths for getting SQLite dump: -Tranquility: python eveCacheToDb.py --eve="~/.wine/drive_c/Program Files/CCP/EVE" --cache="~/.wine/drive_c/users/"$USER"/Local Settings/Application Data/CCP/EVE/c_program_files_ccp_eve_tranquility/cache" --dump="sqlite:////home/"$USER"/Desktop/eve.db" -Singularity: python eveCacheToDb.py --eve="~/.wine/drive_c/Program Files/CCP/Singularity" --cache="~/.wine/drive_c/users/"$USER"/Local Settings/Application Data/CCP/EVE/c_program_files_ccp_singularity_singularity/cache" --sisi --dump="sqlite:////home/"$USER"/Desktop/evetest.db" -''' - -import os -import sys - -# Add eos root path to sys.path -path = os.path.dirname(unicode(__file__, sys.getfilesystemencoding())) -sys.path.append(os.path.realpath(os.path.join(path, "..", "..", ".."))) - -def get_map(): - """ - Return table name - table class map - """ - return {"allianceshortnames": None, - "billtypes": None, - "certificaterelationships": None, - "certificates": None, - "corptickernames": None, - "dgmattribs": AttributeInfo, - "dgmeffects": EffectInfo, - "dgmtypeattribs": Attribute, - "dgmtypeeffects": Effect, - "evegraphics": None, - "evelocations": None, - "eveowners": None, - "eveunits": Unit, - "groupsByCategories": None, - "icons": Icon, - "invbptypes": None, - "invcategories": Category, - "invcontrabandTypesByFaction": None, - "invcontrabandTypesByType": None, - "invgroups": Group, - "invmetagroups": MetaGroup, - "invmarketgroups": MarketGroup, - "invmetatypes": MetaType, - "invmetatypesByTypeID": None, - "invreactiontypes": None, - "invtypes": Item, - "locationscenes": None, - "locationwormholeclasses": None, - "mapcelestialdescriptions": None, - "ownericons": None, - "ramactivities": None, - "ramaltypes": None, - "ramaltypesdetailpercategory": None, - "ramaltypesdetailpergroup": None, - "ramcompletedstatuses": None, - "ramtyperequirements": None, - "schematics": None, - "schematicsByPin": None, - "schematicsByType": None, - "schematicspinmap": None, - "schematicstypemap": None, - "shiptypes": None, - "sounds": None, - "typesByGroups": None, - "typesByMarketGroups": None} - -def get_order(): - """ - Return order for table processing - """ - return ("icons", - "invmarketgroups", - "eveunits", - "dgmattribs", - "dgmeffects", - "invcategories", - "invgroups", - "invmetagroups", - "invtypes", - "invmetatypes", - "dgmtypeattribs", - "dgmtypeeffects") - -def get_customcalls(): - """ - Return custom table - call to get data for it map - """ - return {"invmarketgroups": eve.RemoteSvc("marketProxy").GetMarketGroups()} - -def process_table(sourcetable, tablename, tableclass): - """ - Get all data from cache and write it to database - """ - # Get data from source and process it - tabledata = get_table_data(sourcetable, tablename, get_source_headers(sourcetable)) - # Insert everything into table - insert_table_values(tabledata, tableclass) - return - -def get_source_headers(sourcetable): - """ - Pull list of headers from the source table - """ - sourceheaders = None - guid = getattr(sourcetable, "__guid__", "None") - # For IndexRowset and IndexedRowLists Reverence provides list of headers - if guid in ("util.IndexRowset", "util.FilterRowset"): - sourceheaders = tuple(sourcetable.header) - # For IndexedRowLists, we need to compose list ourselves - elif guid == "util.IndexedRowLists": - headerset = set() - for item in sourcetable: - for row in sourcetable[item]: - for headername in row.__header__.Keys(): - headerset.add(headername) - sourceheaders = tuple(headerset) - return sourceheaders - -def get_table_data(sourcetable, tablename, headers): - """ - Pull data out of source table - """ - # Each row is enclosed into dictionary, full table is list of these dictionaries - datarows = [] - guid = getattr(sourcetable, "__guid__", "None") - # We have Select method for IndexRowset tables - if guid == "util.IndexRowset": - for values in sourcetable.Select(*headers): - # When Select is asked to find single value, it is returned in its raw - # form. Convert is to tuple for proper further processing - if not isinstance(values, (list, tuple, set)): - values = (values,) - headerslen = len(headers) - datarow = {} - # 1 row value should correspond to 1 header, if number or values doesn't - # correspond to number of headers then something went wrong - if headerslen != len(values): - print "Error: malformed data in source table {0}".format(tablename) - return None - # Fill row dictionary with values and append it to list - for i in xrange(headerslen): - # If we've got ASCII string, convert it to Unicode - if isinstance(values[i], str): - datarow[headers[i]] = unicode(values[i], 'ISO-8859-1') - else: - datarow[headers[i]] = values[i] - datarows.append(datarow) - # FilterRowset and IndexedRowLists are accessible almost like dictionaries - elif guid in ("util.FilterRowset", "util.IndexedRowLists"): - # Go through all source table elements - for element in sourcetable.iterkeys(): - # Go through all rows of an element - for row in sourcetable[element]: - datarow = {} - # Fill row dictionary with values we need and append it to the list - for header in headers: - value = getattr(row, header, None) - # None and zero values are different, and we want to write zero - # values to database - if value or value in (0, 0.0): - datarow[header] = value - datarows.append(datarow) - - return datarows - -def insert_table_values(tabledata, tableclass): - """ - Insert values into tables and show progress - """ - rows = 0 - rows_skipped = 0 - # Go through all table rows - for row in tabledata: - instance = tableclass() - # Print dot each 1k inserted rows - if rows / 1000.0 == int(rows / 1000.0): - sys.stdout.write(".") - sys.stdout.flush() - try: - # Go through all fields of a row, process them and insert - for header in row: - setattr(instance, header, process_value(row[header], tableclass, header)) - eos.db.gamedata_session.add(instance) - rows += 1 - except ValueError: - rows_skipped += 1 - # Print out results and actually commit results to database - print "\nInserted {0} rows. skipped {1} rows".format(rows, rows_skipped) - eos.db.gamedata_session.commit() - -def process_value(value, tableclass, header): - # Get column info - info = tableclass._sa_class_manager.mapper.c.get(header) - if info is None: - return - - # Null out non-existent foreign key relations - foreign_keys = info.foreign_keys - if len(foreign_keys) > 0: - for key in foreign_keys: - col = key.column - if not query_existence(col, value) and not key.deferrable: - if info.nullable: - return None - else: - raise ValueError("Integrity check failed") - else: - return value - #Turn booleans into actual booleans, don't leave them as integers - elif type(info.type) == Boolean: - return bool(value) - else: - return value - -existence_cache = {} -def query_existence(col, value): - key = (col, col.table, value) - info = existence_cache.get(key) - if info is None: - info = eos.db.gamedata_session.query(col.table).filter(col == value).count() > 0 - existence_cache[key] = info - - return info - -if __name__ == "__main__": - from ConfigParser import ConfigParser - from optparse import OptionParser - - from reverence import blue - from sqlalchemy import Boolean - from sqlalchemy.orm import class_mapper, ColumnProperty - - import eos.config - - # Parse command line options - usage = "usage: %prog --eve=EVE --cache=CACHE --dump=DUMP [--release=RELEASE --sisi]" - parser = OptionParser(usage=usage) - parser.add_option("-e", "--eve", help="path to eve folder") - parser.add_option("-c", "--cache", help="path to eve cache folder") - parser.add_option("-d", "--dump", help="the SQL Alchemy connection string of where we should place our final dump") - parser.add_option("-r", "--release", help="database release number, defaults to 1", default="1") - parser.add_option("-s", "--sisi", action="store_true", dest="singularity", help="if you're going to work with Singularity test server data, use this option", default=False) - (options, args) = parser.parse_args() - - - # Exit if we do not have any of required options - if not options.eve or not options.cache or not options.dump: - sys.stderr.write("You need to specify paths to eve folder, cache folder and SQL Alchemy connection string. Run script with --help option for further info.\n") - sys.exit() - - # We can deal either with singularity or tranquility servers - if options.singularity: server = "singularity" - else: server = "tranquility" - - # Set static variables for paths - PATH_EVE = os.path.expanduser(options.eve) - PATH_CACHE = os.path.expanduser(options.cache) - - eos.config.gamedata_connectionstring = options.dump - eos.config.debug = False - - from eos.gamedata import * - import eos.db - - # Get version of EVE client - config = ConfigParser() - config.read(os.path.join(PATH_EVE, "common.ini")) - - # Form metadata dictionary for corresponding table - metadata = {} - metadata["version"] = config.getint("main", "build") - metadata["release"] = options.release - - # Initialize Reverence cache manager - eve = blue.EVE(PATH_EVE, cachepath=PATH_CACHE, server=server) - cfg = eve.getconfigmgr() - - # Create all tables we need - eos.db.gamedata_meta.create_all() - - # Add versioning info to the metadata table - for fieldname in metadata: - eos.db.gamedata_session.add(MetaData(fieldname, metadata[fieldname])) - - eos.db.gamedata_session.commit() - - # Get table map, processing order and special table data - TABLE_MAP = get_map() - TABLE_ORDER = get_order() - CUSTOM_CALLS = get_customcalls() - - # Warn about various stuff - for table in cfg.tables: - if not table in TABLE_MAP: - # Warn about new tables in cache which are still not described by table map - print "Warning: unmapped table {0} found in cache".format(table) - for table in TABLE_MAP: - if not table in cfg.tables and not table in CUSTOM_CALLS: - # Warn about mapped tables which are missing in cache - print "Warning: mapped table {0} cannot be found in cache".format(table) - if not table in TABLE_ORDER and TABLE_MAP[table] is not None: - # Warn about mapped tables not specified in processing order - print "Warning: mapped table {0} is missing in processing order".format(table) - for table in TABLE_ORDER: - if not table in TABLE_MAP: - # Warn about unmapped tables in processing order - print "Warning: unmapped table {0} is specified in processing order".format(table) - - # Get data from reverence and write it - for tablename in TABLE_ORDER: - tableclass = TABLE_MAP[tablename] - if tableclass is not None: - # Print currently processed table name - print "Processing: {0}".format(tablename) - # Get table object from the Reverence and process it - source_table = getattr(cfg, tablename) if tablename not in CUSTOM_CALLS else CUSTOM_CALLS[tablename] - # Gather data regarding columns for current table in cache and eos - cols_eos = set(prop.key for prop in class_mapper(TABLE_MAP[tablename]).iterate_properties if isinstance(prop, ColumnProperty)) - cols_rev = set(get_source_headers(source_table)) - notineos = cols_rev.difference(cols_eos) - notinrev = cols_eos.difference(cols_rev) - if notineos: - print "Warning: {0} found in cache but missing in eos definitions: {1}".format("column" if len(notineos) == 1 else "columns", ", ".join(sorted(notineos))) - if notinrev: - print "Warning: {0} found in eos definitions but missing in cache: {1}".format("column" if len(notinrev) == 1 else "columns", ", ".join(sorted(notinrev))) - process_table(source_table, tablename, tableclass) diff --git a/eos/utils/scripts/riskItems.py b/eos/utils/scripts/riskItems.py deleted file mode 100755 index ccb7a22ab..000000000 --- a/eos/utils/scripts/riskItems.py +++ /dev/null @@ -1,565 +0,0 @@ -""" -This is ugly, tricky and unreadable script which helps to detect which items should be tested, -based on how its current effects work. -""" -import sqlite3 -import os.path -import copy -from optparse import OptionParser - -parser = OptionParser() -parser.add_option("-d", "--database", help="path to eve cache data dump in \ -sqlite format, default eos database path is used if none specified", -type="string", default=os.path.join("~", ".pyfa","eve.db")) -parser.add_option("-a", "--attr", help="find items with all of these attributes", -type="string", default="") -parser.add_option("-s", "--srq", help="find items with any of these skill requirements", -type="string", default="") -parser.add_option("-g", "--grp", help="find items from any of these groups", -type="string", default="") -parser.add_option("-z", "--nozero", action="store_true", help="ignore attributes with zero values", -default=False) -parser.add_option("-o", "--noone", action="store_true", help="ignore attributes with value equal to 1", -default=False) -parser.add_option("-t", "--tech12", action="store_true", help="show only t12 items (with exception for items with no t1 variations)", -default=False) -(options, args) = parser.parse_args() - -if not options.attr: - import sys - - sys.stderr.write("You need to specify an attribute name.\n") - sys.exit() - -# Connect to database and set up cursor -db = sqlite3.connect(os.path.expanduser(options.database)) -cursor = db.cursor() - -# As we don't rely on eos's overrides, we need to set them manually -OVERRIDES = ''' -UPDATE invtypes SET published = '1' WHERE typeName = 'Freki'; -UPDATE invtypes SET published = '1' WHERE typeName = 'Mimir'; -UPDATE invtypes SET published = '1' WHERE typeName = 'Utu'; -UPDATE invtypes SET published = '1' WHERE typeName = 'Adrestia'; -''' -for statement in OVERRIDES.split(";\n"): - cursor.execute(statement) - -# Queries to get raw data -# Limit categories to Celestials (2, only for wormhole effects), -# Ships (6), Modules (7), Charges (8), Skills (16), Drones (18), -# Implants (20), Subsystems (32) -QUERY_PUBLISHEDTYPEIDS = 'SELECT it.typeID FROM invtypes AS it INNER JOIN \ -invgroups AS ig ON it.groupID = ig.groupID INNER JOIN invcategories AS ic ON \ -ig.categoryID = ic.categoryID WHERE it.published = 1 AND ic.categoryID IN \ -(2, 6, 7, 8, 16, 18, 20, 32)' -QUERY_ATTRIBUTEID_TYPEID = "SELECT it.typeID, dta.value FROM invtypes AS it INNER JOIN \ -dgmtypeattribs AS dta ON it.typeID = dta.typeID INNER JOIN dgmattribs AS da \ -ON dta.attributeID = da.attributeID WHERE da.attributeID = ?" -QUERY_TYPEID_GROUPID = 'SELECT groupID FROM invtypes WHERE typeID = ? LIMIT 1' -QUERY_GROUPID_CATEGORYID = 'SELECT categoryID FROM invgroups WHERE \ -groupID = ? LIMIT 1' -QUERY_TYPEID_PARENTTYPEID = 'SELECT parentTypeID FROM invmetatypes WHERE \ -typeID = ? LIMIT 1' -QUERY_TYPEID_METAGROUPID = 'SELECT metaGroupID FROM invmetatypes WHERE \ -typeID = ? LIMIT 1' -QUERY_TYPEID_SKILLRQ = 'SELECT dta.value FROM dgmtypeattribs AS dta INNER JOIN \ -dgmattribs AS da ON da.attributeID = dta.attributeID WHERE (da.attributeName = \ -"requiredSkill1" OR da.attributeName = "requiredSkill2" OR da.attributeName = \ -"requiredSkill3") AND dta.typeID = ?' -QUERY_TYPEID_MARKETGROUPID = 'SELECT marketGroupID FROM invtypes WHERE \ -typeID = ? LIMIT 1' -QUERY_TYPEID_TYPENAME = 'SELECT typeName FROM invtypes WHERE typeID = ? \ -LIMIT 1' -QUERY_MARKETGROUPID_PARENTGROUPID = 'SELECT parentGroupID FROM \ -invmarketgroups WHERE marketGroupID = ? LIMIT 1' -QUERY_EFFECTID_TYPEID = 'SELECT typeID FROM dgmtypeeffects WHERE effectID = ?' -# Queries for printing -QUERY_GROUPID_GROUPNAME = 'SELECT groupName FROM invgroups WHERE groupID = ? \ -LIMIT 1' -QUERY_CATEGORYID_CATEGORYNAME = 'SELECT categoryName FROM invcategories \ -WHERE categoryID = ? LIMIT 1' -QUERY_MARKETGROUPID_MARKETGROUPNAME = 'SELECT marketGroupName FROM \ -invmarketgroups WHERE marketGroupID = ? LIMIT 1' - -QUERY_ATTRIBUTENAME_ATTRIBUTEID = 'SELECT attributeID FROM dgmattribs WHERE attributeName = ?' -QUERY_TYPENAME_TYPEID = 'SELECT typeID FROM invtypes WHERE typeName = ?' -QUERY_GROUPNAME_GROUPID = 'SELECT groupID FROM invgroups WHERE groupName = ?' - -if options.srq: - global_skillrqids = set() - for srq in options.srq.split(","): - srqid = 0 - cursor.execute(QUERY_TYPENAME_TYPEID, (srq,)) - for row in cursor: - srqid = row[0] - if not srqid: - import sys - sys.stderr.write("You need to specify proper skill requirement name.\n") - sys.exit() - else: - global_skillrqids.add(srqid) - -if options.grp: - global_groupids = set() - for grp in options.grp.split(","): - grouplist = [] - cursor.execute(QUERY_GROUPNAME_GROUPID, (grp,)) - for row in cursor: - grouplist.append(row[0]) - if len(grouplist) > 1: - print("Warning: multiple groups found, using ID", grouplist[0]) - elif len(grouplist) == 0: - import sys - sys.stderr.write("You need to specify proper group name.\n") - sys.exit() - global_groupids.add(grouplist[0]) - -# Published types set -publishedtypes = set() -cursor.execute(QUERY_PUBLISHEDTYPEIDS) -for row in cursor: - publishedtypes.add(row[0]) - -# We'll use list of items with given attributes as base for any operations -# Term item means item with given attribute -typeswithattr = set() -first = True -for attr in options.attr.split(","): - tmp = set() - cursor.execute(QUERY_ATTRIBUTENAME_ATTRIBUTEID, (attr,)) - noattr = True - for row in cursor: - noattr = False - attrid = row[0] - if noattr: - import sys - sys.stderr.write("No \"{0}\" attribute found.\n".format(attr)) - sys.exit() - cursor.execute(QUERY_ATTRIBUTEID_TYPEID, (attrid,)) - for row in cursor: - if options.nozero: - if row[0] in publishedtypes and row[1] not in (None, 0, 0.0): - tmp.add(row[0]) - elif options.noone: - if row[0] in publishedtypes and row[1] != 1.0: - tmp.add(row[0]) - else: - if row[0] in publishedtypes: - tmp.add(row[0]) - if first: - first = False - typeswithattr = copy.deepcopy(tmp) - else: - typeswithattr.intersection_update(tmp) -if len(typeswithattr) == 0: - import sys - sys.stderr.write("No items found with all of supplied attributes.\n") - sys.exit() - -# Base type maps -# { basetypeid : set(typeid) } -map_basetypeid_typeid = {} -# { typeid : basetypeid } -map_typeid_basetypeid = {} -for typeid in typeswithattr: - # Not all typeIDs in the database have baseTypeID, so assign some - # default value to it - basetypeid = 0 - cursor.execute(QUERY_TYPEID_PARENTTYPEID, (typeid,)) - for row in cursor: - basetypeid = row[0] - # If base type is not published or is not set in database, consider - # item as variation of self - if basetypeid not in typeswithattr: - basetypeid = typeid - if not basetypeid in map_basetypeid_typeid: - map_basetypeid_typeid[basetypeid] = set() - map_basetypeid_typeid[basetypeid].add(typeid) - map_typeid_basetypeid[typeid] = basetypeid - -# Meta group maps -# { metagroupid : set(typeid) } -map_metagroupid_typeid = {} -# { typeid : metagroupid } -map_typeid_metagroupid = {} -for typeid in typeswithattr: - # Assume items are tech 1 by default - metagroupid = 1 - cursor.execute(QUERY_TYPEID_METAGROUPID, (typeid,)) - for row in cursor: - metagroupid = row[0] - if not metagroupid in map_metagroupid_typeid: - map_metagroupid_typeid[metagroupid] = set() - map_metagroupid_typeid[metagroupid].add(typeid) - map_typeid_metagroupid[typeid] = metagroupid - -# Filter out non-t1/t2 items if we're asked to do so -if options.tech12: - toremove = set() - for typeid in typeswithattr: - if map_typeid_basetypeid[typeid] != typeid and map_typeid_metagroupid[typeid] != 2: - toremove.add(typeid) - for id in toremove: - typeswithattr.remove(id) - -print("Attributes:") -for attr in sorted(options.attr.split(",")): - print(attr) -print("") - -# Compose group maps -# { groupid : set(typeid) } -map_groupid_typeid = {} -# { typeid : groupid } -map_typeid_groupid = {} -for typeid in typeswithattr: - groupid = 0 - cursor.execute(QUERY_TYPEID_GROUPID, (typeid,)) - for row in cursor: - groupid = row[0] - if not groupid in map_groupid_typeid: - map_groupid_typeid[groupid] = set() - map_groupid_typeid[groupid].add(typeid) - map_typeid_groupid[typeid] = groupid - -# Category maps -# { categoryid : set(typeid) } -map_categoryid_typeid = {} -# { typeid : categoryid } -map_typeid_categoryid = {} -for typeid in typeswithattr: - categoryid = 0 - cursor.execute(QUERY_GROUPID_CATEGORYID, - (map_typeid_groupid[typeid],)) - for row in cursor: - categoryid = row[0] - if not categoryid in map_categoryid_typeid: - map_categoryid_typeid[categoryid] = set() - map_categoryid_typeid[categoryid].add(typeid) - map_typeid_categoryid[typeid] = categoryid -# { categoryid : set(groupid) } -map_categoryid_groupid = {} -# { groupid : categoryid } -map_groupid_categoryid = {} -for groupid in map_groupid_typeid: - categoryid = 0 - cursor.execute(QUERY_GROUPID_CATEGORYID, - (groupid,)) - for row in cursor: - categoryid = row[0] - if not categoryid in map_categoryid_groupid: - map_categoryid_groupid[categoryid] = set() - map_categoryid_groupid[categoryid].add(groupid) - map_groupid_categoryid[groupid] = categoryid - -# Skill required maps -# { skillid : set(typeid) } -map_skillrq_typeid = {} -# { typeid : set(skillid) } -map_typeid_skillrq = {} -# list of items without skill requirements -set_typeid_noskillrq = set() -for typeid in typeswithattr: - map_typeid_skillrq[typeid] = set() - cursor.execute(QUERY_TYPEID_SKILLRQ, (typeid,)) - no_rqs = True - for row in cursor: - no_rqs = False - skillid = row[0] - if not skillid in map_skillrq_typeid: - map_skillrq_typeid[skillid] = set() - map_skillrq_typeid[skillid].add(typeid) - map_typeid_skillrq[typeid].add(skillid) - if no_rqs: - set_typeid_noskillrq.add(typeid) - -def gettypename(typeid): - typename = "" - cursor.execute(QUERY_TYPEID_TYPENAME, (typeid,)) - for row in cursor: - typename = row[0] - return typename - -def getgroupname(grpid): - grpname = "" - cursor.execute(QUERY_GROUPID_GROUPNAME, (grpid,)) - for row in cursor: - grpname = row[0] - return grpname - -def getcatname(catid): - catname = "" - cursor.execute(QUERY_CATEGORYID_CATEGORYNAME, (catid,)) - for row in cursor: - catname = row[0] - return catname - -if options.grp and options.srq: - # Set of items which are supposed to be affected - targetitems = set() - for groupid in global_groupids: - for srqid in global_skillrqids: - if groupid in map_groupid_typeid and srqid in map_skillrq_typeid: - targetitems.update(map_groupid_typeid[groupid].intersection(map_skillrq_typeid[srqid])) - targetitems_noskillrqs = targetitems.intersection(set_typeid_noskillrq) - # All skill requirements of items which are supposed to be affected - targetitems_skillrqs = set() - for itemid in targetitems: - targetitems_skillrqs.update(map_typeid_skillrq[itemid]) - # Remove skill requirement supplied as argument to script - # we can use that argument when needed manually, and it - # covers all targetitems which we don't want to do with single skill - for srqid in global_skillrqids: - targetitems_skillrqs.remove(srqid) - - if targetitems: - # Print items which are supposed to be affected - print("Affected items:") - for groupid in sorted(global_groupids, key=lambda grid: getgroupname(grid)): - targetitems_grp = targetitems.intersection(map_groupid_typeid[groupid]) - print(" Items from {0} group:".format(getgroupname(groupid))) - # Cycle through all required skills - targetitems_skillrqs_withgiven = copy.deepcopy(targetitems_skillrqs) - for srqid in global_skillrqids: - targetitems_skillrqs_withgiven.add(srqid) - for skillrq in sorted(targetitems_skillrqs_withgiven, key=lambda sk: gettypename(sk)): - targetitems_grp_srq = targetitems_grp.intersection(map_skillrq_typeid[skillrq]) - if targetitems_grp_srq: - print(" Items requiring {0} skill:".format(gettypename(skillrq))) - for item in sorted(targetitems_grp_srq, key=lambda item: gettypename(item)): - # If item has 3rd skill requirement (besides supplied as argument and - # included into header of current section), mention it - if len(map_typeid_skillrq[item]) in (2, 3): - otherskillrq = copy.deepcopy(map_typeid_skillrq[item]) - otherskillrq.discard(skillrq) - print(" {0} ({1})".format(gettypename(item), ", ".join(sorted(gettypename(id) for id in otherskillrq)))) - # Just print item names if there's only 1 skill requirement - elif len(map_typeid_skillrq[item]) == 1: - print(" {0}".format(gettypename(item))) - else: - print("WARNING: Bad things happened, we never should get here") - - print("\nUnaffected items") - - - items_in_groups = set() - for groupid in global_groupids: - items_in_groups.update(map_groupid_typeid[groupid]) - items_with_skillrqs = set() - for srqid in global_skillrqids: - items_with_skillrqs.update(map_skillrq_typeid[srqid]) - # List items which do not belong to given group, but have given skill requirement - wskill = typeswithattr.intersection(items_with_skillrqs) - wogroup = typeswithattr.difference(items_in_groups) - nontarget_wskill_wogroup = wskill.intersection(wogroup) - if nontarget_wskill_wogroup: - print(" With {0} skill requirements, not belonging to {1} groups:".format(", ".join(sorted(gettypename(id) for id in global_skillrqids)), ", ".join(sorted(getgroupname(grid) for grid in global_groupids)))) - for item in sorted(nontarget_wskill_wogroup, key=lambda item: gettypename(item)): - print(" {0}".format(gettypename(item))) - - # List items which belong to given group, but do not have given skill requirement - woskill = typeswithattr.difference(items_with_skillrqs) - wgroup = typeswithattr.intersection(items_in_groups) - nontarget_woskill_wgroup = woskill.intersection(wgroup) - if nontarget_woskill_wgroup: - print(" Without {0} skill requirement, belonging to {1} group:".format(", ".join(sorted(gettypename(id) for id in global_skillrqids)), ", ".join(sorted(getgroupname(grid) for grid in global_groupids)))) - for item in sorted(nontarget_woskill_wgroup, key=lambda item: gettypename(item)): - print(" {0}".format(gettypename(item))) - - # If any of the above lists is missing, list all unaffected items - if not nontarget_wskill_wogroup or not nontarget_woskill_wgroup: - nontarget = typeswithattr.difference(items_in_groups) - for srqid in global_skillrqids: - nontarget.difference_update(map_skillrq_typeid[srqid]) - if nontarget_wskill_wogroup: - nontarget.difference_update(nontarget_wskill_wogroup) - if nontarget_woskill_wgroup: - nontarget.difference_update(nontarget_woskill_wgroup) - nontarget_groups = set() - nontarget_cats = set() - print(" Plain list:") - for item in sorted(nontarget, key=lambda item: gettypename(item)): - nontarget_groups.add(map_typeid_groupid[item]) - print(" {0} ({1})".format(gettypename(item), getgroupname(map_typeid_groupid[item]))) - #print(" Groups:") - #for group in sorted(nontarget_groups, key=lambda grp: getgroupname(grp)): - # nontarget_cats.add(map_groupid_categoryid[group]) - # print(" {0} ({1})".format(getgroupname(group), getcatname(map_groupid_categoryid[group]))) - #print(" Categories:") - #for cat in sorted(nontarget_cats, key=lambda cat: getcatname(cat)): - # print(" {0}".format(getcatname(cat))) - -elif options.grp: - # Set of items which are supposed to be affected - targetitems = set() - for groupid in global_groupids: - if groupid in map_groupid_typeid: - targetitems.update(map_groupid_typeid[groupid]) - # All skill requirements of items which are supposed to be affected - targetitems_skillrqs = set() - for itemid in targetitems: - targetitems_skillrqs.update(map_typeid_skillrq[itemid]) - targetitems_noskillrqs = targetitems.intersection(set_typeid_noskillrq) - if targetitems: - # Print items which are supposed to be affected - print("Affected items:") - for groupid in sorted(global_groupids, key=lambda grid: getgroupname(grid)): - print(" From {0} group:".format(getgroupname(groupid))) - targetitems_grp = targetitems.intersection(map_groupid_typeid[groupid]) - targetitems_noskillrqs_grp = targetitems_noskillrqs.intersection(map_groupid_typeid[groupid]) - # Cycle through all required skills - for skillrq in sorted(targetitems_skillrqs, key=lambda sk: gettypename(sk)): - items_grpsrq = targetitems_grp.intersection(map_skillrq_typeid[skillrq]) - if items_grpsrq: - print(" Requiring {0} skill:".format(gettypename(skillrq))) - for item in sorted(items_grpsrq, key=lambda item: gettypename(item)): - # If item has other skill requirements, print them - if len(map_typeid_skillrq[item]) == 3 or len(map_typeid_skillrq[item]) == 2: - otherskillrq = copy.deepcopy(map_typeid_skillrq[item]) - otherskillrq.discard(skillrq) - print(" {0} ({1})".format(gettypename(item), ", ".join(sorted(gettypename(id) for id in otherskillrq)))) - # Just print item names if there're only 2 skill requirements - elif len(map_typeid_skillrq[item]) == 1: - print(" {0}".format(gettypename(item))) - else: - print("WARNING: Bad things happened, we never should get here") - if targetitems_noskillrqs: - print(" Requiring no skills:") - for item in sorted(targetitems_noskillrqs_grp, key=lambda item: gettypename(item)): - print(" {0}".format(gettypename(item))) - - print("\nUnaffected items") - - # List items which are supposed to be unaffected - nontarget = typeswithattr.difference(targetitems) - nontarget_groups = set() - nontarget_cats = set() - print(" Not belonging to groups {0}:".format(", ".join(getgroupname(id) for id in global_groupids))) - - removeitms = set() - # Check 1 unaffected item with each skill requirement, if some items with it were affected - for skillrq in sorted(targetitems_skillrqs, key=lambda srq: gettypename(srq)): - if nontarget.intersection(map_skillrq_typeid[skillrq]): - print(" With {0} skill requirement:".format(gettypename(skillrq))) - for item in sorted(nontarget.intersection(map_skillrq_typeid[skillrq]), key=lambda item: gettypename(item)): - print(" {0}".format(gettypename(item))) - removeitms.update(map_skillrq_typeid[skillrq]) - nontarget.difference_update(removeitms) - print(" With other or no skill requirements:") - for item in sorted(nontarget, key=lambda item: gettypename(item)): - nontarget_groups.add(map_typeid_groupid[item]) - print(" {0} ({1})".format(gettypename(item), getgroupname(map_typeid_groupid[item]))) - - #print(" Groups:") - #for group in sorted(nontarget_groups, key=lambda grp: getgroupname(grp)): - # nontarget_cats.add(map_groupid_categoryid[group]) - # print(" {0} ({1})".format(getgroupname(group), getcatname(map_groupid_categoryid[group]))) - #print(" Categories:") - #for cat in sorted(nontarget_cats, key=lambda cat: getcatname(cat)): - # print(" {0}".format(getcatname(cat))) - -elif options.srq: - # Set of items which are supposed to be affected - targetitems = set() - for srqid in global_skillrqids: - if srqid in map_skillrq_typeid: - targetitems.update(map_skillrq_typeid[srqid]) - - # All groups of items which are supposed to be affected - targetitems_groups = set() - targetitems_srqs = set() - targetitems_cats = set() - for itemid in targetitems: - targetitems_groups.add(map_typeid_groupid[itemid]) - targetitems_srqs.update(map_typeid_skillrq[itemid]) - targetitems_cats.add(map_typeid_categoryid[itemid]) - if targetitems: - # Print items which are supposed to be affected - print("Affected items:") - for srqid in sorted(global_skillrqids, key=lambda itm: gettypename(itm)): - print(" With {0} skill requirements:".format(gettypename(srqid))) - targetitems_srq = targetitems.intersection(map_skillrq_typeid[srqid]) - targetitems_srq_groups = set() - targetitems_srq_cats = set() - for itemid in targetitems_srq: - targetitems_srq_groups.add(map_typeid_groupid[itemid]) - targetitems_srq_cats.add(map_typeid_categoryid[itemid]) - # Cycle through groups - for groupid in sorted(targetitems_srq_groups, key=lambda grp: getgroupname(grp)): - print(" From {0} group:".format(getgroupname(groupid))) - for item in sorted(targetitems_srq.intersection(map_groupid_typeid[groupid]), key=lambda item: gettypename(item)): - print(" {0} ({1})".format(gettypename(item), ", ".join(sorted(gettypename(itm) for itm in map_typeid_skillrq[item].difference(global_skillrqids))) or "None")) - - print("\nUnaffected items") - - # List items which are supposed to be unaffected - nontarget = typeswithattr.difference(targetitems) - nontarget_groups = set() - nontarget_cats = set() - print(" Without {0} skills requirement:".format(", ".join(gettypename(id) for id in global_skillrqids))) - removeitms = set() - # Check 1 unaffected item from each group where some items were affected - for groupid in sorted(targetitems_groups, key=lambda grp: getgroupname(grp)): - if nontarget.intersection(map_groupid_typeid[groupid]): - print(" From {0} group:".format(getgroupname(groupid))) - for skillrqid in sorted(targetitems_srqs.difference(global_skillrqids), key=lambda srq: gettypename(srq)): - itmset = nontarget.intersection(map_groupid_typeid[groupid]).intersection(map_skillrq_typeid[skillrqid]) - if itmset: - print(" Items with {0} skill requirement:".format(gettypename(skillrqid))) - for item in sorted(itmset, key=lambda itm: gettypename(itm)): - otherskrqs = map_typeid_skillrq[item].difference(global_skillrqids) - otherskrqs.remove(skillrqid) - print(" {0} ({1})".format(gettypename(item), ", ".join(sorted(gettypename(itm) for itm in otherskrqs)) or "None")) - removeitms.update(itmset) - nontarget.difference_update(removeitms) - otsk = nontarget.intersection(map_groupid_typeid[groupid]).difference(set_typeid_noskillrq) - if otsk: - print(" Items with other skill requirements:") - for item in sorted(otsk, key=lambda itm: gettypename(itm)): - print(" {0} (None)".format(gettypename(item))) - removeitms.update(otsk) - nosk = nontarget.intersection(map_groupid_typeid[groupid]).intersection(set_typeid_noskillrq) - if nosk: - print(" Items with no skill requirement:") - for item in sorted(nosk, key=lambda itm: gettypename(itm)): - print(" {0} (None)".format(gettypename(item))) - removeitms.update(nosk) - nontarget.difference_update(removeitms) - for catid in sorted(targetitems_cats, key=lambda cat: getcatname(cat)): - if nontarget.intersection(map_categoryid_typeid[catid]): - print(" From {0} category:".format(getcatname(catid))) - for item in sorted(nontarget.intersection(map_categoryid_typeid[catid]), key=lambda item: gettypename(item)): - print(" {0}".format(gettypename(item))) - removeitms.update(map_categoryid_typeid[catid]) - nontarget.difference_update(removeitms) - if nontarget: - # Check any other unaffected item - print(" Remaining items:") - for item in sorted(nontarget, key=lambda item: gettypename(item)): - nontarget_groups.add(map_typeid_groupid[item]) - print(" {0} ({1})".format(gettypename(item), getgroupname(map_typeid_groupid[item]))) - #print(" Groups:") - #for group in sorted(nontarget_groups, key=lambda grp: getgroupname(grp)): - # nontarget_cats.add(map_groupid_categoryid[group]) - # print(" {0} ({1})".format(getgroupname(group), getcatname(map_groupid_categoryid[group]))) - #print(" Categories:") - #for cat in sorted(nontarget_cats, key=lambda cat: getcatname(cat)): - # print(" {0}".format(getcatname(cat))) - -else: - print("Affected items") - targetitems = typeswithattr - targetitems_groups = set() - targetitems_cats = set() - print(" Assumed set of items:") - for item in sorted(targetitems, key=lambda item: gettypename(item)): - targetitems_groups.add(map_typeid_groupid[item]) - print(" {0} ({1})".format(gettypename(item), getgroupname(map_typeid_groupid[item]))) - print(" Groups:") - for group in sorted(targetitems_groups, key=lambda grp: getgroupname(grp)): - targetitems_cats.add(map_groupid_categoryid[group]) - print(" {0} ({1})".format(getgroupname(group), getcatname(map_groupid_categoryid[group]))) - print(" Categories:") - for cat in sorted(targetitems_cats, key=lambda cat: getcatname(cat)): - print(" {0}".format(getcatname(cat)))