FM / pymacaroons

/usr/lib/python3/dist-packages/pymacaroons/

/usr/lib/python3/dist-packages/pymacaroons

Name	Size	Mode	Actions
binders/	-	0755	rm
caveat_delegates/	-	0755	rm
field_encryptors/	-	0755	rm
serializers/	-	0755	rm
__pycache__/	-	0755	rm
caveat.py	1974	0644	edit dl rm
exceptions.py	488	0644	edit dl rm
macaroon.py	4961	0644	edit dl rm
utils.py	3271	0644	edit dl rm
verifier.py	4177	0644	edit dl rm
__init__.py	391	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/pymacaroons/macaroon.py (4961B)

from __future__ import unicode_literals
import copy
from base64 import standard_b64encode

from pymacaroons.binders import HashSignaturesBinder
from pymacaroons.serializers.binary_serializer import BinarySerializer
from pymacaroons.exceptions import MacaroonInitException
from pymacaroons.utils import (
    convert_to_bytes,
    convert_to_string,
    create_initial_signature
)
from pymacaroons.caveat_delegates import (
    FirstPartyCaveatDelegate, ThirdPartyCaveatDelegate)

MACAROON_V1 = 1
MACAROON_V2 = 2

class Macaroon(object):

def __init__(self,
                 location=None,
                 identifier=None,
                 key=None,
                 caveats=None,
                 signature=None,
                 version=MACAROON_V1):
        if version > MACAROON_V2:
            version = MACAROON_V2
        self._version = version
        self.caveats = caveats or []
        self.location = location or ''
        self.identifier = identifier or ''
        self.signature = signature or ''
        self.first_party_caveat_delegate = FirstPartyCaveatDelegate()
        self.third_party_caveat_delegate = ThirdPartyCaveatDelegate()
        if key:
            self.signature = create_initial_signature(
                convert_to_bytes(key), self.identifier_bytes
            )

@classmethod
    def deserialize(cls, serialized, serializer=None):
        serializer = serializer or BinarySerializer()
        if serialized:
            return serializer.deserialize(serialized)
        else:
            raise MacaroonInitException(
                'Must supply serialized macaroon.'
            )

@property
    def location(self):
        return convert_to_string(self._location)

@location.setter
    def location(self, string_or_bytes):
        self._location = convert_to_bytes(string_or_bytes)

@property
    def version(self):
        return self._version

@property
    def identifier(self):
        if self.version == MACAROON_V1:
            return convert_to_string(self._identifier)
        return self._identifier

@property
    def identifier_bytes(self):
        return self._identifier

@identifier.setter
    def identifier(self, string_or_bytes):
        self._identifier = convert_to_bytes(string_or_bytes)

@property
    def signature(self):
        return convert_to_string(self._signature)

@signature.setter
    def signature(self, string_or_bytes):
        self._signature = convert_to_bytes(string_or_bytes)

@property
    def signature_bytes(self):
        return self._signature

def copy(self):
        return copy.deepcopy(self)

def serialize(self, serializer=None):
        serializer = serializer or BinarySerializer()
        return serializer.serialize(self)

def inspect(self):
        combined = 'location {loc}\n'.format(loc=self.location)
        try:
            combined += 'identifier {id}\n'.format(id=self.identifier)
        except UnicodeEncodeError:
            combined += 'identifier64 {id}\n'.format(id=convert_to_string(
                    standard_b64encode(self.identifier_bytes)
            ))
        for caveat in self.caveats:
            try:
                combined += 'cid {cid}\n'.format(
                    cid=convert_to_string(caveat.caveat_id))
            except UnicodeEncodeError:
                combined += 'cid64 {cid}\n'.format(cid=convert_to_string(
                    standard_b64encode(caveat.caveat_id_bytes)
                ))
            if caveat.verification_key_id and caveat.location:
                vid = convert_to_string(
                    standard_b64encode(caveat.verification_key_id)
                )
                combined += 'vid {vid}\n'.format(vid=vid)
                combined += 'cl {cl}\n'.format(cl=caveat.location)
        combined += 'signature {sig}'.format(sig=self.signature)
        return combined

def first_party_caveats(self):
        return [caveat for caveat in self.caveats if caveat.first_party()]

def third_party_caveats(self):
        return [caveat for caveat in self.caveats if caveat.third_party()]

def prepare_for_request(self, discharge_macaroon):
        ''' Return a new discharge macaroon bound to the receiving macaroon's
        current signature so that it can be used in a request.

This must be done before a discharge macaroon is sent to a server.

:param discharge_macaroon:
        :return: bound discharge macaroon
        '''
        protected = discharge_macaroon.copy()
        return HashSignaturesBinder(self).bind(protected)

def add_first_party_caveat(self, predicate, **kwargs):
        return self.first_party_caveat_delegate.add_first_party_caveat(
            self, predicate, **kwargs
        )

def add_third_party_caveat(self, location, key, key_id, **kwargs):
        return self.third_party_caveat_delegate.add_third_party_caveat(
            self, location, key, key_id, **kwargs
        )

cmd: