Python collections.Sequence() Examples

def _fields_list_to_dict(fields, option_name):
    """Takes a sequence of field names and returns a matching dictionary.

    ["a", "b"] becomes {"a": 1, "b": 1}

    and

    ["a.b.c", "d", "a.c"] becomes {"a.b.c": 1, "d": 1, "a.c": 1}
    """
    if isinstance(fields, collections.Mapping):
        return fields

    if isinstance(fields, collections.Sequence):
        if not all(isinstance(field, string_type) for field in fields):
            raise TypeError("%s must be a list of key names, each an "
                            "instance of %s" % (option_name,
                                                string_type.__name__))
        return dict.fromkeys(fields, 1)

    raise TypeError("%s must be a mapping or "
                    "list of key names" % (option_name,)) 

def write(self, bl, **kargs):
        if Block in self.writeable_objects:
            if isinstance(bl, collections.Sequence):
                assert hasattr(self, 'write_all_blocks'), \
                    '%s does not offer to store a sequence of blocks' % \
                    self.__class__.__name__
                self.write_all_blocks(bl, **kargs)
            else:
                self.write_block(bl, **kargs)
        elif Segment in self.writeable_objects:
            assert len(bl.segments) == 1, \
                '%s is based on segment so if you try to write a block it ' + \
                'must contain only one Segment' % self.__class__.__name__
            self.write_segment(bl.segments[0], **kargs)
        else:
            raise NotImplementedError

    ######## All individual read methods ####################### 

def write(self, bl, **kargs):
        if Block in self.writeable_objects:
            if isinstance(bl, collections.Sequence):
                assert hasattr(self, 'write_all_blocks'), \
                    '%s does not offer to store a sequence of blocks' % \
                    self.__class__.__name__
                self.write_all_blocks(bl, **kargs)
            else:
                self.write_block(bl, **kargs)
        elif Segment in self.writeable_objects:
            assert len(bl.segments) == 1, \
                '%s is based on segment so if you try to write a block it ' + \
                'must contain only one Segment' % self.__class__.__name__
            self.write_segment(bl.segments[0], **kargs)
        else:
            raise NotImplementedError

    ######## All individual read methods ####################### 

def objwalk(obj, path=(), memo=None):
    if memo is None:
        memo = set()
    iterator = None
    if isinstance(obj, Mapping):
        iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
        iterator = enumerate
    if iterator:
        if id(obj) not in memo:
            memo.add(id(obj))
            for path_component, value in iterator(obj):
                for result in objwalk(value, path + (path_component,), memo):
                    yield result
            memo.remove(id(obj))
    else:
        yield path, obj

# optional test code from here on 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def publish(self, titles):
        """
        Publish a set of episodes to the Podcast's RSS feed.

        :param titles:
            Either a single episode title or a sequence of episode titles to
            publish.
        """
        if isinstance(titles, Sequence) and not isinstance(titles, six.string_types):
            for title in titles:
                self.episodes[title].publish()
        elif isinstance(titles, six.string_types):
            self.episodes[titles].publish()
        else:
            raise TypeError('titles must be a string or a sequence of strings.')

        self.update_rss_feed() 

def unpublish(self, titles):
        """
        Unpublish a set of episodes to the Podcast's RSS feed.

        :param titles:
            Either a single episode title or a sequence of episode titles to
            publish.
        """
        if isinstance(titles, Sequence) and not isinstance(titles, six.string_types):
            for title in titles:
                self.episodes[title].unpublish()
        elif isinstance(titles, six.string_types):
            self.episodes[titles].unpublish()
        else:
            raise TypeError('titles must be a string or a sequence of strings.')

        self.update_rss_feed() 

