Example #1
0
def to_dtype_dformat(data):
    """Transforms the given data parameter (string/ or sequence of string or
    sequence of sequence of string/:obj:`DataType`) into a tuple of two
    elements (:obj:`DataType`, :obj:`DataFormat`).
    
    :param data: the data information to be transformed
    :type data: str or seq<str> or seq<seq<str>>
    :return: a tuple <:obj:`DataType`, :obj:`DataFormat`> for the given data
    :rtype: tuple<:obj:`DataType`, :obj:`DataFormat`>
    """
    import operator
    dtype, dformat = data, DataFormat.Scalar
    if isinstance(data, (str, unicode)):
        dtype, dformat = from_dtype_str(data)
    elif operator.isSequenceType(data):
        dformat = DataFormat.OneD
        dtype = data[0]
        if type(dtype) == str:
            dtype, dformat2 = from_dtype_str(dtype)
            if dformat2 == DataFormat.OneD:
                dformat = DataFormat.TwoD
        elif operator.isSequenceType(dtype):
            dformat = DataFormat.TwoD
            dtype = dtype[0]
            if type(dtype) == str:
                dtype, _ = from_dtype_str(dtype)
    dtype = DTYPE_MAP.get(dtype, DataType.Invalid)
    return dtype, dformat
Example #2
0
    def _fitdata_fired(self,new):
        from operator import isSequenceType,isMappingType

        if self.model is not None:
            if isSequenceType(new) and len(new) == 2:
                kw={'x':new[0],'y':new[1]}
            elif isSequenceType(new) and len(new) == 3:
                kw={'x':new[0],'y':new[1],'weights':new[2]}
            elif isMappingType(new):
                kw = dict(new)

                #add any missing pieces
                for i,k in enumerate(('x','y','weights')):
                    if k not in new:
                        if self.model.fiteddata:
                            new[k] = self.model.fiteddata[i]
                        else:
                            raise ValueError('no pre-fitted data available')
            elif new is True:
                if self.model.fiteddata:
                    fd = self.model.fiteddata
                    kw= {'x':fd[0],'y':fd[1],'weights':fd[2]}
                else:
                    raise ValueError('No data to fit')
            else:
                raise ValueError('unusable fitdata event input')

            if 'fixedpars' not in kw:
                 kw['fixedpars'] = [tn.replace('fixfit_','') for tn in self.traits() if tn.startswith('fixfit_') if getattr(self,tn)]
            try:
                self.model.fitData(**kw)
                self.updatetraitparams = True
                self.lastfitfailure = None
            except Exception,e:
                self.lastfitfailure = e
Example #3
0
    def __init__(self, call, attribs=None, argfilter=None, expand_args=True,
                 copy_attribs=True):
        """Initialize

        :Parameters:
          expand_args : bool
            Either to expand the output of looper into a list of arguments for
            call
          attribs : list of basestr
            What attributes of call to store and return later on?
          copy_attribs : bool
            Force copying values of attributes
        """

        self.call = call
        """Call which gets called in the harvester."""

        if attribs is None:
            attribs = []
        if not isSequenceType(attribs):
            raise ValueError, "'attribs' have to specified as a sequence."

        if not (argfilter is None or isSequenceType(argfilter)):
            raise ValueError, "'argfilter' have to be a sequence or None."

        # now give it to me...
        self.argfilter = argfilter
        self.expand_args = expand_args
        self.copy_attribs = copy_attribs
        self.attribs = attribs
 def test_isSequenceType(self):
     self.failUnlessRaises(TypeError, operator.isSequenceType)
     self.failUnless(operator.isSequenceType(dir()))
     self.failUnless(operator.isSequenceType(()))
     self.failUnless(operator.isSequenceType(xrange(10)))
     self.failUnless(operator.isSequenceType('yeahbuddy'))
     self.failIf(operator.isSequenceType(3))
Example #5
0
 def test_isSequenceType(self):
     self.failUnlessRaises(TypeError, operator.isSequenceType)
     self.failUnless(operator.isSequenceType(dir()))
     self.failUnless(operator.isSequenceType(()))
     self.failUnless(operator.isSequenceType(xrange(10)))
     self.failUnless(operator.isSequenceType('yeahbuddy'))
     self.failIf(operator.isSequenceType(3))
Example #6
0
def to_dtype_dformat(data):
    """Transforms the given data parameter (string/ or sequence of string or
    sequence of sequence of string/:obj:`DataType`) into a tuple of two
    elements (:obj:`DataType`, :obj:`DataFormat`).

    :param data: the data information to be transformed
    :type data: :obj:`str` or seq<str> or seq<seq<str>>
    :return: a tuple <:obj:`DataType`, :obj:`DataFormat`> for the given data
    :rtype: tuple<:obj:`DataType`, :obj:`DataFormat`>
    """
    import operator
    dtype, dformat = data, DataFormat.Scalar
    if isinstance(data, (str, unicode)):
        dtype, dformat = from_dtype_str(data)
    elif operator.isSequenceType(data):
        dformat = DataFormat.OneD
        dtype = data[0]
        if isinstance(dtype, str):
            dtype, dformat2 = from_dtype_str(dtype)
            if dformat2 == DataFormat.OneD:
                dformat = DataFormat.TwoD
        elif operator.isSequenceType(dtype):
            dformat = DataFormat.TwoD
            dtype = dtype[0]
            if isinstance(dtype, str):
                dtype, _ = from_dtype_str(dtype)
    dtype = DTYPE_MAP.get(dtype, DataType.Invalid)
    return dtype, dformat
