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[:])