def create(cls, user_name, email, password=None, locale=None,
openid_identity=None, global_admin=False, display_name=None,
autojoin=True, shibboleth_persistent_id=None):
"""
Create a user. If user_name is None, a random user name is generated.
"""
from group import Group
from membership import Membership
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
while user_name is None:
# Note: This can theoretically lead to IntegrityErrors if the same
# username is generated at the same time. This is very unlikely
# though.
from adhocracy.lib.util import random_username
try_user_name = random_username()
if cls.find(try_user_name) is None:
user_name = try_user_name
from adhocracy.lib import helpers as h
h.flash(_('The random username %s has been assigned to you.') %
user_name, 'success')
user = User(user_name, email, password, locale,
display_name=display_name)
meta.Session.add(user)
# Add the global default group
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if autojoin and config_autojoin:
user.fix_autojoin(commit=False)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
from adhocracy.model.openid import OpenID
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
if shibboleth_persistent_id is not None:
from adhocracy.model.shibboleth import Shibboleth
shib = Shibboleth(shibboleth_persistent_id, user)
meta.Session.add(shib)
meta.Session.flush()
return user
def _main(osm, auth, sections):
group = Group(osm, auth, MAPPING.keys(), None)
for section in sections:
assert section in group.SECTIONIDS.keys(), \
"section must be in {!r}.".format(group.SECTIONIDS.keys())
contacts = []
for section in sections:
section_contacts = [member2contacts(member, section) for
member in group.section_all_members(section)]
# flatten list of lists.
contacts += list(itertools.chain(*section_contacts))
# Remove blank emails
contacts = [contact for contact in contacts if contact[2].strip() != "" ]
# remove duplicates
by_email = {contact[2]: contact for contact in contacts}
contacts = list(by_email.values())
w = csv_writer(sys.stdout)
w.writerows(contacts)
def create(cls, user_name, email, password=None, locale=None, openid_identity=None, global_admin=False):
from group import Group
from membership import Membership
from openid import OpenID
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
user = User(user_name, email, password, locale)
meta.Session.add(user)
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
meta.Session.flush()
return user
def member_badges(osm, auth, firstname, lastname, csv=False, no_headers=False, term=None):
group = Group(osm, auth, MAPPING.keys(), term)
members = group.find_by_name(firstname, lastname)
# member = members[-1]
rows = []
for member in members:
for section_type in ('beavers', 'cubs', 'scouts'):
try:
badges = member.get_badges(section_type=section_type)
if badges is not None:
for badge in [_ for _ in badges if _['awarded'] == '1']:
rows.append([member['date_of_birth'], member['last_name'],
member['age'], section_type, member._section['sectionname'],
badge['badge'],
datetime.date.fromtimestamp(int(badge['awarded_date'])).isoformat()])
except:
import traceback
traceback.print_exc()
pass
headers = ["DOB", "Last Name", "Age", "Section Type", "Section Name", "Badge"]
if csv:
w = csv_writer(sys.stdout)
if not no_headers:
w.writerow(list(headers))
w.writerows(rows)
else:
if not no_headers:
print(tabulate.tabulate(rows, headers=headers))
else:
print(tabulate.tabulate(rows, tablefmt="plain"))
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group,
approved=True)
meta.Session.add(membership)
if config.get_bool('adhocracy.create_initial_instance_page'):
Page.create(instance, label, u"", user)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if (config_autojoin and
(config_autojoin == 'ALL' or
key in (k.strip() for k in config_autojoin.split(',')))):
users = adhocracy.model.User.all()
for u in users:
autojoin_membership = Membership(u, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
meta.Session.flush()
return instance
def _parse_group(self, group_element):
group = Group()
group.name = group_element.get("name")
if group.name is None:
raise ParseError("Missing 'name' attribute in group")
self.groups[group.name] = group
for repo_element in group_element.findall("repo"):
self._parse_repo(group, repo_element)
def _main(osm, auth):
#test_section = '15797'
group = Group(osm, auth, MAPPING.keys())
if group.missing_adult_references():
log.warn("Missing adult references {!r}".format(
group.missing_adult_references()))
def flip(self):
'''Return a group that spans the entire canvas, but is flipped
vertically, add it to the DOM and return a reference to it.'''
group = Group()
group.matrix(1, 0, 0, -1, 0, self.height)
self.add_child(group)
return group
def main():
file = open("test.xml","r")
line = file.readline()
while not startDevices(line):
line = file.readline()
line = file.readline().strip()
devices = []
device = ""
group = ""
capability = ""
while not endDevices(line):
if beginDevice(line):
line = deleteTags(line,"<device ",">")
att_id = getAttrId(line)
att_user = getAttrUser(line)
att_fall = getAttrFall(line)
device = Device(att_id, att_user, att_fall)
line = file.readline()
if endDevice(line):
devices.append(device)
line = file.readline()
if beginGroup(line):
line = deleteTags(line,"<group ",">")
att_id = getAttrId(line)
group = Group(att_id)
group.setDevice(device)
line = file.readline()
if endGroup(line):
device.addGroup(group)
line = file.readline()
if beginCapability(line):
line = deleteTags(line, "<capability ", "/>")
att_name = getAttrName(line)
att_value = getAttrValue(line)
capability = Capability(att_name, att_value)
capability.setGroup(group)
group.addCapability(capability)
line = file.readline()
print "Devices\n"
printDevices(devices)
print "End Devices\n"
file.close()
return 0
def _get_group_node(self, app_node, group):
assert self._lock.locked()
name = "g%s" % group
if app_node.has_child(name):
return app_node.get_child(name)
# Obviously an group factory based on app id, someday...
group_node = Group()
group_node.configure({"parent": app_node, "name": name, "group": group})
group_node.start()
return group_node
def load_groups(self):
groups_url = 'http://s.web2.qq.com/api/get_group_name_list_mask2'
data = {'r': open('json/load_groups.json').read() % self.token}
headers = {"Referer": 'http://s.web2.qq.com/proxy.html?v=20110412001&callback=1&id=1'}
response_of_load_group = self.client.post(groups_url, data=data, headers=headers)
groups_data = json.loads(response_of_load_group.text)
if groups_data['retcode'] == 0:
for group_data in groups_data['result']['gnamelist']:
group = Group(group_data, self.token, self.client)
self.groups[group.id] = group
print group_data
group.message('闪亮登场!')
def group(self):
"""
:return: Group() that is attached to this meeting
"""
meeting_group_relationship = self._graph_db.match(start_node=None,
rel_type=GraphRelationship.HAS_MEETING,
end_node=self.meeting_node)
group = Group()
for rel in meeting_group_relationship:
group.id = rel.end_node.properties['id']
group.get_group()
return group
def leave_group(self, group_id):
"""
remove relationship between user and study group
:param group_id: string uuid
:return: None
"""
#TODO exception handling
group = Group()
group.id = group_id
user_group_relationship = self._graph_db.match_one(start_node=self.user_node,
rel_type=GraphRelationship.MEMBER_OF,
end_node=group.group_node)
self._graph_db.delete(user_group_relationship)
def deserialize(self, data):
self.__init__()
self.name = data.get('name')
self.vars = data.get('vars', dict())
self.address = data.get('address', '')
self._uuid = data.get('uuid', uuid.uuid4())
self.implicit= data.get('implicit', False)
groups = data.get('groups', [])
for group_data in groups:
g = Group()
g.deserialize(group_data)
self.groups.append(g)
def render_subimage(self):
# #10: not render non-terminal (as separate image) if is empty
if not self.subfields:
return []
# create a group view, that should be saved as separated image
config = copy.deepcopy(self._passed_config)
if 'view' in config:
del config['view']
if 'children' in config:
del config['children']
group = Group(name=self.name, value=self.value, mark=self.marked,
save_as_subimage=True, **config)
group.add_children(self.subfields)
return group.render()
def testIterate(self):
group = Group(3)
group.append(Block(3))
group.append(Block(3))
group.values[1].forceValue(2)
group.append(Block(3))
group.values[2].forceValue(1)
group.iterate()
group.iterate()
group.iterate()
self.assertTrue(group.values[0].isValid() and group.values[0].values[0] == 3)
def create_groups(forceOptimizer, debug=False):
'''
DESCRIPTION: Create the groups and add them to the list: groups
STATE: finish
'''
if debug:
print ""
print "============="
print "Create Groups"
print "============="
print ""
#go through all blocks in circuit
for block in forceOptimizer.blocks:
group_id = block.groups # the lowest group get all IDs
if debug:
pins = ""
for p in block.pins.values():
pins += " " + p.net
print "Block: ", block.name, " Group ID", group_id, "Pins:", pins
group = search_group(group_id,forceOptimizer) # check if the group allready exists
if group is None: # create a new group if needed
if debug:
print ("Create a new Group with ID", group_id)
group = Group(group_id)
forceOptimizer.groups.append(group)
if block.name.startswith('i'):
group.block_north.add(block);
group.block_west.add(block)
#add the block to the low level group
group.add_block(block)
#if group has parents create them
if len(group.group_id) > 1:
create_parent(group, forceOptimizer, debug)
#else add group to main group
else:
forceOptimizer.group_main.add_child(group)
group.parent = forceOptimizer.group_main
def _main(osm, auth, sections, outdir, term):
assert os.path.exists(outdir) and os.path.isdir(outdir)
group = Group(osm, auth, MAPPING.keys(), term)
for section in sections:
assert section in group.SECTIONIDS.keys(), \
"section must be in {!r}.".format(group.SECTIONIDS.keys())
for section in sections:
vcards = [member2vcard(member, section) for
member in group.section_all_members(section)]
open(os.path.join(outdir, section + ".vcf"), 'w').writelines(vcards)
def insert(self, index, item):
""" Insert an item into the manager at the specified index.
The item can be:-
1) A 'Group' instance.
In which case the group is inserted into the manager's list of
groups.
2) A string.
In which case a 'Group' instance is created with that Id, and then
inserted into the manager's list of groups.
3) An 'ActionManagerItem' instance.
In which case the item is inserted into the manager's default
group.
"""
# 1) The item is a 'Group' instance.
if isinstance(item, Group):
group = item
# Insert the group into the manager.
group.parent = self
self._groups.insert(index, item)
# 2) The item is a string.
elif isinstance(item, basestring):
# Create a group with that Id.
group = Group(id=item)
# Insert the group into the manager.
group.parent = self
self._groups.insert(index, group)
# 3) The item is an 'ActionManagerItem' instance.
else:
# Find the default group.
group = self._get_default_group()
# Insert the item into the default group.
group.insert(index, item)
return group
def create(cls, user_name, email, password=None, locale=None,
openid_identity=None, global_admin=False, display_name=None):
from group import Group
from membership import Membership
from openid import OpenID
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
user = User(user_name, email, password, locale,
display_name=display_name)
meta.Session.add(user)
# Add the global default group
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if config_autojoin:
instances = Instance.all()
if config_autojoin != 'ALL':
instance_keys = [key.strip() for key in
config_autojoin.split(",")]
instances = [instance for instance in instances
if instance.key in instance_keys]
for instance in instances:
autojoin_membership = Membership(user, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
meta.Session.flush()
return user
def prepare_content(handler, gcname, content):
# Same index retrieval used for unique group name checking
groups = Group.gql("WHERE name_c=:1 LIMIT 1", gcname)
if groups.count() != 1:
handler.error(404)
handler.response.out.write("Group identifier " + gcname + " not found")
return
group = groups[0];
qres = recent_group_reviews(group)
picurl = "img/emptyprofpic.png"
if group.picture:
picurl = "grppic?groupid=" + str(group.key().id())
# facebook doesn't like "../" relative urls
if "localhost" in handler.request.url:
picurl = "../" + picurl
else:
picurl = "http://www.fgfweb.com/" + picurl
content = re.sub('\$GROUPNAME', group.name, content)
content = re.sub('\$GROUPDESCR', group.description, content)
content = re.sub('\$IMGSRC', picurl, content)
content = re.sub('\$GROUPID', str(group.key().id()), content)
content = re.sub('\$GROUPJSON', obj2JSON(group), content)
content = re.sub('\$REVDATA', qres2JSON(
qres.objects, "", -1, ""), content)
refer = handler.request.referer
if refer:
refer = "<img src=\"../bytheimg?grpinqref=" +\
safeURIEncode(refer) + "\"/>\n"
else:
refer = "<img id=\"btwimg\" src=\"../bytheimg?grpinq=" +\
str(group.key().id()) + "\"/>\n"
content = re.sub('\$REFER', refer, content)
content = re.sub('\"', "\\\"", content) #browser interp pre-parse
return content
def __init__(self, states, condition=True, action=None, show=True,
confirm=False, group=None, icon=None, redirect=None):
# In its simpler form, "states" is a list of 2 states:
# (fromState, toState). But it can also be a list of several
# (fromState, toState) sub-lists. This way, you may define only 1
# transition at several places in the state-transition diagram. It may
# be useful for "undo" transitions, for example.
self.states = self.standardiseStates(states)
self.condition = condition
if isinstance(condition, basestring):
# The condition specifies the name of a role
self.condition = Role(condition)
self.action = action
self.show = show # If False, the end user will not be able to trigger
# the transition. It will only be possible by code.
self.confirm = confirm # If True, a confirm popup will show up.
self.group = Group.get(group)
# The user may specify a specific icon to show for this transition.
self.icon = icon or 'transition'
# If redirect is None, once the transition will be triggered, Appy will
# perform an automatic redirect:
# (a) if you were on some "view" page, Appy will redirect you to this
# page (thus refreshing it entirely);
# (b) if you were in a list of objects, Appy will Ajax-refresh the row
# containing the object from which you triggered the transition.
# Case (b) can be problematic if the transition modifies the list of
# objects, or if it modifies other elements shown outside this list.
# If you specify redirect='page', case (a) will always apply.
self.redirect = redirect
def set_content(self, *values):
""" Sets the content of a view.
"""
content = []
accum = []
for value in values:
if isinstance(value, ViewSubElement):
content.append(value)
elif type(value) in SequenceTypes:
content.append(Group(*value))
elif isinstance(value, basestring) and (value[:1] == "<") and (value[-1:] == ">"):
# Convert string to an Include value:
content.append(Include(value[1:-1].strip()))
else:
content.append(Item(value))
# If there are any 'Item' objects in the content, wrap the content in a
# Group:
for item in content:
if isinstance(item, Item):
content = [Group(*content)]
break
# Wrap all of the content up into a Group and save it as our content:
self.content = Group(container=self, *content)
def query_list(group_id, member_of_name, user_id=None, if_gstaff=False, **kwargs):
from group import Group
from gsystem_type import GSystemType
group_name, group_id = Group.get_group_name_id(group_id)
gst_name, gst_id = GSystemType.get_gst_name_id(member_of_name)
if if_gstaff:
query = {
'_type': 'GSystem',
'status': 'PUBLISHED',
'group_set': {'$in': [group_id]},
'member_of': {'$in': [gst_id]},
'access_policy': {'$in': [u'Public', u'PUBLIC', u'PRIVATE']}
}
else:
query = {
'_type': 'GSystem',
'status': 'PUBLISHED',
'group_set': {'$in': [group_id]},
'member_of': {'$in': [gst_id]},
'$or':[
{'access_policy': {'$in': [u'Public', u'PUBLIC']}},
{'$and': [
{'access_policy': u"PRIVATE"},
{'created_by': user_id}
]
},
{'created_by': user_id}
]
}
for each in kwargs:
query.update({each : kwargs[each]})
return node_collection.find(query).sort('last_update', -1)
def group_set_names_list(self):
"""Returns a list having names of each member (Group name),
built from 'group_set' field (list of ObjectIds)
"""
from group import Group
return [Group.get_group_name_id(gr_id)[0] for gr_id in self.group_set]
def __init__(self, name=None, group=None, sortBy='', sortOrder='asc',
maxPerPage=30, default=False, colspan=1, translated=None,
show=True, translatedDescr=None, checkboxes=False,
checkboxesDefault=True, **fields):
# "name" is mandatory, excepted in some special cases (ie, when used as
# "select" param for a Ref field).
self.name = name
# Searches may be visually grouped in the portlet.
self.group = Group.get(group)
self.sortBy = sortBy
self.sortOrder = sortOrder
self.maxPerPage = maxPerPage
# If this search is the default one, it will be triggered by clicking
# on main link.
self.default = default
self.colspan = colspan
# If a translated name or description is already given here, we will
# use it instead of trying to translate from labels.
self.translated = translated
self.translatedDescr = translatedDescr
# Condition for showing or not this search
self.show = show
# In the dict below, keys are indexed field names or names of standard
# indexes, and values are search values.
self.fields = fields
# Do we need to display checkboxes for every object of the query result?
self.checkboxes = checkboxes
# Default value for checkboxes
self.checkboxesDefault = checkboxesDefault
def __init__ ( self, *values, **traits ):
""" Initializes the object.
"""
ViewElement.__init__( self, **traits )
content = []
accum = []
for value in values:
if isinstance( value, Group ):
self._flush( content, accum )
content.append( value )
elif type( value ) in SequenceTypes:
self._flush( content, accum )
content.append( Group( *value ) )
else:
accum.append( value )
self._flush( content, accum )
# If 'content' trait was specified, add it to the end of the content:
if self.content is not None:
content.append( self.content )
# Make sure this View is the container for all its children:
for item in content:
item.container = self
# Wrap all of the content up into a Group and save it as our content:
self.content = Group( container = self, *content )
def _set_default_value(self, record, fields=None):
if record.value.get(self.name) is not None:
return
from group import Group
parent_name = self.attrs.get('relation_field', '')
fields = fields or {}
context = record.expr_eval(self.attrs.get('context', {}))
group = Group(self.attrs['relation'], fields,
parent=record,
parent_name=parent_name,
child_name=self.name,
context=context,
parent_datetime_field=self.attrs.get('datetime_field'))
if not fields and record.model_name == self.attrs['relation']:
group.fields = record.group.fields
record.value[self.name] = group
self._connect_value(group)
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group, approved=True)
meta.Session.add(membership)
Page.create(instance, label, u"", user)
meta.Session.flush()
return instance
def _set_default_value(self, record):
if record.value.get(self.name) is not None:
return
from group import Group
parent_name = self.attrs.get('relation_field', '')
group = Group(self.attrs['relation'], {},
parent=record,
parent_name=parent_name,
child_name=self.name,
context=self.context,
parent_datetime_field=self.attrs.get('datetime_field'))
if record.model_name == self.attrs['relation']:
group.fields = record.group.fields
group.signal_connect(group, 'group-changed', self._group_changed)
group.signal_connect(group, 'group-list-changed',
self._group_list_changed)
group.signal_connect(group, 'group-cleared', self._group_cleared)
group.signal_connect(group, 'record-modified', self._record_modified)
record.value[self.name] = group
def test_add_empty_group(app):
app.login(username="******", password="******")
app.init_group_creation()
app.fill_group_form(Group(name="", header="", footer=""))
app.submit_group_creation()
app.logout()
def main_multiprocess():
trajectorydata = pd.read_csv("./trainTrajectory_final.csv")
member = MembershipVector(trajectorydata['UserID'].unique(), GROUP_NUM)
t = Trajectory(trajectorydata)
models = [
hmm.GroupLevelHMM(n_components=N_STATES, init_params='mce')
for i in range(GROUP_NUM)
]
log = open('./logs/log_' + str(datetime.datetime.now()) + '.txt', 'w')
for n in range(30):
print("STAGE : " + str(n + 1))
p = mp.Pool(processes=mp.cpu_count() - 1)
# iterate groups
start = time.time()
manager = mp.Manager()
model_list = manager.list(models)
processes = []
fit_model = partial(train_model_for_group,
models=models,
member=member,
t=t)
model_list = p.map(fit_model, range(0, GROUP_NUM))
p.close()
p.join()
models = list(model_list)
print("Training complete")
# Grouping and update
# group_list = []
# for i in range(0, GROUP_NUM):
# group_list.append(Group(hmm=models[i], membership=member, trajectory=t, groupId=i))
# manager = mp.Manager()
# m_group_list = manager.list(group_list)
# p = mp.Pool(processes=mp.cpu_count()-1)
# m_update_group=partial(update_group, group=m_group_list)
# m_group_list = p.map(m_update_group, range(0, GROUP_NUM))
# group_list = list(m_group_list)
# p.close()
# p.join
for i in range(0, GROUP_NUM):
g = Group(hmm=models[i],
membership=member,
trajectory=t,
groupId=i)
member = g.update()
print("Complete")
end = time.time()
print('total time (s)= ' + str(end - start))
groups = np.zeros(GROUP_NUM)
for i in trajectorydata['UserID']:
groups[member.getProbOfUser(i).argmax()] += 1
print(groups)
eval_log = eval_group_hmms(member, models)
print(eval_log)
log = open('./logs/log_' + str(datetime.datetime.now()) + '.txt', 'w')
log.write(str(eval_log))
log.write(str(groups))
log.close()
for i in range(0, GROUP_NUM):
output = open(
'./models/model_iter_' + str(n) + '_model_' + str(i) + '_' +
str(datetime.datetime.now()) + '.pkl', 'wb')
s = pickle.dump(models[i], output)
output.close()
def test_str(self):
group = self._get_group()
exp_str = [f"Student({s})" for s in group]
exp_str = f"Group({exp_str})"
self.assertEqual(str(Group(group)), exp_str)
def test_sort_by_ages(self):
s1 = Student("a", "a", "a", date(1997, 1, 1), 1, 1)
s2 = Student("a", "a", "a", date(1993, 1, 1), 1, 1)
s3 = Student("a", "a", "a", date(1994, 1, 1), 1, 1)
g = Group([s1, s2, s3])
g.sort_by_age()
self.assertEqual(str(g), str(Group([s1, s3, s2])))
g.sort_by_age(reverse=True)
self.assertEqual(str(g), str(Group([s2, s3, s1])))
s4 = Student("a", "a", "a", date(1992, 1, 1), 1, 1)
for group in permutations([s1, s2, s3, s4]):
g = Group(group)
g.sort_by_age()
self.assertEqual(str(g), str(Group([s1, s3, s2, s4])))
g.sort_by_age(reverse=True)
self.assertEqual(str(g), str(Group([s4, s2, s3, s1])))
def test_add_empty_group(self):
wd = self.wd
self.login(wd, username="******", password="******")
self.create_group(wd, Group(name="", header="", footer=""))
self.logout(wd)
def _create_groups(self, targets=[]):
for target_value in targets:
self.groups[target_value] = Group(target_value)
def ScrapGroup(class_sel):
try:
url = generateURL(class_sel)
except TypeError:
sys.exit()
if url == "Invalid class":
return
#print(url)
status, plain_html = extractHTML(url)
soup = BeautifulSoup(plain_html, "html.parser")
tree_groups = soup.find_all("tr")
group_list = []
tree_groups.pop(0) #remove 2 first branches of the tree
tree_groups.pop(0)
for gr in tree_groups:
#print(list(gr.descendants))
group_iter = gr.descendants #create a generator containing all the branches of the tree
group_content = next(doubleJump(gr.descendants))
if group_content == 'L':
tipo_t = next(doubleJump(group_iter))
horario_t = next(doubleJump(group_iter))
dias_t = next(doubleJump(group_iter))
try:
salon_t = next(doubleJump(group_iter))
except:
salon_t = "Sin Asignar"
group_list[-1].addHorario_lab(horario_t)
group_list[-1].addDias_lab(dias_t)
group_list[-1].labo_salon = salon_t
elif isInt(group_content):
clave_t = next(doubleJump(group_iter))
grupo_t = next(doubleJump(group_iter))
profesor_t = next(doubleJump(group_iter))
tipo_t = next(doubleJump(group_iter))
horario_t = next(doubleJump(group_iter))
dias_t = next(doubleJump(group_iter))
salon_t = next(doubleJump(group_iter))
try:
cupo_t = next(doubleJump(group_iter))
except:
cupo_t = salon_t
salon_t = "Sin Asignar"
try:
vacantes_t = next(doubleJump(group_iter))
except:
vacantes_t = cupo_t
group_list.append(
Group(clave=clave_t,
grupo=grupo_t,
profesor=profesor_t,
tipo=tipo_t,
horario=horario_t,
dias=dias_t,
salon=salon_t,
cupo=cupo_t,
vacantes=vacantes_t))
elif len(list(gr.descendants)) == 6:
horario_t = next(doubleJump(group_iter))
dias_t = next(doubleJump(group_iter))
try:
salon_t = next(doubleJump(group_iter))
except:
salon_t = "Sin Asignar"
group_list[-1].salon.append(salon_t)
group_list[-1].addHorario(horario_t)
group_list[-1].addDias(dias_t)
return group_list
def _set_animation(self):
"""アニメーションの設定
"""
self.timer_group = TimerGroup()
self.middle_sprites.add(self.timer_group)
self.transform_manager = SpriteTransformManager()
self.middle_sprites.add(self.transform_manager)
rects = layout_rects(self.view_area,
2,
1,
padding=40,
margin_vertical=40)
self.hand_sprites = {
self.actor1: {
self.Hand.ROCK:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[0],
rects[0])),
self.Hand.SCISSORS:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[1],
rects[0])),
self.Hand.PAPER:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[2],
rects[0])),
},
self.actor2: {
self.Hand.ROCK:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[0],
rects[1])),
self.Hand.SCISSORS:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[1],
rects[1])),
self.Hand.PAPER:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[2],
rects[1])),
}
}
# wait_surface = self.font.render("wait", True, (0, 0, 0), (255, 255, 255))
# ready_surface = self.font.render("ready", True, (0, 0, 0), (255, 255, 255))
self.actor_state_sprites = {
self.actor1: {
True:
TextSprite(*rects[0].midbottom,
align="center",
vertical_align="bottom",
text="wait",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
False:
TextSprite(*rects[0].midbottom,
align="center",
vertical_align="bottom",
text="ready",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
},
self.actor2: {
True:
TextSprite(*rects[1].midbottom,
align="center",
vertical_align="bottom",
text="wait",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
False:
TextSprite(*rects[1].midbottom,
align="center",
vertical_align="bottom",
text="ready",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
}
}
self.actor_state_group = Group()
self.middle_sprites.add(self.actor_state_group)
# 「さいしょは ぐー」などのセリフスプライト
self.before_battle_sprite1 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="さいしょは ぐー",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite2 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="じゃんけん...",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite3 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="ぽん",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite4 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="あいこで",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite5 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="しょ",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.end_battle_sprite = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="そこまで",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
# あいこ中フラグ
self.pre_aiko = False
def get_groups(self):
return Group.list()
beta_IV = 0.01 beta_RV = 0.01 beta_SI2 = beta beta_II2 = 0.0 beta_RI2 = beta_IR beta_VI2 = beta_IV phi_V = phi phi_T = 0.95 test_rate = 0.5 immune_time = 60 group_size = 3 verbose_mode = False # Need to put here for initiating other objects (nwk and person if needed). population = Person.make_population(N) contact_nwk = ContactNwk(population, verbose_mode) info_nwk = Group(population, group_size) filename = '' # Default file name to export (.csv). Change when use prompt 'export' cmd. mode_master_list = [] # All objects should add into mode_master_list mode01 = mode.Mode01(population) mode02 = mode.Mode02(population, beta) mode04 = mode.Mode04(population, alpha) mode05 = mode.Mode05(population, contact_nwk) mode07 = mode.Mode07(population, beta, delta) mode08 = mode.Mode08(population, beta, delta) mode10 = mode.Mode10(population, phi, beta) mode11 = mode.Mode11(population) mode20 = mode.Mode20(population, contact_nwk, beta) mode21 = mode.Mode21(population, info_nwk) mode22 = mode.Mode22(population, info_nwk)
def test_add_empty_group(app):
app.login(username="******", password="******")
app.create_group(Group(name="", header="", footer=""))
app.logout()
def test_add_group(app):
app.login(username="******", password="******")
app.create_group(
Group(name="Test_Group", header="Test_Group", footer="Comment"))
app.logout()
def possible_sets(target: Tile, free_tiles: list) -> list:
print('target:', target)
print('free_tiles:', free_tiles)
all_tiles = free_tiles + [target]
sets = []
###################################################################################################
# add all the possible Groups sets that contains the target tile
same_num_tiles = list(
filter(
lambda tile: tile.number == target.number and tile.color != target.
color, free_tiles))
same_num_tiles = list(set(same_num_tiles)) # remove duplicates
# other_tiles = lists_difference(free_tiles, same_num_tiles)
same_num_colors = [t.color for t in same_num_tiles] # keep just the colors
# same_num_colors = []
# other_tiles = []
# for tile in tiles:
# if tile.number == target.number and tile.color != target.color and \
# tile.color not in same_num_colors:
# same_num_colors.append(tile.color)
# else:
# other_tiles.append(tile)
combs = nCr(same_num_colors, MIN_LEN - 1)
if len(same_num_colors) == MIN_LEN:
combs.append(same_num_colors)
for comb in combs:
group = Group(target.number, [target.color] + comb)
other_tiles = lists_difference(all_tiles, group.get_tiles())
sets.append(([group], other_tiles))
###################################################################################################
# add all the possible Run sets that contains the target tile
same_color_tiles = list(
filter(lambda t: t.color == target.color and t.number != target.number,
free_tiles))
same_color_tiles = list(set(same_color_tiles)) # remove duplicates
same_color_numbers = sorted(
[target.number] + [t.number
for t in same_color_tiles]) # keep just the numbers
# add all the series with the minimum length that contains the target number
# for i in range(0, len(same_color_numbers) - MIN_LEN + 1):
# series = same_color_numbers[i: i + MIN_LEN]
# numbers_diff = [series[j + 1] - series[j] for j in range(len(series) - 1)]
# if set(numbers_diff) == {1}: # all te differences should be 1
# run = Run(target.color, series)
# other_tiles = lists_difference(all_tiles, run.get_tiles())
# sets.append(([run], other_tiles))
# add all the possible series that contains the target number
for series in get_possible_series(same_color_numbers, target.number):
run = Run(target.color, series)
other_tiles = lists_difference(all_tiles, run.get_tiles())
sets.append(([run], other_tiles))
if len(sets) == 0:
sets.append(([], all_tiles))
return sets
def __init__(self):
self.ignored_lines: int = 0
self.vertices: Iterable[Point] = [None]
self.default_group: Group = Group()
self.named_groups = {}
self.normals: Iterable[Vector] = [None]
class GameScene(Scene):
def __init__(self, rect, levels):
super().__init__(rect)
self.levels = levels
self.curr_level_index = 0
self.num_levels = len(levels)
def build(self, level=None):
level = self.levels[self.curr_level_index] if level is None else level
self.level_name = level['level_name']
self.grid = GameGrid(glb.GAMEGRIDRECT, glb.CELL_SIZE)
# place head of the snake in the center and align to the grid
snake_x, snake_y = self.grid.cell2xy(*self.grid.xy2cell(
glb.GAMEGRIDRECT.centerx, glb.GAMEGRIDRECT.centery))
# create snake parts
head = SnakePart(snake_x, snake_y, head_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_head)
neck = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT,
body_straight_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_body)
body = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT * 2,
body_straight_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_body)
tail = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT * 3,
tail_image, glb.DIRECTION_UP, glb.DIRECTION_UP,
dir2img_tail)
parts = [head, neck, body, tail]
self.snake = Snake(parts,
speed=level['game_speed'],
wrap_around=level.get('wrap_around',
glb.SNAKE_CAN_WRAP_AROUND),
bounding_rect=glb.GAMEGRIDRECT)
self.group_snake = Group([self.snake])
for part in self.snake.parts:
self.grid.occupy_cell(*self.grid.xy2cell(*part.getpos()))
# create some food
self.food = Group()
food_table = level.get('food_table', default_food_table)
self.food_factory = FoodFactory(food_table)
for _ in range(level['num_starting_food']):
fc = self.grid.get_random_free_cell()
if fc:
food_x, food_y = self.grid.cell2xy(*fc)
self.grid.occupy_cell(*fc)
self.food.append(self.food_factory.make_random(food_x, food_y))
# create some walls
self.walls = Group()
for _ in range(level['num_starting_walls']):
fc = self.grid.get_random_free_cell()
if fc:
wall_x, wall_y = self.grid.cell2xy(*fc)
self.grid.occupy_cell(*fc)
self.walls.append(Wall(wall_x, wall_y, wall_image))
self.score = 0
self.score_needed = level['score_needed']
# tile background with sand texture
for cix in range(self.grid.n_cells_x):
for ciy in range(self.grid.n_cells_y):
self.background.blit(ground_image, self.grid.cell2xy(cix, ciy))
# make bounding fence with electricity
for cix in range(self.grid.n_cells_x):
self.background.blit(fence_horiz_image,
self.grid.cell2xy(cix, -1, False))
self.background.blit(
fence_horiz_image_flip_v,
self.grid.cell2xy(cix, self.grid.n_cells_y, False))
for ciy in range(self.grid.n_cells_y):
self.background.blit(fence_vert_image,
self.grid.cell2xy(-1, ciy, False))
self.background.blit(
fence_vert_image_flip_h,
self.grid.cell2xy(self.grid.n_cells_x, ciy, False))
self.background.blit(fence_corner_image,
self.grid.cell2xy(-1, -1, False))
self.background.blit(fence_corner_image_flip_h,
self.grid.cell2xy(self.grid.n_cells_x, -1, False))
self.background.blit(fence_corner_image_flip_v,
self.grid.cell2xy(-1, self.grid.n_cells_y, False))
self.background.blit(
fence_corner_image_flip_hv,
self.grid.cell2xy(self.grid.n_cells_x, self.grid.n_cells_y, False))
# reset timer
self.time_elapsed = 0
self.max_time = level['max_time']
if self.timer is not None and self.timer.is_running:
self.timer.stop()
self.timer = RepeatedTimer(1, self.increase_time, None)
# reset texts
self.text_score = ScreenTextBitmapFont('', 10, 20, bitmap_font)
self.text_health = ScreenTextBitmapFont('', 630, 20, bitmap_font)
self.text_time = ScreenTextBitmapFont('', glb.WIDTH // 2, 20,
bitmap_font)
self.text_level_name = ScreenTextBitmapFont(f'{self.level_name}',
glb.WIDTH // 4 + 32, 20,
bitmap_font)
self.texts = Group([
self.text_score, self.text_health, self.text_time,
self.text_level_name
])
# reset user events
self.EVENT_PLAYER_LOOSE_LEVEL = pygame.USEREVENT + 1
self.EVENT_PLAYER_WIN_LEVEL = pygame.USEREVENT + 2
self.up = 0
self.right = 0
self.blinking_rect_fx = BlinkingRectFX()
self.particles = []
self.built = True
def increase_time(self, *args, **kwargs):
# TODO: VERY UGLY CODE!!
self.time_elapsed += 1
if self.time_is_out(10):
snd_clock_tick.play()
def update(self):
snake = self.snake
grid = self.grid
food = self.food
for part in snake.parts:
grid.release_cell(*grid.xy2cell(*part.getpos()))
snake.move(self.up, self.right, self.walls)
for part in snake.parts:
grid.occupy_cell(*grid.xy2cell(*part.getpos()))
if snake.intersect_itself or not snake.within_world:
snake.kill()
if snake.wrap_around and self.time_elapsed - self.wrap_around_time > 15:
self.snake.wrap_around = False
# grow snake if it eats food
for f in food:
food_rect = grid.get_cell_rect(*grid.xy2cell(*f.rect.center))
if snake.head.rect.colliderect(food_rect):
snake.add_part(grid)
if f.food_type == 'portal':
snake.wrap_around = True
self.wrap_around_time = self.time_elapsed
if f.food_type == 'potion':
snd_eat_potion.play()
elif f.food_type == 'mushroom':
snd_eat_bad_food.play()
else:
snd_eat_good_food.play()
if f.health > 0:
self.score += f.score
snake.health += f.health
food_cix, food_ciy = grid.xy2cell(f.rect.x, f.rect.y)
grid.release_cell(food_cix, food_ciy)
food.remove(f)
fc = grid.get_random_free_cell()
if fc is not None:
food_x, food_y = grid.cell2xy(*fc)
grid.occupy_cell(*fc)
new_food = self.food_factory.make_random(food_x, food_y)
food.append(new_food)
# FX: create new pretty color bubble that will expand around created food
for _ in range(1):
x = new_food.rect.centerx
y = new_food.rect.centery
color = food_type_to_bubble_color.get(
new_food.food_type, glb.PINK)
gravity = 0
vx = 0
vy = 0
radius = 1
border_size = 2
lifetime = 25
rect = new_food.rect.inflate(10, 10)
particle = Particle(
x,
y,
vx,
vy,
color,
radius,
lifetime,
gravity,
border_size,
size_func=lambda size: size + 3.5,
border_size_func=spawn_bubble_border_size_func,
#rect=rect
)
self.particles.append(particle)
if not self.snake.alive or self.time_is_out():
pygame.event.post(pygame.event.Event(
self.EVENT_PLAYER_LOOSE_LEVEL))
return
if self.score >= self.score_needed:
pygame.event.post(pygame.event.Event(self.EVENT_PLAYER_WIN_LEVEL))
snake.update()
for p in self.particles:
p.update()
self.particles = [p for p in self.particles if p.alive]
# update texts
self.text_score.set_text(f'SCORE: {self.score}/{self.score_needed}')
self.text_health.set_text(f'HEALTH: {snake.health}')
if self.max_time:
self.text_time.set_text(
f'TIME: {self.time_elapsed}/{self.max_time}')
else:
self.text_time.set_text(f'TIME: {self.time_elapsed}')
def clear_screen(self, screen):
dirtyrects.clear()
self.group_snake.clear(screen, self.background)
self.walls.clear(screen, self.background)
self.food.clear(screen, self.background)
self.texts.clear(screen, self.background)
def draw(self, screen):
self.group_snake.draw(screen)
self.walls.draw(screen)
self.food.draw(screen)
self.texts.draw(screen)
if self.snake.wrap_around:
self.blinking_rect_fx.draw(screen)
pygame.display.update(dirtyrects)
for particle in self.particles:
particle.draw(screen)
def time_is_out(self, delta=0):
if self.max_time <= 0:
return False
return self.time_elapsed >= self.max_time - delta
def handle_transitions(self, event):
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.scene_manager.pop_scene()
return
if event.type == self.EVENT_PLAYER_LOOSE_LEVEL:
self.build() # here we should rebuild current level
self.scene_manager.push_scene(you_loose_splash_screen)
return
if event.type == self.EVENT_PLAYER_WIN_LEVEL:
if self.curr_level_index < self.num_levels - 1:
self.curr_level_index += 1
self.build() # here we should build next level
self.scene_manager.push_scene(you_win_splash_screen)
else:
self.scene_manager.push_scene(final_splash_screen)
def handle_events(self, event):
keystate = pygame.key.get_pressed()
# handle input
self.up = keystate[pygame.K_UP] - keystate[pygame.K_DOWN]
self.right = keystate[pygame.K_RIGHT] - keystate[pygame.K_LEFT]
def enter(self):
if self.timer is not None and not self.timer.is_running:
self.timer.start()
def leave(self):
if self.timer is not None and self.timer.is_running:
self.timer.stop()
def destroy(self):
self.curr_level_index = 0
self.built = False
def build(self, level=None):
level = self.levels[self.curr_level_index] if level is None else level
self.level_name = level['level_name']
self.grid = GameGrid(glb.GAMEGRIDRECT, glb.CELL_SIZE)
# place head of the snake in the center and align to the grid
snake_x, snake_y = self.grid.cell2xy(*self.grid.xy2cell(
glb.GAMEGRIDRECT.centerx, glb.GAMEGRIDRECT.centery))
# create snake parts
head = SnakePart(snake_x, snake_y, head_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_head)
neck = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT,
body_straight_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_body)
body = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT * 2,
body_straight_image, glb.DIRECTION_UP,
glb.DIRECTION_UP, dir2img_body)
tail = SnakePart(snake_x, snake_y + glb.SNAKE_PART_HEIGHT * 3,
tail_image, glb.DIRECTION_UP, glb.DIRECTION_UP,
dir2img_tail)
parts = [head, neck, body, tail]
self.snake = Snake(parts,
speed=level['game_speed'],
wrap_around=level.get('wrap_around',
glb.SNAKE_CAN_WRAP_AROUND),
bounding_rect=glb.GAMEGRIDRECT)
self.group_snake = Group([self.snake])
for part in self.snake.parts:
self.grid.occupy_cell(*self.grid.xy2cell(*part.getpos()))
# create some food
self.food = Group()
food_table = level.get('food_table', default_food_table)
self.food_factory = FoodFactory(food_table)
for _ in range(level['num_starting_food']):
fc = self.grid.get_random_free_cell()
if fc:
food_x, food_y = self.grid.cell2xy(*fc)
self.grid.occupy_cell(*fc)
self.food.append(self.food_factory.make_random(food_x, food_y))
# create some walls
self.walls = Group()
for _ in range(level['num_starting_walls']):
fc = self.grid.get_random_free_cell()
if fc:
wall_x, wall_y = self.grid.cell2xy(*fc)
self.grid.occupy_cell(*fc)
self.walls.append(Wall(wall_x, wall_y, wall_image))
self.score = 0
self.score_needed = level['score_needed']
# tile background with sand texture
for cix in range(self.grid.n_cells_x):
for ciy in range(self.grid.n_cells_y):
self.background.blit(ground_image, self.grid.cell2xy(cix, ciy))
# make bounding fence with electricity
for cix in range(self.grid.n_cells_x):
self.background.blit(fence_horiz_image,
self.grid.cell2xy(cix, -1, False))
self.background.blit(
fence_horiz_image_flip_v,
self.grid.cell2xy(cix, self.grid.n_cells_y, False))
for ciy in range(self.grid.n_cells_y):
self.background.blit(fence_vert_image,
self.grid.cell2xy(-1, ciy, False))
self.background.blit(
fence_vert_image_flip_h,
self.grid.cell2xy(self.grid.n_cells_x, ciy, False))
self.background.blit(fence_corner_image,
self.grid.cell2xy(-1, -1, False))
self.background.blit(fence_corner_image_flip_h,
self.grid.cell2xy(self.grid.n_cells_x, -1, False))
self.background.blit(fence_corner_image_flip_v,
self.grid.cell2xy(-1, self.grid.n_cells_y, False))
self.background.blit(
fence_corner_image_flip_hv,
self.grid.cell2xy(self.grid.n_cells_x, self.grid.n_cells_y, False))
# reset timer
self.time_elapsed = 0
self.max_time = level['max_time']
if self.timer is not None and self.timer.is_running:
self.timer.stop()
self.timer = RepeatedTimer(1, self.increase_time, None)
# reset texts
self.text_score = ScreenTextBitmapFont('', 10, 20, bitmap_font)
self.text_health = ScreenTextBitmapFont('', 630, 20, bitmap_font)
self.text_time = ScreenTextBitmapFont('', glb.WIDTH // 2, 20,
bitmap_font)
self.text_level_name = ScreenTextBitmapFont(f'{self.level_name}',
glb.WIDTH // 4 + 32, 20,
bitmap_font)
self.texts = Group([
self.text_score, self.text_health, self.text_time,
self.text_level_name
])
# reset user events
self.EVENT_PLAYER_LOOSE_LEVEL = pygame.USEREVENT + 1
self.EVENT_PLAYER_WIN_LEVEL = pygame.USEREVENT + 2
self.up = 0
self.right = 0
self.blinking_rect_fx = BlinkingRectFX()
self.particles = []
self.built = True
def parse_group(group):
return Group(group.id, group.name)
class GameScreen(BaseScreen):
class Hand(Enum):
ROCK = 0
PAPER = 1
SCISSORS = 2
class Actor:
def __init__(self, game_player):
self.game_player = game_player
self.hand = None
def done(self) -> bool:
return self.hand is not None
def set_hand(self, hand):
print(self, "set hand:", hand)
self.hand = hand
def reset(self):
self.hand = None
def decrease_stock(self):
self.game_player.stock -= 1
return self.game_player.stock
def __repr__(self):
return "<Actor: {}>".format(self.game_player)
def __init__(self, game_player1, game_player2, game_setting):
"""ゲーム画面
Args:
game_player1 (GamePlayer): プレイヤー情報(Player, Character, stock(player's rest stock))
game_player2 (GamePlayer): プレイヤー情報(Player, Character, stock(player's rest stock))
game_setting (GameSetting): ゲーム情報(stage, stock(先取))
"""
super().__init__()
game_config = GameConfig("./jsons/config.json")
if game_player1 is None:
game_player1 = get_sample_game_player(game_config, name="sample1")
else:
game_player1 = game_player1
if game_player1.character is None or game_player1.player is None:
game_player1 = get_sample_game_player(game_config,
name="sample1")
if game_player2 is None:
game_player2 = get_sample_game_player(game_config, name="sample2")
else:
game_player2 = game_player2
if game_player2.character is None or game_player2.player is None:
game_player2 = get_sample_game_player(game_config,
name="sample2")
if game_setting is None:
self.game_setting = get_sample_game_setting(game_config, stock=5)
else:
self.game_setting = game_setting
self.actor1 = self.Actor(game_player1)
self.actor2 = self.Actor(game_player2)
# self.font = pygame.font.Font(None, 60)
self.font = pygame.font.Font("./fonts/Mplus2-Medium.ttf", 60)
self.yattane = pygame.mixer.Sound("./sounds/yattane.mp3")
self.uu = pygame.mixer.Sound("./sounds/uu.mp3")
self.sokomade = pygame.mixer.Sound("./sounds/sokomade.mp3")
self.init()
def init(self):
"""初期化処理を行う
"""
self._set_area()
self._set_bg()
self._init_game()
self._set_player_icons()
# self._set_random_btn()
self._set_key_handler()
self._set_checker()
self._set_animation()
self._reset()
def _set_area(self):
"""エリア分割を行う
"""
rect = self.display.get_rect()
area_rects = layout_rects(rect, 2, 3)
self.view_area = area_rects[0].union(area_rects[3])
self.icon_area = area_rects[4].union(area_rects[5])
def _set_bg(self):
"""背景画像の設置．game_setting.stageを参照．
"""
print(self.game_setting.stage)
rect = self.display.get_rect()
bg_image = self.game_setting.stage.image
bg_image = surface_fit_to_rect(bg_image, rect)
self.bg_sprite = SimpleSprite(rect, bg_image)
self.background_sprites.add(self.bg_sprite)
def _init_game(self):
"""ゲームの初期化.
"""
self.actor1.game_player.stock = self.game_setting.stock
self.actor2.game_player.stock = self.game_setting.stock
def _set_player_icons(self):
"""プレイヤーアイコンの設置
"""
rects = layout_rects(self.icon_area,
2,
1,
padding_left=70,
padding_right=50,
margin_horizontal=50)
game_players = [self.actor1.game_player, self.actor2.game_player]
for game_player, rect in zip(game_players, rects):
player_icon_sprite = PlayerStockIcon(left=rect.left,
top=rect.top,
game_player=game_player,
image_height=100)
self.middle_sprites.add(player_icon_sprite)
def _set_random_btn(self):
"""(デバッグ)ランダム勝敗ボタンの設置
"""
rect = self.display.get_rect()
surface = self.font.render("random result", True, (255, 255, 255),
(0, 0, 0))
random_result_btn = RichSprite(rect.w // 2,
rect.h // 3,
image=surface,
press_fnc=self._random_result)
self.middle_sprites.add(random_result_btn)
def _random_result(self):
"""ランダムに勝敗をつける関数
"""
import random
players = [self.actor1.game_player, self.actor2.game_player]
win_i = random.randint(0, 1)
players[win_i].stock = 1
players[(win_i + 1) % 2].stock = 0
print("player {} win.".format(players[win_i].player.name))
self._go_to_result()
def _set_key_handler(self):
"""プレイヤーの入力を処理するGroupの設置
"""
self.key_handers = []
for actor, keys in zip([self.actor1, self.actor2],
[(pygame.K_1, pygame.K_2, pygame.K_3),
(pygame.K_8, pygame.K_9, pygame.K_0)]):
key_to_fnc_dic = {
keys[0]: (self._set_hand, (actor, self.Hand.ROCK)),
keys[1]: (self._set_hand, (actor, self.Hand.SCISSORS)),
keys[2]: (self._set_hand, (actor, self.Hand.PAPER)),
}
key_hundler = KeyHandler(key_to_fnc_dic)
self.middle_sprites.add(key_hundler)
self.key_handers.append(key_hundler)
def _set_checker(self):
"""チェッカーGroupの設置
"""
self.checkers = []
# プレイヤー1, 2が入力完了したかどうかを監視するもの
key_done_checker = Checker([self.actor1.done, self.actor2.done],
self._start_battle_before_animation,
stop_when_call_fnc=True)
self.middle_sprites.add(key_done_checker)
self.checkers.append(key_done_checker)
def _judge(self):
"""勝ち負け判定
"""
win_actor = None
rest = 1
if self.actor1.hand == self.actor2.hand:
pass # あいこ
elif (self.actor1.hand == self.Hand.ROCK and self.actor2.hand == self.Hand.SCISSORS) or \
(self.actor1.hand == self.Hand.PAPER and self.actor2.hand == self.Hand.ROCK) or \
(self.actor1.hand == self.Hand.SCISSORS and self.actor2.hand == self.Hand.PAPER):
# actor1の勝ち
rest = self.actor2.decrease_stock()
win_actor = self.actor1
else:
# actor2の勝ち
rest = self.actor1.decrease_stock()
win_actor = self.actor2
self._start_battle_after_animation(win_actor)
# self._reset()
def _set_animation(self):
"""アニメーションの設定
"""
self.timer_group = TimerGroup()
self.middle_sprites.add(self.timer_group)
self.transform_manager = SpriteTransformManager()
self.middle_sprites.add(self.transform_manager)
rects = layout_rects(self.view_area,
2,
1,
padding=40,
margin_vertical=40)
self.hand_sprites = {
self.actor1: {
self.Hand.ROCK:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[0],
rects[0])),
self.Hand.SCISSORS:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[1],
rects[0])),
self.Hand.PAPER:
SimpleSprite(
rects[0],
fit_surface(self.actor1.game_player.character.arm_image[2],
rects[0])),
},
self.actor2: {
self.Hand.ROCK:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[0],
rects[1])),
self.Hand.SCISSORS:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[1],
rects[1])),
self.Hand.PAPER:
SimpleSprite(
rects[1],
fit_surface(self.actor2.game_player.character.arm_image[2],
rects[1])),
}
}
# wait_surface = self.font.render("wait", True, (0, 0, 0), (255, 255, 255))
# ready_surface = self.font.render("ready", True, (0, 0, 0), (255, 255, 255))
self.actor_state_sprites = {
self.actor1: {
True:
TextSprite(*rects[0].midbottom,
align="center",
vertical_align="bottom",
text="wait",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
False:
TextSprite(*rects[0].midbottom,
align="center",
vertical_align="bottom",
text="ready",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
},
self.actor2: {
True:
TextSprite(*rects[1].midbottom,
align="center",
vertical_align="bottom",
text="wait",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
False:
TextSprite(*rects[1].midbottom,
align="center",
vertical_align="bottom",
text="ready",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255)),
}
}
self.actor_state_group = Group()
self.middle_sprites.add(self.actor_state_group)
# 「さいしょは ぐー」などのセリフスプライト
self.before_battle_sprite1 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="さいしょは ぐー",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite2 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="じゃんけん...",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite3 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="ぽん",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite4 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="あいこで",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.before_battle_sprite5 = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="しょ",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
self.end_battle_sprite = TextSprite(*self.view_area.center,
align="center",
vertical_align="middle",
text="そこまで",
font=self.font,
color=(0, 0, 0),
bgcolor=(255, 255, 255))
# あいこ中フラグ
self.pre_aiko = False
def _start_battle_before_animation(self):
"""バトルアニメーションを開始
"""
dummy = Group()
self.timer_group.add_timer_sprite(
dummy, timer=30, on_delete_fnc=self.actor_state_group.empty)
if self.pre_aiko:
self.timer_group.add_timer_sprite(
self.before_battle_sprite4,
timer=60,
start_delay=30,
on_delete_fnc=self._start_battle_hand_animation,
debug_label="あいこで")
self.timer_group.add_timer_sprite(self.before_battle_sprite5,
timer=30,
start_delay=90,
layer="front",
debug_label="しょ")
else:
self.timer_group.add_timer_sprite(self.before_battle_sprite1,
timer=60,
start_delay=30,
debug_label="最初はグー")
self.timer_group.add_timer_sprite(
self.before_battle_sprite2,
timer=60,
start_delay=90,
on_delete_fnc=self._start_battle_hand_animation,
debug_label="じゃんけん")
self.timer_group.add_timer_sprite(self.before_battle_sprite3,
timer=30,
start_delay=150,
layer="front",
debug_label="ぽん")
def _start_battle_hand_animation(self):
"""手を出すアニメーションを開始
"""
# self.actor_state_group.empty()
total_frame = 60
group = Group()
for actor in [self.actor1, self.actor2]:
sprite = self.hand_sprites[actor][actor.hand]
group.add(sprite)
sprite.image.set_alpha(0)
props = make_transform_properties(0,
0,
0,
0,
0,
1,
total_frame=int(total_frame *
0.2))
self.transform_manager.add_transformer(sprite, props)
self.timer_group.add_timer_sprite(group,
timer=total_frame,
on_delete_fnc=self._judge,
debug_label="手を表示する")
def _start_battle_after_animation(self, actor):
"""勝者を受け取って何かする
Args:
actor (Actor): 勝者Actor
"""
self.pre_aiko = False
if actor == self.actor1:
self.yattane.play()
elif actor == self.actor2:
self.uu.play()
else:
self.pre_aiko = True
end = False
for actor in [self.actor1, self.actor2]:
if actor.game_player.stock == 0:
end = True
break
dummy = Group()
self.timer_group.add_timer_sprite(
dummy,
timer=90,
on_delete_fnc=self._start_battle_end_animation
if end else self._reset,
debug_label="ボイスの分")
def _start_battle_end_animation(self):
"""Resultに移る前のアニメーション
"""
self.sokomade.play()
self.end_battle_sprite.image.set_alpha(0)
total_frame = 90
props = make_transform_properties(0,
0,
0,
0,
0,
1,
total_frame=int(total_frame * 0.3))
self.transform_manager.add_transformer(self.end_battle_sprite, props)
self.timer_group.add_timer_sprite(self.end_battle_sprite,
timer=total_frame,
on_delete_fnc=self._go_to_result,
debug_label="result遷移までの間(そこまでボイス分)")
def _set_hand(self, actor, hand):
"""actorのHandを更新する
Args:
actor (Actor): Actor
hand (Hand): Hand
"""
actor.set_hand(hand)
self._update_actor_state_sprites()
def _update_actor_state_sprites(self):
"""Actorの状態に応じて画像を変化させる
"""
self.actor_state_group.empty()
for actor in [self.actor1, self.actor2]:
self.actor_state_group.add(
self.actor_state_sprites[actor][actor.done()])
def _go_to_result(self):
"""結果画面に進む
"""
self.run = False
self.next_screen = Screen.RESULT
def _reset(self):
"""入力待ちに戻す
"""
self.actor1.reset()
self.actor2.reset()
for key_hander in self.key_handers:
key_hander.resume()
for checker in self.checkers:
checker.resume()
self._update_actor_state_sprites()
def test_sort_by_age_and_skill(self):
s1 = Student("a", "a", "a", date(1993, 1, 1), 1, 4)
s2 = Student("a", "a", "a", date(1993, 1, 1), 1, 2)
s3 = Student("a", "a", "a", date(1994, 1, 1), 1, 3)
g = Group([s1, s2, s3])
g.sort_by_age_and_skill()
self.assertEqual(str(g), str(Group([s3, s2, s1])))
g.sort_by_age_and_skill(reverse=True)
self.assertEqual(str(g), str(Group([s1, s2, s3])))
s4 = Student("a", "a", "a", date(1994, 1, 1), 1, 7)
for group in permutations([s1, s2, s3, s4]):
g = Group(group)
g.sort_by_age_and_skill()
self.assertEqual(str(g), str(Group([s3, s4, s2, s1])))
g.sort_by_age_and_skill(reverse=True)
self.assertEqual(str(g), str(Group([s1, s2, s4, s3])))
from students import AbstractStudent, DefaultStudent, MemberOfStudentCouncil, NerdStudent
from group import Group
from exam import Exam
from grades import Grades
stud1 = DefaultStudent('A A A', [('Math', [4, 4, 4])])
stud1.addSubjectAndGrade('Physics', [3, 4, 3])
stud2 = DefaultStudent('B B B', [('Math', [2, 2, 2]), ('Physics', [5, 5, 5])])
stud3 = NerdStudent('CCC', [('Math', [2, 2, 2]), ('Physics', [2, 2, 2])])
group = Group('8888', 20, [stud1, stud2, stud3])
exam = Exam(group, 'Math')
exam1 = Exam(group, 'Physics')
exam.checkGrades()
exam.examination()
exam.examination()
exam.examination()
print(group)
def test_add_group(self):
wd = self.wd
self.login(wd, username="******", password="******")
self.create_group(
wd, Group(name="fdg", header="dffgfgr", footer="dvfvfbbf"))
self.logout(wd)
def test_add_new_group():
new_group = Group('group_name', 'invite_key')
GroupManager().add_new_group(new_group)
assert GroupManager().find_group('group_name') == new_group
def create(cls,
user_name,
email,
password=None,
locale=None,
openid_identity=None,
global_admin=False,
display_name=None,
autojoin=True,
shibboleth_persistent_id=None):
"""
Create a user. If user_name is None, a random user name is generated.
"""
from group import Group
from membership import Membership
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
while user_name is None:
# Note: This can theoretically lead to IntegrityErrors if the same
# username is generated at the same time. This is very unlikely
# though.
from adhocracy.lib.util import random_username
try_user_name = random_username()
if cls.find(try_user_name) is None:
user_name = try_user_name
from adhocracy.lib import helpers as h
h.flash(
_('The random username %s has been assigned to you.') %
user_name, 'success')
user = User(user_name,
email,
password,
locale,
display_name=display_name)
meta.Session.add(user)
# Add the global default group
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if autojoin and config_autojoin:
user.fix_autojoin(commit=False)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
from adhocracy.model.openid import OpenID
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
if shibboleth_persistent_id is not None:
from adhocracy.model.shibboleth import Shibboleth
shib = Shibboleth(shibboleth_persistent_id, user)
meta.Session.add(shib)
meta.Session.flush()
return user
student4 = Student('Григорьев', 'Лука', 'Сергеевич', 'male', 26, 145, 82, 'IT',
'RT-518', 'III')
student5 = Student('Громов', 'Ибрагил', 'Артемович', 'male', 22, 192, 73, 'IT',
'RT-518', 'III')
student6 = Student('Хохлова', 'Илона', 'Лукьевна', 'female', 23, 134, 85, 'IT',
'RT-518', 'III')
student7 = Student('Силина', 'Элизабет', 'Альбертовна', 'female', 24, 154, 84,
'IT', 'RT-518', 'III')
student8 = Student('Рогова', 'Кира', 'Авксентьевна', 'female', 25, 132, 89,
'IT', 'RT-518', 'III')
student9 = Student('Щербакова', 'Неолина', 'Вячеславовна', 'female', 23, 164,
76, 'IT', 'RT-518', 'III')
student10 = Student('Лукина', 'Эвелина', 'Митрофановна', 'female', 24, 165, 59,
'IT', 'RT-518', 'III')
student11 = Student('Суханова', 'Аделия', 'Игнатьевна', 'male', 25, 157, 49,
'IT', 'RT-518', 'III')
group_rt = Group(student1, student2, student3, student4, student5, student6,
student7, student8, student9, student10)
print(group_rt)
group_rt.add_to_group(student11)
group_rt.delete_from_group(student8)
print(group_rt.find_student('Самойлов'))
print(group_rt.find_student('Mix'))
group_rt.add_to_group(student11)
group_rt.add_to_group(student11)
group_rt.add_to_group(student11)
print(group_rt)
def __init__(self, np_type=0, max_rec_count=1000, min_gr_size=2, max_gr_size=5):
"""
Attributes
----------
creation_datetime : str
difficulty : int
type : int
cells : list(Cell)
Notes
-----
ジグソーはBOXをJIGSAWに置換するため、BOXの絡むLocked Candidatesの使用を不許可にする
その他の特殊ナンプレはサムグループ以外はHOUSEの要素数が9固定なので解法の使用は基本的に可
そのため、サムナンプレではPEERからの候補数字を削除するときに追加条件を付与する
"""
# 解答生成メソッドの再帰上限
self.max_rec_count = max_rec_count
self.creation_datetime = f'{datetime.now():%y%m%d_%H%M%S_%f}'
self.difficulty = None
self.type = np_type # 0:normal,1:diagonal,2:sum,3:jig
self.type_str = ('NOR', 'DIA', 'SUM', 'JIG')[self.type]
self.cells = [Cell(i, 0) for i in range(81)]
self.answer = None
self.sums = None
self.techniques = {
'CRBE': False,
'Last Digit': False,
'Naked Single': False,
'Hidden Single': False,
'Naked Pair': False,
'Hidden Pair': False,
'Naked Triple': False,
'Hidden Triple': False,
'Locked Candidates Pointing': False,
'Locked Candidates Claiming': False,
'X-Wing': False,
}
self.allow_using = copy.deepcopy(self.techniques)
for i in self.allow_using.keys():
self.allow_using[i] = True
self.houses = self.rows + self.columns + self.boxes
self.peers = [
{*i, *j, *k}
for (i, j, k) in zip(self.peers_box, self.peers_column, self.peers_row)
]
gr = Group()
if self.type == 0:
self.lines = gr.show_lines()
self.group = gr.group.copy()
if self.type == 1:
self.lines = gr.show_lines()
self.group = gr.group.copy()
diagonal1 = [i for i in range(81) if i % 10 == 0]
diagonal2 = [i for i in range(81) if i % 8 == 0 and i != 0 and i != 80]
self.diagonals = [diagonal1, diagonal2]
# print(f'diagonals: {self.diagonals}')
peers_diagonal1 = [
[i * 10 for i in range(9)] if j % 10 == 0 else [] for j in range(81)
]
peers_diagonal2 = [
[(i + 1) * 8 for i in range(9)]
if j % 8 == 0 and j != 0 and j != 80
else []
for j in range(81)
]
self.houses += [diagonal1, diagonal2]
self.peers = [
{*i, *j, *k, *l, *m}
for (i, j, k, l, m) in zip(
self.peers_box,
self.peers_column,
self.peers_row,
peers_diagonal1,
peers_diagonal2,
)
]
if self.type == 2:
# gr = Group()
# サムグループの上限変更は要望あれば
gr.get_new_random_group(min_gr_size, max_gr_size)
self.lines = gr.show_lines()
self.group = gr.group.copy()
self.sums = gr.members.copy()
if self.type == 3:
for key in [
'CRBE',
'Locked Candidates Pointing',
'Locked Candidates Claiming',
]:
self.allow_using[key] = False
self.init_jig()
def obj_to_group(parser: 'ObjFile') -> Group:
group = Group()
for _, named_group in parser.named_groups.items():
group.add_child(named_group)
return group
def get_group_counters(group_id_or_name):
group_name, group_id = Group.get_group_name_id(group_id_or_name)
return counter_collection.find({'group_id': group_id})
def test_one_delivery(app):
app.from_and_to_the_city(from_city_name="Москва", to_city_name="Санкт-Петербург")
app.parameters_of_the_good(Group(length="1", width="1", height="1", weight="1"))
app.press_submit_button()
app.result_page()
def execute(path):
f = open(path, 'r')
contents = f.read()
soup = BeautifulSoup(contents, 'lxml')
f.close()
rows = soup.find_all("row")
table = create_table(rows)
all_groups = []
day = ''
time_start = ''
current_groups = []
for row_index in range(len(table)):
row = table[row_index]
is_pattern_config = check_config_pattern(row)
if is_pattern_config:
l = (list(map(lambda group: group.name, current_groups)))
l.sort()
r = row[2:]
r.sort()
if not (l == r):
all_groups += current_groups
current_groups = []
for g in row[2:]:
current_groups.append(Group(g))
continue
else:
continue
pos = check_even_and_get_position(row)
if (pos == None):
for index in range(len(row)):
if not (row[index] == ''):
current_groups[index].add_subject(row[index], time_start,
False, day)
continue
if (pos == 1):
day = row[0]
time_start = row[1]
for index in range(len(row) - 2):
if not (row[index + 2] == ''):
current_groups[index].add_subject(row[index + 2],
time_start, True, day)
if row_index + 1 != len(table):
if check_separate_line(table[row_index + 1], index):
current_groups[index].add_subject(
row[index + 1], time_start, False, day)
elif not (check_even_and_get_position(
table[row_index + 1]) == None):
current_groups[index].add_subject(
row[index + 1], time_start, False, day)
elif (pos == 0):
time_start = row[0]
for index in range(len(row) - 1):
if not (row[index + 1] == ''):
current_groups[index].add_subject(row[index + 1],
time_start, True, day)
if row_index + 1 != len(table):
if check_separate_line(table[row_index + 1], index):
current_groups[index].add_subject(
row[index + 1], time_start, False, day)
elif not (check_even_and_get_position(
table[row_index + 1]) == None):
current_groups[index].add_subject(
row[index + 1], time_start, False, day)
all_groups += current_groups
return all_groups
def AsGroup(self):
return Group(self.objects[:])