Example #7
0
    def __setitem__(self, index, W):
        """
        Speed-up if x is a sparse matrix.
        TODO: checks (first remove the data).
        TODO: once we've got this working in all cases, should we submit to scipy?
        """
        try:
            i, j = index
        except (ValueError, TypeError):
            raise IndexError, "invalid index"

        if isinstance(i, slice) and isinstance(j, slice) and\
               (i.step is None) and (j.step is None) and\
               (isinstance(W, sparse.lil_matrix) or isinstance(W, numpy.ndarray)):
            rows = self.rows[i]
            datas = self.data[i]
            j0 = j.start
            if isinstance(W, sparse.lil_matrix):
                for row, data, rowW, dataW in izip(rows, datas, W.rows,
                                                   W.data):
                    jj = bisect.bisect(row, j0)  # Find the insertion point
                    row[jj:jj] = [j0 + k for k in rowW]
                    data[jj:jj] = dataW
            elif isinstance(W, ndarray):
                nq = W.shape[1]
                for row, data, rowW in izip(rows, datas, W):
                    jj = bisect.bisect(row, j0)  # Find the insertion point
                    row[jj:jj] = range(j0, j0 + nq)
                    data[jj:jj] = rowW
        elif isinstance(i, int) and isinstance(j,
                                               (list, tuple, numpy.ndarray)):
            if len(j) == 0:
                return
            row = dict(izip(self.rows[i], self.data[i]))
            try:
                row.update(dict(izip(j, W)))
            except TypeError:
                row.update(dict(izip(j, itertools.repeat(W))))
            items = row.items()
            items.sort()
            row, data = izip(*items)
            self.rows[i] = list(row)
            self.data[i] = list(data)
        elif isinstance(i, slice) and isinstance(j, int) and isSequenceType(W):
            # This corrects a bug in scipy sparse matrix as of version 0.7.0, but
            # it is not efficient!
            for w, k in izip(W, xrange(*i.indices(self.shape[0]))):
                sparse.lil_matrix.__setitem__(self, (k, j), w)
        elif isinstance(i, int) and isinstance(
                j, slice) and (isNumberType(W) and not isSequenceType(W)):
            # this fixes a bug in scipy 0.7.1
            sparse.lil_matrix.__setitem__(
                self, index, [W] * len(xrange(*j.indices(self.shape[1]))))
        elif isinstance(i, slice) and isinstance(j, slice) and isNumberType(W):
            n = len(xrange(*i.indices(self.shape[0])))
            m = len(xrange(*j.indices(self.shape[1])))
            sparse.lil_matrix.__setitem__(self, index, W * numpy.ones((n, m)))
        else:
            sparse.lil_matrix.__setitem__(self, index, W)
    def setup_analog_scan(self,
                          channels=(0, 1, 2, 3),
                          sweeps=-1,
                          rate=100,
                          gains=GAIN2_DIFF,
                          exttrig=0):

        if self.scanning:
            raise MeasurementComputingError, "cannot start new scan without stopping old one"

        if not isSequenceType(channels):
            channels = (channels, )
        if not isSequenceType(gains):
            gains = (gains, ) * len(channels)

        if len(gains) != len(channels):
            raise MeasurementComputingError, \
                "gain list not compatible with channel list" + str(channels) + ":" + str(gains)

        self.setup_gain_list(channels, gains)

        timerPre, timerVal, setupTime, actRate = self.compute_timer_vals(
            rate * len(channels))

        self.actRate = actRate

        if sweeps <= 0:  # continuous scan !
            blocking = self.DATA_SAMPLE_SIZE // len(channels)
            if len(channels) * blocking != self.DATA_SAMPLE_SIZE:
                raise MeasurementComputingError, \
                    "continuous scan channel count must be submultiple of %d" % self.DATA_SAMPLE_SIZE
            tCount = self.DATA_SAMPLE_SIZE  # each block is filled in continuous mode
            scanmode = self.AD_CONT_MODE

        elif sweeps == 1:  # use AD_SINGLEEXEC mode for single sweep
            tCount = len(channels)
            scanmode = self.AD_SINGLE_MODE

        else:
            # round block count up to next block above requested samples
            blocks = (len(channels) * sweeps + self.DATA_SAMPLE_SIZE -
                      1) // self.DATA_SAMPLE_SIZE
            tCount = blocks * self.DATA_SAMPLE_SIZE
            if tCount > self.MAX_STORED_SAMPLES:
                raise MeasurementComputingError, \
                    "burst scan sample count must be <  %d" % self.MAX_STORED_SAMPLES
            scanmode = self.AD_BURST_MODE
            self.burst_scan_count = tCount
            self.burst_scan_blocks = blocks

        tChigh = tCount >> 8
        tClow = tCount & 255
        self.write((self.CBAINSCAN, tClow, tChigh, timerVal + setupTime,
                    timerPre, scanmode
                    | exttrig))
        self.continuous_scan_packet_index = 1
        self.got_last_packet = 1
        self.last_packet_time = 0.0  # long ago!
        self.packet_dt = self.DATA_SAMPLE_SIZE / actRate
Example #9
0
 def merge_undo ( self, undo_item ):
     """ Merges two undo items if possible.
     """
     # Undo items are potentially mergeable only if they are of the same 
     # class and refer to the same object trait, so check that first:
     if (isinstance( undo_item, self.__class__ ) and
        (self.object is undo_item.object) and
        (self.name == undo_item.name)):
         v1 = self.new_value
         v2 = undo_item.new_value
         t1 = type( v1 )
         if t1 is type( v2 ):
             
             if t1 is str:
                 # Merge two undo items if they have new values which are 
                 # strings which only differ by one character (corresponding 
                 # to a single character insertion, deletion or replacement 
                 # operation in a text editor): 
                 n1 = len( v1 )
                 n2 = len( v2 )
                 n  = min( n1, n2 )
                 i  = 0
                 while (i < n) and (v1[i] == v2[i]): 
                     i += 1
                 if v1[i + (n2 <= n1):] == v2[i + (n2 >= n1):]:
                     self.new_value = v2
                     return True
                 
             elif isSequenceType( v1 ):
                 # Merge sequence types only if a single element has changed
                 # from the 'original' value, and the element type is a 
                 # simple Python type:
                 v1 = self.old_value
                 if isSequenceType( v1 ):
                     # Note: wxColour says it's a sequence type, but it
                     # doesn't support 'len', so we handle the exception
                     # just in case other classes have similar behavior:
                     try:
                         if len( v1 ) == len( v2 ):
                             diffs = 0
                             for i, item in enumerate( v1 ):
                                 titem = type( item )
                                 item2 = v2[i]
                                 if ((titem not in SimpleTypes)   or
                                     (titem is not type( item2 )) or
                                     (item != item2)):
                                     diffs += 1
                                     if diffs >= 2:
                                         return False
                             self.new_value = v2
                             return True
                     except:
                         pass
                     
             elif t1 in NumericTypes:
                 # Always merge simple numeric trait changes: 
                 self.new_value = v2
                 return True
     return False
