Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(212)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/univ.py

Issue 1493973002: Remove telemetry/third_party/gsutilz (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@gsutil_changes
Patch Set: rebase Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/tagmap.py ('k') | tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/useful.py » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/univ.py
diff --git a/tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/univ.py b/tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/univ.py
deleted file mode 100644
index 9cd16f8a2a971cddcd506d1540be328e2835006e..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/univ.py
+++ /dev/null
@@ -1,1042 +0,0 @@
-# ASN.1 "universal" data types
-import operator, sys
-from pyasn1.type import base, tag, constraint, namedtype, namedval, tagmap
-from pyasn1.codec.ber import eoo
-from pyasn1.compat import octets
-from pyasn1 import error
-
-# "Simple" ASN.1 types (yet incomplete)
-
-class Integer(base.AbstractSimpleAsn1Item):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
- )
- namedValues = namedval.NamedValues()
- def __init__(self, value=None, tagSet=None, subtypeSpec=None,
- namedValues=None):
- if namedValues is None:
- self.__namedValues = self.namedValues
- else:
- self.__namedValues = namedValues
- base.AbstractSimpleAsn1Item.__init__(
- self, value, tagSet, subtypeSpec
- )
-
- def __and__(self, value): return self.clone(self._value & value)
- def __rand__(self, value): return self.clone(value & self._value)
- def __or__(self, value): return self.clone(self._value | value)
- def __ror__(self, value): return self.clone(value | self._value)
- def __xor__(self, value): return self.clone(self._value ^ value)
- def __rxor__(self, value): return self.clone(value ^ self._value)
- def __lshift__(self, value): return self.clone(self._value << value)
- def __rshift__(self, value): return self.clone(self._value >> value)
-
- def __add__(self, value): return self.clone(self._value + value)
- def __radd__(self, value): return self.clone(value + self._value)
- def __sub__(self, value): return self.clone(self._value - value)
- def __rsub__(self, value): return self.clone(value - self._value)
- def __mul__(self, value): return self.clone(self._value * value)
- def __rmul__(self, value): return self.clone(value * self._value)
- def __mod__(self, value): return self.clone(self._value % value)
- def __rmod__(self, value): return self.clone(value % self._value)
- def __pow__(self, value, modulo=None): return self.clone(pow(self._value, value, modulo))
- def __rpow__(self, value): return self.clone(pow(value, self._value))
-
- if sys.version_info[0] <= 2:
- def __div__(self, value): return self.clone(self._value // value)
- def __rdiv__(self, value): return self.clone(value // self._value)
- else:
- def __truediv__(self, value): return self.clone(self._value / value)
- def __rtruediv__(self, value): return self.clone(value / self._value)
- def __divmod__(self, value): return self.clone(self._value // value)
- def __rdivmod__(self, value): return self.clone(value // self._value)
-
- __hash__ = base.AbstractSimpleAsn1Item.__hash__
-
- def __int__(self): return int(self._value)
- if sys.version_info[0] <= 2:
- def __long__(self): return long(self._value)
- def __float__(self): return float(self._value)
- def __abs__(self): return abs(self._value)
- def __index__(self): return int(self._value)
-
- def __lt__(self, value): return self._value < value
- def __le__(self, value): return self._value <= value
- def __eq__(self, value): return self._value == value
- def __ne__(self, value): return self._value != value
- def __gt__(self, value): return self._value > value
- def __ge__(self, value): return self._value >= value
-
- def prettyIn(self, value):
- if not isinstance(value, str):
- try:
- return int(value)
- except:
- raise error.PyAsn1Error(
- 'Can\'t coerce %s into integer: %s' % (value, sys.exc_info()[1])
- )
- r = self.__namedValues.getValue(value)
- if r is not None:
- return r
- try:
- return int(value)
- except:
- raise error.PyAsn1Error(
- 'Can\'t coerce %s into integer: %s' % (value, sys.exc_info()[1])
- )
-
- def prettyOut(self, value):
- r = self.__namedValues.getName(value)
- return r is None and str(value) or repr(r)
-
- def getNamedValues(self): return self.__namedValues
-
- def clone(self, value=None, tagSet=None, subtypeSpec=None,
- namedValues=None):
- if value is None and tagSet is None and subtypeSpec is None \
- and namedValues is None:
- return self
- if value is None:
- value = self._value
- if tagSet is None:
- tagSet = self._tagSet
- if subtypeSpec is None:
- subtypeSpec = self._subtypeSpec
- if namedValues is None:
- namedValues = self.__namedValues
- return self.__class__(value, tagSet, subtypeSpec, namedValues)
-
- def subtype(self, value=None, implicitTag=None, explicitTag=None,
- subtypeSpec=None, namedValues=None):
- if value is None:
- value = self._value
- if implicitTag is not None:
- tagSet = self._tagSet.tagImplicitly(implicitTag)
- elif explicitTag is not None:
- tagSet = self._tagSet.tagExplicitly(explicitTag)
- else:
- tagSet = self._tagSet
- if subtypeSpec is None:
- subtypeSpec = self._subtypeSpec
- else:
- subtypeSpec = subtypeSpec + self._subtypeSpec
- if namedValues is None:
- namedValues = self.__namedValues
- else:
- namedValues = namedValues + self.__namedValues
- return self.__class__(value, tagSet, subtypeSpec, namedValues)
-
-class Boolean(Integer):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01),
- )
- subtypeSpec = Integer.subtypeSpec+constraint.SingleValueConstraint(0,1)
- namedValues = Integer.namedValues.clone(('False', 0), ('True', 1))
-
-class BitString(base.AbstractSimpleAsn1Item):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
- )
- namedValues = namedval.NamedValues()
- def __init__(self, value=None, tagSet=None, subtypeSpec=None,
- namedValues=None):
- if namedValues is None:
- self.__namedValues = self.namedValues
- else:
- self.__namedValues = namedValues
- base.AbstractSimpleAsn1Item.__init__(
- self, value, tagSet, subtypeSpec
- )
-
- def clone(self, value=None, tagSet=None, subtypeSpec=None,
- namedValues=None):
- if value is None and tagSet is None and subtypeSpec is None \
- and namedValues is None:
- return self
- if value is None:
- value = self._value
- if tagSet is None:
- tagSet = self._tagSet
- if subtypeSpec is None:
- subtypeSpec = self._subtypeSpec
- if namedValues is None:
- namedValues = self.__namedValues
- return self.__class__(value, tagSet, subtypeSpec, namedValues)
-
- def subtype(self, value=None, implicitTag=None, explicitTag=None,
- subtypeSpec=None, namedValues=None):
- if value is None:
- value = self._value
- if implicitTag is not None:
- tagSet = self._tagSet.tagImplicitly(implicitTag)
- elif explicitTag is not None:
- tagSet = self._tagSet.tagExplicitly(explicitTag)
- else:
- tagSet = self._tagSet
- if subtypeSpec is None:
- subtypeSpec = self._subtypeSpec
- else:
- subtypeSpec = subtypeSpec + self._subtypeSpec
- if namedValues is None:
- namedValues = self.__namedValues
- else:
- namedValues = namedValues + self.__namedValues
- return self.__class__(value, tagSet, subtypeSpec, namedValues)
-
- def __str__(self): return str(tuple(self))
-
- # Immutable sequence object protocol
-
- def __len__(self):
- if self._len is None:
- self._len = len(self._value)
- return self._len
- def __getitem__(self, i):
- if isinstance(i, slice):
- return self.clone(operator.getitem(self._value, i))
- else:
- return self._value[i]
-
- def __add__(self, value): return self.clone(self._value + value)
- def __radd__(self, value): return self.clone(value + self._value)
- def __mul__(self, value): return self.clone(self._value * value)
- def __rmul__(self, value): return self * value
-
- def prettyIn(self, value):
- r = []
- if not value:
- return ()
- elif isinstance(value, str):
- if value[0] == '\'':
- if value[-2:] == '\'B':
- for v in value[1:-2]:
- if v == '0':
- r.append(0)
- elif v == '1':
- r.append(1)
- else:
- raise error.PyAsn1Error(
- 'Non-binary BIT STRING initializer %s' % (v,)
- )
- return tuple(r)
- elif value[-2:] == '\'H':
- for v in value[1:-2]:
- i = 4
- v = int(v, 16)
- while i:
- i = i - 1
- r.append((v>>i)&0x01)
- return tuple(r)
- else:
- raise error.PyAsn1Error(
- 'Bad BIT STRING value notation %s' % (value,)
- )
- else:
- for i in value.split(','):
- j = self.__namedValues.getValue(i)
- if j is None:
- raise error.PyAsn1Error(
- 'Unknown bit identifier \'%s\'' % (i,)
- )
- if j >= len(r):
- r.extend([0]*(j-len(r)+1))
- r[j] = 1
- return tuple(r)
- elif isinstance(value, (tuple, list)):
- r = tuple(value)
- for b in r:
- if b and b != 1:
- raise error.PyAsn1Error(
- 'Non-binary BitString initializer \'%s\'' % (r,)
- )
- return r
- elif isinstance(value, BitString):
- return tuple(value)
- else:
- raise error.PyAsn1Error(
- 'Bad BitString initializer type \'%s\'' % (value,)
- )
-
- def prettyOut(self, value):
- return '\"\'%s\'B\"' % ''.join([str(x) for x in value])
-
-class OctetString(base.AbstractSimpleAsn1Item):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
- )
- defaultBinValue = defaultHexValue = base.noValue
- encoding = 'us-ascii'
- def __init__(self, value=None, tagSet=None, subtypeSpec=None,
- encoding=None, binValue=None, hexValue=None):
- if encoding is None:
- self._encoding = self.encoding
- else:
- self._encoding = encoding
- if binValue is not None:
- value = self.fromBinaryString(binValue)
- if hexValue is not None:
- value = self.fromHexString(hexValue)
- if value is None or value is base.noValue:
- value = self.defaultHexValue
- if value is None or value is base.noValue:
- value = self.defaultBinValue
- self.__intValue = None
- base.AbstractSimpleAsn1Item.__init__(self, value, tagSet, subtypeSpec)
-
- def clone(self, value=None, tagSet=None, subtypeSpec=None,
- encoding=None, binValue=None, hexValue=None):
- if value is None and tagSet is None and subtypeSpec is None and \
- encoding is None and binValue is None and hexValue is None:
- return self
- if value is None and binValue is None and hexValue is None:
- value = self._value
- if tagSet is None:
- tagSet = self._tagSet
- if subtypeSpec is None:
- subtypeSpec = self._subtypeSpec
- if encoding is None:
- encoding = self._encoding
- return self.__class__(
- value, tagSet, subtypeSpec, encoding, binValue, hexValue
- )
-
- if sys.version_info[0] <= 2:
- def prettyIn(self, value):
- if isinstance(value, str):
- return value
- elif isinstance(value, (tuple, list)):
- try:
- return ''.join([ chr(x) for x in value ])
- except ValueError:
- raise error.PyAsn1Error(
- 'Bad OctetString initializer \'%s\'' % (value,)
- )
- else:
- return str(value)
- else:
- def prettyIn(self, value):
- if isinstance(value, bytes):
- return value
- elif isinstance(value, OctetString):
- return value.asOctets()
- elif isinstance(value, (tuple, list, map)):
- try:
- return bytes(value)
- except ValueError:
- raise error.PyAsn1Error(
- 'Bad OctetString initializer \'%s\'' % (value,)
- )
- else:
- try:
- return str(value).encode(self._encoding)
- except UnicodeEncodeError:
- raise error.PyAsn1Error(
- 'Can\'t encode string \'%s\' with \'%s\' codec' % (value, self._encoding)
- )
-
-
- def fromBinaryString(self, value):
- bitNo = 8; byte = 0; r = ()
- for v in value:
- if bitNo:
- bitNo = bitNo - 1
- else:
- bitNo = 7
- r = r + (byte,)
- byte = 0
- if v == '0':
- v = 0
- elif v == '1':
- v = 1
- else:
- raise error.PyAsn1Error(
- 'Non-binary OCTET STRING initializer %s' % (v,)
- )
- byte = byte | (v << bitNo)
- return octets.ints2octs(r + (byte,))
-
- def fromHexString(self, value):
- r = p = ()
- for v in value:
- if p:
- r = r + (int(p+v, 16),)
- p = ()
- else:
- p = v
- if p:
- r = r + (int(p+'0', 16),)
- return octets.ints2octs(r)
-
- def prettyOut(self, value):
- if sys.version_info[0] <= 2:
- numbers = tuple([ ord(x) for x in value ])
- else:
- numbers = tuple(value)
- if [ x for x in numbers if x < 32 or x > 126 ]:
- return '0x' + ''.join([ '%.2x' % x for x in numbers ])
- else:
- return str(value)
-
- def __repr__(self):
- if self._value is base.noValue:
- return self.__class__.__name__ + '()'
- if [ x for x in self.asNumbers() if x < 32 or x > 126 ]:
- return self.__class__.__name__ + '(hexValue=\'' + ''.join([ '%.2x' % x for x in self.asNumbers() ])+'\')'
- else:
- return self.__class__.__name__ + '(\'' + self.prettyOut(self._value) + '\')'
-
- if sys.version_info[0] <= 2:
- def __str__(self): return str(self._value)
- def __unicode__(self):
- return self._value.decode(self._encoding, 'ignore')
- def asOctets(self): return self._value
- def asNumbers(self):
- if self.__intValue is None:
- self.__intValue = tuple([ ord(x) for x in self._value ])
- return self.__intValue
- else:
- def __str__(self): return self._value.decode(self._encoding, 'ignore')
- def __bytes__(self): return self._value
- def asOctets(self): return self._value
- def asNumbers(self):
- if self.__intValue is None:
- self.__intValue = tuple(self._value)
- return self.__intValue
-
- # Immutable sequence object protocol
-
- def __len__(self):
- if self._len is None:
- self._len = len(self._value)
- return self._len
- def __getitem__(self, i):
- if isinstance(i, slice):
- return self.clone(operator.getitem(self._value, i))
- else:
- return self._value[i]
-
- def __add__(self, value): return self.clone(self._value + self.prettyIn(value))
- def __radd__(self, value): return self.clone(self.prettyIn(value) + self._value)
- def __mul__(self, value): return self.clone(self._value * value)
- def __rmul__(self, value): return self * value
-
-class Null(OctetString):
- defaultValue = ''.encode() # This is tightly constrained
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
- )
- subtypeSpec = OctetString.subtypeSpec+constraint.SingleValueConstraint(''.encode())
-
-if sys.version_info[0] <= 2:
- intTypes = (int, long)
-else:
- intTypes = int
-
-class ObjectIdentifier(base.AbstractSimpleAsn1Item):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
- )
- def __add__(self, other): return self.clone(self._value + other)
- def __radd__(self, other): return self.clone(other + self._value)
-
- def asTuple(self): return self._value
-
- # Sequence object protocol
-
- def __len__(self):
- if self._len is None:
- self._len = len(self._value)
- return self._len
- def __getitem__(self, i):
- if isinstance(i, slice):
- return self.clone(
- operator.getitem(self._value, i)
- )
- else:
- return self._value[i]
-
- def __str__(self): return self.prettyPrint()
-
- def index(self, suboid): return self._value.index(suboid)
-
- def isPrefixOf(self, value):
- """Returns true if argument OID resides deeper in the OID tree"""
- l = len(self)
- if l <= len(value):
- if self._value[:l] == value[:l]:
- return 1
- return 0
-
- def prettyIn(self, value):
- """Dotted -> tuple of numerics OID converter"""
- if isinstance(value, tuple):
- pass
- elif isinstance(value, ObjectIdentifier):
- return tuple(value)
- elif isinstance(value, str):
- r = []
- for element in [ x for x in value.split('.') if x != '' ]:
- try:
- r.append(int(element, 0))
- except ValueError:
- raise error.PyAsn1Error(
- 'Malformed Object ID %s at %s: %s' %
- (str(value), self.__class__.__name__, sys.exc_info()[1])
- )
- value = tuple(r)
- else:
- try:
- value = tuple(value)
- except TypeError:
- raise error.PyAsn1Error(
- 'Malformed Object ID %s at %s: %s' %
- (str(value), self.__class__.__name__,sys.exc_info()[1])
- )
-
- for x in value:
- if not isinstance(x, intTypes) or x < 0:
- raise error.PyAsn1Error(
- 'Invalid sub-ID in %s at %s' % (value, self.__class__.__name__)
- )
-
- return value
-
- def prettyOut(self, value): return '.'.join([ str(x) for x in value ])
-
-class Real(base.AbstractSimpleAsn1Item):
- try:
- _plusInf = float('inf')
- _minusInf = float('-inf')
- _inf = (_plusInf, _minusInf)
- except ValueError:
- # Infinity support is platform and Python dependent
- _plusInf = _minusInf = None
- _inf = ()
-
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
- )
-
- def __normalizeBase10(self, value):
- m, b, e = value
- while m and m % 10 == 0:
- m = m / 10
- e = e + 1
- return m, b, e
-
- def prettyIn(self, value):
- if isinstance(value, tuple) and len(value) == 3:
- for d in value:
- if not isinstance(d, intTypes):
- raise error.PyAsn1Error(
- 'Lame Real value syntax: %s' % (value,)
- )
- if value[1] not in (2, 10):
- raise error.PyAsn1Error(
- 'Prohibited base for Real value: %s' % (value[1],)
- )
- if value[1] == 10:
- value = self.__normalizeBase10(value)
- return value
- elif isinstance(value, intTypes):
- return self.__normalizeBase10((value, 10, 0))
- elif isinstance(value, float):
- if self._inf and value in self._inf:
- return value
- else:
- e = 0
- while int(value) != value:
- value = value * 10
- e = e - 1
- return self.__normalizeBase10((int(value), 10, e))
- elif isinstance(value, Real):
- return tuple(value)
- elif isinstance(value, str): # handle infinite literal
- try:
- return float(value)
- except ValueError:
- pass
- raise error.PyAsn1Error(
- 'Bad real value syntax: %s' % (value,)
- )
-
- def prettyOut(self, value):
- if value in self._inf:
- return '\'%s\'' % value
- else:
- return str(value)
-
- def isPlusInfinity(self): return self._value == self._plusInf
- def isMinusInfinity(self): return self._value == self._minusInf
- def isInfinity(self): return self._value in self._inf
-
- def __str__(self): return str(float(self))
-
- def __add__(self, value): return self.clone(float(self) + value)
- def __radd__(self, value): return self + value
- def __mul__(self, value): return self.clone(float(self) * value)
- def __rmul__(self, value): return self * value
- def __sub__(self, value): return self.clone(float(self) - value)
- def __rsub__(self, value): return self.clone(value - float(self))
- def __mod__(self, value): return self.clone(float(self) % value)
- def __rmod__(self, value): return self.clone(value % float(self))
- def __pow__(self, value, modulo=None): return self.clone(pow(float(self), value, modulo))
- def __rpow__(self, value): return self.clone(pow(value, float(self)))
-
- if sys.version_info[0] <= 2:
- def __div__(self, value): return self.clone(float(self) / value)
- def __rdiv__(self, value): return self.clone(value / float(self))
- else:
- def __truediv__(self, value): return self.clone(float(self) / value)
- def __rtruediv__(self, value): return self.clone(value / float(self))
- def __divmod__(self, value): return self.clone(float(self) // value)
- def __rdivmod__(self, value): return self.clone(value // float(self))
-
- def __int__(self): return int(float(self))
- if sys.version_info[0] <= 2:
- def __long__(self): return long(float(self))
- def __float__(self):
- if self._value in self._inf:
- return self._value
- else:
- return float(
- self._value[0] * pow(self._value[1], self._value[2])
- )
- def __abs__(self): return abs(float(self))
-
- def __lt__(self, value): return float(self) < value
- def __le__(self, value): return float(self) <= value
- def __eq__(self, value): return float(self) == value
- def __ne__(self, value): return float(self) != value
- def __gt__(self, value): return float(self) > value
- def __ge__(self, value): return float(self) >= value
-
- if sys.version_info[0] <= 2:
- def __nonzero__(self): return bool(float(self))
- else:
- def __bool__(self): return bool(float(self))
- __hash__ = base.AbstractSimpleAsn1Item.__hash__
-
- def __getitem__(self, idx):
- if self._value in self._inf:
- raise error.PyAsn1Error('Invalid infinite value operation')
- else:
- return self._value[idx]
-
-class Enumerated(Integer):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x0A)
- )
-
-# "Structured" ASN.1 types
-
-class SetOf(base.AbstractConstructedAsn1Item):
- componentType = None
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
- )
- typeId = 1
-
- def _cloneComponentValues(self, myClone, cloneValueFlag):
- idx = 0; l = len(self._componentValues)
- while idx < l:
- c = self._componentValues[idx]
- if c is not None:
- if isinstance(c, base.AbstractConstructedAsn1Item):
- myClone.setComponentByPosition(
- idx, c.clone(cloneValueFlag=cloneValueFlag)
- )
- else:
- myClone.setComponentByPosition(idx, c.clone())
- idx = idx + 1
-
- def _verifyComponent(self, idx, value):
- if self._componentType is not None and \
- not self._componentType.isSuperTypeOf(value):
- raise error.PyAsn1Error('Component type error %s' % (value,))
-
- def getComponentByPosition(self, idx): return self._componentValues[idx]
- def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
- l = len(self._componentValues)
- if idx >= l:
- self._componentValues = self._componentValues + (idx-l+1)*[None]
- if value is None:
- if self._componentValues[idx] is None:
- if self._componentType is None:
- raise error.PyAsn1Error('Component type not defined')
- self._componentValues[idx] = self._componentType.clone()
- self._componentValuesSet = self._componentValuesSet + 1
- return self
- elif not isinstance(value, base.Asn1Item):
- if self._componentType is None:
- raise error.PyAsn1Error('Component type not defined')
- if isinstance(self._componentType, base.AbstractSimpleAsn1Item):
- value = self._componentType.clone(value=value)
- else:
- raise error.PyAsn1Error('Instance value required')
- if verifyConstraints:
- if self._componentType is not None:
- self._verifyComponent(idx, value)
- self._verifySubtypeSpec(value, idx)
- if self._componentValues[idx] is None:
- self._componentValuesSet = self._componentValuesSet + 1
- self._componentValues[idx] = value
- return self
-
- def getComponentTagMap(self):
- if self._componentType is not None:
- return self._componentType.getTagMap()
-
- def prettyPrint(self, scope=0):
- scope = scope + 1
- r = self.__class__.__name__ + ':\n'
- for idx in range(len(self._componentValues)):
- r = r + ' '*scope
- if self._componentValues[idx] is None:
- r = r + '<empty>'
- else:
- r = r + self._componentValues[idx].prettyPrint(scope)
- return r
-
-class SequenceOf(SetOf):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
- )
- typeId = 2
-
-class SequenceAndSetBase(base.AbstractConstructedAsn1Item):
- componentType = namedtype.NamedTypes()
- def __init__(self, componentType=None, tagSet=None,
- subtypeSpec=None, sizeSpec=None):
- base.AbstractConstructedAsn1Item.__init__(
- self, componentType, tagSet, subtypeSpec, sizeSpec
- )
- if self._componentType is None:
- self._componentTypeLen = 0
- else:
- self._componentTypeLen = len(self._componentType)
-
- def __getitem__(self, idx):
- if isinstance(idx, str):
- return self.getComponentByName(idx)
- else:
- return base.AbstractConstructedAsn1Item.__getitem__(self, idx)
-
- def __setitem__(self, idx, value):
- if isinstance(idx, str):
- self.setComponentByName(idx, value)
- else:
- base.AbstractConstructedAsn1Item.__setitem__(self, idx, value)
-
- def _cloneComponentValues(self, myClone, cloneValueFlag):
- idx = 0; l = len(self._componentValues)
- while idx < l:
- c = self._componentValues[idx]
- if c is not None:
- if isinstance(c, base.AbstractConstructedAsn1Item):
- myClone.setComponentByPosition(
- idx, c.clone(cloneValueFlag=cloneValueFlag)
- )
- else:
- myClone.setComponentByPosition(idx, c.clone())
- idx = idx + 1
-
- def _verifyComponent(self, idx, value):
- if idx >= self._componentTypeLen:
- raise error.PyAsn1Error(
- 'Component type error out of range'
- )
- t = self._componentType[idx].getType()
- if not t.isSuperTypeOf(value):
- raise error.PyAsn1Error('Component type error %r vs %r' % (t, value))
-
- def getComponentByName(self, name):
- return self.getComponentByPosition(
- self._componentType.getPositionByName(name)
- )
- def setComponentByName(self, name, value=None, verifyConstraints=True):
- return self.setComponentByPosition(
- self._componentType.getPositionByName(name), value,
- verifyConstraints
- )
-
- def getComponentByPosition(self, idx):
- try:
- return self._componentValues[idx]
- except IndexError:
- if idx < self._componentTypeLen:
- return
- raise
- def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
- l = len(self._componentValues)
- if idx >= l:
- self._componentValues = self._componentValues + (idx-l+1)*[None]
- if value is None:
- if self._componentValues[idx] is None:
- self._componentValues[idx] = self._componentType.getTypeByPosition(idx).clone()
- self._componentValuesSet = self._componentValuesSet + 1
- return self
- elif not isinstance(value, base.Asn1Item):
- t = self._componentType.getTypeByPosition(idx)
- if isinstance(t, base.AbstractSimpleAsn1Item):
- value = t.clone(value=value)
- else:
- raise error.PyAsn1Error('Instance value required')
- if verifyConstraints:
- if self._componentTypeLen:
- self._verifyComponent(idx, value)
- self._verifySubtypeSpec(value, idx)
- if self._componentValues[idx] is None:
- self._componentValuesSet = self._componentValuesSet + 1
- self._componentValues[idx] = value
- return self
-
- def getNameByPosition(self, idx):
- if self._componentTypeLen:
- return self._componentType.getNameByPosition(idx)
-
- def getDefaultComponentByPosition(self, idx):
- if self._componentTypeLen and self._componentType[idx].isDefaulted:
- return self._componentType[idx].getType()
-
- def getComponentType(self):
- if self._componentTypeLen:
- return self._componentType
-
- def setDefaultComponents(self):
- if self._componentTypeLen == self._componentValuesSet:
- return
- idx = self._componentTypeLen
- while idx:
- idx = idx - 1
- if self._componentType[idx].isDefaulted:
- if self.getComponentByPosition(idx) is None:
- self.setComponentByPosition(idx)
- elif not self._componentType[idx].isOptional:
- if self.getComponentByPosition(idx) is None:
- raise error.PyAsn1Error(
- 'Uninitialized component #%s at %r' % (idx, self)
- )
-
- def prettyPrint(self, scope=0):
- scope = scope + 1
- r = self.__class__.__name__ + ':\n'
- for idx in range(len(self._componentValues)):
- if self._componentValues[idx] is not None:
- r = r + ' '*scope
- componentType = self.getComponentType()
- if componentType is None:
- r = r + '<no-name>'
- else:
- r = r + componentType.getNameByPosition(idx)
- r = '%s=%s\n' % (
- r, self._componentValues[idx].prettyPrint(scope)
- )
- return r
-
-class Sequence(SequenceAndSetBase):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
- )
- typeId = 3
-
- def getComponentTagMapNearPosition(self, idx):
- if self._componentType:
- return self._componentType.getTagMapNearPosition(idx)
-
- def getComponentPositionNearType(self, tagSet, idx):
- if self._componentType:
- return self._componentType.getPositionNearType(tagSet, idx)
- else:
- return idx
-
-class Set(SequenceAndSetBase):
- tagSet = baseTagSet = tag.initTagSet(
- tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
- )
- typeId = 4
-
- def getComponent(self, innerFlag=0): return self
-
- def getComponentByType(self, tagSet, innerFlag=0):
- c = self.getComponentByPosition(
- self._componentType.getPositionByType(tagSet)
- )
- if innerFlag and isinstance(c, Set):
- # get inner component by inner tagSet
- return c.getComponent(1)
- else:
- # get outer component by inner tagSet
- return c
-
- def setComponentByType(self, tagSet, value=None, innerFlag=0,
- verifyConstraints=True):
- idx = self._componentType.getPositionByType(tagSet)
- t = self._componentType.getTypeByPosition(idx)
- if innerFlag: # set inner component by inner tagSet
- if t.getTagSet():
- return self.setComponentByPosition(
- idx, value, verifyConstraints
- )
- else:
- t = self.setComponentByPosition(idx).getComponentByPosition(idx)
- return t.setComponentByType(
- tagSet, value, innerFlag, verifyConstraints
- )
- else: # set outer component by inner tagSet
- return self.setComponentByPosition(
- idx, value, verifyConstraints
- )
-
- def getComponentTagMap(self):
- if self._componentType:
- return self._componentType.getTagMap(True)
-
- def getComponentPositionByType(self, tagSet):
- if self._componentType:
- return self._componentType.getPositionByType(tagSet)
-
-class Choice(Set):
- tagSet = baseTagSet = tag.TagSet() # untagged
- sizeSpec = constraint.ConstraintsIntersection(
- constraint.ValueSizeConstraint(1, 1)
- )
- typeId = 5
- _currentIdx = None
-
- def __eq__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] == other
- return NotImplemented
- def __ne__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] != other
- return NotImplemented
- def __lt__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] < other
- return NotImplemented
- def __le__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] <= other
- return NotImplemented
- def __gt__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] > other
- return NotImplemented
- def __ge__(self, other):
- if self._componentValues:
- return self._componentValues[self._currentIdx] >= other
- return NotImplemented
- if sys.version_info[0] <= 2:
- def __nonzero__(self): return bool(self._componentValues)
- else:
- def __bool__(self): return bool(self._componentValues)
-
- def __len__(self): return self._currentIdx is not None and 1 or 0
-
- def verifySizeSpec(self):
- if self._currentIdx is None:
- raise error.PyAsn1Error('Component not chosen')
- else:
- self._sizeSpec(' ')
-
- def _cloneComponentValues(self, myClone, cloneValueFlag):
- try:
- c = self.getComponent()
- except error.PyAsn1Error:
- pass
- else:
- if isinstance(c, Choice):
- tagSet = c.getEffectiveTagSet()
- else:
- tagSet = c.getTagSet()
- if isinstance(c, base.AbstractConstructedAsn1Item):
- myClone.setComponentByType(
- tagSet, c.clone(cloneValueFlag=cloneValueFlag)
- )
- else:
- myClone.setComponentByType(tagSet, c.clone())
-
- def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
- l = len(self._componentValues)
- if idx >= l:
- self._componentValues = self._componentValues + (idx-l+1)*[None]
- if self._currentIdx is not None:
- self._componentValues[self._currentIdx] = None
- if value is None:
- if self._componentValues[idx] is None:
- self._componentValues[idx] = self._componentType.getTypeByPosition(idx).clone()
- self._componentValuesSet = 1
- self._currentIdx = idx
- return self
- elif not isinstance(value, base.Asn1Item):
- value = self._componentType.getTypeByPosition(idx).clone(
- value=value
- )
- if verifyConstraints:
- if self._componentTypeLen:
- self._verifyComponent(idx, value)
- self._verifySubtypeSpec(value, idx)
- self._componentValues[idx] = value
- self._currentIdx = idx
- self._componentValuesSet = 1
- return self
-
- def getMinTagSet(self):
- if self._tagSet:
- return self._tagSet
- else:
- return self._componentType.genMinTagSet()
-
- def getEffectiveTagSet(self):
- if self._tagSet:
- return self._tagSet
- else:
- c = self.getComponent()
- if isinstance(c, Choice):
- return c.getEffectiveTagSet()
- else:
- return c.getTagSet()
-
- def getTagMap(self):
- if self._tagSet:
- return Set.getTagMap(self)
- else:
- return Set.getComponentTagMap(self)
-
- def getComponent(self, innerFlag=0):
- if self._currentIdx is None:
- raise error.PyAsn1Error('Component not chosen')
- else:
- c = self._componentValues[self._currentIdx]
- if innerFlag and isinstance(c, Choice):
- return c.getComponent(innerFlag)
- else:
- return c
-
- def getName(self, innerFlag=0):
- if self._currentIdx is None:
- raise error.PyAsn1Error('Component not chosen')
- else:
- if innerFlag:
- c = self._componentValues[self._currentIdx]
- if isinstance(c, Choice):
- return c.getName(innerFlag)
- return self._componentType.getNameByPosition(self._currentIdx)
-
- def setDefaultComponents(self): pass
-
-class Any(OctetString):
- tagSet = baseTagSet = tag.TagSet() # untagged
- typeId = 6
-
- def getTagMap(self):
- return tagmap.TagMap(
- { self.getTagSet(): self },
- { eoo.endOfOctets.getTagSet(): eoo.endOfOctets },
- self
- )
-
-# XXX
-# coercion rules?
« no previous file with comments | « tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/tagmap.py ('k') | tools/telemetry/third_party/gsutilz/third_party/pyasn1/pyasn1/type/useful.py » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698