def setUpClass(cls):
        template_path = []
        template_uniq = set()
        for member in cls.__mro__:
            try:
                path = member._rft_template_path
            except AttributeError:
                continue

            if isinstance(path, basestring):
                path = [path]
            elif isinstance(path, collections.Sequence):
                pass
            else:
                path = [path]

            uniq_path = set(path) - template_uniq
            template_uniq.update(uniq_path)
            template_path.extend(x for x in path if x in uniq_path)

        cls.env = environment.Environment(template_path, cls._rft_config_path)
        cls.env.setupclass()

        super(TestCaseMixin, cls).setUpClass() 

def Slice(*args, **kwargs):  # pylint: disable=invalid-name
  """A block which applies Python slicing to a PyObject, Tuple, or Sequence.

  For example, to reverse a sequence:
  ```python
  (Map(Scalar()) >> Slice(step=-1)).eval(range(5)) => [4, 3, 2, 1, 0]
  ```

  Positional arguments are not accepted in order to avoid the ambiguity
  of slice(start=N) vs. slice(stop=N).

  Args:
    *args: Positional arguments; must be empty (see above).
    **kwargs: Keyword arguments; `start=None, stop=None, step=None, name=None`.

  Returns:
    The block.
  """
  if args:
    raise TypeError('Slice does not accept positional arguments; allowed '
                    'keyword arguments are start, stop, and step')
  name = kwargs.pop('name', None)
  return GetItem(_get_slice(**kwargs), name=name).set_constructor_name(
      'td.Slice') 

def replace_vars(data, repl_vars):
    """Return the given data structure with appropriate variables replaced.

    Args:
        data (Any): Data of an arbitrary type.

    Returns:
        Any: Data of the same time, possibly with replaced values.
    """
    if isinstance(data, (six.text_type, six.binary_type)):
        for k, v in repl_vars.items():
            data = data.replace('${' + k + '}', v)
        return data
    if isinstance(data, collections.Sequence):
        return type(data)([replace_vars(d, repl_vars) for d in data])
    if isinstance(data, collections.Mapping):
        return type(data)([(k, replace_vars(v, repl_vars))
                           for k, v in data.items()])
    return data 

def __init__(self, emmodel, rtsolver, emmodel_kwargs=None, rtsolver_kwargs=None):
        """create a new model. It is not recommanded to instantiate Model class directly. Instead use the :py:meth:`make_model` function.
        """

        # emmodel can be a single value (class or string) or an array with the same size as snowpack layers array
        if isinstance(emmodel, collections.Sequence) and not isinstance(emmodel, six.string_types):
            self.emmodel = [get_emmodel(em) for em in emmodel]
        else:
            self.emmodel = get_emmodel(emmodel)

        if isinstance(rtsolver, six.string_types):
            self.rtsolver = import_class(rtsolver, root='smrt.rtsolver')
        else:
            self.rtsolver = rtsolver

        # The implementation avoid metaclass by supplying an optional list of arguments to the emmodel and rtsolver
        # to alter the behavior the emmodel (or rtsolver)
        # this is not the most general case, but metaclass can still be used for advanced user
        self.emmodel_kwargs = emmodel_kwargs if emmodel_kwargs is not None else dict()
        self.rtsolver_kwargs = rtsolver_kwargs if rtsolver_kwargs is not None else dict() 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def tau_range(self, trange):
        """Return a scaled tau range.

        Tau scaling factor is the maximum tau value to avoid and empty solution
        (where all variables are discarded).
        The value is estimated on the maximum correlation between data and
        labels.

        Parameters
        ----------
        trange : :class:`numpy.ndarray`
            Tau range containing relative values (expected maximum is lesser
            than 1.0 and minimum greater than 0.0).

        Returns
        -------
        tau_range : :class:`numpy.ndarray`
            Scaled tau range.
        """
        if np.max(trange) >= 1.0 or np.min(trange) < 0.0:
            raise ValueError('Relative tau should be in [0,1)')
        if isinstance(trange, Sequence):
            trange = np.sort(trange)
        return trange * self.tau_scaling_factor 