Example #10
0
    def merge_undo(self, undo_item):
        """ Merges two undo items if possible.
        """
        # Undo items are potentially mergeable only if they are of the same
        # class and refer to the same object trait, so check that first:
        if (
            isinstance(undo_item, self.__class__)
            and (self.object is undo_item.object)
            and (self.name == undo_item.name)
        ):
            v1 = self.new_value
            v2 = undo_item.new_value
            t1 = type(v1)
            if t1 is type(v2):

                if t1 is str:
                    # Merge two undo items if they have new values which are
                    # strings which only differ by one character (corresponding
                    # to a single character insertion, deletion or replacement
                    # operation in a text editor):
                    n1 = len(v1)
                    n2 = len(v2)
                    n = min(n1, n2)
                    i = 0
                    while (i < n) and (v1[i] == v2[i]):
                        i += 1
                    if v1[i + (n2 <= n1) :] == v2[i + (n2 >= n1) :]:
                        self.new_value = v2
                        return True

                elif isSequenceType(v1):
                    # Merge sequence types only if a single element has changed
                    # from the 'original' value, and the element type is a
                    # simple Python type:
                    v1 = self.old_value
                    if isSequenceType(v1):
                        # Note: wxColour says it's a sequence type, but it
                        # doesn't support 'len', so we handle the exception
                        # just in case other classes have similar behavior:
                        try:
                            if len(v1) == len(v2):
                                diffs = 0
                                for i, item in enumerate(v1):
                                    titem = type(item)
                                    item2 = v2[i]
                                    if (titem not in SimpleTypes) or (titem is not type(item2)) or (item != item2):
                                        diffs += 1
                                        if diffs >= 2:
                                            return False
                                self.new_value = v2
                                return True
                        except:
                            pass

                elif t1 in NumericTypes:
                    # Always merge simple numeric trait changes:
                    self.new_value = v2
                    return True
        return False
Example #11
0
def _flatten(seq):
    from operator import isSequenceType
    if not isSequenceType(seq): return seq
    while isSequenceType(seq):
        if type(item) in (TupleType, ListType):
            res.extend(flatten(item))
        else:
            res.append(item)
    return res
Example #12
0
def _flatten(seq):
    from operator import isSequenceType
    if not isSequenceType(seq): return seq
    while isSequenceType(seq):
        if type(item) in (TupleType, ListType):
            res.extend(flatten(item))
        else:
            res.append(item)
    return res
Example #13
0
    def test_01_RequestCACerts(self):

        cacert = self.proxy.RetrieveCACertificates()

        self.failUnless(operator.isSequenceType(cacert),
                        "RetrieveCACertificate returns a non-sequence")

        self.failUnless(
            len(cacert) == 2,
            "RetrieveCACertificate returns a tuple of len != 2")

        self.failUnless(
            type(cacert[1]) != str and operator.isSequenceType(cacert[1]),
            "cacert[1] is not a sequence")

        self.assert_(
            cacert[0],
            "RetrieveCACertificate returned failure: " + str(cacert[1]))

        certList = cacert[1]

        #
        # It should be  a list containing a single pair (cert, policy)
        #
        self.assert_(
            len(certList) == 1, "Retrieved cert list is not of length 1")

        self.assert_(
            len(certList[0]) == 2,
            "Retrieved cert list does not contain a single pair")

        cert, policy = certList[0]

        self.assert_(re.search("access_id_CA", policy),
                     "Policy string does not appear to be valid")

        self.assert_(re.search("BEGIN CERTIFICATE", cert),
                     "Certificate does not appear to be valid")

        tmp = tempfile.mktemp()
        fh = open(tmp, "w")
        fh.write(cert)
        fh.close()

        fh = os.popen("openssl x509 -noout -subject -in %s" % (tmp), "r")
        subj = fh.read()
        fh.close()

        m = re.search(r"^subject=\s+(.*)", subj)

        self.assert_(m is not None, "Did not match subject")

        global issuer
        issuer = m.group(1)

        os.unlink(tmp)
  def setup_analog_scan(
          self, channels=(0, 1, 2, 3),
          sweeps=-1, rate=100, gains=GAIN2_DIFF, exttrig=0):

    if self.scanning:
      raise MeasurementComputingError, "cannot start new scan without stopping old one"

    if not isSequenceType(channels):
      channels = (channels,)
    if not isSequenceType(gains):
      gains = (gains,) * len(channels)

    if len(gains) != len(channels):
      raise MeasurementComputingError, \
          "gain list not compatible with channel list" + str(channels) + ":" + str(gains)

    self.setup_gain_list(channels, gains)

    timerPre, timerVal, setupTime, actRate = self.compute_timer_vals(
        rate * len(channels))

    self.actRate = actRate

    if sweeps <= 0:  # continuous scan !
      blocking = self.DATA_SAMPLE_SIZE // len(channels)
      if len(channels) * blocking != self.DATA_SAMPLE_SIZE:
        raise MeasurementComputingError, \
            "continuous scan channel count must be submultiple of %d" % self.DATA_SAMPLE_SIZE
      tCount = self.DATA_SAMPLE_SIZE  # each block is filled in continuous mode
      scanmode = self.AD_CONT_MODE

    elif sweeps == 1:  # use AD_SINGLEEXEC mode for single sweep
      tCount = len(channels)
      scanmode = self.AD_SINGLE_MODE

    else:
      # round block count up to next block above requested samples
      blocks = (
          len(channels) * sweeps + self.DATA_SAMPLE_SIZE - 1) // self.DATA_SAMPLE_SIZE
      tCount = blocks * self.DATA_SAMPLE_SIZE
      if tCount > self.MAX_STORED_SAMPLES:
        raise MeasurementComputingError, \
            "burst scan sample count must be <  %d" % self.MAX_STORED_SAMPLES
      scanmode = self.AD_BURST_MODE
      self.burst_scan_count = tCount
      self.burst_scan_blocks = blocks

    tChigh = tCount >> 8
    tClow = tCount & 255
    self.write(
        (self.CBAINSCAN, tClow, tChigh, timerVal + setupTime, timerPre, scanmode
         | exttrig))
    self.continuous_scan_packet_index = 1
    self.got_last_packet = 1
    self.last_packet_time = 0.0  # long ago!
    self.packet_dt = self.DATA_SAMPLE_SIZE / actRate
Example #15
0
 def __init__(self, values, shadow_values):
     if not isSequenceType(values) or not isSequenceType(shadow_values):
         raise TypeError("values and shadow_values must be sequences.")
     if len(values) != len(shadow_values):
         raise ValueError(
             "values and shadow_values must have the same length.")
     self.values = values
     # Store always a copy: values and shadow_values may be identical,
     # and if this is the case, the two reverse() calls in the method
     # reverse() below will cancel each other.
     self.shadow_values = shadow_values[:]
Example #16
0
 def __init__(self, values, shadow_values):
     if not isSequenceType(values) or not isSequenceType(shadow_values):
         raise TypeError("values and shadow_values must be sequences.")
     if len(values) != len(shadow_values):
         raise ValueError(
             "values and shadow_values must have the same length.")
     self.values = values
     # Store always a copy: values and shadow_values may be identical,
     # and if this is the case, the two reverse() calls in the method
     # reverse() below will cancel each other.
     self.shadow_values = shadow_values[:]
