Python collections.Sequence() Examples

The following are code examples for showing how to use collections.Sequence(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: mongodb-monitoring   Author: jruaux   File: helpers.py    (Apache License 2.0) View Source Project 6 votes vote down vote up
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,)) 
Example 2
Project: NeoAnalysis   Author: neoanalysis   File: baseio.py    (license) View Source Project 6 votes vote down vote up
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 ####################### 
Example 3
Project: NeoAnalysis   Author: neoanalysis   File: baseio.py    (license) View Source Project 6 votes vote down vote up
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 ####################### 
Example 4
Project: code   Author: ActiveState   File: recipe-577982.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 5
Project: swjtu-pyscraper   Author: Desgard   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 6
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 7
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 8
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 9
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 10
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: pyparsing.py    (MIT License) View Source Project 6 votes vote down vote up
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 
Example 11
Project: zanph   Author: zanph   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 12
Project: zanph   Author: zanph   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 13
Project: hostapd-mana   Author: adde88   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 14
Project: typecaster   Author: nbedi   File: models.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 15
Project: typecaster   Author: nbedi   File: models.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 16
Project: ramdisk-func-test   Author: openstack   File: __init__.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 17
Project: fold   Author: tensorflow   File: blocks.py    (license) View Source Project 6 votes vote down vote up
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') 
Example 18
Project: artman   Author: googleapis   File: config_util.py    (license) View Source Project 6 votes vote down vote up
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 
Example 19
Project: smrt   Author: smrt-model   File: model.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 20
Project: RPoint   Author: george17-meet   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 21
Project: isni-reconcile   Author: cmh2166   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 22
Project: l1l2py   Author: slipguru   File: scaler.py    (license) View Source Project 6 votes vote down vote up
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 
Example 23
Project: l1l2py   Author: slipguru   File: scaler.py    (license) View Source Project 6 votes vote down vote up
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 
Example 24
Project: threatdetectionservice   Author: flyballlabs   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 25
Project: threatdetectionservice   Author: flyballlabs   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 26
Project: oa_qian   Author: sunqb   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 27
Project: oa_qian   Author: sunqb   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 28
Project: pyventory   Author: lig   File: asset.py    (license) View Source Project 6 votes vote down vote up
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 
Example 29
Project: malmo-challenge   Author: Kaixhin   File: malmo.py    (license) View Source Project 6 votes vote down vote up
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 
Example 30
Project: malmo-challenge   Author: Microsoft   File: malmo.py    (license) View Source Project 6 votes vote down vote up
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 
Example 31
Project: pywhip   Author: inbo   File: validators.py    (license) View Source Project 6 votes vote down vote up
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 
Example 32
Project: CaScale   Author: Thatsillogical   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 33
Project: graynet   Author: raamana   File: utils.py    (license) View Source Project 6 votes vote down vote up
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 
Example 34
Project: ShelbySearch   Author: Agentscreech   File: sqltypes.py    (license) View Source Project 6 votes vote down vote up
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 
Example 35
Project: raspberry-gpio-emulator   Author: nosix   File: GPIO.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 36
Project: pyetje   Author: rorlika   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 37
Project: pyetje   Author: rorlika   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 38
Project: Tencent_Cartoon_Download   Author: Fretice   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 39
Project: Problematica-public   Author: TechMaz   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 40
Project: bawk   Author: jttwnsnd   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 41
Project: aioworkers   Author: aioworkers   File: subprocess.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 42
Project: aioworkers   Author: aioworkers   File: http.py    (license) View Source Project 6 votes vote down vote up
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 
Example 43
Project: Price-Comparator   Author: Thejas-1   File: sqltypes.py    (license) View Source Project 6 votes vote down vote up
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 
Example 44
Project: fieldsight-kobocat   Author: awemulya   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 45
Project: python-peers   Author: Harrisonkamau   File: grade_school_test.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 46
Project: curious   Author: SunDwarf   File: member.py    (license) View Source Project 6 votes vote down vote up
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` 
Example 47
Project: chainer-speech-recognition   Author: musyoku   File: gram_ctc.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 48
Project: sslstrip-hsts-openwrt   Author: adde88   File: pyparsing.py    (license) View Source Project 6 votes vote down vote up
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 
Example 49
Project: covar_me_app   Author: CovarMe   File: helpers.py    (license) View Source Project 6 votes vote down vote up
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,)) 
Example 50
Project: atropos   Author: jdidion   File: base.py    (license) View Source Project 6 votes vote down vote up
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)