def mu_range(self, mrange):
        """Return a scaled mu range.

        Mu scaling factor is estimated on the maximum eigenvalue of the
        correlation matrix and is used to simplify the parameters choice.

        Parameters
        ----------
        mrange : :class:`numpy.ndarray`
            Mu range containing relative values (expected maximum is lesser
            than 1.0 and minimum greater than 0.0).

        Returns
        -------
        mu_range : :class:`numpy.ndarray`
            Scaled mu range.
        """
        if np.min(mrange) < 0.0:
            raise ValueError('Relative mu should be greater than / equal to 0')

        if isinstance(mrange, Sequence):
            mrange = np.sort(mrange)
        return mrange * self.mu_scaling_factor 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __format_value(cls, value, context, start_key):
        if value is NotImplemented:
            raise NotImplementedError
        if isinstance(value, six.string_types):
            for key in cls._string_format_regex.findall(value):
                if key == start_key:
                    raise errors.ValueSubstitutionInfiniteLoopError
                context[key] = cls.__format_value(
                    context[key], context, start_key)
            return value.format(**context)
        if isinstance(value, Mapping):
            return OrderedDict(
                (k, cls.__format_value(v, context, start_key)) for k, v in value.items())
        if isinstance(value, Sequence):
            return [cls.__format_value(v, context, start_key) for v in value]
        return value 

def allocate_remotes(remotes):
    """
    Utility method for building a Malmo ClientPool.
    Using this method allows sharing the same ClientPool across
    mutiple experiment
    :param remotes: tuple or array of tuples. Each tuple can be (), (ip,), (ip, port)
    :return: Malmo ClientPool with all registered clients
    """
    if not isinstance(remotes, list):
        remotes = [remotes]

    pool = ClientPool()
    for remote in remotes:
        if isinstance(remote, ClientInfo):
            pool.add(remote)
        elif isinstance(remote, Sequence):
            if len(remote) == 0:
                pool.add(ClientInfo('localhost', 10000))
            elif len(remote) == 1:
                pool.add(ClientInfo(remote[0], 10000))
            else:
                pool.add(ClientInfo(remote[0], int(remote[1])))
    return pool 

def allocate_remotes(remotes):
    """
    Utility method for building a Malmo ClientPool.
    Using this method allows sharing the same ClientPool across
    mutiple experiment
    :param remotes: tuple or array of tuples. Each tuple can be (), (ip,), (ip, port)
    :return: Malmo ClientPool with all registered clients
    """
    if not isinstance(remotes, list):
        remotes = [remotes]

    pool = ClientPool()
    for remote in remotes:
        if isinstance(remote, ClientInfo):
            pool.add(remote)
        elif isinstance(remote, Sequence):
            if len(remote) == 0:
                pool.add(ClientInfo('localhost', 10000))
            elif len(remote) == 1:
                pool.add(ClientInfo(remote[0], 10000))
            else:
                pool.add(ClientInfo(remote[0], int(remote[1])))
    return pool 

def _resolve_coerce(self, schema):
        """add coerce rules to convert datatypes of int and float,
        recusively using the rules combinations of cerberus:
        {TERM : {RULE: --> str (STOP)
                       --> list/Sequence --> str (STOP)
                                         --> dict => (if type: ADD) + RECALL
                       --> dict/Mapping => (if type: ADD) + RECALL
                      }}
        """
        for term, rules in schema.items():
            if isinstance(rules, _str_type):
                continue
            elif isinstance(rules, Sequence):
                for subschema in rules:
                    if isinstance(subschema, Mapping):
                        if 'type' in subschema.keys():
                            self._add_coerce(subschema)
                        self._resolve_coerce(subschema)
            elif isinstance(rules, Mapping):
                if 'type' in rules.keys():
                    self._add_coerce(rules)
                self._resolve_coerce(rules)
            else:
                NotImplemented 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def check_edge_range(edge_range_spec):
    "Validates the edge rage specified"

    if edge_range_spec is None:
        edge_range = edge_range_spec
    elif isinstance(edge_range_spec, (collections.Sequence, np.ndarray)):
        if len(edge_range_spec) != 2:
            raise ValueError('edge_range must be a tuple of two values: (min, max)')
        if edge_range_spec[0] >= edge_range_spec[1]:
            raise ValueError('edge_range : min {} is not less than max {} !'.format(edge_range_spec[0], edge_range_spec[1]))

        # CLI args are strings unless converted to numeric
        edge_range = np.float64(edge_range_spec)
        if not np.all(np.isfinite(edge_range)):
            raise ValueError('Infinite or NaN values in edge range : {}'.format(edge_range_spec))

        # converting it to tuple to make it immutable
        edge_range = tuple(edge_range)
    else:
        raise ValueError('Invalid edge range! Must be a tuple of two values (min, max)')

    return edge_range 