Example #17
0
    def test_isXxxType_more(self):
        import operator

        assert not operator.isSequenceType(list)
        assert not operator.isSequenceType(dict)
        assert not operator.isSequenceType({})
        assert not operator.isMappingType(list)
        assert not operator.isMappingType(dict)
        assert not operator.isMappingType([])
        assert not operator.isMappingType(())
        assert not operator.isNumberType(int)
        assert not operator.isNumberType(float)
Example #18
0
    def test_isXxxType_more(self):
        import operator

        assert not operator.isSequenceType(list)
        assert not operator.isSequenceType(dict)
        assert not operator.isSequenceType({})
        assert not operator.isMappingType(list)
        assert not operator.isMappingType(dict)
        assert not operator.isMappingType([])
        assert not operator.isMappingType(())
        assert not operator.isNumberType(int)
        assert not operator.isNumberType(float)
Example #19
0
def server_init(args=None, groups=None):
	"""
	Initialize embedded server. If this client is not linked against
	the embedded server library, this function does nothing.
	
	args -- sequence of command-line arguments
	groups -- sequence of groups to use in defaults files
	"""
	
	global server_init_done
	
	if server_init_done:
		raise ProgrammingError('already initialized')
	
	args_count = 0
	if args is not None:
		if not operator.isSequenceType(args):
			raise TypeError('args must be a sequence')
		
		try:
			args_count = len(args)
		except Exception:
			raise TypeError('args could not be sized')
		
		for arg in args:
			if not isinstance(arg, basestring):
				raise TypeError('args must contain strings')
		
		args_array = (ctypes.c_char_p * args_count)(*args)
		
		
	if groups is not None:
		if not operator.isSequenceType(groups):
			raise TypeError('groups must be a sequence')
		
		try:
			len(groups)
		except Exception:
			raise TypeError('groups could not be sized')
		
		for group in groups:
			if not isinstance(group, basestring):
				raise TypeError('groups must contain strings')
		
		# create a null-terminated list (one longer than we need)
		groups_array = (ctypes.c_char_p * (len(groups)+1))(*groups)
	
	res = _mysql_api.mysql_server_init(args_count, args_array, groups)
	if res:
		return do_exception(None)
	
	server_init_done = True
    def test_01_RequestCACerts(self):

        cacert = self.proxy.RetrieveCACertificates()

        self.failUnless(operator.isSequenceType(cacert),
                        "RetrieveCACertificate returns a non-sequence")
        
        self.failUnless(len(cacert) == 2,
                        "RetrieveCACertificate returns a tuple of len != 2")
        
        self.failUnless(type(cacert[1]) != str and operator.isSequenceType(cacert[1]),
                        "cacert[1] is not a sequence")
        
        self.assert_(cacert[0],
                     "RetrieveCACertificate returned failure: " + str(cacert[1]))

        certList = cacert[1]

        #
        # It should be  a list containing a single pair (cert, policy)
        #
        self.assert_(len(certList) == 1, "Retrieved cert list is not of length 1")

        self.assert_(len(certList[0]) == 2, "Retrieved cert list does not contain a single pair")

        cert, policy = certList[0]

        self.assert_(re.search("access_id_CA", policy),
                     "Policy string does not appear to be valid")

        self.assert_(re.search("BEGIN CERTIFICATE", cert),
                     "Certificate does not appear to be valid")

        tmp = tempfile.mktemp()
        fh = open(tmp, "w")
        fh.write(cert)
        fh.close()
        
        fh = os.popen("openssl x509 -noout -subject -in %s" % (tmp), "r")
        subj = fh.read()
        fh.close()

        m = re.search(r"^subject=\s+(.*)", subj)

        self.assert_(m is not None, "Did not match subject")

        global issuer
        issuer = m.group(1)

        os.unlink(tmp)
Example #21
0
def constructFileName(fname, shaderName, shaderParams, shaderArgs):
	assert(kgUtils.isAString(shaderName) and kgUtils.isAString(fname))
	assert(operator.isSequenceType(shaderParams) and operator.isSequenceType(shaderArgs))
	fname = os.path.abspath(fname)
	fname1, ext = os.path.splitext(fname)
	resFileName=fname1
	if(shaderParams != None or shaderArgs != None):	
		print shaderParams
		print shaderArgs
		resFileName +=  '_' + '_'.join([ x[:2]\
					  + '_' + re.sub(r'[.]', '_', y) \
					  for x, y in map(None, shaderParams, shaderArgs)])
	resFileName += ext
	print resFileName
	return resFileName
Example #22
0
def _ExpandValue(var, specials, params, name, default):
  """Expand one value.

  This expands the <field>.<field>...<field> part of the variable
  expansion. A field may be of the form *<param> to use the value
  of a parameter as the field name.
  """
  if var == '_key':
    return name
  elif var == '_this':
    return params
  if var.startswith('_'):
    value = specials
  else:
    value = params

  for v in var.split('.'):
    if v == '*_this':
      v = params
    if v.startswith('*'):
      v = _GetValue(specials['_params'], v[1:])
      if operator.isSequenceType(v):
        v = v[0]  # reduce repeated url param to single value
    value = _GetValue(value, str(v), default)
  return value
Example #23
0
    def add(self, *objs):
        """
        Add an object or container of objects to the network
        """
        self.unprepare()
        for obj in objs:
            if isinstance(obj, (NeuronGroup, Connection, NetworkOperation)):
                self._added_objects.append(obj)
            if isinstance(obj, NeuronGroup):
                if obj not in self.groups:
                    self.groups.append(obj)
            elif isinstance(obj, Connection):
                if obj not in self.connections:
                    self.connections.append(obj)
            elif isinstance(obj, NetworkOperation):
                if obj not in self._all_operations:
                    self._operations_dict[obj.when].append(obj)
                    self._all_operations.append(obj)
            elif isSequenceType(obj):
                for o in obj:
                    self.add(o)
            else:
                raise TypeError('Only the following types of objects can be added to a network: NeuronGroup, Connection or NetworkOperation')

            try:
                gco = obj.contained_objects
                if gco is not None:
                    self.add(gco)
            except AttributeError:
                pass
