craftin/PGPy-3_13_patch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replaced TypedProperty with sdproperty; replaced ClassProperty with classproperty

Browse Source
This commit is contained in:
Michael Greene
2014-09-24 15:55:42 -07:00
parent 31ec94b191
commit 919c6357b2
10 changed files with 343 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
pgpy/constants.py
View File

@@ -15,6 +15,7 @@ import six
from cryptography.hazmat.backends import openssl
from cryptography.hazmat.primitives.ciphers import algorithms
from .decorators import classproperty
from .types import FlagEnum
@@ -22,11 +23,6 @@ from .types import FlagEnum
_hashtunedata = bytearray([10, 11, 12, 13, 14, 15, 16, 17] * 128 * 100)
class ClassProperty(property):
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class Backend(Enum):
OpenSSL = openssl.backend
@@ -254,8 +250,7 @@ class SignatureType(IntEnum):
Timestamp = 0x40
ThirdParty_Confirmation = 0x50
@ClassProperty
@classmethod
@classproperty
def certifications(cls):
return {SignatureType.Generic_Cert, SignatureType.Persona_Cert, SignatureType.Casual_Cert,
SignatureType.Positive_Cert, SignatureType.CertRevocation}

100
pgpy/decorators.py
View File

@@ -4,88 +4,56 @@ import contextlib
import functools
import warnings
from singledispatch import singledispatch
from .errors import PGPError
class TypedProperty(property):
def __init__(self, fget=None, fset=None, fdel=None, doc=None, **kwargs):
for k in kwargs:
setattr(self, k, kwargs[k])
def classproperty(fget):
class ClassProperty(object):
def __init__(self, fget):
self.fget = fget
self.__doc__ = fget.__doc__
super(TypedProperty, self).__init__(fget, fset, fdel, doc)
def __get__(self, cls, owner):
return self.fget(owner)
def __set__(self, obj, val):
##TODO: being able to detect subclasses would be cool
if 'fset' + val.__class__.__name__ in self.__dict__:
getattr(self, 'fset' + val.__class__.__name__)(obj, val)
def __set__(self, obj, value):
raise AttributeError("Read-only attribute")
# Python 2.7 shenanigans
##TODO: this is not ideal; fix it
elif bytes is str and val.__class__.__name__ in ['str', 'unicode']:
if 'fsetstr' in self.__dict__:
self.fsetstr(obj, str(val))
else:
self.fsetbytes(obj, val)
def __delete__(self, obj):
raise AttributeError("Read-only attribute")
else:
super(TypedProperty, self).__set__(obj, val)
return ClassProperty(fget)
def __getattr__(self, item):
def _typedsetter(ftypedsetter):
"""
This is a catch-all method for TypedProperty
So, when you decorate a class like so:
class A(object):
@TypedProperty
def a(self):
return self._a
@a.setter
def a(self, val):
self._a = val
@a.bytes
def a(self, val):
self._a = int.from_bytes(val, 'big')
@a.fsetbytes is set automagically and when val's type is 'bytes',
that setter is called instead of the default one
def sdmethod(meth):
sd = singledispatch(meth)
This should work with anything, because fset{x} is set by the setter, and selected by __class__.__name__
"""
cur_setters = dict((k, v) for k, v in self.__dict__.items()) # if k[:4] == 'fset' and k != 'fset'
if isinstance(ftypedsetter, TypedProperty):
# ftypedsetter at this point is a TypedProperty
# in this instance, something like this happened:
# class A(object):
# @TypedProperty
# def x(self):
# return self._x
# @x.bytearray
# @x.bytes
# def x(self, val):
# self._x = int.from_bytes(val, 'big')
#
# so we need to replace ftypedsetter with the function already wrapped in the instance in ftypedsetter
# it should be the only key in ftypedsetter.__dict__ that isn't in self.__dict__
diff = dict(set(ftypedsetter.__dict__.items()) - set(self.__dict__.items()))
if len(diff) > 0:
ftypedsetter = list(diff.values())[0]
cur_setters.update(diff.items())
def wrapper(obj, *args, **kwargs):
return sd.dispatch(args[0].__class__)(obj, *args, **kwargs)
cur_setters['fset' + item] = ftypedsetter
wrapper.register = sd.register
wrapper.dispatch = sd.dispatch
wrapper.registry = sd.registry
wrapper._clear_cache = sd._clear_cache
functools.update_wrapper(wrapper, meth)
return wrapper
return type(self)(self.fget, self.fset, self.fdel, self.__doc__, **cur_setters)
# this fixes some python 2.7/3.2 shenanigans
if item == '__isabstractmethod__':
raise AttributeError(item)
def sdproperty(fget):
def defset(obj, val):
raise TypeError(str(val.__class__))
if item in self.__dict__ or item in ['fset', 'fget', 'fdel', '__doc__']:
return self.__dict__[item]
class _(property):
def register(self, cls=None, fset=None):
return self.fset.register(cls, fset)
if 'fset' + item in self.__dict__:
return 'fset' + item in self.__dict__
def setter(self, fset):
self.register(object, fset)
return type(self)(self.fget, self.fset, self.fdel, self.__doc__)
return _typedsetter
return _(fget, sdmethod(defset))
class KeyAction(object):

