:param: sort {id_asc, id_desc, time_asc, time_desc} string
        Docs: https://vk.com/dev/groups.getMembers
975367
def get_members(self, sort='id_asc'):
        
        return self._session.fetch_items("groups.getMembers", User.from_json, 1000, group_id=self.id, sort=sort, fields=User.__slots__ + User.USER_FIELDS)
229286
def sort_func(self, key):
        
        if key == self._KEYS.SCHEMA:
            return 'aaa'
        if key == self._KEYS.NAME:
            return 'aab'
        if key == self._KEYS.SOURCES:
            return 'aac'
        if key == self._KEYS.ALIAS:
            return 'aad'
        if key == self._KEYS.MODELS:
            return 'aae'
        if key == self._KEYS.PHOTOMETRY:
            return 'zzy'
        if key == self._KEYS.SPECTRA:
            return 'zzz'
        return key
141848
function getMembers(index) {
  if (this._members === undefined) {
    this._members = _(getValue(this, 'member') || getValue(this, 'memberOf'))
      .split(/,\s*/)
      .compact()
      .sort(util.compareNatural)
      .value();
  }
  var result = this._members;
  return index === undefined ? result : result[index];
}
753171
def sorted_members(self):
        
        members = collections.OrderedDict()
        required_names = self.metadata.get("required", ())
        for name, shape in self.members.items():
            members[name] = AbShapeMember(name=name, shape=shape, is_required=name in required_names)

        if self.is_output_shape:
            # ResponseMetadata is the first member for all output shapes.
            yield AbShapeMember(
                name="ResponseMetadata",
                shape=self._shape_resolver.get_shape_by_name("ResponseMetadata"),
                is_required=True,
            )

        yield from sorted(members.values(), key=lambda m: not m.is_required)
236977
def group_members(self, group, limit=99999):
        
        url = 'rest/api/1.0/admin/groups/more-members'
        params = {}
        if limit:
            params['limit'] = limit
        if group:
            params['context'] = group
        return (self.get(url, params=params) or {}).get('values')
632856
function mappingMembers(mapping) {
  const { from, to } = mapping
  const memberUris = [ from, to ].filter(Boolean)
    .map(bundle => reduceSet(bundle[memberField(bundle)] || []))
  return [].concat(...memberUris).sort()
}
1032472
def members(key, options = default_paging_options)
      options = default_paging_options.dup.merge!(options)
      if options[:page] < 1
        options[:page] = 1
      end

      if options[:page] > total_pages(key, options[:page_size])
        options[:page] = total_pages(key, options[:page_size])
      end

      index_for_redis = options[:page] - 1
      starting_offset = (index_for_redis * options[:page_size])

      if starting_offset < 0
        starting_offset = 0
      end

      ending_offset = (starting_offset + options[:page_size]) - 1
      Amico.redis.zrevrange(key, starting_offset, ending_offset, :with_scores => false)
    end
528585
def sort(self, **kwargs):
        
        query = {}
        for field in kwargs:
            query[field] = kwargs[field]
        self._q.append({'$sort': query})
        return self
515813
def getmembers(self):
        
        return filter(
            lambda m: not m[0].startswith("__") and not inspect.isfunction(m[1]) and not inspect.ismethod(m[1]),
            inspect.getmembers(self.__class__)
        )
649161
def members(refresh = false)
      @members = nil if refresh
      @members ||= safe_members.sort{|a,b| a.to_s <=> b.to_s}
    end
390217
def group(args):
    
    p = OptionParser(group.__doc__)
    p.set_outfile()

    opts, args = p.parse_args(args)

    if len(args) < 1:
        sys.exit(not p.print_help())

    anchorfiles = args
    groups = Grouper()
    for anchorfile in anchorfiles:
        ac = AnchorFile(anchorfile)
        for a, b, idx in ac.iter_pairs():
            groups.join(a, b)

    logging.debug("Created {0} groups with {1} members.".\
                  format(len(groups), groups.num_members))

    outfile = opts.outfile
    fw = must_open(outfile, "w")
    for g in groups:
        print(",".join(sorted(g)), file=fw)
    fw.close()

    return outfile
941205
def group_memberships(self, group_id, **kwargs):
        ""
        api_path = "/api/v2/groups/{group_id}/memberships.json"
        api_path = api_path.format(group_id=group_id)
        return self.call(api_path, **kwargs)