Example #24
0
    def init_with_figure(cls, data=None, affine=None, threshold=None,
                         cut_coords=None, figure=None, axes=None,
                         black_bg=False, leave_space=False):
        cut_coords = cls.find_cut_coords(data, affine, threshold,
                                         cut_coords)

        if not isinstance(figure, pl.Figure):
            # Make sure that we have a figure
            figsize = cls._default_figsize[:]
            # Adjust for the number of axes
            figsize[0] *= len(cut_coords)
            facecolor = 'k' if black_bg else 'w'

            if leave_space:
                figsize[0] += 3.4
            figure = pl.figure(figure, figsize=figsize,
                            facecolor=facecolor)
        else:
            if isinstance(axes, pl.Axes):
                assert axes.figure is figure, ("The axes passed are not "
                "in the figure")

        if axes is None:
            axes = [0., 0., 1., 1.]
            if leave_space:
                axes = [0.3, 0, .7, 1.]
        if operator.isSequenceType(axes):
            axes = figure.add_axes(axes)
            axes.axis('off')
        return cls(cut_coords, axes, black_bg)
Example #25
0
def size(X):
    from operator import isSequenceType
    out = marray()
    while isSequenceType(X):
        out.append(len(X))
        X = X[0]
    return out
Example #26
0
File: merge.py Project: ifwe/tds
def merge(*mappings, **opts):
    '''
    Merges all mappings given as arguments.

    opts can have {'keyeq': predicate}
    '''

    mapping = {}

    keytransform = opts.get('keytransform', lambda k: k)
    use_list = opts.get('use_list', lambda k: k)

    for elem in mappings:
        if isMappingType(elem):
            # {key: value, key: value, ...}
            items = elem.iteritems()
        elif isSequenceType(elem):
            # [(key, value), (key, value), ...]
            if not all(len(s) == 2 for s in elem):
                raise TypeError(
                    'mapping sequences must be sequences of (key,'
                    'value) pairs: %s %s', type(elem), repr(elem)
                )

            items = elem
        else:
            raise TypeError('all arguments to merge must be mappings: %r',
                            elem)

        for key, value in items:
            merge_values(
                mapping, keytransform(key), value, keytransform, use_list
            )

    return mapping
Example #27
0
    def fireEvent(self, event_type, event_value, listeners=None):
        """sends an event to all listeners or a specific one"""

        if listeners is None:
            listeners = self._listeners

        if listeners is None:
            return

        if not operator.isSequenceType(listeners):
            listeners = listeners,

        for listener in listeners:
            if isinstance(listener, weakref.ref) or isinstance(
                    listener, BoundMethodWeakref):
                l = listener()
            else:
                l = listener
            if l is None:
                continue
            meth = getattr(l, 'eventReceived', None)
            if meth is not None and operator.isCallable(meth):
                l.eventReceived(self, event_type, event_value)
            elif operator.isCallable(l):
                l(self, event_type, event_value)
def electrode(Re, Ce, v_el='v_el', vm='vm', i_inj='i_inj', i_cmd='i_cmd'):
    '''
    An intracellular electrode modeled as an RC circuit,
    or multiple RC circuits in series (if Re, Ce are lists).
    v_el = electrode (=recording) potential
    vm = membrane potential
    i_inj = current entering the membrane
    i_cmd = electrode command current (None = no injection)
    Returns an Equations() object.
    '''
    if isSequenceType(Re):
        if len(Re) != len(Ce) or len(Re) < 2:
            raise TypeError, "Re and Ce must have the same length"
        v_mid, i_mid = [], []
        for i in range(len(Re) - 1):
            v_mid.append('v_mid_' + str(i) + unique_id())
            i_mid.append('i_mid_' + str(i) + unique_id())
        eqs = electrode(Re[0], Ce[0], v_mid[0], vm, i_inj, i_mid[0])
        for i in range(1, len(Re) - 1):
            eqs + electrode(Re[i], Ce[i], v_mid[i], v_mid[i - 1], i_mid[i - 1], i_mid[i])
        eqs += electrode(Re[-1], Ce[-1], v_el, v_mid[-1], i_mid[-1], i_cmd)
        return eqs
    else:
        if Ce > 0 * farad:
            return Equations('''
            dvr/dt = ((vm-vr)/Re+ic)/Ce : mV
            ie = (vr-vm)/Re : nA''', vr=v_el, vm=vm, ic=i_cmd, ie=i_inj, \
            Re=Re, Ce=Ce)
        else: # ideal electrode - pb here
            return Equations('''
            vr = vm+Re*ic : volt
            ie = ic : amp''', vr=v_el, vm=vm, ic=i_cmd, ie=i_inj)
Example #29
0
    def init_with_figure(cls, data=None, affine=None, threshold=None,
                         cut_coords=None, figure=None, axes=None,
                         black_bg=False, leave_space=False):
        cut_coords = cls.find_cut_coords(data, affine, threshold,
                                         cut_coords)
        if isinstance(axes, pl.Axes) and figure is None:
            figure = axes.figure

        if not isinstance(figure, pl.Figure):
            # Make sure that we have a figure
            figsize = cls._default_figsize[:]
            # Adjust for the number of axes
            figsize[0] *= len(cut_coords)
            facecolor = 'k' if black_bg else 'w'

            if leave_space:
                figsize[0] += 3.4
            figure = pl.figure(figure, figsize=figsize,
                            facecolor=facecolor)
        else:
            if isinstance(axes, pl.Axes):
                assert axes.figure is figure, ("The axes passed are not "
                "in the figure")

        if axes is None:
            axes = [0., 0., 1., 1.]
            if leave_space:
                axes = [0.3, 0, .7, 1.]
        if operator.isSequenceType(axes):
            axes = figure.add_axes(axes)
        # People forget to turn their axis off, or to set the zorder, and
        # then they cannot see their slicer
        axes.axis('off')
        return cls(cut_coords, axes, black_bg)
Example #30
0
def _uniquemerge2literal(attrs):
    """Compress a sequence into its unique elements (with string merge).

    Whenever there is more then one unique element in `attrs`, these
    are converted to a string and join with a '+' character inbetween.

    Parameters
    ----------
    attrs : sequence, arbitrary

    Returns
    -------
    Non-sequence arguments are passed as is. Sequences are converted into
    a single item representation (see above) and returned.  None is returned
    in case of an empty sequence.
    """
    # only do something if multiple items are given
    if not operator.isSequenceType(attrs):
        return attrs
    unq = np.unique(attrs)
    lunq = len(unq)
    if lunq > 1:
        return '+'.join([str(l) for l in unq])
    elif lunq:  # first entry (non
        return unq[0]
    else:
        return None
def _convert_to_svm_node_array(x):
	""" convert a sequence or mapping to an svm_node array """
	import operator

	# Find non zero elements
	iter_range = []
	if type(x) == dict:
		for k, v in x.iteritems():
# all zeros kept due to the precomputed kernel; no good solution yet
#			if v != 0:
				iter_range.append( k )
	elif operator.isSequenceType(x):
		for j in range(len(x)):
