def buildassignees(assignee):
return {
'name': maybe(assignee).find('snm').text.or_else(''),
'epo-number': maybe(assignee).find('iid').text.or_else(''),
'reference': maybe(assignee).find('irf').text.or_else(''),
'cross-reference': maybe(assignee).find('syn').text.or_else('')
}
def buildcitations(patcit):
return {
'dnum': patcit.attrib.get('dnum', ''),
'country': maybe(patcit).find('document-id').find('country').text.or_else(''),
'doc-number': maybe(patcit).find('document-id').find('doc-number').text.or_else(''),
'kind': maybe(patcit).find('document-id').find('kind').text.or_else('')
}
def text(self, group1, group2, constant):
result = self.compare(group1, group2, constant)
template = "%6.1f and %6.1f differ by %s than %s"
group1 = maybe(group1).or_else(0)
group2 = maybe(group2).or_else(0)
return template % (group1, group2, "less" if result else "more",
constant)
def compare(self, group1, group2, constant=100.0):
old_value = maybe(group1).or_else(0)
new_value = maybe(group2).or_else(0)
if (new_value + old_value) == 0:
return False
total = new_value + old_value
adjusted_total = (constant / 100.0) * total
return group1 >= adjusted_total
def calculate_percentage_variance(old_value, new_value):
old_value = maybe(old_value).or_else(0)
new_value = maybe(new_value).or_else(0)
if new_value > old_value:
temp = new_value
new_value = old_value
old_value = temp
return abs(((float(new_value) - float(old_value)) / old_value) * 100.0)
def text(self, group1, group2, constant):
result = self.compare(group1, group2, constant)
new_value = maybe(group2).or_else(0)
total = maybe(group1).or_else(0) + new_value
if total == 0:
return "denominator value is zero so the check fails"
template = "%s is %s than %s%% of %s"
return template % (group1, "more" if result else "less", constant,
total)
def rightblink3(self):
# Let's save the current stage to local values
# Then blink the left red and leave the right red on
# Maybe just blink 3 times then put things back how
# they were?
self.saveValues()
self.bothred()
maybe(self.rightred).blink(0.5, 0.5, 3, False)
self.loadValues()
def use(item):
obj = globalvars.save_data.player.find(item)
if not obj:
print(f'You do not have a {item}.')
elif maybe(obj).use == True:
respond(obj, 'use_succ', f'You use the {obj}.')
if maybe(obj).single_use == True:
globalvars.save_data.player.take(item)
else:
respond(obj, 'use_fail', f'You cannot use a {obj} now.')
def parties(bibliographic):
party = bibliographic.find('{http://www.epo.org/exchange}parties')
applicants = maybe(party).findall(
'{http://www.epo.org/exchange}applicants').or_else([])
inventors = maybe(party).findall(
'{http://www.epo.org/exchange}inventors').or_else([])
return {
'applicants': partyapplicants(applicants),
'inventors': partyinventors(inventors)
}
def publication_reference(reference):
return {
'country':
maybe(reference).find('document-id').find('country').text.or_else(''),
'doc-number':
maybe(reference).find('document-id').find('doc-number').text.or_else(
''),
'kind':
maybe(reference).find('document-id').find('kind').text.or_else(''),
'date':
maybe(reference).find('document-id').find('date').text.or_else('')
}
def application_reference(reference):
return {
'appl-type':
reference.attrib.get('appl-type', ''),
'country':
maybe(reference).find('document-id').find('country').text.or_else(''),
'doc-number':
maybe(reference).find('document-id').find('doc-number').text.or_else(
''),
'date':
maybe(reference).find('document-id').find('date').text.or_else(''),
}
def test_something_cmp(self):
if PY2:
n = Nothing()
s = maybe(5)
s1 = maybe(7)
self.assertEqual(1, cmp(s, n))
self.assertEqual(cmp(5, 5), cmp(s, s))
self.assertEqual(cmp(5, 7), cmp(s, s1))
self.assertEqual(cmp(7, 5), cmp(s1, s))
self.assertEqual(cmp(5, 5), cmp(s, 5))
self.assertEqual(cmp(5, 7), cmp(s, 7))
self.assertEqual(cmp(7, 5), cmp(7, s))
def compare(self, group1, group2, constant=100.0):
old_value = maybe(group1).or_else(0)
new_value = maybe(group2).or_else(0)
if new_value > old_value:
temp = new_value
new_value = old_value
old_value = temp
if old_value == 0:
if new_value == 0:
return True
return False
percentage_variance = calculate_percentage_variance(group1, group2)
return percentage_variance <= constant
def test_something_cmp(self):
if PY2:
n = Nothing()
s = maybe(5)
s1 = maybe(7)
self.assertEqual(1, cmp(s, n))
self.assertEqual(cmp(5, 5), cmp(s, s))
self.assertEqual(cmp(5, 7), cmp(s, s1))
self.assertEqual(cmp(7, 5), cmp(s1, s))
self.assertEqual(cmp(5, 5), cmp(s, 5))
self.assertEqual(cmp(5, 7), cmp(s, 7))
self.assertEqual(cmp(7, 5), cmp(7, s))
def update_status():
globalvars.save_data.nutrition -= 1
globalvars.save_data.hydration -= 1
if maybe(globalvars.save_data).nutrition == 1:
printSlowColor(Fore.RED + "Blood sugar levels are dangerously low." +
Fore.RESET)
if maybe(globalvars.save_data).hyrdration == 1:
printSlowColor(Fore.RED + "H2O content of blood is dangerously low." +
Fore.RESET)
if globalvars.save_data.nutrition < 1:
Death("starve", None)
elif globalvars.save_data.hydration < 1:
Death("thirst", None)
def buildcitation(patcit):
return {
'country':
maybe(patcit).find('document-id').find('country').text.or_else(''),
'doc-number':
maybe(patcit).find('document-id').find('doc-number').text.or_else(''),
'kind':
maybe(patcit).find('document-id').find('kind').text.or_else(''),
'name':
maybe(patcit).find('document-id').find('name').text.or_else(''),
'date':
maybe(patcit).find('document-id').find('date').text.or_else('')
}
def test_something_typeConversions(self):
import math
self.assertEqual(complex(1), complex(Something(1)))
self.assertEqual(oct(1), oct(Something(1)))
self.assertEqual(hex(16), hex(Something(16)))
self.assertEqual(math.trunc(math.pi), math.trunc(maybe(math.pi)))
def useon(item, target):
obj = globalvars.save_data.player.find(item)
tarobj = globalvars.save_data.current_room.items.find(target)
if not obj:
print(f'You do not have a {item}.')
elif tarobj.is_none:
print(f'There is no {target} to use the {obj} on')
elif maybe(obj).use_on.is_some and tarobj.name in obj.use_on:
respond(obj, f'use_succ_{target}',
f'You use the {obj} on the {tarobj}')
if maybe(obj).single_use == True:
globalvars.save_data.player.take(item)
#TODO make it so that the item actualy gets used on the target
else:
respond(obj, f'use_fail_{tarobj}',
f'You can\'t use the {obj} on the {tarobj}')
def to_database(metadata):
"""Callback to Neo4j
"""
print('------------------------------------------------')
pprint(metadata)
doc_number = metadata['doc-number']
kind = metadata['kind']
date_publ = metadata['date-publ']
status = metadata['status']
country = metadata['country']
title = metadata['title'][0].get('title',
'') if len(metadata['title']) > 0 else ''
family_id = metadata['family-id']
family_members = metadata['family-members']
citations = metadata['citations']
classifications = metadata['classifications']
assignees = metadata['parties'].get('applicants', [])
DataImport.create_document('Bibliographic', '?', '', doc_number, kind,
date_publ, status, country, title, '', '', '',
'')
for citation in citations:
DataImport.add_citation(doc_number, citation.get('doc-number', ''),
citation.get('country', ''),
citation.get('kind', ''), date_publ, '', '',
'')
for classification in classifications:
DataImport.add_classification(doc_number,
classification.get('section', ''),
classification.get('class', ''),
classification.get('subclass', ''),
classification.get('main-group', ''),
classification.get('subgroup', ''),
date_publ, '', '', '')
for assignee in assignees:
DataImport.add_assignee(doc_number,
maybe(assignee)['docdb']['name'].or_else(''),
'', '', '', date_publ, '', '', '')
for member in family_members:
application = member['application-references']['docdb']
DataImport.add_family_member('FamilyApplication', family_id,
application['doc-number'],
application['country'],
application['kind'],
application['is-representative'])
publication = member['publication-references']['docdb']
for sequence, document in publication.items():
DataImport.add_family_member('FamilyPublication', family_id,
document['doc-number'],
application['country'],
application['kind'])
print('------------------------------------------------')
print('\n')
def test_something_getItem_returnsNothing(self):
s = maybe(dict(test='value'))
self.assertTrue(isinstance(s['test'], Something))
self.assertTrue(s['test'].is_some())
self.assertTrue(isinstance(s['test1'], Nothing))
self.assertTrue(s['test1'].is_none())
def _serialize(self, value: adventurelib.Item, attr, obj, **kwargs):
if hasattr(value, "name"):
return str(value.name)
name = maybe(value)['name']
if name is None:
self.fail("badobj")
return str(name)
def test_something_iter_onNotIterable_returnsArrayIterator(self):
class Foo(object):
pass
obj = Foo()
l = list(iter(maybe(obj)))
self.assertEqual(l, [obj])
def test_something_reversed(self):
l = maybe([1, 2, 3])
lr = list(reversed(l))
self.assertEqual(lr[0], 3)
self.assertEqual(lr[1], 2)
self.assertEqual(lr[2], 1)
def test_something_reversed(self):
l = maybe([1, 2, 3])
lr = list(reversed(l))
self.assertEqual(lr[0], 3)
self.assertEqual(lr[1], 2)
self.assertEqual(lr[2], 1)
def quantize(begin, end, subdiv, breakouts):
lapse = Lapse(begin, timedelta(hours=1) / subdiv)
results = []
iterator = iter(breakouts)
repeat = 0
try:
breakout = next(iterator)
while lapse.precedes(end):
if lapse.precedes(breakout.start_at):
repeat = 0
results.append((lapse.start_at, Nothing(), repeat))
elif breakout.lapse.contains(lapse):
results.append((lapse.start_at, maybe(breakout), repeat))
repeat += 1
else:
repeat = 0
breakout = next(iterator)
continue
lapse.increment()
except StopIteration:
while lapse.precedes(end):
results.append((lapse.start_at, Nothing(), repeat))
lapse.increment()
finally:
return results
def extract_year(year):
if not year.text:
return None
# Extract the first year found, if any
year = maybe(re.search('\d+', year.text)).group()
return int(year) if year else None
def test_something_iter_onNotIterable_returnsArrayIterator(self):
class Foo(object):
pass
obj = Foo()
l = list(iter(maybe(obj)))
self.assertEqual(l, [obj])
def test_something_typeConversions(self):
import math
self.assertEqual(complex(1), complex(Something(1)))
self.assertEqual(oct(1), oct(Something(1)))
self.assertEqual(hex(16), hex(Something(16)))
self.assertEqual(math.trunc(math.pi), math.trunc(maybe(math.pi)))
def test_something_getItem_returnsNothing(self):
s = maybe(dict(test='value'))
self.assertTrue(isinstance(s['test'], Something))
self.assertTrue(s['test'].is_some())
self.assertTrue(isinstance(s['test1'], Nothing))
self.assertTrue(s['test1'].is_none())
def buildassignees(assignee):
if assignee.find('addressbook') is not None:
return {
'orgname':
maybe(assignee).find('addressbook').find('orgname').text.or_else(
''),
'role':
maybe(assignee).find('addressbook').find('role').text.or_else(''),
'address':
buildassigneeaddress(assignee.find('addressbook').find('address'))
if assignee.find('addressbook').find('address') is not None else ''
}
else:
return {
'orgname': maybe(assignee).find('orgname').text.or_else(''),
'role': maybe(assignee).find('role').text.or_else('')
}
def eat(item):
obj = globalvars.save_data.player.find(item)
if not obj:
print(f'You do not have a {item}.')
elif maybe(obj).edible == True:
globalvars.save_data.player.take(item)
respond(obj, 'eat_succ', f'You eat the {obj}.')
else:
respond(obj, 'eat_fail', f'You can\'t eat the {obj}.')
def lookat(item):
obj = maybe(globalvars.save_data.player.find(item))
if obj.is_none():
print(f"You do not have a {item}.")
else:
if obj.color.is_some():
print(f"It's a sort of {obj.color}-ish colour")
if obj.size.is_some():
print(f"it's about {obj.size}")
def update_status():
if maybe(globalvars.save_data.current_room).breathable == 1:
globalvars.save_data.oxygen -= 10
if globalvars.save_data.oxygen == 10:
printSlowColor(Fore.RED +
"Your oxygen levels are dangerously low." +
Fore.RESET)
elif maybe(globalvars.save_data.current_room).breathable == 2:
globalvars.save_data.oxygen -= 30
if globalvars.save_data.oxygen == 30:
printSlowColor(Fore.RED +
"Your oxygen levels are dangerously low." +
Fore.RESET)
else:
globalvars.save_data.oxygen = min(globalvars.save_data.oxygen + 10,
100)
if globalvars.save_data.oxygen <= 0:
commands.Death("suffocate", None)
def take(item):
obj = globalvars.save_data.current_room.items.find(item)
if not obj:
print(f'there is no {item} here')
elif maybe(obj).immovable == True:
respond(obj, 'take_fail', f'You cannot take the {obj}.')
else:
globalvars.save_data.current_room.items.take(item)
globalvars.save_data.player.add(obj)
respond(obj, 'take_succ', f'You have taken a {obj}.')
def test_something_missing_onDefaultDict_forwardsCallToDefaultDict(self):
from collections import defaultdict
d = maybe(defaultdict(lambda: 'default'))
d['test'] = 'ok'
self.assertEqual(d['doesnt exist'], 'default')
self.assertEqual(d['test'], 'ok')
self.assertTrue(d['doesnt exist'].is_some())
self.assertTrue(d['test'].is_some())
def test_something_missing_onDefaultDict_forwardsCallToDefaultDict(self):
from collections import defaultdict
d = maybe(defaultdict(lambda: 'default'))
d['test'] = 'ok'
self.assertEqual(d['doesnt exist'], 'default')
self.assertEqual(d['test'], 'ok')
self.assertTrue(d['doesnt exist'].is_some())
self.assertTrue(d['test'].is_some())
def test_something_list_getItem_returnsNothing(self):
s = maybe([1, 2, 3])
self.assertTrue(isinstance(s[0], Something))
self.assertTrue(s[0].is_some())
self.assertEqual(s[0].get(), 1)
self.assertTrue(isinstance(s['test1'], Nothing))
self.assertTrue(s['test1'].is_none())
self.assertTrue(isinstance(s[dict()], Nothing))
self.assertTrue(s[dict()].is_none())
self.assertTrue(isinstance(s[10], Nothing))
self.assertTrue(s[10].is_none())
def test_something_iter_onIterable_returnsArrayIterator(self):
s = maybe([1, 2, 3, 4, 5])
l = list(iter(s))
self.assertEqual([1, 2, 3, 4, 5], l)
def test_maybe_withNone_returnsNothing(self):
result = maybe(None)
self.assertIsInstance(result, Nothing)
def test_maybe_withMaybe_returnMaybe(self):
m = maybe("value")
self.assertEqual(maybe(m), m)
def test_nothing_forwardsMethodCalls_handlesNonExisting(self):
result = maybe(None).invalid().call()
assert result.is_none()
def test_maybe_withValue_returnsSomething(self):
result = maybe("Value")
self.assertIsInstance(result, Something)
def test_something_forwardsMethodCalls_handlesNonExisting(self):
result = maybe('VALUE').lowerr()
assert result.is_none()
def test_something_forwardsMethodCalls(self):
result = maybe('VALUE').lower()
assert result.is_some()
assert result == 'value', "result %s should be 'value'" % result
assert result == maybe('value')
def test_something_len_isZero(self):
s = maybe(dict(test='value'))
self.assertEqual(len(s), 1)
s = maybe([1, 2, 3])
self.assertEqual(len(s), 3)
def test_something_setItem_doestNothing(self):
s = maybe(dict(test='value'))
s['test'] = 'yeah'
self.assertEqual(s['test'], 'yeah')
self.assertTrue(s['test'].is_some())
def test_something_delItem_doestNothing(self):
s = maybe(dict(test='value'))
del s['test'] # Will raise if __delitem__ wasnt defined
self.assertEqual(len(s), 0)
self.assertTrue(s['test'].is_none())
