How to use the oss2.utils function in oss2

def make_get_encrypted_object(key, content, content_crypto_material, invalid_cek_alg='', ranges=None):
    request_text = '''GET /{0} HTTP/1.1
Host: ming-oss-share.oss-cn-hangzhou.aliyuncs.com
Accept-Encoding: identity
Connection: keep-alive
date: Sat, 12 Dec 2015 00:35:53 GMT
User-Agent: aliyun-sdk-python/2.0.2(Windows/7/;3.3.3)
Accept: */*
authorization: OSS ZCDmm7TPZKHtx77j:PAedG7U86ZxQ2WTB+GdpSltoiTI='''.format(key)

    encrypted_key = utils.b64encode_as_string(content_crypto_material.encrypted_key)
    encrypted_iv = utils.b64encode_as_string(content_crypto_material.encrypted_iv)
    wrap_alg = content_crypto_material.wrap_alg
    cek_alg = content_crypto_material.cek_alg
    if invalid_cek_alg:
        cek_alg = invalid_cek_alg
    cipher = content_crypto_material.cipher

    encrypted_content = cipher.encrypt(content)

    response_text = '''HTTP/1.1 200 OK
Server: AliyunOSS
Date: Sat, 12 Dec 2015 00:35:53 GMT
Content-Type: text/plain
Content-Length: {0}
Connection: keep-alive
x-oss-request-id: 566B6BE93A7B8CFD53D4BAA3

def test_oss_utils_negative(self):
        try:
            oss2.utils.makedir_p('/')
            self.assertTrue(False)
        except:
            pass
        
        try:
            oss2.utils.silently_remove('/')
            self.assertTrue(False)
        except:
            pass
        
        try:
            oss2.utils.force_rename('/', '/')
            self.assertTrue(False)
        except:
            pass
        
        oss2.utils.makedir_p('xyz')
        oss2.utils.makedir_p('zyz')
        try:
            oss2.utils.force_rename('xyz', 'zyx')
            self.assertTrue(False)
        except:
            pass

def test_crypto_get_compact_deprecated_kms(self, do_request):
        content = b'a' * 1024 * 1024
        encrypted_kms_path = "tests/deprecated_encrypted_1MB_a_kms"
        encrypted_meta_kms_path = "tests/deprecated_encrypted_1MB_a_meta_kms.json"

        with open(encrypted_kms_path, 'rb') as f:
            encrypted_content = f.read()

        with open(encrypted_meta_kms_path, 'r') as f:
            meta = json.loads(f.read())

        key = random_string(10)
        provider = oss2.AliKMSProvider(OSS_ID, OSS_SECRET, OSS_REGION, OSS_CMK)

        request_text, response_text = make_get_encrypted_object_compact_deprecated(key, encrypted_content, meta)
        plain_key = utils.b64decode_from_string(meta['base64-plain-key'])
        plain_start = meta['plain-start']

        req_info = unittests.common.mock_response(do_request, response_text)
        with patch('oss2.AliKMSProvider.decrypt_encrypted_key', return_value=plain_key):
            with patch('oss2.AliKMSProvider.decrypt_encrypted_iv', return_value=plain_start):
                result = unittests.common.bucket(provider).get_object(key)

        self.assertRequest(req_info, request_text)
        self.assertEqual(result.read(), content)

stats['previous'] = bytes_consumed
            stats['ncalled'] += 1

        key = random_string(16)
        content = random_bytes(5 * 100 * 1024 + 100)

        pathname = self._prepare_temp_file(content)

        part_size = 100 * 1024
        oss2.resumable_upload(bucket, key, pathname,
                              multipart_threshold=200 * 1024,
                              part_size=part_size,
                              progress_callback=progress_callback,
                              num_threads=1)
        self.assertEqual(stats['previous'], len(content))
        self.assertEqual(stats['ncalled'], oss2.utils.how_many(len(content), part_size) + 1)

        stats = {'previous': -1, 'ncalled': 0}
        oss2.resumable_upload(bucket, key, pathname,
                              multipart_threshold=len(content) + 100,
                              progress_callback=progress_callback)
        self.assertEqual(stats['previous'], len(content))

        bucket.delete_object(key)

def __init__(self, file_object, size, content_length=None):
        self.f = oss2.utils.SizedFileAdapter(file_object, size)
        self.content_length = content_length
        self.request_id = 'fake-request-id'

parts = []
            data_size = 1024 * 500
            part_size = 1024 * 200

            context = models.MultipartUploadCryptoContext(data_size, part_size)
            init_result = crypto_bucket.init_multipart_upload(key, upload_context=context)
            self.assertTrue(init_result.status == 200)
            upload_id = init_result.upload_id

            if upload_contexts_flag:
                context = None

            for i in range(3):
                if do_md5:
                    headers = {'Content-Md5': oss2.utils.content_md5(content[i])}
                else:
                    headers = None
                upload_result = crypto_bucket.upload_part(key, upload_id, i + 1, content[i], headers=headers,
                                                          upload_context=context)
                parts.append(oss2.models.PartInfo(i + 1, upload_result.etag, size=len(content[i]),
                                                  part_crc=upload_result.crc))
                self.assertTrue(upload_result.status == 200)
                self.assertTrue(upload_result.crc is not None)

            complete_result = crypto_bucket.complete_multipart_upload(key, upload_id, parts)
            self.assertTrue(complete_result.status == 200)

            get_result_range_1 = crypto_bucket.get_object(key, byte_range=(0, 204799))
            self.assertTrue(get_result_range_1.status == 206)
            content_got_1 = get_result_range_1.read()
            self.assertEqual(content_1, content_got_1)

def test_ali_kms_provider_basic(self):
        provider = AliKMSProvider(OSS_ID, OSS_SECRET, OSS_CMK_REGION, OSS_CMK, passphrase=random_string(8))
        self.assertEqual(provider.wrap_alg, "KMS/ALICLOUD")
        self.assertEqual(provider.cipher.alg, "AES/CTR/NoPadding")
        plain_key, encrypted_key = provider.get_key()
        plain_iv = provider.get_iv()

        with patch('oss2.AliKMSProvider.get_key', return_value=[plain_key, encrypted_key]):
            with patch.object(oss2.utils, 'random_iv', return_value=plain_iv, autospect=True):
                content_crypto_material = provider.create_content_material()
                self.assertFalse(content_crypto_material.is_unencrypted())
                decrypted_key = provider.decrypt_encrypted_key(content_crypto_material.encrypted_key)
                decrypted_iv = provider.decrypt_encrypted_iv(content_crypto_material.encrypted_iv)
                self.assertEqual(plain_key, decrypted_key)
                self.assertEqual(plain_iv, decrypted_iv)

result = bucket.get_object('motto.txt')

assert result.read() == content

# 生成一个签名的URL，将在60秒后过期
url = bucket.sign_url('GET', 'motto.txt', 60)

print(url)


# 人工构造一个使用V2签名的请求
key = 'object-from-post.txt'

boundary = 'arbitraryboundaryvalue'
headers = {'Content-Type': 'multipart/form-data; boundary=' + boundary}
encoded_policy = oss2.utils.b64encode_as_string(oss2.to_bytes('{ "expiration": "%s","conditions": [["starts-with", "$key", ""]]}'
         % oss2.date_to_iso8601(datetime.datetime.utcfromtimestamp(int(time.time()) + 60))))

digest = hmac.new(oss2.to_bytes(access_key_secret), oss2.to_bytes(encoded_policy), hashlib.sha256).digest()
signature = oss2.utils.b64encode_as_string(digest)

form_fields = {
    'x-oss-signature-version': 'OSS2',
    'x-oss-signature': signature,
    'x-oss-access-key-id': access_key_id,
    'policy': encoded_policy,
    'key': key,
}

# 对象的内容
content = 'file content for post object request'

def read_next_frame(self):
        frame_type = bytearray(self.read_raw(4))
        payload_length = bytearray(self.read_raw(4))
        utils.change_endianness_if_needed(payload_length) # convert to little endian
        payload_length_val = struct.unpack("I", bytes(payload_length))[0]
        header_checksum = bytearray(self.read_raw(4))

        frame_type[0] = 0 #mask the version bit
        utils.change_endianness_if_needed(frame_type) # convert to little endian
        frame_type_val = struct.unpack("I", bytes(frame_type))[0]
        if (frame_type_val != SelectResponseAdapter._DATA_FRAME_TYPE and
            frame_type_val != SelectResponseAdapter._CONTINIOUS_FRAME_TYPE and
            frame_type_val != SelectResponseAdapter._END_FRAME_TYPE and
            frame_type_val != SelectResponseAdapter._META_END_FRAME_TYPE and
            frame_type_val != SelectResponseAdapter._JSON_META_END_FRAME_TYPE):
                logger.warning("Unexpected frame type: {0}. RequestId:{1}. This could be due to the old version of client.".format(frame_type_val, self.request_id))
                raise SelectOperationClientError(self.request_id, "Unexpected frame type:" + str(frame_type_val))

        self.payload = self.read_raw(payload_length_val)
        file_offset_bytes = bytearray(self.payload[0:8])
        utils.change_endianness_if_needed(file_offset_bytes)
        self.file_offset = struct.unpack("Q", bytes(file_offset_bytes))[0]
        if frame_type_val == SelectResponseAdapter._DATA_FRAME_TYPE:
            self.frame_length = payload_length_val - 8
            self.frame_off_set = 0

req.set_accept_format('json')
    req.set_RoleArn(role_arn)
    req.set_RoleSessionName('oss-python-sdk-example')

    body = clt.do_action(req)

    j = json.loads(body)

    token = StsToken()

    token.access_key_id = j['Credentials']['AccessKeyId']
    token.access_key_secret = j['Credentials']['AccessKeySecret']
    token.security_token = j['Credentials']['SecurityToken']
    token.request_id = j['RequestId']
    token.expiration = oss2.utils.to_unixtime(j['Credentials']['Expiration'], '%Y-%m-%dT%H:%M:%SZ')

    return token