#			if x[j] != 0:
				iter_range.append( j )
	else:
		raise TypeError,"data must be a mapping or a sequence"

	iter_range.sort()
	data = svmc.svm_node_array(len(iter_range)+1)
	svmc.svm_node_array_set(data,len(iter_range),-1,0)

	j = 0
	for k in iter_range:
		svmc.svm_node_array_set(data,j,k,x[k])
		j = j + 1
	return data
Example #32
0
    def init_with_figure(cls, img, threshold=None,
                         cut_coords=None, figure=None, axes=None,
                         black_bg=False, leave_space=False):
        cut_coords = cls.find_cut_coords(img, threshold,
                                         cut_coords)
        if isinstance(axes, pl.Axes) and figure is None:
            figure = axes.figure

        if not isinstance(figure, pl.Figure):
            # Make sure that we have a figure
            figsize = cls._default_figsize[:]
            # Adjust for the number of axes
            figsize[0] *= len(cut_coords)
            facecolor = 'k' if black_bg else 'w'

            if leave_space:
                figsize[0] += 3.4
            figure = pl.figure(figure, figsize=figsize,
                            facecolor=facecolor)
        if isinstance(axes, pl.Axes):
            assert axes.figure is figure, ("The axes passed are not "
                    "in the figure")

        if axes is None:
            axes = [0., 0., 1., 1.]
            if leave_space:
                axes = [0.3, 0, .7, 1.]
        if operator.isSequenceType(axes):
            axes = figure.add_axes(axes)
        # People forget to turn their axis off, or to set the zorder, and
        # then they cannot see their slicer
        axes.axis('off')
        return cls(cut_coords, axes, black_bg)
Example #33
0
def find_capacitance(model):
    '''
    Tries to find the membrane capacitance from
    a set of differential equations or a model given as
    a dictionnary (with typical keys 'model', 'threshold' and 'reset').
    '''
    if type(model) == types.DictType:
        if 'Cm' in model:
            return model['Cm']
        if 'C' in model:
            return model['C']
        # Failed: look the equations
        if 'model' in model:
            model = model['model']
        else: # no clue!
            raise TypeError, 'Strange model!'

    if isinstance(model, StateUpdater):
        if hasattr(model, 'Cm'):
            return model.Cm
        if hasattr(model, 'C'):
            return model.C

    if isSequenceType(model):
        model = model[0] # The first equation is the membrane equation
    if type(model) == types.FunctionType:
        if 'Cm' in model.func_globals:
            return model.func_globals['Cm']
        if 'C' in model.func_globals:
            return model.func_globals['C']

    # Nothing was found!
    raise TypeError, 'No capacitance found!'
Example #34
0
    def _action(self, key, func, missingok=False, **kwargs):
        """Run specific func either on a single item or on all of them

        Parameters
        ----------
        key : str
          Name of the conditional attribute
        func
          Function (not bound) to call given an item, and **kwargs
        missingok : bool
          If True - do not complain about wrong key
        """
        if isinstance(key, basestring):
            if key.upper() == 'ALL':
                for key_ in self:
                    self._action(key_, func, missingok=missingok, **kwargs)
            else:
                try:
                    func(self[key], **kwargs)
                except:
                    if missingok:
                        return
                    raise
        elif operator.isSequenceType(key):
            for item in key:
                self._action(item, func, missingok=missingok, **kwargs)
        else:
            raise ValueError, \
                  "Don't know how to handle  variable given by %s" % key
Example #35
0
def merge(*mappings, **opts):
    '''
    Merges all mappings given as arguments.

    opts can have {'keyeq': predicate}
    '''

    mapping = {}

    keytransform = opts.get('keytransform', lambda k: k)
    use_list = opts.get('use_list', lambda k: k)

    for elem in mappings:
        if isMappingType(elem):
            # {key: value, key: value, ...}
            items = elem.iteritems()
        elif isSequenceType(elem):
            # [(key, value), (key, value), ...]
            if not all(len(s) == 2 for s in elem):
                raise TypeError(
                    'mapping sequences must be sequences of (key,'
                    'value) pairs: %s %s', type(elem), repr(elem))

            items = elem
        else:
            raise TypeError('all arguments to merge must be mappings: %r',
                            elem)

        for key, value in items:
            merge_values(mapping, keytransform(key), value, keytransform,
                         use_list)

    return mapping
Example #36
0
def _check_input_times(times):

    issequence = False
    if isSequenceType(times):
        ## Here assume sequence contains
        ## elements of same type.
        test_tm = times[0]
        issequence = True
    else:
        test_tm = times

    if not issequence:
        times = [times]

    if isinstance(test_tm, datetime.datetime):
        tticks = map(ticks, times)
        tticks = array(tticks, float)
    elif isNumberType(test_tm):
        tticks = array(times, float)
    else:
        raise TypeError("Second input for interpolation functions" \
        " must be list/array of number or datatime, or single" \
        " number or datetime")

    return tticks
Example #37
0
 def upgraderChangeUserAgentTuple(self, clients=None):
     "Change the user agent to the newer tuple format for detection"
     if not clients:
         clients = self.getClients()
     lookup = {
         "Konqueror/2.2": ("Mozilla/5", "Konqueror", "2", "2"),
         "Konqueror": ("Mozilla/5", "Konqueror", "", ""),
         "MSIE": ("Mozilla/4", "MSIE", "", ""),
         "MSIE 6": ("Mozilla/4", "MSIE", "6", ""),
         "MSIE 6.0": ("Mozilla/4", "MSIE", "6", "0"),
         "MSIE 5": ("Mozilla/4", "MSIE", "5", ""),
         "MSIE 4": ("Mozilla/4", "MSIE", "4", ""),
         "MSIE 3": ("Mozilla/3", "MSIE", "3", ""),
         "MSIE 2": ("Mozilla/2", "MSIE", "2", ""),
         "MSIE 5.5": ("Mozilla/4", "MSIE", "5", "5"),
         "MSIE 5.0": ("Mozilla/4", "MSIE", "5", "0"),
         "Opera": ("", "Opera", "", ""),
         "Opera/6": ("", "Opera", "6", ""),
         "Opera/6.0": ("", "Opera", "6", "0"),
         "Opera/5": ("", "Opera", "5", ""),
         "Opera/5.0": ("", "Opera", "5", "0"),
     }
     if operator.isSequenceType(clients):
         list = [lookup[i] for i in clients if i in lookup]
         if len(list):
             self.setClients(tuple(list))