def _setup_getitem(self, default_comparator, index):
            if not isinstance(index, util.string_types) and \
                    isinstance(index, collections.Sequence):
                index = default_comparator._check_literal(
                    self.expr, operators.json_path_getitem_op,
                    index, bindparam_type=JSON.JSONPathType
                )

                operator = operators.json_path_getitem_op
            else:
                index = default_comparator._check_literal(
                    self.expr, operators.json_getitem_op,
                    index, bindparam_type=JSON.JSONIndexType
                )
                operator = operators.json_getitem_op

            return operator, index, self.type 

def output(channel, outmode):
    # type: (int or Sequence[int], int or bool or Sequence[int] or Sequence[bool]) -> None
    __check_mode()

    if isinstance(channel, Sequence):
        def zip_outmode():
            # type: () -> Sequence[tuple]
            if isinstance(outmode, Sequence):
                assert len(channel) == len(outmode)
                return zip(channel, outmode)
            else:
                return zip(channel, [outmode] * len(channel))

        for (c, m) in zip_outmode():
            __output(__to_channel(c), m)
    else:
        __output(__to_channel(channel), outmode) 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def make_command(self, value):
        cmd = self.config.get('cmd')
        if value is None:
            return cmd,
        elif not cmd and isinstance(value, Sequence):
            return value
        elif not cmd and isinstance(value, str):
            return value,
        elif isinstance(cmd, list) and isinstance(value, str):
            return cmd + [value]
        elif isinstance(cmd, list) and isinstance(value, Sequence):
            result = list(cmd)
            result.extend(value)
            return result
        elif isinstance(cmd, list) and isinstance(value, Mapping):
            return [i.format_map(value) for i in cmd]
        elif isinstance(cmd, str) and isinstance(value, str):
            return self.config.cmd + ' ' + value,
        elif isinstance(cmd, str) and isinstance(value, Mapping):
            return self.config.cmd.format_map(value),
        elif isinstance(cmd, str) and isinstance(value, Sequence):
            return self.config.cmd.format(*value),
        else:
            raise ValueError(value) 

def raw_key(self, key):
        if self._prefix:
            url = self._prefix / key
        elif self._template and isinstance(key, Mapping):
            url = URL(self._template.format_map(key))
        elif self._template and isinstance(key, Sequence):
            url = URL(self._template.format(*key))
        elif self._template:
            url = URL(self._template.format(key))
        elif isinstance(key, str):
            url = URL(key)
        else:
            url = key
        if self._allow_hosts and url.host not in self._allow_hosts:
            raise KeyError(key)
        return url 

def _setup_getitem(self, default_comparator, index):
            if not isinstance(index, util.string_types) and \
                    isinstance(index, collections.Sequence):
                index = default_comparator._check_literal(
                    self.expr, operators.json_path_getitem_op,
                    index, bindparam_type=JSON.JSONPathType
                )

                operator = operators.json_path_getitem_op
            else:
                index = default_comparator._check_literal(
                    self.expr, operators.json_getitem_op,
                    index, bindparam_type=JSON.JSONIndexType
                )
                operator = operators.json_getitem_op

            return operator, index, self.type 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def test_sort_school(self):

        students = [
            (3, ("Kyle",)),
            (4, ("Christopher", "Jennifer",)),
            (6, ("Kareem",))
        ]
        for grade, students_in_grade in students:
            for student in students_in_grade:
                self.school.add(student, grade)

        result = self.school.sort()

        # Attempts to catch false positives
        self.assertTrue(isinstance(result, Sequence) or
                        isinstance(result, GeneratorType) or
                        callable(getattr(result, '__reversed__', False)))

        result_list = list(result.items() if hasattr(result, "items")
                           else result)

        self.assertEqual(result_list, students) 

