def run(self, arg):
today_match = {"": ""}
while(1):
all_user_birth = DBHandler().select("SELECT Open_ID,Birth from UserInfo")
for user_line in all_user_birth[1]:
user_id = user_line[0]
if user_line[1] is not None:
user_birth = user_line[1].strftime("%Y-%m-%d")
birth_MM_DD = user_birth.split("-", 1)[1]
else:
birth_MM_DD = ""
now_MM_DD = time.strftime('%m-%d', time.localtime(time.time()))
if birth_MM_DD == now_MM_DD and today_match.get(user_id, "NoRecord") != birth_MM_DD:
today_match[user_id] = now_MM_DD
print("match")
ret = WeChatHandler().sendMsgViaCust(Resource.getMsg("Birth") + Resource.getMsg("ReplyHappy"),
"touser", user_id)
if int(ret) != 0:
print("BirthDayNotifier Cust Msg failed..Use preview")
sleep(300)
WeChatHandler().sendMsgToOneAsPreview(Resource.getMsg("Birth") + Resource.getMsg("ReplyHappy"),
"touser", user_id)
ActionsExecutor.add_manual_action(user_id, Action(self.check_reply, user_id, "NoHappy"))
threading.Timer(3600, self.get_action, args=(user_id,)).start()
self.logger.debug("Sleep Birth")
sleep(120)
def unSub_Weahter(user, city, lang):
UserHandler.logger.info(
"User <%s> is un-subscribing the city <%s> weather" % (user, city))
# QUERY
user_sub_result = DBHandler().select(
"SELECT Cities from WeatherSub WHERE Open_ID = '%s'" % user)
content = ""
if int(user_sub_result[0]) > 0:
old_cities = user_sub_result[1][0][0].split()
if city not in old_cities:
content = "未订阅<%s>天气" % city
else:
old_cities.remove(city)
if len(old_cities) > 0:
content = Resource.getMsg(
"UnSubWea", lang) % (city, " ".join(old_cities))
update_sql = "UPDATE WeatherSub SET Cities = '%s' WHERE Open_ID = '%s'" % (
" ".join(old_cities), user)
DBHandler().update(update_sql)
else:
content = Resource.getMsg("UnSubAllWea", lang) % city
delete_sql = "DELETE from WeatherSub WHERE Open_ID = '%s'" % (
user)
DBHandler().delete(delete_sql)
else:
content = Resource.getMsg("NoSub", lang)
return content
def __init__(self,max_cores=1,name='Cores'):
Resource.__init__(self)
cores = self.manager.BoundedSemaphore(max_cores)
in_service = InService( \
inbox = self.checkinbox ,
cores = cores ,
name = name+'_checkin' ,
)
out_service = OutService( \
inbox = self.checkoutbox ,
cores = cores ,
name = name+'_checkout' ,
)
self.name = name
self.max_cores = max_cores
self.cores = cores
self.in_service = in_service
self.out_service = out_service
self.start()
def __init__(self, parentObject=None, resourceDescriptor = {}):
Resource.__init__(self)
# The resources dictionary is for subclasses of RESTfulResource, routable as http endpoints
# The Properties dictionary is for serializable objects and strings, get/put but not routable
self.Resources = RESTfulDictEndpoint(self.resources) #make resources endpoint from the dictionary
# make properties resource and it's endpoint
self._properties = {}
self.Properties = RESTfulDictEndpoint(self._properties) #make Properties endpoint from its dict
# make an entry in resources to point to properties
self.Resources.update({'Properties': self.Properties}) # put Properties into the resource dict
self.Resources.update({'thisObject': self}) #self-identity
# initialize Properties by putting in the constructor properties
self._resourceDescriptor = resourceDescriptor # for settings and properties update
if parentObject == None : #no parent means this is a base object, fill in base settings
self.Resources.update({'baseObject': self})
self.Resources.update({'parentObject': self})
self.Properties.update({'pathFromBase': ''})
self.Properties.update({'resourceName': 'baseObject'})
self.Properties.update({'resourceClass': 'SmartObject'})
else : # fill in properties and identity of parent, base, and path to base
self.Properties.update({'resourceName': resourceDescriptor['resourceName']})
self.Properties.update({'resourceClass': resourceDescriptor['resourceClass']})
self.Resources.update({'parentObject' : parentObject.Resources.get('thisObject')})
self.Resources.update({'baseObject': parentObject.Resources.get('baseObject') })
self.Properties.update({'pathFromBase': self.Resources.get('parentObject').Properties.get('pathFromBase') \
+ '/' + self.Properties.get('resourceName')})
self._parseContentTypes = ['*/*']
self._serializeContentTypes = ['*/*']
self.defaultResources = None
self.resources.update({'l': ResourceList(self)})
def __init__(self, name):
Resource.__init__(self, name)
self._registry = {}
self._resources = {}
return
def __init__(self, name):
Resource.__init__(self, name)
self._registry = {}
self._resources = {}
return
def test_get_brief_summary_output(self):
""" Test get_brief_summary method's output in Resource class"""
# Create a Resource object
resource = Resource(1, "White Noise", Name("Don", "", "DeLillo"),
"Delillo's White Noise follows narrator Jack "\
"Gladney, a professor at a small Liberal Arts "\
"college and describes an academic year. Jack "\
"teaches at a school called the "\
"College-on-the-Hill, where he serves as the "\
"department chair of Hitler studies. He lives in "\
"Blacksmith, a quiet college town, with his wife, "\
"Babette, and four of their children from earlier "\
"marriages: Heinrich, Steffie, Denise, and "\
"Wilder. Throughout the novel, various "\
"half-siblings and ex-spouses drift in and out "\
"of the family’s home.",
"sci-fi", "English", 1985, "US", 326, "book",
["culture", "survival", "life", "society"])
# Assert expected results
self.assertEqual(resource.get_brief_summary(), "Delillo's White "\
"Noise follows narrator Jack Gladney, a professor "\
"at a \nsmall Liberal Arts college and describes an "\
"academic year. Jack teaches \nat ...")
def __init__(self,max_cores=1,name='Cores'):
Resource.__init__(self)
cores = self.manager.BoundedSemaphore(max_cores)
in_service = InService( \
inbox = self.checkinbox ,
cores = cores ,
name = name+'_checkin' ,
)
out_service = OutService( \
inbox = self.checkoutbox ,
cores = cores ,
name = name+'_checkout' ,
)
self.name = name
self.max_cores = max_cores
self.cores = cores
self.in_service = in_service
self.out_service = out_service
self.start()
def resourceSearchTests(pf):
try:
# try out isChild with a non-child resource
p = Resource("eddie", "atype")
c = Resource("franks|schild", "atype|btype")
theVerdict = p.isChild(c)
except PTexception, a:
pf.failed(a.value)
def resourceSearchTests(pf):
try:
# try out isChild with a non-child resource
p = Resource("eddie","atype")
c = Resource("franks|schild","atype|btype")
theVerdict = p.isChild(c)
except PTexception, a:
pf.failed(a.value)
def __init__(self):
Resource.__init__(self)
self._parseContentTypes = []
self._serializeContentTypes = []
self.defaultClass = 'RESTfulResource' # class name, override in derived classes
self.wellKnownClasses = [
'Description', 'Observers', 'PropertyOfInterest', 'SmartObject',
'RESTfulResource', 'Agent'
]
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def add_resource(self, resourceData: Dict):
new_resource = Resource(self.__database_manager.get_next_resource_id(),
resourceData["title"],
resourceData["link"],
author=resourceData["author"],
subject=resourceData["subject"],
resource_type=Resource.Type(
resourceData["type"]),
isbn=resourceData["isbn"])
self.__resource_list.append(new_resource)
self.__database_manager.add_resource(new_resource)
def __notify(self, msg):
if msg != "":
for user in self.user_list:
ret = WeChatHandler().sendMsgViaCust(
msg + Resource.getMsg("ReYes"), "touser", user)
if int(ret) != 0:
print("HealthyNotifier Cust Msg failed..Use preview")
WeChatHandler().sendMsgToOneAsPreview(
msg + Resource.getMsg("ReYes"), "touser", user)
self.user_wait_list.append(user)
threading.Timer(300, self.clear_wait, (user, )).start()
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def set_requests():
"""
:return: request对象数组
"""
requests = []
for i in range(request_time):
vcpu, disk, ram = get_random()
resource = Resource(vcpu, disk, ram)
resource.set_resource(vcpu, disk, ram)
request = Request(None, resource)
requests.append(request)
return requests
def __init__(self, appName="", AVs=None, executions=None):
Resource.__init__(self,appName,"application")
if AVs == None:
self.attributes = []
else:
self.attributes = []
self.addAttributes(AVs)
if executions == None:
self.executions = []
else:
self.executions = []
self.addExecutions(executions)
def get_initial_run_info(resIdx, attrs, eInfo, ptds):
"""Parses the run data file and addes the information to the Execution
object, exe."""
runMachineArg = eInfo.machineName
# expect only one execution resource in resIdx
[exe] = resIdx.findResourcesByType("execution")
(runMachine, runOS, exe, numberOfProcesses, threadsPerProcess) = getInitialAVs(
resIdx, attrs, exe, runMachineArg, ptds
)
envNewName = ptds.getNewResourceName("env")
env = Resource(envNewName, "environment")
resIdx.addResource(env)
if attrs.getCurrent()[0] != "RunDataEnd":
(exe) = getSubmission(resIdx, attrs, exe, ptds)
if attrs.getCurrent()[0] != "RunDataEnd":
(exe) = getFilesystems(resIdx, attrs, exe, ptds)
if attrs.getCurrent()[0] != "RunDataEnd":
(env) = getLibraries(resIdx, attrs, env, exe)
# env.dump(recurse=True)
if attrs.getCurrent()[0] != "RunDataEnd":
(exe) = getInputDecks(resIdx, attrs, exe, ptds)
# expect only one build resource in resIdx
[build] = resIdx.findResourcesByType("build")
# check to see if we figured out how many processes there were
if numberOfProcesses != -1:
# yes, so create resource entries for all processes and threads
i = 0
while i < int(numberOfProcesses):
process = Resource(
exe.name + Resource.resDelim + "Process-" + str(i), "execution" + Resource.resDelim + "process"
)
resIdx.addResource(process)
process.addAttribute("environment", env.name, "resource")
process.addAttribute("build", build.name, "resource")
process.addAttribute("OS name", runOS.name, "resource")
if runMachine:
process.addAttribute("machine name", runMachine.name, "resource")
j = 0
while j < int(threadsPerProcess):
thread = Resource(
process.name + Resource.resDelim + "Thread-" + str(j),
"execution" + Resource.resDelim + "process" + Resource.resDelim + "thread",
)
resIdx.addResource(thread)
j += 1
i += 1
# couldn't figure out number of processes, so link up resources with
# the execution resource
else:
exe.addAttribute("environment", env.name, "resource")
exe.addAttribute("build", build.name, "resource")
exe.addAttribute("OS name", runOS.name, "resource")
if runMachine:
exe.addAttribute("machine name", runMachine.name, "resource")
def dump(self, indent=0, recurse=False):
"""Dump routine for debugging."""
i = indent
ind_str = ""
while i > 0:
ind_str += " "
i -= 1
Resource.dump(self, indent, recurse)
print ind_str + self.name + "'s performanceResults: " \
+ str(len(self.performanceResults))
for p in self.performanceResults:
p.dump(indent + 1, recurse)
def dump(self, indent=0, recurse=False):
"""Dump routine for debugging."""
i = indent
ind_str = ""
while i > 0:
ind_str += " "
i -= 1
Resource.dump(self, indent, recurse)
print ind_str + self.name + "'s performanceResults: " \
+ str(len(self.performanceResults))
for p in self.performanceResults:
p.dump(indent+1, recurse)
def __init__(self, name, settings):
Resource.__init__(self, 'PBXProject', name)
self.organization = 'Pygling'
self.archiveVersion = 1
self.objectVersion = 46
self.objects = Objects(self)
self.targets = ObjectList()
self.configurationList = self.objects.createConfigurationList(
self, settings, 'Debug')
self.mainGroup = self.objects.createGroup()
self.sourcesGroup = self.addGroup('Sources')
self.frameworksGroup = self.addGroup('Frameworks')
self.productsGroup = self.addGroup('Products')
def onUnSub(user_open_ID):
WeChatName = DBHandler().select(
"SELECT WechatName from UserInfo WHERE Open_ID = '%s'" %
user_open_ID)[1][0][0]
if len(WeChatName) > 0:
msg = Resource.getMsg("UnSub") % WeChatName
else:
msg = Resource.getMsg("UnSub") % user_open_ID
ret = WeChatHandler().sendMsgViaCust(msg)
if int(ret) != 0:
print("onUnSub Cust Msg failed..Use preview")
WeChatHandler().sendMsgToOneAsPreview(msg)
return "No Action"
def clear_wait(self, user_open_id):
if user_open_id in self.user_wait_list:
self.user_wait_list.remove(user_open_id)
ret = WeChatHandler().sendMsgViaCust(Resource.getMsg("FiveMins"),
"touser", user_open_id)
if int(ret) != 0:
print("HealthyNotifier Cust Msg failed..Use preview")
WeChatHandler().sendMsgToOneAsPreview(
Resource.getMsg("FiveMins"), "touser", user_open_id)
DBHandler().insert(
"INSERT into HealthyRecord VALUES (null, '%s', 'N', null)" %
user_open_id)
else:
#has record into DB when user reply the correct message
pass
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad=loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def __init__(self, objects, group, type, name, path, configurations,
defaultConfiguration):
Resource.__init__(self, 'PBXNativeTarget', name)
self.objects = objects
self.group = group
self.generated = None
self.product = self.objects.createFileReference(
type, path, 'BUILT_PRODUCTS_DIR')
self.configurationList = self.objects.createConfigurationList(
self, configurations, defaultConfiguration)
self.sourcePhase = self.objects.createSourceBuildPhase(self)
self.frameworkPhase = self.objects.createFrameworkPhase(self)
self.copyFilesPhase = self.objects.createCopyFilesPhase(self)
self.dependencies = ObjectList('PBXTargetDependency')
self.phases = ObjectList('PBXBuildPhases')
def onSub(user_open_ID):
user_dict = WeChatHandler().getUserInfo(user_open_ID)
user_priority = UserHandler.verify_user(user_open_ID)
if user_priority == -1:
user_insert_sql = "INSERT into UserInfo VALUES ('%s', 'N', '%s', null, '%s', null, null, null, '%s', null, " \
"null, null, null)" % (
user_open_ID, user_dict['nickname'], TypeDef.sex_dict[user_dict['sex']],
(user_dict['city'] + ',' + user_dict['province'] + ',' + user_dict[
'country']).replace("\'", "\\\'"))
DBHandler().insert(user_insert_sql)
else:
update_sql = "UPDATE UserInfo SET WechatName = '%s',Sex='%s',Address='%s' WHERE Open_ID = '%s'"\
% (user_dict['nickname'], TypeDef.sex_dict[user_dict['sex']],
(user_dict['city'] + ',' + user_dict['province'] + ',' + user_dict['country']).replace("\'", "\\\'"),
user_open_ID)
DBHandler().update(update_sql)
return_msg = Resource.getMsg("WlcMsg", user_dict['language'])
'''
if user_dict['language'] == "zh_CN":
sql_query = "Select IDX,Media_ID,Title from HistoryArticle"
else:
sql_query = "Select IDX,Media_ID,Title from HistoryArticle WHERE Language = 'en'"
results = DBHandler().select(sql_query)
for line in results[1]:
return_msg = return_msg + str(line[0]) + "..." + line[2] + "\n"
threading.Timer(3, WeChatHandler().sendMsgViaCust,
(Resource.getMsg("Menu", user_dict['language']), "touser", user_open_ID)
).start()
'''
return return_msg
def script_main(argv):
if (len(argv) != 15):
exit(-1)
currency = bool(int(argv[1]))
trade = bool(int(argv[2]))
#Should be -1 if no converging value should be used
converging_value = float(argv[3])
amountOfActors = int(argv[4])
amountOfResources = int(argv[5])
min_init_resources = float(argv[6])
max_init_resources = float(argv[7])
min_init_production = float(argv[8])
max_init_production = float(argv[9])
min_init_amountToSell = float(argv[10])
max_init_amountToSell = float(argv[11])
min_inti_priceDivergence = float(argv[12])
max_inti_priceDivergence = float(argv[13])
days = int(argv[14])
resource = Resource(min_init_resources, max_init_resources,
min_init_production, max_init_production,
amountOfResources, amountOfActors, currency)
society = Society(currency, amountOfActors, resource,
min_init_amountToSell, max_init_amountToSell,
min_inti_priceDivergence, max_inti_priceDivergence,
trade, converging_value)
society.Update(days)
def resourceBasicTests(pf):
print "ResourceBasicTests"
try:
# try giving Resource name=None
app = Resource(None)
except PTexception, a:
pf.passed(a.value)
def test_str(self):
"""
Test that str method returns a string representation of the object.
"""
# Create a Resource object
resource = Resource(1, "White Noise", Name("Don", "", "DeLillo"),
"Delillo's White Noise follows narrator Jack "\
"Gladney, a professor at a small Liberal Arts "\
"college and describes an academic year. Jack "\
"teaches at a school called the "\
"College-on-the-Hill, where he serves as the "\
"department chair of Hitler studies. He lives in "\
"Blacksmith, a quiet college town, with his wife, "\
"Babette, and four of their children from earlier "\
"marriages: Heinrich, Steffie, Denise, and "\
"Wilder. Throughout the novel, various "\
"half-siblings and ex-spouses drift in and out "\
"of the family’s home.",
"sci-fi", "English", 1985, "US", 326, "book",
["culture", "survival", "life", "society"])
# Assert expected result of the str function
self.assertEqual(str(resource), ("ID: 1 \nTitle: White Noise "\
"\nCreator: Don DeLillo \nSummary: Delillo's White Noise follows "\
"narrator Jack Gladney, a professor at a \nsmall Liberal Arts "\
"college and describes an academic year. Jack teaches \nat ... "\
"\nGenre: sci-fi \nLanguage: English \nYear: 1985 "\
"\nCountry: US \nLength: 326p \nType: book "\
"\nKeywords: culture, life, society, survival"))
def check_reply(self, user, msg, isTimer='N'):
reply_msg = ""
if msg != Resource.getMsg("IHappy"):
reply_msg = Resource.getMsg("MustHappy") + Resource.get_random_birth_msg()
ActionsExecutor.add_manual_action(user, Action(self.check_reply, user, "NoHappy"))
else:
reply_msg = Resource.getMsg("AlwaysHappy")
if isTimer == "Y":
ret = WeChatHandler().sendMsgViaCust(reply_msg, "touser", user)
if int(ret) != 0:
print("BirthDayNotifier.get_action timer")
WeChatHandler().sendMsgToOneAsPreview(reply_msg, "touser", user)
self.logger.info("check_reply return %s" % reply_msg)
return reply_msg
def system_init():
processor_temp = Processor()
resource_temp = Resource()
processor_temp.create_process('init', 0)
for x in processor_temp.get_running_list():
print(x + " ", end='')
return processor_temp, resource_temp
def main():
currency = False
trade = False
#Should be -1 if no converging value should be used
converging_value = 10**5
amountOfActors = 10000
amountOfResources = 20
min_init_resources = 0
max_init_resources = 50
min_init_production = -0.2
max_init_production = 0.2
resource = Resource(min_init_resources, max_init_resources,
min_init_production, max_init_production,
amountOfResources, amountOfActors, currency)
min_init_amountToSell = 0
max_init_amountToSell = 1
min_inti_priceDivergence = -0.2
max_inti_priceDivergence = 0.2
society = Society(currency, amountOfActors, resource,
min_init_amountToSell, max_init_amountToSell,
min_inti_priceDivergence, max_inti_priceDivergence,
trade, converging_value)
society.Update(30)
def sub_user_for_weather(user, new_city, lang):
UserHandler.logger.info(
"User <%s> is subscribing the city <%s> weather" %
(user, new_city))
#QUERY
user_sub_result = DBHandler().select(
"SELECT Cities from WeatherSub WHERE Open_ID = '%s'" % user)
content = ""
if len(new_city.split()) == 0 and int(user_sub_result[0]) > 0:
content = Resource.getMsg(
"WeatherHead", lang) + user_sub_result[1][0][
0] #only one cell here, use [0][0] to visit
elif int(user_sub_result[0]) == 0 and len(new_city.split()) == 0:
content = Resource.getMsg("NoSubCity", lang)
#INSERT
elif int(user_sub_result[0]) == 0 and len(new_city.split()) != 0:
weather = WeatherHandler()
ret = weather.getWeather(new_city, lang)
if ret != "Failed":
content = Resource.getMsg("FirstSub", lang) % new_city + ret
# write sub info into db
insert_sql = "INSERT into WeatherSub VALUES ('%s', '%s', NULL)" % (
user, new_city)
DBHandler().insert(insert_sql)
else:
content = Resource.getMsg("WrongCity", lang)
#UPDATE
elif int(user_sub_result[0]) > 0 and len(new_city.split()) != 0:
old_cities = user_sub_result[1][0][0].split()
if len(old_cities) > 5:
content = Resource.getMsg("MAXCityLimit", lang)
elif new_city in old_cities:
content = Resource.getMsg("Subbed", lang) % new_city
else:
weather = WeatherHandler()
ret = weather.getWeather(
new_city,
WeChatHandler().getUserInfo(user)['language'])
if ret != "Failed":
old_cities.append(new_city)
content = Resource.getMsg(
"SubbedMore", lang) % " ".join(old_cities) + ret
update_sql = "UPDATE WeatherSub SET Cities = '%s' WHERE Open_ID = '%s'" % (
" ".join(old_cities), user)
DBHandler().update(update_sql)
else:
content = Resource.getMsg("WrongCity", lang)
else:
content = Resource.getMsg("UnKnownIssue", lang)
return content
def add_resource_with_access_map(resource_name, actions):
''' Add a resource with a dictionary of role names and supported actions '''
if are_valid_roles(actions.keys()) and not is_valid_resource(resource_name) \
and are_valid_actions(itertools.chain.from_iterable(actions.values())):
resources[resource_name] = Resource(resource_name, actions)
return True
else:
return False
def TEST_resource_trading_multiple_trades_with_one():
number_of_resources = 2
number_of_actors = 3
resource = Resource(0, 0, 0, 0, number_of_resources, number_of_actors)
actor1 = 0
actor2 = 1
actor3 = 2
resource1 = 0
resource2 = 1
resource1_amount = 20
resource2_amount = 20
resource23_amount = 10
resource.resourceArray[actor1][0][resource2] = resource1_amount
resource.resourceArray[actor2][0][resource1] = resource2_amount
resource.resourceArray[actor3][0][resource2] = resource23_amount
resource_before = resource.GetTotalResources()
bartermark = Market.NiceMarket(number_of_resources, resource)
bartermark.PostResource(resource1, resource2, 10, 20, actor1)
bartermark.PostResource(resource2, resource1, 40, 20, actor2)
bartermark.PostResource(resource1, resource2, 5, 10, actor3)
bartermark.MatchTrades()
if resource_before == resource.GetTotalResources() and resource.resourceArray[actor2][0][resource2] == 30 and resource.resourceArray[actor2][0][resource1] == 5 and resource.resourceArray[actor1][0][resource2] == 0 and resource.resourceArray[actor1][0][resource1] == 10 and resource.resourceArray[actor3][0][resource2] == 0 and resource.resourceArray[actor3][0][resource1] == 5:
print("TEST_resource_trading_multiple_trades_with_one successful")
else:
print("TEST_resource_trading_multiple_trades_with_one failed")
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def user_check_weather(user, city, lang):
UserHandler.logger.info("User <%s> is checking the city <%s> weather" %
(user, city))
content = ""
ret = WeatherHandler().getWeather(city, lang)
if ret != "Failed":
content = ret
else:
content = Resource.getMsg("WrongCity", lang)
return content
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
assert self.r.load(self, "result2", loader, synch = True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad = loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
# Resource expects game_priority to be an integer,
# Config won't know unless we define it as such.
Config.define("performance", "game_priority", int, 2)
self.e = GameEngine()
def tearDown(self):
self.e.quit()
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad = loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
assert self.r.load(self, "result2", loader, synch = True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad = loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
self.e = Engine()
def tearDown(self):
self.e.quit()
def __str__(self):
symbolstr = ", ".join(["%s" % k for k in sorted(self.getSymbolCardLists().keys())])
secondCollection = ["%s" % k for k, l in sorted(self.getSymbolCardLists().items()) if len(l) > 1]
if secondCollection:
symbolstr += " || " + ", ".join(secondCollection)
multistrs = []
for symbol, cards in self.getMultiplierCardsBySymbol():
factor = sum([c.getMultiplier() for c in cards])
multistrs.append("%d x %s" % (factor, symbol.name))
return """%s%s%s
People: %d, Foodtrack: %d, Food: %d, Tools: %s, One-time tools: %s
Resources: %s
Hutcount: %d
Symbolcards: %s (%d)
Multipliercards: %s (%d)
score (cardscore): %d (%d)\n""" % (self.colorOS, self.color.name, self.colorOSnormal, \
self.getPersonCount(), self.getFoodTrack(), self.resources.count(Resource.food), self.toolbox, self.oneTimeTools,
Resource.coloredOutput(sorted(self.getNonFood())),
len(self.huts), \
symbolstr, self.symbolCardPoints(), \
", ".join(multistrs), self.multiplierCardPoints(),\
self.getScore(), self.getCardScore())
p = Resource("eddie","atype")
c = Resource("franks|schild","atype|btype")
theVerdict = p.isChild(c)
except PTexception, a:
pf.failed(a.value)
except:
pf.failed("non-PTexception when try isChild non-child resource")
else:
if theVerdict == True:
pf.failed("isChild fail with non-child resource")
else:
pf.passed("isChild pass with non-child resource")
try:
# try out isChild
p = Resource("eddie","atype")
c = Resource("eddie","atype")
theVerdict = p.isChild(c)
except PTexception, a:
pf.failed(a.value)
except:
pf.failed("non-PTexception when try isChild same name resource")
else:
if theVerdict == True:
pf.failed("isChild fail same name resource")
else:
pf.passed("isChild pass same name resource")
try:
# try out isChild
p = Resource("eddie","atype")
def __init__(self, config = None):
"""
Constructor.
@param config: L{Config} instance for settings
"""
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
tickrate = self.config.get("engine", "tickrate")
Engine.__init__(self, fps = fps, tickrate = tickrate)
pygame.init()
self.title = _("Frets on Fire")
self.restartRequested = False
self.handlingException = False
self.video = Video(self.title)
self.audio = Audio()
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.pre_open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
pygame.init()
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
Log.debug("Initializing video.")
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
# Enable the high priority timer if configured
if self.config.get("engine", "highpriority"):
Log.debug("Enabling high priority timer.")
self.timer.highPriority = True
viewport = glGetIntegerv(GL_VIEWPORT)
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.img = ImgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.server = None
self.sessions = []
self.mainloop = self.loading
# Load game modifications
Mod.init(self)
theme = Config.load(self.resource.fileName("theme.ini"))
Theme.open(theme)
# Make sure we are using the new upload URL
if self.config.get("game", "uploadurl").startswith("http://kempele.fi"):
self.config.set("game", "uploadurl", "http://fretsonfire.sourceforge.net/play")
self.addTask(self.audio, synchronized = False)
self.addTask(self.input, synchronized = False)
self.addTask(self.view)
self.addTask(self.resource, synchronized = False)
self.data = Data(self.resource, self.img)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
Log.debug("Ready.")
class GameEngine(Engine):
"""The main game engine."""
def __init__(self, config = None):
"""
Constructor.
@param config: L{Config} instance for settings
"""
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
tickrate = self.config.get("engine", "tickrate")
Engine.__init__(self, fps = fps, tickrate = tickrate)
pygame.init()
self.title = _("Frets on Fire")
self.restartRequested = False
self.handlingException = False
self.video = Video(self.title)
self.audio = Audio()
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.pre_open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
pygame.init()
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
Log.debug("Initializing video.")
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
# Enable the high priority timer if configured
if self.config.get("engine", "highpriority"):
Log.debug("Enabling high priority timer.")
self.timer.highPriority = True
viewport = glGetIntegerv(GL_VIEWPORT)
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.img = ImgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.server = None
self.sessions = []
self.mainloop = self.loading
# Load game modifications
Mod.init(self)
theme = Config.load(self.resource.fileName("theme.ini"))
Theme.open(theme)
# Make sure we are using the new upload URL
if self.config.get("game", "uploadurl").startswith("http://kempele.fi"):
self.config.set("game", "uploadurl", "http://fretsonfire.sourceforge.net/play")
self.addTask(self.audio, synchronized = False)
self.addTask(self.input, synchronized = False)
self.addTask(self.view)
self.addTask(self.resource, synchronized = False)
self.data = Data(self.resource, self.img)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
Log.debug("Ready.")
def setStartupLayer(self, startupLayer):
"""
Set the L{Layer} that will be shown when the all
the resources have been loaded. See L{Data}
@param startupLayer: Startup L{Layer}
"""
self.startupLayer = startupLayer
def isDebugModeEnabled(self):
return bool(self.debugLayer)
def setDebugModeEnabled(self, enabled):
"""
Show or hide the debug layer.
@type enabled: bool
"""
if enabled:
self.debugLayer = DebugLayer(self)
else:
self.debugLayer = None
def toggleFullscreen(self):
"""
Toggle between fullscreen and windowed mode.
@return: True on success
"""
if not self.video.toggleFullscreen():
# on windows, the fullscreen toggle kills our textures, se we must restart the whole game
self.input.broadcastSystemEvent("restartRequested")
self.config.set("video", "fullscreen", not self.video.fullscreen)
return True
self.config.set("video", "fullscreen", self.video.fullscreen)
return True
def restart(self):
"""Restart the game."""
if not self.restartRequested:
self.restartRequested = True
self.input.broadcastSystemEvent("restartRequested")
else:
# evilynux - With self.audio.close(), calling self.quit() results in
# a crash. Calling the parent directly as a workaround.
Engine.quit(self)
def quit(self):
self.audio.close()
Engine.quit(self)
def resizeScreen(self, width, height):
"""
Resize the game screen.
@param width: New width in pixels
@param height: New height in pixels
"""
self.view.setGeometry((0, 0, width, height))
self.img.setGeometry((0, 0, width, height))
def isServerRunning(self):
return bool(self.server)
def startServer(self):
"""Start the game server."""
if not self.server:
Log.debug("Starting server.")
self.server = Server(self)
self.addTask(self.server, synchronized = False)
def connect(self, host):
"""
Connect to a game server.
@param host: Name of host to connect to
@return: L{Session} connected to remote server
"""
Log.debug("Connecting to host %s." % host)
session = ClientSession(self)
session.connect(host)
self.addTask(session, synchronized = False)
self.sessions.append(session)
return session
def stopServer(self):
"""Stop the game server."""
if self.server:
Log.debug("Stopping server.")
self.removeTask(self.server)
self.server = None
def disconnect(self, session):
"""
Disconnect a L{Session}
param session: L{Session} to disconnect
"""
if session in self.sessions:
Log.debug("Disconnecting.")
self.removeTask(session)
self.sessions.remove(session)
def loadImgDrawing(self, target, name, fileName, textureSize = None):
"""
Load an SVG drawing synchronously.
@param target: An object that will own the drawing
@param name: The name of the attribute the drawing will be assigned to
@param fileName: The name of the file in the data directory
@param textureSize Either None or (x, y), in which case the file will
be rendered to an x by y texture
@return: L{ImgDrawing} instance
"""
return self.data.loadImgDrawing(target, name, fileName, textureSize)
def loading(self):
"""Loading state loop."""
done = Engine.run(self)
self.clearScreen()
if self.data.essentialResourcesLoaded():
if not self.loadingScreenShown:
self.loadingScreenShown = True
Dialogs.showLoadingScreen(self, self.data.resourcesLoaded)
if self.startupLayer:
self.view.pushLayer(self.startupLayer)
self.mainloop = self.main
self.view.render()
self.video.flip()
return done
def clearScreen(self):
self.img.clear(*Theme.backgroundColor)
def main(self):
"""Main state loop."""
# Tune the scheduler priority so that transitions are as smooth as possible
if self.view.isTransitionInProgress():
self.boostBackgroundThreads(False)
else:
self.boostBackgroundThreads(True)
done = Engine.run(self)
self.clearScreen()
self.view.render()
if self.debugLayer:
self.debugLayer.render(1.0, True)
self.video.flip()
return done
def run(self):
try:
return self.mainloop()
except KeyboardInterrupt:
sys.exit(0)
except SystemExit:
sys.exit(0)
except Exception, e:
def clearMatrixStack(stack):
try:
glMatrixMode(stack)
for i in range(16):
glPopMatrix()
except:
pass
if self.handlingException:
# A recursive exception is fatal as we can't reliably reset the GL state
sys.exit(1)
self.handlingException = True
Log.error("%s: %s" % (e.__class__, e))
import traceback
traceback.print_exc()
clearMatrixStack(GL_PROJECTION)
clearMatrixStack(GL_MODELVIEW)
Dialogs.showMessage(self, unicode(e))
self.handlingException = False
return True
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
assert self.r.load(self, "result2", loader, synch = True) == 0xdada
assert self.result2 == 0xdada
def run(self):
try:
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
if len(self.file_list) == 0:
resources = Resource.find_all_in_paths(self.paths)
else:
resources = []
for file_path in self.file_list:
resources.append(Resource(file_path))
if resources is not None:
for resource in resources:
if resource.requirements is not None:
directory, file_name = os.path.split(resource.path_to_file)
try:
chunks = resource.get_chunks_by_merging_requirements_from_paths(self.paths, previously_merged=[])
except RequirementNotSatisfiedException, rnse:
print "A requirement could not be satisfied for %s\n\n%s\n" % (resource.path_to_file, rnse)
return -1
for chunk in chunks:
analyzers = self.config.get_analyzers_for_resource(chunk.resource)
if analyzers:
for analyzer in analyzers:
print 'Analysis:%s:%s' % (analyzer.__class__, chunk.resource.path_to_file)
analysis = analyzer.analyze(chunk.resource)
print analysis
if not analysis.good:
return -1
merged_content = ''.join([chunk.content for chunk in chunks])
output_file_name = os.path.join(self.output_dir, file_name)
f = open(output_file_name, 'w')
try:
f.write(merged_content)
finally:
f.flush()
f.close()
print "Created %s" % output_file_name
# TODO: Process chunks to prevent reminification
output_resource = Resource(output_file_name)
minifier = self.config.get_minifier_for_file_type(output_resource.file_type)
if minifier and not output_resource.minified:
minification = minifier.minify(output_resource)
if not minification.good:
print minification
return -1
minified_output_file_path = os.path.join(self.output_dir, output_resource.minified_file_name)
f = open(minified_output_file_path, 'w')
try:
f.write(minification.content)
finally:
f.flush()
f.close()
except Exception:
traceback.print_exc(file=sys.stderr)
return -1
return 0
class GameEngine(object):
"""The main game engine."""
def __init__(self, config = None):
"""
Constructor.
@param config: L{Config} instance for settings
"""
if not config:
config = Config.load()
self.config = config
self.fps = self.config.get("video", "fps")
pygame.init()
self.title = _("Frets on Fire")
self.restartRequested = False
self.handlingException = False
self.video = Video(self.title)
self.audio = Audio()
log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.pre_open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
pygame.init()
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
log.debug("Initializing video.")
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
viewport = glGetIntegerv(GL_VIEWPORT)
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.img = ImgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.server = None
self.mainloop = self.loading
# Load game modifications
Mod.init(self)
theme = Config.load(self.resource.fileName("theme.ini"))
Theme.open(theme)
# Make sure we are using the new upload URL
if self.config.get("game", "uploadurl").startswith("http://kempele.fi"):
self.config.set("game", "uploadurl", "http://fretsonfire.sourceforge.net/play")
self.running = True
self.timer = FpsTimer()
self.tickDelta = 0
self.task = TaskEngine(self)
self.task.addTask(self.input, synced = False)
self.task.addTask(self.view)
self.task.addTask(self.resource, synced = False)
self.data = Data(self.resource, self.img)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
log.debug("Ready.")
def enableGarbageCollection(self, enabled):
"""
Enable or disable garbage collection whenever a random garbage
collection run would be undesirable. Disabling the garbage collector
has the unfortunate side-effect that your memory usage will skyrocket.
"""
if enabled:
gc.enable()
else:
gc.disable()
def collectGarbage(self):
"""
Run a garbage collection run.
"""
gc.collect()
def setStartupLayer(self, startupLayer):
"""
Set the L{Layer} that will be shown when the all
the resources have been loaded. See L{Data}
@param startupLayer: Startup L{Layer}
"""
self.startupLayer = startupLayer
def isDebugModeEnabled(self):
return bool(self.debugLayer)
def setDebugModeEnabled(self, enabled):
"""
Show or hide the debug layer.
@type enabled: bool
"""
if enabled:
self.debugLayer = DebugLayer(self)
else:
self.debugLayer = None
def toggleFullscreen(self):
"""
Toggle between fullscreen and windowed mode.
@return: True on success
"""
if not self.video.toggleFullscreen():
# on windows, the fullscreen toggle kills our textures, se we must restart the whole game
self.input.broadcastSystemEvent("restartRequested")
self.config.set("video", "fullscreen", not self.video.fullscreen)
return True
self.config.set("video", "fullscreen", self.video.fullscreen)
return True
def restart(self):
"""Restart the game."""
if not self.restartRequested:
self.restartRequested = True
self.input.broadcastSystemEvent("restartRequested")
else:
self.quit()
def quit(self):
self.audio.close()
self.task.exit()
self.running = False
def resizeScreen(self, width, height):
"""
Resize the game screen.
@param width: New width in pixels
@param height: New height in pixels
"""
self.view.setGeometry((0, 0, width, height))
self.img.setGeometry((0, 0, width, height))
def startWorld(self):
self.world = World(self)
def finishGame(self):
self.world.finishGame()
self.world = None
self.view.pushLayer(MainMenu.MainMenu(self))
def loadImgDrawing(self, target, name, fileName, textureSize = None):
"""
Load an SVG drawing synchronously.
@param target: An object that will own the drawing
@param name: The name of the attribute the drawing will be assigned to
@param fileName: The name of the file in the data directory
@param textureSize Either None or (x, y), in which case the file will
be rendered to an x by y texture
@return: L{ImgDrawing} instance
"""
return self.data.loadImgDrawing(target, name, fileName, textureSize)
def loading(self):
"""Loading state loop."""
if self.data.essentialResourcesLoaded():
if not self.loadingScreenShown:
self.loadingScreenShown = True
Dialogs.showLoadingScreen(self, self.data.resourcesLoaded)
if self.startupLayer:
self.view.pushLayer(self.startupLayer)
self.mainloop = self.main
self.view.render()
def clearScreen(self):
self.img.clear(*Theme.backgroundColor)
def main(self):
"""Main state loop."""
self.view.render()
if self.debugLayer:
self.debugLayer.render(1.0, True)
def run(self):
try:
self.tickDelta = self.timer.tick()
done = self.task.run()
self.clearScreen()
self.mainloop()
self.video.flip()
# Calculate FPS every 2 seconds
if self.timer.fpsTime >= 2000:
self.fpsEstimate = self.timer.get_fps()
print ("%.2f fps" % self.fpsEstimate)
self.timer.delay(self.fps)
return done
except KeyboardInterrupt:
sys.exit(0)
except SystemExit:
sys.exit(0)
except Exception, e:
def clearMatrixStack(stack):
try:
glMatrixMode(stack)
for i in range(16):
glPopMatrix()
except:
pass
if self.handlingException:
# A recursive exception is fatal as we can't reliably reset the GL state
sys.exit(1)
self.handlingException = True
log.error("%s: %s" % (e.__class__, e))
import traceback
traceback.print_exc()
clearMatrixStack(GL_PROJECTION)
clearMatrixStack(GL_MODELVIEW)
Dialogs.showMessage(self, unicode(e))
self.handlingException = False
return True
def getInitialAVs(resIdx, attrs, exeName, ptds):
""" Takes attrs, which is a list of name, value pairs, and builds
a build Resource object and Execution object
"""
executableAVs = []
buildAVs = []
buildOSAVs = []
AppName = ""
BuildMachType = ""
BuildMachine = ""
BuildOSName = ""
BuildOSVersion = ""
BuildOSType = ""
# regular expressions for parsing
for name, value, type in attrs:
if name == "BuildDataBegin":
pass
elif name == "BuildDataEnd":
break
# Get executable specific data
elif name == "ApplicationName":
AppName = value
elif name == "ApplicationExeTrialName" or name == "ApplicationExeUserComment":
AppTrialName = value
elif name.startswith("Application"):
if name == "ApplicationLanguages":
value = fixListFormat(value)
executableAVs.append(("Languages", value, "string"))
elif name == "ApplicationParadigms":
value = fixListFormat(value)
executableAVs.append(("Concurrency", value, "string"))
elif name == "ApplicationExeName":
executableAVs.append(("Executable Name", value, "string"))
elif name == "ApplicationExeSize":
executableAVs.append(("Executable Size", value, "string"))
elif name == "ApplicationExePerms":
executableAVs.append(("Executable Permissions", value, "string"))
elif name == "ApplicationExeUID":
executableAVs.append(("Executable UID", value, "string"))
elif name == "ApplicationExeGID":
executableAVs.append(("Executable GID", value, "string"))
elif name == "ApplicationExeTimestamp":
executableAVs.append(("Executable Timestamp", value, "string"))
elif name == "ApplicationExeUsername":
executableAVs.append(("Username", value, "string"))
# get Build specific data
elif name.startswith("Build") and not (name.find("BuildOS") >= 0):
if name == "BuildEnv":
BuildEnv = [] # a list of attr value pairs
# where attr = "BuildEnv"+ (enviroment variable name)
# and value is the environment variable's value
# e.g. for PATH=/usr/bin:/usr/local/bin
# attr = BuildEnvPATH
# value = /usr/bin:/usr/local/bin
BuildEnv = StringToList("Env_", "@@@", value)
for (n, v) in BuildEnv:
if v != "":
buildAVs.append((n, v, "string"))
else:
if name == "BuildNode" or name == "BuildMachine":
BuildMachine = value
if name == "BuildNode":
BuildMachType = "node"
buildAVs.append(("Node Name", value, "string"))
elif name == "BuildMachine":
BuildMachType = "machine"
buildAVs.append(("Machine Name", value, "string"))
if name == "BuildDateTime":
buildAVs.append(("DateTime", value, "string"))
# get Build operating system specific data
elif name.startswith("BuildOS"):
if name == "BuildOSName":
BuildOSName = value
elif name == "BuildOSReleaseVersion":
BuildOSVersion = value
elif name == "BuildOSReleaseType":
BuildOSType = value
if exeName == "" or exeName == None:
raise PTexception("missing execution name in Build.getInitialAVs")
exeNewName = ptds.getNewResourceName(exeName)
# ATTR CHANGE TODO
# executableAVs should be attrs of build, not execution
exe = Execution(exeNewName, executableAVs)
resIdx.addResource(exe)
newBuildName = ptds.getNewResourceName("build")
build = Resource(newBuildName, "build", buildAVs)
resIdx.addResource(build)
if BuildMachine == "" or BuildMachine == None:
raise PTexception("missing build machine name in build data file for " " execution:%s" % exeName)
if BuildMachType == "node":
fullname, type = getMachineName(ptds, BuildMachine, BuildMachType)
# print fullname
buildMachine = Resource(fullname, type)
else: # machine
fullname, type = getMachineName(ptds, BuildMachine, BuildMachType)
buildMachine = Resource(fullname, type)
if BuildOSName == "" or BuildOSName == None:
raise PTexception("missing build operating system name for execution" "execution:%s" % exeName)
if BuildOSVersion == "" or BuildOSVersion == None or BuildOSType == "" or BuildOSType == None:
raise PTexception("missing build operating system details for execution" "execution:%s" % exeName)
buildOSNewName = ptds.getNewResourceName(BuildOSName + " " + BuildOSVersion + " " + BuildOSType)
buildOS = Resource(buildOSNewName, "operatingSystem", buildOSAVs)
resIdx.addResources([buildOS, buildMachine])
build.addAttribute("Node Name", buildMachine.name, "resource")
build.addAttribute("OS Name", buildOS.name, "resource")
return (build, exe)
def testPureResource(self):
rs = Resource()
rs.addPerson(1, "r")
with self.assertRaisesRegex(AttributeError, "object has no attribute 'resourceValue'"):
rs.reapResources(self.redPlayer)
# -*- coding: UTF-8 -*-
import simplejson
from Resource import Resource
datacloud = Resource('A6988846915732','391BB7B7-827D-1DE5-2F64-04339E801812','http://192.168.13.183/mcm/api')
#################user operation##############################
# print datacloud.createUser({"username":"******","password":"******","email":"*****@*****.**"})
r = datacloud.userLogin('zxh','123456')
datacloud.setSessionToken(r["id"])
# print datacloud.userLogout(r["id"])
# r = datacloud.verifyEmail({"username":"******","email":"*****@*****.**","language":"zh_CN"})
# print simplejson.dumps(r, ensure_ascii=False)
# print r['msg']
# print r['status']
# print datacloud.resetRequest({"username":"******","email":"*****@*****.**","language":"zh_CN"})
# print datacloud.getUserInfo('5576b9eec24a9b3c54f82203');
# print datacloud.updateUserInfo({'userId':'55796f23dfc407df41432f94','address':'dandong'})
# print datacloud.deleteUser('55796f23dfc407df41432f94');
#################object operation##############################
# print datacloud.createObject("company",{"address":"丹东1", "name":"aaa","icon":{"isFile":True,"path":"E:\\2007119124513598_2.jpg"},"icon2":{"isFile":True,"path":"E:\\2007119124513598_2.jpg"}})
# print datacloud.createObject("company",{"address":"germany", "name":"ccc","icon":{"url":"http://a82510f6efdff35a65fb.b0.upaiyun.com/apicloud/e96e53bb577560b2d5acb1e3ef7a492b.jpg","id":"5578114b85ff91bf364f0d6a","name":"2007119124513598_2.jpg"}})
# print datacloud.getObject('company','55828f4c291f49171a8dba9b')
# print datacloud.updateObject('company','5578125185ff91bf364f0d6c',{'address':'dandong',"icon":{"isFile":True,"path":"E:\\zhanqi.PNG"}})
def chooseResourecestoPay(self, nonFoodResources, hut):
promptString = "\nchoose resources (format='wcsgj...') to pay the hut: %s\n available resources: %s " % (str(hut),
Resource.coloredOutput(nonFoodResources))
finished = False
while not finished:
chosenResources = fetchConvertedInput(promptString,
lambda v: printfString("the input '%s' does not consist of only numbers!", v),
mapToResources,
self.printPlayersFunc)
if not chosenResources:
chosenResources = nonFoodResources
finished = all([self.chosenItemsAvailable(nonFoodResources, chosenResources),
self.validPaymentIfAnyHut(hut, chosenResources),
self.validPaymentIfCountHut(hut, chosenResources)])
return chosenResources
def filterOutPayableHuts(self, player, huts):
notPayable, payable = [hut for hut in huts if not player.isPayable(hut)], [hut for hut in huts if player.isPayable(hut)]
if notPayable:
printError("with available resources: %s\nyou can't afford the following hut%s: " % (Resource.coloredOutput(player.getNonFood()) , suffix(notPayable)), " ".join([str(hut) for hut in notPayable]))
return payable
def wantsToBuy(self, outstring, nonFoodResources, hutOrCard):
return fetchConvertedInput("with available resources: %s\ndo you want to buy this %s (y|n): %s ? (y) " % (Resource.coloredOutput(nonFoodResources),outstring, str(hutOrCard)),
lambda v: printfString("please answer y(es) or n(o) - not: '%s'", v),
yesNo,
self.printPlayersFunc)
Program begins.
"""
# Total visited links
visited = []
# Total working links found
urls = []
resources = []
# Create excel file
# wb = Workbook()
# filename = input("Enter a title for the excel file: ")
url = input("Enter url to crawl: ")
resource = Resource(url)
resource.get_resource_data()
resource_values = {
"title": resource.title,
"url": resource.link,
"link status": resource.status,
"resource types": resource.resource_type,
"disciplines": resource.themes,
"organization": resource.get_org(),
"organization validated in VIAF": resource.org.validated,
"VIAF uri": resource.org.uri,
"contact organization": resource.resource_contact_org,
"contact name": resource.resource_contact_person_name,
"contact email": resource.resource_contact_email,
"contact phone": resource.resource_contact_phone,
}
def printResourceStatus(self, player):
nonFood = player.getNonFood()
print("available Resource%s: %s " % (suffix(nonFood), Resource.coloredOutput(nonFood)))
def fetchPlacePersonsInput(self, people, foodtrack, food, resources, personsLeft):
return fetchConvertedInput(self.prompt % (people, foodtrack, food, suffix(resources), Resource.coloredOutput(resources), personsLeft, suffix(personsLeft), suffix(personsLeft)),
lambda v: printfString("'%s' does not seem to be of format <Resource><number>!", v),
stringAndNumber,
self.printPlayersFunc)
Program begins.
"""
# Total visited links
visited = []
# Total working links found
urls = []
resources = []
# Create excel file
# wb = Workbook()
# filename = input("Enter a title for the excel file: ")
url = input("Enter url to crawl: ")
resource = Resource(url)
resource.get_resource_data()
resource_values = {'title': resource.title, 'url': resource.link, 'link status': resource.status,
#'resource types': resource.resource_type, 'disciplines': resource.themes,
'organization': resource.get_org(), 'organization validated in VIAF': resource.org.validated,
'VIAF uri': resource.org.uri, 'contact organization': resource.resource_contact_org,
'contact name': resource.resource_contact_person_name,
'contact email': resource.resource_contact_email, 'contact phone': resource.resource_contact_phone}
fieldnames = ['title', 'url', 'link status', 'resource types', 'disciplines', 'organization',
'organization validated in VIAF', 'VIAF uri', 'contact organization', 'contact name', 'contact email',
'contact phone']
with open('{}.csv'.format(resource.title.replace("|", "").strip().replace(" ", "_")), 'w') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
def doBuyCards(self, player, cards, boughtCards, players, cardPile):
for card in cards:
if len(player.getNonFood()) < card[1]:
print("with available resources: %s you can't afford the following card:\nprice %d%s\n " % (Resource.coloredOutput(player.getNonFood()), card[1], str(card[0])))
elif self.wantsToBuy("card", player.getNonFood(), card[0]):
player.buyCard(card[0], players, cardPile, player.getNonFood()[:card[1]])
boughtCards.append(card[0])
return boughtCards