Example #38
0
    def __init__(self, intf, dict=None, inst=None) :
        actualIntf = None
        
        if isinstance(intf, str) or isinstance(intf, unicode) :
            actualIntf = [ _jclass.JClass(intf) ]
        elif isinstance(intf, _jclass._JavaClass) :
            actualIntf = [ intf ]
        elif operator.isSequenceType(intf) :
            actualIntf = []
            for i in intf :            
                if isinstance(i, str) or isinstance(i, unicode) :
                    actualIntf.append(_jclass.JClass(i))
                elif isinstance(i, _jclass._JavaClass) :
                    actualIntf.append(i)
                else:
                    raise TypeError, "JProxy requires java interface classes or the names of java interfaces classes"                
        else:
            raise TypeError, "JProxy requires java interface classes or the names of java interfaces classes"
                
        for i in actualIntf :
            if not JClassUtil.isInterface(i) :
                raise TypeError, "JProxy requires java interface classes or the names of java interfaces classes : "+i.__name__                 

        if dict is not None and inst is not None :
            raise RuntimeError, "Specify only one of dict and inst"

        self._dict = dict
        self._inst = inst
        
        self._proxy = _jpype.createProxy(self, actualIntf)
Example #39
0
    def _build_parameter(self, param_def):
        '''Builds a list of parameters, each of them represented by a dictionary
        containing information: name, type, default_value, description, min and
        max values. In case of simple parameters, type is the parameter type.
        In case of ParamRepeat, type is a list containing definition of the 
        param repeat.
        '''
        ret = []
        param_def = param_def or ()
        for p in param_def:
            t = p[1]
            ret_p = {'min': 1, 'max': None}
            # take care of old ParamRepeat
            if isinstance(t, ParamRepeat):
                t = t.obj()

            if operator.isSequenceType(t) and not isinstance(t, (str, unicode)):
                if operator.isMappingType(t[-1]):
                    ret_p.update(t[-1])
                    t = self._build_parameter(t[:-1])
                else:
                    t = self._build_parameter(t)

            ret_p['name'] = p[0]
            ret_p['type'] = t
            ret_p['default_value'] = p[2]
            ret_p['description'] = p[3]
            ret.append(ret_p)
        return ret
Example #40
0
def geocentric_to_geographic_latitude(geoclat):
    """
    Converts a geocentric latitude to a geographic/geodetic latitude.
    
    :param geoclat:
        An :class:`astropysics.coords.AngularCoordinate` object (or arguments to
        create one) or an angle in degrees for the geocentric latitude.
        
    :returns: 
        An :class:`astropysics.coords.AngularCoordinate` object with the
        geographic latitude.
    """
    from astropysics.constants import Rea, Reb
    from astropysics.coords import AngularCoordinate
    from operator import isSequenceType

    if not isinstance(geoclat, AngularCoordinate):
        if isSequenceType(geoclat):
            rads = AngularCoordinate(*geoclat).radians
        else:
            rads = AngularCoordinate(geoclat).radians
    else:
        rads = geoclat.radians

    boasq = (Reb / Rea)**2
    return AngularCoordinate(np.arctan((1 / boasq) * np.tan(rads)),
                             radians=True)
Example #41
0
    def __setitem__(self, key, value):
        """Add a new IndexedCollectable to the collection

        Parameters
        ----------
        item : IndexedCollectable
          or of derived class. Must have 'name' assigned.
        """
        # local binding
        ulength = self._uniform_length

        # XXX should we check whether it is some other Collectable?
        if not isinstance(value, ArrayCollectable):
            # if it is only a single element iterable, attempt broadcasting
            if isSequenceType(value) and len(value) == 1 and not ulength is None:
                if ulength > 1:
                    # cannot use np.repeat, because it destroys dimensionality
                    value = [value[0]] * ulength
            value = ArrayCollectable(value)
        if ulength is None:
            ulength = len(value)
        elif not len(value.value) == ulength:
            raise ValueError(
                "Collectable '%s' with length [%i] does not match "
                "the required length [%i] of collection '%s'." % (key, len(value.value), ulength, str(self))
            )
        # tell the attribute to maintain the desired length
        value.set_length_check(ulength)
        Collection.__setitem__(self, key, value)
Example #42
0
def isSequenceType(obj):
    if six.PY2:
        import operator
        return operator.isSequenceType(obj)
    else:
        import collections.abc
        return isinstance(obj, collections.abc.Sequence)
Example #43
0
    def _setValidjdrange(self, val):
        """
        Sets the jd range over which this method is valid. Trying to get
        something outside will result in an `exc`:EphemerisAccuracyWarning:
        Intended for use in __init__.
        
        :param val: 
            The range as (minjd,maxjd), can be None to indicate no bound. If set
            to None, the result will be (None,None).
        
        """
        if val is None:
            self._validrange = (None, None)
        else:
            v1, v2 = val
            if v1 is None and v2 is None:
                self._validrange = (None, None)
            else:
                from operator import isSequenceType
                from ..obstools import calendar_to_jd
                from datetime import datetime

                vs = []
                for v in (v1, v2):
                    if v is None:
                        vs.append(None)
                    elif v == 'now':
                        vs.append(calendar_to_jd(datetime.utcnow(), tz=None))
                    elif hasattr(v, 'year') or isSequenceType(v):
                        vs.append(calendar_to_jd(v))
                    else:
                        vs.append(v)
                self._validrange = tuple(vs)
Example #44
0
def seq_to_svm_node(x):
    """convert a sequence or mapping to an SVMNode array"""
    import operator

    length = len(x)

    # make two lists, one of indices, one of values
    # YYY Use isinstance  instead of type...is so we could
    #     easily use derived subclasses
    if isinstance(x, np.ndarray):
        iter_range = range(length)
        iter_values = x
    elif isinstance(x, dict):
        iter_range = list(x).sort()
        iter_values = np.ndarray(x.values())
    elif operator.isSequenceType(x):
        iter_range = range(length)
        iter_values = np.asarray(x)
    else:
        raise TypeError, "data must be a mapping or an ndarray or a sequence"

    # allocate c struct
    data = svmc.svm_node_array(length + 1)
    # insert markers into the c struct
    svmc.svm_node_array_set(data, length, -1, 0.0)
    # pass the list and the ndarray to the c struct
    svmc.svm_node_array_set(data, iter_range, iter_values)

    return data
