From 2564242cd2094f91ee7cba24a7080b063fef1838 Mon Sep 17 00:00:00 2001 From: Sourcery AI <> Date: Wed, 5 Jul 2023 14:18:47 +0000 Subject: [PATCH] 'Refactored by Sourcery' --- experiments/request_sender.py | 12 +- main.py | 6 +- modules/aws_manager.py | 150 +++++++------- modules/data_accessor.py | 12 +- modules/frontend.py | 47 +++-- modules/instance_source.py | 31 ++- modules/load_balancer.py | 6 +- modules/load_predictor.py | 14 +- modules/model_source.py | 15 +- modules/prize_request.py | 6 +- modules/proactive_controller.py | 39 ++-- modules/proactive_controller2.py | 25 ++- modules/query_processor.py | 14 +- modules/reactive_controller.py | 8 +- modules/scheduler.py | 35 ++-- modules/utils.py | 13 +- .../vendored/PIL/BlpImagePlugin.py | 110 +++++----- .../vendored/PIL/BmpImagePlugin.py | 62 +++--- .../vendored/PIL/BufrStubImagePlugin.py | 5 +- serverless-lambda/vendored/PIL/ContainerIO.py | 11 +- .../vendored/PIL/CurImagePlugin.py | 10 +- .../vendored/PIL/DcxImagePlugin.py | 10 +- .../vendored/PIL/DdsImagePlugin.py | 2 +- .../vendored/PIL/EpsImagePlugin.py | 78 ++++---- .../vendored/PIL/FitsStubImagePlugin.py | 3 +- .../vendored/PIL/FliImagePlugin.py | 12 +- serverless-lambda/vendored/PIL/FontFile.py | 14 +- .../vendored/PIL/FpxImagePlugin.py | 6 +- .../vendored/PIL/GbrImagePlugin.py | 10 +- serverless-lambda/vendored/PIL/GdImageFile.py | 2 +- .../vendored/PIL/GifImagePlugin.py | 63 ++---- .../vendored/PIL/GimpGradientFile.py | 26 +-- .../vendored/PIL/GribStubImagePlugin.py | 5 +- .../vendored/PIL/Hdf5StubImagePlugin.py | 3 +- .../vendored/PIL/IcnsImagePlugin.py | 17 +- .../vendored/PIL/IcoImagePlugin.py | 21 +- .../vendored/PIL/ImImagePlugin.py | 128 ++++++------ serverless-lambda/vendored/PIL/Image.py | 183 +++++------------ serverless-lambda/vendored/PIL/ImageCms.py | 43 ++-- serverless-lambda/vendored/PIL/ImageColor.py | 52 ++--- serverless-lambda/vendored/PIL/ImageDraw.py | 13 +- serverless-lambda/vendored/PIL/ImageFile.py | 45 ++--- serverless-lambda/vendored/PIL/ImageFont.py | 10 +- serverless-lambda/vendored/PIL/ImageMath.py | 44 ++-- serverless-lambda/vendored/PIL/ImageMode.py | 8 +- serverless-lambda/vendored/PIL/ImageMorph.py | 41 ++-- serverless-lambda/vendored/PIL/ImageOps.py | 29 +-- .../vendored/PIL/ImagePalette.py | 61 +++--- serverless-lambda/vendored/PIL/ImageQt.py | 19 +- serverless-lambda/vendored/PIL/ImageShow.py | 30 ++- serverless-lambda/vendored/PIL/ImageStat.py | 30 +-- serverless-lambda/vendored/PIL/ImageWin.py | 2 +- .../vendored/PIL/IptcImagePlugin.py | 15 +- .../vendored/PIL/Jpeg2KImagePlugin.py | 18 +- .../vendored/PIL/JpegImagePlugin.py | 22 +- .../vendored/PIL/MicImagePlugin.py | 9 +- .../vendored/PIL/MspImagePlugin.py | 2 +- serverless-lambda/vendored/PIL/PSDraw.py | 5 +- serverless-lambda/vendored/PIL/PaletteFile.py | 2 +- .../vendored/PIL/PalmImagePlugin.py | 8 +- serverless-lambda/vendored/PIL/PcfFontFile.py | 32 +-- .../vendored/PIL/PcxImagePlugin.py | 2 +- .../vendored/PIL/PdfImagePlugin.py | 16 +- serverless-lambda/vendored/PIL/PdfParser.py | 189 ++++++++---------- .../vendored/PIL/PngImagePlugin.py | 91 ++++----- .../vendored/PIL/PpmImagePlugin.py | 30 +-- .../vendored/PIL/PsdImagePlugin.py | 37 +--- .../vendored/PIL/SgiImagePlugin.py | 25 +-- .../vendored/PIL/SpiderImagePlugin.py | 51 ++--- .../vendored/PIL/SunImagePlugin.py | 12 +- .../vendored/PIL/TgaImagePlugin.py | 10 +- .../vendored/PIL/TiffImagePlugin.py | 93 ++++----- .../vendored/PIL/WalImageFile.py | 5 +- .../vendored/PIL/WebPImagePlugin.py | 20 +- .../vendored/PIL/WmfImagePlugin.py | 9 +- .../vendored/PIL/XbmImagePlugin.py | 10 +- .../vendored/PIL/XpmImagePlugin.py | 2 +- serverless-lambda/vendored/PIL/features.py | 10 +- .../vendored/backports/weakref.py | 3 +- serverless-lambda/vendored/bleach/__init__.py | 16 +- serverless-lambda/vendored/bleach/encoding.py | 23 +-- .../vendored/bleach/sanitizer.py | 14 +- .../vendored/concurrent/futures/_base.py | 28 ++- .../vendored/concurrent/futures/process.py | 6 +- serverless-lambda/vendored/enum/__init__.py | 170 +++++++--------- .../backports/weakref.py | 3 +- .../python/google/protobuf/descriptor.py | 51 ++--- .../google/protobuf/descriptor_database.py | 7 +- .../python/google/protobuf/descriptor_pool.py | 54 +++-- .../protobuf/internal/_parameterized.py | 29 ++- .../google/protobuf/internal/containers.py | 23 +-- .../google/protobuf/internal/decoder.py | 13 +- .../google/protobuf/internal/encoder.py | 11 +- .../protobuf/internal/enum_type_wrapper.py | 4 +- .../protobuf/internal/python_message.py | 128 ++++++------ .../protobuf/internal/well_known_types.py | 60 ++---- .../google/protobuf/internal/wire_format.py | 8 +- .../python/google/protobuf/json_format.py | 51 ++--- .../python/google/protobuf/proto_builder.py | 87 ++++---- .../python/google/protobuf/reflection.py | 8 +- .../google/protobuf/service_reflection.py | 12 +- .../python/google/protobuf/symbol_database.py | 3 +- .../python/google/protobuf/text_encoding.py | 4 +- .../python/google/protobuf/text_format.py | 104 +++++----- .../vendored/external/six_archive/six.py | 134 ++++++++----- .../vendored/funcsigs/__init__.py | 122 +++++------ .../vendored/google/protobuf/descriptor.py | 51 ++--- .../google/protobuf/descriptor_database.py | 7 +- .../google/protobuf/descriptor_pool.py | 54 +++-- serverless-lambda/vendored/six.py | 134 ++++++++----- 110 files changed, 1635 insertions(+), 2153 deletions(-) diff --git a/experiments/request_sender.py b/experiments/request_sender.py index 0f5a326..e9c2f10 100644 --- a/experiments/request_sender.py +++ b/experiments/request_sender.py @@ -35,8 +35,7 @@ def get_data(): with open(f'{upper_folder}/resources/test.jpg', 'rb') as f: raw_data = f.read() base64_bytes = b64encode(raw_data) - base64_string = base64_bytes.decode('utf-8') - return base64_string + return base64_bytes.decode('utf-8') def send_data(args, reader): pool = ThreadPoolExecutor(5000) @@ -61,8 +60,7 @@ def get_kr_data(): with open(test_file, 'rb') as f: raw_data = f.read() base64_bytes = b64encode(raw_data) - base64_string = base64_bytes.decode('utf-8') - return base64_string + return base64_bytes.decode('utf-8') def send_data_kr(args, reader): pool = ThreadPoolExecutor(5000) @@ -72,7 +70,7 @@ def send_data_kr(args, reader): if reader.line_num > args.timeout: break - num = int(int(row['tweets']) / 2) + num = int(row['tweets']) // 2 lam = (60 * 1000.0) / num samples = np.random.poisson(lam, num) print(f'line: {reader.line_num}; sample_number: {num}') @@ -93,7 +91,7 @@ def send_data_nmt(args, reader): if reader.line_num > args.timeout: break - num = int(int(row['tweets']) / 2) + num = int(row['tweets']) // 2 lam = (60 * 1000.0) / num samples = np.random.poisson(lam, num) print(f'line: {reader.line_num}; sample_number: {num}') @@ -128,8 +126,8 @@ def send_data_mx(args, reader): def send_fixed_data(args): pool = ThreadPoolExecutor(3000) data = get_data() + num = 3000 for _ in range(20): - num = 3000 lam = (60 * 1000.0) / num samples = np.random.poisson(lam, num) for s in samples: diff --git a/main.py b/main.py index f476c0d..27472b1 100644 --- a/main.py +++ b/main.py @@ -24,12 +24,8 @@ def get_args(): return parser.parse_args() def copy_keys(args, keys): - dst_dict = {} src_dict = vars(args) - for key in keys: - if src_dict[key] is not None: - dst_dict[key] = src_dict[key] - return dst_dict + return {key: src_dict[key] for key in keys if src_dict[key] is not None} """ port -> just port as we know diff --git a/modules/aws_manager.py b/modules/aws_manager.py index ca25d8b..8052d56 100644 --- a/modules/aws_manager.py +++ b/modules/aws_manager.py @@ -23,35 +23,35 @@ @app.task def check_spot_states(): - all_info = aws_accessor.get_all_cluster() - if all_info: - client = get_client() - spot_list = [] - [ spot_list.append(c) for c in all_info ] - - cancel_reqs = [] - num = 0 - for info in spot_list: - name = info['name'] - for req, i in info['info'].items(): - res = client.describe_spot_fleet_requests(SpotFleetRequestIds=[req]) - if res['SpotFleetRequestConfigs'][0]['SpotFleetRequestState'] != 'active': - logging.info(f'Inactive spot request detected: {req}') - num += len(i['instance_id_list']) - cancel_reqs.append(req) - start_on_demand_instances(name) + if not (all_info := aws_accessor.get_all_cluster()): + return + client = get_client() + spot_list = [] + [ spot_list.append(c) for c in all_info ] + + cancel_reqs = [] + num = 0 + for info in spot_list: + name = info['name'] + for req, i in info['info'].items(): + res = client.describe_spot_fleet_requests(SpotFleetRequestIds=[req]) + if res['SpotFleetRequestConfigs'][0]['SpotFleetRequestState'] != 'active': + logging.info(f'Inactive spot request detected: {req}') + num += len(i['instance_id_list']) + cancel_reqs.append(req) + start_on_demand_instances(name) - time.sleep(10) - if len(cancel_reqs) > 0: - logging.info('Cancel inactive requests') - cancel_spot_instances(name, cancel_reqs) + time.sleep(10) + if cancel_reqs: + logging.info('Cancel inactive requests') + cancel_spot_instances(name, cancel_reqs) - # interrupt recovery test - time.sleep(100) - logging.info(f'Monitor launching {num} spot instances') - name = 'inception' - launch_spot_instances(name, {'imageId':AMIS[DEFAULT_REGION]['CPU'], 'instanceType':'c5.large', 'targetCapacity':num, 'key_value':[('exp_round', 0)] }) - stop_on_demand_instances(name) + # interrupt recovery test + time.sleep(100) + logging.info(f'Monitor launching {num} spot instances') + name = 'inception' + launch_spot_instances(name, {'imageId':AMIS[DEFAULT_REGION]['CPU'], 'instanceType':'c5.large', 'targetCapacity':num, 'key_value':[('exp_round', 0)] }) + stop_on_demand_instances(name) @app.task def launch_on_demand_instances(name, params): @@ -91,27 +91,25 @@ def launch_on_demand_instances(name, params): if 'key_value' in params: _add_tags(ec2.meta.client, ids, params['key_value']) - + ins_list = utils.get_ins_from_ids(params['region'], ids) # check the state of instances by trying ssh while True: logging.info('Checking SSH connection') - if all([_check_ssh(i.ip) for i in ins_list]): + if all(_check_ssh(i.ip) for i in ins_list): logging.info('Checked SSH connection') break time.sleep(10) ins_list = utils.get_ins_from_ids(params['region'], ids) mdl_source.setup_config(ins_list, params['region'], params['instanceType']) - + ins_dict = {} [ ins_dict.update( {i: utils.get_ins_from_id(ec2, params['region'], i)} ) for i in ids] pre_demand_aws_accessor.del_requests(name, ids) - save_ins = {} - for id, ins in ins_dict.items(): - save_ins[id] = ins.__dict__ + save_ins = {id: ins.__dict__ for id, ins in ins_dict.items()} demand_aws_accessor.save_cluster(name, save_ins) def stop_on_demand_instances(name, typ='t2.medium' , region=DEFAULT_REGION): @@ -120,36 +118,35 @@ def stop_on_demand_instances(name, typ='t2.medium' , region=DEFAULT_REGION): ins = [] [ins.append(id) for id, instance in info.items() if instance['typ'] == typ and instance['region'] == region] - if len(ins) > 0: + if ins: logging.info(f'Stop {len(ins)} {typ} on demand backup instances') backup_ins_accessor.del_all_instance() res = client.stop_instances(InstanceIds=ins) while True: res = client.describe_instances(InstanceIds=ins) ins_res = res['Reservations'][0]['Instances'] - if all([ r['State']['Name'] == 'stopped' for r in ins_res ]): - logging.info(f'Backup instances stopped') + if all(r['State']['Name'] == 'stopped' for r in ins_res): + logging.info('Backup instances stopped') break - logging.info(f'Checking backup instances state') + logging.info('Checking backup instances state') time.sleep(10) def start_on_demand_instances(name, typ='t2.medium' , region=DEFAULT_REGION): client = get_client() - record = demand_aws_accessor.get_cluster(name) - if record: + if record := demand_aws_accessor.get_cluster(name): info = record['info'] ins = [] [ins.append(id) for id, instance in info.items() if instance['typ'] == typ and instance['region'] == region] - if len(ins) > 0: + if ins: logging.info(f'Start {len(ins)} {typ} on demand instances') res = client.start_instances(InstanceIds=ins) instances = utils.get_ins_from_ids(region, ins) while True: logging.info('Checking SSH connection') - if all([_check_ssh(i.ip) for i in instances]): + if all(_check_ssh(i.ip) for i in instances): logging.info('Checked SSH connection') break time.sleep(10) @@ -182,15 +179,14 @@ def kill_on_demand_instances(name, region, typ, num): def kill_all_on_demand_ins(name, region): ec2 = boto3.resource('ec2', region_name=region, **CREDENTIALS) records = demand_aws_accessor.get_cluster(name) - pre_rec = pre_demand_aws_accessor.get_cluster(name) - if pre_rec: + if pre_rec := pre_demand_aws_accessor.get_cluster(name): pre_ids = pre_rec['info'].keys() - if len(list(pre_ids)) > 0: + if list(pre_ids): ec2.instances.filter(InstanceIds=list(pre_ids)).terminate() pre_demand_aws_accessor.del_requests(name, pre_ids) if records: ids = records['info'].keys() - if len(list(ids)) > 0: + if list(ids): ec2.instances.filter(InstanceIds=list(ids)).terminate() demand_aws_accessor.del_requests(name, ids) @@ -230,7 +226,7 @@ def launch_spot_instances(name, params): # check the state of instances by trying ssh while True: logging.info('Checking SSH connection') - if all([_check_ssh(i.ip) for i in ins]): + if all(_check_ssh(i.ip) for i in ins): logging.info('Checked SSH connection') break time.sleep(10) @@ -267,7 +263,7 @@ def kill_spot_instances_by_num(name, region, typ, num): req_ins_num = [] [ req_ins_num.append((len(ins['instance_id_list']), r)) for r, ins in info.items() if ins['type'] == typ and ins['region'] == region ] - + logging.info(f'Will kill {num} {typ} instances') cancel_req_ids = [] @@ -280,15 +276,15 @@ def kill_spot_instances_by_num(name, region, typ, num): cancel_req_ids.append(req) logging.info(f'Kill {total_size} {typ} instances') - - if len(cancel_req_ids) > 0: + + if cancel_req_ids: cancel_spot_instances(name, cancel_req_ids) def cancel_spot_instances(name, request_ids): info = aws_accessor.get_cluster(name)['info'] for i in request_ids: if i not in info: - logging.info('Request ID : {} not found'.format(i)) + logging.info(f'Request ID : {i} not found') continue instance_id_list = info[i]['instance_id_list'] region = info[i]['region'] @@ -298,13 +294,12 @@ def cancel_spot_instances(name, request_ids): TerminateInstances=True ) if 'SuccessfulFleetRequests' in res: - logging.info('Successful cancel spot fleet request {}'.format(i)) + logging.info(f'Successful cancel spot fleet request {i}') instance_accessor.del_instance(name, [ i.__dict__ for i in utils.get_ins_from_ids(region, instance_id_list)]) aws_accessor.del_request(name, i) def cancel_all_instances(name): - requests = aws_accessor.get_requests(name) - if requests: + if requests := aws_accessor.get_requests(name): cancel_spot_instances(name, requests) @@ -312,33 +307,34 @@ def get_client(region=DEFAULT_REGION): return boto3.client('ec2', region_name=region, **CREDENTIALS) def _get_request_config(params): - base = { + return { 'TargetCapacity': params['targetCapacity'], 'TerminateInstancesWithExpiration': True, 'ValidFrom': datetime(2018, 1, 1), 'ValidUntil': datetime(2019, 1, 1), 'IamFleetRole': 'arn:aws:iam::906727922743:role/aws-ec2-spot-fleet-role', - 'LaunchSpecifications': [{ - 'ImageId': params['imageId'], - 'KeyName': KEYS[params['region']], - 'InstanceType': params['instanceType'], - 'BlockDeviceMappings': [{ - 'VirtualName': 'Root', - 'DeviceName': '/dev/sda1', - 'Ebs': { - 'VolumeSize': 75, - 'VolumeType': 'gp2', - 'DeleteOnTermination': True - } - }], - 'Monitoring': { - 'Enabled': False + 'LaunchSpecifications': [ + { + 'ImageId': params['imageId'], + 'KeyName': KEYS[params['region']], + 'InstanceType': params['instanceType'], + 'BlockDeviceMappings': [ + { + 'VirtualName': 'Root', + 'DeviceName': '/dev/sda1', + 'Ebs': { + 'VolumeSize': 75, + 'VolumeType': 'gp2', + 'DeleteOnTermination': True, + }, + } + ], + 'Monitoring': {'Enabled': False}, } - }], + ], 'AllocationStrategy': 'lowestPrice', - 'Type': 'maintain' + 'Type': 'maintain', } - return base def _send_request(client, params): """ @@ -351,7 +347,7 @@ def _send_request(client, params): res = client.request_spot_fleet( SpotFleetRequestConfig=_get_request_config(params) ) - logging.info('Created spot fleet request {}'.format(res["SpotFleetRequestId"])) + logging.info(f'Created spot fleet request {res["SpotFleetRequestId"]}') return res['SpotFleetRequestId'] def _wait_initialized(client, instance_id_list): @@ -364,7 +360,10 @@ def _wait_initialized(client, instance_id_list): if len(res['InstanceStatuses']) == 0: time.sleep(10) continue - if all([ s['InstanceStatus']['Status'] == 'ok' for s in res['InstanceStatuses'] ]): + if all( + s['InstanceStatus']['Status'] == 'ok' + for s in res['InstanceStatuses'] + ): logging.info('Instances are initialized now.') return time.sleep(10) @@ -381,8 +380,7 @@ def _wait_active(client, request_id, max_num): res = client.describe_spot_fleet_instances(SpotFleetRequestId=request_id) if len(res['ActiveInstances']) == max_num: logging.info('Instances are active now.') - instance_id_list = [ i['InstanceId'] for i in res['ActiveInstances'] ] - return instance_id_list + return [ i['InstanceId'] for i in res['ActiveInstances'] ] time.sleep(10) def _set_security_group(client, instance_id_list, security_groups): diff --git a/modules/data_accessor.py b/modules/data_accessor.py index f3b38fa..5e6dd7a 100644 --- a/modules/data_accessor.py +++ b/modules/data_accessor.py @@ -26,8 +26,7 @@ def save_prizes(self, prizes): ) def get_prize(self, region): - record = self.collection.find_one({'region' : region}) - if record: + if record := self.collection.find_one({'region': region}): return record['sizes'] class AWSAccessor(_BaseAccessor): @@ -40,8 +39,7 @@ def save_cluster(self, name, info): self.collection.update({'name' : name}, doc, upsert=True) def get_by_region_typ(self, name, region, typ): - record = self.collection.find_one({'name' : name}) - if record: + if record := self.collection.find_one({'name': name}): for r, info in record['info'].items(): if info['region'] == region and info['type'] == typ: return (r, info['instance_id_list']) @@ -61,8 +59,7 @@ def del_requests(self, name, ids): [self.del_request(name, id) for id in ids] def get_requests(self, name): - record = self.collection.find_one({'name' : name}) - if record: + if record := self.collection.find_one({'name': name}): return record['info'].keys() class InstanceAccessor(_BaseAccessor): @@ -75,8 +72,7 @@ def update_instances(self, name, instance_list): self.collection.update({'name' : name}, doc, upsert=True) def get_instances(self, name): - record = self.collection.find_one({'name' : name}) - if record: + if record := self.collection.find_one({'name': name}): return record['instances'] def get_all_instances(self): diff --git a/modules/frontend.py b/modules/frontend.py index 997d2e9..2f2dea6 100644 --- a/modules/frontend.py +++ b/modules/frontend.py @@ -27,35 +27,34 @@ @app.route('/predict/', methods=['POST']) #decorator async def predict(request, model_name): - if request.method == 'POST': - receive_time = utils.now() - logging.info(f'Received request for model: {model_name}') + if request.method != 'POST': + return + receive_time = utils.now() + logging.info(f'Received request for model: {model_name}') - typ = request.json['type'] - # use a general decoder to handle different types - # data = utils.decode_image(request.json['data']) if typ == 'image' else request.json['data'] - data = request.json['data'] + typ = request.json['type'] + # use a general decoder to handle different types + # data = utils.decode_image(request.json['data']) if typ == 'image' else request.json['data'] + data = request.json['data'] - sch.record_request(model_name) - res, typ, handel_time = await processor.send_query(model_name, receive_time, data) + sch.record_request(model_name) + res, typ, handel_time = await processor.send_query(model_name, receive_time, data) - if (typ > 3): - scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999 + 0.001 - elif (handel_time > UPPER_LATENCY_BOUND): - scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999 + 0.001 - else: - scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999 + scheduler.Scheduler.failed_rate = ( + scheduler.Scheduler.failed_rate * 0.999 + 0.001 + if (typ > 3) or (handel_time > UPPER_LATENCY_BOUND) + else scheduler.Scheduler.failed_rate * 0.999 + ) + if sch.failed_rate > SLA_BOUND: ## SLA mentioned in proposal + sch.launch_standby('c5.xlarge', 1, model_name) + scheduler.Scheduler.failed_rate = 0.0 - if sch.failed_rate > SLA_BOUND: ## SLA mentioned in proposal - sch.launch_standby('c5.xlarge', 1, model_name) - scheduler.Scheduler.failed_rate = 0.0 - - logging.info(f'Model: {model_name}; typ: {typ}; handel_time: {handel_time}; failed_rate: {scheduler.Scheduler.failed_rate}') - return json({ - 'res' : res, - 'latency' : handel_time - }) + logging.info(f'Model: {model_name}; typ: {typ}; handel_time: {handel_time}; failed_rate: {scheduler.Scheduler.failed_rate}') + return json({ + 'res' : res, + 'latency' : handel_time + }) @app.listener('after_server_start') async def notify_server_started(app, loop): diff --git a/modules/instance_source.py b/modules/instance_source.py index 1ef4e51..d8f665c 100644 --- a/modules/instance_source.py +++ b/modules/instance_source.py @@ -43,23 +43,31 @@ def initial_ins(self, name, tag): class OnDemandSource(_InstanceSource): def get_ins_alloc(self, name, balancer): - ins_json = demand_aws_accessor.get_cluster(name) - if ins_json: + if ins_json := demand_aws_accessor.get_cluster(name): intance_list = [ utils.dict2Instance(i) for i in ins_json['info'].values() ] return balancer.next_ip(name, intance_list) def get_current_ins_and_prize(self, name, index_type): - aws_info = demand_aws_accessor.get_cluster(name) - intance_list = [] - if aws_info: + if aws_info := demand_aws_accessor.get_cluster(name): intance_list = [utils.dict2Instance(i) for i in aws_info['info'].values()] + else: + intance_list = [] currentInstance = [] [ currentInstance.append(len([ i for i in intance_list if i.typ == typ and i.region == DEFAULT_REGION])) for typ in index_type ] info = pre_demand_aws_accessor.get_cluster(name) if info and info['info']: c_tmp = [] - [ c_tmp.append(sum([ i['num'] for _, i in info['info'].items() if i['type'] == typ and i['region'] == DEFAULT_REGION])) for typ in index_type ] + [ + c_tmp.append( + sum( + i['num'] + for _, i in info['info'].items() + if i['type'] == typ and i['region'] == DEFAULT_REGION + ) + ) + for typ in index_type + ] currentInstance = [ (e1 + e2) for e1, e2 in zip(currentInstance, c_tmp)] prize_list = prize_request.get_demand_prize_by_region_type(DEFAULT_REGION, index_type) return currentInstance, prize_list @@ -111,7 +119,16 @@ def get_current_ins_and_prize(self, name, index_type): info = pre_aws_accessor.get_cluster(name) if info['info']: c_tmp = [] - [ c_tmp.append(sum([ i['num'] for _, i in info['info'].items() if i['type'] == typ and i['region'] == DEFAULT_REGION])) for typ in index_type ] + [ + c_tmp.append( + sum( + i['num'] + for _, i in info['info'].items() + if i['type'] == typ and i['region'] == DEFAULT_REGION + ) + ) + for typ in index_type + ] currentInstance = [ (e1 + e2) for e1, e2 in zip(currentInstance, c_tmp)] prize_list = prize_request.get_spot_prize_by_region_type(DEFAULT_REGION, index_type) diff --git a/modules/load_balancer.py b/modules/load_balancer.py index d339d5f..ce918ec 100644 --- a/modules/load_balancer.py +++ b/modules/load_balancer.py @@ -28,9 +28,9 @@ class WeightedBalancer(_Balancer): def next_ip(self, name, instance_list): if len(instance_list) <= 0: return - + weight_list = [ (i.ip, Instance_Weights[i.typ], i.typ) for i in instance_list ] - max_weight = max([ i[1] for i in weight_list ]) + max_weight = max(i[1] for i in weight_list) gcd_weight = utils.gcd([ i[1] for i in weight_list ]) index, current_weight = self.indexes[name] if name in self.indexes else (-1, max_weight) @@ -44,7 +44,7 @@ def next_ip(self, name, instance_list): if next_ip_index < 0: current_weight = current_weight - gcd_weight if current_weight > 0 else max_weight index = -1 - + self.indexes[name] = (next_ip_index, current_weight) return (weight_list[next_ip_index][0], weight_list[next_ip_index][2]) diff --git a/modules/load_predictor.py b/modules/load_predictor.py index 271dddf..459e702 100644 --- a/modules/load_predictor.py +++ b/modules/load_predictor.py @@ -34,13 +34,11 @@ def forecast_lstm(self, X): X = X.reshape(1, 1, len(X)) forecast = self.model.predict(X, batch_size=1) # return an array - return [x for x in forecast[0, :]] + return list(forecast[0, :]) def inverse_difference(self, last_ob, forecast): - inverted = list() - inverted.append(forecast[0] + last_ob) - for i in range(1, len(forecast)): - inverted.append(forecast[i] + inverted[i-1]) + inverted = [forecast[0] + last_ob] + inverted.extend(forecast[i] + inverted[i-1] for i in range(1, len(forecast))) return inverted def inverse_transform(self, forecast, current_load): @@ -49,8 +47,7 @@ def inverse_transform(self, forecast, current_load): # invert scaling inv_scale = self.scaler.inverse_transform(forecast) inv_scale = inv_scale[0, :] - inv_diff = self.inverse_difference(current_load, inv_scale) - return inv_diff + return self.inverse_difference(current_load, inv_scale) def predict(self, current_load): X = [[(current_load - self.last_step)]] @@ -59,5 +56,4 @@ def predict(self, current_load): X.reshape(-1, 1) Y = self.scaler.transform(X) forecast = self.forecast_lstm(Y) - forecast_real = self.inverse_transform(forecast, current_load) - return forecast_real + return self.inverse_transform(forecast, current_load) diff --git a/modules/model_source.py b/modules/model_source.py index 2e0d72e..3c8bcf7 100644 --- a/modules/model_source.py +++ b/modules/model_source.py @@ -91,8 +91,7 @@ def __init__(self): def get_request(self, data, ip): - dct = {'url': url, 'headers': headers, 'data': data, 'timeout': 2} - return dct + return {'url': url, 'headers': headers, 'data': data, 'timeout': 2} def setup_config(self, ins, region, typ): self. _start_nginx(ins) @@ -104,7 +103,7 @@ def setup_config(self, ins, region, typ): image_data = [{ "b64": self.test_data},] if typ.startswith('p2'): - image_data = image_data * HANDLE_SIZE_P2 + image_data *= HANDLE_SIZE_P2 for i in ins: while True: @@ -138,7 +137,9 @@ def _start_nginx(self, instances): utils.check_command(ses, f'sudo cp /etc/nginx/{nginx_conf} /etc/nginx/nginx.conf && sudo systemctl restart nginx') def _deploy_model(self, region, ips, cmd): - return all([utils.check_command(utils.get_session(i), cmd, debug=True) for i in ips]) + return all( + utils.check_command(utils.get_session(i), cmd, debug=True) for i in ips + ) class KerasSource(_ModelSource): @@ -153,14 +154,12 @@ def get_request(self, data, ip): url = f'http://{ip}:8301/invocations' files = payload - dct = {'url': url, 'data': files, 'timeout': 2.5} - return dct + return {'url': url, 'data': files, 'timeout': 2.5} def _get_data(self): test_file = f'{utils.upper_folder}/keras/SageMaker/cat.jpg' with open(test_file, "rb") as f: - raw_data = f.read() - return raw_data + return f.read() def setup_config(self, ins, region, typ): for i in ins: diff --git a/modules/prize_request.py b/modules/prize_request.py index 7ea7a4c..46facb1 100644 --- a/modules/prize_request.py +++ b/modules/prize_request.py @@ -74,9 +74,9 @@ def get_spot_prize_by_region_type(region, types): ''' Return a prize list based on the input region and types ($ / sec) ''' - if region == 'us-east-1' or region == 'us-west-1': - region = region[0:7] - + if region in ['us-east-1', 'us-west-1']: + region = region[:7] + types = [ t.replace('.', '_') for t in types ] prize_list = [] sizes = spot_prize_accessor.get_prize(region) diff --git a/modules/proactive_controller.py b/modules/proactive_controller.py index 2d4db56..f696840 100644 --- a/modules/proactive_controller.py +++ b/modules/proactive_controller.py @@ -28,10 +28,10 @@ def __init__(self, step=50, interval=60, instance_info=None): self.interval = interval def calculateCapacity(self, current_instances): - totalCapa = 0 - for i in range(len(current_instances)): - totalCapa += self.instance_info[i][0] * current_instances[i] - return totalCapa + return sum( + self.instance_info[i][0] * current_instances[i] + for i in range(len(current_instances)) + ) def findCheap(self, t_start, t_stop, residualForecasts, time_span): cheapest_i = 0 @@ -39,10 +39,13 @@ def findCheap(self, t_start, t_stop, residualForecasts, time_span): for i in range(len(self.instance_info)): total_cost = self.instance_info[i][1] * time_span + self.instance_info[i][2] i_capacity = self.instance_info[i][0] - counted = 0 - for j in range(t_stop - t_start): - if (residualForecasts[t_start + j] > 0): - counted += i_capacity if (residualForecasts[t_start + j] >= i_capacity) else residualForecasts[t_start + j] + counted = sum( + i_capacity + if (residualForecasts[t_start + j] >= i_capacity) + else residualForecasts[t_start + j] + for j in range(t_stop - t_start) + if (residualForecasts[t_start + j] > 0) + ) cost_per_r = (total_cost * 1.0) / counted #print('i:'+str(i)+' total_cost:'+str(total_cost)+' i_capacity:'+str(i_capacity)+' cost_p:'+str(cost_per_r)) if lowest_cost >= cost_per_r: @@ -61,12 +64,15 @@ def findHigh(self, t_start, t_stop, residualForecasts, time_span): continue total_cost = self.instance_info[i][1] * time_span i_capacity = self.instance_info[i][0] - + if (-1 *high_demand) < i_capacity: continue - counted = 0 - for j in range(t_stop - t_start): - counted += i_capacity if (residualForecasts[t_start + j] <= i_capacity) else - residualForecasts[t_start + j] + counted = sum( + i_capacity + if (residualForecasts[t_start + j] <= i_capacity) + else -residualForecasts[t_start + j] + for j in range(t_stop - t_start) + ) cost_per_r = (total_cost * 1.0) / counted #print('i:'+str(i)+' total_cost:'+str(total_cost)+' i_capacity:'+str(i_capacity)+' cost_p:'+str(cost_per_r)) if highest_cost <= cost_per_r: @@ -77,7 +83,7 @@ def findHigh(self, t_start, t_stop, residualForecasts, time_span): def fill(self, t_start, t_stop, residualForecasts): #print('fill t_start: '+str(t_start)+' t_stop: '+str(t_stop)) time_span = t_stop * self.interval #timespan in seconds - time_span = time_span if (time_span > 60) else 60 + time_span = max(time_span, 60) #print('timespan: '+str(time_span)) cheapest_i = self.findCheap(t_start, t_stop, residualForecasts, time_span) #print('cheapest_i '+str(cheapest_i)) @@ -101,7 +107,7 @@ def fill(self, t_start, t_stop, residualForecasts): def kill(self, t_start, t_stop, residualForecasts): #print('fill t_start: '+str(t_start)+' t_stop: '+str(t_stop)) time_span = t_stop * self.interval - time_span = time_span if (time_span > 60) else 60 + time_span = max(time_span, 60) highest_i = self.findHigh(t_start, t_stop, residualForecasts, time_span) #print('highest_i '+str(highest_i)) if highest_i == -1: @@ -124,9 +130,9 @@ def greedyFind(self, t_current): return totalCapa = self.calculateCapacity(self.instance_plan[t_current]) residualForecasts = [ x - totalCapa for x in self.forecasts] + t_stop = 0 #print(residualForecasts) if (residualForecasts[t_current] >= 0): - t_stop = 0 for i in range(len(residualForecasts) - t_current): if (residualForecasts[i + t_current] >= 0): t_stop += 1 @@ -135,7 +141,6 @@ def greedyFind(self, t_current): #print('fill t_stop:' + str(t_stop)) self.fill(t_current, t_stop, residualForecasts) else: - t_stop = 0 for i in range(len(residualForecasts) - t_current): if (residualForecasts[i+ t_current] < 0): t_stop +=1 @@ -154,7 +159,7 @@ def schedule(self, forecasts, current_instances, instance_info): """ self.instance_info = instance_info # step + 1, index 0 means current, 1 means the first prediction - self.instance_plan = [current_instances.copy() for i in range(self.step)] + self.instance_plan = [current_instances.copy() for _ in range(self.step)] self.forecasts = forecasts #print(self.instance_plan) self.greedyFind(0) diff --git a/modules/proactive_controller2.py b/modules/proactive_controller2.py index 139d180..b8d25f3 100644 --- a/modules/proactive_controller2.py +++ b/modules/proactive_controller2.py @@ -29,10 +29,10 @@ def __init__(self, step=50, interval=60, instance_info=None): self.interval = interval def calculateCapacity(self, current_instances): - totalCapa = 0 - for i in range(len(current_instances)): - totalCapa += self.instance_info[i][0] * current_instances[i] - return totalCapa + return sum( + self.instance_info[i][0] * current_instances[i] + for i in range(len(current_instances)) + ) def findCheapest(self, t_span, residualForecasts, max_idx): cheapest_i = -1 @@ -41,10 +41,13 @@ def findCheapest(self, t_span, residualForecasts, max_idx): for i in range(len(self.instance_info)): totalCost = self.instance_info[i][1] * t_span * self.interval + self.instance_info[i][2] iCapa = self.instance_info[i][0] - counted = 0 - for j in range(t_span): - if residualForecasts[max_idx + j] > 0: - counted += iCapa if (residualForecasts[max_idx + j] >= iCapa) else residualForecasts[max_idx + j] + counted = sum( + iCapa + if (residualForecasts[max_idx + j] >= iCapa) + else residualForecasts[max_idx + j] + for j in range(t_span) + if residualForecasts[max_idx + j] > 0 + ) cost_per_r = (totalCost * 1.0) / counted #print('i:'+str(i)+' total_cost:'+str(totalCost)+' i_capacity:'+str(iCapa)+' cost_p:'+str(cost_per_r)) if lowest_cost >= cost_per_r > 0: @@ -91,8 +94,10 @@ def schedule(self, forecasts, current_instances, instance_info): # print(current_instances) self.n_instance = len(instance_info) self.instance_info = [row[:] for row in instance_info] - for i in range(len(instance_info)): - self.instance_info.append([instance_info[i][0],instance_info[i][1], 0]) + self.instance_info.extend( + [instance_info[i][0], instance_info[i][1], 0] + for i in range(len(instance_info)) + ) self.existing_limit = current_instances.copy() #print(self.existing_limit) self.instance_plan = [0] * len(self.instance_info) diff --git a/modules/query_processor.py b/modules/query_processor.py index 17a0851..7db6b87 100644 --- a/modules/query_processor.py +++ b/modules/query_processor.py @@ -55,9 +55,8 @@ async def _manage_queue(self): info = await self.query_queue.get() name = info[0][1] fu, times, data = [i[0] for i in info], [i[2] for i in info], [i[3] for i in info] - - alloc_info = ins_source.get_ins_alloc(name, self.balancer) - if alloc_info: + + if alloc_info := ins_source.get_ins_alloc(name, self.balancer): ip, typ = alloc_info[0], alloc_info[1] if typ.startswith('p2'): other_info = await self.query_queue.get(HANDLE_SIZE_P2 - 1) @@ -96,15 +95,6 @@ async def _serve(self, name, data, ip): else: logging.info(f'Request rejected. ip: {ip}; status: {resp.status}') return ([ r for _ in data ], req_typ) - async with self.session.get(mdl_source.get_lambda_req()) as res_lam: - if res_lam.status == 200: - r = await res_lam.text() - req_typ = [REQ_LAMBDA_GPU for _ in data] if is_gpu else [REQ_LAMBDA_CPU for _ in data] - return ([ r for _ in data ], req_typ) - else: - logging.info(f'Lambda rejected. status: {res_lam.status}') - req_typ = [REQ_FAIL_GPU for _ in data] if is_gpu else [REQ_FAIL_CPU for _ in data] - return ([ f'Error code : {res_lam.status}' for _ in data ], req_typ) class QueryQuene(): def __init__(self): diff --git a/modules/reactive_controller.py b/modules/reactive_controller.py index b49798f..280d728 100644 --- a/modules/reactive_controller.py +++ b/modules/reactive_controller.py @@ -28,10 +28,10 @@ def __init__(self, interval=5, instance_info): self.interval = interval def calculateCapacity(self, current_instances): - totalCapa = 0 - for i in range(len(current_instances)): - totalCapa += instance_info[i][0] * current_instances[i] - return totalCapa + return sum( + instance_info[i][0] * current_instances[i] + for i in range(len(current_instances)) + ) def findCheap(self, surplus): cheapest_i = 0 diff --git a/modules/scheduler.py b/modules/scheduler.py index ca727a4..df7a790 100644 --- a/modules/scheduler.py +++ b/modules/scheduler.py @@ -29,9 +29,11 @@ class Scheduler(): def set_loop(self, loop_): self.loop = loop_ logging.info('starting scheduler') - self.predictor = load_predictor.Predictor(init_load=2964, - model_path=utils.upper_folder +'/resources/my_model_32.h5', - scaler_path=utils.upper_folder +'/resources/my_scaler.save') + self.predictor = load_predictor.Predictor( + init_load=2964, + model_path=f'{utils.upper_folder}/resources/my_model_32.h5', + scaler_path=f'{utils.upper_folder}/resources/my_scaler.save', + ) self.warm_up_num = {} self.count = {} self.res_list = [] @@ -66,7 +68,7 @@ async def schedule(self): while True: # await asyncio.sleep(PREDICTOR_PARAM[1]) - for i in range(0,PREDICTOR_PARAM[1]//PREDICTOR_WINDOW): + for _ in range(0,PREDICTOR_PARAM[1]//PREDICTOR_WINDOW): await asyncio.sleep(PREDICTOR_WINDOW) for name in self.count.keys(): if self.count[name] > max_count_window: @@ -87,25 +89,22 @@ async def schedule(self): max_count_window = 0 self.warm_up_num[name] -= 1 continue - + currentInstance, prize_list = ins_source.get_current_ins_and_prize(name, IndexType) if prize_list is None: logging.info(f'Prize uavailable for {IndexType}') self.count[name] = 0 max_count_window = 0 continue - # logging.info(f': Updated prize_list') - instanceInfo = [] - for i in range(len(IndexType)): - instanceInfo.append([Capacity[i], prize_list[i], prize_list[i] * 180]) - + instanceInfo = [ + [Capacity[i], prize_list[i], prize_list[i] * 180] + for i in range(len(IndexType)) + ] # forecasts = self.predictor.predict(max_count_window * Times) # logging.info(f': Updated forecasts') - if max_count < max_count_window: - max_count = max_count_window - + max_count = max(max_count, max_count_window) forecasts = [max_count * Times] * 50 @@ -118,12 +117,12 @@ async def schedule(self): des_list = reduce(col_max_values, [ res[0] for res in self.res_list ]) des = [ max(c - d, 0) for c, d in zip(currentInstance, des_list) ] self.res_list.remove(self.res_list[0]) - - logging.info(f'Results: {results}; Current: {currentInstance}; Launch: {launch}; Destroy: {des}') - cost = 0 - for i in range(len(currentInstance)): - cost += instanceInfo[i][1] * 60 * currentInstance[i] + logging.info(f'Results: {results}; Current: {currentInstance}; Launch: {launch}; Destroy: {des}') + cost = sum( + instanceInfo[i][1] * 60 * currentInstance[i] + for i in range(len(currentInstance)) + ) for i in range(len(launch)): if launch[i] > 0: logging.info(f'Launch {launch[i]} {IndexType[i]} instances for model: {name}') diff --git a/modules/utils.py b/modules/utils.py index 5dd8821..9531c27 100644 --- a/modules/utils.py +++ b/modules/utils.py @@ -27,10 +27,7 @@ def _gcd_in_two(x, y): max_val = max(x, y) min_val = min(x, y) - if min_val == 0: - return max_val - else: - return _gcd_in_two(min_val, max_val % min_val) + return max_val if min_val == 0 else _gcd_in_two(min_val, max_val % min_val) decode_image = lambda raw_data: b64decode(raw_data) @@ -70,10 +67,10 @@ def dict2Instance(dct): def parse_instances(cursor): lst = [] [ lst.append(c) for c in cursor ] - res = {} - for dct in lst: - res[dct['name']] = [ dict2Instance(i) for i in dct['instances'] ] - return res + return { + dct['name']: [dict2Instance(i) for i in dct['instances']] + for dct in lst + } def get_session(ip): ssh = paramiko.client.SSHClient() diff --git a/serverless-lambda/vendored/PIL/BlpImagePlugin.py b/serverless-lambda/vendored/PIL/BlpImagePlugin.py index ec358db..42c1589 100644 --- a/serverless-lambda/vendored/PIL/BlpImagePlugin.py +++ b/serverless-lambda/vendored/PIL/BlpImagePlugin.py @@ -296,7 +296,7 @@ def decode(self, buffer): def _read_palette(self): ret = [] - for i in range(256): + for _ in range(256): try: b, g, r, a = struct.unpack("<4B", self.fd.read(4)) except struct.error: @@ -330,23 +330,22 @@ def _load(self): self._decode_jpeg_stream() elif self._blp_compression == 1: - if self._blp_encoding in (4, 5): - data = bytearray() - palette = self._read_palette() - _data = BytesIO(self.fd.read(self._blp_lengths[0])) - while True: - try: - offset, = struct.unpack("= 40: # v3 and OS/2 file_info['y_flip'] = i8(header_data[7]) == 0xff file_info['direction'] = 1 if file_info['y_flip'] else -1 - file_info['width'] = i32(header_data[0:4]) + file_info['width'] = i32(header_data[:4]) file_info['height'] = i32(header_data[4:8]) if not file_info['y_flip'] else 2**32 - i32(header_data[4:8]) file_info['planes'] = i16(header_data[8:10]) file_info['bits'] = i16(header_data[10:12]) @@ -135,6 +132,8 @@ def _bitmap(self, header=0, offset=0): 24: [(0xff0000, 0xff00, 0xff)], 16: [(0xf800, 0x7e0, 0x1f), (0x7c00, 0x3e0, 0x1f)] } + if file_info['bits'] not in SUPPORTED: + raise IOError("Unsupported BMP bitfields layout") MASK_MODES = { (32, (0xff0000, 0xff00, 0xff, 0x0)): "BGRX", (32, (0xff000000, 0xff0000, 0xff00, 0x0)): "XBGR", @@ -144,14 +143,11 @@ def _bitmap(self, header=0, offset=0): (16, (0xf800, 0x7e0, 0x1f)): "BGR;16", (16, (0x7c00, 0x3e0, 0x1f)): "BGR;15" } - if file_info['bits'] in SUPPORTED: - if file_info['bits'] == 32 and file_info['rgba_mask'] in SUPPORTED[file_info['bits']]: - raw_mode = MASK_MODES[(file_info['bits'], file_info['rgba_mask'])] - self.mode = "RGBA" if raw_mode in ("BGRA",) else self.mode - elif file_info['bits'] in (24, 16) and file_info['rgb_mask'] in SUPPORTED[file_info['bits']]: - raw_mode = MASK_MODES[(file_info['bits'], file_info['rgb_mask'])] - else: - raise IOError("Unsupported BMP bitfields layout") + if file_info['bits'] == 32 and file_info['rgba_mask'] in SUPPORTED[file_info['bits']]: + raw_mode = MASK_MODES[(file_info['bits'], file_info['rgba_mask'])] + self.mode = "RGBA" if raw_mode in ("BGRA",) else self.mode + elif file_info['bits'] in (24, 16) and file_info['rgb_mask'] in SUPPORTED[file_info['bits']]: + raw_mode = MASK_MODES[(file_info['bits'], file_info['rgb_mask'])] else: raise IOError("Unsupported BMP bitfields layout") elif file_info['compression'] == self.RAW: @@ -161,26 +157,24 @@ def _bitmap(self, header=0, offset=0): raise IOError("Unsupported BMP compression (%d)" % file_info['compression']) # ---------------- Once the header is processed, process the palette/LUT if self.mode == "P": # Paletted for 1, 4 and 8 bit images - # ----------------------------------------------------- 1-bit images - if not (0 < file_info['colors'] <= 65536): + if not 0 < file_info['colors'] <= 65536: raise IOError("Unsupported BMP Palette size (%d)" % file_info['colors']) + padding = file_info['palette_padding'] + palette = read(padding * file_info['colors']) + greyscale = True + indices = (0, 255) if file_info['colors'] == 2 else list(range(file_info['colors'])) + # ------------------ Check if greyscale and ignore palette if so + for ind, val in enumerate(indices): + rgb = palette[ind*padding:ind*padding + 3] + if rgb != o8(val) * 3: + greyscale = False + # -------- If all colors are grey, white or black, ditch palette + if greyscale: + self.mode = "1" if file_info['colors'] == 2 else "L" + raw_mode = self.mode else: - padding = file_info['palette_padding'] - palette = read(padding * file_info['colors']) - greyscale = True - indices = (0, 255) if file_info['colors'] == 2 else list(range(file_info['colors'])) - # ------------------ Check if greyscale and ignore palette if so - for ind, val in enumerate(indices): - rgb = palette[ind*padding:ind*padding + 3] - if rgb != o8(val) * 3: - greyscale = False - # -------- If all colors are grey, white or black, ditch palette - if greyscale: - self.mode = "1" if file_info['colors'] == 2 else "L" - raw_mode = self.mode - else: - self.mode = "P" - self.palette = ImagePalette.raw("BGRX" if padding == 4 else "BGR", palette) + self.mode = "P" + self.palette = ImagePalette.raw("BGRX" if padding == 4 else "BGR", palette) # ----------------------------- Finally set the tile data for the plugin self.info['compression'] = file_info['compression'] @@ -193,7 +187,7 @@ def _open(self): # read 14 bytes: magic number, filesize, reserved, header final offset head_data = self.fp.read(14) # choke if the file does not have the required magic bytes - if head_data[0:2] != b"BM": + if head_data[:2] != b"BM": raise SyntaxError("Not a BMP file") # read the start position of the BMP image data (u32) offset = i32(head_data[10:14]) @@ -230,7 +224,7 @@ def _save(im, fp, filename): try: rawmode, bits, colors = SAVE[im.mode] except KeyError: - raise IOError("cannot write mode %s as BMP" % im.mode) + raise IOError(f"cannot write mode {im.mode} as BMP") info = im.encoderinfo diff --git a/serverless-lambda/vendored/PIL/BufrStubImagePlugin.py b/serverless-lambda/vendored/PIL/BufrStubImagePlugin.py index 16d83c7..66c5c60 100644 --- a/serverless-lambda/vendored/PIL/BufrStubImagePlugin.py +++ b/serverless-lambda/vendored/PIL/BufrStubImagePlugin.py @@ -28,7 +28,7 @@ def register_handler(handler): # Image adapter def _accept(prefix): - return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC" + return prefix[:4] in [b"BUFR", b"ZCZC"] class BufrStubImageFile(ImageFile.StubImageFile): @@ -49,8 +49,7 @@ def _open(self): self.mode = "F" self.size = 1, 1 - loader = self._load() - if loader: + if loader := self._load(): loader.open(self) def _load(self): diff --git a/serverless-lambda/vendored/PIL/ContainerIO.py b/serverless-lambda/vendored/PIL/ContainerIO.py index 496ed68..5a846c6 100644 --- a/serverless-lambda/vendored/PIL/ContainerIO.py +++ b/serverless-lambda/vendored/PIL/ContainerIO.py @@ -76,10 +76,7 @@ def read(self, n=0): read until end of region. :returns: An 8-bit string. """ - if n: - n = min(n, self.length - self.pos) - else: - n = self.length - self.pos + n = min(n, self.length - self.pos) if n else self.length - self.pos if not n: # EOF return "" self.pos = self.pos + n @@ -109,8 +106,8 @@ def readlines(self): """ l = [] while True: - s = self.readline() - if not s: + if s := self.readline(): + l.append(s) + else: break - l.append(s) return l diff --git a/serverless-lambda/vendored/PIL/CurImagePlugin.py b/serverless-lambda/vendored/PIL/CurImagePlugin.py index e4257cd..707fff9 100644 --- a/serverless-lambda/vendored/PIL/CurImagePlugin.py +++ b/serverless-lambda/vendored/PIL/CurImagePlugin.py @@ -50,20 +50,12 @@ def _open(self): # pick the largest cursor in the file m = b"" - for i in range(i16(s[4:])): + for _ in range(i16(s[4:])): s = self.fp.read(16) if not m: m = s elif i8(s[0]) > i8(m[0]) and i8(s[1]) > i8(m[1]): m = s - # print("width", i8(s[0])) - # print("height", i8(s[1])) - # print("colors", i8(s[2])) - # print("reserved", i8(s[3])) - # print("hotspot x", i16(s[4:])) - # print("hotspot y", i16(s[6:])) - # print("bytes", i32(s[8:])) - # print("offset", i32(s[12:])) if not m: raise TypeError("No cursors were found") diff --git a/serverless-lambda/vendored/PIL/DcxImagePlugin.py b/serverless-lambda/vendored/PIL/DcxImagePlugin.py index 2045927..2c0da29 100644 --- a/serverless-lambda/vendored/PIL/DcxImagePlugin.py +++ b/serverless-lambda/vendored/PIL/DcxImagePlugin.py @@ -52,12 +52,12 @@ def _open(self): # Component directory self._offset = [] - for i in range(1024): - offset = i32(self.fp.read(4)) - if not offset: - break - self._offset.append(offset) + for _ in range(1024): + if offset := i32(self.fp.read(4)): + self._offset.append(offset) + else: + break self.__fp = self.fp self.frame = None self.seek(0) diff --git a/serverless-lambda/vendored/PIL/DdsImagePlugin.py b/serverless-lambda/vendored/PIL/DdsImagePlugin.py index 9508e61..ab28f4a 100644 --- a/serverless-lambda/vendored/PIL/DdsImagePlugin.py +++ b/serverless-lambda/vendored/PIL/DdsImagePlugin.py @@ -110,7 +110,7 @@ def _open(self): raise IOError("Unsupported header size %r" % (header_size)) header_bytes = self.fp.read(header_size - 4) if len(header_bytes) != 120: - raise IOError("Incomplete header: %s bytes" % len(header_bytes)) + raise IOError(f"Incomplete header: {len(header_bytes)} bytes") header = BytesIO(header_bytes) flags, height, width = struct.unpack("<3I", header.read(12)) diff --git a/serverless-lambda/vendored/PIL/EpsImagePlugin.py b/serverless-lambda/vendored/PIL/EpsImagePlugin.py index b503487..fab4586 100644 --- a/serverless-lambda/vendored/PIL/EpsImagePlugin.py +++ b/serverless-lambda/vendored/PIL/EpsImagePlugin.py @@ -44,12 +44,14 @@ # Python < 3.3 import distutils.spawn which = distutils.spawn.find_executable - for binary in ('gswin32c', 'gswin64c', 'gs'): - if which(binary) is not None: - gs_windows_binary = binary - break - else: - gs_windows_binary = False + gs_windows_binary = next( + ( + binary + for binary in ('gswin32c', 'gswin64c', 'gs') + if which(binary) is not None + ), + False, + ) def has_ghostscript(): @@ -98,10 +100,7 @@ def Ghostscript(tile, size, fp, scale=1): os.close(in_fd) infile = infile_temp - # ignore length and offset! - # ghostscript can read it - # copy whole file to read in ghostscript - with open(infile_temp, 'wb') as f: + with open(infile, 'wb') as f: # fetch length of fp fp.seek(0, 2) fsize = fp.tell() @@ -117,20 +116,23 @@ def Ghostscript(tile, size, fp, scale=1): f.write(s) # Build ghostscript command - command = ["gs", - "-q", # quiet mode - "-g%dx%d" % size, # set output geometry (pixels) - "-r%fx%f" % res, # set input DPI (dots per inch) - "-dBATCH", # exit after processing - "-dNOPAUSE", # don't pause between pages, - "-dSAFER", # safe mode - "-sDEVICE=ppmraw", # ppm driver - "-sOutputFile=%s" % outfile, # output file - "-c", "%d %d translate" % (-bbox[0], -bbox[1]), - # adjust for image origin - "-f", infile, # input file - "-c", "showpage", # showpage (see: https://bugs.ghostscript.com/show_bug.cgi?id=698272) - ] + command = [ + "gs", + "-q", + "-g%dx%d" % size, + "-r%fx%f" % res, + "-dBATCH", + "-dNOPAUSE", + "-dSAFER", + "-sDEVICE=ppmraw", + f"-sOutputFile={outfile}", + "-c", + "%d %d translate" % (-bbox[0], -bbox[1]), + "-f", + infile, + "-c", + "showpage", + ] if gs_windows_binary is not None: if not gs_windows_binary: @@ -255,23 +257,17 @@ def _open(self): except: pass - else: - m = field.match(s) - if m: - k = m.group(1) - - if k == "EndComments": - break - if k[:8] == "PS-Adobe": - self.info[k[:8]] = k[9:] - else: - self.info[k] = "" - elif s[0] == '%': - # handle non-DSC Postscript comments that some - # tools mistakenly put in the Comments section - pass + elif m := field.match(s): + k = m.group(1) + + if k == "EndComments": + break + if k[:8] == "PS-Adobe": + self.info[k[:8]] = k[9:] else: - raise IOError("bad EPS header") + self.info[k] = "" + elif s[0] != '%': + raise IOError("bad EPS header") s_raw = fp.readline() s = s_raw.strip('\r\n') @@ -317,7 +313,7 @@ def _find_offset(self, fp): fp.seek(0, 2) length = fp.tell() offset = 0 - elif i32(s[0:4]) == 0xC6D3D0C5: + elif i32(s[:4]) == 0xC6D3D0C5: # FIX for: Some EPS file not handled correctly / issue #302 # EPS can contain binary data # or start directly with latin coding diff --git a/serverless-lambda/vendored/PIL/FitsStubImagePlugin.py b/serverless-lambda/vendored/PIL/FitsStubImagePlugin.py index be926ca..c98b6a4 100644 --- a/serverless-lambda/vendored/PIL/FitsStubImagePlugin.py +++ b/serverless-lambda/vendored/PIL/FitsStubImagePlugin.py @@ -52,8 +52,7 @@ def _open(self): self.mode = "F" self.size = 1, 1 - loader = self._load() - if loader: + if loader := self._load(): loader.open(self) def _load(self): diff --git a/serverless-lambda/vendored/PIL/FliImagePlugin.py b/serverless-lambda/vendored/PIL/FliImagePlugin.py index 2c190b6..bd9d61c 100644 --- a/serverless-lambda/vendored/PIL/FliImagePlugin.py +++ b/serverless-lambda/vendored/PIL/FliImagePlugin.py @@ -44,9 +44,11 @@ def _open(self): # HEAD s = self.fp.read(128) magic = i16(s[4:6]) - if not (magic in [0xAF11, 0xAF12] and - i16(s[14:16]) in [0, 3] and # flags - s[20:22] == b"\x00\x00"): # reserved + if ( + magic not in [0xAF11, 0xAF12] + or i16(s[14:16]) not in [0, 3] + or s[20:22] != b"\x00\x00" + ): # reserved raise SyntaxError("not an FLI/FLC file") # frames @@ -71,7 +73,7 @@ def _open(self): if i16(s[4:6]) == 0xF100: # prefix chunk; ignore it - self.__offset = self.__offset + i32(s) + self.__offset += i32(s) s = self.fp.read(16) if i16(s[4:6]) == 0xF1FA: @@ -95,7 +97,7 @@ def _palette(self, palette, shift): # load palette i = 0 - for e in range(i16(self.fp.read(2))): + for _ in range(i16(self.fp.read(2))): s = self.fp.read(2) i = i + i8(s[0]) n = i8(s[1]) diff --git a/serverless-lambda/vendored/PIL/FontFile.py b/serverless-lambda/vendored/PIL/FontFile.py index 46e49bc..550a188 100644 --- a/serverless-lambda/vendored/PIL/FontFile.py +++ b/serverless-lambda/vendored/PIL/FontFile.py @@ -77,8 +77,7 @@ def compile(self): self.metrics = [None] * 256 x = y = 0 for i in range(256): - glyph = self[i] - if glyph: + if glyph := self[i]: d, dst, src, im = glyph xx = src[2] - src[0] # yy = src[3] - src[1] @@ -99,16 +98,15 @@ def save(self, filename): self.compile() # font data - self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG") + self.bitmap.save(f"{os.path.splitext(filename)[0]}.pbm", "PNG") # font metrics - with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp: + with open(f"{os.path.splitext(filename)[0]}.pil", "wb") as fp: fp.write(b"PILfont\n") fp.write((";;;;;;%d;\n" % self.ysize).encode('ascii')) # HACK!!! fp.write(b"DATA\n") for id in range(256): - m = self.metrics[id] - if not m: - puti16(fp, [0] * 10) - else: + if m := self.metrics[id]: puti16(fp, m[0] + m[1] + m[2]) + else: + puti16(fp, [0] * 10) diff --git a/serverless-lambda/vendored/PIL/FpxImagePlugin.py b/serverless-lambda/vendored/PIL/FpxImagePlugin.py index d7bba42..474cb07 100644 --- a/serverless-lambda/vendored/PIL/FpxImagePlugin.py +++ b/serverless-lambda/vendored/PIL/FpxImagePlugin.py @@ -100,11 +100,7 @@ def _open_index(self, index=1): s = prop[0x2000002 | id] - colors = [] - for i in range(i32(s, 4)): - # note: for now, we ignore the "uncalibrated" flag - colors.append(i32(s, 8+i*4) & 0x7fffffff) - + colors = [i32(s, 8+i*4) & 0x7fffffff for i in range(i32(s, 4))] self.mode, self.rawmode = MODES[tuple(colors)] # load JPEG tables, if any diff --git a/serverless-lambda/vendored/PIL/GbrImagePlugin.py b/serverless-lambda/vendored/PIL/GbrImagePlugin.py index bd4c12f..e296bd3 100644 --- a/serverless-lambda/vendored/PIL/GbrImagePlugin.py +++ b/serverless-lambda/vendored/PIL/GbrImagePlugin.py @@ -46,7 +46,7 @@ def _open(self): if header_size < 20: raise SyntaxError("not a GIMP brush") if version not in (1, 2): - raise SyntaxError("Unsupported GIMP brush version: %s" % version) + raise SyntaxError(f"Unsupported GIMP brush version: {version}") width = i32(self.fp.read(4)) height = i32(self.fp.read(4)) @@ -54,7 +54,7 @@ def _open(self): if width <= 0 or height <= 0: raise SyntaxError("not a GIMP brush") if color_depth not in (1, 4): - raise SyntaxError("Unsupported GIMP brush color depth: %s" % color_depth) + raise SyntaxError(f"Unsupported GIMP brush color depth: {color_depth}") if version == 1: comment_length = header_size-20 @@ -67,11 +67,7 @@ def _open(self): comment = self.fp.read(comment_length)[:-1] - if color_depth == 1: - self.mode = "L" - else: - self.mode = 'RGBA' - + self.mode = "L" if color_depth == 1 else 'RGBA' self.size = width, height self.info["comment"] = comment diff --git a/serverless-lambda/vendored/PIL/GdImageFile.py b/serverless-lambda/vendored/PIL/GdImageFile.py index 09ab5ec..2299a87 100644 --- a/serverless-lambda/vendored/PIL/GdImageFile.py +++ b/serverless-lambda/vendored/PIL/GdImageFile.py @@ -53,7 +53,7 @@ def _open(self): s = self.fp.read(775) self.mode = "L" # FIXME: "P" - self.size = i16(s[0:2]), i16(s[2:4]) + self.size = i16(s[:2]), i16(s[2:4]) # transparency index tindex = i16(s[5:7]) diff --git a/serverless-lambda/vendored/PIL/GifImagePlugin.py b/serverless-lambda/vendored/PIL/GifImagePlugin.py index c01adff..a22ef64 100644 --- a/serverless-lambda/vendored/PIL/GifImagePlugin.py +++ b/serverless-lambda/vendored/PIL/GifImagePlugin.py @@ -53,9 +53,7 @@ class GifImageFile(ImageFile.ImageFile): def data(self): s = self.fp.read(1) - if s and i8(s): - return self.fp.read(i8(s)) - return None + return self.fp.read(i8(s)) if s and i8(s) else None def _open(self): @@ -102,9 +100,7 @@ def n_frames(self): @property def is_animated(self): if self._is_animated is None: - if self._n_frames is not None: - self._is_animated = self._n_frames != 1 - else: + if self._n_frames is None: current = self.tell() try: @@ -114,6 +110,8 @@ def is_animated(self): self._is_animated = False self.seek(current) + else: + self._is_animated = self._n_frames != 1 return self._is_animated def seek(self, frame): @@ -133,18 +131,15 @@ def seek(self, frame): def _seek(self, frame): if frame == 0: - # rewind - self.__offset = 0 self.dispose = None self.dispose_extent = [0, 0, 0, 0] # x0, y0, x1, y1 self.__frame = -1 + self.__offset = 0 self.__fp.seek(self.__rewind) self._prev_im = None self.disposal_method = 0 - else: - # ensure that the previous frame was loaded - if not self.im: - self.load() + elif not self.im: + self.load() if frame != self.__frame + 1: raise ValueError("cannot seek to frame %d" % frame) @@ -189,8 +184,7 @@ def _seek(self, frame): # disposal method - find the value of bits 4 - 6 dispose_bits = 0b00011100 & flags - dispose_bits = dispose_bits >> 2 - if dispose_bits: + if dispose_bits := dispose_bits >> 2: # only set the dispose if it is not # unspecified. I'm not sure if this is # correct, but it seems to prevent the last @@ -220,7 +214,7 @@ def _seek(self, frame): s = self.fp.read(9) # extent - x0, y0 = i16(s[0:]), i16(s[2:]) + x0, y0 = i16(s[:]), i16(s[2:]) x1, y1 = x0 + i16(s[4:]), y0 + i16(s[6:]) self.dispose_extent = x0, y0, x1, y1 flags = i8(s[8]) @@ -230,7 +224,7 @@ def _seek(self, frame): if flags & 128: bits = (flags & 7) + 1 self.palette =\ - ImagePalette.raw("RGB", self.fp.read(3 << bits)) + ImagePalette.raw("RGB", self.fp.read(3 << bits)) # image data bits = i8(self.fp.read(1)) @@ -241,10 +235,6 @@ def _seek(self, frame): (bits, interlace))] break - else: - pass - # raise IOError, "illegal GIF tag `%x`" % i8(s) - try: if self.disposal_method < 2: # do not dispose or none specified @@ -253,10 +243,8 @@ def _seek(self, frame): # replace with background colour self.dispose = Image.core.fill("P", self.size, self.info["background"]) - else: - # replace with previous contents - if self.im: - self.dispose = self.im.copy() + elif self.im: + self.dispose = self.im.copy() # only dispose the extent in this frame if self.dispose: @@ -320,13 +308,10 @@ def _normalize_mode(im, initial_call=False): im.load() return im if Image.getmodebase(im.mode) == "RGB": - if initial_call: - palette_size = 256 - if im.palette: - palette_size = len(im.palette.getdata()[1]) // 3 - return im.convert("P", palette=Image.ADAPTIVE, colors=palette_size) - else: + if not initial_call: return im.convert("P") + palette_size = len(im.palette.getdata()[1]) // 3 if im.palette else 256 + return im.convert("P", palette=Image.ADAPTIVE, colors=palette_size) return im.convert("L") @@ -380,7 +365,7 @@ def _write_single_frame(im, fp, palette): # local image header flags = 0 if get_interlace(im): - flags = flags | 64 + flags |= 64 _write_local_header(fp, im, (0, 0), flags) im_out.encoderconfig = (8, get_interlace(im)) @@ -590,12 +575,10 @@ def _save_netpbm(im, fp, filename): # Allow ppmquant to receive SIGPIPE if ppmtogif exits quant_proc.stdout.close() - retcode = quant_proc.wait() - if retcode: + if retcode := quant_proc.wait(): raise CalledProcessError(retcode, quant_cmd) - retcode = togif_proc.wait() - if retcode: + if retcode := togif_proc.wait(): raise CalledProcessError(retcode, togif_cmd) try: @@ -633,12 +616,7 @@ def _get_optimize(im, info): # create the new palette if not every color is used optimise = _FORCE_OPTIMIZE or im.mode == 'L' if optimise or im.width * im.height < 512 * 512: - # check which colors are used - used_palette_colors = [] - for i, count in enumerate(im.histogram()): - if count: - used_palette_colors.append(i) - + used_palette_colors = [i for i, count in enumerate(im.histogram()) if count] if optimise or (len(used_palette_colors) <= 128 and max(used_palette_colors) > len(used_palette_colors)): return used_palette_colors @@ -648,8 +626,7 @@ def _get_color_table_size(palette_bytes): # calculate the palette size for the header import math color_table_size = int(math.ceil(math.log(len(palette_bytes)//3, 2)))-1 - if color_table_size < 0: - color_table_size = 0 + color_table_size = max(color_table_size, 0) return color_table_size diff --git a/serverless-lambda/vendored/PIL/GimpGradientFile.py b/serverless-lambda/vendored/PIL/GimpGradientFile.py index 10593da..9f6ae9d 100644 --- a/serverless-lambda/vendored/PIL/GimpGradientFile.py +++ b/serverless-lambda/vendored/PIL/GimpGradientFile.py @@ -27,17 +27,10 @@ def linear(middle, pos): if pos <= middle: - if middle < EPSILON: - return 0.0 - else: - return 0.5 * pos / middle - else: - pos = pos - middle - middle = 1.0 - middle - if middle < EPSILON: - return 1.0 - else: - return 0.5 + 0.5 * pos / middle + return 0.0 if middle < EPSILON else 0.5 * pos / middle + pos = pos - middle + middle = 1.0 - middle + return 1.0 if middle < EPSILON else 0.5 + 0.5 * pos / middle def curved(middle, pos): @@ -117,22 +110,17 @@ def __init__(self, fp): gradient = [] - for i in range(count): - + for _ in range(count): s = fp.readline().split() w = [float(x) for x in s[:11]] x0, x1 = w[0], w[2] - xm = w[1] - rgb0 = w[3:7] - rgb1 = w[7:11] - - segment = SEGMENTS[int(s[11])] cspace = int(s[12]) if cspace != 0: raise IOError("cannot handle HSV colour space") - gradient.append((x0, x1, xm, rgb0, rgb1, segment)) + xm = w[1] + gradient.append((x0, x1, xm, w[3:7], w[7:11], SEGMENTS[int(s[11])])) self.gradient = gradient diff --git a/serverless-lambda/vendored/PIL/GribStubImagePlugin.py b/serverless-lambda/vendored/PIL/GribStubImagePlugin.py index 33c8291..4ec1367 100644 --- a/serverless-lambda/vendored/PIL/GribStubImagePlugin.py +++ b/serverless-lambda/vendored/PIL/GribStubImagePlugin.py @@ -29,7 +29,7 @@ def register_handler(handler): # Image adapter def _accept(prefix): - return prefix[0:4] == b"GRIB" and i8(prefix[7]) == 1 + return prefix[:4] == b"GRIB" and i8(prefix[7]) == 1 class GribStubImageFile(ImageFile.StubImageFile): @@ -50,8 +50,7 @@ def _open(self): self.mode = "F" self.size = 1, 1 - loader = self._load() - if loader: + if loader := self._load(): loader.open(self) def _load(self): diff --git a/serverless-lambda/vendored/PIL/Hdf5StubImagePlugin.py b/serverless-lambda/vendored/PIL/Hdf5StubImagePlugin.py index de4d5bb..c758beb 100644 --- a/serverless-lambda/vendored/PIL/Hdf5StubImagePlugin.py +++ b/serverless-lambda/vendored/PIL/Hdf5StubImagePlugin.py @@ -49,8 +49,7 @@ def _open(self): self.mode = "F" self.size = 1, 1 - loader = self._load() - if loader: + if loader := self._load(): loader.open(self) def _load(self): diff --git a/serverless-lambda/vendored/PIL/IcnsImagePlugin.py b/serverless-lambda/vendored/PIL/IcnsImagePlugin.py index b382a73..9ee5bdc 100644 --- a/serverless-lambda/vendored/PIL/IcnsImagePlugin.py +++ b/serverless-lambda/vendored/PIL/IcnsImagePlugin.py @@ -72,8 +72,7 @@ def read_32(fobj, start_length, size): if byte & 0x80: blocksize = byte - 125 byte = fobj.read(1) - for i in range(blocksize): - data.append(byte) + data.extend(byte for _ in range(blocksize)) else: blocksize = byte + 1 data.append(fobj.read(blocksize)) @@ -208,10 +207,10 @@ def itersizes(self): return sizes def bestsize(self): - sizes = self.itersizes() - if not sizes: + if sizes := self.itersizes(): + return max(sizes) + else: raise SyntaxError("No 32bit icon resources found") - return max(sizes) def dataforsize(self, size): """ @@ -223,7 +222,7 @@ def dataforsize(self, size): for code, reader in self.SIZES[size]: desc = self.dct.get(code) if desc is not None: - dct.update(reader(self.fobj, desc, size)) + dct |= reader(self.fobj, desc, size) return dct def getimage(self, size=None): @@ -314,16 +313,16 @@ def _save(im, fp, filename): im.encoderinfo.get("append_images", [])} last_w = None for w in [16, 32, 128, 256, 512]: - prefix = 'icon_{}x{}'.format(w, w) + prefix = f'icon_{w}x{w}' - first_path = os.path.join(iconset, prefix+'.png') + first_path = os.path.join(iconset, f'{prefix}.png') if last_w == w: shutil.copyfile(second_path, first_path) else: im_w = provided_images.get(w, im.resize((w, w), Image.LANCZOS)) im_w.save(first_path) - second_path = os.path.join(iconset, prefix+'@2x.png') + second_path = os.path.join(iconset, f'{prefix}@2x.png') im_w2 = provided_images.get(w*2, im.resize((w*2, w*2), Image.LANCZOS)) im_w2.save(second_path) last_w = w*2 diff --git a/serverless-lambda/vendored/PIL/IcoImagePlugin.py b/serverless-lambda/vendored/PIL/IcoImagePlugin.py index 428fdd4..c41b5e1 100644 --- a/serverless-lambda/vendored/PIL/IcoImagePlugin.py +++ b/serverless-lambda/vendored/PIL/IcoImagePlugin.py @@ -43,9 +43,13 @@ def _save(im, fp, filename): [(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)]) width, height = im.size - sizes = filter(lambda x: False if (x[0] > width or x[1] > height or - x[0] > 256 or x[1] > 256) else True, - sizes) + sizes = filter( + lambda x: x[0] <= width + and x[1] <= height + and x[0] <= 256 + and x[1] <= 256, + sizes, + ) sizes = list(sizes) fp.write(struct.pack("' _MODE_CONV = { - # official modes - "1": ('|b1', None), # Bits need to be extended to bytes + "1": ('|b1', None), "L": ('|u1', None), "LA": ('|u1', 2), - "I": (_ENDIAN + 'i4', None), - "F": (_ENDIAN + 'f4', None), + "I": (f'{_ENDIAN}i4', None), + "F": (f'{_ENDIAN}f4', None), "P": ('|u1', None), "RGB": ('|u1', 3), "RGBX": ('|u1', 4), "RGBA": ('|u1', 4), "CMYK": ('|u1', 4), "YCbCr": ('|u1', 3), - "LAB": ('|u1', 3), # UNDONE - unsigned |u1i1i1 + "LAB": ('|u1', 3), "HSV": ('|u1', 3), - # I;16 == I;16L, and I;32 == I;32L "I;16": ('u2', None), "I;16L": (' maxcolors: - return None - return out + out = [(h[i], i) for i in range(256) if h[i]] + return None if len(out) > maxcolors else out return self.im.getcolors(maxcolors) def getdata(self, band=None): @@ -1218,9 +1191,7 @@ def getdata(self, band=None): """ self.load() - if band is not None: - return self.im.getband(band) - return self.im # could be abused + return self.im.getband(band) if band is not None else self.im def getextrema(self): """ @@ -1234,9 +1205,7 @@ def getextrema(self): self.load() if self.im.bands > 1: - extrema = [] - for i in range(self.im.bands): - extrema.append(self.im.getband(i).getextrema()) + extrema = [self.im.getband(i).getextrema() for i in range(self.im.bands)] return tuple(extrema) return self.im.getextrema() @@ -1277,9 +1246,7 @@ def getpixel(self, xy): """ self.load() - if self.pyaccess: - return self.pyaccess.getpixel(xy) - return self.im.getpixel(xy) + return self.pyaccess.getpixel(xy) if self.pyaccess else self.im.getpixel(xy) def getprojection(self): """ @@ -1425,9 +1392,9 @@ def alpha_composite(self, im, dest=(0, 0), source=(0, 0)): raise ValueError("Source must be a tuple") if not isinstance(dest, (list, tuple)): raise ValueError("Destination must be a tuple") - if not len(source) in (2, 4): + if len(source) not in {2, 4}: raise ValueError("Source must be a 2 or 4-tuple") - if not len(dest) == 2: + if len(dest) != 2: raise ValueError("Destination must be a 2-tuple") if min(source) < 0: raise ValueError("Source must be non-negative") @@ -1438,20 +1405,12 @@ def alpha_composite(self, im, dest=(0, 0), source=(0, 0)): source = source + im.size # over image, crop if it's not the whole thing. - if source == (0, 0) + im.size: - overlay = im - else: - overlay = im.crop(source) - + overlay = im if source == (0, 0) + im.size else im.crop(source) # target for the paste box = dest + (dest[0] + overlay.width, dest[1] + overlay.height) # destination image. don't copy if we're using the whole image. - if box == (0, 0) + self.size: - background = self - else: - background = self.crop(box) - + background = self if box == (0, 0) + self.size else self.crop(box) result = alpha_composite(background, overlay) self.paste(result, box) @@ -1510,7 +1469,7 @@ def putalpha(self, alpha): if self.mode not in ("LA", "RGBA"): # attempt to promote self to a matching alpha mode try: - mode = getmodebase(self.mode) + "A" + mode = f"{getmodebase(self.mode)}A" try: self.im.setmode(mode) except (AttributeError, ValueError): @@ -1524,11 +1483,7 @@ def putalpha(self, alpha): except (KeyError, ValueError): raise ValueError("illegal image mode") - if self.mode == "LA": - band = 1 - else: - band = 3 - + band = 1 if self.mode == "LA" else 3 if isImageType(alpha): # alpha layer if alpha.mode not in ("1", "L"): @@ -1586,10 +1541,7 @@ def putpalette(self, data, rawmode="RGB"): palette = ImagePalette.raw(data.rawmode, data.palette) else: if not isinstance(data, bytes): - if bytes is str: - data = "".join(chr(x) for x in data) - else: - data = bytes(data) + data = "".join(chr(x) for x in data) if bytes is str else bytes(data) palette = ImagePalette.raw(rawmode, data) self.mode = "P" self.palette = palette @@ -1727,11 +1679,7 @@ def resize(self, size, resample=NEAREST, box=None): size = tuple(size) - if box is None: - box = (0, 0) + self.size - else: - box = tuple(box) - + box = (0, 0) + self.size if box is None else tuple(box) if self.size == size and box == (0, 0) + self.size: return self.copy() @@ -1808,15 +1756,8 @@ def rotate(self, angle, resample=NEAREST, expand=0, center=None, w, h = self.size - if translate is None: - post_trans = (0, 0) - else: - post_trans = translate - if center is None: - rotn_center = (w / 2.0, h / 2.0) # FIXME These should be rounded to ints? - else: - rotn_center = center - + post_trans = (0, 0) if translate is None else translate + rotn_center = (w / 2.0, h / 2.0) if center is None else center angle = - math.radians(angle) matrix = [ round(math.cos(angle), 15), round(math.sin(angle), 15), 0.0, @@ -1898,9 +1839,7 @@ def save(self, fp, format=None, **params): # may mutate self! self.load() - save_all = False - if 'save_all' in params: - save_all = params.pop('save_all') + save_all = params.pop('save_all') if 'save_all' in params else False self.encoderinfo = params self.encoderconfig = () @@ -1914,15 +1853,11 @@ def save(self, fp, format=None, **params): try: format = EXTENSION[ext] except KeyError: - raise ValueError('unknown file extension: {}'.format(ext)) + raise ValueError(f'unknown file extension: {ext}') if format.upper() not in SAVE: init() - if save_all: - save_handler = SAVE_ALL[format.upper()] - else: - save_handler = SAVE[format.upper()] - + save_handler = SAVE_ALL[format.upper()] if save_all else SAVE[format.upper()] if open_fp: if params.get('append', False): fp = builtins.open(filename, "r+b") @@ -1996,10 +1931,7 @@ def split(self): """ self.load() - if self.im.bands == 1: - ims = [self.copy()] - else: - ims = map(self._new, self.im.split()) + ims = [self.copy()] if self.im.bands == 1 else map(self._new, self.im.split()) return tuple(ims) def getchannel(self, channel): @@ -2019,8 +1951,7 @@ def getchannel(self, channel): try: channel = self.getbands().index(channel) except ValueError: - raise ValueError( - 'The image has no channel "{}"'.format(channel)) + raise ValueError(f'The image has no channel "{channel}"') return self._new(self.im.getband(channel)) @@ -2144,7 +2075,7 @@ def __transformer(self, box, image, method, data, h = box[3] - box[1] if method == AFFINE: - data = data[0:6] + data = data[:6] elif method == EXTENT: # convert extent to an affine transform @@ -2155,12 +2086,12 @@ def __transformer(self, box, image, method, data, data = (xs, 0, x0, 0, ys, y0) elif method == PERSPECTIVE: - data = data[0:8] + data = data[:8] elif method == QUAD: # quadrilateral warp. data specifies the four corners # given as NW, SW, SE, and NE. - nw = data[0:2] + nw = data[:2] sw = data[2:4] se = data[4:6] ne = data[6:8] @@ -2442,11 +2373,7 @@ def fromarray(obj, mode=None): size = shape[1], shape[0] if strides is not None: - if hasattr(obj, 'tobytes'): - obj = obj.tobytes() - else: - obj = obj.tostring() - + obj = obj.tobytes() if hasattr(obj, 'tobytes') else obj.tostring() return frombuffer(mode, size, obj, "raw", rawmode, 0, 1) @@ -2490,8 +2417,8 @@ def fromqpixmap(im): } # shortcuts -_fromarray_typemap[((1, 1), _ENDIAN + "i4")] = ("I", "I") -_fromarray_typemap[((1, 1), _ENDIAN + "f4")] = ("F", "F") +_fromarray_typemap[(1, 1), f"{_ENDIAN}i4"] = ("I", "I") +_fromarray_typemap[(1, 1), f"{_ENDIAN}f4"] = ("F", "F") def _decompression_bomb_check(size): diff --git a/serverless-lambda/vendored/PIL/ImageCms.py b/serverless-lambda/vendored/PIL/ImageCms.py index d82e30e..f060797 100644 --- a/serverless-lambda/vendored/PIL/ImageCms.py +++ b/serverless-lambda/vendored/PIL/ImageCms.py @@ -170,12 +170,8 @@ def __init__(self, profile): def _set(self, profile, filename=None): self.profile = profile self.filename = filename - if profile: - self.product_name = None # profile.product_name - self.product_info = None # profile.product_info - else: - self.product_name = None - self.product_info = None + self.product_info = None # profile.product_info + self.product_name = None # profile.product_name def tobytes(self): """ @@ -333,8 +329,7 @@ def profileToProfile( raise PyCMSError("renderingIntent must be an integer between 0 and 3") if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG): - raise PyCMSError( - "flags must be an integer between 0 and %s" + _MAX_FLAG) + raise PyCMSError(f"flags must be an integer between 0 and %s{_MAX_FLAG}") try: if not isinstance(inputProfile, ImageCmsProfile): @@ -440,8 +435,7 @@ def buildTransform( raise PyCMSError("renderingIntent must be an integer between 0 and 3") if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG): - raise PyCMSError( - "flags must be an integer between 0 and %s" + _MAX_FLAG) + raise PyCMSError(f"flags must be an integer between 0 and %s{_MAX_FLAG}") try: if not isinstance(inputProfile, ImageCmsProfile): @@ -538,8 +532,7 @@ def buildProofTransform( raise PyCMSError("renderingIntent must be an integer between 0 and 3") if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG): - raise PyCMSError( - "flags must be an integer between 0 and %s" + _MAX_FLAG) + raise PyCMSError(f"flags must be an integer between 0 and %s{_MAX_FLAG}") try: if not isinstance(inputProfile, ImageCmsProfile): @@ -641,8 +634,8 @@ def createProfile(colorSpace, colorTemp=-1): if colorSpace not in ["LAB", "XYZ", "sRGB"]: raise PyCMSError( - "Color space not supported for on-the-fly profile creation (%s)" - % colorSpace) + f"Color space not supported for on-the-fly profile creation ({colorSpace})" + ) if colorSpace == "LAB": try: @@ -690,12 +683,14 @@ def getProfileName(profile): model = profile.profile.product_model manufacturer = profile.profile.product_manufacturer - if not (model or manufacturer): + if model or manufacturer: + return ( + model + "\n" + if not manufacturer or len(model) > 30 + else "%s - %s\n" % (model, manufacturer) + ) + else: return profile.profile.product_description + "\n" - if not manufacturer or len(model) > 30: - return model + "\n" - return "%s - %s\n" % (model, manufacturer) - except (AttributeError, IOError, TypeError, ValueError) as v: raise PyCMSError(v) @@ -730,10 +725,7 @@ def getProfileInfo(profile): # // info was description \r\n\r\n copyright \r\n\r\n K007 tag \r\n\r\n whitepoint description = profile.profile.product_description cpright = profile.profile.product_copyright - arr = [] - for elt in (description, cpright): - if elt: - arr.append(elt) + arr = [elt for elt in (description, cpright) if elt] return "\r\n\r\n".join(arr) + "\r\n\r\n" except (AttributeError, IOError, TypeError, ValueError) as v: @@ -936,10 +928,7 @@ def isIntentSupported(profile, intent, direction): profile = ImageCmsProfile(profile) # FIXME: I get different results for the same data w. different # compilers. Bug in LittleCMS or in the binding? - if profile.profile.is_intent_supported(intent, direction): - return 1 - else: - return -1 + return 1 if profile.profile.is_intent_supported(intent, direction) else -1 except (AttributeError, IOError, TypeError, ValueError) as v: raise PyCMSError(v) diff --git a/serverless-lambda/vendored/PIL/ImageColor.py b/serverless-lambda/vendored/PIL/ImageColor.py index 4a1c90b..72f5ed7 100644 --- a/serverless-lambda/vendored/PIL/ImageColor.py +++ b/serverless-lambda/vendored/PIL/ImageColor.py @@ -33,8 +33,7 @@ def getrgb(color): """ color = color.lower() - rgb = colormap.get(color, None) - if rgb: + if rgb := colormap.get(color, None): if isinstance(rgb, tuple): return rgb colormap[color] = rgb = getrgb(rgb) @@ -71,45 +70,29 @@ def getrgb(color): int(color[7:9], 16), ) - m = re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color) - if m: - return ( - int(m.group(1)), - int(m.group(2)), - int(m.group(3)) - ) + if m := re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color): + return int(m[1]), int(m[2]), int(m[3]) - m = re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color) - if m: + if m := re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color): return ( - int((int(m.group(1)) * 255) / 100.0 + 0.5), - int((int(m.group(2)) * 255) / 100.0 + 0.5), - int((int(m.group(3)) * 255) / 100.0 + 0.5) - ) + int(int(m[1]) * 255 / 100.0 + 0.5), + int(int(m[2]) * 255 / 100.0 + 0.5), + int(int(m[3]) * 255 / 100.0 + 0.5), + ) - m = re.match(r"hsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color) - if m: + if m := re.match(r"hsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color): from colorsys import hls_to_rgb - rgb = hls_to_rgb( - float(m.group(1)) / 360.0, - float(m.group(3)) / 100.0, - float(m.group(2)) / 100.0, - ) + rgb = hls_to_rgb(float(m[1]) / 360.0, float(m[3]) / 100.0, float(m[2]) / 100.0) return ( int(rgb[0] * 255 + 0.5), int(rgb[1] * 255 + 0.5), int(rgb[2] * 255 + 0.5) ) - m = re.match(r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", - color) - if m: - return ( - int(m.group(1)), - int(m.group(2)), - int(m.group(3)), - int(m.group(4)) - ) + if m := re.match( + r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color + ): + return int(m[1]), int(m[2]), int(m[3]), int(m[4]) raise ValueError("unknown color specifier: %r" % color) @@ -127,16 +110,15 @@ def getcolor(color, mode): # same as getrgb, but converts the result to the given mode color, alpha = getrgb(color), 255 if len(color) == 4: - color, alpha = color[0:3], color[3] + color, alpha = color[:3], color[3] if Image.getmodebase(mode) == "L": r, g, b = color color = (r*299 + g*587 + b*114)//1000 if mode[-1] == 'A': return (color, alpha) - else: - if mode[-1] == 'A': - return color + (alpha,) + elif mode[-1] == 'A': + return color + (alpha,) return color diff --git a/serverless-lambda/vendored/PIL/ImageDraw.py b/serverless-lambda/vendored/PIL/ImageDraw.py index 89df273..e48bf7f 100644 --- a/serverless-lambda/vendored/PIL/ImageDraw.py +++ b/serverless-lambda/vendored/PIL/ImageDraw.py @@ -67,10 +67,7 @@ def __init__(self, im, mode=None): blend = 1 else: raise ValueError("mode mismatch") - if mode == "P": - self.palette = im.palette - else: - self.palette = None + self.palette = im.palette if mode == "P" else None self.im = im.im self.draw = Image.core.draw(self.im, blend) self.mode = mode @@ -78,11 +75,7 @@ def __init__(self, im, mode=None): self.ink = self.draw.draw_ink(1, mode) else: self.ink = self.draw.draw_ink(-1, mode) - if mode in ("1", "P", "I", "F"): - # FIXME: fix Fill2 to properly support matte for I+F images - self.fontmode = "1" - else: - self.fontmode = "L" # aliasing is okay for other modes + self.fontmode = "1" if mode in ("1", "P", "I", "F") else "L" self.fill = 0 self.font = None @@ -373,7 +366,7 @@ def floodfill(image, xy, value, border=None, thresh=0): except IndexError: pass else: - if p != value and p != border: + if p not in [value, border]: pixel[s, t] = value newedge.append((s, t)) edge = newedge diff --git a/serverless-lambda/vendored/PIL/ImageFile.py b/serverless-lambda/vendored/PIL/ImageFile.py index 1a3c4aa..1475984 100644 --- a/serverless-lambda/vendored/PIL/ImageFile.py +++ b/serverless-lambda/vendored/PIL/ImageFile.py @@ -56,7 +56,7 @@ def raise_ioerror(error): message = ERRORS.get(error) if not message: message = "decoder error %d" % error - raise IOError(message + " when reading image file") + raise IOError(f"{message} when reading image file") # @@ -116,8 +116,6 @@ def __init__(self, fp=None, filename=None): def draft(self, mode, size): "Set draft mode" - pass - def verify(self): "Check file integrity" @@ -162,7 +160,7 @@ def load(self): # try memory mapping decoder_name, extents, offset, args = self.tile[0] if decoder_name == "raw" and len(args) >= 3 and args[0] == self.mode \ - and args[0] in Image._MAPMODES: + and args[0] in Image._MAPMODES: try: if hasattr(Image.core, "map"): # use built-in mapper WIN32 only @@ -222,10 +220,9 @@ def load(self): if not s: # truncated jpeg if LOAD_TRUNCATED_IMAGES: break - else: - self.tile = [] - raise IOError("image file is truncated " - "(%d bytes not processed)" % len(b)) + self.tile = [] + raise IOError("image file is truncated " + "(%d bytes not processed)" % len(b)) b = b + s n, err_code = decoder.decode(b) @@ -299,7 +296,7 @@ def _open(self): def load(self): loader = self._load() if loader is None: - raise IOError("cannot find loader for this %s file" % self.format) + raise IOError(f"cannot find loader for this {self.format} file") image = loader.load(self) assert image is not None # become the other object (!) @@ -345,11 +342,7 @@ def feed(self, data): if self.finished: return - if self.data is None: - self.data = data - else: - self.data = self.data + data - + self.data = data if self.data is None else self.data + data # parse what we have if self.decoder: @@ -367,23 +360,15 @@ def feed(self, data): # end of stream self.data = None self.finished = 1 - if e < 0: - # decoding error - self.image = None - raise_ioerror(e) - else: + if e >= 0: # end of image return + # decoding error + self.image = None + raise_ioerror(e) self.data = self.data[n:] - elif self.image: - - # if we end up here with no decoder, this file cannot - # be incrementally parsed. wait until we've gotten all - # available data - pass - - else: + elif not self.image: # attempt to open this file try: @@ -621,11 +606,7 @@ def setimage(self, im, extents=None): # following c code self.im = im - if extents: - (x0, y0, x1, y1) = extents - else: - (x0, y0, x1, y1) = (0, 0, 0, 0) - + (x0, y0, x1, y1) = extents if extents else (0, 0, 0, 0) if x0 == 0 and x1 == 0: self.state.xsize, self.state.ysize = self.im.size else: diff --git a/serverless-lambda/vendored/PIL/ImageFont.py b/serverless-lambda/vendored/PIL/ImageFont.py index f3b55e0..1e5faf9 100644 --- a/serverless-lambda/vendored/PIL/ImageFont.py +++ b/serverless-lambda/vendored/PIL/ImageFont.py @@ -212,9 +212,7 @@ def getsize(self, text, *args, **kwargs): def getmask(self, text, mode="", *args, **kwargs): im = self.font.getmask(text, mode, *args, **kwargs) - if self.orientation is not None: - return im.transpose(self.orientation) - return im + return im.transpose(self.orientation) if self.orientation is not None else im def load(filename): @@ -264,11 +262,7 @@ def truetype(font=None, size=10, index=0, encoding="", dirs = [] if sys.platform == "win32": - # check the windows font repository - # NOTE: must use uppercase WINDIR, to work around bugs in - # 1.5.2's os.environ.get() - windir = os.environ.get("WINDIR") - if windir: + if windir := os.environ.get("WINDIR"): dirs.append(os.path.join(windir, "fonts")) elif sys.platform in ('linux', 'linux2'): lindirs = os.environ.get("XDG_DATA_DIRS", "") diff --git a/serverless-lambda/vendored/PIL/ImageMath.py b/serverless-lambda/vendored/PIL/ImageMath.py index c5bea70..3c848e3 100644 --- a/serverless-lambda/vendored/PIL/ImageMath.py +++ b/serverless-lambda/vendored/PIL/ImageMath.py @@ -27,7 +27,7 @@ def _isconstant(v): - return isinstance(v, int) or isinstance(v, float) + return isinstance(v, (int, float)) class _Operand(object): @@ -37,21 +37,20 @@ def __init__(self, im): self.im = im def __fixup(self, im1): - # convert image to suitable mode - if isinstance(im1, _Operand): + if not isinstance(im1, _Operand): + # argument was a constant + return ( + Image.new("I", self.im.size, im1) + if _isconstant(im1) and self.im.mode in ("1", "L", "I") + else Image.new("F", self.im.size, im1) + ) # argument was an image. - if im1.im.mode in ("1", "L"): - return im1.im.convert("I") - elif im1.im.mode in ("I", "F"): - return im1.im - else: - raise ValueError("unsupported mode: %s" % im1.im.mode) + if im1.im.mode in ("1", "L"): + return im1.im.convert("I") + elif im1.im.mode in ("I", "F"): + return im1.im else: - # argument was a constant - if _isconstant(im1) and self.im.mode in ("1", "L", "I"): - return Image.new("I", self.im.size, im1) - else: - return Image.new("F", self.im.size, im1) + raise ValueError(f"unsupported mode: {im1.im.mode}") def apply(self, op, im1, im2=None, mode=None): im1 = self.__fixup(im1) @@ -60,9 +59,9 @@ def apply(self, op, im1, im2=None, mode=None): out = Image.new(mode or im1.mode, im1.size, None) im1.load() try: - op = getattr(_imagingmath, op+"_"+im1.mode) + op = getattr(_imagingmath, f"{op}_{im1.mode}") except AttributeError: - raise TypeError("bad operand type for '%s'" % op) + raise TypeError(f"bad operand type for '{op}'") _imagingmath.unop(op, out.im.id, im1.im.id) else: # binary operation @@ -73,8 +72,8 @@ def apply(self, op, im1, im2=None, mode=None): im1 = im1.convert("F") if im2.mode != "F": im2 = im2.convert("F") - if im1.mode != im2.mode: - raise ValueError("mode mismatch") + if im1.mode != im2.mode: + raise ValueError("mode mismatch") if im1.size != im2.size: # crop both arguments to a common size size = (min(im1.size[0], im2.size[0]), @@ -89,9 +88,9 @@ def apply(self, op, im1, im2=None, mode=None): im1.load() im2.load() try: - op = getattr(_imagingmath, op+"_"+im1.mode) + op = getattr(_imagingmath, f"{op}_{im1.mode}") except AttributeError: - raise TypeError("bad operand type for '%s'" % op) + raise TypeError(f"bad operand type for '{op}'") _imagingmath.binop(op, out.im.id, im1.im.id, im2.im.id) return _Operand(out) @@ -236,10 +235,7 @@ def imagemath_convert(self, mode): return _Operand(self.im.convert(mode)) -ops = {} -for k, v in list(globals().items()): - if k[:10] == "imagemath_": - ops[k[10:]] = v +ops = {k[10:]: v for k, v in list(globals().items()) if k[:10] == "imagemath_"} def eval(expression, _dict={}, **kw): diff --git a/serverless-lambda/vendored/PIL/ImageMode.py b/serverless-lambda/vendored/PIL/ImageMode.py index b227f21..f91d85d 100644 --- a/serverless-lambda/vendored/PIL/ImageMode.py +++ b/serverless-lambda/vendored/PIL/ImageMode.py @@ -37,10 +37,10 @@ def getmode(mode): # initialize mode cache from . import Image - modes = {} - # core modes - for m, (basemode, basetype, bands) in Image._MODEINFO.items(): - modes[m] = ModeDescriptor(m, bands, basemode, basetype) + modes = { + m: ModeDescriptor(m, bands, basemode, basetype) + for m, (basemode, basetype, bands) in Image._MODEINFO.items() + } # extra experimental modes modes["RGBa"] = ModeDescriptor("RGBa", ("R", "G", "B", "a"), "RGB", "L") modes["LA"] = ModeDescriptor("LA", ("L", "A"), "L", "L") diff --git a/serverless-lambda/vendored/PIL/ImageMorph.py b/serverless-lambda/vendored/PIL/ImageMorph.py index d236773..e9b8198 100644 --- a/serverless-lambda/vendored/PIL/ImageMorph.py +++ b/serverless-lambda/vendored/PIL/ImageMorph.py @@ -49,10 +49,7 @@ class LutBuilder(object): """ def __init__(self, patterns=None, op_name=None): - if patterns is not None: - self.patterns = patterns - else: - self.patterns = [] + self.patterns = patterns if patterns is not None else [] self.lut = None if op_name is not None: known_patterns = { @@ -69,7 +66,7 @@ def __init__(self, patterns=None, op_name=None): '4:(01. .1. ...)->1'] } if op_name not in known_patterns: - raise Exception('Unknown pattern '+op_name+'!') + raise Exception(f'Unknown pattern {op_name}!') self.patterns = known_patterns[op_name] @@ -100,24 +97,26 @@ def _pattern_permute(self, basic_pattern, options, basic_result): # rotations if '4' in options: res = patterns[-1][1] - for i in range(4): - patterns.append( - (self._string_permute(patterns[-1][0], [6, 3, 0, - 7, 4, 1, - 8, 5, 2]), res)) + patterns.extend( + ( + self._string_permute( + patterns[-1][0], [6, 3, 0, 7, 4, 1, 8, 5, 2] + ), + res, + ) + for _ in range(4) + ) # mirror if 'M' in options: n = len(patterns) - for pattern, res in patterns[0:n]: - patterns.append( - (self._string_permute(pattern, [2, 1, 0, - 5, 4, 3, - 8, 7, 6]), res)) - + patterns.extend( + (self._string_permute(pattern, [2, 1, 0, 5, 4, 3, 8, 7, 6]), res) + for pattern, res in patterns[:n] + ) # negate if 'N' in options: n = len(patterns) - for pattern, res in patterns[0:n]: + for pattern, res in patterns[:n]: # Swap 0 and 1 pattern = (pattern .replace('0', 'Z') @@ -141,10 +140,10 @@ def build_lut(self): m = re.search( r'(\w*):?\s*\((.+?)\)\s*->\s*(\d)', p.replace('\n', '')) if not m: - raise Exception('Syntax error in pattern "'+p+'"') - options = m.group(1) - pattern = m.group(2) - result = int(m.group(3)) + raise Exception(f'Syntax error in pattern "{p}"') + options = m[1] + pattern = m[2] + result = int(m[3]) # Get rid of spaces pattern = pattern.replace(' ', '').replace('\n', '') diff --git a/serverless-lambda/vendored/PIL/ImageOps.py b/serverless-lambda/vendored/PIL/ImageOps.py index 25d491a..399aa2e 100644 --- a/serverless-lambda/vendored/PIL/ImageOps.py +++ b/serverless-lambda/vendored/PIL/ImageOps.py @@ -236,15 +236,13 @@ def equalize(image, mask=None): histo = [_f for _f in h[b:b+256] if _f] if len(histo) <= 1: lut.extend(list(range(256))) + elif step := (functools.reduce(operator.add, histo) - histo[-1]) // 255: + n = step // 2 + for i in range(256): + lut.append(n // step) + n = n + h[i+b] else: - step = (functools.reduce(operator.add, histo) - histo[-1]) // 255 - if not step: - lut.extend(list(range(256))) - else: - n = step // 2 - for i in range(256): - lut.append(n // step) - n = n + h[i+b] + lut.extend(list(range(256))) return _lut(image, lut) @@ -345,12 +343,9 @@ def fit(image, size, method=Image.NEAREST, bleed=0.0, centering=(0.5, 0.5)): # make the crop leftSide = int(liveArea[0] + (float(liveSize[0]-cropWidth) * centering[0])) - if leftSide < 0: - leftSide = 0 + leftSide = max(leftSide, 0) topSide = int(liveArea[1] + (float(liveSize[1]-cropHeight) * centering[1])) - if topSide < 0: - topSide = 0 - + topSide = max(topSide, 0) out = image.crop( (leftSide, topSide, leftSide + cropWidth, topSide + cropHeight) ) @@ -386,9 +381,7 @@ def invert(image): :param image: The image to invert. :return: An image. """ - lut = [] - for i in range(256): - lut.append(255-i) + lut = [255-i for i in range(256)] return _lut(image, lut) @@ -410,10 +403,8 @@ def posterize(image, bits): :param bits: The number of bits to keep for each channel (1-8). :return: An image. """ - lut = [] mask = ~(2**(8-bits)-1) - for i in range(256): - lut.append(i & mask) + lut = [i & mask for i in range(256)] return _lut(image, lut) diff --git a/serverless-lambda/vendored/PIL/ImagePalette.py b/serverless-lambda/vendored/PIL/ImagePalette.py index cecc645..f98d28c 100644 --- a/serverless-lambda/vendored/PIL/ImagePalette.py +++ b/serverless-lambda/vendored/PIL/ImagePalette.py @@ -41,8 +41,9 @@ def __init__(self, mode="RGB", palette=None, size=0): self.palette = palette or bytearray(range(256))*len(self.mode) self.colors = {} self.dirty = None - if ((size == 0 and len(self.mode)*256 != len(self.palette)) or - (size != 0 and size != len(self.palette))): + if ( + size == 0 and len(self.mode) * 256 != len(self.palette) + ) or size not in [0, len(self.palette)]: raise ValueError("wrong palette size") def copy(self): @@ -66,7 +67,7 @@ def getdata(self): """ if self.rawmode: return self.rawmode, self.palette - return self.mode + ";L", self.tobytes() + return f"{self.mode};L", self.tobytes() def tobytes(self): """Convert palette to bytes. @@ -78,9 +79,7 @@ def tobytes(self): if isinstance(self.palette, bytes): return self.palette arr = array.array("B", self.palette) - if hasattr(arr, 'tobytes'): - return arr.tobytes() - return arr.tostring() + return arr.tobytes() if hasattr(arr, 'tobytes') else arr.tostring() # Declare tostring as an alias for tobytes tostring = tobytes @@ -92,24 +91,23 @@ def getcolor(self, color): """ if self.rawmode: raise ValueError("palette contains raw palette data") - if isinstance(color, tuple): - try: - return self.colors[color] - except KeyError: - # allocate new color slot - if isinstance(self.palette, bytes): - self.palette = bytearray(self.palette) - index = len(self.colors) - if index >= 256: - raise ValueError("cannot allocate more than 256 colors") - self.colors[color] = index - self.palette[index] = color[0] - self.palette[index+256] = color[1] - self.palette[index+512] = color[2] - self.dirty = 1 - return index - else: + if not isinstance(color, tuple): raise ValueError("unknown color specifier: %r" % color) + try: + return self.colors[color] + except KeyError: + # allocate new color slot + if isinstance(self.palette, bytes): + self.palette = bytearray(self.palette) + index = len(self.colors) + if index >= 256: + raise ValueError("cannot allocate more than 256 colors") + self.colors[color] = index + self.palette[index] = color[0] + self.palette[index+256] = color[1] + self.palette[index+512] = color[2] + self.dirty = 1 + return index def save(self, fp): """Save palette to text file. @@ -148,20 +146,13 @@ def raw(rawmode, data): # Factories def make_linear_lut(black, white): - lut = [] - if black == 0: - for i in range(256): - lut.append(white*i//255) - else: + if black != 0: raise NotImplementedError # FIXME - return lut + return [white*i//255 for i in range(256)] def make_gamma_lut(exp): - lut = [] - for i in range(256): - lut.append(int(((i / 255.0) ** exp) * 255.0 + 0.5)) - return lut + return [int(((i / 255.0) ** exp) * 255.0 + 0.5) for i in range(256)] def negative(mode="RGB"): @@ -172,9 +163,7 @@ def negative(mode="RGB"): def random(mode="RGB"): from random import randint - palette = [] - for i in range(256*len(mode)): - palette.append(randint(0, 255)) + palette = [randint(0, 255) for _ in range(256*len(mode))] return ImagePalette(mode, palette) diff --git a/serverless-lambda/vendored/PIL/ImageQt.py b/serverless-lambda/vendored/PIL/ImageQt.py index 280cbc6..0f24f23 100644 --- a/serverless-lambda/vendored/PIL/ImageQt.py +++ b/serverless-lambda/vendored/PIL/ImageQt.py @@ -109,10 +109,11 @@ def align8to32(bytes, width, mode): if not extra_padding: return bytes - new_data = [] - for i in range(len(bytes) // bytes_per_line): - new_data.append(bytes[i*bytes_per_line:(i+1)*bytes_per_line] + b'\x00' * extra_padding) - + new_data = [ + bytes[i * bytes_per_line : (i + 1) * bytes_per_line] + + b'\x00' * extra_padding + for i in range(len(bytes) // bytes_per_line) + ] return b''.join(new_data) @@ -120,9 +121,7 @@ def _toqclass_helper(im): data = None colortable = None - # handle filename, if given instead of image name if hasattr(im, "toUtf8"): - # FIXME - is this really the best way to do this? if str is bytes: im = unicode(im.toUtf8(), "utf-8") else: @@ -134,15 +133,11 @@ def _toqclass_helper(im): format = QImage.Format_Mono elif im.mode == "L": format = QImage.Format_Indexed8 - colortable = [] - for i in range(256): - colortable.append(rgb(i, i, i)) + colortable = [rgb(i, i, i) for i in range(256)] elif im.mode == "P": format = QImage.Format_Indexed8 - colortable = [] palette = im.getpalette() - for i in range(0, len(palette), 3): - colortable.append(rgb(*palette[i:i+3])) + colortable = [rgb(*palette[i:i+3]) for i in range(0, len(palette), 3)] elif im.mode == "RGB": data = im.tobytes("raw", "BGRX") format = QImage.Format_RGB32 diff --git a/serverless-lambda/vendored/PIL/ImageShow.py b/serverless-lambda/vendored/PIL/ImageShow.py index b50d613..aac4fda 100644 --- a/serverless-lambda/vendored/PIL/ImageShow.py +++ b/serverless-lambda/vendored/PIL/ImageShow.py @@ -47,10 +47,14 @@ def show(image, title=None, **options): :param \**options: Additional viewer options. :returns: True if a suitable viewer was found, false otherwise. """ - for viewer in _viewers: - if viewer.show(image, title=title, **options): - return 1 - return 0 + return next( + ( + 1 + for viewer in _viewers + if viewer.show(image, title=title, **options) + ), + 0, + ) class Viewer(object): @@ -61,14 +65,7 @@ class Viewer(object): def show(self, image, **options): # save temporary image to disk - if image.mode[:4] == "I;16": - # @PIL88 @PIL101 - # "I;16" isn't an 'official' mode, but we still want to - # provide a simple way to show 16-bit images. - base = "L" - # FIXME: auto-contrast if max() > 255? - else: - base = Image.getmodebase(image.mode) + base = "L" if image.mode[:4] == "I;16" else Image.getmodebase(image.mode) if base != image.mode and image.mode != "1" and image.mode != "RGBA": image = image.convert(base) @@ -124,9 +121,7 @@ def get_command(self, file, **options): # on darwin open returns immediately resulting in the temp # file removal while app is opening command = "open -a /Applications/Preview.app" - command = "(%s %s; sleep 20; rm -f %s)&" % (command, quote(file), - quote(file)) - return command + return f"({command} {quote(file)}; sleep 20; rm -f {quote(file)})&" register(MacViewer) @@ -150,8 +145,7 @@ class UnixViewer(Viewer): def show_file(self, file, **options): command, executable = self.get_command_ex(file, **options) - command = "(%s %s; rm -f %s)&" % (command, quote(file), - quote(file)) + command = f"({command} {quote(file)}; rm -f {quote(file)})&" os.system(command) return 1 @@ -179,7 +173,7 @@ def get_command_ex(self, file, title=None, **options): # imagemagick's display command instead. command = executable = "xv" if title: - command += " -name %s" % quote(title) + command += f" -name {quote(title)}" return command, executable if which("xv"): diff --git a/serverless-lambda/vendored/PIL/ImageStat.py b/serverless-lambda/vendored/PIL/ImageStat.py index cd58fc8..72b5d50 100644 --- a/serverless-lambda/vendored/PIL/ImageStat.py +++ b/serverless-lambda/vendored/PIL/ImageStat.py @@ -30,10 +30,7 @@ class Stat(object): def __init__(self, image_or_list, mask=None): try: - if mask: - self.h = image_or_list.histogram(mask) - else: - self.h = image_or_list.histogram() + self.h = image_or_list.histogram(mask) if mask else image_or_list.histogram() except AttributeError: self.h = image_or_list # assume it to be a histogram list if not isinstance(self.h, list): @@ -45,7 +42,7 @@ def __getattr__(self, id): if id[:4] == "_get": raise AttributeError(id) # calculate missing attribute - v = getattr(self, "_get" + id)() + v = getattr(self, f"_get{id}")() setattr(self, id, v) return v @@ -69,10 +66,10 @@ def minmax(histogram): def _getcount(self): "Get total number of pixels in each layer" - v = [] - for i in range(0, len(self.h), 256): - v.append(functools.reduce(operator.add, self.h[i:i+256])) - return v + return [ + functools.reduce(operator.add, self.h[i : i + 256]) + for i in range(0, len(self.h), 256) + ] def _getsum(self): "Get sum of all pixels in each layer" @@ -99,10 +96,7 @@ def _getsum2(self): def _getmean(self): "Get average pixel level for each layer" - v = [] - for i in self.bands: - v.append(self.sum[i] / self.count[i]) - return v + return [self.sum[i] / self.count[i] for i in self.bands] def _getmedian(self): "Get median pixel level for each layer" @@ -122,10 +116,7 @@ def _getmedian(self): def _getrms(self): "Get RMS for each layer" - v = [] - for i in self.bands: - v.append(math.sqrt(self.sum2[i] / self.count[i])) - return v + return [math.sqrt(self.sum2[i] / self.count[i]) for i in self.bands] def _getvar(self): "Get variance for each layer" @@ -139,10 +130,7 @@ def _getvar(self): def _getstddev(self): "Get standard deviation for each layer" - v = [] - for i in self.bands: - v.append(math.sqrt(self.var[i])) - return v + return [math.sqrt(self.var[i]) for i in self.bands] Global = Stat # compatibility diff --git a/serverless-lambda/vendored/PIL/ImageWin.py b/serverless-lambda/vendored/PIL/ImageWin.py index d8398e9..fb47546 100644 --- a/serverless-lambda/vendored/PIL/ImageWin.py +++ b/serverless-lambda/vendored/PIL/ImageWin.py @@ -192,7 +192,7 @@ def __init__(self, title="PIL", width=None, height=None): ) def __dispatcher(self, action, *args): - return getattr(self, "ui_handle_" + action)(*args) + return getattr(self, f"ui_handle_{action}")(*args) def ui_handle_clear(self, dc, x0, y0, x1, y1): pass diff --git a/serverless-lambda/vendored/PIL/IptcImagePlugin.py b/serverless-lambda/vendored/PIL/IptcImagePlugin.py index f5a8de1..dada82f 100644 --- a/serverless-lambda/vendored/PIL/IptcImagePlugin.py +++ b/serverless-lambda/vendored/PIL/IptcImagePlugin.py @@ -91,10 +91,7 @@ def _open(self): tag, size = self.field() if not tag or tag == (8, 10): break - if size: - tagdata = self.fp.read(size) - else: - tagdata = None + tagdata = self.fp.read(size) if size else None if tag in self.info: if isinstance(self.info[tag], list): self.info[tag].append(tagdata) @@ -103,15 +100,12 @@ def _open(self): else: self.info[tag] = tagdata - # print(tag, self.info[tag]) + # print(tag, self.info[tag]) # mode layers = i8(self.info[(3, 60)][0]) component = i8(self.info[(3, 60)][1]) - if (3, 65) in self.info: - id = i8(self.info[(3, 65)][0])-1 - else: - id = 0 + id = i8(self.info[(3, 65)][0])-1 if (3, 65) in self.info else 0 if layers == 1 and not component: self.mode = "L" elif layers == 3 and component: @@ -222,7 +216,7 @@ def getiptcinfo(im): # 0x0404 contains IPTC/NAA data data = app[offset:offset+size] break - offset = offset + size + offset += size if offset & 1: offset += 1 except (AttributeError, KeyError): @@ -239,7 +233,6 @@ def getiptcinfo(im): if data is None: return None # no properties - # create an IptcImagePlugin object without initializing it class FakeImage(object): pass im = FakeImage() diff --git a/serverless-lambda/vendored/PIL/Jpeg2KImagePlugin.py b/serverless-lambda/vendored/PIL/Jpeg2KImagePlugin.py index 7ab183a..5de1f77 100644 --- a/serverless-lambda/vendored/PIL/Jpeg2KImagePlugin.py +++ b/serverless-lambda/vendored/PIL/Jpeg2KImagePlugin.py @@ -39,10 +39,7 @@ def _parse_codestream(fp): size = (xsiz - xosiz, ysiz - yosiz) if csiz == 1: - if (yrsiz[0] & 0x7f) > 8: - mode = 'I;16' - else: - mode = 'L' + mode = 'I;16' if (yrsiz[0] & 0x7f) > 8 else 'L' elif csiz == 2: mode = 'LA' elif csiz == 3: @@ -163,12 +160,11 @@ def _open(self): else: sig = sig + self.fp.read(8) - if sig == b'\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a': - self.codec = "jp2" - self.size, self.mode = _parse_jp2_header(self.fp) - else: + if sig != b'\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a': raise SyntaxError('not a JPEG 2000 file') + self.codec = "jp2" + self.size, self.mode = _parse_jp2_header(self.fp) if self.size is None or self.mode is None: raise SyntaxError('unable to determine size/mode') @@ -219,11 +215,7 @@ def _accept(prefix): # Save support def _save(im, fp, filename): - if filename.endswith('.j2k'): - kind = 'j2k' - else: - kind = 'jp2' - + kind = 'j2k' if filename.endswith('.j2k') else 'jp2' # Get the keyword arguments info = im.encoderinfo diff --git a/serverless-lambda/vendored/PIL/JpegImagePlugin.py b/serverless-lambda/vendored/PIL/JpegImagePlugin.py index 6a18fff..3ef2daf 100644 --- a/serverless-lambda/vendored/PIL/JpegImagePlugin.py +++ b/serverless-lambda/vendored/PIL/JpegImagePlugin.py @@ -181,9 +181,7 @@ def SOF(self, marker): # fixup icc profile self.icclist.sort() # sort by sequence number if i8(self.icclist[0][13]) == len(self.icclist): - profile = [] - for p in self.icclist: - profile.append(p[14:]) + profile = [p[14:] for p in self.icclist] icc_profile = b"".join(profile) else: icc_profile = None # wrong number of fragments @@ -290,7 +288,7 @@ def DQT(self, marker): def _accept(prefix): - return prefix[0:1] == b"\377" + return prefix[:1] == b"\377" ## @@ -345,7 +343,7 @@ def _open(self): # self.__offset = self.fp.tell() break s = self.fp.read(1) - elif i == 0 or i == 0xFFFF: + elif i in [0, 0xFFFF]: # padded marker or junk; move on s = b"\xff" elif i == 0xFF00: # Skip extraneous data (escaped 0xFF) @@ -361,12 +359,7 @@ def load_read(self, read_bytes): """ s = self.fp.read(read_bytes) - if not s and ImageFile.LOAD_TRUNCATED_IMAGES: - # Premature EOF. - # Pretend file is finished adding EOI marker - return b"\xFF\xD9" - - return s + return b"\xFF\xD9" if not s and ImageFile.LOAD_TRUNCATED_IMAGES else s def draft(self, mode, size): @@ -476,7 +469,7 @@ def _getexif(self): else: info = TiffImagePlugin.ImageFileDirectory_v1(head) info.load(file) - exif.update(_fixup_dict(info)) + exif |= _fixup_dict(info) # get gpsinfo extension try: # exif field 0x8825 is an offset pointer to the location @@ -525,7 +518,8 @@ def _getmp(self): rawmpentries = mp[0xB002] for entrynum in range(0, quant): unpackedentry = struct.unpack_from( - '{}LLLHH'.format(endianness), rawmpentries, entrynum * 16) + f'{endianness}LLLHH', rawmpentries, entrynum * 16 + ) labels = ('Attribute', 'Size', 'DataOffset', 'EntryNo1', 'EntryNo2') mpentry = dict(zip(labels, unpackedentry)) @@ -619,7 +613,7 @@ def _save(im, fp, filename): try: rawmode = RAWMODE[im.mode] except KeyError: - raise IOError("cannot write mode %s as JPEG" % im.mode) + raise IOError(f"cannot write mode {im.mode} as JPEG") info = im.encoderinfo diff --git a/serverless-lambda/vendored/PIL/MicImagePlugin.py b/serverless-lambda/vendored/PIL/MicImagePlugin.py index 1dbb6a5..314e7dc 100644 --- a/serverless-lambda/vendored/PIL/MicImagePlugin.py +++ b/serverless-lambda/vendored/PIL/MicImagePlugin.py @@ -55,10 +55,11 @@ def _open(self): # best way to identify MIC files, but what the... ;-) self.images = [] - for path in self.ole.listdir(): - if path[1:] and path[0][-4:] == ".ACI" and path[1] == "Image": - self.images.append(path) - + self.images.extend( + path + for path in self.ole.listdir() + if path[1:] and path[0][-4:] == ".ACI" and path[1] == "Image" + ) # if we didn't find any images, this is probably not # an MIC file. if not self.images: diff --git a/serverless-lambda/vendored/PIL/MspImagePlugin.py b/serverless-lambda/vendored/PIL/MspImagePlugin.py index 5ea3c1c..387bfe9 100644 --- a/serverless-lambda/vendored/PIL/MspImagePlugin.py +++ b/serverless-lambda/vendored/PIL/MspImagePlugin.py @@ -159,7 +159,7 @@ def decode(self, buffer): def _save(im, fp, filename): if im.mode != "1": - raise IOError("cannot write mode %s as MSP" % im.mode) + raise IOError(f"cannot write mode {im.mode} as MSP") # create MSP header header = [0] * 16 diff --git a/serverless-lambda/vendored/PIL/PSDraw.py b/serverless-lambda/vendored/PIL/PSDraw.py index de34713..1262cba 100644 --- a/serverless-lambda/vendored/PIL/PSDraw.py +++ b/serverless-lambda/vendored/PIL/PSDraw.py @@ -114,10 +114,7 @@ def image(self, box, im, dpi=None): """Draw a PIL image, centered in the given box.""" # default resolution depends on mode if not dpi: - if im.mode == "1": - dpi = 200 # fax - else: - dpi = 100 # greyscale + dpi = 200 if im.mode == "1" else 100 # image size (on paper) x = float(im.size[0] * 72) / dpi y = float(im.size[1] * 72) / dpi diff --git a/serverless-lambda/vendored/PIL/PaletteFile.py b/serverless-lambda/vendored/PIL/PaletteFile.py index 9ed69d6..d1dbc6a 100644 --- a/serverless-lambda/vendored/PIL/PaletteFile.py +++ b/serverless-lambda/vendored/PIL/PaletteFile.py @@ -33,7 +33,7 @@ def __init__(self, fp): if not s: break - if s[0:1] == b"#": + if s[:1] == b"#": continue if len(s) > 100: raise SyntaxError("bad palette file") diff --git a/serverless-lambda/vendored/PIL/PalmImagePlugin.py b/serverless-lambda/vendored/PIL/PalmImagePlugin.py index 7d7b165..b1ed298 100644 --- a/serverless-lambda/vendored/PIL/PalmImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PalmImagePlugin.py @@ -140,7 +140,7 @@ def _save(im, fp, filename): lambda x, shift=8-bpp, maxval=(1 << bpp)-1: maxval - (x >> shift)) # we ignore the palette here im.mode = "P" - rawmode = "P;" + str(bpp) + rawmode = f"P;{str(bpp)}" version = 1 elif im.mode == "L" and "bpp" in im.info and im.info["bpp"] in (1, 2, 4): @@ -152,7 +152,7 @@ def _save(im, fp, filename): im = im.point(lambda x, maxval=(1 << bpp)-1: maxval - (x & maxval)) # we ignore the palette here im.mode = "P" - rawmode = "P;" + str(bpp) + rawmode = f"P;{str(bpp)}" version = 1 elif im.mode == "1": @@ -164,7 +164,7 @@ def _save(im, fp, filename): else: - raise IOError("cannot write mode %s as Palm" % im.mode) + raise IOError(f"cannot write mode {im.mode} as Palm") # # make sure image data is available @@ -181,7 +181,7 @@ def _save(im, fp, filename): flags = 0 if im.mode == "P" and "custom-colormap" in im.info: - flags = flags & _FLAGS["custom-colormap"] + flags &= _FLAGS["custom-colormap"] colormapsize = 4 * 256 + 2 colormapmode = im.palette.mode colormap = im.getdata().getpalette() diff --git a/serverless-lambda/vendored/PIL/PcfFontFile.py b/serverless-lambda/vendored/PIL/PcfFontFile.py index eba85fe..8aaeb6d 100644 --- a/serverless-lambda/vendored/PIL/PcfFontFile.py +++ b/serverless-lambda/vendored/PIL/PcfFontFile.py @@ -63,7 +63,7 @@ def __init__(self, fp): count = l32(fp.read(4)) self.toc = {} - for i in range(count): + for _ in range(count): type = l32(fp.read(4)) self.toc[type] = l32(fp.read(4)), l32(fp.read(4)), l32(fp.read(4)) @@ -94,11 +94,7 @@ def _getformat(self, tag): format = l32(fp.read(4)) - if format & 4: - i16, i32 = b16, b32 - else: - i16, i32 = l16, l32 - + i16, i32 = (b16, b32) if format & 4 else (l16, l32) return fp, format, i16, i32 def _load_properties(self): @@ -112,10 +108,7 @@ def _load_properties(self): nprops = i32(fp.read(4)) - # read property description - p = [] - for i in range(nprops): - p.append((i32(fp.read(4)), i8(fp.read(1)), i32(fp.read(4)))) + p = [(i32(fp.read(4)), i8(fp.read(1)), i32(fp.read(4))) for _ in range(nprops)] if nprops & 3: fp.seek(4 - (nprops & 3), 1) # pad @@ -143,7 +136,7 @@ def _load_metrics(self): if (format & 0xff00) == 0x100: # "compressed" metrics - for i in range(i16(fp.read(2))): + for _ in range(i16(fp.read(2))): left = i8(fp.read(1)) - 128 right = i8(fp.read(1)) - 128 width = i8(fp.read(1)) - 128 @@ -159,7 +152,7 @@ def _load_metrics(self): else: # "jumbo" metrics - for i in range(i32(fp.read(4))): + for _ in range(i32(fp.read(4))): left = i16(fp.read(2)) right = i16(fp.read(2)) width = i16(fp.read(2)) @@ -189,14 +182,8 @@ def _load_bitmaps(self, metrics): if nbitmaps != len(metrics): raise IOError("Wrong number of bitmaps") - offsets = [] - for i in range(nbitmaps): - offsets.append(i32(fp.read(4))) - - bitmapSizes = [] - for i in range(4): - bitmapSizes.append(i32(fp.read(4))) - + offsets = [i32(fp.read(4)) for _ in range(nbitmaps)] + bitmapSizes = [i32(fp.read(4)) for _ in range(4)] # byteorder = format & 4 # non-zero => MSB bitorder = format & 8 # non-zero => MSB padindex = format & 3 @@ -207,10 +194,7 @@ def _load_bitmaps(self, metrics): data = fp.read(bitmapsize) pad = BYTES_PER_ROW[padindex] - mode = "1;R" - if bitorder: - mode = "1" - + mode = "1" if bitorder else "1;R" for i in range(nbitmaps): x, y, l, r, w, a, d, f = metrics[i] b, e = offsets[i], offsets[i+1] diff --git a/serverless-lambda/vendored/PIL/PcxImagePlugin.py b/serverless-lambda/vendored/PIL/PcxImagePlugin.py index 564713a..7b25036 100644 --- a/serverless-lambda/vendored/PIL/PcxImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PcxImagePlugin.py @@ -125,7 +125,7 @@ def _save(im, fp, filename): try: version, bits, planes, rawmode = SAVE[im.mode] except KeyError: - raise ValueError("Cannot save %s images as PCX" % im.mode) + raise ValueError(f"Cannot save {im.mode} images as PCX") # bytes per plane stride = (im.size[0] * bits + 7) // 8 diff --git a/serverless-lambda/vendored/PIL/PdfImagePlugin.py b/serverless-lambda/vendored/PIL/PdfImagePlugin.py index e8e0c4f..3e5f326 100644 --- a/serverless-lambda/vendored/PIL/PdfImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PdfImagePlugin.py @@ -78,7 +78,7 @@ def _save(im, fp, filename, save_all=False): existing_pdf.start_writing() existing_pdf.write_header() - existing_pdf.write_comment("created by PIL PDF driver " + __version__) + existing_pdf.write_comment(f"created by PIL PDF driver {__version__}") # # pages @@ -101,7 +101,7 @@ def _save(im, fp, filename, save_all=False): # Image format does not have n_frames. It is a single frame image pass numberOfPages += im_numberOfPages - for i in range(im_numberOfPages): + for _ in range(im_numberOfPages): image_refs.append(existing_pdf.next_object_id(0)) page_refs.append(existing_pdf.next_object_id(0)) contents_refs.append(existing_pdf.next_object_id(0)) @@ -126,6 +126,10 @@ def _save(im, fp, filename, save_all=False): colorspace = PdfParser.PdfName("DeviceGray") procset = "ImageB" # grayscale bits = 1 + elif im.mode == "CMYK": + filter = "DCTDecode" + colorspace = PdfParser.PdfName("DeviceCMYK") + procset = "ImageC" # color images elif im.mode == "L": filter = "DCTDecode" # params = "<< /Predictor 15 /Columns %d >>" % (width-2) @@ -140,12 +144,8 @@ def _save(im, fp, filename, save_all=False): filter = "DCTDecode" colorspace = PdfParser.PdfName("DeviceRGB") procset = "ImageC" # color images - elif im.mode == "CMYK": - filter = "DCTDecode" - colorspace = PdfParser.PdfName("DeviceCMYK") - procset = "ImageC" # color images else: - raise ValueError("cannot save mode %s" % im.mode) + raise ValueError(f"cannot save mode {im.mode}") # # image @@ -167,7 +167,7 @@ def _save(im, fp, filename, save_all=False): elif filter == "RunLengthDecode": ImageFile._save(im, op, [("packbits", (0, 0)+im.size, 0, im.mode)]) else: - raise ValueError("unsupported PDF filter (%s)" % filter) + raise ValueError(f"unsupported PDF filter ({filter})") # # Get image characteristics diff --git a/serverless-lambda/vendored/PIL/PdfParser.py b/serverless-lambda/vendored/PIL/PdfParser.py index b6938fd..54595e7 100644 --- a/serverless-lambda/vendored/PIL/PdfParser.py +++ b/serverless-lambda/vendored/PIL/PdfParser.py @@ -142,7 +142,9 @@ def __delitem__(self, key): elif key in self.deleted_entries: generation = self.deleted_entries[key] else: - raise IndexError("object ID " + str(key) + " cannot be deleted because it doesn't exist") + raise IndexError( + f"object ID {str(key)} cannot be deleted because it doesn't exist" + ) def __contains__(self, key): return key in self.existing_entries or key in self.new_entries @@ -177,7 +179,10 @@ def write(self, f): f.write(make_bytes("%010d %05d n \n" % self.new_entries[object_id])) else: this_deleted_object_id = deleted_keys.pop(0) - check_format_condition(object_id == this_deleted_object_id, "expected the next deleted object ID to be %s, instead found %s" % (object_id, this_deleted_object_id)) + check_format_condition( + object_id == this_deleted_object_id, + f"expected the next deleted object ID to be {object_id}, instead found {this_deleted_object_id}", + ) try: next_in_linked_list = deleted_keys[0] except IndexError: @@ -205,29 +210,28 @@ def __hash__(self): return hash(self.name) def __repr__(self): - return "PdfName(%s)" % repr(self.name) + return f"PdfName({repr(self.name)})" @classmethod - def from_pdf_stream(klass, data): - return klass(PdfParser.interpret_name(data)) + def from_pdf_stream(cls, data): + return cls(PdfParser.interpret_name(data)) allowed_chars = set(range(33,127)) - set(ord(c) for c in "#%/()<>[]{}") def __bytes__(self): - if str == bytes: # Python 2.x - result = bytearray(b"/") - for b in self.name: - if ord(b) in self.allowed_chars: - result.append(b) - else: - result.extend(b"#%02X" % ord(b)) - else: # Python 3.x - result = bytearray(b"/") - for b in self.name: - if b in self.allowed_chars: - result.append(b) - else: - result.extend(make_bytes("#%02X" % b)) + result = bytearray(b"/") + for b in self.name: + if ( + str == bytes + and ord(b) in self.allowed_chars + or str != bytes + and b in self.allowed_chars + ): + result.append(b) + elif str == bytes: + result.extend(b"#%02X" % ord(b)) + else: + result.extend(make_bytes("#%02X" % b)) return bytes(result) __str__ = __bytes__ @@ -263,10 +267,7 @@ def __getattr__(self, key): value = self[key.encode("us-ascii")] except KeyError: raise AttributeError(key) - if isinstance(value, bytes): - return decode_text(value) - else: - return value + return decode_text(value) if isinstance(value, bytes) else value def __bytes__(self): out = bytearray(b"<<") @@ -291,11 +292,11 @@ def __init__(self, data): if str == bytes: # Python 2.x def __str__(self): - return "<%s>" % "".join("%02X" % ord(b) for b in self.data) + return f'<{"".join("%02X" % ord(b) for b in self.data)}>' else: # Python 3.x def __bytes__(self): - return make_bytes("<%s>" % "".join("%02X" % b for b in self.data)) + return make_bytes(f'<{"".join("%02X" % b for b in self.data)}>') class PdfStream: @@ -308,14 +309,15 @@ def decode(self): filter = self.dictionary.Filter except AttributeError: return self.buf - if filter == b"FlateDecode": - try: - expected_length = self.dictionary.DL - except AttributeError: - expected_length = self.dictionary.Length - return zlib.decompress(self.buf, bufsize=int(expected_length)) - else: - raise NotImplementedError("stream filter %s unknown/unsupported" % repr(self.dictionary.Filter)) + if filter != b"FlateDecode": + raise NotImplementedError( + f"stream filter {repr(self.dictionary.Filter)} unknown/unsupported" + ) + try: + expected_length = self.dictionary.DL + except AttributeError: + expected_length = self.dictionary.Length + return zlib.decompress(self.buf, bufsize=int(expected_length)) def pdf_repr(x): @@ -325,7 +327,7 @@ def pdf_repr(x): return b"false" elif x is None: return b"null" - elif isinstance(x, PdfName) or isinstance(x, PdfDict) or isinstance(x, PdfArray) or isinstance(x, PdfBinary): + elif isinstance(x, (PdfName, PdfDict, PdfArray, PdfBinary)): return bytes(x) elif isinstance(x, int): return str(x).encode("us-ascii") @@ -441,11 +443,9 @@ def rewrite_pages(self): if page_ref not in self.pages: # the page has been deleted continue - # make dict keys into strings for passing to write_page - stringified_page_info = {} - for key, value in page_info.items(): - # key should be a PdfName - stringified_page_info[key.name_as_str()] = value + stringified_page_info = { + key.name_as_str(): value for key, value in page_info.items() + } stringified_page_info["Parent"] = self.pages_ref new_page_ref = self.write_page(None, **stringified_page_info) for j, cur_page_ref in enumerate(self.pages): @@ -571,8 +571,7 @@ def next_object_id(self, offset=None): def read_trailer(self): search_start_offset = len(self.buf) - 16384 - if search_start_offset < self.start_offset: - search_start_offset = self.start_offset + search_start_offset = max(search_start_offset, self.start_offset) m = self.re_trailer_end.search(self.buf, search_start_offset) check_format_condition(m, "trailer end not found") # make sure we found the LAST trailer @@ -606,17 +605,20 @@ def read_prev_trailer(self, xref_section_offset): re_dict_end = re.compile(whitespace_optional + br"\>\>" + whitespace_optional) @classmethod - def interpret_trailer(klass, trailer_data): + def interpret_trailer(cls, trailer_data): trailer = {} offset = 0 while True: - m = klass.re_name.match(trailer_data, offset) + m = cls.re_name.match(trailer_data, offset) if not m: - m = klass.re_dict_end.match(trailer_data, offset) - check_format_condition(m and m.end() == len(trailer_data), "name not found in trailer, remaining data: " + repr(trailer_data[offset:])) + m = cls.re_dict_end.match(trailer_data, offset) + check_format_condition( + m and m.end() == len(trailer_data), + f"name not found in trailer, remaining data: {repr(trailer_data[offset:])}", + ) break - key = klass.interpret_name(m.group(1)) - value, offset = klass.get_value(trailer_data, m.end()) + key = cls.interpret_name(m.group(1)) + value, offset = cls.get_value(trailer_data, m.end()) trailer[key] = value check_format_condition(b"Size" in trailer and isinstance(trailer[b"Size"], int), "/Size not in trailer or not an integer") check_format_condition(b"Root" in trailer and isinstance(trailer[b"Root"], IndirectReference), "/Root not in trailer or not an indirect reference") @@ -625,17 +627,14 @@ def interpret_trailer(klass, trailer_data): re_hashes_in_name = re.compile(br"([^#]*)(#([0-9a-fA-F]{2}))?") @classmethod - def interpret_name(klass, raw, as_text=False): + def interpret_name(cls, raw, as_text=False): name = b"" - for m in klass.re_hashes_in_name.finditer(raw): + for m in cls.re_hashes_in_name.finditer(raw): if m.group(3): name += m.group(1) + bytearray.fromhex(m.group(3).decode("us-ascii")) else: name += m.group(1) - if as_text: - return name.decode("utf-8") - else: - return bytes(name) + return name.decode("utf-8") if as_text else bytes(name) re_null = re.compile(whitespace_optional + br"null(?=" + delimiter_or_ws + br")") re_true = re.compile(whitespace_optional + br"true(?=" + delimiter_or_ws + br")") @@ -654,100 +653,86 @@ def interpret_name(klass, raw, as_text=False): re_stream_end = re.compile(whitespace_optional + br"endstream(?=" + delimiter_or_ws + br")") @classmethod - def get_value(klass, data, offset, expect_indirect=None, max_nesting=-1): + def get_value(cls, data, offset, expect_indirect=None, max_nesting=-1): if max_nesting == 0: return None, None - m = klass.re_comment.match(data, offset) - if m: + if m := cls.re_comment.match(data, offset): offset = m.end() - m = klass.re_indirect_def_start.match(data, offset) - if m: + if m := cls.re_indirect_def_start.match(data, offset): check_format_condition(int(m.group(1)) > 0, "indirect object definition: object ID must be greater than 0") check_format_condition(int(m.group(2)) >= 0, "indirect object definition: generation must be non-negative") check_format_condition(expect_indirect is None or expect_indirect == IndirectReference(int(m.group(1)), int(m.group(2))), "indirect object definition different than expected") - object, offset = klass.get_value(data, m.end(), max_nesting=max_nesting-1) + object, offset = cls.get_value(data, m.end(), max_nesting=max_nesting-1) if offset is None: return object, None - m = klass.re_indirect_def_end.match(data, offset) + m = cls.re_indirect_def_end.match(data, offset) check_format_condition(m, "indirect object definition end not found") return object, m.end() check_format_condition(not expect_indirect, "indirect object definition not found") - m = klass.re_indirect_reference.match(data, offset) - if m: + if m := cls.re_indirect_reference.match(data, offset): check_format_condition(int(m.group(1)) > 0, "indirect object reference: object ID must be greater than 0") check_format_condition(int(m.group(2)) >= 0, "indirect object reference: generation must be non-negative") return IndirectReference(int(m.group(1)), int(m.group(2))), m.end() - m = klass.re_dict_start.match(data, offset) - if m: + if m := cls.re_dict_start.match(data, offset): offset = m.end() result = {} - m = klass.re_dict_end.match(data, offset) + m = cls.re_dict_end.match(data, offset) while not m: - key, offset = klass.get_value(data, offset, max_nesting=max_nesting-1) + key, offset = cls.get_value(data, offset, max_nesting=max_nesting-1) if offset is None: return result, None - value, offset = klass.get_value(data, offset, max_nesting=max_nesting-1) + value, offset = cls.get_value(data, offset, max_nesting=max_nesting-1) result[key] = value if offset is None: return result, None - m = klass.re_dict_end.match(data, offset) + m = cls.re_dict_end.match(data, offset) offset = m.end() - m = klass.re_stream_start.match(data, offset) - if m: + if m := cls.re_stream_start.match(data, offset): try: stream_len = int(result[b"Length"]) except (TypeError, KeyError, ValueError): raise PdfFormatError("bad or missing Length in stream dict (%r)" % result.get(b"Length", None)) stream_data = data[m.end():m.end() + stream_len] - m = klass.re_stream_end.match(data, m.end() + stream_len) + m = cls.re_stream_end.match(data, m.end() + stream_len) check_format_condition(m, "stream end not found") offset = m.end() result = PdfStream(PdfDict(result), stream_data) else: result = PdfDict(result) return result, offset - m = klass.re_array_start.match(data, offset) - if m: + if m := cls.re_array_start.match(data, offset): offset = m.end() result = [] - m = klass.re_array_end.match(data, offset) + m = cls.re_array_end.match(data, offset) while not m: - value, offset = klass.get_value(data, offset, max_nesting=max_nesting-1) + value, offset = cls.get_value(data, offset, max_nesting=max_nesting-1) result.append(value) if offset is None: return result, None - m = klass.re_array_end.match(data, offset) + m = cls.re_array_end.match(data, offset) return result, m.end() - m = klass.re_null.match(data, offset) - if m: + if m := cls.re_null.match(data, offset): return None, m.end() - m = klass.re_true.match(data, offset) - if m: + if m := cls.re_true.match(data, offset): return True, m.end() - m = klass.re_false.match(data, offset) - if m: + if m := cls.re_false.match(data, offset): return False, m.end() - m = klass.re_name.match(data, offset) - if m: - return PdfName(klass.interpret_name(m.group(1))), m.end() - m = klass.re_int.match(data, offset) - if m: + if m := cls.re_name.match(data, offset): + return PdfName(cls.interpret_name(m.group(1))), m.end() + if m := cls.re_int.match(data, offset): return int(m.group(1)), m.end() - m = klass.re_real.match(data, offset) - if m: + if m := cls.re_real.match(data, offset): return float(m.group(1)), m.end() # XXX Decimal instead of float??? - m = klass.re_string_hex.match(data, offset) - if m: + if m := cls.re_string_hex.match(data, offset): hex_string = bytearray([b for b in m.group(1) if b in b"0123456789abcdefABCDEF"]) # filter out whitespace if len(hex_string) % 2 == 1: hex_string.append(ord(b"0")) # append a 0 if the length is not even - yes, at the end return bytearray.fromhex(hex_string.decode("us-ascii")), m.end() - m = klass.re_string_lit.match(data, offset) - if m: - return klass.get_literal_string(data, m.end()) + if m := cls.re_string_lit.match(data, offset): + return cls.get_literal_string(data, m.end()) #return None, offset # fallback (only for debugging) - raise PdfFormatError("unrecognized object: " + repr(data[offset:offset+32])) + raise PdfFormatError(f"unrecognized object: {repr(data[offset:offset + 32])}") re_lit_str_token = re.compile(br"(\\[nrtbf()\\])|(\\[0-9]{1,3})|(\\(\r\n|\r|\n))|(\r\n|\r|\n)|(\()|(\))") escaped_chars = { @@ -770,13 +755,13 @@ def get_value(klass, data, offset, expect_indirect=None, max_nesting=-1): } @classmethod - def get_literal_string(klass, data, offset): + def get_literal_string(cls, data, offset): nesting_depth = 0 result = bytearray() - for m in klass.re_lit_str_token.finditer(data, offset): + for m in cls.re_lit_str_token.finditer(data, offset): result.extend(data[offset:m.start()]) if m.group(1): - result.extend(klass.escaped_chars[m.group(1)[1]]) + result.extend(cls.escaped_chars[m.group(1)[1]]) elif m.group(2): result.append(int(m.group(2)[1:], 8)) elif m.group(3): @@ -817,8 +802,8 @@ def read_xref_table(self, xref_section_offset): check_format_condition(m, "xref entry not found") offset = m.end() is_free = m.group(3) == b"f" - generation = int(m.group(2)) if not is_free: + generation = int(m.group(2)) new_entry = (int(m.group(1)), generation) check_format_condition(i not in self.xref_table or self.xref_table[i] == new_entry, "xref entry duplicated (and not identical)") self.xref_table[i] = new_entry @@ -826,8 +811,10 @@ def read_xref_table(self, xref_section_offset): def read_indirect(self, ref, max_nesting=-1): offset, generation = self.xref_table[ref[0]] - check_format_condition(generation == ref[1], "expected to find generation %s for object ID %s in xref table, instead found generation %s at offset %s" \ - % (ref[1], ref[0], generation, offset)) + check_format_condition( + generation == ref[1], + f"expected to find generation {ref[1]} for object ID {ref[0]} in xref table, instead found generation {generation} at offset {offset}", + ) value = self.get_value(self.buf, offset + self.start_offset, expect_indirect=IndirectReference(*ref), max_nesting=max_nesting)[0] self.cached_objects[ref] = value return value diff --git a/serverless-lambda/vendored/PIL/PngImagePlugin.py b/serverless-lambda/vendored/PIL/PngImagePlugin.py index 621e19b..764adb7 100644 --- a/serverless-lambda/vendored/PIL/PngImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PngImagePlugin.py @@ -115,7 +115,7 @@ def read(self): if not is_cid(cid): if not ImageFile.LOAD_TRUNCATED_IMAGES: - raise SyntaxError("broken PNG file (chunk %s)" % repr(cid)) + raise SyntaxError(f"broken PNG file (chunk {repr(cid)})") return cid, pos, length @@ -300,8 +300,9 @@ def __init__(self, fp): def check_text_memory(self, chunklen): self.text_memory += chunklen if self.text_memory > MAX_TEXT_MEMORY: - raise ValueError("Too much memory used in text chunks: %s>MAX_TEXT_MEMORY" % - self.text_memory) + raise ValueError( + f"Too much memory used in text chunks: {self.text_memory}>MAX_TEXT_MEMORY" + ) def chunk_iCCP(self, pos, length): @@ -317,8 +318,7 @@ def chunk_iCCP(self, pos, length): logger.debug("Compression method %s", i8(s[i])) comp_method = i8(s[i]) if comp_method != 0: - raise SyntaxError("Unknown compression method %s in iCCP chunk" % - comp_method) + raise SyntaxError(f"Unknown compression method {comp_method} in iCCP chunk") try: icc_profile = _safe_zlib_decompress(s[i+2:]) except ValueError: @@ -419,11 +419,11 @@ def chunk_pHYs(self, pos, length): s = ImageFile._safe_read(self.fp, length) px, py = i32(s), i32(s[4:]) unit = i8(s[8]) - if unit == 1: # meter + if unit == 0: + self.im_info["aspect"] = px, py + elif unit == 1: dpi = int(px * 0.0254 + 0.5), int(py * 0.0254 + 0.5) self.im_info["dpi"] = dpi - elif unit == 0: - self.im_info["aspect"] = px, py return s def chunk_tEXt(self, pos, length): @@ -455,13 +455,9 @@ def chunk_zTXt(self, pos, length): except ValueError: k = s v = b"" - if v: - comp_method = i8(v[0]) - else: - comp_method = 0 + comp_method = i8(v[0]) if v else 0 if comp_method != 0: - raise SyntaxError("Unknown compression method %s in zTXt chunk" % - comp_method) + raise SyntaxError(f"Unknown compression method {comp_method} in zTXt chunk") try: v = _safe_zlib_decompress(v[1:]) except ValueError: @@ -498,17 +494,16 @@ def chunk_iTXt(self, pos, length): except ValueError: return s if cf != 0: - if cm == 0: - try: - v = _safe_zlib_decompress(v) - except ValueError: - if ImageFile.LOAD_TRUNCATED_IMAGES: - return s - else: - raise - except zlib.error: + if cm != 0: + return s + try: + v = _safe_zlib_decompress(v) + except ValueError: + if ImageFile.LOAD_TRUNCATED_IMAGES: return s - else: + else: + raise + except zlib.error: return s if bytes is not str: try: @@ -625,11 +620,7 @@ def load_read(self, read_bytes): self.__idat = length # empty chunks are allowed # read more data from this chunk - if read_bytes <= 0: - read_bytes = self.__idat - else: - read_bytes = min(read_bytes, self.__idat) - + read_bytes = self.__idat if read_bytes <= 0 else min(read_bytes, self.__idat) self.__idat = self.__idat - read_bytes return self.fp.read(read_bytes) @@ -696,12 +687,10 @@ def _save(im, fp, filename, chunk=putchunk): if "bits" in im.encoderinfo: # number of bits specified by user colors = 1 << im.encoderinfo["bits"] + elif im.palette: + colors = max(min(len(im.palette.getdata()[1])//3, 256), 2) else: - # check palette contents - if im.palette: - colors = max(min(len(im.palette.getdata()[1])//3, 256), 2) - else: - colors = 256 + colors = 256 if colors <= 2: bits = 1 @@ -724,7 +713,7 @@ def _save(im, fp, filename, chunk=putchunk): try: rawmode, mode = _OUTMODES[mode] except KeyError: - raise IOError("cannot write mode %s as PNG" % mode) + raise IOError(f"cannot write mode {mode} as PNG") # # write minimal PNG file @@ -740,8 +729,7 @@ def _save(im, fp, filename, chunk=putchunk): chunks = [b"cHRM", b"gAMA", b"sBIT", b"sRGB", b"tIME"] - icc = im.encoderinfo.get("icc_profile", im.info.get("icc_profile")) - if icc: + if icc := im.encoderinfo.get("icc_profile", im.info.get("icc_profile")): # ICC profile # according to PNG spec, the iCCP chunk contains: # Profile name 1-79 bytes (character string) @@ -756,8 +744,7 @@ def _save(im, fp, filename, chunk=putchunk): # Disallow sRGB chunks when an iCCP-chunk has been emitted. chunks.remove(b"sRGB") - info = im.encoderinfo.get("pnginfo") - if info: + if info := im.encoderinfo.get("pnginfo"): chunks_multiple_allowed = [b"sPLT", b"iTXt", b"tEXt", b"zTXt"] for cid, data in info.chunks: if cid in chunks: @@ -792,26 +779,22 @@ def _save(im, fp, filename, chunk=putchunk): elif im.mode == "RGB": red, green, blue = transparency chunk(fp, b"tRNS", o16(red) + o16(green) + o16(blue)) - else: - if "transparency" in im.encoderinfo: - # don't bother with transparency if it's an RGBA - # and it's in the info dict. It's probably just stale. - raise IOError("cannot use transparency for this mode") - else: - if im.mode == "P" and im.im.getpalettemode() == "RGBA": - alpha = im.im.getpalette("RGBA", "A") - alpha_bytes = 2**bits - chunk(fp, b"tRNS", alpha[:alpha_bytes]) - - dpi = im.encoderinfo.get("dpi") - if dpi: + elif "transparency" in im.encoderinfo: + # don't bother with transparency if it's an RGBA + # and it's in the info dict. It's probably just stale. + raise IOError("cannot use transparency for this mode") + elif im.mode == "P" and im.im.getpalettemode() == "RGBA": + alpha = im.im.getpalette("RGBA", "A") + alpha_bytes = 2**bits + chunk(fp, b"tRNS", alpha[:alpha_bytes]) + + if dpi := im.encoderinfo.get("dpi"): chunk(fp, b"pHYs", o32(int(dpi[0] / 0.0254 + 0.5)), o32(int(dpi[1] / 0.0254 + 0.5)), b'\x01') - info = im.encoderinfo.get("pnginfo") - if info: + if info := im.encoderinfo.get("pnginfo"): chunks = [b"bKGD", b"hIST"] for cid, data in info.chunks: if cid in chunks: diff --git a/serverless-lambda/vendored/PIL/PpmImagePlugin.py b/serverless-lambda/vendored/PIL/PpmImagePlugin.py index c599ba8..03bc900 100644 --- a/serverless-lambda/vendored/PIL/PpmImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PpmImagePlugin.py @@ -39,7 +39,7 @@ def _accept(prefix): - return prefix[0:1] == b"P" and prefix[1] in b"0456y" + return prefix[:1] == b"P" and prefix[1] in b"0456y" ## @@ -97,15 +97,10 @@ def _open(self): elif ix == 2: # maxgrey if s > 255: - if not mode == 'L': - raise ValueError("Too many colors for band: %s" % s) - if s < 2**16: - self.mode = 'I' - rawmode = 'I;16B' - else: - self.mode = 'I' - rawmode = 'I;32B' - + if mode != 'L': + raise ValueError(f"Too many colors for band: {s}") + rawmode = 'I;16B' if s < 2**16 else 'I;32B' + self.mode = 'I' self.size = xsize, ysize self.tile = [("raw", (0, 0, xsize, ysize), @@ -131,17 +126,14 @@ def _save(im, fp, filename): elif im.mode == "RGBA": rawmode, head = "RGB", b"P6" else: - raise IOError("cannot write mode %s as PPM" % im.mode) + raise IOError(f"cannot write mode {im.mode} as PPM") fp.write(head + ("\n%d %d\n" % im.size).encode('ascii')) - if head == b"P6": + if head == b"P5" and rawmode == "I;16B": + fp.write(b"65535\n") + elif head == b"P5" and rawmode == "I;32B": + fp.write(b"2147483648\n") + elif head == b"P5" and rawmode == "L" or head != b"P5" and head == b"P6": fp.write(b"255\n") - if head == b"P5": - if rawmode == "L": - fp.write(b"255\n") - elif rawmode == "I;16B": - fp.write(b"65535\n") - elif rawmode == "I;32B": - fp.write(b"2147483648\n") ImageFile._save(im, fp, [("raw", (0, 0)+im.size, 0, (rawmode, 0, 1))]) # ALTERNATIVE: save via builtin debug function diff --git a/serverless-lambda/vendored/PIL/PsdImagePlugin.py b/serverless-lambda/vendored/PIL/PsdImagePlugin.py index f6e04f7..fbe86dc 100644 --- a/serverless-lambda/vendored/PIL/PsdImagePlugin.py +++ b/serverless-lambda/vendored/PIL/PsdImagePlugin.py @@ -73,11 +73,7 @@ def _open(self): self.mode = mode self.size = i32(s[18:]), i32(s[14:]) - # - # color mode data - - size = i32(read(4)) - if size: + if size := i32(read(4)): data = read(size) if mode == "P" and size == 768: self.palette = ImagePalette.raw("RGB;L", data) @@ -87,8 +83,7 @@ def _open(self): self.resources = [] - size = i32(read(4)) - if size: + if size := i32(read(4)): # load resources end = self.fp.tell() + size while self.fp.tell() < end: @@ -109,11 +104,9 @@ def _open(self): self.layers = [] - size = i32(read(4)) - if size: + if size := i32(read(4)): end = self.fp.tell() + size - size = i32(read(4)) - if size: + if size := i32(read(4)): self.layers = _layerinfo(self.fp) self.fp.seek(end) @@ -168,8 +161,7 @@ def _layerinfo(file): # read layerinfo block layers = [] read = file.read - for i in range(abs(i16(read(2)))): - + for _ in range(abs(i16(read(2)))): # bounding box y0 = i32(read(4)) x0 = i32(read(4)) @@ -183,14 +175,10 @@ def _layerinfo(file): if len(types) > 4: continue - for i in types: + for _ in types: type = i16(read(2)) - if type == 65535: - m = "A" - else: - m = "RGBA"[type] - + m = "A" if type == 65535 else "RGBA"[type] mode.append(m) size = i32(read(4)) info.append((m, size)) @@ -236,17 +224,12 @@ def _layerinfo(file): file.seek(size - combined, 1) layers.append((name, mode, (x0, y0, x1, y1))) - # get tiles - i = 0 - for name, mode, bbox in layers: + for i, (name, mode, bbox) in enumerate(layers): tile = [] for m in mode: - t = _maketile(file, m, bbox, 1) - if t: + if t := _maketile(file, m, bbox, 1): tile.extend(t) layers[i] = name, mode, bbox, tile - i += 1 - return layers @@ -287,7 +270,7 @@ def _maketile(file, mode, bbox, channels): tile.append( ("packbits", bbox, offset, layer) ) - for y in range(ysize): + for _ in range(ysize): offset = offset + i16(bytecount[i:i+2]) i += 2 diff --git a/serverless-lambda/vendored/PIL/SgiImagePlugin.py b/serverless-lambda/vendored/PIL/SgiImagePlugin.py index 8b34561..2d05823 100644 --- a/serverless-lambda/vendored/PIL/SgiImagePlugin.py +++ b/serverless-lambda/vendored/PIL/SgiImagePlugin.py @@ -121,7 +121,7 @@ def _open(self): def _save(im, fp, filename): - if im.mode != "RGB" and im.mode != "RGBA" and im.mode != "L": + if im.mode not in ["RGB", "RGBA", "L"]: raise ValueError("Unsupported SGI image mode") # Get the keyword arguments @@ -144,20 +144,14 @@ def _save(im, fp, filename): dim = 3 # X Dimension = width / Y Dimension = height x, y = im.size - if im.mode == "L" and y == 1: - dim = 1 - elif im.mode == "L": - dim = 2 - # Z Dimension: Number of channels - z = len(im.mode) - - if dim == 1 or dim == 2: - z = 1 - + if im.mode == "L": + dim = 1 if y == 1 else 2 + z = 1 if dim in {1, 2} else len(im.mode) # assert we've got the right number of bands. if len(im.getbands()) != z: - raise ValueError("incorrect number of bands in SGI write: %s vs %s" % - (z, len(im.getbands()))) + raise ValueError( + f"incorrect number of bands in SGI write: {z} vs {len(im.getbands())}" + ) # Minimum Byte value pinmin = 0 @@ -184,10 +178,7 @@ def _save(im, fp, filename): fp.write(struct.pack('>l', colormap)) fp.write(struct.pack('404s', b'')) # dummy - rawmode = 'L' - if bpc == 2: - rawmode = 'L;16B' - + rawmode = 'L;16B' if bpc == 2 else 'L' for channel in im.split(): fp.write(channel.tobytes('raw', rawmode, 0, orientation)) diff --git a/serverless-lambda/vendored/PIL/SpiderImagePlugin.py b/serverless-lambda/vendored/PIL/SpiderImagePlugin.py index d89a3e1..e00f613 100644 --- a/serverless-lambda/vendored/PIL/SpiderImagePlugin.py +++ b/serverless-lambda/vendored/PIL/SpiderImagePlugin.py @@ -44,10 +44,7 @@ def isInt(f): try: i = int(f) - if f-i == 0: - return 1 - else: - return 0 + return 1 if f-i == 0 else 0 except (ValueError, OverflowError): return 0 @@ -75,10 +72,7 @@ def isSpiderHeader(t): labbyt = int(h[22]) # total no. of bytes in header lenbyt = int(h[23]) # record length in bytes # print("labrec = %d, labbyt = %d, lenbyt = %d" % (labrec,labbyt,lenbyt)) - if labbyt != (labrec * lenbyt): - return 0 - # looks like a valid header - return labbyt + return 0 if labbyt != (labrec * lenbyt) else labbyt def isSpiderImage(filename): @@ -144,10 +138,7 @@ def _open(self): else: raise SyntaxError("inconsistent stack header values") - if self.bigendian: - self.rawmode = "F;32BF" - else: - self.rawmode = "F;32F" + self.rawmode = "F;32BF" if self.bigendian else "F;32F" self.mode = "F" self.tile = [ @@ -165,10 +156,7 @@ def is_animated(self): # 1st image index is zero (although SPIDER imgnumber starts at 1) def tell(self): - if self.imgnumber < 1: - return 0 - else: - return self.imgnumber - 1 + return 0 if self.imgnumber < 1 else self.imgnumber - 1 def seek(self, frame): if self.istack == 0: @@ -183,9 +171,7 @@ def seek(self, frame): # returns a byte image after rescaling to 0..255 def convert2byte(self, depth=255): (minimum, maximum) = self.getextrema() - m = 1 - if maximum != minimum: - m = depth / (maximum-minimum) + m = depth / (maximum-minimum) if maximum != minimum else 1 b = -m * minimum return self.point(lambda i, m=m, b=b: i * m + b).convert("L") @@ -207,13 +193,13 @@ def loadImageSeries(filelist=None): imglist = [] for img in filelist: if not os.path.exists(img): - print("unable to find %s" % img) + print(f"unable to find {img}") continue try: im = Image.open(img).convert2byte() except: if not isSpiderImage(img): - print(img + " is not a Spider image file") + print(f"{img} is not a Spider image file") continue im.info['filename'] = img imglist.append(im) @@ -230,11 +216,8 @@ def makeSpiderHeader(im): if 1024 % lenbyt != 0: labrec += 1 labbyt = labrec * lenbyt - hdr = [] nvalues = int(labbyt / 4) - for i in range(nvalues): - hdr.append(0.0) - + hdr = [0.0 for _ in range(nvalues)] if len(hdr) < 23: return [] @@ -250,11 +233,7 @@ def makeSpiderHeader(im): # adjust for Fortran indexing hdr = hdr[1:] hdr.append(0.0) - # pack binary data into a string - hdrstr = [] - for v in hdr: - hdrstr.append(struct.pack('f', v)) - return hdrstr + return [struct.pack('f', v) for v in hdr] def _save(im, fp, filename): @@ -296,10 +275,10 @@ def _save_spider(im, fp, filename): sys.exit() im = Image.open(filename) - print("image: " + str(im)) - print("format: " + str(im.format)) - print("size: " + str(im.size)) - print("mode: " + str(im.mode)) + print(f"image: {str(im)}") + print(f"format: {str(im.format)}") + print(f"size: {str(im.size)}") + print(f"mode: {str(im.mode)}") print("max, min: ", end=' ') print(im.getextrema()) @@ -309,6 +288,6 @@ def _save_spider(im, fp, filename): # perform some image operation im = im.transpose(Image.FLIP_LEFT_RIGHT) print( - "saving a flipped version of %s as %s " % - (os.path.basename(filename), outfile)) + f"saving a flipped version of {os.path.basename(filename)} as {outfile} " + ) im.save(outfile, SpiderImageFile.format) diff --git a/serverless-lambda/vendored/PIL/SunImagePlugin.py b/serverless-lambda/vendored/PIL/SunImagePlugin.py index fd5e827..33706d1 100644 --- a/serverless-lambda/vendored/PIL/SunImagePlugin.py +++ b/serverless-lambda/vendored/PIL/SunImagePlugin.py @@ -74,15 +74,9 @@ def _open(self): elif depth == 8: self.mode = rawmode = "L" elif depth == 24: - if file_type == 3: - self.mode, rawmode = "RGB", "RGB" - else: - self.mode, rawmode = "RGB", "BGR" + self.mode, rawmode = ("RGB", "RGB") if file_type == 3 else ("RGB", "BGR") elif depth == 32: - if file_type == 3: - self.mode, rawmode = 'RGB', 'RGBX' - else: - self.mode, rawmode = 'RGB', 'BGRX' + self.mode, rawmode = ('RGB', 'RGBX') if file_type == 3 else ('RGB', 'BGRX') else: raise SyntaxError("Unsupported Mode/Bit Depth") @@ -93,7 +87,7 @@ def _open(self): if palette_type != 1: raise SyntaxError("Unsupported Palette Type") - offset = offset + palette_length + offset += palette_length self.palette = ImagePalette.raw("RGB;L", self.fp.read(palette_length)) if self.mode == "L": self.mode = "P" diff --git a/serverless-lambda/vendored/PIL/TgaImagePlugin.py b/serverless-lambda/vendored/PIL/TgaImagePlugin.py index 76d9ba8..13ea6e1 100644 --- a/serverless-lambda/vendored/PIL/TgaImagePlugin.py +++ b/serverless-lambda/vendored/PIL/TgaImagePlugin.py @@ -145,21 +145,17 @@ def _save(im, fp, filename): try: rawmode, bits, colormaptype, imagetype = SAVE[im.mode] except KeyError: - raise IOError("cannot write mode %s as TGA" % im.mode) + raise IOError(f"cannot write mode {im.mode} as TGA") if colormaptype: colormapfirst, colormaplength, colormapentry = 0, 256, 24 else: colormapfirst, colormaplength, colormapentry = 0, 0, 0 - if im.mode == "RGBA": - flags = 8 - else: - flags = 0 - + flags = 8 if im.mode == "RGBA" else 0 orientation = im.info.get("orientation", -1) if orientation > 0: - flags = flags | 0x20 + flags |= 0x20 fp.write(b"\000" + o8(colormaptype) + diff --git a/serverless-lambda/vendored/PIL/TiffImagePlugin.py b/serverless-lambda/vendored/PIL/TiffImagePlugin.py index f903918..b2f175e 100644 --- a/serverless-lambda/vendored/PIL/TiffImagePlugin.py +++ b/serverless-lambda/vendored/PIL/TiffImagePlugin.py @@ -499,8 +499,7 @@ def named(self): Returns the complete tag dictionary, with named tags where possible. """ - return dict((TiffTags.lookup(code).name, value) - for code, value in self.items()) + return {TiffTags.lookup(code).name: value for code, value in self.items()} def __len__(self): return len(set(self._tagdata) | set(self._tags_v2)) @@ -542,19 +541,14 @@ def _setitem(self, tag, value, legacy_api): if all(isinstance(v, IFDRational) for v in values): self.tagtype[tag] = 5 elif all(isinstance(v, int) for v in values): - if all(v < 2 ** 16 for v in values): - self.tagtype[tag] = 3 - else: - self.tagtype[tag] = 4 + self.tagtype[tag] = 3 if all(v < 2 ** 16 for v in values) else 4 elif all(isinstance(v, float) for v in values): self.tagtype[tag] = 12 - else: - if bytes is str: - # Never treat data as binary by default on Python 2. - self.tagtype[tag] = 2 - else: - if all(isinstance(v, str) for v in values): - self.tagtype[tag] = 2 + elif bytes is str: + # Never treat data as binary by default on Python 2. + self.tagtype[tag] = 2 + elif all(isinstance(v, str) for v in values): + self.tagtype[tag] = 2 if self.tagtype[tag] == 7 and bytes is not str: values = [value.encode("ascii", 'replace') if isinstance( @@ -579,8 +573,8 @@ def _setitem(self, tag, value, legacy_api): except ValueError: # We've got a builtin tag with 1 expected entry warnings.warn( - "Metadata Warning, tag %s had too many entries: %s, expected 1" % ( - tag, len(values))) + f"Metadata Warning, tag {tag} had too many entries: {len(values)}, expected 1" + ) dest[tag] = values[0] else: @@ -621,9 +615,12 @@ def _register_basic(idx_fmt_name): from .TiffTags import TYPES idx, fmt, name = idx_fmt_name TYPES[idx] = name - size = struct.calcsize("=" + fmt) - _load_dispatch[idx] = size, lambda self, data, legacy_api=True: ( - self._unpack("{}{}".format(len(data) // size, fmt), data)) + size = struct.calcsize(f"={fmt}") + _load_dispatch[ + idx + ] = size, lambda self, data, legacy_api=True: self._unpack( + f"{len(data) // size}{fmt}", data + ) _write_dispatch[idx] = lambda self, *values: ( b"".join(self._pack(fmt, value) for value in values)) @@ -705,7 +702,7 @@ def load(self, fp): self._offset = fp.tell() try: - for i in range(self._unpack("H", self._ensure_read(fp, 2))[0]): + for _ in range(self._unpack("H", self._ensure_read(fp, 2))[0]): tag, typ, count, data = self._unpack("HHL4s", self._ensure_read(fp, 12)) if DEBUG: @@ -725,8 +722,7 @@ def load(self, fp): here = fp.tell() offset, = self._unpack("L", data) if DEBUG: - print("Tag Location: %s - Data Location: %s" % - (here, offset), end=" ") + print(f"Tag Location: {here} - Data Location: {offset}", end=" ") fp.seek(offset) data = ImageFile._safe_read(fp, size) fp.seek(here) @@ -776,7 +772,7 @@ def save(self, fp): stripoffsets = len(entries) typ = self.tagtype.get(tag) if DEBUG: - print("Tag %s, Type: %s, Value: %s" % (tag, typ, value)) + print(f"Tag {tag}, Type: {typ}, Value: {value}") values = value if isinstance(value, tuple) else (value,) data = self._write_dispatch[typ](self, *values) if DEBUG: @@ -830,8 +826,8 @@ def save(self, fp): ImageFileDirectory_v2._write_dispatch = _write_dispatch for idx, name in TYPES.items(): name = name.replace(" ", "_") - setattr(ImageFileDirectory_v2, "load_" + name, _load_dispatch[idx][1]) - setattr(ImageFileDirectory_v2, "write_" + name, _write_dispatch[idx]) + setattr(ImageFileDirectory_v2, f"load_{name}", _load_dispatch[idx][1]) + setattr(ImageFileDirectory_v2, f"write_{name}", _write_dispatch[idx]) del _load_dispatch, _write_dispatch, idx, name @@ -978,9 +974,7 @@ def n_frames(self): @property def is_animated(self): if self._is_animated is None: - if self._n_frames is not None: - self._is_animated = self._n_frames != 1 - else: + if self._n_frames is None: current = self.tell() try: @@ -990,6 +984,8 @@ def is_animated(self): self._is_animated = False self.seek(current) + else: + self._is_animated = self._n_frames != 1 return self._is_animated def seek(self, frame): @@ -1018,7 +1014,7 @@ def _seek(self, frame): self.fp.seek(self.__next) self._frame_pos.append(self.__next) if DEBUG: - print("Loading tags, location: %s" % self.fp.tell()) + print(f"Loading tags, location: {self.fp.tell()}") self.tag_v2.load(self.fp) self.__next = self.tag_v2.next self.__frame += 1 @@ -1072,7 +1068,7 @@ def _load_libtiff(self): self.load_prepare() - if not len(self.tile) == 1: + if len(self.tile) != 1: raise IOError("Not exactly one tile") # (self._compression, (extents tuple), @@ -1135,7 +1131,6 @@ def _load_libtiff(self): self.tile = [] self.readonly = 0 - # libtiff closed the fp in a, we need to close self.fp, if possible if self._exclusive_fp: if self.__frame == 0 and not self.__next: self.fp.close() @@ -1384,7 +1379,7 @@ def _save(im, fp, filename): try: rawmode, prefix, photo, format, bits, extra = SAVE_INFO[im.mode] except KeyError: - raise IOError("cannot write mode %s as TIFF" % im.mode) + raise IOError(f"cannot write mode {im.mode} as TIFF") ifd = ImageFileDirectory_v2(prefix=prefix) @@ -1402,7 +1397,7 @@ def _save(im, fp, filename): # write any arbitrary tags passed in as an ImageFileDirectory info = im.encoderinfo.get("tiffinfo", {}) if DEBUG: - print("Tiffinfo Keys: %s" % list(info)) + print(f"Tiffinfo Keys: {list(info)}") if isinstance(info, ImageFileDirectory_v1): info = info.to_v2() for key in info: @@ -1440,8 +1435,7 @@ def _save(im, fp, filename): if name in im.encoderinfo: ifd[key] = im.encoderinfo[name] - dpi = im.encoderinfo.get("dpi") - if dpi: + if dpi := im.encoderinfo.get("dpi"): ifd[RESOLUTION_UNIT] = 2 ifd[X_RESOLUTION] = dpi[0] ifd[Y_RESOLUTION] = dpi[1] @@ -1471,7 +1465,7 @@ def _save(im, fp, filename): if libtiff: if DEBUG: print("Saving using libtiff encoder") - print("Items: %s" % sorted(ifd.items())) + print(f"Items: {sorted(ifd.items())}") _fp = 0 if hasattr(fp, "fileno"): try: @@ -1483,15 +1477,8 @@ def _save(im, fp, filename): # STRIPOFFSETS and STRIPBYTECOUNTS are added by the library # based on the data in the strip. blocklist = [STRIPOFFSETS, STRIPBYTECOUNTS] - atts = {} - # bits per sample is a single short in the tiff directory, not a list. - atts[BITSPERSAMPLE] = bits[0] - # Merge the ones that we have with (optional) more bits from - # the original file, e.g x,y resolution so that we can - # save(load('')) == original file. - legacy_ifd = {} - if hasattr(im, 'tag'): - legacy_ifd = im.tag.to_v2() + atts = {BITSPERSAMPLE: bits[0]} + legacy_ifd = im.tag.to_v2() if hasattr(im, 'tag') else {} for tag, value in itertools.chain(ifd.items(), getattr(im, 'tag_v2', {}).items(), legacy_ifd.items()): @@ -1511,7 +1498,7 @@ def _save(im, fp, filename): atts[tag] = value if DEBUG: - print("Converted items: %s" % sorted(atts.items())) + print(f"Converted items: {sorted(atts.items())}") # libtiff always expects the bytes in native order. # we're storing image byte order. So, if the rawmode @@ -1669,9 +1656,9 @@ def goToEnd(self): def setEndian(self, endian): self.endian = endian - self.longFmt = self.endian + "L" - self.shortFmt = self.endian + "H" - self.tagFormat = self.endian + "HHL" + self.longFmt = f"{self.endian}L" + self.shortFmt = f"{self.endian}H" + self.tagFormat = f"{self.endian}HHL" def skipIFDs(self): while True: @@ -1735,7 +1722,7 @@ def close(self): def fixIFD(self): numTags = self.readShort() - for i in range(numTags): + for _ in range(numTags): tag, fieldType, count = struct.unpack(self.tagFormat, self.f.read(8)) @@ -1770,7 +1757,7 @@ def fixOffsets(self, count, isShort=False, isLong=False): if not isShort and not isLong: raise RuntimeError("offset is neither short nor long") - for i in range(count): + for _ in range(count): offset = self.readShort() if isShort else self.readLong() offset += self.offsetOfNewPage if isShort and offset >= 65536: @@ -1803,11 +1790,7 @@ def _save_all(im, fp, filename): for ims in [im]+append_images: ims.encoderinfo = encoderinfo ims.encoderconfig = encoderconfig - if not hasattr(ims, "n_frames"): - nfr = 1 - else: - nfr = ims.n_frames - + nfr = 1 if not hasattr(ims, "n_frames") else ims.n_frames for idx in range(nfr): ims.seek(idx) ims.load() diff --git a/serverless-lambda/vendored/PIL/WalImageFile.py b/serverless-lambda/vendored/PIL/WalImageFile.py index 6602cc8..3681911 100644 --- a/serverless-lambda/vendored/PIL/WalImageFile.py +++ b/serverless-lambda/vendored/PIL/WalImageFile.py @@ -70,9 +70,8 @@ def imopen(fp): if hasattr(filename, "read"): return imopen(filename) - else: - with builtins.open(filename, "rb") as fp: - return imopen(fp) + with builtins.open(filename, "rb") as fp: + return imopen(fp) quake2palette = ( diff --git a/serverless-lambda/vendored/PIL/WebPImagePlugin.py b/serverless-lambda/vendored/PIL/WebPImagePlugin.py index 39a8f2e..56daa44 100644 --- a/serverless-lambda/vendored/PIL/WebPImagePlugin.py +++ b/serverless-lambda/vendored/PIL/WebPImagePlugin.py @@ -169,11 +169,10 @@ def _save_all(im, fp, filename): encoderinfo = im.encoderinfo.copy() append_images = list(encoderinfo.get("append_images", [])) - # If total frame count is 1, then save using the legacy API, which - # will preserve non-alpha modes - total = 0 - for ims in [im]+append_images: - total += 1 if not hasattr(ims, "n_frames") else ims.n_frames + total = sum( + 1 if not hasattr(ims, "n_frames") else ims.n_frames + for ims in [im] + append_images + ) if total == 1: _save(im, fp, filename) return @@ -204,8 +203,9 @@ def _save_all(im, fp, filename): # Validate background color if (not isinstance(background, (list, tuple)) or len(background) != 4 or not all(v >= 0 and v < 256 for v in background)): - raise IOError("Background color is not an RGBA tuple clamped " - "to (0-255): %s" % str(background)) + raise IOError( + f"Background color is not an RGBA tuple clamped to (0-255): {str(background)}" + ) # Convert to packed uint bg_r, bg_g, bg_b, bg_a = background @@ -229,11 +229,7 @@ def _save_all(im, fp, filename): try: for ims in [im]+append_images: # Get # of frames in this image - if not hasattr(ims, "n_frames"): - nfr = 1 - else: - nfr = ims.n_frames - + nfr = 1 if not hasattr(ims, "n_frames") else ims.n_frames for idx in range(nfr): ims.seek(idx) ims.load() diff --git a/serverless-lambda/vendored/PIL/WmfImagePlugin.py b/serverless-lambda/vendored/PIL/WmfImagePlugin.py index 173ddb2..cd5063d 100644 --- a/serverless-lambda/vendored/PIL/WmfImagePlugin.py +++ b/serverless-lambda/vendored/PIL/WmfImagePlugin.py @@ -134,19 +134,14 @@ def _open(self): self.info["wmf_bbox"] = x0, y0, x1, y1 - if xdpi == ydpi: - self.info["dpi"] = xdpi - else: - self.info["dpi"] = xdpi, ydpi - + self.info["dpi"] = xdpi if xdpi == ydpi else (xdpi, ydpi) else: raise SyntaxError("Unsupported file format") self.mode = "RGB" self.size = size - loader = self._load() - if loader: + if loader := self._load(): loader.open(self) def _load(self): diff --git a/serverless-lambda/vendored/PIL/XbmImagePlugin.py b/serverless-lambda/vendored/PIL/XbmImagePlugin.py index b43fbef..72ae1db 100644 --- a/serverless-lambda/vendored/PIL/XbmImagePlugin.py +++ b/serverless-lambda/vendored/PIL/XbmImagePlugin.py @@ -50,10 +50,7 @@ class XbmImageFile(ImageFile.ImageFile): def _open(self): - m = xbm_head.match(self.fp.read(512)) - - if m: - + if m := xbm_head.match(self.fp.read(512)): xsize = int(m.group("width")) ysize = int(m.group("height")) @@ -71,13 +68,12 @@ def _open(self): def _save(im, fp, filename): if im.mode != "1": - raise IOError("cannot write mode %s as XBM" % im.mode) + raise IOError(f"cannot write mode {im.mode} as XBM") fp.write(("#define im_width %d\n" % im.size[0]).encode('ascii')) fp.write(("#define im_height %d\n" % im.size[1]).encode('ascii')) - hotspot = im.encoderinfo.get("hotspot") - if hotspot: + if hotspot := im.encoderinfo.get("hotspot"): fp.write(("#define im_x_hot %d\n" % hotspot[0]).encode('ascii')) fp.write(("#define im_y_hot %d\n" % hotspot[1]).encode('ascii')) diff --git a/serverless-lambda/vendored/PIL/XpmImagePlugin.py b/serverless-lambda/vendored/PIL/XpmImagePlugin.py index a5cca0e..0fb5e5f 100644 --- a/serverless-lambda/vendored/PIL/XpmImagePlugin.py +++ b/serverless-lambda/vendored/PIL/XpmImagePlugin.py @@ -83,7 +83,7 @@ def _open(self): rgb = s[i+1] if rgb == b"None": self.info["transparency"] = c - elif rgb[0:1] == b"#": + elif rgb[:1] == b"#": # FIXME: handle colour names (see ImagePalette.py) rgb = int(rgb[1:], 16) palette[c] = (o8((rgb >> 16) & 255) + diff --git a/serverless-lambda/vendored/PIL/features.py b/serverless-lambda/vendored/PIL/features.py index d96bf38..7cd2d25 100644 --- a/serverless-lambda/vendored/PIL/features.py +++ b/serverless-lambda/vendored/PIL/features.py @@ -10,8 +10,8 @@ def check_module(feature): - if not (feature in modules): - raise ValueError("Unknown module %s" % feature) + if feature not in modules: + raise ValueError(f"Unknown module {feature}") module = modules[feature] @@ -36,11 +36,11 @@ def get_supported_modules(): def check_codec(feature): if feature not in codecs: - raise ValueError("Unknown codec %s" % feature) + raise ValueError(f"Unknown codec {feature}") codec = codecs[feature] - return codec + "_encoder" in dir(Image.core) + return f"{codec}_encoder" in dir(Image.core) def get_supported_codecs(): @@ -57,7 +57,7 @@ def get_supported_codecs(): def check_feature(feature): if feature not in features: - raise ValueError("Unknown feature %s" % feature) + raise ValueError(f"Unknown feature {feature}") module, flag = features[feature] diff --git a/serverless-lambda/vendored/backports/weakref.py b/serverless-lambda/vendored/backports/weakref.py index 0052fef..3e6b5da 100644 --- a/serverless-lambda/vendored/backports/weakref.py +++ b/serverless-lambda/vendored/backports/weakref.py @@ -95,8 +95,7 @@ def atexit(self): @atexit.setter def atexit(self, value): - info = self._registry.get(self) - if info: + if info := self._registry.get(self): info.atexit = bool(value) def __repr__(self): diff --git a/serverless-lambda/vendored/bleach/__init__.py b/serverless-lambda/vendored/bleach/__init__.py index 13b5e2e..9ce7f46 100644 --- a/serverless-lambda/vendored/bleach/__init__.py +++ b/serverless-lambda/vendored/bleach/__init__.py @@ -317,8 +317,8 @@ def linkify_nodes(tree, parse_text=True): current_child + 1) children += adj - if node.tag == ETREE_TAG('a') and not (node in _seen): - if not node.get('href', None) is None: + if node.tag == ETREE_TAG('a') and node not in _seen: + if node.get('href', None) is not None: attrs = dict(node.items()) _text = attrs['_text'] = _render_inner(node) @@ -347,7 +347,7 @@ def linkify_nodes(tree, parse_text=True): elif current_child >= 0: if node.tag == ETREE_TAG('pre') and skip_pre: linkify_nodes(node, False) - elif not (node in _seen): + elif node not in _seen: linkify_nodes(node, parse_text) current_child += 1 @@ -388,13 +388,9 @@ def link_repl(match): end = '' m = re.search(punct_re, url) if m: - end = m.group(0) - url = url[0:m.start()] - if re.search(proto_re, url): - href = url - else: - href = ''.join(['http://', url]) - + end = m[0] + url = url[:m.start()] + href = url if re.search(proto_re, url) else ''.join(['http://', url]) link = { '_text': url, 'href': href, diff --git a/serverless-lambda/vendored/bleach/encoding.py b/serverless-lambda/vendored/bleach/encoding.py index 707adaa..4da4bcd 100644 --- a/serverless-lambda/vendored/bleach/encoding.py +++ b/serverless-lambda/vendored/bleach/encoding.py @@ -32,22 +32,21 @@ def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'): if strings_only and is_protected_type(s): return s try: - if not isinstance(s, six.string_types): - if hasattr(s, '__unicode__'): - s = s.__unicode__() - else: - if six.PY3: - if isinstance(s, bytes): - s = six.text_type(s, encoding, errors) - else: - s = six.text_type(s) - else: - s = six.text_type(bytes(s), encoding, errors) - else: + if isinstance(s, six.string_types): # Note: We use .decode() here, instead of six.text_type(s, # encoding, errors), so that if s is a SafeBytes, it ends up being # a SafeText at the end. s = s.decode(encoding, errors) + elif hasattr(s, '__unicode__'): + s = s.__unicode__() + elif six.PY3: + s = ( + six.text_type(s, encoding, errors) + if isinstance(s, bytes) + else six.text_type(s) + ) + else: + s = six.text_type(bytes(s), encoding, errors) except UnicodeDecodeError as e: if not isinstance(s, Exception): raise UnicodeDecodeError(*e.args) diff --git a/serverless-lambda/vendored/bleach/sanitizer.py b/serverless-lambda/vendored/bleach/sanitizer.py index eec6659..0822191 100644 --- a/serverless-lambda/vendored/bleach/sanitizer.py +++ b/serverless-lambda/vendored/bleach/sanitizer.py @@ -71,12 +71,9 @@ def sanitize_token(self, token): del attrs['xlink:href'] if 'style' in attrs: attrs['style'] = self.sanitize_css(attrs['style']) - token['data'] = [(name, val) for name, val in - attrs.items()] + token['data'] = list(attrs.items()) return token - elif self.strip_disallowed_elements: - pass - else: + elif not self.strip_disallowed_elements: if token['type'] == tokenTypes['EndTag']: token['data'] = ''.format(token['name']) elif token['data']: @@ -126,9 +123,9 @@ def sanitize_css(self, style): if not value: continue if prop.lower() in self.allowed_css_properties: - clean.append(prop + ': ' + value + ';') + clean.append(f'{prop}: {value};') elif prop.lower() in self.allowed_svg_properties: - clean.append(prop + ': ' + value + ';') + clean.append(f'{prop}: {value};') return ' '.join(clean) @@ -142,6 +139,5 @@ def __init__(self, stream, encoding=None, parseMeta=True, useChardet=True, def __iter__(self): for token in HTMLTokenizer.__iter__(self): - token = self.sanitize_token(token) - if token: + if token := self.sanitize_token(token): yield token diff --git a/serverless-lambda/vendored/concurrent/futures/_base.py b/serverless-lambda/vendored/concurrent/futures/_base.py index 510ffa5..b5984e9 100644 --- a/serverless-lambda/vendored/concurrent/futures/_base.py +++ b/serverless-lambda/vendored/concurrent/futures/_base.py @@ -219,9 +219,9 @@ def as_completed(fs, timeout=None): fs = set(fs) total_futures = len(fs) with _AcquireFutures(fs): - finished = set( - f for f in fs - if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]) + finished = { + f for f in fs if f._state in [CANCELLED_AND_NOTIFIED, FINISHED] + } pending = fs - finished waiter = _create_and_install_waiters(fs, _AS_COMPLETED) finished = list(finished) @@ -288,8 +288,9 @@ def wait(fs, timeout=None, return_when=ALL_COMPLETED): futures. """ with _AcquireFutures(fs): - done = set(f for f in fs - if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]) + done = { + f for f in fs if f._state in [CANCELLED_AND_NOTIFIED, FINISHED] + } not_done = set(fs) - done if (return_when == FIRST_COMPLETED) and done: @@ -403,17 +404,14 @@ def done(self): return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED] def __get_result(self): - if self._exception: - if isinstance(self._exception, types.InstanceType): - # The exception is an instance of an old-style class, which - # means type(self._exception) returns types.ClassType instead - # of the exception's actual class type. - exception_type = self._exception.__class__ - else: - exception_type = type(self._exception) - raise exception_type, self._exception, self._traceback - else: + if not self._exception: return self._result + exception_type = ( + self._exception.__class__ + if isinstance(self._exception, types.InstanceType) + else type(self._exception) + ) + raise exception_type, self._exception, self._traceback def add_done_callback(self, fn): """Attaches a callable that will be called when the future finishes. diff --git a/serverless-lambda/vendored/concurrent/futures/process.py b/serverless-lambda/vendored/concurrent/futures/process.py index fa5b96f..0fecb14 100644 --- a/serverless-lambda/vendored/concurrent/futures/process.py +++ b/serverless-lambda/vendored/concurrent/futures/process.py @@ -276,10 +276,10 @@ def __init__(self, max_workers=None): if max_workers is None: self._max_workers = multiprocessing.cpu_count() - else: - if max_workers <= 0: - raise ValueError("max_workers must be greater than 0") + elif max_workers <= 0: + raise ValueError("max_workers must be greater than 0") + else: self._max_workers = max_workers # Make the call queue slightly larger than the number of processes to diff --git a/serverless-lambda/vendored/enum/__init__.py b/serverless-lambda/vendored/enum/__init__.py index d6ffb3a..c9930fa 100644 --- a/serverless-lambda/vendored/enum/__init__.py +++ b/serverless-lambda/vendored/enum/__init__.py @@ -12,10 +12,7 @@ any except NameError: def any(iterable): - for element in iterable: - if element: - return True - return False + return any(iterable) try: from collections import OrderedDict @@ -166,7 +163,7 @@ def __new__(metacls, cls, bases, classdict): first_enum) # save enum items into separate mapping so they don't get baked into # the new class - members = dict((k, classdict[k]) for k in classdict._member_names) + members = {k: classdict[k] for k in classdict._member_names} for name in classdict._member_names: del classdict[name] @@ -177,7 +174,7 @@ def __new__(metacls, cls, bases, classdict): try: _order_ = [name for (name, value) in sorted(members.items(), key=lambda item: item[1])] except TypeError: - _order_ = [name for name in sorted(members.keys())] + _order_ = list(sorted(members.keys())) else: _order_ = classdict._member_names else: @@ -187,22 +184,16 @@ def __new__(metacls, cls, bases, classdict): aliases = [name for name in members if name not in _order_] _order_ += aliases - # check for illegal enum names (any others?) - invalid_names = set(members) & set(['mro']) - if invalid_names: - raise ValueError('Invalid enum member name(s): %s' % ( - ', '.join(invalid_names), )) + if invalid_names := set(members) & {'mro'}: + raise ValueError(f"Invalid enum member name(s): {', '.join(invalid_names)}") # save attributes from super classes so we know if we can take # the shortcut of storing members in the class dict - base_attributes = set([a for b in bases for a in b.__dict__]) + base_attributes = {a for b in bases for a in b.__dict__} # create our new Enum type enum_class = super(EnumMeta, metacls).__new__(metacls, cls, bases, classdict) enum_class._member_names_ = [] # names in random order - if OrderedDict is not None: - enum_class._member_map_ = OrderedDict() - else: - enum_class._member_map_ = {} # name->value map + enum_class._member_map_ = OrderedDict() if OrderedDict is not None else {} enum_class._member_type_ = member_type # Reverse value->name map for hashable values. @@ -216,10 +207,7 @@ def __new__(metacls, cls, bases, classdict): __new__ = enum_class.__new__ for member_name in _order_: value = members[member_name] - if not isinstance(value, tuple): - args = (value, ) - else: - args = value + args = (value, ) if not isinstance(value, tuple) else value if member_type is tuple: # special case for tuple enums args = (args, ) # wrap it one more time if not use_args or not args: @@ -273,7 +261,7 @@ def __new__(metacls, cls, bases, classdict): if member_type is not object: methods = ('__getnewargs_ex__', '__getnewargs__', '__reduce_ex__', '__reduce__') - if not any(m in member_type.__dict__ for m in methods): + if all(m not in member_type.__dict__ for m in methods): _make_class_unpicklable(enum_class) unpicklable = True @@ -321,13 +309,13 @@ def __new__(metacls, cls, bases, classdict): setattr(enum_class, '__new__', Enum.__dict__['__new__']) return enum_class - def __bool__(cls): + def __bool__(self): """ classes/types should always be True. """ return True - def __call__(cls, value, names=None, module=None, type=None, start=1): + def __call__(self, value, names=None, module=None, type=None, start=1): """Either returns an existing member, or creates a new enum class. This method is used both when an enum class is given a value to match @@ -344,20 +332,19 @@ def __call__(cls, value, names=None, module=None, type=None, start=1): """ if names is None: # simple value lookup - return cls.__new__(cls, value) + return self.__new__(self, value) # otherwise, functional API: we're creating a new Enum type - return cls._create_(value, names, module=module, type=type, start=start) + return self._create_(value, names, module=module, type=type, start=start) - def __contains__(cls, member): - return isinstance(member, cls) and member.name in cls._member_map_ + def __contains__(self, member): + return isinstance(member, self) and member.name in self._member_map_ - def __delattr__(cls, attr): + def __delattr__(self, attr): # nicer error message when someone tries to delete an attribute # (see issue19025). - if attr in cls._member_map_: - raise AttributeError( - "%s: cannot delete Enum member." % cls.__name__) - super(EnumMeta, cls).__delattr__(attr) + if attr in self._member_map_: + raise AttributeError(f"{self.__name__}: cannot delete Enum member.") + super(EnumMeta, self).__delattr__(attr) def __dir__(self): return (['__class__', '__doc__', '__members__', '__module__'] + @@ -373,7 +360,7 @@ def __members__(cls): """ return cls._member_map_.copy() - def __getattr__(cls, name): + def __getattr__(self, name): """Return the enum member matching `name` We use __getattr__ instead of descriptors or inserting into the enum @@ -385,28 +372,28 @@ def __getattr__(cls, name): if _is_dunder(name): raise AttributeError(name) try: - return cls._member_map_[name] + return self._member_map_[name] except KeyError: raise AttributeError(name) - def __getitem__(cls, name): - return cls._member_map_[name] + def __getitem__(self, name): + return self._member_map_[name] - def __iter__(cls): + def __iter__(self): return (cls._member_map_[name] for name in cls._member_names_) - def __reversed__(cls): + def __reversed__(self): return (cls._member_map_[name] for name in reversed(cls._member_names_)) - def __len__(cls): - return len(cls._member_names_) + def __len__(self): + return len(self._member_names_) __nonzero__ = __bool__ - def __repr__(cls): - return "" % cls.__name__ + def __repr__(self): + return "" % self.__name__ - def __setattr__(cls, name, value): + def __setattr__(self, name, value): """Block attempts to reassign Enum members. A simple assignment to the class namespace only changes one of the @@ -414,12 +401,12 @@ def __setattr__(cls, name, value): resulting in an inconsistent Enumeration. """ - member_map = cls.__dict__.get('_member_map_', {}) + member_map = self.__dict__.get('_member_map_', {}) if name in member_map: raise AttributeError('Cannot reassign members.') - super(EnumMeta, cls).__setattr__(name, value) + super(EnumMeta, self).__setattr__(name, value) - def _create_(cls, class_name, names=None, module=None, type=None, start=1): + def _create_(self, class_name, names=None, module=None, type=None, start=1): """Convenience method to create a new Enum class. `names` can be: @@ -432,17 +419,13 @@ def _create_(cls, class_name, names=None, module=None, type=None, start=1): """ if pyver < 3.0: - # if class_name is unicode, attempt a conversion to ASCII if isinstance(class_name, unicode): try: class_name = class_name.encode('ascii') except UnicodeEncodeError: raise TypeError('%r is not representable in ASCII' % class_name) - metacls = cls.__class__ - if type is None: - bases = (cls, ) - else: - bases = (type, cls) + metacls = self.__class__ + bases = (self, ) if type is None else (type, self) classdict = metacls.__prepare__(class_name, bases) _order_ = [] @@ -520,9 +503,8 @@ def _get_mixins_(bases): if issubclass(base, Enum): if first_enum is None: first_enum = base - else: - if member_type is None: - member_type = base + elif member_type is None: + member_type = base return member_type, first_enum @@ -545,10 +527,7 @@ def _find_new_(classdict, member_type, first_enum): N__new__ = getattr(None, '__new__') O__new__ = getattr(object, '__new__') - if Enum is None: - E__new__ = N__new__ - else: - E__new__ = Enum.__dict__['__new__'] + E__new__ = N__new__ if Enum is None else Enum.__dict__['__new__'] # check all possibles for __member_new__ before falling back to # __new__ for method in ('__member_new__', '__new__'): @@ -578,11 +557,7 @@ def _find_new_(classdict, member_type, first_enum): # if a non-object.__new__ is used then whatever value/tuple was # assigned to the enum member name will be passed to __new__ and to the # new enum member's __init__ - if __new__ is object.__new__: - use_args = False - else: - use_args = True - + use_args = __new__ is not object.__new__ return __new__, False, use_args else: @staticmethod @@ -624,11 +599,7 @@ def _find_new_(classdict, member_type, first_enum): # if a non-object.__new__ is used then whatever value/tuple was # assigned to the enum member name will be passed to __new__ and to the # new enum member's __init__ - if __new__ is object.__new__: - use_args = False - else: - use_args = True - + use_args = __new__ is not object.__new__ return __new__, save_new, use_args @@ -638,8 +609,9 @@ def _find_new_(classdict, member_type, first_enum): # and then use the `type(name, bases, dict)` method to # create the class. ######################################################## -temp_enum_dict = {} -temp_enum_dict['__doc__'] = "Generic enumeration.\n\n Derive from this class to define new enumerations.\n\n" +temp_enum_dict = { + '__doc__': "Generic enumeration.\n\n Derive from this class to define new enumerations.\n\n" +} def __new__(cls, value): # all enum instances are actually created during class construction @@ -659,7 +631,7 @@ def __new__(cls, value): for member in cls._member_map_.values(): if member.value == value: return member - raise ValueError("%s is not a valid %s" % (value, cls.__name__)) + raise ValueError(f"{value} is not a valid {cls.__name__}") temp_enum_dict['__new__'] = __new__ del __new__ @@ -670,7 +642,7 @@ def __repr__(self): del __repr__ def __str__(self): - return "%s.%s" % (self.__class__.__name__, self._name_) + return f"{self.__class__.__name__}.{self._name_}" temp_enum_dict['__str__'] = __str__ del __str__ @@ -711,48 +683,49 @@ def __format__(self, format_spec): def __cmp__(self, other): if type(other) is self.__class__: - if self is other: - return 0 - return -1 + return 0 if self is other else -1 return NotImplemented - raise TypeError("unorderable types: %s() and %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__cmp__'] = __cmp__ del __cmp__ else: def __le__(self, other): - raise TypeError("unorderable types: %s() <= %s()" % (self.__class__.__name__, other.__class__.__name__)) + raise TypeError( + f"unorderable types: {self.__class__.__name__}() <= {other.__class__.__name__}()" + ) temp_enum_dict['__le__'] = __le__ del __le__ def __lt__(self, other): - raise TypeError("unorderable types: %s() < %s()" % (self.__class__.__name__, other.__class__.__name__)) + raise TypeError( + f"unorderable types: {self.__class__.__name__}() < {other.__class__.__name__}()" + ) temp_enum_dict['__lt__'] = __lt__ del __lt__ def __ge__(self, other): - raise TypeError("unorderable types: %s() >= %s()" % (self.__class__.__name__, other.__class__.__name__)) + raise TypeError( + f"unorderable types: {self.__class__.__name__}() >= {other.__class__.__name__}()" + ) temp_enum_dict['__ge__'] = __ge__ del __ge__ def __gt__(self, other): - raise TypeError("unorderable types: %s() > %s()" % (self.__class__.__name__, other.__class__.__name__)) + raise TypeError( + f"unorderable types: {self.__class__.__name__}() > {other.__class__.__name__}()" + ) temp_enum_dict['__gt__'] = __gt__ del __gt__ def __eq__(self, other): - if type(other) is self.__class__: - return self is other - return NotImplemented + return self is other if type(other) is self.__class__ else NotImplemented temp_enum_dict['__eq__'] = __eq__ del __eq__ def __ne__(self, other): - if type(other) is self.__class__: - return self is not other - return NotImplemented + return self is not other if type(other) is self.__class__ else NotImplemented temp_enum_dict['__ne__'] = __ne__ del __ne__ @@ -796,14 +769,11 @@ def _convert(cls, name, module, filter, source=None): # also, replace the __reduce_ex__ method so unpickling works in # previous Python versions module_globals = vars(_sys.modules[module]) - if source: - source = vars(source) - else: - source = module_globals - members = dict((name, value) for name, value in source.items() if filter(name)) + source = vars(source) if source else module_globals + members = {name: value for name, value in source.items() if filter(name)} cls = cls(name, members, module=module) cls.__reduce_ex__ = _reduce_ex_by_name - module_globals.update(cls.__members__) + module_globals |= cls.__members__ module_globals[name] = cls return cls temp_enum_dict['_convert'] = _convert @@ -823,14 +793,14 @@ def _reduce_ex_by_name(self, proto): def unique(enumeration): """Class decorator that ensures only unique members exist in an enumeration.""" - duplicates = [] - for name, member in enumeration.__members__.items(): - if name != member.name: - duplicates.append((name, member.name)) - if duplicates: + if duplicates := [ + (name, member.name) + for name, member in enumeration.__members__.items() + if name != member.name + ]: duplicate_names = ', '.join( - ["%s -> %s" % (alias, name) for (alias, name) in duplicates] - ) + [f"{alias} -> {name}" for (alias, name) in duplicates] + ) raise ValueError('duplicate names found in %r: %s' % (enumeration, duplicate_names) ) diff --git a/serverless-lambda/vendored/external/org_python_pypi_backports_weakref/backports/weakref.py b/serverless-lambda/vendored/external/org_python_pypi_backports_weakref/backports/weakref.py index 0052fef..3e6b5da 100644 --- a/serverless-lambda/vendored/external/org_python_pypi_backports_weakref/backports/weakref.py +++ b/serverless-lambda/vendored/external/org_python_pypi_backports_weakref/backports/weakref.py @@ -95,8 +95,7 @@ def atexit(self): @atexit.setter def atexit(self, value): - info = self._registry.get(self) - if info: + if info := self._registry.get(self): info.atexit = bool(value) def __repr__(self): diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor.py index b1f3ca3..0ac12a8 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor.py @@ -61,12 +61,10 @@ class TypeTransformationError(Error): # and make it return True when the descriptor is an instance of the extension # type written in C++. class DescriptorMetaclass(type): - def __instancecheck__(cls, obj): - if super(DescriptorMetaclass, cls).__instancecheck__(obj): + def __instancecheck__(self, obj): + if super(DescriptorMetaclass, self).__instancecheck__(obj): return True - if isinstance(obj, cls._C_DESCRIPTOR_CLASS): - return True - return False + return isinstance(obj, self._C_DESCRIPTOR_CLASS) else: # The standard metaclass; nothing changes. DescriptorMetaclass = type @@ -127,8 +125,7 @@ def GetOptions(self): try: options_class = getattr(descriptor_pb2, self._options_class_name) except AttributeError: - raise RuntimeError('Unknown options class name %s!' % - (self._options_class_name)) + raise RuntimeError(f'Unknown options class name {self._options_class_name}!') self._options = options_class() return self._options @@ -283,30 +280,29 @@ def __init__(self, name, full_name, filename, containing_type, fields, self.fields = fields for field in self.fields: field.containing_type = self - self.fields_by_number = dict((f.number, f) for f in fields) - self.fields_by_name = dict((f.name, f) for f in fields) + self.fields_by_number = {f.number: f for f in fields} + self.fields_by_name = {f.name: f for f in fields} self._fields_by_camelcase_name = None self.nested_types = nested_types for nested_type in nested_types: nested_type.containing_type = self - self.nested_types_by_name = dict((t.name, t) for t in nested_types) + self.nested_types_by_name = {t.name: t for t in nested_types} self.enum_types = enum_types for enum_type in self.enum_types: enum_type.containing_type = self - self.enum_types_by_name = dict((t.name, t) for t in enum_types) - self.enum_values_by_name = dict( - (v.name, v) for t in enum_types for v in t.values) + self.enum_types_by_name = {t.name: t for t in enum_types} + self.enum_values_by_name = {v.name: v for t in enum_types for v in t.values} self.extensions = extensions for extension in self.extensions: extension.extension_scope = self - self.extensions_by_name = dict((f.name, f) for f in extensions) + self.extensions_by_name = {f.name: f for f in extensions} self.is_extendable = is_extendable self.extension_ranges = extension_ranges self.oneofs = oneofs if oneofs is not None else [] - self.oneofs_by_name = dict((o.name, o) for o in self.oneofs) + self.oneofs_by_name = {o.name: o for o in self.oneofs} for oneof in self.oneofs: oneof.containing_type = self self.syntax = syntax or "proto2" @@ -314,8 +310,7 @@ def __init__(self, name, full_name, filename, containing_type, fields, @property def fields_by_camelcase_name(self): if self._fields_by_camelcase_name is None: - self._fields_by_camelcase_name = dict( - (f.camelcase_name, f) for f in self.fields) + self._fields_by_camelcase_name = {f.camelcase_name: f for f in self.fields} return self._fields_by_camelcase_name def EnumValueName(self, enum, value): @@ -517,10 +512,7 @@ def __init__(self, name, full_name, index, number, type, cpp_type, label, self.full_name = full_name self.file = file self._camelcase_name = None - if json_name is None: - self.json_name = _ToJsonName(name) - else: - self.json_name = json_name + self.json_name = _ToJsonName(name) if json_name is None else json_name self.index = index self.number = number self.type = type @@ -566,7 +558,7 @@ def ProtoTypeToCppProtoType(proto_type): try: return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type] except KeyError: - raise TypeTransformationError('Unknown proto_type: %s' % proto_type) + raise TypeTransformationError(f'Unknown proto_type: {proto_type}') class EnumDescriptor(_NestedDescriptorBase): @@ -619,8 +611,8 @@ def __init__(self, name, full_name, filename, values, self.values = values for value in self.values: value.type = self - self.values_by_name = dict((v.name, v) for v in values) - self.values_by_number = dict((v.number, v) for v in values) + self.values_by_name = {v.name: v for v in values} + self.values_by_number = {v.number: v for v in values} def CopyToProto(self, proto): """Copies this to a descriptor_pb2.EnumDescriptorProto. @@ -734,7 +726,7 @@ def __init__(self, name, full_name, index, methods, options=None, file=None, serialized_end=serialized_end) self.index = index self.methods = methods - self.methods_by_name = dict((m.name, m) for m in methods) + self.methods_by_name = {m.name: m for m in methods} # Set the containing service for each method in this service. for method in self.methods: method.containing_service = self @@ -956,10 +948,10 @@ def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True, if package: file_descriptor_proto.name = os.path.join(package.replace('.', '/'), - proto_name + '.proto') + f'{proto_name}.proto') file_descriptor_proto.package = package else: - file_descriptor_proto.name = proto_name + '.proto' + file_descriptor_proto.name = f'{proto_name}.proto' _message.default_pool.Add(file_descriptor_proto) result = _message.default_pool.FindFileByName(file_descriptor_proto.name) @@ -997,10 +989,7 @@ def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True, full_name = '.'.join(full_message_name + [field_proto.name]) enum_desc = None nested_desc = None - if field_proto.json_name: - json_name = field_proto.json_name - else: - json_name = None + json_name = field_proto.json_name if field_proto.json_name else None if field_proto.HasField('type_name'): type_name = field_proto.type_name full_type_name = '.'.join(full_message_name + diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_database.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_database.py index eb45e12..ea0d73f 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_database.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_database.py @@ -63,7 +63,7 @@ def Add(self, file_desc_proto): self._file_desc_protos_by_file[proto_name] = file_desc_proto elif self._file_desc_protos_by_file[proto_name] != file_desc_proto: raise DescriptorDatabaseConflictingDefinitionError( - '%s already added, but with different descriptor.' % proto_name) + f'{proto_name} already added, but with different descriptor.') # Add all the top-level descriptors to the index. package = file_desc_proto.package @@ -134,10 +134,9 @@ def _ExtractSymbols(desc_proto, package): Yields: The fully qualified name found in the descriptor. """ - message_name = package + '.' + desc_proto.name if package else desc_proto.name + message_name = f'{package}.{desc_proto.name}' if package else desc_proto.name yield message_name for nested_type in desc_proto.nested_type: - for symbol in _ExtractSymbols(nested_type, message_name): - yield symbol + yield from _ExtractSymbols(nested_type, message_name) for enum_type in desc_proto.enum_type: yield '.'.join((message_name, enum_type.name)) diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_pool.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_pool.py index 3dbe0fd..49fada9 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_pool.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/descriptor_pool.py @@ -301,7 +301,7 @@ def FindFileByName(self, file_name): else: raise error if not file_proto: - raise KeyError('Cannot find a file named %s' % file_name) + raise KeyError(f'Cannot find a file named {file_name}') return self._ConvertFileProtoToFileDescriptor(file_proto) def FindFileContainingSymbol(self, symbol): @@ -350,7 +350,7 @@ def FindFileContainingSymbol(self, symbol): assert message.extensions_by_name[extension_name] return message.file except KeyError: - raise KeyError('Cannot find a file containing %s' % symbol) + raise KeyError(f'Cannot find a file containing {symbol}') def FindMessageTypeByName(self, full_name): """Loads the named descriptor from the pool. @@ -505,7 +505,7 @@ def _FindFileContainingSymbolInDb(self, symbol): else: raise error if not file_proto: - raise KeyError('Cannot find a file containing %s' % symbol) + raise KeyError(f'Cannot find a file containing {symbol}') return self._ConvertFileProtoToFileDescriptor(file_proto) def _ConvertFileProtoToFileDescriptor(self, file_proto): @@ -542,8 +542,7 @@ def _ConvertFileProtoToFileDescriptor(self, file_proto): # scope of available message types when defining the passed in # file proto. for dependency in built_deps: - scope.update(self._ExtractSymbols( - dependency.message_types_by_name.values())) + scope |= self._ExtractSymbols(dependency.message_types_by_name.values()) scope.update((_PrefixWithDot(enum.full_name), enum) for enum in dependency.enum_types_by_name.values()) @@ -613,11 +612,7 @@ def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, else: desc_name = desc_proto.name - if file_desc is None: - file_name = None - else: - file_name = file_desc.name - + file_name = None if file_desc is None else file_desc.name if scope is None: scope = {} @@ -639,10 +634,7 @@ def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, index, None, [], desc.options) for index, desc in enumerate(desc_proto.oneof_decl)] extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range] - if extension_ranges: - is_extendable = True - else: - is_extendable = False + is_extendable = bool(extension_ranges) desc = descriptor.Descriptor( name=desc_proto.name, full_name=desc_name, @@ -694,11 +686,7 @@ def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, else: enum_name = enum_proto.name - if file_desc is None: - file_name = None - else: - file_name = file_desc.name - + file_name = None if file_desc is None else file_desc.name values = [self._MakeEnumValueDescriptor(value, index) for index, value in enumerate(enum_proto.value)] desc = descriptor.EnumDescriptor(name=enum_proto.name, @@ -708,7 +696,7 @@ def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, values=values, containing_type=containing_type, options=_OptionsOrNone(enum_proto)) - scope['.%s' % enum_name] = desc + scope[f'.{enum_name}'] = desc self._enum_descriptors[enum_name] = desc return desc @@ -811,8 +799,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType( field_proto.type) - if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE - or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_MESSAGE, + descriptor.FieldDescriptor.TYPE_GROUP, + ]: field_desc.message_type = desc if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: @@ -823,8 +813,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.default_value = [] elif field_proto.HasField('default_value'): field_desc.has_default_value = True - if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or - field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_DOUBLE, + descriptor.FieldDescriptor.TYPE_FLOAT, + ]: field_desc.default_value = float(field_proto.default_value) elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: field_desc.default_value = field_proto.default_value @@ -841,8 +833,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.default_value = int(field_proto.default_value) else: field_desc.has_default_value = False - if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or - field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_DOUBLE, + descriptor.FieldDescriptor.TYPE_FLOAT, + ]: field_desc.default_value = 0.0 elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: field_desc.default_value = u'' @@ -946,8 +940,7 @@ def _ExtractSymbols(self, descriptors): for desc in descriptors: yield (_PrefixWithDot(desc.full_name), desc) - for symbol in self._ExtractSymbols(desc.nested_types): - yield symbol + yield from self._ExtractSymbols(desc.nested_types) for enum in desc.enum_types: yield (_PrefixWithDot(enum.full_name), enum) @@ -964,8 +957,7 @@ def _GetDeps(self, dependencies): for dependency in dependencies: dep_desc = self.FindFileByName(dependency) yield dep_desc - for parent_dep in dep_desc.dependencies: - yield parent_dep + yield from dep_desc.dependencies def _GetTypeFromScope(self, package, type_name, scope): """Finds a given type name in the current scope. @@ -991,7 +983,7 @@ def _GetTypeFromScope(self, package, type_name, scope): def _PrefixWithDot(name): - return name if name.startswith('.') else '.%s' % name + return name if name.startswith('.') else f'.{name}' if _USE_C_DESCRIPTORS: diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/_parameterized.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/_parameterized.py index 23a78f0..fa808dc 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/_parameterized.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/_parameterized.py @@ -170,7 +170,7 @@ def _CleanRepr(obj): # Helper function formerly from the unittest module, removed from it in # Python 2.7. def _StrClass(cls): - return '%s.%s' % (cls.__module__, cls.__name__) + return f'{cls.__module__}.{cls.__name__}' def _NonStringIterable(obj): @@ -180,7 +180,7 @@ def _NonStringIterable(obj): def _FormatParameterList(testcase_params): if isinstance(testcase_params, collections.Mapping): - return ', '.join('%s=%s' % (argname, _CleanRepr(value)) + return ', '.join(f'{argname}={_CleanRepr(value)}' for argname, value in testcase_params.items()) elif _NonStringIterable(testcase_params): return ', '.join(map(_CleanRepr, testcase_params)) @@ -240,16 +240,16 @@ def BoundParamTest(self): # method of TestGeneratorMetaclass. # The metaclass will make sure to create a unique, but nondescriptive # name for this test. - BoundParamTest.__x_extra_id__ = '(%s)' % ( - _FormatParameterList(testcase_params),) + BoundParamTest.__x_extra_id__ = f'({_FormatParameterList(testcase_params)})' else: - raise RuntimeError('%s is not a valid naming type.' % (naming_type,)) + raise RuntimeError(f'{naming_type} is not a valid naming type.') - BoundParamTest.__doc__ = '%s(%s)' % ( - BoundParamTest.__name__, _FormatParameterList(testcase_params)) + BoundParamTest.__doc__ = ( + f'{BoundParamTest.__name__}({_FormatParameterList(testcase_params)})') if test_method.__doc__: BoundParamTest.__doc__ += '\n%s' % (test_method.__doc__,) return BoundParamTest + return (MakeBoundParamTest(c) for c in self.testcases) @@ -351,7 +351,7 @@ class TestGeneratorMetaclass(type): Parameters decorator. """ - def __new__(mcs, class_name, bases, dct): + def __new__(cls, class_name, bases, dct): dct['_id_suffix'] = id_suffix = {} for name, obj in dct.items(): if (name.startswith(unittest.TestLoader.testMethodPrefix) and @@ -360,7 +360,7 @@ def __new__(mcs, class_name, bases, dct): dct.pop(name) _UpdateClassDictForParamTestCase(dct, id_suffix, name, iterator) - return type.__new__(mcs, class_name, bases, dct) + return type.__new__(cls, class_name, bases, dct) def _UpdateClassDictForParamTestCase(dct, id_suffix, name, iterator): @@ -379,8 +379,9 @@ def _UpdateClassDictForParamTestCase(dct, id_suffix, name, iterator): new_name = func.__name__ else: new_name = '%s%s%d' % (name, _SEPARATOR, idx) - assert new_name not in dct, ( - 'Name of parameterized test case "%s" not unique' % (new_name,)) + assert ( + new_name + not in dct), f'Name of parameterized test case "{new_name}" not unique' dct[new_name] = func id_suffix[new_name] = getattr(func, '__x_extra_id__', '') @@ -393,7 +394,7 @@ def _OriginalName(self): return self._testMethodName.split(_SEPARATOR)[0] def __str__(self): - return '%s (%s)' % (self._OriginalName(), _StrClass(self.__class__)) + return f'{self._OriginalName()} ({_StrClass(self.__class__)})' def id(self): # pylint: disable=invalid-name """Returns the descriptive ID of the test. @@ -404,9 +405,7 @@ def id(self): # pylint: disable=invalid-name Returns: The test id. """ - return '%s.%s%s' % (_StrClass(self.__class__), - self._OriginalName(), - self._id_suffix.get(self._testMethodName, '')) + return f"{_StrClass(self.__class__)}.{self._OriginalName()}{self._id_suffix.get(self._testMethodName, '')}" def CoopParameterizedTestCase(other_base_class): diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/containers.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/containers.py index 68be9e5..b9927a6 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/containers.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/containers.py @@ -147,8 +147,8 @@ def clear(self): def update(*args, **kwds): if len(args) > 2: - raise TypeError("update() takes at most 2 positional " - "arguments ({} given)".format(len(args))) + raise TypeError( + f"update() takes at most 2 positional arguments ({len(args)} given)") elif not args: raise TypeError("update() takes at least 1 argument (0 given)") self = args[0] @@ -272,8 +272,9 @@ def extend(self, elem_seq): return raise - new_values = [self._type_checker.CheckValue(elem) for elem in elem_seq_iter] - if new_values: + if new_values := [ + self._type_checker.CheckValue(elem) for elem in elem_seq_iter + ]: self._values.extend(new_values) self._message_listener.Modified() @@ -311,9 +312,7 @@ def __getslice__(self, start, stop): def __setslice__(self, start, stop, values): """Sets the subset of items from between the specified indices.""" - new_values = [] - for value in values: - new_values.append(self._type_checker.CheckValue(value)) + new_values = [self._type_checker.CheckValue(value) for value in values] self._values[start:stop] = new_values self._message_listener.Modified() @@ -477,10 +476,7 @@ def __contains__(self, item): # will make the default implementation (from our base class) always insert # the key. def get(self, key, default=None): - if key in self: - return self[key] - else: - return default + return self[key] if key in self else default def __setitem__(self, key, value): checked_key = self._key_checker.CheckValue(key) @@ -578,10 +574,7 @@ def get_or_create(self, key): # will make the default implementation (from our base class) always insert # the key. def get(self, key, default=None): - if key in self: - return self[key] - else: - return default + return self[key] if key in self else default def __contains__(self, item): return item in self._values diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/decoder.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/decoder.py index ff3e6d3..3144b86 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/decoder.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/decoder.py @@ -305,7 +305,7 @@ def InnerDecode(buffer, pos): # To avoid that, we parse it specially. if (float_bytes[3:4] in b'\x7F\xFF' and float_bytes[2:3] >= b'\x80'): # If at least one significand bit is set... - if float_bytes[0:3] != b'\x00\x00\x80': + if float_bytes[:3] != b'\x00\x00\x80': return (_NAN, new_pos) # If sign bit is set... if float_bytes[3:4] == b'\xFF': @@ -317,6 +317,7 @@ def InnerDecode(buffer, pos): # handling blocks every time we parse one value. result = local_unpack('= b'\xF0') - and (double_bytes[0:7] != b'\x00\x00\x00\x00\x00\x00\xF0')): + if (double_bytes[7:8] in b'\x7F\xFF' and double_bytes[6:7] >= b'\xF0' + and double_bytes[:7] != b'\x00\x00\x00\x00\x00\x00\xF0'): return (_NAN, new_pos) # Note that we expect someone up-stack to catch struct.error and convert @@ -347,6 +347,7 @@ def InnerDecode(buffer, pos): # handling blocks every time we parse one value. result = local_unpack(' 0: - return result + 1 - else: - return result + return result + 1 if result < 0 and remainder > 0 else result class FieldMask(object): @@ -395,9 +389,7 @@ class FieldMask(object): def ToJsonString(self): """Converts FieldMask to string according to proto3 JSON spec.""" - camelcase_paths = [] - for path in self.paths: - camelcase_paths.append(_SnakeCaseToCamelCase(path)) + camelcase_paths = [_SnakeCaseToCamelCase(path) for path in self.paths] return ','.join(camelcase_paths) def FromJsonString(self, value): @@ -408,10 +400,7 @@ def FromJsonString(self, value): def IsValidForDescriptor(self, message_descriptor): """Checks whether the FieldMask is valid for Message Descriptor.""" - for path in self.paths: - if not _IsValidPath(message_descriptor, path): - return False - return True + return all(_IsValidPath(message_descriptor, path) for path in self.paths) def AllFieldsFromDescriptor(self, message_descriptor): """Gets all direct fields of Message Descriptor to FieldMask.""" @@ -500,13 +489,12 @@ def _SnakeCaseToCamelCase(path_name): raise Error('Fail to print FieldMask to Json string: Path name ' '{0} must not contain uppercase letters.'.format(path_name)) if after_underscore: - if c.islower(): - result.append(c.upper()) - after_underscore = False - else: + if not c.islower(): raise Error('Fail to print FieldMask to Json string: The ' 'character after a "_" must be a lowercase letter ' 'in path name {0}.'.format(path_name)) + result.append(c.upper()) + after_underscore = False elif c == '_': after_underscore = True else: @@ -609,7 +597,7 @@ def AddLeafNodes(self, prefix, node): if not node: self.AddPath(prefix) for name in node: - child_path = prefix + '.' + name + child_path = f'{prefix}.{name}' self.AddLeafNodes(child_path, node[name]) def MergeMessage( @@ -625,9 +613,7 @@ def _StrConvert(value): # This file is imported by c extension and some methods like ClearField # requires string for the field name. py2/py3 has different text # type and may use unicode. - if not isinstance(value, str): - return value.encode('utf-8') - return value + return value.encode('utf-8') if not isinstance(value, str) else value def _MergeMessage( @@ -661,14 +647,13 @@ def _MergeMessage( repeated_destination.add().MergeFrom(item) else: repeated_destination.extend(repeated_source) + elif field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE: + if replace_message: + destination.ClearField(_StrConvert(name)) + if source.HasField(name): + getattr(destination, name).MergeFrom(getattr(source, name)) else: - if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE: - if replace_message: - destination.ClearField(_StrConvert(name)) - if source.HasField(name): - getattr(destination, name).MergeFrom(getattr(source, name)) - else: - setattr(destination, name, getattr(source, name)) + setattr(destination, name, getattr(source, name)) def _AddFieldPaths(node, prefix, field_mask): @@ -677,10 +662,7 @@ def _AddFieldPaths(node, prefix, field_mask): field_mask.paths.append(prefix) return for name in sorted(node): - if prefix: - child_path = prefix + '.' + name - else: - child_path = name + child_path = f'{prefix}.{name}' if prefix else name _AddFieldPaths(node[name], child_path, field_mask) diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/wire_format.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/wire_format.py index 883f525..fad5b5b 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/wire_format.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/internal/wire_format.py @@ -102,16 +102,12 @@ def ZigZagEncode(value): effectively used with varint encoding. See wire_format.h for more details. """ - if value >= 0: - return value << 1 - return (value << 1) ^ (~0) + return value << 1 if value >= 0 else (value << 1) ^ (~0) def ZigZagDecode(value): """Inverse of ZigZagEncode().""" - if not value & 0x1: - return value >> 1 - return (value >> 1) ^ (~0) + return value >> 1 if not value & 0x1 else (value >> 1) ^ (~0) diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/json_format.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/json_format.py index 801eed6..af6cc09 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/json_format.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/json_format.py @@ -179,20 +179,14 @@ def _RegularMessageToJsonObject(self, message, js): try: for field, value in fields: - if self.preserving_proto_field_name: - name = field.name - else: - name = field.json_name + name = field.name if self.preserving_proto_field_name else field.json_name if _IsMapEntry(field): # Convert a map field. v_field = field.message_type.fields_by_name['value'] js_map = {} for key in value: if isinstance(key, bool): - if key: - recorded_key = 'true' - else: - recorded_key = 'false' + recorded_key = 'true' if key else 'false' else: recorded_key = key js_map[recorded_key] = self._FieldToJsonObject( @@ -208,7 +202,7 @@ def _RegularMessageToJsonObject(self, message, js): f.type == descriptor.FieldDescriptor.TYPE_MESSAGE and f.label == descriptor.FieldDescriptor.LABEL_OPTIONAL): f = f.message_type - name = '[%s.%s]' % (f.full_name, name) + name = f'[{f.full_name}.{name}]' js[name] = self._FieldToJsonObject(field, value) else: js[name] = self._FieldToJsonObject(field, value) @@ -222,10 +216,7 @@ def _RegularMessageToJsonObject(self, message, js): field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE) or field.containing_oneof): continue - if self.preserving_proto_field_name: - name = field.name - else: - name = field.json_name + name = field.name if self.preserving_proto_field_name else field.json_name if name in js: # Skip the field which has been serailized already. continue @@ -265,10 +256,7 @@ def _FieldToJsonObject(self, field, value): return str(value) elif field.cpp_type in _FLOAT_TYPES: if math.isinf(value): - if value < 0.0: - return _NEG_INFINITY - else: - return _INFINITY + return _NEG_INFINITY if value < 0.0 else _INFINITY if math.isnan(value): return _NAN return value @@ -324,10 +312,7 @@ def _ListValueMessageToJsonObject(self, message): def _StructMessageToJsonObject(self, message): """Converts Struct message according to Proto3 JSON Specification.""" fields = message.fields - ret = {} - for key in fields: - ret[key] = self._ValueMessageToJsonObject(fields[key]) - return ret + return {key: self._ValueMessageToJsonObject(fields[key]) for key in fields} def _WrapperMessageToJsonObject(self, message): return self._FieldToJsonObject( @@ -444,8 +429,7 @@ def _ConvertFieldValuePair(self, js, message): """ names = [] message_descriptor = message.DESCRIPTOR - fields_by_json_name = dict((f.json_name, f) - for f in message_descriptor.fields) + fields_by_json_name = {f.json_name: f for f in message_descriptor.fields} for name in js: try: field = fields_by_json_name.get(name, None) @@ -533,9 +517,7 @@ def _ConvertFieldValuePair(self, js, message): raise ParseError('Failed to parse {0} field: {1}'.format(name, e)) else: raise ParseError(str(e)) - except ValueError as e: - raise ParseError('Failed to parse {0} field: {1}.'.format(name, e)) - except TypeError as e: + except (ValueError, TypeError) as e: raise ParseError('Failed to parse {0} field: {1}.'.format(name, e)) def _ConvertAnyMessage(self, value, message): @@ -658,12 +640,11 @@ def _ConvertScalarFieldValue(value, field, require_str=False): elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING: if field.type == descriptor.FieldDescriptor.TYPE_BYTES: return base64.b64decode(value) - else: - # Checking for unpaired surrogates appears to be unreliable, - # depending on the specific Python version, so we check manually. - if _UNPAIRED_SURROGATE_PATTERN.search(value): - raise ParseError('Unpaired surrogate') - return value + # Checking for unpaired surrogates appears to be unreliable, + # depending on the specific Python version, so we check manually. + if _UNPAIRED_SURROGATE_PATTERN.search(value): + raise ParseError('Unpaired surrogate') + return value elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM: # Convert an enum value. enum_value = field.enum_type.values_by_name.get(value, None) @@ -674,9 +655,9 @@ def _ConvertScalarFieldValue(value, field, require_str=False): except ValueError: raise ParseError('Invalid enum value {0} for enum type {1}.'.format( value, field.enum_type.full_name)) - if enum_value is None: - raise ParseError('Invalid enum value {0} for enum type {1}.'.format( - value, field.enum_type.full_name)) + if enum_value is None: + raise ParseError('Invalid enum value {0} for enum type {1}.'.format( + value, field.enum_type.full_name)) return enum_value.number diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/proto_builder.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/proto_builder.py index 736caed..6702216 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/proto_builder.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/proto_builder.py @@ -42,7 +42,7 @@ def _GetMessageFromFactory(factory, full_name): - """Get a proto class from the MessageFactory by name. + """Get a proto class from the MessageFactory by name. Args: factory: a MessageFactory instance. @@ -52,13 +52,12 @@ def _GetMessageFromFactory(factory, full_name): Raises: KeyError, if the proto is not found in the factory's descriptor pool. """ - proto_descriptor = factory.pool.FindMessageTypeByName(full_name) - proto_cls = factory.GetPrototype(proto_descriptor) - return proto_cls + proto_descriptor = factory.pool.FindMessageTypeByName(full_name) + return factory.GetPrototype(proto_descriptor) def MakeSimpleProtoClass(fields, full_name=None, pool=None): - """Create a Protobuf class whose fields are basic types. + """Create a Protobuf class whose fields are basic types. Note: this doesn't validate field names! @@ -71,46 +70,44 @@ def MakeSimpleProtoClass(fields, full_name=None, pool=None): Returns: a class, the new protobuf class with a FileDescriptor. """ - factory = message_factory.MessageFactory(pool=pool) - - if full_name is not None: - try: - proto_cls = _GetMessageFromFactory(factory, full_name) - return proto_cls - except KeyError: - # The factory's DescriptorPool doesn't know about this class yet. - pass - - # Get a list of (name, field_type) tuples from the fields dict. If fields was - # an OrderedDict we keep the order, but otherwise we sort the field to ensure - # consistent ordering. - field_items = fields.items() - if not isinstance(fields, OrderedDict): - field_items = sorted(field_items) - - # Use a consistent file name that is unlikely to conflict with any imported - # proto files. - fields_hash = hashlib.sha1() - for f_name, f_type in field_items: - fields_hash.update(f_name.encode('utf-8')) - fields_hash.update(str(f_type).encode('utf-8')) - proto_file_name = fields_hash.hexdigest() + '.proto' - - # If the proto is anonymous, use the same hash to name it. - if full_name is None: - full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' + - fields_hash.hexdigest()) - try: - proto_cls = _GetMessageFromFactory(factory, full_name) - return proto_cls - except KeyError: - # The factory's DescriptorPool doesn't know about this class yet. - pass - - # This is the first time we see this proto: add a new descriptor to the pool. - factory.pool.Add( - _MakeFileDescriptorProto(proto_file_name, full_name, field_items)) - return _GetMessageFromFactory(factory, full_name) + factory = message_factory.MessageFactory(pool=pool) + + if full_name is not None: + try: + return _GetMessageFromFactory(factory, full_name) + except KeyError: + # The factory's DescriptorPool doesn't know about this class yet. + pass + + # Get a list of (name, field_type) tuples from the fields dict. If fields was + # an OrderedDict we keep the order, but otherwise we sort the field to ensure + # consistent ordering. + field_items = fields.items() + if not isinstance(fields, OrderedDict): + field_items = sorted(field_items) + + # Use a consistent file name that is unlikely to conflict with any imported + # proto files. + fields_hash = hashlib.sha1() + for f_name, f_type in field_items: + fields_hash.update(f_name.encode('utf-8')) + fields_hash.update(str(f_type).encode('utf-8')) + proto_file_name = f'{fields_hash.hexdigest()}.proto' + + # If the proto is anonymous, use the same hash to name it. + if full_name is None: + full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' + + fields_hash.hexdigest()) + try: + return _GetMessageFromFactory(factory, full_name) + except KeyError: + # The factory's DescriptorPool doesn't know about this class yet. + pass + + # This is the first time we see this proto: add a new descriptor to the pool. + factory.pool.Add( + _MakeFileDescriptorProto(proto_file_name, full_name, field_items)) + return _GetMessageFromFactory(factory, full_name) def _MakeFileDescriptorProto(proto_file_name, full_name, field_items): diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/reflection.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/reflection.py index f4ce8ca..91f8f7a 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/reflection.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/reflection.py @@ -109,10 +109,10 @@ class Child(message.Message): if descriptor in MESSAGE_CLASS_CACHE: return MESSAGE_CLASS_CACHE[descriptor] - attributes = {} - for name, nested_type in descriptor.nested_types_by_name.items(): - attributes[name] = MakeClass(nested_type) - + attributes = { + name: MakeClass(nested_type) + for name, nested_type in descriptor.nested_types_by_name.items() + } attributes[GeneratedProtocolMessageType._DESCRIPTOR_KEY] = descriptor result = GeneratedProtocolMessageType( diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/service_reflection.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/service_reflection.py index 1c3636a..dc0bcfb 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/service_reflection.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/service_reflection.py @@ -61,7 +61,7 @@ class MyProtoService(service.Service): _DESCRIPTOR_KEY = 'DESCRIPTOR' - def __init__(cls, name, bases, dictionary): + def __init__(self, name, bases, dictionary): """Creates a message service class. Args: @@ -78,7 +78,7 @@ def __init__(cls, name, bases, dictionary): return descriptor = dictionary[GeneratedServiceType._DESCRIPTOR_KEY] service_builder = _ServiceBuilder(descriptor) - service_builder.BuildService(cls) + service_builder.BuildService(self) class GeneratedServiceStubType(GeneratedServiceType): @@ -91,7 +91,7 @@ class GeneratedServiceStubType(GeneratedServiceType): _DESCRIPTOR_KEY = 'DESCRIPTOR' - def __init__(cls, name, bases, dictionary): + def __init__(self, name, bases, dictionary): """Creates a message service stub class. Args: @@ -101,14 +101,14 @@ def __init__(cls, name, bases, dictionary): dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object describing this protocol service type. """ - super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary) + super(GeneratedServiceStubType, self).__init__(name, bases, dictionary) # Don't do anything if this class doesn't have a descriptor. This happens # when a service stub is subclassed. if GeneratedServiceStubType._DESCRIPTOR_KEY not in dictionary: return descriptor = dictionary[GeneratedServiceStubType._DESCRIPTOR_KEY] service_stub_builder = _ServiceStubBuilder(descriptor) - service_stub_builder.BuildServiceStub(cls) + service_stub_builder.BuildServiceStub(self) class _ServiceBuilder(object): @@ -223,7 +223,7 @@ def _NonImplementedMethod(self, method_name, rpc_controller, callback): rpc_controller: RPC controller used to execute this method. callback: A callback which will be invoked when the method finishes. """ - rpc_controller.SetFailed('Method %s not implemented.' % method_name) + rpc_controller.SetFailed(f'Method {method_name} not implemented.') callback(None) diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/symbol_database.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/symbol_database.py index 5ad869f..fcda960 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/symbol_database.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/symbol_database.py @@ -165,8 +165,7 @@ def _GetAllMessages(desc): """Walk a message Descriptor and recursively yields all message names.""" yield desc for msg_desc in desc.nested_types: - for nested_desc in _GetAllMessages(msg_desc): - yield nested_desc + yield from _GetAllMessages(msg_desc) result = {} for file_name in files: diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_encoding.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_encoding.py index 9899563..4f063da 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_encoding.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_encoding.py @@ -90,9 +90,7 @@ def CUnescape(text): def ReplaceHex(m): # Only replace the match if the number of leading back slashes is odd. i.e. # the slash itself is not escaped. - if len(m.group(1)) & 1: - return m.group(1) + 'x0' + m.group(2) - return m.group(0) + return f'{m.group(1)}x0{m.group(2)}' if len(m.group(1)) & 1 else m.group(0) # This is required because the 'string_escape' encoding doesn't # allow single-digit hex escapes (like '\xf'). diff --git a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_format.py b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_format.py index aaca78a..71e1aec 100644 --- a/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_format.py +++ b/serverless-lambda/vendored/external/protobuf_archive/python/google/protobuf/text_format.py @@ -100,10 +100,7 @@ def GetColumn(self): class TextWriter(object): def __init__(self, as_utf8): - if six.PY2: - self._writer = io.BytesIO() - else: - self._writer = io.StringIO() + self._writer = io.BytesIO() if six.PY2 else io.StringIO() def write(self, val): if six.PY2: @@ -163,9 +160,7 @@ def MessageToString(message, printer.PrintMessage(message) result = out.getvalue() out.close() - if as_one_line: - return result.rstrip() - return result + return result.rstrip() if as_one_line else result def _IsMapEntry(field): @@ -301,11 +296,10 @@ def __init__(self, def _TryPrintAsAnyMessage(self, message): """Serializes if message is a google.protobuf.Any field.""" - packed_message = _BuildMessageFromTypeName(message.TypeName(), - self.descriptor_pool) - if packed_message: + if packed_message := _BuildMessageFromTypeName(message.TypeName(), + self.descriptor_pool): packed_message.MergeFromString(message.value) - self.out.write('%s[%s]' % (self.indent * ' ', message.type_url)) + self.out.write(f"{self.indent * ' '}[{message.type_url}]") self._PrintMessageFieldValue(packed_message) self.out.write(' ' if self.as_one_line else '\n') return True @@ -359,21 +353,20 @@ def PrintField(self, field, value): out.write(' ' * self.indent) if self.use_field_number: out.write(str(field.number)) - else: - if field.is_extension: - out.write('[') - if (field.containing_type.GetOptions().message_set_wire_format and - field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and - field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL): - out.write(field.message_type.full_name) - else: - out.write(field.full_name) - out.write(']') - elif field.type == descriptor.FieldDescriptor.TYPE_GROUP: - # For groups, use the capitalized name. - out.write(field.message_type.name) + elif field.is_extension: + out.write('[') + if (field.containing_type.GetOptions().message_set_wire_format and + field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and + field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL): + out.write(field.message_type.full_name) else: - out.write(field.name) + out.write(field.full_name) + out.write(']') + elif field.type == descriptor.FieldDescriptor.TYPE_GROUP: + # For groups, use the capitalized name. + out.write(field.message_type.name) + else: + out.write(field.name) if field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE: # The colon is optional in this case, but our cross-language golden files @@ -395,7 +388,7 @@ def _PrintMessageFieldValue(self, value): closeb = '}' if self.as_one_line: - self.out.write(' %s ' % openb) + self.out.write(f' {openb} ') self.PrintMessage(value) self.out.write(closeb) else: @@ -645,8 +638,8 @@ def _MergeField(self, tokenizer, message): if not message_descriptor.is_extendable: raise tokenizer.ParseErrorPreviousToken( - 'Message type "%s" does not have extensions.' % - message_descriptor.full_name) + f'Message type "{message_descriptor.full_name}" does not have extensions.' + ) # pylint: disable=protected-access field = message.Extensions._FindExtensionByName(name) # pylint: enable=protected-access @@ -662,8 +655,8 @@ def _MergeField(self, tokenizer, message): 'that message\'s _pb2 module must be imported as well' % name) elif message_descriptor != field.containing_type: raise tokenizer.ParseErrorPreviousToken( - 'Extension "%s" does not extend message type "%s".' % - (name, message_descriptor.full_name)) + f'Extension "{name}" does not extend message type "{message_descriptor.full_name}".' + ) tokenizer.Consume(']') @@ -691,8 +684,8 @@ def _MergeField(self, tokenizer, message): if not field: raise tokenizer.ParseErrorPreviousToken( - 'Message type "%s" has no field named "%s".' % - (message_descriptor.full_name, name)) + f'Message type "{message_descriptor.full_name}" has no field named "{name}".' + ) if field: if not self._allow_multiple_scalars and field.containing_oneof: @@ -782,12 +775,11 @@ def _MergeMessageField(self, tokenizer, message, field): expanded_any_sub_message = _BuildMessageFromTypeName(packed_type_name, self.descriptor_pool) if not expanded_any_sub_message: - raise ParseError('Type %s not found in descriptor pool' % - packed_type_name) + raise ParseError(f'Type {packed_type_name} not found in descriptor pool') while not tokenizer.TryConsume(expanded_any_end_token): if tokenizer.AtEnd(): - raise tokenizer.ParseErrorPreviousToken('Expected "%s".' % - (expanded_any_end_token,)) + raise tokenizer.ParseErrorPreviousToken( + f'Expected "{expanded_any_end_token}".') self._MergeField(tokenizer, expanded_any_sub_message) if field.label == descriptor.FieldDescriptor.LABEL_REPEATED: any_message = getattr(message, field.name).add() @@ -811,7 +803,7 @@ def _MergeMessageField(self, tokenizer, message, field): while not tokenizer.TryConsume(end_token): if tokenizer.AtEnd(): - raise tokenizer.ParseErrorPreviousToken('Expected "%s".' % (end_token,)) + raise tokenizer.ParseErrorPreviousToken(f'Expected "{end_token}".') self._MergeField(tokenizer, sub_message) if is_map_entry: @@ -884,18 +876,17 @@ def _MergeScalarField(self, tokenizer, message, field): if (not self._allow_multiple_scalars and can_check_presence and message.HasExtension(field)): raise tokenizer.ParseErrorPreviousToken( - 'Message type "%s" should not have multiple "%s" extensions.' % - (message.DESCRIPTOR.full_name, field.full_name)) + f'Message type "{message.DESCRIPTOR.full_name}" should not have multiple "{field.full_name}" extensions.' + ) else: message.Extensions[field] = value - else: - if (not self._allow_multiple_scalars and can_check_presence and + elif (not self._allow_multiple_scalars and can_check_presence and message.HasField(field.name)): - raise tokenizer.ParseErrorPreviousToken( - 'Message type "%s" should not have multiple "%s" fields.' % - (message.DESCRIPTOR.full_name, field.name)) - else: - setattr(message, field.name, value) + raise tokenizer.ParseErrorPreviousToken( + f'Message type "{message.DESCRIPTOR.full_name}" should not have multiple "{field.name}" fields.' + ) + else: + setattr(message, field.name, value) def _SkipFieldContents(tokenizer): @@ -978,7 +969,7 @@ def _SkipFieldValue(tokenizer): if (not tokenizer.TryConsumeIdentifier() and not _TryConsumeInt64(tokenizer) and not _TryConsumeUint64(tokenizer) and not tokenizer.TryConsumeFloat()): - raise ParseError('Invalid field value: ' + tokenizer.token) + raise ParseError(f'Invalid field value: {tokenizer.token}') class Tokenizer(object): @@ -1076,7 +1067,7 @@ def Consume(self, token): ParseError: If the text couldn't be consumed. """ if not self.TryConsume(token): - raise self.ParseError('Expected "%s".' % token) + raise self.ParseError(f'Expected "{token}".') def ConsumeComment(self): result = self.token @@ -1141,7 +1132,7 @@ def ConsumeIdentifierOrNumber(self): """ result = self.token if not self._IDENTIFIER_OR_NUMBER.match(result): - raise self.ParseError('Expected identifier or number, got %s.' % result) + raise self.ParseError(f'Expected identifier or number, got {result}.') self.NextToken() return result @@ -1472,10 +1463,7 @@ def _ParseAbstractInteger(text, is_long=False): # We force 32-bit values to int and 64-bit values to long to make # alternate implementations where the distinction is more significant # (e.g. the C++ implementation) simpler. - if is_long: - return long(text, 0) - else: - return int(text, 0) + return long(text, 0) if is_long else int(text, 0) except ValueError: raise ValueError('Couldn\'t parse integer: %s' % text) @@ -1498,10 +1486,7 @@ def ParseFloat(text): except ValueError: # Check alternative spellings. if _FLOAT_INFINITY.match(text): - if text[0] == '-': - return float('-inf') - else: - return float('inf') + return float('-inf') if text[0] == '-' else float('inf') elif _FLOAT_NAN.match(text): return float('nan') else: @@ -1555,8 +1540,9 @@ def ParseEnum(field, value): # Identifier. enum_value = enum_descriptor.values_by_name.get(value, None) if enum_value is None: - raise ValueError('Enum type "%s" has no value named %s.' % - (enum_descriptor.full_name, value)) + raise ValueError( + f'Enum type "{enum_descriptor.full_name}" has no value named {value}.' + ) else: # Numeric value. enum_value = enum_descriptor.values_by_number.get(number, None) diff --git a/serverless-lambda/vendored/external/six_archive/six.py b/serverless-lambda/vendored/external/six_archive/six.py index 190c023..662629d 100644 --- a/serverless-lambda/vendored/external/six_archive/six.py +++ b/serverless-lambda/vendored/external/six_archive/six.py @@ -1,5 +1,6 @@ """Utilities for writing code that runs on Python 2 and 3""" + # Copyright (c) 2010-2015 Benjamin Peterson # # Permission is hereby granted, free of charge, to any person obtaining a copy @@ -35,7 +36,7 @@ # Useful for very coarse version differentiation. PY2 = sys.version_info[0] == 2 PY3 = sys.version_info[0] == 3 -PY34 = sys.version_info[0:2] >= (3, 4) +PY34 = sys.version_info[:2] >= (3, 4) if PY3: string_types = str, @@ -145,10 +146,7 @@ def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): new_mod = name self.mod = new_mod if new_attr is None: - if old_attr is None: - new_attr = name - else: - new_attr = old_attr + new_attr = name if old_attr is None else old_attr self.attr = new_attr else: self.mod = old_mod @@ -176,21 +174,19 @@ def __init__(self, six_module_name): def _add_module(self, mod, *fullnames): for fullname in fullnames: - self.known_modules[self.name + "." + fullname] = mod + self.known_modules[f"{self.name}.{fullname}"] = mod def _get_module(self, fullname): - return self.known_modules[self.name + "." + fullname] + return self.known_modules[f"{self.name}.{fullname}"] def find_module(self, fullname, path=None): - if fullname in self.known_modules: - return self - return None + return self if fullname in self.known_modules else None def __get_module(self, fullname): try: return self.known_modules[fullname] except KeyError: - raise ImportError("This loader does not know module " + fullname) + raise ImportError(f"This loader does not know module {fullname}") def load_module(self, fullname): try: @@ -235,14 +231,21 @@ class _MovedItems(_LazyModule): _moved_attributes = [ MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), - MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), + MovedAttribute( + "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse" + ), MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), MovedAttribute("intern", "__builtin__", "sys"), MovedAttribute("map", "itertools", "builtins", "imap", "map"), MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), - MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), + MovedAttribute( + "reload_module", + "__builtin__", + "importlib" if PY34 else "imp", + "reload", + ), MovedAttribute("reduce", "__builtin__", "functools"), MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), MovedAttribute("StringIO", "StringIO", "io"), @@ -251,7 +254,9 @@ class _MovedItems(_LazyModule): MovedAttribute("UserString", "UserString", "collections"), MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), - MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), + MovedAttribute( + "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest" + ), MovedModule("builtins", "__builtin__"), MovedModule("configparser", "ConfigParser"), MovedModule("copyreg", "copy_reg"), @@ -262,8 +267,14 @@ class _MovedItems(_LazyModule): MovedModule("html_entities", "htmlentitydefs", "html.entities"), MovedModule("html_parser", "HTMLParser", "html.parser"), MovedModule("http_client", "httplib", "http.client"), - MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), - MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), + MovedModule( + "email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart" + ), + MovedModule( + "email_mime_nonmultipart", + "email.MIMENonMultipart", + "email.mime.nonmultipart", + ), MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), @@ -277,24 +288,37 @@ class _MovedItems(_LazyModule): MovedModule("tkinter", "Tkinter"), MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), - MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), - MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule( + "tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext" + ), + MovedModule( + "tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog" + ), MovedModule("tkinter_tix", "Tix", "tkinter.tix"), MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), - MovedModule("tkinter_colorchooser", "tkColorChooser", - "tkinter.colorchooser"), - MovedModule("tkinter_commondialog", "tkCommonDialog", - "tkinter.commondialog"), + MovedModule( + "tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser" + ), + MovedModule( + "tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog" + ), MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), MovedModule("tkinter_font", "tkFont", "tkinter.font"), MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), - MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", - "tkinter.simpledialog"), - MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), - MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), - MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule( + "tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog" + ), + MovedModule( + "urllib_parse", f"{__name__}.moves.urllib_parse", "urllib.parse" + ), + MovedModule( + "urllib_error", f"{__name__}.moves.urllib_error", "urllib.error" + ), + MovedModule( + "urllib", f"{__name__}.moves.urllib", f"{__name__}.moves.urllib" + ), MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), @@ -308,20 +332,18 @@ class _MovedItems(_LazyModule): for attr in _moved_attributes: setattr(_MovedItems, attr.name, attr) if isinstance(attr, MovedModule): - _importer._add_module(attr, "moves." + attr.name) + _importer._add_module(attr, f"moves.{attr.name}") del attr _MovedItems._moved_attributes = _moved_attributes -moves = _MovedItems(__name__ + ".moves") +moves = _MovedItems(f"{__name__}.moves") _importer._add_module(moves, "moves") class Module_six_moves_urllib_parse(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_parse""" - - _urllib_parse_moved_attributes = [ MovedAttribute("ParseResult", "urlparse", "urllib.parse"), MovedAttribute("SplitResult", "urlparse", "urllib.parse"), @@ -353,15 +375,16 @@ class Module_six_moves_urllib_parse(_LazyModule): Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes -_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), - "moves.urllib_parse", "moves.urllib.parse") +_importer._add_module( + Module_six_moves_urllib_parse(f"{__name__}.moves.urllib_parse"), + "moves.urllib_parse", + "moves.urllib.parse", +) class Module_six_moves_urllib_error(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_error""" - - _urllib_error_moved_attributes = [ MovedAttribute("URLError", "urllib2", "urllib.error"), MovedAttribute("HTTPError", "urllib2", "urllib.error"), @@ -373,15 +396,16 @@ class Module_six_moves_urllib_error(_LazyModule): Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes -_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), - "moves.urllib_error", "moves.urllib.error") +_importer._add_module( + Module_six_moves_urllib_error(f"{__name__}.moves.urllib.error"), + "moves.urllib_error", + "moves.urllib.error", +) class Module_six_moves_urllib_request(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_request""" - - _urllib_request_moved_attributes = [ MovedAttribute("urlopen", "urllib2", "urllib.request"), MovedAttribute("install_opener", "urllib2", "urllib.request"), @@ -423,15 +447,16 @@ class Module_six_moves_urllib_request(_LazyModule): Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes -_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), - "moves.urllib_request", "moves.urllib.request") +_importer._add_module( + Module_six_moves_urllib_request(f"{__name__}.moves.urllib.request"), + "moves.urllib_request", + "moves.urllib.request", +) class Module_six_moves_urllib_response(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_response""" - - _urllib_response_moved_attributes = [ MovedAttribute("addbase", "urllib", "urllib.response"), MovedAttribute("addclosehook", "urllib", "urllib.response"), @@ -444,15 +469,16 @@ class Module_six_moves_urllib_response(_LazyModule): Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes -_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), - "moves.urllib_response", "moves.urllib.response") +_importer._add_module( + Module_six_moves_urllib_response(f"{__name__}.moves.urllib.response"), + "moves.urllib_response", + "moves.urllib.response", +) class Module_six_moves_urllib_robotparser(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_robotparser""" - - _urllib_robotparser_moved_attributes = [ MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), ] @@ -462,8 +488,13 @@ class Module_six_moves_urllib_robotparser(_LazyModule): Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes -_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), - "moves.urllib_robotparser", "moves.urllib.robotparser") +_importer._add_module( + Module_six_moves_urllib_robotparser( + f"{__name__}.moves.urllib.robotparser" + ), + "moves.urllib_robotparser", + "moves.urllib.robotparser", +) class Module_six_moves_urllib(types.ModuleType): @@ -479,8 +510,9 @@ class Module_six_moves_urllib(types.ModuleType): def __dir__(self): return ['parse', 'error', 'request', 'response', 'robotparser'] -_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), - "moves.urllib") +_importer._add_module( + Module_six_moves_urllib(f"{__name__}.moves.urllib"), "moves.urllib" +) def add_move(move): diff --git a/serverless-lambda/vendored/funcsigs/__init__.py b/serverless-lambda/vendored/funcsigs/__init__.py index 5f5378b..c06d10a 100644 --- a/serverless-lambda/vendored/funcsigs/__init__.py +++ b/serverless-lambda/vendored/funcsigs/__init__.py @@ -32,7 +32,7 @@ def formatannotation(annotation, base_module=None): if isinstance(annotation, type): if annotation.__module__ in ('builtins', '__builtin__', base_module): return annotation.__name__ - return annotation.__module__+'.'+annotation.__name__ + return f'{annotation.__module__}.{annotation.__name__}' return repr(annotation) @@ -63,27 +63,22 @@ def signature(obj): if obj.__self__ is None: # Unbound method - preserve as-is. return sig - else: - # Bound method. Eat self - if we can. - params = tuple(sig.parameters.values()) - - if not params or params[0].kind in (_VAR_KEYWORD, _KEYWORD_ONLY): - raise ValueError('invalid method signature') - - kind = params[0].kind - if kind in (_POSITIONAL_OR_KEYWORD, _POSITIONAL_ONLY): - # Drop first parameter: - # '(p1, p2[, ...])' -> '(p2[, ...])' - params = params[1:] - else: - if kind is not _VAR_POSITIONAL: - # Unless we add a new parameter type we never - # get here - raise ValueError('invalid argument type') - # It's a var-positional parameter. - # Do nothing. '(*args[, ...])' -> '(*args[, ...])' - - return sig.replace(parameters=params) + # Bound method. Eat self - if we can. + params = tuple(sig.parameters.values()) + + if not params or params[0].kind in (_VAR_KEYWORD, _KEYWORD_ONLY): + raise ValueError('invalid method signature') + + kind = params[0].kind + if kind in (_POSITIONAL_OR_KEYWORD, _POSITIONAL_ONLY): + # Drop first parameter: + # '(p1, p2[, ...])' -> '(p2[, ...])' + params = params[1:] + elif kind is not _VAR_POSITIONAL: + # Unless we add a new parameter type we never + # get here + raise ValueError('invalid argument type') + return sig.replace(parameters=params) try: sig = obj.__signature__ @@ -196,8 +191,8 @@ class _empty(object): class _ParameterKind(int): - def __new__(self, *args, **kwargs): - obj = int.__new__(self, *args) + def __new__(cls, *args, **kwargs): + obj = int.__new__(cls, *args) obj._name = kwargs['name'] return obj @@ -264,14 +259,12 @@ def __init__(self, name, kind, default=_empty, annotation=_empty, if kind != _POSITIONAL_ONLY: raise ValueError("None is not a valid name for a " "non-positional-only parameter") - self._name = name else: name = str(name) if kind != _POSITIONAL_ONLY and not re.match(r'[a-z_]\w*$', name, re.I): msg = '{0!r} is not a valid parameter name'.format(name) raise ValueError(msg) - self._name = name - + self._name = name self._partial_kwarg = _partial_kwarg @property @@ -330,9 +323,9 @@ def __str__(self): formatted = '{0}={1}'.format(formatted, repr(self._default)) if kind == _VAR_POSITIONAL: - formatted = '*' + formatted + formatted = f'*{formatted}' elif kind == _VAR_KEYWORD: - formatted = '**' + formatted + formatted = f'**{formatted}' return formatted @@ -417,10 +410,9 @@ def kwargs(self): if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or param._partial_kwarg): kwargs_started = True - else: - if param_name not in self.arguments: - kwargs_started = True - continue + elif param_name not in self.arguments: + kwargs_started = True + continue if not kwargs_started: continue @@ -432,7 +424,7 @@ def kwargs(self): else: if param.kind == _VAR_KEYWORD: # **kwargs - kwargs.update(arg) + kwargs |= arg else: # plain keyword argument kwargs[param_name] = arg @@ -490,32 +482,31 @@ def __init__(self, parameters=None, return_annotation=_empty, if parameters is None: params = OrderedDict() - else: - if __validate_parameters__: - params = OrderedDict() - top_kind = _POSITIONAL_ONLY - - for idx, param in enumerate(parameters): - kind = param.kind - if kind < top_kind: - msg = 'wrong parameter order: {0} before {1}' - msg = msg.format(top_kind, param.kind) - raise ValueError(msg) - else: - top_kind = kind + elif __validate_parameters__: + params = OrderedDict() + top_kind = _POSITIONAL_ONLY + + for idx, param in enumerate(parameters): + kind = param.kind + if kind < top_kind: + msg = 'wrong parameter order: {0} before {1}' + msg = msg.format(top_kind, param.kind) + raise ValueError(msg) + else: + top_kind = kind - name = param.name - if name is None: - name = str(idx) - param = param.replace(name=name) + name = param.name + if name is None: + name = str(idx) + param = param.replace(name=name) - if name in params: - msg = 'duplicate parameter name: {0!r}'.format(name) - raise ValueError(msg) + if name in params: + raise ValueError('duplicate parameter name: {0!r}'.format(name)) + else: params[name] = param - else: - params = OrderedDict(((param.name, param) - for param in parameters)) + else: + params = OrderedDict(((param.name, param) + for param in parameters)) self._parameters = params self._return_annotation = return_annotation @@ -540,11 +531,7 @@ def from_function(cls, func): defaults = func.__defaults__ kwdefaults = getattr(func, '__kwdefaults__', None) - if defaults: - pos_default_count = len(defaults) - else: - pos_default_count = 0 - + pos_default_count = len(defaults) if defaults else 0 parameters = [] # Non-keyword-only parameters w/o defaults. @@ -629,8 +616,9 @@ def __eq__(self, other): len(self.parameters) != len(other.parameters)): return False - other_positions = dict((param, idx) - for idx, param in enumerate(other.parameters.keys())) + other_positions = { + param: idx for idx, param in enumerate(other.parameters.keys()) + } for idx, (param_name, param) in enumerate(self.parameters.items()): if param.kind == _KEYWORD_ONLY: @@ -784,12 +772,12 @@ def _bind(self, args, kwargs, partial=False): return self._bound_arguments_cls(self, arguments) - def bind(*args, **kwargs): + def bind(self, **kwargs): '''Get a BoundArguments object, that maps the passed `args` and `kwargs` to the function's signature. Raises `TypeError` if the passed arguments can not be bound. ''' - return args[0]._bind(args[1:], kwargs) + return self[0]._bind(self[1:], kwargs) def bind_partial(self, *args, **kwargs): '''Get a BoundArguments object, that partially maps the @@ -801,7 +789,7 @@ def bind_partial(self, *args, **kwargs): def __str__(self): result = [] render_kw_only_separator = True - for idx, param in enumerate(self.parameters.values()): + for param in self.parameters.values(): formatted = str(param) kind = param.kind diff --git a/serverless-lambda/vendored/google/protobuf/descriptor.py b/serverless-lambda/vendored/google/protobuf/descriptor.py index b1f3ca3..0ac12a8 100644 --- a/serverless-lambda/vendored/google/protobuf/descriptor.py +++ b/serverless-lambda/vendored/google/protobuf/descriptor.py @@ -61,12 +61,10 @@ class TypeTransformationError(Error): # and make it return True when the descriptor is an instance of the extension # type written in C++. class DescriptorMetaclass(type): - def __instancecheck__(cls, obj): - if super(DescriptorMetaclass, cls).__instancecheck__(obj): + def __instancecheck__(self, obj): + if super(DescriptorMetaclass, self).__instancecheck__(obj): return True - if isinstance(obj, cls._C_DESCRIPTOR_CLASS): - return True - return False + return isinstance(obj, self._C_DESCRIPTOR_CLASS) else: # The standard metaclass; nothing changes. DescriptorMetaclass = type @@ -127,8 +125,7 @@ def GetOptions(self): try: options_class = getattr(descriptor_pb2, self._options_class_name) except AttributeError: - raise RuntimeError('Unknown options class name %s!' % - (self._options_class_name)) + raise RuntimeError(f'Unknown options class name {self._options_class_name}!') self._options = options_class() return self._options @@ -283,30 +280,29 @@ def __init__(self, name, full_name, filename, containing_type, fields, self.fields = fields for field in self.fields: field.containing_type = self - self.fields_by_number = dict((f.number, f) for f in fields) - self.fields_by_name = dict((f.name, f) for f in fields) + self.fields_by_number = {f.number: f for f in fields} + self.fields_by_name = {f.name: f for f in fields} self._fields_by_camelcase_name = None self.nested_types = nested_types for nested_type in nested_types: nested_type.containing_type = self - self.nested_types_by_name = dict((t.name, t) for t in nested_types) + self.nested_types_by_name = {t.name: t for t in nested_types} self.enum_types = enum_types for enum_type in self.enum_types: enum_type.containing_type = self - self.enum_types_by_name = dict((t.name, t) for t in enum_types) - self.enum_values_by_name = dict( - (v.name, v) for t in enum_types for v in t.values) + self.enum_types_by_name = {t.name: t for t in enum_types} + self.enum_values_by_name = {v.name: v for t in enum_types for v in t.values} self.extensions = extensions for extension in self.extensions: extension.extension_scope = self - self.extensions_by_name = dict((f.name, f) for f in extensions) + self.extensions_by_name = {f.name: f for f in extensions} self.is_extendable = is_extendable self.extension_ranges = extension_ranges self.oneofs = oneofs if oneofs is not None else [] - self.oneofs_by_name = dict((o.name, o) for o in self.oneofs) + self.oneofs_by_name = {o.name: o for o in self.oneofs} for oneof in self.oneofs: oneof.containing_type = self self.syntax = syntax or "proto2" @@ -314,8 +310,7 @@ def __init__(self, name, full_name, filename, containing_type, fields, @property def fields_by_camelcase_name(self): if self._fields_by_camelcase_name is None: - self._fields_by_camelcase_name = dict( - (f.camelcase_name, f) for f in self.fields) + self._fields_by_camelcase_name = {f.camelcase_name: f for f in self.fields} return self._fields_by_camelcase_name def EnumValueName(self, enum, value): @@ -517,10 +512,7 @@ def __init__(self, name, full_name, index, number, type, cpp_type, label, self.full_name = full_name self.file = file self._camelcase_name = None - if json_name is None: - self.json_name = _ToJsonName(name) - else: - self.json_name = json_name + self.json_name = _ToJsonName(name) if json_name is None else json_name self.index = index self.number = number self.type = type @@ -566,7 +558,7 @@ def ProtoTypeToCppProtoType(proto_type): try: return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type] except KeyError: - raise TypeTransformationError('Unknown proto_type: %s' % proto_type) + raise TypeTransformationError(f'Unknown proto_type: {proto_type}') class EnumDescriptor(_NestedDescriptorBase): @@ -619,8 +611,8 @@ def __init__(self, name, full_name, filename, values, self.values = values for value in self.values: value.type = self - self.values_by_name = dict((v.name, v) for v in values) - self.values_by_number = dict((v.number, v) for v in values) + self.values_by_name = {v.name: v for v in values} + self.values_by_number = {v.number: v for v in values} def CopyToProto(self, proto): """Copies this to a descriptor_pb2.EnumDescriptorProto. @@ -734,7 +726,7 @@ def __init__(self, name, full_name, index, methods, options=None, file=None, serialized_end=serialized_end) self.index = index self.methods = methods - self.methods_by_name = dict((m.name, m) for m in methods) + self.methods_by_name = {m.name: m for m in methods} # Set the containing service for each method in this service. for method in self.methods: method.containing_service = self @@ -956,10 +948,10 @@ def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True, if package: file_descriptor_proto.name = os.path.join(package.replace('.', '/'), - proto_name + '.proto') + f'{proto_name}.proto') file_descriptor_proto.package = package else: - file_descriptor_proto.name = proto_name + '.proto' + file_descriptor_proto.name = f'{proto_name}.proto' _message.default_pool.Add(file_descriptor_proto) result = _message.default_pool.FindFileByName(file_descriptor_proto.name) @@ -997,10 +989,7 @@ def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True, full_name = '.'.join(full_message_name + [field_proto.name]) enum_desc = None nested_desc = None - if field_proto.json_name: - json_name = field_proto.json_name - else: - json_name = None + json_name = field_proto.json_name if field_proto.json_name else None if field_proto.HasField('type_name'): type_name = field_proto.type_name full_type_name = '.'.join(full_message_name + diff --git a/serverless-lambda/vendored/google/protobuf/descriptor_database.py b/serverless-lambda/vendored/google/protobuf/descriptor_database.py index b8f5140..74ecd9d 100644 --- a/serverless-lambda/vendored/google/protobuf/descriptor_database.py +++ b/serverless-lambda/vendored/google/protobuf/descriptor_database.py @@ -63,7 +63,7 @@ def Add(self, file_desc_proto): self._file_desc_protos_by_file[proto_name] = file_desc_proto elif self._file_desc_protos_by_file[proto_name] != file_desc_proto: raise DescriptorDatabaseConflictingDefinitionError( - '%s already added, but with different descriptor.' % proto_name) + f'{proto_name} already added, but with different descriptor.') # Add all the top-level descriptors to the index. package = file_desc_proto.package @@ -143,10 +143,9 @@ def _ExtractSymbols(desc_proto, package): Yields: The fully qualified name found in the descriptor. """ - message_name = package + '.' + desc_proto.name if package else desc_proto.name + message_name = f'{package}.{desc_proto.name}' if package else desc_proto.name yield message_name for nested_type in desc_proto.nested_type: - for symbol in _ExtractSymbols(nested_type, message_name): - yield symbol + yield from _ExtractSymbols(nested_type, message_name) for enum_type in desc_proto.enum_type: yield '.'.join((message_name, enum_type.name)) diff --git a/serverless-lambda/vendored/google/protobuf/descriptor_pool.py b/serverless-lambda/vendored/google/protobuf/descriptor_pool.py index f4c533a..9d5394e 100644 --- a/serverless-lambda/vendored/google/protobuf/descriptor_pool.py +++ b/serverless-lambda/vendored/google/protobuf/descriptor_pool.py @@ -302,7 +302,7 @@ def FindFileByName(self, file_name): else: raise error if not file_proto: - raise KeyError('Cannot find a file named %s' % file_name) + raise KeyError(f'Cannot find a file named {file_name}') return self._ConvertFileProtoToFileDescriptor(file_proto) def FindFileContainingSymbol(self, symbol): @@ -351,7 +351,7 @@ def FindFileContainingSymbol(self, symbol): assert message.extensions_by_name[extension_name] return message.file except KeyError: - raise KeyError('Cannot find a file containing %s' % symbol) + raise KeyError(f'Cannot find a file containing {symbol}') def FindMessageTypeByName(self, full_name): """Loads the named descriptor from the pool. @@ -523,7 +523,7 @@ def _FindFileContainingSymbolInDb(self, symbol): else: raise error if not file_proto: - raise KeyError('Cannot find a file containing %s' % symbol) + raise KeyError(f'Cannot find a file containing {symbol}') return self._ConvertFileProtoToFileDescriptor(file_proto) def _ConvertFileProtoToFileDescriptor(self, file_proto): @@ -560,8 +560,7 @@ def _ConvertFileProtoToFileDescriptor(self, file_proto): # scope of available message types when defining the passed in # file proto. for dependency in built_deps: - scope.update(self._ExtractSymbols( - dependency.message_types_by_name.values())) + scope |= self._ExtractSymbols(dependency.message_types_by_name.values()) scope.update((_PrefixWithDot(enum.full_name), enum) for enum in dependency.enum_types_by_name.values()) @@ -631,11 +630,7 @@ def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, else: desc_name = desc_proto.name - if file_desc is None: - file_name = None - else: - file_name = file_desc.name - + file_name = None if file_desc is None else file_desc.name if scope is None: scope = {} @@ -657,10 +652,7 @@ def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, index, None, [], desc.options) for index, desc in enumerate(desc_proto.oneof_decl)] extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range] - if extension_ranges: - is_extendable = True - else: - is_extendable = False + is_extendable = bool(extension_ranges) desc = descriptor.Descriptor( name=desc_proto.name, full_name=desc_name, @@ -712,11 +704,7 @@ def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, else: enum_name = enum_proto.name - if file_desc is None: - file_name = None - else: - file_name = file_desc.name - + file_name = None if file_desc is None else file_desc.name values = [self._MakeEnumValueDescriptor(value, index) for index, value in enumerate(enum_proto.value)] desc = descriptor.EnumDescriptor(name=enum_proto.name, @@ -726,7 +714,7 @@ def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, values=values, containing_type=containing_type, options=_OptionsOrNone(enum_proto)) - scope['.%s' % enum_name] = desc + scope[f'.{enum_name}'] = desc self._enum_descriptors[enum_name] = desc return desc @@ -829,8 +817,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType( field_proto.type) - if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE - or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_MESSAGE, + descriptor.FieldDescriptor.TYPE_GROUP, + ]: field_desc.message_type = desc if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: @@ -841,8 +831,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.default_value = [] elif field_proto.HasField('default_value'): field_desc.has_default_value = True - if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or - field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_DOUBLE, + descriptor.FieldDescriptor.TYPE_FLOAT, + ]: field_desc.default_value = float(field_proto.default_value) elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: field_desc.default_value = field_proto.default_value @@ -859,8 +851,10 @@ def _SetFieldType(self, field_proto, field_desc, package, scope): field_desc.default_value = int(field_proto.default_value) else: field_desc.has_default_value = False - if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or - field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + if field_proto.type in [ + descriptor.FieldDescriptor.TYPE_DOUBLE, + descriptor.FieldDescriptor.TYPE_FLOAT, + ]: field_desc.default_value = 0.0 elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: field_desc.default_value = u'' @@ -964,8 +958,7 @@ def _ExtractSymbols(self, descriptors): for desc in descriptors: yield (_PrefixWithDot(desc.full_name), desc) - for symbol in self._ExtractSymbols(desc.nested_types): - yield symbol + yield from self._ExtractSymbols(desc.nested_types) for enum in desc.enum_types: yield (_PrefixWithDot(enum.full_name), enum) @@ -982,8 +975,7 @@ def _GetDeps(self, dependencies): for dependency in dependencies: dep_desc = self.FindFileByName(dependency) yield dep_desc - for parent_dep in dep_desc.dependencies: - yield parent_dep + yield from dep_desc.dependencies def _GetTypeFromScope(self, package, type_name, scope): """Finds a given type name in the current scope. @@ -1009,7 +1001,7 @@ def _GetTypeFromScope(self, package, type_name, scope): def _PrefixWithDot(name): - return name if name.startswith('.') else '.%s' % name + return name if name.startswith('.') else f'.{name}' if _USE_C_DESCRIPTORS: diff --git a/serverless-lambda/vendored/six.py b/serverless-lambda/vendored/six.py index 6bf4fd3..6c488e0 100644 --- a/serverless-lambda/vendored/six.py +++ b/serverless-lambda/vendored/six.py @@ -20,6 +20,7 @@ """Utilities for writing code that runs on Python 2 and 3""" + from __future__ import absolute_import import functools @@ -35,7 +36,7 @@ # Useful for very coarse version differentiation. PY2 = sys.version_info[0] == 2 PY3 = sys.version_info[0] == 3 -PY34 = sys.version_info[0:2] >= (3, 4) +PY34 = sys.version_info[:2] >= (3, 4) if PY3: string_types = str, @@ -145,10 +146,7 @@ def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): new_mod = name self.mod = new_mod if new_attr is None: - if old_attr is None: - new_attr = name - else: - new_attr = old_attr + new_attr = name if old_attr is None else old_attr self.attr = new_attr else: self.mod = old_mod @@ -176,21 +174,19 @@ def __init__(self, six_module_name): def _add_module(self, mod, *fullnames): for fullname in fullnames: - self.known_modules[self.name + "." + fullname] = mod + self.known_modules[f"{self.name}.{fullname}"] = mod def _get_module(self, fullname): - return self.known_modules[self.name + "." + fullname] + return self.known_modules[f"{self.name}.{fullname}"] def find_module(self, fullname, path=None): - if fullname in self.known_modules: - return self - return None + return self if fullname in self.known_modules else None def __get_module(self, fullname): try: return self.known_modules[fullname] except KeyError: - raise ImportError("This loader does not know module " + fullname) + raise ImportError(f"This loader does not know module {fullname}") def load_module(self, fullname): try: @@ -235,7 +231,9 @@ class _MovedItems(_LazyModule): _moved_attributes = [ MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), - MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), + MovedAttribute( + "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse" + ), MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), MovedAttribute("intern", "__builtin__", "sys"), MovedAttribute("map", "itertools", "builtins", "imap", "map"), @@ -243,7 +241,12 @@ class _MovedItems(_LazyModule): MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), MovedAttribute("getoutput", "commands", "subprocess"), MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), - MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), + MovedAttribute( + "reload_module", + "__builtin__", + "importlib" if PY34 else "imp", + "reload", + ), MovedAttribute("reduce", "__builtin__", "functools"), MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), MovedAttribute("StringIO", "StringIO", "io"), @@ -252,7 +255,9 @@ class _MovedItems(_LazyModule): MovedAttribute("UserString", "UserString", "collections"), MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), - MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), + MovedAttribute( + "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest" + ), MovedModule("builtins", "__builtin__"), MovedModule("configparser", "ConfigParser"), MovedModule("copyreg", "copy_reg"), @@ -265,8 +270,14 @@ class _MovedItems(_LazyModule): MovedModule("http_client", "httplib", "http.client"), MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"), - MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), - MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), + MovedModule( + "email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart" + ), + MovedModule( + "email_mime_nonmultipart", + "email.MIMENonMultipart", + "email.mime.nonmultipart", + ), MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), @@ -279,24 +290,37 @@ class _MovedItems(_LazyModule): MovedModule("tkinter", "Tkinter"), MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), - MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), - MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule( + "tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext" + ), + MovedModule( + "tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog" + ), MovedModule("tkinter_tix", "Tix", "tkinter.tix"), MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), - MovedModule("tkinter_colorchooser", "tkColorChooser", - "tkinter.colorchooser"), - MovedModule("tkinter_commondialog", "tkCommonDialog", - "tkinter.commondialog"), + MovedModule( + "tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser" + ), + MovedModule( + "tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog" + ), MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), MovedModule("tkinter_font", "tkFont", "tkinter.font"), MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), - MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", - "tkinter.simpledialog"), - MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), - MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), - MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule( + "tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog" + ), + MovedModule( + "urllib_parse", f"{__name__}.moves.urllib_parse", "urllib.parse" + ), + MovedModule( + "urllib_error", f"{__name__}.moves.urllib_error", "urllib.error" + ), + MovedModule( + "urllib", f"{__name__}.moves.urllib", f"{__name__}.moves.urllib" + ), MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), @@ -310,20 +334,18 @@ class _MovedItems(_LazyModule): for attr in _moved_attributes: setattr(_MovedItems, attr.name, attr) if isinstance(attr, MovedModule): - _importer._add_module(attr, "moves." + attr.name) + _importer._add_module(attr, f"moves.{attr.name}") del attr _MovedItems._moved_attributes = _moved_attributes -moves = _MovedItems(__name__ + ".moves") +moves = _MovedItems(f"{__name__}.moves") _importer._add_module(moves, "moves") class Module_six_moves_urllib_parse(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_parse""" - - _urllib_parse_moved_attributes = [ MovedAttribute("ParseResult", "urlparse", "urllib.parse"), MovedAttribute("SplitResult", "urlparse", "urllib.parse"), @@ -357,15 +379,16 @@ class Module_six_moves_urllib_parse(_LazyModule): Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes -_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), - "moves.urllib_parse", "moves.urllib.parse") +_importer._add_module( + Module_six_moves_urllib_parse(f"{__name__}.moves.urllib_parse"), + "moves.urllib_parse", + "moves.urllib.parse", +) class Module_six_moves_urllib_error(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_error""" - - _urllib_error_moved_attributes = [ MovedAttribute("URLError", "urllib2", "urllib.error"), MovedAttribute("HTTPError", "urllib2", "urllib.error"), @@ -377,15 +400,16 @@ class Module_six_moves_urllib_error(_LazyModule): Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes -_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), - "moves.urllib_error", "moves.urllib.error") +_importer._add_module( + Module_six_moves_urllib_error(f"{__name__}.moves.urllib.error"), + "moves.urllib_error", + "moves.urllib.error", +) class Module_six_moves_urllib_request(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_request""" - - _urllib_request_moved_attributes = [ MovedAttribute("urlopen", "urllib2", "urllib.request"), MovedAttribute("install_opener", "urllib2", "urllib.request"), @@ -429,15 +453,16 @@ class Module_six_moves_urllib_request(_LazyModule): Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes -_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), - "moves.urllib_request", "moves.urllib.request") +_importer._add_module( + Module_six_moves_urllib_request(f"{__name__}.moves.urllib.request"), + "moves.urllib_request", + "moves.urllib.request", +) class Module_six_moves_urllib_response(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_response""" - - _urllib_response_moved_attributes = [ MovedAttribute("addbase", "urllib", "urllib.response"), MovedAttribute("addclosehook", "urllib", "urllib.response"), @@ -450,15 +475,16 @@ class Module_six_moves_urllib_response(_LazyModule): Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes -_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), - "moves.urllib_response", "moves.urllib.response") +_importer._add_module( + Module_six_moves_urllib_response(f"{__name__}.moves.urllib.response"), + "moves.urllib_response", + "moves.urllib.response", +) class Module_six_moves_urllib_robotparser(_LazyModule): """Lazy loading of moved objects in six.moves.urllib_robotparser""" - - _urllib_robotparser_moved_attributes = [ MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), ] @@ -468,8 +494,13 @@ class Module_six_moves_urllib_robotparser(_LazyModule): Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes -_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), - "moves.urllib_robotparser", "moves.urllib.robotparser") +_importer._add_module( + Module_six_moves_urllib_robotparser( + f"{__name__}.moves.urllib.robotparser" + ), + "moves.urllib_robotparser", + "moves.urllib.robotparser", +) class Module_six_moves_urllib(types.ModuleType): @@ -485,8 +516,9 @@ class Module_six_moves_urllib(types.ModuleType): def __dir__(self): return ['parse', 'error', 'request', 'response', 'robotparser'] -_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), - "moves.urllib") +_importer._add_module( + Module_six_moves_urllib(f"{__name__}.moves.urllib"), "moves.urllib" +) def add_move(move):