38
pgpy/packet/fields.py
View File

@@ -23,7 +23,7 @@ from ..constants import HashAlgorithm
from ..constants import String2KeyType
from ..constants import SymmetricKeyAlgorithm
from ..decorators import TypedProperty
from ..decorators import sdproperty
from ..errors import PGPDecryptionError
@@ -444,48 +444,48 @@ class String2Key(Field):
After the hashing is done, the data is unloaded from the hash
context(s) as with the other S2K algorithms.
"""
@TypedProperty
@sdproperty
def encalg(self):
return self._encalg
@encalg.SymmetricKeyAlgorithm
def encalg(self, val):
@encalg.register(SymmetricKeyAlgorithm)
def encalg_(self, val):
self._encalg = val
@encalg.int
def encalg(self, val):
@encalg.register(int)
def encalg_(self, val):
self.encalg = SymmetricKeyAlgorithm(val)
@TypedProperty
@sdproperty
def specifier(self):
return self._specifier
@specifier.String2KeyType
def specifier(self, val):
@specifier.register(String2KeyType)
def specifier_(self, val):
self._specifier = val
@specifier.int
def specifier(self, val):
@specifier.register(int)
def specifier_(self, val):
self.specifier = String2KeyType(val)
@TypedProperty
@sdproperty
def halg(self):
return self._halg
@halg.HashAlgorithm
def halg(self, val):
@halg.register(HashAlgorithm)
def halg_(self, val):
self._halg = val
@halg.int
def halg(self, val):
@halg.register(int)
def halg_(self, val):
self.halg = HashAlgorithm(val)
@TypedProperty
@sdproperty
def count(self):
return (16 + (self._count & 15)) << ((self._count >> 4) + 6)
@count.int
def count(self, val):
@count.register(int)
def count_(self, val):
self._count = val
def __init__(self):

162
pgpy/packet/packets.py
View File

@@ -43,7 +43,7 @@ from ..constants import SymmetricKeyAlgorithm
from ..constants import TrustFlags
from ..constants import TrustLevel
from ..decorators import TypedProperty
from ..decorators import sdproperty
from ..errors import PGPDecryptionError
@@ -144,20 +144,20 @@ class PKESessionKeyV3(PKESessionKey):
"""
__ver__ = 3
@TypedProperty
@sdproperty
def encrypter(self):
return self._encrypter
@encrypter.bytearray
def encrypter(self, val):
@encrypter.register(bytearray)
def encrypter_(self, val):
self._encrypter = binascii.hexlify(val).upper().decode('latin-1')
@TypedProperty
@sdproperty
def pkalg(self):
return self._pkalg
@pkalg.PubKeyAlgorithm
def pkalg(self, val):
@pkalg.register(PubKeyAlgorithm)
def pkalg_(self, val):
self._pkalg = val
_c = {PubKeyAlgorithm.RSAEncryptOrSign: RSACipherText,
@@ -171,8 +171,8 @@ class PKESessionKeyV3(PKESessionKey):
else:
self.ct = None
@pkalg.int
def pkalg(self, val):
@pkalg.register(int)
def pkalg_(self, val):
self.pkalg = PubKeyAlgorithm(val)
def __init__(self):
@@ -309,24 +309,24 @@ class SignatureV4(Signature):
"""
__ver__ = 4
@TypedProperty
@sdproperty
def sigtype(self):
return self._sigtype
@sigtype.SignatureType
def sigtype(self, val):
@sigtype.register(SignatureType)
def sigtype_(self, val):
self._sigtype = val
@sigtype.int
def sigtype(self, val):
@sigtype.register(int)
def sigtype_(self, val):
self.sigtype = SignatureType(val)
@TypedProperty
@sdproperty
def pubalg(self):
return self._pubalg
@pubalg.PubKeyAlgorithm
def pubalg(self, val):
@pubalg.register(PubKeyAlgorithm)
def pubalg_(self, val):
self._pubalg = val
if val in [PubKeyAlgorithm.RSAEncryptOrSign, PubKeyAlgorithm.RSAEncrypt, PubKeyAlgorithm.RSASign]:
self.signature = RSASignature()
@@ -334,20 +334,20 @@ class SignatureV4(Signature):
elif val == PubKeyAlgorithm.DSA:
self.signature = DSASignature()
@pubalg.int
def pubalg(self, val):
@pubalg.register(int)
def pubalg_(self, val):
self.pubalg = PubKeyAlgorithm(val)
@TypedProperty
@sdproperty
def halg(self):
return self._halg
@halg.HashAlgorithm
def halg(self, val):
@halg.register(HashAlgorithm)
def halg_(self, val):
self._halg = val
@halg.int
def halg(self, val):
@halg.register(int)
def halg_(self, val):
try:
self.halg = HashAlgorithm(val)
@@ -576,24 +576,24 @@ class OnePassSignatureV3(OnePassSignature):
"""
__ver__ = 3
@TypedProperty
@sdproperty
def sigtype(self):
return self._sigtype
@sigtype.SignatureType
def sigtype(self, val):
@sigtype.register(SignatureType)
def sigtype_(self, val):
self._sigtype = val
@sigtype.int
def sigtype(self, val):
@sigtype.register(int)
def sigtype_(self, val):
self.sigtype = SignatureType(val)
@TypedProperty
@sdproperty
def pubalg(self):
return self._pubalg
@pubalg.PubKeyAlgorithm
def pubalg(self, val):
@pubalg.register(PubKeyAlgorithm)
def pubalg_(self, val):
self._pubalg = val
if val in [PubKeyAlgorithm.RSAEncryptOrSign, PubKeyAlgorithm.RSAEncrypt, PubKeyAlgorithm.RSASign]:
self.signature = RSASignature()
@@ -601,37 +601,37 @@ class OnePassSignatureV3(OnePassSignature):
elif val == PubKeyAlgorithm.DSA:
self.signature = DSASignature()
@pubalg.int
def pubalg(self, val):
@pubalg.register(int)
def pubalg_(self, val):
self.pubalg = PubKeyAlgorithm(val)
@TypedProperty
@sdproperty
def halg(self):
return self._halg
@halg.HashAlgorithm
def halg(self, val):
@halg.register(HashAlgorithm)
def halg_(self, val):
self._halg = val
@halg.int
def halg(self, val):
@halg.register(int)
def halg_(self, val):
try:
self.halg = HashAlgorithm(val)
except ValueError:
self._halg = val
@TypedProperty
@sdproperty
def signer(self):
return self._signer
@signer.str
def signer(self, val):
@signer.register(str)
def signer_(self, val):
self._signer = val
@signer.bytes
@signer.bytearray
def signer(self, val):
@signer.register(bytes)
@signer.register(bytearray)
def signer_(self, val):
self.signer = binascii.hexlify(val).upper().decode('latin-1')
def __init__(self):
@@ -687,29 +687,29 @@ class PubKey(VersionedPacket, Primary, Public):
class PubKeyV4(PubKey):
__ver__ = 4
@TypedProperty
@sdproperty
def created(self):
return self._created
@created.datetime
def created(self, val):
@created.register(datetime)
def created_(self, val):
self._created = val
@created.int
def created(self, val):
@created.register(int)
def created_(self, val):
self.created = datetime.utcfromtimestamp(val)
@created.bytearray
@created.bytes
def created(self, val):
@created.register(bytes)
@created.register(bytearray)
def created_(self, val):
self.created = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def pkalg(self):
return self._pkalg
@pkalg.PubKeyAlgorithm
def pkalg(self, val):
@pkalg.register(PubKeyAlgorithm)
def pkalg_(self, val):
self._pkalg = val
_c = {
@@ -737,8 +737,8 @@ class PubKeyV4(PubKey):
else:
self.keymaterial = None
@pkalg.int
def pkalg(self, val):
@pkalg.register(int)
def pkalg_(self, val):
self.pkalg = PubKeyAlgorithm(val)
@property
@@ -859,16 +859,16 @@ class CompressedData(Packet):
"""
__typeid__ = 0x08
@TypedProperty
@sdproperty
def calg(self):
return self._calg
@calg.CompressionAlgorithm
def calg(self, val):
@calg.register(CompressionAlgorithm)
def calg_(self, val):
self._calg = val
@calg.int
def calg(self, val):
@calg.register(int)
def calg_(self, val):
self.calg = CompressionAlgorithm(val)
def __init__(self):
@@ -1010,21 +1010,21 @@ class LiteralData(Packet):
"""
__typeid__ = 0x0B
@TypedProperty
@sdproperty
def mtime(self):
return self._mtime
@mtime.datetime
def mtime(self, val):
@mtime.register(datetime)
def mtime_(self, val):
self._mtime = val
@mtime.int
def mtime(self, val):
@mtime.register(int)
def mtime_(self, val):
self.mtime = datetime.utcfromtimestamp(val)
@mtime.bytes
@mtime.bytearray
def mtime(self, val):
@mtime.register(bytes)
@mtime.register(bytearray)
def mtime_(self, val):
self.mtime = self.bytes_to_int(val)
@property
@@ -1089,28 +1089,28 @@ class Trust(Packet):
"""
__typeid__ = 0x0C
@TypedProperty
@sdproperty
def trustlevel(self):
return self._trustlevel
@trustlevel.TrustLevel
def trustlevel(self, val):
@trustlevel.register(TrustLevel)
def trustlevel_(self, val):
self._trustlevel = val
@trustlevel.int
def trustlevel(self, val):
@trustlevel.register(int)
def trustlevel_(self, val):
self.trustlevel = TrustLevel(val & 0x0F)
@TypedProperty
@sdproperty
def trustflags(self):
return self._trustflags
@trustflags.list
def trustflags(self, val):
@trustflags.register(list)
def trustflags_(self, val):
self._trustflags = val
@trustflags.int
def trustflags(self, val):
@trustflags.register(int)
def trustflags_(self, val):
self._trustflags = TrustFlags & val
def __init__(self):

312
pgpy/packet/subpackets/signature.py
View File

@@ -8,6 +8,8 @@ import calendar
from datetime import datetime
from datetime import timedelta
import six
from .types import EmbeddedSignatureHeader
from .types import Signature
@@ -22,23 +24,23 @@ from ...constants import RevocationKeyClass
from ...constants import RevocationReason
from ...constants import SymmetricKeyAlgorithm
from ...decorators import TypedProperty
from ...decorators import sdproperty
from ...types import Fingerprint
class URI(Signature):
@TypedProperty
@sdproperty
def uri(self):
return self._uri
@uri.str
def uri(self, val):
@uri.register(str)
def uri_(self, val):
self._uri = val
@uri.bytearray
@uri.bytes
def uri(self, val):
@uri.register(bytes)
@uri.register(bytearray)
def uri_(self, val):
self.uri = val.decode('latin-1')
def __init__(self):
@@ -59,31 +61,31 @@ class URI(Signature):
class FlagList(Signature):
__flags__ = None
@TypedProperty
@sdproperty
def flags(self):
return self._flags
@flags.list
def flags(self, val):
@flags.register(list)
def flags_(self, val):
self._flags = val
@flags.CompressionAlgorithm
@flags.HashAlgorithm
@flags.PubKeyAlgorithm
@flags.SymmetricKeyAlgorithm
def flags(self, val):
@flags.register(CompressionAlgorithm)
@flags.register(HashAlgorithm)
@flags.register(PubKeyAlgorithm)
@flags.register(SymmetricKeyAlgorithm)
def flags_(self, val):
self.flags.append(val)
@flags.int
def flags(self, val):
@flags.register(int)
def flags_(self, val):
if self.__flags__ is None:
raise AttributeError("Error: __flags__ not set!")
self.flags.append(self.__flags__(val))
@flags.bytearray
@flags.bytes
def flags(self, val):
@flags.register(bytes)
@flags.register(bytearray)
def flags_(self, val):
self.flags = self.bytes_to_int(val)
def __init__(self):
@@ -105,27 +107,28 @@ class FlagList(Signature):
class ByteFlag(Signature):
__flags__ = None
@TypedProperty
@sdproperty
def flags(self):
return self._flags
@flags.list
def flags(self, val):
@flags.register(set)
@flags.register(list)
def flags_(self, val):
self._flags = val
@flags.KeyFlags
def flags(self, val):
@flags.register(_KeyFlags)
def flags_(self, val):
self.flags.append(val)
@flags.int
def flags(self, val):
@flags.register(int)
def flags_(self, val):
if self.__flags__ is None:
raise AttributeError("Error: __flags__ not set!")
self.flags += self.__flags__ & val
@flags.bytearray
@flags.bytes
def flags(self, val):
@flags.register(bytes)
@flags.register(bytearray)
def flags_(self, val):
self.flags = self.bytes_to_int(val)
def __init__(self):
@@ -145,26 +148,26 @@ class ByteFlag(Signature):
class Boolean(Signature):
@TypedProperty
def bool(self):
@sdproperty
def bflag(self):
return self._bool
@bool.bool
def bool(self, val):
@bflag.register(bool)
def bflag_(self, val):
self._bool = val
@bool.bytearray
@bool.bytes
def bool(self, val):
@bflag.register(bytes)
@bflag.register(bytearray)
def bflag_(self, val):
self.bool = bool(self.bytes_to_int(val))
def __init__(self):
super(Boolean, self).__init__()
self.bool = False
self.bflag = False
def __bytes__(self):
_bytes = super(Boolean, self).__bytes__()
_bytes += self.int_to_bytes(int(self.bool))
_bytes += self.int_to_bytes(int(self.bflag))
return _bytes
def __bool__(self): # pragma: no cover
@@ -173,11 +176,11 @@ class Boolean(Signature):
# Python 2.7
def __nonzero__(self): # pragma: no cover
return self.bool
return self.__bool__()
def parse(self, packet):
super(Boolean, self).parse(packet)
self.bool = packet[:1]
self.bflag = packet[:1]
del packet[:1]
@@ -193,21 +196,21 @@ class CreationTime(Signature):
"""
__typeid__ = 0x02
@TypedProperty
@sdproperty
def created(self):
return self._created
@created.datetime
def created(self, val):
@created.register(datetime)
def created_(self, val):
self._created = val
@created.int
def created(self, val):
@created.register(int)
def created_(self, val):
self.created = datetime.utcfromtimestamp(val)
@created.bytearray
@created.bytes
def created(self, val):
@created.register(bytes)
@created.register(bytearray)
def created_(self, val):
self.created = self.bytes_to_int(val)
def __init__(self):
@@ -237,21 +240,21 @@ class SignatureExpirationTime(Signature):
"""
__typeid__ = 0x03
@TypedProperty
@sdproperty
def expires(self):
return self._expires
@expires.timedelta
def expires(self, val):
@expires.register(timedelta)
def expires_(self, val):
self._expires = val
@expires.int
def expires(self, val):
@expires.register(int)
def expires_(self, val):
self.expires = timedelta(seconds=val)
@expires.bytearray
@expires.bytes
def expires(self, val):
@expires.register(bytes)
@expires.register(bytearray)
def expires_(self, val):
self.expires = self.bytes_to_int(val)
def __init__(self):
@@ -323,31 +326,31 @@ class TrustSignature(Signature):
"""
__typeid__ = 0x05
@TypedProperty
@sdproperty
def level(self):
return self._level
@level.int
def level(self, val):
@level.register(int)
def level_(self, val):
self._level = val
@level.bytearray
@level.bytes
def level(self, val):
@level.register(bytes)
@level.register(bytearray)
def level_(self, val):
self.level = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def amount(self):
return self._amount
@amount.int
def amount(self, val):
@amount.register(int)
def amount_(self, val):
# clamp 'val' to the range 0-255
self._amount = max(0, min(val, 255))
@amount.bytearray
@amount.bytes
def amount(self, val):
@amount.register(bytes)
@amount.register(bytearray)
def amount_(self, val):
self.amount = self.bytes_to_int(val)
def __init__(self):
@@ -385,17 +388,17 @@ class RegularExpression(Signature):
"""
__typeid__ = 0x06
@TypedProperty
@sdproperty
def regex(self):
return self._regex
@regex.str
def regex(self, val):
@regex.register(str)
def regex_(self, val):
self._regex = val
@regex.bytearray
@regex.bytes
def regex(self, val):
@regex.register(bytes)
@regex.register(bytearray)
def regex_(self, val):
self.regex = val.decode('latin-1')
def __init__(self):
@@ -485,59 +488,60 @@ class RevocationKey(Signature):
"""
__typeid__ = 0x0C
@TypedProperty
@sdproperty
def keyclass(self):
return self._keyclass
@keyclass.list
def keyclass(self, val):
@keyclass.register(list)
def keyclass_(self, val):
self._keyclass = val
@keyclass.RevocationKeyClass
def keyclass(self, val):
@keyclass.register(RevocationKeyClass)
def keyclass_(self, val):
self.keyclass.append(val)
@keyclass.int
def keyclass(self, val):
@keyclass.register(int)
def keyclass_(self, val):
self.keyclass += RevocationKeyClass & val
@keyclass.bytearray
@keyclass.bytes
def keyclass(self, val):
@keyclass.register(bytes)
@keyclass.register(bytearray)
def keyclass_(self, val):
self.keyclass = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def algorithm(self):
return self._algorithm
@algorithm.PubKeyAlgorithm
def algorithm(self, val):
@algorithm.register(PubKeyAlgorithm)
def algorithm_(self, val):
self._algorithm = val
@algorithm.int
def algorithm(self, val):
@algorithm.register(int)
def algorithm_(self, val):
self.algorithm = PubKeyAlgorithm(val)
@algorithm.bytearray
@algorithm.bytes
def algorithm(self, val):
@algorithm.register(bytes)
@algorithm.register(bytearray)
def algorithm_(self, val):
self.algorithm = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def fingerprint(self):
return self._fingerprint
@fingerprint.Fingerprint
def fingerprint(self, val):
@fingerprint.register(Fingerprint)
def fingerprint_(self, val):
self._fingerprint = val
@fingerprint.str
def fingerprint(self, val):
@fingerprint.register(str)
@fingerprint.register(six.text_type)
def fingerprint_(self, val):
self.fingerprint = Fingerprint(val)
@fingerprint.bytearray
@fingerprint.bytes
def fingerprint(self, val):
@fingerprint.register(bytes)
@fingerprint.register(bytearray)
def fingerprint_(self, val):
self.fingerprint = ''.join('{:02x}'.format(c) for c in val).upper()
def __init__(self):
@@ -566,12 +570,12 @@ class RevocationKey(Signature):
class Issuer(Signature):
__typeid__ = 0x10
@TypedProperty
@sdproperty
def issuer(self):
return self._issuer
@issuer.bytearray
def issuer(self, val):
@issuer.register(bytearray)
def issuer_(self, val):
self._issuer = binascii.hexlify(val).upper().decode('latin-1')
def __init__(self):
@@ -592,50 +596,51 @@ class Issuer(Signature):
class NotationData(Signature):
__typeid__ = 0x14
@TypedProperty
@sdproperty
def flags(self):
return self._flags
@flags.list
def flags(self, val):
@flags.register(list)
def flags_(self, val):
self._flags = val
@flags.NotationDataFlags
def flags(self, val):
@flags.register(NotationDataFlags)
def flags_(self, val):
self.flags.append(val)
@flags.int
def flags(self, val):
@flags.register(int)
def flags_(self, val):
self.flags += NotationDataFlags & val
@flags.bytearray
@flags.bytes
def flags(self, val):
@flags.register(bytes)
@flags.register(bytearray)
def flags_(self, val):
self.flags = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def name(self):
return self._name
@name.str
def name(self, val):
@name.register(str)
@name.register(six.text_type)
def name_(self, val):
self._name = val
@name.bytearray
@name.bytes
def name(self, val):
@name.register(bytes)
@name.register(bytearray)
def name_(self, val):
self.name = val.decode('latin-1')
@TypedProperty
@sdproperty
def value(self):
return self._value
@value.str
def value(self, val):
@value.register(str)
def value_(self, val):
self._value = val
@value.bytearray
@value.bytes
@value.register(bytes)
@value.register(bytearray)
def value(self, val):
if NotationDataFlags.HumanReadable in self.flags:
self.value = val.decode('latin-1')
@@ -694,17 +699,17 @@ class PreferredKeyServer(URI):
class PrimaryUserID(Signature):
__typeid__ = 0x19
@TypedProperty
@sdproperty
def primary(self):
return self._primary
@primary.bool
def primary(self, val):
@primary.register(bool)
def primary_(self, val):
self._primary = val
@primary.bytearray
@primary.bytes
def primary(self, val):
@primary.register(bytes)
@primary.register(bytearray)
def primary_(self, val):
self.primary = bool(self.bytes_to_int(val))
def __init__(self):
@@ -734,17 +739,17 @@ class KeyFlags(ByteFlag):
class SignersUserID(Signature):
__typeid__ = 0x1C
@TypedProperty
@sdproperty
def userid(self):
return self._userid
@userid.str
def userid(self, val):
@userid.register(str)
def userid_(self, val):
self._userid = val
@userid.bytearray
@userid.bytes
def userid(self, val):
@userid.register(bytes)
@userid.register(bytearray)
def userid_(self, val):
self.userid = val.decode('latin-1')
def __init__(self):
@@ -765,34 +770,35 @@ class SignersUserID(Signature):
class ReasonForRevocation(Signature):
__typeid__ = 0x1D
@TypedProperty
@sdproperty
def code(self):
return self._code
@code.RevocationReason
def code(self, val):
@code.register(RevocationReason)
def code_(self, val):
self._code = val
@code.int
def code(self, val):
@code.register(int)
def code_(self, val):
self.code = RevocationReason(val)
@code.bytearray
@code.bytes
def code(self, val):
@code.register(bytes)
@code.register(bytearray)
def code_(self, val):
self.code = self.bytes_to_int(val)
@TypedProperty
@sdproperty
def string(self):
return self._string
@string.str
def string(self, val):
@string.register(str)
@string.register(six.text_type)
def string_(self, val):
self._string = val
@string.bytearray
@string.bytes
def string(self, val):
@string.register(bytes)
@string.register(bytearray)
def string_(self, val):
self.string = val.decode('latin-1')
def __init__(self):
@@ -825,11 +831,11 @@ class Features(ByteFlag):
class EmbeddedSignature(Signature):
__typeid__ = 0x20
@TypedProperty
@sdproperty
def _sig(self):
return self._sigpkt
@_sig.SignatureV4
@_sig.setter
def _sig(self, val):
self._sig = val

29
pgpy/packet/subpackets/types.py
View File

@@ -4,31 +4,32 @@ import abc
from ..types import VersionedHeader
from ...decorators import TypedProperty
from ...decorators import sdproperty
from ...types import Dispatchable
from ...types import Header as _Header
class Header(_Header):
@TypedProperty
@sdproperty
def critical(self):
return self._critical
@critical.bool
def critical(self, val):
@critical.register(bool)
def critical_(self, val):
self._critical = val
@TypedProperty
@sdproperty
def typeid(self):
return self._typeid
@typeid.int
def typeid(self, val):
@typeid.register(int)
def typeid_(self, val):
self._typeid = val & 0x7f
@typeid.bytearray
@typeid.bytes
def typeid(self, val):
@typeid.register(bytes)
@typeid.register(bytearray)
def typeid_(self, val):
v = self.bytes_to_int(val)
self.typeid = v
self.critical = bool(v & 0x80)
@@ -106,13 +107,13 @@ class UserAttribute(SubPacket):
class Opaque(Signature, UserAttribute):
__typeid__ = None
@TypedProperty
@sdproperty
def payload(self):
return self._payload
@payload.bytearray
@payload.bytes
def payload(self, val):
@payload.register(bytes)
@payload.register(bytearray)
def payload_(self, val):
self._payload = val
def __init__(self):

24
pgpy/packet/subpackets/userattribute.py
View File

@@ -6,7 +6,7 @@ from .types import UserAttribute
from ...constants import ImageEncoding
from ...decorators import TypedProperty
from ...decorators import sdproperty
class Image(UserAttribute):
@@ -45,36 +45,36 @@ class Image(UserAttribute):
"""
__typeid__ = 0x01
@TypedProperty
@sdproperty
def version(self):
return self._version
@version.int
def version(self, val):
@version.register(int)
def version_(self, val):
self._version = val
@TypedProperty
@sdproperty
def iencoding(self):
return self._iencoding
@iencoding.ImageEncoding
def iencoding(self, val):
@iencoding.register(ImageEncoding)
def iencoding_ie(self, val):
self._iencoding = val
@iencoding.int
def iencoding(self, val):
@iencoding.register(int)
def iencoding_int(self, val):
try:
self.iencoding = ImageEncoding(val)
except ValueError:
self._iencoding = val
@TypedProperty
@sdproperty
def image(self):
return self._image
@image.bytearray
@image.bytes
@image.register(bytes)
@image.register(bytearray)
def image(self, val):
self._image = bytearray(val)

20
pgpy/packet/types.py
View File

@@ -6,7 +6,7 @@ import abc
import six
from ..decorators import TypedProperty
from ..decorators import sdproperty
from ..types import Dispatchable
from ..types import Field
@@ -14,12 +14,12 @@ from ..types import Header as _Header
class Header(_Header):
@TypedProperty
@sdproperty
def tag(self):
return self._tag
@tag.int
def tag(self, val):
@tag.register(int)
def tag_int(self, val):
self._tag = (val & 0x3F) if self._lenfmt else ((val & 0x3C) >> 2)
@property
@@ -94,12 +94,12 @@ class Header(_Header):
class VersionedHeader(Header):
@TypedProperty
@sdproperty
def version(self):
return self._version
@version.int
def version(self, val):
@version.register(int)
def version_int(self, val):
self._version = val
def __init__(self):
@@ -164,12 +164,12 @@ class VersionedPacket(Packet):
class Opaque(Packet):
__typeid__ = None
@TypedProperty
@sdproperty
def payload(self):
return self._payload
@payload.bytearray
@payload.bytes
@payload.register(bytearray)
@payload.register(bytes)
def payload(self, val):
self._payload = val

20
pgpy/types.py
View File

@@ -20,7 +20,7 @@ import six
from ._author import __version__
from .decorators import TypedProperty
from .decorators import sdproperty
# for Python 2.7
if six.PY2:
@@ -299,17 +299,17 @@ class Header(Field):
return _new_length(l) if nhf else _old_length(l, llen)
@TypedProperty
@sdproperty
def length(self):
return self._len
@length.int
def length(self, val):
@length.register(int)
def length_int(self, val):
self._len = val
@length.bytearray
@length.bytes
def length(self, val):
@length.register(six.binary_type)
@length.register(bytearray)
def length_bin(self, val):
def _new_len(b):
fo = b[0]
@@ -339,7 +339,7 @@ class Header(Field):
_new_len(val) if self._lenfmt == 1 else _old_len(val)
@TypedProperty
@sdproperty
def llen(self):
l = self.length
lf = self._lenfmt
@@ -360,8 +360,8 @@ class Header(Field):
##TODO: what if _llen needs to be (re)computed?
return self._llen
@llen.int
def llen(self, val):
@llen.register(int)
def llen_int(self, val):
if self._lenfmt == 0:
self._llen = {0: 1, 1: 2, 2: 4, 3: 0}[val]

1
requirements.txt
View File

@@ -2,3 +2,4 @@ cryptography==0.5.4
requests
enum34
six
singledispatch