689045
def process_document(self, doc):
        
        member_descriptions = doc.select_segments("members[*].description")
        members = doc.select_segments("members[*]")

        ignore_before = datetime.datetime(1890, 1, 1)
        ignore_after = datetime.datetime(2500, 10, 10)
        relative_base = datetime.datetime(2018, 1, 1)

        for m_d, m in zip(member_descriptions, members):
            dates = doc.extract(
                self.date_extractor,
                m_d,
                extract_first_date_only=False,  # first valid

                additional_formats=['%Y@%m@%d', '%a %Y, %b %d'],

                use_default_formats=True,

                # ignore_dates_before: datetime.datetime = None,
                ignore_dates_before=ignore_before,

                # ignore_dates_after: datetime.datetime = None,
                ignore_dates_after=ignore_after,

                detect_relative_dates=False,

                relative_base=relative_base,

                # preferred_date_order: str = "MDY",  # used for interpreting ambiguous dates that are missing parts
                preferred_date_order="DMY",

                prefer_language_date_order=True,

                # timezone: str = None,  # default is local timezone.
                # timezone='GMT',

                # to_timezone: str = None,  # when not specified, not timezone conversion is done.
                # to_timezone='UTC',

                # return_as_timezone_aware: bool = True
                return_as_timezone_aware=False,

                # prefer_day_of_month: str = "first",  # can be "current", "first", "last".
                prefer_day_of_month='first',

                # prefer_dates_from: str = "current"  # can be "future", "future", "past".)
                prefer_dates_from='future',

                # date_value_resolution: DateResolution = DateResolution.DAY
            )
            m.store(dates, "related_dates")
        return list()
490140
def members(name, members_list):
    '''
    
    '''
    retcode = 1
    grp_info = __salt__['group.info'](name)
    if grp_info and name in grp_info['name']:
        cmd = '/usr/bin/dscl . -delete /Groups/{0} GroupMembership'.format(name)
        retcode = __salt__['cmd.retcode'](cmd) == 0
        for user in members_list.split(','):
            cmd = '/usr/bin/dscl . -merge /Groups/{0} GroupMembership {1}'.format(name, user)
            retcode = __salt__['cmd.retcode'](cmd)
            if not retcode == 0:
                break
            # provided list is '': users previously deleted from group
            else:
                retcode = 0

    return retcode == 0
1211408
def list_groups(self, scope_ids=None, recurse=None, deleted=None, properties=None):
        
        query_parameters = {}
        if scope_ids is not None:
            query_parameters['scopeIds'] = self._serialize.query('scope_ids', scope_ids, 'str')
        if recurse is not None:
            query_parameters['recurse'] = self._serialize.query('recurse', recurse, 'bool')
        if deleted is not None:
            query_parameters['deleted'] = self._serialize.query('deleted', deleted, 'bool')
        if properties is not None:
            query_parameters['properties'] = self._serialize.query('properties', properties, 'str')
        response = self._send(http_method='GET',
                              location_id='5966283b-4196-4d57-9211-1b68f41ec1c2',
                              version='5.0',
                              query_parameters=query_parameters)
        return self._deserialize('[Identity]', self._unwrap_collection(response))
228367
def get_oneline_doc(self) -> str:
        
        attr = self.attr_obj
        if self.display_group == AttrCategory.DESCRIPTOR:
            if isinstance(attr, property):
                doc_list = ['@property with getter']
                if attr.fset:
                    doc_list.append(SETTER)
                if attr.fdel:
                    doc_list.append(DELETER)
            else:
                doc_list = ['class %s' % attr.__class__.__name__]
                if hasattr(attr, '__get__'):
                    doc_list.append(GETTER)
                if hasattr(attr, '__set__'):
                    doc_list.append(SETTER)
                if hasattr(attr, '__delete__'):
                    doc_list.append(DELETER)
                doc_list[0] = ' '.join([doc_list[0], 'with', doc_list.pop(1)])
            if attr.__doc__ is not None:
                doc_list.append(inspect.getdoc(attr).split('\n', 1)[0])
            return ', '.join(doc_list)

        if hasattr(attr, '__doc__'):
            doc = inspect.getdoc(attr)
            return doc.split('\n', 1)[0] if doc else ''  # default doc is None
        return ''
1349301
def get_document_list(self):
        
        try:
            return self.__dict__['document_list']
        except KeyError:
            obj_list = DocumentSet([
                self._connection.documents.get(i) for i in self.document_ids
            ])
            self.__dict__['document_list'] = obj_list
            return obj_list