Python compat.set函数代码示例

 def _update_pages(self):
     all_pages = WikiSystem(self.env).get_pages()
     self.pages = set([p for p in all_pages if len(p) >= self.minimum_length])
     exclude = set([p.strip() for p in (self.exclude or '') if p.strip()])
     self.pages.difference_update(exclude)
     explicitly_wikified = set([p.strip() for p in (self.explicitly_wikify or '') if p.strip()])
     self.pages.update(explicitly_wikified)

 def sort(self):
     """Do an in-place topological sort of this prototype."""
     from api import TracForgeAdminSystem
     steps = TracForgeAdminSystem(self.env).get_project_setup_participants()
     
     all_provides = set()
     for action, args in self:
         all_provides |= set(steps[action].get('provides', ()))
     
     effective_depends = {}
     for action, args in self:
         # All real deps are always used
         effective_depends.setdefault(action, []).extend(steps[action].get('depends', ()))
         for tag in steps[action].get('optional_depends', ()):
             # Any optional dep that is provided by something else is used
             if tag in all_provides:
                 effective_depends[action].append(tag)
     
     old = set([action for action, args in self])
     new = []
     tags = set()
     for i in xrange(len(self)):
         for action in old:
             self.env.log.debug('TracForge: %s %s %s %s %s', i, action, old, new, tags)
             if all([tag in tags for tag in effective_depends[action]]):
                 new.append(action)
                 tags |= set(steps[action].get('provides', []))
                 old.remove(action)
                 break
         if not old:
             break
     if old:
         raise ValueError('Cant solve')
     action_map = dict(self)
     self[:] = [(action, action_map[action]) for action in new]

    def __init__(self, env, tkt, db=None, ticket_cache=None):
        '''Initialize ticket links
        Use `ticket_cache` (if is not None) to store fetched tickets.
        '''
        self.env = env
        if not isinstance(tkt, Ticket):
            if ticket_cache is not None:
                tid = int(tkt)
                if tid not in ticket_cache:
                    ticket_cache[tid] = Ticket(self.env, tid)
                tkt = ticket_cache[tid]
            else:
                tkt = Ticket(self.env, tkt)
        self.tkt = tkt

        db = db or self.env.get_db_cnx()
        cursor = db.cursor()

        cursor.execute('SELECT dest FROM mastertickets WHERE source=%s ORDER BY dest', (self.tkt.id,))
        self.blocking = set([int(num) for num, in cursor])
        self._old_blocking = copy.copy(self.blocking)

        cursor.execute('SELECT source FROM mastertickets WHERE dest=%s ORDER BY source', (self.tkt.id,))
        self.blocked_by = set([int(num) for num, in cursor])
        self._old_blocked_by = copy.copy(self.blocked_by)

    def get_user_permissions(self, username):
        """Retrieve the permissions for the given user and return them in a
        dictionary.
        
        The permissions are stored in the database as (username, action)
        records. There's simple support for groups by using lowercase names for
        the action column: such a record represents a group and not an actual
        permission, and declares that the user is part of that group.
        """
        subjects = set([username])
        for provider in self.group_providers:
            subjects.update(provider.get_permission_groups(username))

        actions = set([])
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT username,action FROM permission")
        rows = cursor.fetchall()
        while True:
            num_users = len(subjects)
            num_actions = len(actions)
            for user, action in rows:
                if user in subjects:
                    if action.isupper() and action not in actions:
                        actions.add(action)
                    if not action.isupper() and action not in subjects:
                        # action is actually the name of the permission group
                        # here
                        subjects.add(action)
            if num_users == len(subjects) and num_actions == len(actions):
                break
        return list(actions)

    def ticket_deleted(self, tkt):
        db = self.env.get_db_cnx()

        links = TicketLinks(self.env, tkt, db)
        links.blocking = set()
        links.blocked_by = set()
        links.save('trac', 'Ticket #%s deleted' % tkt.id, when=None, db=db)

        db.commit()

 def ticket_changed(self, tkt, comment, author, old_values):
     db = self.env.get_db_cnx()
     
     links = TicketLinks(self.env, tkt, db)
     links.blocking = set(self.NUMBERS_RE.findall(tkt['blocking'] or ''))
     links.blocked_by = set(self.NUMBERS_RE.findall(tkt['blockedby'] or ''))
     links.save(author, comment, tkt.time_changed, db)
     
     db.commit()

    def testSprintTicketStatsChartUsesAliases(self):
        self.env.compmgr.enabled[SprintTicketStatsChartGenerator] = True
        self.teh.create_ticket(Type.USER_STORY, {Key.SPRINT: self.sprint.name})

        get_widget = ChartGenerator(self.env).get_chartwidget
        widget = get_widget(ChartType.SPRINT_TICKET_STATS, sprint_name=self.sprint.name)

        chart_labels = set([item[1] for item in widget.data["labels"]])
        self.assert_equals(set(["User Story", "Task"]), chart_labels)

    def post_process_request(self, req, template, data, content_type):
        if req.path_info.startswith('/ticket/'):
            # In case of an invalid ticket, the data is invalid
            if not data:
                return template, data, content_type
            tkt = data['ticket']
            links = TicketLinks(self.env, tkt)
            
            for i in links.blocked_by:
                if Ticket(self.env, i)['status'] != 'closed':
                    add_script(req, 'mastertickets/disable_resolve.js')
                    break

            # Add link to depgraph if needed
            if links:
                add_ctxtnav(req, 'Depgraph', req.href.depgraph(tkt.id))
            
            for change in data.get('changes', {}):
                if not change.has_key('fields'):
                    continue
                for field, field_data in change['fields'].iteritems():
                    if field in self.fields:
                        if field_data['new'].strip():
                            new = set([int(n) for n in field_data['new'].split(',')])
                        else:
                            new = set()
                        if field_data['old'].strip():
                            old = set([int(n) for n in field_data['old'].split(',')])
                        else:
                            old = set()
                        add = new - old
                        sub = old - new
                        elms = tag()
                        if add:
                            elms.append(
                                tag.em(u', '.join([unicode(n) for n in sorted(add)]))
                            )
                            elms.append(u' added')
                        if add and sub:
                            elms.append(u'; ')
                        if sub:
                            elms.append(
                                tag.em(u', '.join([unicode(n) for n in sorted(sub)]))
                            )
                            elms.append(u' removed')
                        field_data['rendered'] = elms
            
        #add a link to generate a dependency graph for all the tickets in the milestone
        if req.path_info.startswith('/milestone/'):
            if not data:
                return template, data, content_type
            milestone=data['milestone']
            add_ctxtnav(req, 'Depgraph', req.href.depgraph('milestone', milestone.name))


        return template, data, content_type

 def _field_names_for_backlog_types(self):
     field_names = set()
     ticket_config = AgiloConfig(self.env).ticket_configuration
     for type_name in self.ticket_types:
         # don't trust the type_name in self.ticket_types, backlog admin page
         # does not do validation on that
         if type_name not in ticket_config.fieldnames_per_type:
             continue
         fields_for_this_type = ticket_config.fieldnames_per_type[type_name]
         field_names.update(set(fields_for_this_type))
     return field_names

    def post_process_request(self, req, template, origData, content_type):
        if req.path_info.startswith('/newticket'):
            mode = 'new'
        elif req.path_info.startswith('/ticket/'):
            mode = 'view'
        else:
            return template, origData, content_type
        fieldData = {}
        fieldData['condfields'] = {}

        all_fields = []
        standard_fields = set()
        for f in TicketSystem(self.env).get_ticket_fields():
            all_fields.append(f['name'])
            if not f.get('custom'):
                standard_fields.add(f['name'])

        if 'owner' in all_fields:
            curr_idx = all_fields.index('owner')
            if 'cc' in all_fields:
                insert_idx = all_fields.index('cc')
            else:
                insert_idx = len(all_fields)
            if curr_idx < insert_idx:
                all_fields.insert(insert_idx, all_fields[curr_idx])
                del all_fields[curr_idx]

        for t in self.types:
            fieldData['condfields'][t] = self.get_fields(t, all_fields, standard_fields)
            # fields = set(getattr(self, t+'_fields'))
            # if self.include_std:
            #     fields.update(standard_fields)
            # fields.update(self.forced_fields)
            # fieldData['condfields'][t] = dict([
            #     (f, f in fields) for f in all_fields
            # ])

        self.log.debug(all_fields)
        self.log.info(standard_fields)

        fieldData['mode'] = mode
        fieldData['all_fields'] = list(all_fields)
        fieldData['ok_view_fields'] = sorted(set(all_fields) - self.forced_fields,
                                             key=lambda x: all_fields.index(x))
        fieldData['ok_new_fields'] = sorted((set(all_fields) - self.forced_fields) - set(['owner']),
                                            key=lambda x: all_fields.index(x))

        add_script_data(req, fieldData)
        add_script(req, '/condfields.js')
        return template, origData, content_type

    def process_request(self, req):
        data = {}
        ticket_types = {}
        field_types = {}
        mode = req.path_info[12:-3]
        if mode != 'new' and mode != 'view':
            raise TracError('Invalid condfields view')
        all_fields = []
        standard_fields = set()
        for f in TicketSystem(self.env).get_ticket_fields():
            all_fields.append(f['name'])

        field_types[f['name']] = f['type']

        if not f.get('custom'):
            standard_fields.add(f['name'])

        if 'owner' in all_fields:
            curr_idx = all_fields.index('owner')
            if 'cc' in all_fields:
                insert_idx = all_fields.index('cc')
            else:
                insert_idx = len(all_fields)
            if curr_idx < insert_idx:
                all_fields.insert(insert_idx, all_fields[curr_idx])
                del all_fields[curr_idx]

        for t in self.types:
            if not self.show_default:
                hiddenfields = set(getattr(self, t+'_fields'))
                fields = set(all_fields)
                fields.difference_update(hiddenfields)
            else:
                fields = set(getattr(self, t+'_fields'))
                if self.include_std:
                    fields.update(standard_fields)
            fields.update(set(self.forced_fields))
            ticket_types[t] = dict([
                (f, f in fields) for f in all_fields
            ])

        self.log.debug(all_fields)
        self.log.info(standard_fields)

        data['mode'] = mode
        data['types'] = json.dumps(ticket_types)
        data['field_types'] = json.dumps(field_types)
        data['required_fields'] = json.dumps(list(self.forced_fields))

        return 'condfields.js', {'condfields': data}, 'text/plain'

 def _get_metric_groups(self, available_metrics):
     # Some metrics are well known and we show them together in one chart.
     # We have the RT_USP ratio separate because of two reasons:
     #  - it has not much to do with the other charts
     #  - the numbers are much lower so we would need to add a second scale 
     #    which is not yet implemented in the team metrics chart.
     chart_groups = [(Key.ESTIMATED_VELOCITY, Key.VELOCITY), 
                     (Key.CAPACITY, Key.COMMITMENT), 
                     (Key.RT_USP_RATIO, )]
     grouped_metrics = []
     [grouped_metrics.extend(i) for i in chart_groups]
     other_metrics = set(available_metrics).difference(set(grouped_metrics))
     other_metrics = [(i,) for i in other_metrics]
     return chart_groups + other_metrics

    def post_process_request(self, req, template, data, content_type):
        if req.path_info.startswith('/ticket/'):
            tkt = data['ticket']
            links = TicketLinks(self.env, tkt)
            
            for i in links.blocked_by:
                if Ticket(self.env, i)['status'] != 'closed':
                    add_script(req, 'mastertickets/disable_resolve.js')
                    break

            data['mastertickets'] = {
                'field_values': {
                    'blocking': linkify_ids(self.env, req, links.blocking),
                    'blockedby': linkify_ids(self.env, req, links.blocked_by),
                },
            }
            
            # Add link to depgraph if needed
            if links:
                add_ctxtnav(req, 'Depgraph', req.href.depgraph(tkt.id))
            
            for change in data.get('changes', []):
                for field, field_data in change['fields'].iteritems():
                    if field in self.fields:
                        if field_data['new'].strip():
                            new = set([int(n) for n in field_data['new'].split(',')])
                        else:
                            new = set()
                        if field_data['old'].strip():
                            old = set([int(n) for n in field_data['old'].split(',')])
                        else:
                            old = set()
                        add = new - old
                        sub = old - new
                        elms = tag()
                        if add:
                            elms.append(
                                tag.em(u', '.join([unicode(n) for n in sorted(add)]))
                            )
                            elms.append(u' added')
                        if add and sub:
                            elms.append(u'; ')
                        if sub:
                            elms.append(
                                tag.em(u', '.join([unicode(n) for n in sorted(sub)]))
                            )
                            elms.append(u' removed')
                        field_data['rendered'] = elms
            
        return template, data, content_type

    def ticket_changed(self, tkt, comment, author, old_values):
        db = self.env.get_db_cnx()

        links = TicketLinks(self.env, tkt, db)

        old_relations = {'blocking': set([]), 'blockedby': set([])}
        if "blocking" in old_values:
            old_relations['blocking'] = extract_ticket_ids(old_values['blocking'])

        if "blockedby" in old_values:
            old_relations['blockedby'] = extract_ticket_ids(old_values['blockedby'])

        links.save(old_relations, author, comment, tkt.time_changed, db)

        db.commit()

    def ticket_deleted(self, tkt):
        with self.env.db_transaction as db:
            links = CrashDumpTicketLinks(self.env, tkt, db)
            links.crashes = set()
            links.save('trac', 'Ticket #%s deleted'%tkt.id, when=None, db=db)

            db.commit()