def _sorted_roles(self) -> 'List[dt_role.Role]':
        if not self._member.guild:
            return []

        roles = []
        for id in self._member.role_ids:
            try:
                roles.append(self._member.guild.roles[id])
            except (KeyError, AttributeError):
                pass

        return sorted(roles)

    # opt: the default Sequence makes us re-create the sorted role list constantly
    # we don't wanna cache it, without introducing invalidation hell
    # so we just put `__iter__` on `_sorted_roles` 

def gram_ctc(xs, label_unigram, label_bigram, blank_symbol, input_length=None, length_unigram=None, reduce='mean'):
	if not isinstance(xs, collections.Sequence):
		raise TypeError('xs must be a list of Variables')
	if not isinstance(blank_symbol, int):
		raise TypeError('blank_symbol must be non-negative integer.')
	assert blank_symbol >= 0
	assert blank_symbol < xs[0].shape[1]
	assert len(xs[0].shape) == 2
	assert label_unigram.shape[1] == label_bigram.shape[1]

	if input_length is None:
		xp = cuda.get_array_module(xs[0].data)
		input_length = variable.Variable(xp.full((len(xs[0].data),), len(xs), dtype=np.int32))
		length_unigram = variable.Variable(xp.full((len(label_unigram.data),), len(label_unigram.data[0]), dtype=np.int32))

	return GramCTC(blank_symbol, reduce)(input_length, length_unigram, label_unigram, label_bigram, *xs) 

def __init__( self, exprs, savelist = False ):
        super(ParseExpression,self).__init__(savelist)
        if isinstance( exprs, _generatorType ):
            exprs = list(exprs)

        if isinstance( exprs, basestring ):
            self.exprs = [ Literal( exprs ) ]
        elif isinstance( exprs, collections.Sequence ):
            # if sequence of strings provided, wrap with Literal
            if all(isinstance(expr, basestring) for expr in exprs):
                exprs = map(Literal, exprs)
            self.exprs = list(exprs)
        else:
            try:
                self.exprs = list( exprs )
            except TypeError:
                self.exprs = [ exprs ]
        self.callPreparse = False 

def _fields_list_to_dict(fields, option_name):
    """Takes a sequence of field names and returns a matching dictionary.

    ["a", "b"] becomes {"a": 1, "b": 1}

    and

    ["a.b.c", "d", "a.c"] becomes {"a.b.c": 1, "d": 1, "a.c": 1}
    """
    if isinstance(fields, collections.Mapping):
        return fields

    if isinstance(fields, collections.Sequence):
        if not all(isinstance(field, string_type) for field in fields):
            raise TypeError("%s must be a list of key names, each an "
                            "instance of %s" % (option_name,
                                                string_type.__name__))
        return dict.fromkeys(fields, 1)

    raise TypeError("%s must be a mapping or "
                    "list of key names" % (option_name,)) 

def _post_process_dict(self, dict_val):
        if dict_val is None:
            return
        for key, value in tuple(dict_val.items()):
            if value is None:
                continue
            if isinstance(value, Summarizable):
                dict_val[key] = value = value.summarize()
            if isinstance(value, dict):
                self._post_process_dict(value)
            elif (
                    isinstance(value, Sequence) and
                    len(value) > 0 and
                    all(
                        val is None or isinstance(val, dict)
                        for val in value)):
                for val in value:
                    self._post_process_dict(val)
            else:
                if isinstance(value, Const):
                    dict_val[key] = value = value.value
                self._post_process_other(dict_val, key, value)