Synnefo » ./kamaki

        cnt_back_up = self.container

        try:

            self.container = container or cnt_back_up

        finally:

            self.container = cnt_back_up

    def upload_object_unchunked(

            self, obj, f,

            f = StringIO(data)

        else:

            data = f.read(size) if size else f.read()

            obj,

            data=data,

            etag=etag,

            permissions=sharing,

            public=public,

            success=201)

    def create_object_by_manifestation(

            self, obj,

        :param public: (bool)

        """

        self._assert_container()

            obj,

            content_length=0,

            etag=etag,

            permissions=sharing,

            public=public,

            manifest='%s/%s' % (self.container, obj))

    # upload_* auxiliary methods

    def _put_block_async(self, data, hash, upload_gen=None):

            permissions=permissions,

            public=public,

            success=success)

    def _culculate_blocks_for_upload(

            self, blocksize, blockhash, size, nblocks, hashes, hmap, fileobj,

                thread.join()

            raise

            obj,

            format='json',

            hashmap=True,

            content_type=content_type,

            json=hashmap,

            success=201)

    # download_* auxiliary methods

    def _get_remote_blocks_info(self, obj, **restargs):

        :param usernames: (list)

        """

    def del_account_group(self, group):

        """

        :param group: (str)

        """

    def get_account_info(self, until=None):

        """

        :param metapairs: (dict) {key1:val1, key2:val2, ...}

        """

        assert(type(metapairs) is dict)

    def del_account_meta(self, metakey):

        """

        :param metakey: (str) metadatum key

        """

    def set_account_quota(self, quota):

        """

        :param quota: (int)

        """

    def set_account_versioning(self, versioning):

        """

        "param versioning: (str)

        """

    def list_containers(self):

        """

            until=until,

            delimiter=delimiter,

            success=(204, 404, 409))

        if r.status_code == 404:

            raise ClientError(

                'Container "%s" does not exist' % self.container,

        :param metapairs: (dict) {key1:val1, key2:val2, ...}

        """

        assert(type(metapairs) is dict)

    def del_container_meta(self, metakey):

        """

        :param metakey: (str) metadatum key

        """

    def set_container_quota(self, quota):

        """

        :param quota: (int)

        """

    def set_container_versioning(self, versioning):

        """

        :param versioning: (str)

        """

    def del_object(self, obj, until=None, delimiter=None):

        """

        :param delimiter: (str)

        """

        self._assert_container()

    def set_object_meta(self, obj, metapairs):

        """

        :param metapairs: (dict) {key1:val1, key2:val2, ...}

        """

        assert(type(metapairs) is dict)

    def del_object_meta(self, obj, metakey):

        """

        :param metakey: (str) metadatum key

        """

    def publish_object(self, obj):

        """

        :returns: (str) access url

        """

        info = self.get_object_info(obj)

        pref, sep, rest = self.base_url.partition('//')

        base = rest.split('/')[0]

        """

        :param obj: (str) remote object path

        """

    def get_object_info(self, obj, version=None):

        """

        """

        perms = dict(read=read_permition or '', write=write_permition or '')

    def del_object_sharing(self, obj):

        """

        for i in range(nblocks):

            block = source_file.read(min(blocksize, filesize - offset))

            offset += len(block)

                obj,

                update=True,

                content_range='bytes */*',

                content_type='application/octet-stream',

                content_length=len(block),

                data=block)

            if upload_cb:

                upload_gen.next()

        :param upto_bytes: max number of bytes to leave on file

        """

            obj,

            update=True,

            content_range='bytes 0-%s/*' % upto_bytes,

            content_type='application/octet-stream',

            object_bytes=upto_bytes,

            source_object=path4url(self.container, obj))

    def overwrite_object(self, obj, start, end, source_file, upload_cb=None):

        """Overwrite a part of an object from local source file

        for i in range(nblocks):

            read_size = min(blocksize, filesize - offset, datasize - offset)

            block = source_file.read(read_size)

                obj,

                update=True,

                content_type='application/octet-stream',

                    start + offset + len(block) - 1),

                data=block)

            offset += len(block)

            if upload_cb:

                upload_gen.next()

        self._assert_account()

        self.container = dst_container

        src_path = path4url(src_container, src_object)

            dst_object or src_object,

            success=201,

            copy_from=src_path,

            public=public,

            content_type=content_type,

            delimiter=delimiter)

    def move_object(

            self, src_container, src_object, dst_container,

        self.container = dst_container

        dst_object = dst_object or src_object

        src_path = path4url(src_container, src_object)

            dst_object,

            success=201,

            move_from=src_path,

            public=public,

            content_type=content_type,

            delimiter=delimiter)

    def get_sharing_accounts(self, limit=None, marker=None, *args, **kwargs):

        """Get accounts that share with self.account