Example #45
0
def _convert_to_svm_node_array(x, keep_zeros = True):
    """
    convert a sequence or mapping to an svm_node array.
    
    3/12/09 -- originally, zeros were included (the in-line comment suggests this had something
                       to do with precomputed kernels?) test ?
    """
    import operator
    
    # Find non zero elements
    iter_range = []
    if type(x) == dict:
        for k, v in x.iteritems():
            # all zeros kept due to the precomputed kernel; no good solution yet
            if v != 0 or keep_zeros:
                iter_range.append( k )
    elif operator.isSequenceType(x):
        for j in range(len(x)):
            if x[j] != 0 or keep_zeros:
                iter_range.append( j )
    else:
        raise TypeError,"data must be a mapping or a sequence"
    
    iter_range.sort()
    data = svmc.svm_node_array(len(iter_range)+1)
    svmc.svm_node_array_set(data,len(iter_range),-1,0)
    
    j = 0
    for k in iter_range:
        svmc.svm_node_array_set(data,j,k,x[k])
        j = j + 1
    return data
def Vectorize(v):
    "Converts v from a sequence into a Vector3."
    if operator.isSequenceType(v):
        v = DirectX.Vector3(System.Single(v[0]), System.Single(v[1]),
                            System.Single(v[2]))

    return v
Example #47
0
 def __idiv__(self,arg):
     if operator.isSequenceType(arg) :
         assert len(arg) == len(self.__GFlist) , "list of incorrect length"
         for l,g in izip(arg,self.__GFlist) : g /=l 
     else : 
         for i,g in self : g /= arg
     return self
Example #48
0
    def _action(self, key, func, missingok=False, **kwargs):
        """Run specific func either on a single item or on all of them

        Parameters
        ----------
        key : str
          Name of the conditional attribute
        func
          Function (not bound) to call given an item, and **kwargs
        missingok : bool
          If True - do not complain about wrong key
        """
        if isinstance(key, basestring):
            if key.upper() == 'ALL':
                for key_ in self:
                    self._action(key_, func, missingok=missingok, **kwargs)
            else:
                try:
                    func(self[key], **kwargs)
                except:
                    if missingok:
                        return
                    raise
        elif operator.isSequenceType(key):
            for item in key:
                self._action(item, func, missingok=missingok, **kwargs)
        else:
            raise ValueError, \
                  "Don't know how to handle  variable given by %s" % key
Example #49
0
File: fx.py Project: schoeke/PyMVPA
def _uniquemerge2literal(attrs):
    """Compress a sequence into its unique elements (with string merge).

    Whenever there is more then one unique element in `attrs`, these
    are converted to a string and join with a '+' character inbetween.

    Parameters
    ----------
    attrs : sequence, arbitrary

    Returns
    -------
    Non-sequence arguments are passed as is. Sequences are converted into
    a single item representation (see above) and returned.  None is returned
    in case of an empty sequence.
    """
    # only do something if multiple items are given
    if not operator.isSequenceType(attrs):
        return attrs
    unq = np.unique(attrs)
    lunq = len(unq)
    if lunq > 1:
        return "+".join([str(l) for l in unq])
    elif lunq:  # first entry (non
        return unq[0]
    else:
        return None
Example #50
0
 def connect(self, attrs):
     if not operator.isSequenceType(attrs):
         attrs = (attrs,)
     self.disconnect()
     self._attrs = attrs
     for attr in self._attrs:
         attr.addListener(self)
Example #51
0
 def remove(self, *objs, **kwds):
     '''
     Remove an object or sequence of objects from a Network (note that this
     will force the Network to be prepared from scratch).
     '''
     unprepare = kwds.pop('unprepare', True)
     for obj in objs:
         if isinstance(obj, (NeuronGroup, Connection, NetworkOperation)):
             self._added_objects = [o for o in self._added_objects if o is not obj]
             if isinstance(obj, NeuronGroup):
                 self.groups = [o for o in self.groups if o is not obj]
             if isinstance(obj, Connection):
                 self.connections = [o for o in self.connections if o is not obj]
             if isinstance(obj, NetworkOperation):
                 self._all_operations = [o for o in self._all_operations if o is not obj]
                 self._operations_dict[obj.when] = [o for o in self._operations_dict[obj.when]
                                                    if o is not obj]
         elif isSequenceType(obj):
             for o in obj:
                 self.remove(o, unprepare=False)
         else:
             raise TypeError('Only the following types of objects can be removed from a network: NeuronGroup, Connection or NetworkOperation')
         try:
             gco = obj.contained_objects
             if gco is not None:
                 self.remove(gco, unprepare=False)
         except AttributeError:
             pass
     if unprepare:
         self.unprepare()
Example #52
0
def _convert_to_svm_node_array(x):
    """ convert a sequence or mapping to an svm_node array """
    import operator

    # Find non zero elements
    iter_range = []
    if type(x) == dict:
        for k, v in x.iteritems():
            # all zeros kept due to the precomputed kernel; no good solution yet
            #			if v != 0:
            iter_range.append(k)
    elif operator.isSequenceType(x):
        for j in range(len(x)):
            #			if x[j] != 0:
            iter_range.append(j)
    else:
        raise TypeError, "data must be a mapping or a sequence"

    iter_range.sort()
    data = svmc.svm_node_array(len(iter_range) + 1)
    svmc.svm_node_array_set(data, len(iter_range), -1, 0)

    j = 0
    for k in iter_range:
        svmc.svm_node_array_set(data, j, k, x[k])
        j = j + 1
    return data
Example #53
0
 def __idiv__(self,arg):
     if operator.isSequenceType(arg):
         assert len(arg) == len(self.__GFlist) , "list of incorrect length"
         for l,g in izip(arg,self.__GFlist): g /=l
     else:
         for i,g in self: self[i] /= arg
     return self
Example #54
0
def __calKeyframes(start, end, func, *additionalArgs, **keyArgs):
    """
    helping to calculate and pack key values
    """
    perc = start
    values = func(perc, *additionalArgs)
    samplingRate = 60.0
    if keyArgs.has_key('samplingRate'):
        samplingRate = keyArgs['samplingRate']

    keyArrays = []
    if operator.isSequenceType(values):
        valueCount = len(values)
        isSequence = True
        for value in values:
            keyArrays.append([value])
    else:
        isSequence = False
        keyArrays.append(values)

    offset = 1.0 / samplingRate
    epsilon = offset * 0.0001
    while perc != end:
        perc += offset
        if (end - start > 0) ^ ((perc + epsilon) < end):
            perc = end
        values = func(perc, *additionalArgs)
        if isSequence:
            for i in range(valueCount):
                keyArrays[i].append(values[i])
        else:
            keyArrays.append(values)
    return keyArrays
Example #55
0
def size(X):
    from operator import isSequenceType
    out = marray()
    while isSequenceType(X):
        out.append(len(X))
        X = X[0]
    return out
Example #56
0
    def validate(self, data):
        """Checks that the data is a valid sequence."""
        from operator import isSequenceType

        if not isSequenceType(data):
            return "List data has to be a sequence."
        return True