filename
stringlengths
13
19
text
stringlengths
134
1.04M
the-stack_106_32214
import pandas as pd from dash_website.utils.aws_loader import load_csv columns_to_take = [ "id", "sex", "age_category", "sample", "aging_rate", "Age", "Biological_Age", "Ethnicity.White", "Ethnicity.British", "Ethnicity.Irish", "Ethnicity.White_Other", "Ethnicity.Mixed", "Ethnicity.White_and_Black_Caribbean", "Ethnicity.White_and_Black_African", "Ethnicity.White_and_Asian", "Ethnicity.Mixed_Other", "Ethnicity.Asian", "Ethnicity.Indian", "Ethnicity.Pakistani", "Ethnicity.Bangladeshi", "Ethnicity.Asian_Other", "Ethnicity.Black", "Ethnicity.Caribbean", "Ethnicity.African", "Ethnicity.Black_Other", "Ethnicity.Chinese", "Ethnicity.Other", "Ethnicity.Other_ethnicity", "Ethnicity.Do_not_know", "Ethnicity.Prefer_not_to_answer", "Ethnicity.NA", ] if __name__ == "__main__": list_information = [] for chamber_type in [3, 4]: information_raw = load_csv( f"page12_AttentionMapsVideos/RawVideos/files/AttentionMaps-samples_Age_Heart_MRI_{chamber_type}chambersRawVideo.csv", usecols=columns_to_take, )[columns_to_take].set_index("id") information_raw.drop(index=information_raw[information_raw["aging_rate"] != "normal"].index, inplace=True) information = pd.DataFrame( None, columns=["chamber", "sex", "age_group", "sample", "chronological_age", "biological_age", "ethnicity"], index=information_raw.index, ) information["chamber"] = chamber_type information["sex"] = information_raw["sex"].str.lower() information["age_group"] = information_raw["age_category"] information["sample"] = information_raw["sample"] information["chronological_age"] = information_raw["Age"].round(1) information["biological_age"] = information_raw["Biological_Age"] for id_participant in information_raw.index: ethnicities = information_raw.loc[ id_participant, information_raw.columns[information_raw.columns.str.startswith("Ethnicity")] ] information.loc[id_participant, "ethnicity"] = " ".join( list(map(lambda list_ethni: list_ethni.split(".")[1], ethnicities[ethnicities == 1].index)) ) list_information.append(information.reset_index()) pd.concat(list_information).reset_index(drop=True).to_feather("all_data/datasets/videos/information.feather")
the-stack_106_32215
# -*- coding: utf-8 -*- # # Copyright (C) 2010-2016 PPMessage. # Guijin Ding, [email protected] # All rights reserved # from ppmessage.core.apkinfo import ApkInfo from ppmessage.core.ipainfo import IpaInfo import traceback import random import sys import os APP_NAME = "ppmessage" if len(sys.argv) == 2: APP_NAME = sys.argv[1] IOS_IPA_FILE = APP_NAME + ".ipa" IOS_IPA_PATH = "../web/assets/static/yvertical/portal/resources/app/" + IOS_IPA_FILE DOWNLOAD_APP_HTML = "../web/assets/static/yvertical/portal/download-app/download-app.html" DOWNLOAD_APP_HTML_TEMPLATE = "../web/assets/static/yvertical/portal/download-app/download-app.html.template" def _importIOSApp(): _file_name = IOS_IPA_FILE _file_path = IOS_IPA_PATH _ipa = IpaInfo() _ipa.init(_file_path, _file_name) print(_ipa.getDistinctName()) print(_ipa.getFriendlyName()) print(_ipa.getVersionName()) _ipa.putPList("ppmessage.cn", "root", "YVERTICAL1q2w3e4r5t") _plist_url = _ipa.getPListUrl("ppmessage.cn") print(_plist_url) return _plist_url def _download_html(_ios_plist_url): _ios_download_link = "" _r = None with open(DOWNLOAD_APP_HTML_TEMPLATE, "r") as _file: _r = _file.read() _r = _r.decode("utf8") _r = _r.replace("{IOS_PLIST_URL}", _ios_plist_url) with open(DOWNLOAD_APP_HTML, "w") as _file: _r = _r.encode("utf8") _file.write(_r) def _import(): _plist_url = _importIOSApp() _download_html(_plist_url) return if __name__ == "__main__": import sys reload(sys) sys.setdefaultencoding('utf8') import codecs codecs.register(lambda name: codecs.lookup('utf8') if name == 'utf8mb4' else None) _import()
the-stack_106_32216
import time import logging from spaceone.inventory.libs.manager import GoogleCloudManager from spaceone.inventory.libs.schema.base import ReferenceModel from spaceone.inventory.model.load_balancing.cloud_service import * from spaceone.inventory.connector.load_balancing import LoadBalancingConnector from spaceone.inventory.model.load_balancing.cloud_service_type import CLOUD_SERVICE_TYPES _LOGGER = logging.getLogger(__name__) class LoadBalancingManager(GoogleCloudManager): connector_name = 'LoadBalancingConnector' cloud_service_types = CLOUD_SERVICE_TYPES def collect_cloud_service(self, params): _LOGGER.debug(f'** Load Balancing START **') start_time = time.time() """ Args: params: - options - schema - secret_data - filter - zones Response: CloudServiceResponse/ErrorResourceResponse """ collected_cloud_services = [] error_responses = [] lb_id = "" secret_data = params['secret_data'] load_bal_conn: LoadBalancingConnector = self.locator.get_connector(self.connector_name, **params) project_id = secret_data.get('project_id') load_balancers = [] instance_groups = load_bal_conn.list_instance_groups() target_pools = load_bal_conn.list_target_pools() url_maps = load_bal_conn.list_url_maps() forwarding_rules = load_bal_conn.list_forwarding_rules() backend_services = load_bal_conn.list_back_end_services() backend_buckets = load_bal_conn.list_back_end_buckets() ssl_certificates = load_bal_conn.list_ssl_certificates() auto_scalers = load_bal_conn.list_auto_scalers() health_checks = load_bal_conn.list_health_checks() legacy_health_checks = [] http_health_checks = load_bal_conn.list_http_health_checks() https_health_checks = load_bal_conn.list_https_health_checks() legacy_health_checks.extend(http_health_checks) legacy_health_checks.extend(https_health_checks) # proxies grpc_proxies = load_bal_conn.list_grpc_proxies() http_proxies = load_bal_conn.list_target_http_proxies() https_proxies = load_bal_conn.list_target_https_proxies() ssl_proxies = load_bal_conn.list_ssl_proxies() tcp_proxies = load_bal_conn.list_tcp_proxies() target_proxies, selective_proxies = self.get_all_proxy_list(grpc_proxies, http_proxies, https_proxies, ssl_proxies, tcp_proxies, forwarding_rules) lbs_from_proxy = self.get_load_balacer_from_target_proxy(backend_services, selective_proxies, project_id) lbs_from_url_map = self.get_load_balancer_from_url_maps(url_maps, backend_services, backend_buckets, project_id) lbs_from_target_pool = self.get_load_balancer_from_target_pools(target_pools, project_id) load_balancers.extend(lbs_from_proxy) load_balancers.extend(lbs_from_url_map) load_balancers.extend(lbs_from_target_pool) for load_balancer in load_balancers: try: lb_id = load_balancer.get('id') lb_type = load_balancer.get('lb_type') health_checks_vo = load_balancer.get('heath_check_vos', {}) health_self_links = health_checks_vo.get('health_check_self_link_list', []) ################################## # Set Target Proxies ################################## if lb_type != 'target_proxy': matched_target_proxies, matched_certificates = self.get_matched_target_proxies(load_balancer, target_proxies, ssl_certificates) load_balancer.update({'target_proxies': matched_target_proxies, 'certificates': matched_certificates}) ################################## # Set forwarding Rules to Load Balancer ################################## matched_forwarding_rules = self.get_matched_forwarding_rules(load_balancer, forwarding_rules) load_balancer.update({'forwarding_rules': matched_forwarding_rules}) ################################## # Set Health Check to Load Balancer ################################## if len(health_self_links) > 0: filter_check_list = list(set(health_checks_vo.get('health_check_list', []))) filter_check_self_link_list = list(set(health_checks_vo.get('health_check_self_link_list', []))) matched_health_list = self._get_matched_health_checks(filter_check_self_link_list, health_checks) if len(matched_health_list) == len(filter_check_list): load_balancer['heath_check_vos'].update({ 'health_check_list': filter_check_list, 'health_check_self_link_list': filter_check_self_link_list, 'health_checks': matched_health_list }) else: matched_health_legacy_list = self._get_matched_health_checks(filter_check_self_link_list, legacy_health_checks) matched_health_list.extend(matched_health_legacy_list) load_balancer['heath_check_vos'].update({ 'health_check_list': filter_check_list, 'health_check_self_link_list': filter_check_self_link_list, 'health_checks': matched_health_list }) ############################ # Set Front to Load Balancer ############################ frontends = self.get_front_from_loadbalancer(load_balancer) frontend_display = self._get_frontend_display(frontends) if len(frontends) > 0: load_balancer.update({'frontends': frontends, 'frontend_display': frontend_display}) ############################# # Set Backend to Load Balancer ############################# backend_vo = {} if lb_type in ['target_pool']: backend_vo.update({ 'type': 'target_pool', 'target_pool_backend': self.get_backend_from_target_pools(load_balancer, instance_groups) }) elif lb_type in ['url_map', 'target_proxy']: key = 'proxy_backend' if lb_type == 'target_proxy' else 'url_map_backend' backends = self.get_backend_from_url_map_and_proxy(load_balancer, instance_groups, auto_scalers) backend_vo.update({ 'type': 'proxy' if lb_type == 'target_proxy' else 'url_map', key: backends }) load_balancer.update({'backends': backend_vo}) ######################################## # Set Backend Tab to LoadBalancer ######################################## backends_tab = self._get_backend_tabs(load_balancer) load_balancer.update({ 'backend_tabs': backends_tab }) ######################################## # Set Backend Display ######################################## backend_display = self._get_backend_display(load_balancer) load_balancer.update({ 'backends_display': backend_display }) ''' Get Appropriate Region & Protocols Protocols - 1. Frontend's forwarding Maps 2. Backend's end protocol Region - backend-svc's backend ''' lead_protocol = self._get_lead_protocol(load_balancer) region = self._get_proper_region(load_balancer) load_balancer.update({ 'lead_protocol': lead_protocol, 'region': region }) refer_link = self._get_refer_link(load_balancer, project_id) _name = load_balancer.get('name', '') load_balance_data = LoadBalancing(load_balancer, strict=False) lb_resource = LoadBalancingResource({ 'name': _name, 'region_code': region, 'data': load_balance_data, 'reference': ReferenceModel(load_balance_data.reference(refer_link)) }) self.set_region_code(region) collected_cloud_services.append(LoadBalancingResponse({'resource': lb_resource})) except Exception as e: _LOGGER.error(f'[collect_cloud_service] => {e}') error_response = self.generate_resource_error_response(e, 'NetworkService', 'LoadBalancing', lb_id) error_responses.append(error_response) _LOGGER.debug(f'** Load Balancing Finished {time.time() - start_time} Seconds **') return collected_cloud_services, error_responses def get_backend_from_target_pools(self, loadbalcnacer, instance_group): for pool in loadbalcnacer.get('target_pools', []): ratio = pool.get('failover_ratio') target_backend = { 'name': pool.get('name'), 'region': self._get_matched_last_target('region', pool), 'session_affinity': pool.get('session_affinity'), 'health_check': self._get_matched_last_target_in_list(pool.get('health_checks', [])), 'backup_pool': self._get_matched_last_target('backup_pool', pool) if pool.get('backup_pool') else '', 'fail_over': 0.0 if ratio is None else float(ratio), 'fail_over_display': '0.0 %' if ratio is None else f'{str(float(ratio) * 100)} %', 'backend_instances': self.get_instance_for_back_ends(loadbalcnacer, pool, instance_group) } return target_backend def get_backend_from_url_map_and_proxy(self, loadbalcnacer, instance_group, auto_scalers): target_backend_list = [] backend_services = loadbalcnacer.get('backend_services', []) backend_buckets = loadbalcnacer.get('backend_buckets', []) for service in backend_services: selected_port = self.get_selected_port(service.get('healthChecks'), loadbalcnacer.get('heath_check_vos')) for backend_service_back in service.get('backends', []): balancing_mode = backend_service_back.get('balancingMode') balancing_mode_display = self._get_balancing_mode_display(backend_service_back) auto_scaler_vo = self._get_selected_instance_group(backend_service_back, instance_group, auto_scalers) target_backend_svc = { 'name': service.get('name'), 'type': 'Instance group', 'instance_name': self._get_matched_last_target('group', backend_service_back), 'region': self.get_region_from_group(backend_service_back.get('group', '')), 'cloud_cdn': 'enabled' if service.get('enableCdn') else 'disabled', 'end_point_protocol': service.get('protocol'), 'named_port': service.get('portName'), 'timeout': str(service.get('timeoutSec')) + ' seconds', 'health_check': self._get_matched_last_target_in_list(service.get('healthChecks', [])), 'capacity': float(backend_service_back.get('capacityScaler', 0.0)), 'capacity_display': str(float(backend_service_back.get('capacityScaler', 0.0)) * 100) + ' %', 'selected_port': selected_port, 'balancing_mode': balancing_mode, 'balancing_mode_display': balancing_mode_display, 'scheme': service.get('loadBalancingScheme') } if auto_scaler_vo is not None: auto_display = self._get_autoscaling_display(auto_scaler_vo) target_backend_svc.update({ 'autoscaling_policy': auto_scaler_vo, 'autoscaling_display': 'No configuration' if auto_display == '' else auto_display, }) else: target_backend_svc.update({ 'autoscaling_display': 'No configuration', }) target_backend_list.append(target_backend_svc) for bucket in backend_buckets: region = self._get_matched_last_target('region', bucket) if bucket.get('region') else 'global' target_backend_bucket = { 'name': bucket.get('name'), 'instance_name': bucket.get('bucketName'), 'type': 'Backend Bucket', 'region': region, 'cloud_cdn': 'enabled' if bucket.get('enableCdn') else 'disabled', 'custom_response_headers': bucket.get('customResponseHeaders', []) } target_backend_list.append(target_backend_bucket) return target_backend_list def get_selected_port(self, health_checks, health_checks_vos): selected_port = [] for hk in health_checks: for single_hk in health_checks_vos.get('health_checks', []): if hk == single_hk.get('selfLink'): key = self._get_key_name_for_health_check(single_hk) hc_vo = single_hk.get(key, {}).get('port') if key and hc_vo: selected_port.append(hc_vo) return selected_port def get_region_from_group(self, group_link): if '/zones/' in group_link: parsed_group = group_link[group_link.find('/zones/') + 7:] zone = parsed_group[:parsed_group.find('/')] return zone[:-2] else: return self._extract_region_from_group(group_link) def get_instance_for_back_ends(self, lb, pool, instance_groups): instance_list = [] instances = pool.get('instances', []) addresses = [d.get('IPAddress') for d in lb.get('forwarding_rules', []) if d.get('IPAddress', '') != ''] source_link = lb.get('source_link') for instance_group in instance_groups: if source_link in instance_group.get('targetPools', []): instance_list.append({ 'type': 'Instance Group', 'name': instance_group.get('name'), 'region': 'global' if instance_group.get('region') is None else self._get_matched_last_target( 'region', instance_group), 'zone': '', 'address': addresses }) for instance in instances: zone = self._extract_zone(instance) instance_list.append({ 'type': 'Compute VM', 'name': instance[instance.rfind('/') + 1:], 'region': zone[:-2], 'zone': zone, 'address': addresses }) return instance_list def get_all_proxy_list(self, grpc_proxies, http_proxies, https_proxies, ssl_proxies, tcp_proxies, forwarding_rules): proxy_list = [] proxy_list_relate_to_load_balancer = [] all_resources = [{'type': 'grpc', 'source': grpc_proxies}, {'type': 'http', 'source': http_proxies}, {'type': 'https', 'source': https_proxies}, {'type': 'ssl', 'source': ssl_proxies}, {'type': 'tcp', 'source': tcp_proxies} ] for resource in all_resources: for proxy in resource.get('source', []): proxy_type = resource.get('type') proxy_key: str = self._get_proxy_key(resource.get('type')) in_used_by, in_used_by_display = self._get_in_used_by_forwarding_rule(proxy, forwarding_rules) proxy_vo = { proxy_key: proxy, 'proxy_key': proxy_key, 'type': proxy_type, 'name': proxy.get('name', ''), 'description': proxy.get('description', ''), 'target_resource': {}, 'in_used_by': in_used_by, 'target_proxy_display': { 'name': proxy.get('name', ''), 'description': proxy.get('description', ''), 'type': f'{proxy_type.upper()} Proxy', 'target_resource': self._get_matched_last_target('urlMap', proxy), 'in_used_by_display': in_used_by_display, 'creation_timestamp': proxy.get('creationTimestamp'), }, } if proxy_type in ['ssl', 'tcp']: proxy_list_relate_to_load_balancer.append(proxy_vo) proxy_list.append(proxy_vo) return proxy_list, proxy_list_relate_to_load_balancer def get_load_balancer_from_url_maps(self, url_maps, backend_services, backend_buckets, project): load_balancer_list = [] for url_map in url_maps: region = self._get_matched_last_target('region', url_map) if url_map.get('region') else 'global' url_map_single_vo = {} identifiers = self._get_matched_services(url_map) backend_svc_list = self.get_lb_info_from_selected_items(identifiers, 'selfLink', backend_services) health_check_list = self._get_health_checks_from_backend_svc(backend_svc_list) backend_bucktet_list = self.get_lb_info_from_selected_items(identifiers, 'selfLink', backend_buckets) host_and_path_rules = self.get_matched_host_and_path(url_map) url_map_single_vo.update({ 'lb_type': 'url_map', 'project': project, 'region': region, 'id': url_map.get('id'), 'description': url_map.get('description', ''), 'name': url_map.get('name'), 'self_link': self._get_self_link(project, region, url_map.get('name')), 'identifier': url_map.get('selfLink'), 'heath_check_vos': { 'health_check_list': self._get_matched_last_target_in_list(health_check_list), 'health_check_self_link_list': health_check_list, }, 'backend_services': backend_svc_list, 'backend_buckets': backend_bucktet_list, 'host_and_paths': host_and_path_rules, 'creation_timestamp': url_map.get('creationTimestamp') }) load_balancer_list.append(url_map_single_vo) return load_balancer_list def get_load_balancer_from_target_pools(self, target_pools, project): load_balancer_list = [] for target_pool in target_pools: region = self._get_matched_last_target('region', target_pool) if target_pool.get('region') else 'global' health_checks = target_pool.get('healthChecks', []) target_pool.update({ '_region': region, 'num_of_instance': len(target_pool.get('instances', [])), '_health_checks': self._get_matched_last_target_in_list(health_checks) }) target_pool_vo = { 'lb_type': 'target_pool', 'project': project, 'region': region, 'description': target_pool.get('description'), 'id': target_pool.get('id'), 'name': target_pool.get('name'), 'heath_check_vos': { 'health_check_list': self._get_matched_last_target_in_list(health_checks), 'health_check_self_link_list': health_checks, }, 'identifier': target_pool.get('selfLink'), 'self_link': self._get_self_link(project, region, target_pool.get('name')), 'creation_timestamp': target_pool.get('creationTimestamp'), 'target_pools': [TargetPools(target_pool, strict=False)] } load_balancer_list.append(target_pool_vo) return load_balancer_list def get_load_balacer_from_target_proxy(self, backends, selective_proxies, project): backend_proxies = [] for ssl_tcp_proxy in selective_proxies: key = 'tcp_proxy' if 'tcp_proxy' in ssl_tcp_proxy else 'ssl_proxy' proxy_info = ssl_tcp_proxy.get(key, {}) for backend in backends: health_checks = backend.get('healthChecks', []) if backend.get('selfLink') == proxy_info.get('service', ''): region = self._extract_region_from_proxy(backend.get('selfLink'), project) backend.update({'region': region, 'type': 'Global' if region == 'global' else region}) backend_proxy_vo = { 'lb_type': 'target_proxy', 'project': project, 'id': proxy_info.get('id'), 'region': region, 'name': proxy_info.get('name'), 'self_link': self._get_self_link(project, region, proxy_info.get('name')), 'heath_check_vos': { 'health_check_list': self._get_matched_last_target_in_list(health_checks), 'health_check_self_link_list': health_checks, }, 'identifier': proxy_info.get('selfLink'), 'creation_timestamp': proxy_info.get('creationTimestamp'), 'target_proxies': [ssl_tcp_proxy], 'backend_services': [backend] } backend_proxies.append(backend_proxy_vo) return backend_proxies def get_matched_forwarding_rules(self, loadbalancer, forwarding_rules): matched_forwarding_rules = [] lb_type = loadbalancer.get('lb_type') if lb_type == 'target_pool': for forwarding_rule in forwarding_rules: if loadbalancer.get('identifier') == forwarding_rule.get('target'): region = forwarding_rule.get('region') r_type = 'Global' if region == 'global' or region is None else 'Regional' if r_type == 'Regional': _region = region[region.rfind('/')+1:] forwarding_rule.update({'region': _region}) forwarding_rule.update({'type': r_type}) if forwarding_rule.get('portRange', '').find('-') > 0: forwarding_rule.update({'portRange': self._get_port_ranage_from_str(forwarding_rule.get('portRange', ''))}) matched_forwarding_rules.append(forwarding_rule) elif lb_type in ['url_map', 'target_proxy']: self_links = self._get_self_links_from_proxies(loadbalancer.get('target_proxies', [])) for forwarding_rule in forwarding_rules: if forwarding_rule.get('target') in self_links: region = forwarding_rule.get('region') r_type = 'Global' if region == 'global' or region is None else 'Regional' if r_type == 'Regional': _region = region[region.rfind('/')+1:] forwarding_rule.update({'region': _region}) forwarding_rule.update({'type': r_type}) if forwarding_rule.get('portRange', '').find('-') > 0: forwarding_rule.update({'portRange': self._get_port_ranage_from_str(forwarding_rule.get('portRange', ''))}) matched_forwarding_rules.append(forwarding_rule) return matched_forwarding_rules def get_matched_target_proxies(self, lb, target_proxies, certs): matched_target_proxies = [] matched_certificate = [] for target_proxy in target_proxies: key = target_proxy.get('proxy_key') proxy_info = target_proxy.get(key, {}) if 'urlMap' in proxy_info: if proxy_info.get('urlMap') == lb.get('identifier'): if 'sslCertificates' in proxy_info: matching_ones = self._get_matched_certificates(certs, proxy_info.get('sslCertificates', [])) for matching_one in matching_ones: key = 'managed' if 'managed' in matching_one else 'selfManaged' ssl_type = 'Customer supplied' if key == 'managed': ssl_type = 'Google managed' elif key == 'selfManaged': ssl_type = 'Customer managed' managed = matching_one.get(key, {}) domain_info = managed.get('domainStatus', {}) domain_status = self.convert_labels_format(managed.get('domainStatus', {})) domains = [dd for dd in domain_info] matching_one.update({ 'domains': domains, 'type': ssl_type }) if domain_status: matching_one['managed'].update({'domain_status': domain_status}) matched_certificate.append(matching_one) matched_target_proxies.append(target_proxy) return matched_target_proxies, matched_certificate def get_matched_host_and_path(self, target_item): host_and_path_rules = [] if 'defaultService' in target_item: host_and_path_rules.append({ 'host': ['All unmatched (default)'], 'path': ['All unmatched (default)'], 'backend': self._get_matched_last_target('defaultService', target_item) }) if 'hostRules' in target_item: host_rule_map = {} for host_rule in target_item.get('hostRules', []): host_rule_map[host_rule.get('pathMatcher')] = {'host': host_rule.get('hosts', [])} for path_matcher in target_item.get('pathMatchers', []): _name = path_matcher.get('name', '') default_service = path_matcher.get('defaultService') if default_service: host_and_path_rules.append({ 'host': host_rule_map.get(_name, {}).get('host'), 'path': ['/*'], 'backend': self._get_matched_last_target('defaultService', target_item) }) for path_rule in path_matcher.get('pathRules', []): host_and_path_rules.append({ 'host': host_rule_map.get(_name, {}).get('host'), 'path': path_rule.get('paths', []), 'backend': self._get_matched_last_target('service', path_rule) }) return host_and_path_rules def get_front_from_loadbalancer(self, loadbalancer): frontends = [] proxies = loadbalancer.get('target_proxies', []) pools = loadbalancer.get('target_pools', []) for forwarding_rule in loadbalancer.get('forwarding_rules', []): target = forwarding_rule.get('target', '') ports = forwarding_rule.get('ports', []) region = 'global' if forwarding_rule.get('region') is None else forwarding_rule.get('region') _region = region[region.rfind('/') + 1:] if not proxies: for pool in pools: if target == pool.get('self_link'): front_single = { 'name': forwarding_rule.get('name'), 'protocols': forwarding_rule.get('IPProtocol').upper(), 'scope': 'Global' if region == 'global' else f'Regional ({_region})', 'region': _region, 'ip_address': forwarding_rule.get('IPAddress'), 'port': self._get_list_from_str( forwarding_rule.get('portRange')) if not ports else self._get_list_from_str(ports), 'network_tier': forwarding_rule.get('networkTier').capitalize() } frontends.append(front_single) else: for proxy in proxies: key = proxy.get('proxy_key', '') proxy_vo = proxy.get(key) if target == proxy_vo.get('selfLink'): front_single = { 'name': forwarding_rule.get('name'), 'protocols': proxy.get('type').upper(), 'scope': 'Global' if region == 'global' else f'Regional ({_region})', 'region': _region, 'ip_address': forwarding_rule.get('IPAddress'), 'port': self._get_list_from_str( forwarding_rule.get('portRange')) if not ports else self._get_list_from_str(ports), 'network_tier': forwarding_rule.get('networkTier').capitalize() } if 'sslCertificates' in proxy_vo: front_single.update( {'certificate': self._get_matched_last_target_in_list(proxy_vo.get('sslCertificates'))}) frontends.append(front_single) return frontends @staticmethod def _get_frontend_display(frontend): frontend_display = '' rule_length = len(frontend) if rule_length > 0: regions = list(set([ft.get('region') for ft in frontend if 'region' in ft])) located_at = regions[0] if len(regions) == 1 else 'Multi regions' if len(regions) > 1 else '' _located_at = f'within {located_at}' if located_at != '' else '' plural = '' if rule_length == 1 else 's' frontend_display = f'{rule_length} Forwarding Rule{plural} {_located_at}' return frontend_display @staticmethod def _get_refer_link(lb, project): base = 'https://console.cloud.google.com/net-services/loadbalancing/details' lb_type = lb.get('lb_type') name = lb.get('name') region = lb.get('region') if lb_type == 'url_map': return base + f'/http/{name}?project={project}' elif lb_type == 'target_pool': return base + f'/network/{region}/{name}?project={project}' else: return base + f'/proxy/{name}?project={project}' @staticmethod def _get_proper_region(lb): lb_type = lb.get('lb_type') proper_region = '' if lb_type == 'url_map': backends = lb.get('backends', {}) _type = backends.get('type') _backends = backends.get(f'{_type}_backend', []) prop = [backend.get('region') for backend in _backends if backend.get('region', '') != 'global'] _prop = list(set(prop)) proper_region = 'global' if not _prop else _prop[0] elif lb_type == 'target_pool': proper_region = lb.get('region') else: proper_region = lb.get('region') return proper_region @staticmethod def _get_lead_protocol(load_balancer): lead_protocol = '' all_protocols = [d.get('protocols') for d in load_balancer.get('frontends', []) if 'protocols' in d] if len(all_protocols) > 0: lead_protocol = 'HTTP(S)' if 'HTTPS' in all_protocols and 'HTTP' in all_protocols else all_protocols[0] else: all_protocols = [d.get('type').upper() for d in load_balancer.get('target_proxies', []) if 'type' in d] lead_protocol = f'{all_protocols[0]} (Proxy)' if len(all_protocols) > 0 else 'TCP/UDP' return lead_protocol @staticmethod def _get_backend_tabs(load_balancers): backends_tab_list = [] backends = load_balancers.get('backends', {}) backends_type = backends.get('type') object_key = f'{backends_type}_backend' if backends_type in ['proxy', 'url_map']: for back_end in backends.get(object_key, []): _region = back_end.get('region') backends_tab_list.append({ 'name': back_end.get('name'), 'type': 'Backend Bucket' if back_end.get('type') == 'Backend Bucket' else 'Backend service', 'scope': 'Global' if _region == 'global' else f'Regional ({_region})', 'protocol': back_end.get('end_point_protocol', ''), }) else: back_end = backends.get(object_key, {}) _region = back_end.get('region') protocol = back_end.get('end_point_protocol', '') backends_tab_list.append({ 'name': back_end.get('name'), 'type': 'Backend Bucket' if back_end.get('type') == 'Backend Bucket' else 'Backend service', 'scope': 'Global' if _region == 'global' else f'Regional ({_region})', 'protocol': '', }) return backends_tab_list @staticmethod def _get_backend_display(load_balancer): lb_type = load_balancer.get('lb_type') display = '' if lb_type == 'target_pool': _pools = len(load_balancer.get('target_pools', [])) pools = load_balancer.get('target_pools', []) num_of_instance = 0 for pool in pools: num_of_instance = num_of_instance + len(pool.get('instances', [])) pool_plural = '(s)' if _pools > 1 else '' num_plural = 's' if num_of_instance > 1 else '' display = f'{_pools} Target pool{pool_plural}' if num_of_instance == 0 else \ f'{_pools} Target pool{pool_plural} ({num_of_instance} Instance{num_plural})' else: service = len(load_balancer.get('backend_services', [])) bucket = len(load_balancer.get('backend_buckets', [])) display = f'{service} Backend Services & {bucket} Backend Buckets' if service > 0 and bucket > 0 \ else f'{bucket} Backend Buckets' if bucket > 0 else f'{service} Backend Service' return display @staticmethod def _extract_zone(self_link): p_len = len('/zones/') p_key = '/zones/' _zone = self_link[self_link.find(p_key) + p_len:] return _zone[:_zone.find('/')] @staticmethod def _get_matched_certificates(certs, ssl_certificates): certificates = [] for cert in certs: if cert.get('selfLink', '') in ssl_certificates: certificates.append(cert) return certificates @staticmethod def _get_matched_services(target_item): matching_item_self_links = [] if 'defaultService' in target_item: matching_item_self_links.append(target_item.get('defaultService')) if 'pathMatchers' in target_item and isinstance(target_item.get('pathMatchers'), list): for path_matcher in target_item.get('pathMatchers'): if path_matcher.get('defaultService', '') not in matching_item_self_links: matching_item_self_links.append(path_matcher.get('defaultService', '')) if 'pathRules' in path_matcher and isinstance(path_matcher.get('pathRules'), list): for rule in path_matcher.get('pathRules'): if rule.get('service') not in matching_item_self_links: matching_item_self_links.append(rule.get('service')) return matching_item_self_links @staticmethod def _get_self_links_from_proxies(target_proxies): self_link_list = [] for proxy in target_proxies: key = proxy.get('proxy_key') self_link = proxy.get(key, {}).get('selfLink') if self_link: self_link_list.append(self_link) return self_link_list @staticmethod def _get_matched_last_target(key, source): a = source.get(key, '') return a[a.rfind('/') + 1:] @staticmethod def _get_matched_last_target_in_list(target_list): matched_links_vos = [] for target_item in target_list: a = target_item matched_links_vos.append(a[a.rfind('/') + 1:]) return matched_links_vos @staticmethod def _get_self_link(project, region, name): return f'https://www.googleapis.com/compute/v1/projects/{project}/regions/{region}/load_balancing/{name}' @staticmethod def _get_zone_from_target(key, source): a = source.get(key, '') return a[a.find('zones') + 6:a.find('/instances')] @staticmethod def _get_list_from_str(target_str): switching_target = None if isinstance(target_str, int): switching_target = target_str else: port_range = target_str.split('-') switching_target = port_range[0] if len(port_range) > 1 and port_range[0] == port_range[1] else target_str return switching_target if isinstance(switching_target, list) else [switching_target] @staticmethod def _get_port_ranage_from_str(target_str): port_range = target_str.split('-') switching_target = port_range[0] if len(port_range) > 1 and port_range[0] == port_range[1] else target_str return switching_target @staticmethod def _get_in_used_by_forwarding_rule(target_proxy, forwarding_rules): in_used_by = [] in_used_by_display = [] for forwarding_rule in forwarding_rules: if forwarding_rule.get('target') == target_proxy.get('selfLink'): in_used_by.append({ 'id': forwarding_rule.get('id', ''), 'name': forwarding_rule.get('name', ''), 'self_link': forwarding_rule.get('selfLink', ''), }) in_used_by_display.append(forwarding_rule.get('name', '')) return in_used_by, in_used_by_display @staticmethod def _get_matching_target_proxy(loadbalancer, all_proxies): target_proxies = [] for proxy in all_proxies: proxy_key: str = 'grpc_proxy' if 'grpc_proxy' in proxy \ else 'http_proxy' if 'http_proxy' in proxy else 'https_proxy' selected_px = proxy.get(proxy_key, {}).get('url_map', '') if selected_px == loadbalancer.get('identifier', ''): proxy['target_resource'].update({ 'id': loadbalancer.get('id'), 'name': loadbalancer.get('name'), 'self_link': loadbalancer.get('identifier') }) target_proxies.append(proxy) return target_proxies @staticmethod def _extract_region_from_proxy(self_link, project): p_len = len(project) + 1 p_key = f'{project}/' _region = self_link[self_link.find(p_key) + p_len:] return _region[:_region.find('/')] @staticmethod def _extract_region_from_group(self_link): p_len = 9 p_key = self_link.find('/regions/') if p_key == -1: return 'global' else: _region = self_link[p_key + p_len:] return _region[:_region.find('/')] @staticmethod def _get_proxy_key(proxy_type): proxy_key = 'tcp_proxy' if proxy_type == 'grpc': proxy_key = 'grpc_proxy' elif proxy_type == 'http': proxy_key = 'http_proxy' elif proxy_type == 'https': proxy_key = 'https_proxy' elif proxy_type == 'ssl': proxy_key = 'ssl_proxy' return proxy_key def get_lb_info_from_selected_items(self, identifier, key, selected_items): matched_lb_vo = [] for selected_item in selected_items: if selected_item.get(key, '') in identifier: region = self._extract_region_from_group(selected_item.get(key, '')) _type = 'Global' if region == 'global' else 'Regional' selected_item.update({ 'region': self._extract_region_from_group(selected_item.get(key, '')), 'type': _type }) matched_lb_vo.append(selected_item) return matched_lb_vo @staticmethod def _get_matched_health_checks(self_link_list, health_checks): health_check_list = [] for health_check in health_checks: if health_check.get('selfLink', '') in self_link_list: health_check_list.append(health_check) return health_check_list @staticmethod def _get_health_checks_from_backend_svc(backend_svcs): health_check_list = [] for backend_svc in backend_svcs: if len(backend_svc.get('healthChecks', [])) > 0: health_check_list.extend(backend_svc.get('healthChecks')) return health_check_list @staticmethod def _get_autoscaling_display(autoscaling_policy): auto_scaling_display = '' if 'cpuUtilization' in autoscaling_policy: cpu_util = autoscaling_policy.get('cpuUtilization', {}) target = float(cpu_util.get('utilizationTarget', 0.0)) * 100 auto_scaling_display = f'On: Target CPU utilization {target} %' elif 'loadBalancingUtilization' in autoscaling_policy: cpu_util = autoscaling_policy.get('loadBalancingUtilization', {}) target = float(cpu_util.get('utilizationTarget', 0.0)) * 100 auto_scaling_display = f'On: Load balancing utilization {target} %' elif 'customMetricUtilizations' in autoscaling_policy: auto_scaling_display = f'On: custom metrics' return auto_scaling_display @staticmethod def _get_balancing_mode_display(backend): display_msg = 'No configuration' if 'maxUtilization' in backend: rate = float(backend.get('maxUtilization', 0.0)) * 100 display_msg = f'Max Backend Utilization: {rate} %' elif 'maxRate' in backend: rate = int(backend.get('maxRate', 0)) display_msg = f'Max Backend Rate: {rate}' elif 'maxRatePerInstance' in backend: rate = float(backend.get('maxRatePerInstance', 0.0)) display_msg = f'Max Backend Rate Per Instance: {rate}' elif 'maxRatePerEndpoint' in backend: rate = float(backend.get('maxRatePerEndpoint', 0.0)) display_msg = f'Max Backend Rate Per Endpoint: {rate}' elif 'maxConnections' in backend: rate = int(backend.get('maxConnections', 0)) display_msg = f'Max Backend Connection: {rate}' elif 'maxConnectionsPerInstance' in backend: rate = int(backend.get('maxConnectionsPerInstance', 0)) display_msg = f'Max Backend Connections Per Instance: {rate}' elif 'maxConnectionsPerEndpoint' in backend: rate = int(backend.get('maxConnectionsPerEndpoint', 0)) display_msg = f'Max Backend Connections Per Endpoint: {rate}' return display_msg @staticmethod def _get_selected_instance_group(backend, instance_groups, auto_scalers): for instance_group in instance_groups: if backend.get('group') == instance_group.get('instanceGroup'): for auto_scaler in auto_scalers: if auto_scaler.get('target') == instance_group.get('selfLink'): auto_policy = auto_scaler.get('autoscalingPolicy', {}) return auto_policy @staticmethod def _get_key_name_for_health_check(hk): if 'tcpHealthCheck' in hk: return 'tcpHealthCheck' elif 'sslHealthCheck' in hk: return 'tcpHealthCheck' elif 'httpHealthCheck' in hk: return 'tcpHealthCheck' elif 'httpsHealthCheck' in hk: return 'tcpHealthCheck' elif 'http2HealthCheck' in hk: return 'tcpHealthCheck' elif 'grpcHealthCheck' in hk: return 'grpcHealthCheck' else: return None
the-stack_106_32218
""" Generic data algorithms. This module is experimental at the moment and not intended for public consumption """ from __future__ import annotations import operator from textwrap import dedent from typing import ( TYPE_CHECKING, Dict, Optional, Tuple, Union, cast, ) from warnings import ( catch_warnings, simplefilter, warn, ) import numpy as np from pandas._libs import ( algos, hashtable as htable, iNaT, lib, ) from pandas._typing import ( AnyArrayLike, ArrayLike, DtypeObj, FrameOrSeriesUnion, ) from pandas.util._decorators import doc from pandas.core.dtypes.cast import ( construct_1d_object_array_from_listlike, infer_dtype_from_array, ) from pandas.core.dtypes.common import ( ensure_float64, ensure_int64, ensure_object, ensure_platform_int, ensure_uint64, is_array_like, is_bool_dtype, is_categorical_dtype, is_complex_dtype, is_datetime64_dtype, is_datetime64_ns_dtype, is_extension_array_dtype, is_float_dtype, is_integer, is_integer_dtype, is_list_like, is_numeric_dtype, is_object_dtype, is_period_dtype, is_scalar, is_signed_integer_dtype, is_timedelta64_dtype, is_unsigned_integer_dtype, needs_i8_conversion, pandas_dtype, ) from pandas.core.dtypes.dtypes import PandasDtype from pandas.core.dtypes.generic import ( ABCDatetimeArray, ABCExtensionArray, ABCIndex, ABCMultiIndex, ABCRangeIndex, ABCSeries, ABCTimedeltaArray, ) from pandas.core.dtypes.missing import ( isna, na_value_for_dtype, ) from pandas.core.array_algos.take import take_nd from pandas.core.construction import ( array as pd_array, ensure_wrapped_if_datetimelike, extract_array, ) from pandas.core.indexers import validate_indices if TYPE_CHECKING: from pandas import ( Categorical, DataFrame, Index, Series, ) from pandas.core.arrays import ( DatetimeArray, TimedeltaArray, ) _shared_docs: Dict[str, str] = {} # --------------- # # dtype access # # --------------- # def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]: """ routine to ensure that our data is of the correct input dtype for lower-level routines This will coerce: - ints -> int64 - uint -> uint64 - bool -> uint64 (TODO this should be uint8) - datetimelike -> i8 - datetime64tz -> i8 (in local tz) - categorical -> codes Parameters ---------- values : array-like Returns ------- values : ndarray pandas_dtype : np.dtype or ExtensionDtype """ if not isinstance(values, ABCMultiIndex): # extract_array would raise values = extract_array(values, extract_numpy=True) # we check some simple dtypes first if is_object_dtype(values): return ensure_object(np.asarray(values)), np.dtype("object") try: if is_bool_dtype(values): # we are actually coercing to uint64 # until our algos support uint8 directly (see TODO) return np.asarray(values).astype("uint64"), np.dtype("bool") elif is_signed_integer_dtype(values): return ensure_int64(values), np.dtype("int64") elif is_unsigned_integer_dtype(values): return ensure_uint64(values), np.dtype("uint64") elif is_float_dtype(values): return ensure_float64(values), np.dtype("float64") elif is_complex_dtype(values): # ignore the fact that we are casting to float # which discards complex parts with catch_warnings(): simplefilter("ignore", np.ComplexWarning) values = ensure_float64(values) return values, np.dtype("float64") except (TypeError, ValueError, OverflowError): # if we are trying to coerce to a dtype # and it is incompatible this will fall through to here return ensure_object(values), np.dtype("object") # datetimelike if needs_i8_conversion(values.dtype): if is_period_dtype(values.dtype): from pandas import PeriodIndex values = PeriodIndex(values)._data elif is_timedelta64_dtype(values.dtype): from pandas import TimedeltaIndex values = TimedeltaIndex(values)._data else: # Datetime if values.ndim > 1 and is_datetime64_ns_dtype(values.dtype): # Avoid calling the DatetimeIndex constructor as it is 1D only # Note: this is reached by DataFrame.rank calls GH#27027 # TODO(EA2D): special case not needed with 2D EAs asi8 = values.view("i8") dtype = values.dtype return asi8, dtype from pandas import DatetimeIndex values = DatetimeIndex(values)._data dtype = values.dtype return values.asi8, dtype elif is_categorical_dtype(values.dtype): values = cast("Categorical", values) values = values.codes dtype = pandas_dtype("category") # we are actually coercing to int64 # until our algos support int* directly (not all do) values = ensure_int64(values) return values, dtype # we have failed, return object values = np.asarray(values, dtype=object) return ensure_object(values), np.dtype("object") def _reconstruct_data( values: ArrayLike, dtype: DtypeObj, original: AnyArrayLike ) -> ArrayLike: """ reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.ndtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray """ if isinstance(values, ABCExtensionArray) and values.dtype == dtype: # Catch DatetimeArray/TimedeltaArray return values if is_extension_array_dtype(dtype): cls = dtype.construct_array_type() if isinstance(values, cls) and values.dtype == dtype: return values values = cls._from_sequence(values) elif is_bool_dtype(dtype): values = values.astype(dtype, copy=False) # we only support object dtypes bool Index if isinstance(original, ABCIndex): values = values.astype(object, copy=False) elif dtype is not None: if is_datetime64_dtype(dtype): dtype = "datetime64[ns]" elif is_timedelta64_dtype(dtype): dtype = "timedelta64[ns]" values = values.astype(dtype, copy=False) return values def _ensure_arraylike(values) -> ArrayLike: """ ensure that we are arraylike if not already """ if not is_array_like(values): inferred = lib.infer_dtype(values, skipna=False) if inferred in ["mixed", "string", "mixed-integer"]: # "mixed-integer" to ensure we do not cast ["ss", 42] to str GH#22160 if isinstance(values, tuple): values = list(values) values = construct_1d_object_array_from_listlike(values) else: values = np.asarray(values) return values _hashtables = { "float64": htable.Float64HashTable, "uint64": htable.UInt64HashTable, "int64": htable.Int64HashTable, "string": htable.StringHashTable, "object": htable.PyObjectHashTable, } def _get_hashtable_algo(values: np.ndarray): """ Parameters ---------- values : np.ndarray Returns ------- htable : HashTable subclass values : ndarray """ values, _ = _ensure_data(values) ndtype = _check_object_for_strings(values) htable = _hashtables[ndtype] return htable, values def _get_values_for_rank(values: ArrayLike): if is_categorical_dtype(values): values = cast("Categorical", values)._values_for_rank() values, _ = _ensure_data(values) return values def get_data_algo(values: ArrayLike): values = _get_values_for_rank(values) ndtype = _check_object_for_strings(values) htable = _hashtables.get(ndtype, _hashtables["object"]) return htable, values def _check_object_for_strings(values: np.ndarray) -> str: """ Check if we can use string hashtable instead of object hashtable. Parameters ---------- values : ndarray Returns ------- str """ ndtype = values.dtype.name if ndtype == "object": # it's cheaper to use a String Hash Table than Object; we infer # including nulls because that is the only difference between # StringHashTable and ObjectHashtable if lib.infer_dtype(values, skipna=False) in ["string"]: ndtype = "string" return ndtype # --------------- # # top-level algos # # --------------- # def unique(values): """ Hash table-based unique. Uniques are returned in order of appearance. This does NOT sort. Significantly faster than numpy.unique for long enough sequences. Includes NA values. Parameters ---------- values : 1d array-like Returns ------- numpy.ndarray or ExtensionArray The return can be: * Index : when the input is an Index * Categorical : when the input is a Categorical dtype * ndarray : when the input is a Series/ndarray Return numpy.ndarray or ExtensionArray. See Also -------- Index.unique : Return unique values from an Index. Series.unique : Return unique values of Series object. Examples -------- >>> pd.unique(pd.Series([2, 1, 3, 3])) array([2, 1, 3]) >>> pd.unique(pd.Series([2] + [1] * 5)) array([2, 1]) >>> pd.unique(pd.Series([pd.Timestamp('20160101'), ... pd.Timestamp('20160101')])) array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]') >>> pd.unique(pd.Series([pd.Timestamp('20160101', tz='US/Eastern'), ... pd.Timestamp('20160101', tz='US/Eastern')])) array([Timestamp('2016-01-01 00:00:00-0500', tz='US/Eastern')], dtype=object) >>> pd.unique(pd.Index([pd.Timestamp('20160101', tz='US/Eastern'), ... pd.Timestamp('20160101', tz='US/Eastern')])) DatetimeIndex(['2016-01-01 00:00:00-05:00'], ... dtype='datetime64[ns, US/Eastern]', freq=None) >>> pd.unique(list('baabc')) array(['b', 'a', 'c'], dtype=object) An unordered Categorical will return categories in the order of appearance. >>> pd.unique(pd.Series(pd.Categorical(list('baabc')))) [b, a, c] Categories (3, object): [b, a, c] >>> pd.unique(pd.Series(pd.Categorical(list('baabc'), ... categories=list('abc')))) [b, a, c] Categories (3, object): [b, a, c] An ordered Categorical preserves the category ordering. >>> pd.unique(pd.Series(pd.Categorical(list('baabc'), ... categories=list('abc'), ... ordered=True))) [b, a, c] Categories (3, object): [a < b < c] An array of tuples >>> pd.unique([('a', 'b'), ('b', 'a'), ('a', 'c'), ('b', 'a')]) array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object) """ values = _ensure_arraylike(values) if is_extension_array_dtype(values): # Dispatch to extension dtype's unique. return values.unique() original = values htable, values = _get_hashtable_algo(values) table = htable(len(values)) uniques = table.unique(values) uniques = _reconstruct_data(uniques, original.dtype, original) return uniques unique1d = unique def isin(comps: AnyArrayLike, values: AnyArrayLike) -> np.ndarray: """ Compute the isin boolean array. Parameters ---------- comps : array-like values : array-like Returns ------- ndarray[bool] Same length as `comps`. """ if not is_list_like(comps): raise TypeError( "only list-like objects are allowed to be passed " f"to isin(), you passed a [{type(comps).__name__}]" ) if not is_list_like(values): raise TypeError( "only list-like objects are allowed to be passed " f"to isin(), you passed a [{type(values).__name__}]" ) if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)): values = _ensure_arraylike(list(values)) elif isinstance(values, ABCMultiIndex): # Avoid raising in extract_array values = np.array(values) else: values = extract_array(values, extract_numpy=True) comps = _ensure_arraylike(comps) comps = extract_array(comps, extract_numpy=True) if is_extension_array_dtype(comps.dtype): return comps.isin(values) elif needs_i8_conversion(comps.dtype): # Dispatch to DatetimeLikeArrayMixin.isin return pd_array(comps).isin(values) elif needs_i8_conversion(values.dtype) and not is_object_dtype(comps.dtype): # e.g. comps are integers and values are datetime64s return np.zeros(comps.shape, dtype=bool) # TODO: not quite right ... Sparse/Categorical elif needs_i8_conversion(values.dtype): return isin(comps, values.astype(object)) elif is_extension_array_dtype(values.dtype): return isin(np.asarray(comps), np.asarray(values)) # GH16012 # Ensure np.in1d doesn't get object types or it *may* throw an exception # Albeit hashmap has O(1) look-up (vs. O(logn) in sorted array), # in1d is faster for small sizes if len(comps) > 1_000_000 and len(values) <= 26 and not is_object_dtype(comps): # If the values include nan we need to check for nan explicitly # since np.nan it not equal to np.nan if isna(values).any(): def f(c, v): return np.logical_or(np.in1d(c, v), np.isnan(c)) else: f = np.in1d else: common = np.find_common_type([values.dtype, comps.dtype], []) values = values.astype(common, copy=False) comps = comps.astype(common, copy=False) name = common.name if name == "bool": name = "uint8" f = getattr(htable, f"ismember_{name}") return f(comps, values) def factorize_array( values: np.ndarray, na_sentinel: int = -1, size_hint: Optional[int] = None, na_value=None, mask: Optional[np.ndarray] = None, ) -> Tuple[np.ndarray, np.ndarray]: """ Factorize an array-like to codes and uniques. This doesn't do any coercion of types or unboxing before factorization. Parameters ---------- values : ndarray na_sentinel : int, default -1 size_hint : int, optional Passed through to the hashtable's 'get_labels' method na_value : object, optional A value in `values` to consider missing. Note: only use this parameter when you know that you don't have any values pandas would consider missing in the array (NaN for float data, iNaT for datetimes, etc.). mask : ndarray[bool], optional If not None, the mask is used as indicator for missing values (True = missing, False = valid) instead of `na_value` or condition "val != val". Returns ------- codes : ndarray uniques : ndarray """ hash_klass, values = get_data_algo(values) table = hash_klass(size_hint or len(values)) uniques, codes = table.factorize( values, na_sentinel=na_sentinel, na_value=na_value, mask=mask ) codes = ensure_platform_int(codes) return codes, uniques @doc( values=dedent( """\ values : sequence A 1-D sequence. Sequences that aren't pandas objects are coerced to ndarrays before factorization. """ ), sort=dedent( """\ sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. """ ), size_hint=dedent( """\ size_hint : int, optional Hint to the hashtable sizer. """ ), ) def factorize( values, sort: bool = False, na_sentinel: Optional[int] = -1, size_hint: Optional[int] = None, ) -> Tuple[np.ndarray, Union[np.ndarray, Index]]: """ Encode the object as an enumerated type or categorical variable. This method is useful for obtaining a numeric representation of an array when all that matters is identifying distinct values. `factorize` is available as both a top-level function :func:`pandas.factorize`, and as a method :meth:`Series.factorize` and :meth:`Index.factorize`. Parameters ---------- {values}{sort} na_sentinel : int or None, default -1 Value to mark "not found". If None, will not drop the NaN from the uniques of the values. .. versionchanged:: 1.1.2 {size_hint}\ Returns ------- codes : ndarray An integer ndarray that's an indexer into `uniques`. ``uniques.take(codes)`` will have the same values as `values`. uniques : ndarray, Index, or Categorical The unique valid values. When `values` is Categorical, `uniques` is a Categorical. When `values` is some other pandas object, an `Index` is returned. Otherwise, a 1-D ndarray is returned. .. note :: Even if there's a missing value in `values`, `uniques` will *not* contain an entry for it. See Also -------- cut : Discretize continuous-valued array. unique : Find the unique value in an array. Examples -------- These examples all show factorize as a top-level method like ``pd.factorize(values)``. The results are identical for methods like :meth:`Series.factorize`. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b']) >>> codes array([0, 0, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) With ``sort=True``, the `uniques` will be sorted, and `codes` will be shuffled so that the relationship is the maintained. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True) >>> codes array([1, 1, 0, 2, 1]...) >>> uniques array(['a', 'b', 'c'], dtype=object) Missing values are indicated in `codes` with `na_sentinel` (``-1`` by default). Note that missing values are never included in `uniques`. >>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b']) >>> codes array([ 0, -1, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) Thus far, we've only factorized lists (which are internally coerced to NumPy arrays). When factorizing pandas objects, the type of `uniques` will differ. For Categoricals, a `Categorical` is returned. >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques ['a', 'c'] Categories (3, object): ['a', 'b', 'c'] Notice that ``'b'`` is in ``uniques.categories``, despite not being present in ``cat.values``. For all other pandas objects, an Index of the appropriate type is returned. >>> cat = pd.Series(['a', 'a', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques Index(['a', 'c'], dtype='object') If NaN is in the values, and we want to include NaN in the uniques of the values, it can be achieved by setting ``na_sentinel=None``. >>> values = np.array([1, 2, 1, np.nan]) >>> codes, uniques = pd.factorize(values) # default: na_sentinel=-1 >>> codes array([ 0, 1, 0, -1]) >>> uniques array([1., 2.]) >>> codes, uniques = pd.factorize(values, na_sentinel=None) >>> codes array([0, 1, 0, 2]) >>> uniques array([ 1., 2., nan]) """ # Implementation notes: This method is responsible for 3 things # 1.) coercing data to array-like (ndarray, Index, extension array) # 2.) factorizing codes and uniques # 3.) Maybe boxing the uniques in an Index # # Step 2 is dispatched to extension types (like Categorical). They are # responsible only for factorization. All data coercion, sorting and boxing # should happen here. if isinstance(values, ABCRangeIndex): return values.factorize(sort=sort) values = _ensure_arraylike(values) original = values if not isinstance(values, ABCMultiIndex): values = extract_array(values, extract_numpy=True) # GH35667, if na_sentinel=None, we will not dropna NaNs from the uniques # of values, assign na_sentinel=-1 to replace code value for NaN. dropna = True if na_sentinel is None: na_sentinel = -1 dropna = False if ( isinstance(values, (ABCDatetimeArray, ABCTimedeltaArray)) and values.freq is not None ): codes, uniques = values.factorize(sort=sort) if isinstance(original, ABCIndex): uniques = original._shallow_copy(uniques, name=None) elif isinstance(original, ABCSeries): from pandas import Index uniques = Index(uniques) return codes, uniques if is_extension_array_dtype(values.dtype): codes, uniques = values.factorize(na_sentinel=na_sentinel) dtype = original.dtype else: values, dtype = _ensure_data(values) if original.dtype.kind in ["m", "M"]: # Note: factorize_array will cast NaT bc it has a __int__ # method, but will not cast the more-correct dtype.type("nat") na_value = iNaT else: na_value = None codes, uniques = factorize_array( values, na_sentinel=na_sentinel, size_hint=size_hint, na_value=na_value ) if sort and len(uniques) > 0: uniques, codes = safe_sort( uniques, codes, na_sentinel=na_sentinel, assume_unique=True, verify=False ) code_is_na = codes == na_sentinel if not dropna and code_is_na.any(): # na_value is set based on the dtype of uniques, and compat set to False is # because we do not want na_value to be 0 for integers na_value = na_value_for_dtype(uniques.dtype, compat=False) uniques = np.append(uniques, [na_value]) codes = np.where(code_is_na, len(uniques) - 1, codes) uniques = _reconstruct_data(uniques, dtype, original) # return original tenor if isinstance(original, ABCIndex): if original.dtype.kind in ["m", "M"] and isinstance(uniques, np.ndarray): original._data = cast( "Union[DatetimeArray, TimedeltaArray]", original._data ) uniques = type(original._data)._simple_new(uniques, dtype=original.dtype) uniques = original._shallow_copy(uniques, name=None) elif isinstance(original, ABCSeries): from pandas import Index uniques = Index(uniques) return codes, uniques def value_counts( values, sort: bool = True, ascending: bool = False, normalize: bool = False, bins=None, dropna: bool = True, ) -> Series: """ Compute a histogram of the counts of non-null values. Parameters ---------- values : ndarray (1-d) sort : bool, default True Sort by values ascending : bool, default False Sort in ascending order normalize: bool, default False If True then compute a relative histogram bins : integer, optional Rather than count values, group them into half-open bins, convenience for pd.cut, only works with numeric data dropna : bool, default True Don't include counts of NaN Returns ------- Series """ from pandas.core.series import Series name = getattr(values, "name", None) if bins is not None: from pandas.core.reshape.tile import cut values = Series(values) try: ii = cut(values, bins, include_lowest=True) except TypeError as err: raise TypeError("bins argument only works with numeric data.") from err # count, remove nulls (from the index), and but the bins result = ii.value_counts(dropna=dropna) result = result[result.index.notna()] result.index = result.index.astype("interval") result = result.sort_index() # if we are dropna and we have NO values if dropna and (result._values == 0).all(): result = result.iloc[0:0] # normalizing is by len of all (regardless of dropna) counts = np.array([len(ii)]) else: if is_extension_array_dtype(values): # handle Categorical and sparse, result = Series(values)._values.value_counts(dropna=dropna) result.name = name counts = result._values else: keys, counts = value_counts_arraylike(values, dropna) result = Series(counts, index=keys, name=name) if sort: result = result.sort_values(ascending=ascending) if normalize: result = result / counts.sum() return result # Called once from SparseArray, otherwise could be private def value_counts_arraylike(values, dropna: bool): """ Parameters ---------- values : arraylike dropna : bool Returns ------- uniques : np.ndarray or ExtensionArray counts : np.ndarray """ values = _ensure_arraylike(values) original = values values, _ = _ensure_data(values) ndtype = values.dtype.name if needs_i8_conversion(original.dtype): # datetime, timedelta, or period keys, counts = htable.value_count_int64(values, dropna) if dropna: msk = keys != iNaT keys, counts = keys[msk], counts[msk] else: # ndarray like # TODO: handle uint8 f = getattr(htable, f"value_count_{ndtype}") keys, counts = f(values, dropna) keys = _reconstruct_data(keys, original.dtype, original) return keys, counts def duplicated(values: ArrayLike, keep: Union[str, bool] = "first") -> np.ndarray: """ Return boolean ndarray denoting duplicate values. Parameters ---------- values : ndarray-like Array over which to check for duplicate values. keep : {'first', 'last', False}, default 'first' - ``first`` : Mark duplicates as ``True`` except for the first occurrence. - ``last`` : Mark duplicates as ``True`` except for the last occurrence. - False : Mark all duplicates as ``True``. Returns ------- duplicated : ndarray """ values, _ = _ensure_data(values) ndtype = values.dtype.name f = getattr(htable, f"duplicated_{ndtype}") return f(values, keep=keep) def mode(values, dropna: bool = True) -> Series: """ Returns the mode(s) of an array. Parameters ---------- values : array-like Array over which to check for duplicate values. dropna : boolean, default True Don't consider counts of NaN/NaT. .. versionadded:: 0.24.0 Returns ------- mode : Series """ from pandas import Series import pandas.core.indexes.base as ibase values = _ensure_arraylike(values) original = values # categorical is a fast-path if is_categorical_dtype(values): if isinstance(values, Series): # TODO: should we be passing `name` below? return Series(values._values.mode(dropna=dropna), name=values.name) return values.mode(dropna=dropna) if dropna and needs_i8_conversion(values.dtype): mask = values.isnull() values = values[~mask] values, _ = _ensure_data(values) ndtype = values.dtype.name f = getattr(htable, f"mode_{ndtype}") result = f(values, dropna=dropna) try: result = np.sort(result) except TypeError as err: warn(f"Unable to sort modes: {err}") result = _reconstruct_data(result, original.dtype, original) # Ensure index is type stable (should always use int index) return Series(result, index=ibase.default_index(len(result))) def rank( values: ArrayLike, axis: int = 0, method: str = "average", na_option: str = "keep", ascending: bool = True, pct: bool = False, ) -> np.ndarray: """ Rank the values along a given axis. Parameters ---------- values : array-like Array whose values will be ranked. The number of dimensions in this array must not exceed 2. axis : int, default 0 Axis over which to perform rankings. method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' The method by which tiebreaks are broken during the ranking. na_option : {'keep', 'top'}, default 'keep' The method by which NaNs are placed in the ranking. - ``keep``: rank each NaN value with a NaN ranking - ``top``: replace each NaN with either +/- inf so that they there are ranked at the top ascending : boolean, default True Whether or not the elements should be ranked in ascending order. pct : boolean, default False Whether or not to the display the returned rankings in integer form (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1). """ if values.ndim == 1: values = _get_values_for_rank(values) ranks = algos.rank_1d( values, labels=np.zeros(len(values), dtype=np.int64), ties_method=method, ascending=ascending, na_option=na_option, pct=pct, ) elif values.ndim == 2: values = _get_values_for_rank(values) ranks = algos.rank_2d( values, axis=axis, ties_method=method, ascending=ascending, na_option=na_option, pct=pct, ) else: raise TypeError("Array with ndim > 2 are not supported.") return ranks def checked_add_with_arr( arr: np.ndarray, b, arr_mask: Optional[np.ndarray] = None, b_mask: Optional[np.ndarray] = None, ) -> np.ndarray: """ Perform array addition that checks for underflow and overflow. Performs the addition of an int64 array and an int64 integer (or array) but checks that they do not result in overflow first. For elements that are indicated to be NaN, whether or not there is overflow for that element is automatically ignored. Parameters ---------- arr : array addend. b : array or scalar addend. arr_mask : np.ndarray[bool] or None, default None array indicating which elements to exclude from checking b_mask : np.ndarray[bool] or None, default None array or scalar indicating which element(s) to exclude from checking Returns ------- sum : An array for elements x + b for each element x in arr if b is a scalar or an array for elements x + y for each element pair (x, y) in (arr, b). Raises ------ OverflowError if any x + y exceeds the maximum or minimum int64 value. """ # For performance reasons, we broadcast 'b' to the new array 'b2' # so that it has the same size as 'arr'. b2 = np.broadcast_to(b, arr.shape) if b_mask is not None: # We do the same broadcasting for b_mask as well. b2_mask = np.broadcast_to(b_mask, arr.shape) else: b2_mask = None # For elements that are NaN, regardless of their value, we should # ignore whether they overflow or not when doing the checked add. if arr_mask is not None and b2_mask is not None: not_nan = np.logical_not(arr_mask | b2_mask) elif arr_mask is not None: not_nan = np.logical_not(arr_mask) elif b_mask is not None: not_nan = np.logical_not(b2_mask) else: not_nan = np.empty(arr.shape, dtype=bool) not_nan.fill(True) # gh-14324: For each element in 'arr' and its corresponding element # in 'b2', we check the sign of the element in 'b2'. If it is positive, # we then check whether its sum with the element in 'arr' exceeds # np.iinfo(np.int64).max. If so, we have an overflow error. If it # it is negative, we then check whether its sum with the element in # 'arr' exceeds np.iinfo(np.int64).min. If so, we have an overflow # error as well. mask1 = b2 > 0 mask2 = b2 < 0 if not mask1.any(): to_raise = ((np.iinfo(np.int64).min - b2 > arr) & not_nan).any() elif not mask2.any(): to_raise = ((np.iinfo(np.int64).max - b2 < arr) & not_nan).any() else: to_raise = ( (np.iinfo(np.int64).max - b2[mask1] < arr[mask1]) & not_nan[mask1] ).any() or ( (np.iinfo(np.int64).min - b2[mask2] > arr[mask2]) & not_nan[mask2] ).any() if to_raise: raise OverflowError("Overflow in int64 addition") return arr + b def quantile(x, q, interpolation_method="fraction"): """ Compute sample quantile or quantiles of the input array. For example, q=0.5 computes the median. The `interpolation_method` parameter supports three values, namely `fraction` (default), `lower` and `higher`. Interpolation is done only, if the desired quantile lies between two data points `i` and `j`. For `fraction`, the result is an interpolated value between `i` and `j`; for `lower`, the result is `i`, for `higher` the result is `j`. Parameters ---------- x : ndarray Values from which to extract score. q : scalar or array Percentile at which to extract score. interpolation_method : {'fraction', 'lower', 'higher'}, optional This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points `i` and `j`: - fraction: `i + (j - i)*fraction`, where `fraction` is the fractional part of the index surrounded by `i` and `j`. -lower: `i`. - higher: `j`. Returns ------- score : float Score at percentile. Examples -------- >>> from scipy import stats >>> a = np.arange(100) >>> stats.scoreatpercentile(a, 50) 49.5 """ x = np.asarray(x) mask = isna(x) x = x[~mask] values = np.sort(x) def _interpolate(a, b, fraction): """ Returns the point at the given fraction between a and b, where 'fraction' must be between 0 and 1. """ return a + (b - a) * fraction def _get_score(at): if len(values) == 0: return np.nan idx = at * (len(values) - 1) if idx % 1 == 0: score = values[int(idx)] else: if interpolation_method == "fraction": score = _interpolate(values[int(idx)], values[int(idx) + 1], idx % 1) elif interpolation_method == "lower": score = values[np.floor(idx)] elif interpolation_method == "higher": score = values[np.ceil(idx)] else: raise ValueError( "interpolation_method can only be 'fraction' " ", 'lower' or 'higher'" ) return score if is_scalar(q): return _get_score(q) else: q = np.asarray(q, np.float64) result = [_get_score(x) for x in q] result = np.array(result, dtype=np.float64) return result # --------------- # # select n # # --------------- # class SelectN: def __init__(self, obj, n: int, keep: str): self.obj = obj self.n = n self.keep = keep if self.keep not in ("first", "last", "all"): raise ValueError('keep must be either "first", "last" or "all"') def compute(self, method: str) -> FrameOrSeriesUnion: raise NotImplementedError def nlargest(self): return self.compute("nlargest") def nsmallest(self): return self.compute("nsmallest") @staticmethod def is_valid_dtype_n_method(dtype: DtypeObj) -> bool: """ Helper function to determine if dtype is valid for nsmallest/nlargest methods """ return ( is_numeric_dtype(dtype) and not is_complex_dtype(dtype) ) or needs_i8_conversion(dtype) class SelectNSeries(SelectN): """ Implement n largest/smallest for Series Parameters ---------- obj : Series n : int keep : {'first', 'last'}, default 'first' Returns ------- nordered : Series """ def compute(self, method: str) -> Series: n = self.n dtype = self.obj.dtype if not self.is_valid_dtype_n_method(dtype): raise TypeError(f"Cannot use method '{method}' with dtype {dtype}") if n <= 0: return self.obj[[]] dropped = self.obj.dropna() # slow method if n >= len(self.obj): ascending = method == "nsmallest" return dropped.sort_values(ascending=ascending).head(n) # fast method arr, pandas_dtype = _ensure_data(dropped.values) if method == "nlargest": arr = -arr if is_integer_dtype(pandas_dtype): # GH 21426: ensure reverse ordering at boundaries arr -= 1 elif is_bool_dtype(pandas_dtype): # GH 26154: ensure False is smaller than True arr = 1 - (-arr) if self.keep == "last": arr = arr[::-1] narr = len(arr) n = min(n, narr) kth_val = algos.kth_smallest(arr.copy(), n - 1) (ns,) = np.nonzero(arr <= kth_val) inds = ns[arr[ns].argsort(kind="mergesort")] if self.keep != "all": inds = inds[:n] if self.keep == "last": # reverse indices inds = narr - 1 - inds return dropped.iloc[inds] class SelectNFrame(SelectN): """ Implement n largest/smallest for DataFrame Parameters ---------- obj : DataFrame n : int keep : {'first', 'last'}, default 'first' columns : list or str Returns ------- nordered : DataFrame """ def __init__(self, obj, n: int, keep: str, columns): super().__init__(obj, n, keep) if not is_list_like(columns) or isinstance(columns, tuple): columns = [columns] columns = list(columns) self.columns = columns def compute(self, method: str) -> DataFrame: from pandas import Int64Index n = self.n frame = self.obj columns = self.columns for column in columns: dtype = frame[column].dtype if not self.is_valid_dtype_n_method(dtype): raise TypeError( f"Column {repr(column)} has dtype {dtype}, " f"cannot use method {repr(method)} with this dtype" ) def get_indexer(current_indexer, other_indexer): """ Helper function to concat `current_indexer` and `other_indexer` depending on `method` """ if method == "nsmallest": return current_indexer.append(other_indexer) else: return other_indexer.append(current_indexer) # Below we save and reset the index in case index contains duplicates original_index = frame.index cur_frame = frame = frame.reset_index(drop=True) cur_n = n indexer = Int64Index([]) for i, column in enumerate(columns): # For each column we apply method to cur_frame[column]. # If it's the last column or if we have the number of # results desired we are done. # Otherwise there are duplicates of the largest/smallest # value and we need to look at the rest of the columns # to determine which of the rows with the largest/smallest # value in the column to keep. series = cur_frame[column] is_last_column = len(columns) - 1 == i values = getattr(series, method)( cur_n, keep=self.keep if is_last_column else "all" ) if is_last_column or len(values) <= cur_n: indexer = get_indexer(indexer, values.index) break # Now find all values which are equal to # the (nsmallest: largest)/(nlargest: smallest) # from our series. border_value = values == values[values.index[-1]] # Some of these values are among the top-n # some aren't. unsafe_values = values[border_value] # These values are definitely among the top-n safe_values = values[~border_value] indexer = get_indexer(indexer, safe_values.index) # Go on and separate the unsafe_values on the remaining # columns. cur_frame = cur_frame.loc[unsafe_values.index] cur_n = n - len(indexer) frame = frame.take(indexer) # Restore the index on frame frame.index = original_index.take(indexer) # If there is only one column, the frame is already sorted. if len(columns) == 1: return frame ascending = method == "nsmallest" return frame.sort_values(columns, ascending=ascending, kind="mergesort") # ---- # # take # # ---- # def take( arr, indices: np.ndarray, axis: int = 0, allow_fill: bool = False, fill_value=None ): """ Take elements from an array. Parameters ---------- arr : sequence Non array-likes (sequences without a dtype) are coerced to an ndarray. indices : sequence of integers Indices to be taken. axis : int, default 0 The axis over which to select values. allow_fill : bool, default False How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right (the default). This is similar to :func:`numpy.take`. * True: negative values in `indices` indicate missing values. These values are set to `fill_value`. Any other negative values raise a ``ValueError``. fill_value : any, optional Fill value to use for NA-indices when `allow_fill` is True. This may be ``None``, in which case the default NA value for the type (``self.dtype.na_value``) is used. For multi-dimensional `arr`, each *element* is filled with `fill_value`. Returns ------- ndarray or ExtensionArray Same type as the input. Raises ------ IndexError When `indices` is out of bounds for the array. ValueError When the indexer contains negative values other than ``-1`` and `allow_fill` is True. Notes ----- When `allow_fill` is False, `indices` may be whatever dimensionality is accepted by NumPy for `arr`. When `allow_fill` is True, `indices` should be 1-D. See Also -------- numpy.take : Take elements from an array along an axis. Examples -------- >>> from pandas.api.extensions import take With the default ``allow_fill=False``, negative numbers indicate positional indices from the right. >>> take(np.array([10, 20, 30]), [0, 0, -1]) array([10, 10, 30]) Setting ``allow_fill=True`` will place `fill_value` in those positions. >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True) array([10., 10., nan]) >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True, ... fill_value=-10) array([ 10, 10, -10]) """ if not is_array_like(arr): arr = np.asarray(arr) indices = np.asarray(indices, dtype=np.intp) if allow_fill: # Pandas style, -1 means NA validate_indices(indices, arr.shape[axis]) result = take_nd( arr, indices, axis=axis, allow_fill=True, fill_value=fill_value ) else: # NumPy style result = arr.take(indices, axis=axis) return result # ------------ # # searchsorted # # ------------ # def searchsorted(arr, value, side="left", sorter=None) -> np.ndarray: """ Find indices where elements should be inserted to maintain order. .. versionadded:: 0.25.0 Find the indices into a sorted array `arr` (a) such that, if the corresponding elements in `value` were inserted before the indices, the order of `arr` would be preserved. Assuming that `arr` is sorted: ====== ================================ `side` returned index `i` satisfies ====== ================================ left ``arr[i-1] < value <= self[i]`` right ``arr[i-1] <= value < self[i]`` ====== ================================ Parameters ---------- arr: array-like Input array. If `sorter` is None, then it must be sorted in ascending order, otherwise `sorter` must be an array of indices that sort it. value : array_like Values to insert into `arr`. side : {'left', 'right'}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array_like, optional Optional array of integer indices that sort array a into ascending order. They are typically the result of argsort. Returns ------- array of ints Array of insertion points with the same shape as `value`. See Also -------- numpy.searchsorted : Similar method from NumPy. """ if sorter is not None: sorter = ensure_platform_int(sorter) if ( isinstance(arr, np.ndarray) and is_integer_dtype(arr.dtype) and (is_integer(value) or is_integer_dtype(value)) ): # if `arr` and `value` have different dtypes, `arr` would be # recast by numpy, causing a slow search. # Before searching below, we therefore try to give `value` the # same dtype as `arr`, while guarding against integer overflows. iinfo = np.iinfo(arr.dtype.type) value_arr = np.array([value]) if is_scalar(value) else np.array(value) if (value_arr >= iinfo.min).all() and (value_arr <= iinfo.max).all(): # value within bounds, so no overflow, so can convert value dtype # to dtype of arr dtype = arr.dtype else: dtype = value_arr.dtype if is_scalar(value): value = dtype.type(value) else: value = pd_array(value, dtype=dtype) elif not ( is_object_dtype(arr) or is_numeric_dtype(arr) or is_categorical_dtype(arr) ): # E.g. if `arr` is an array with dtype='datetime64[ns]' # and `value` is a pd.Timestamp, we may need to convert value arr = ensure_wrapped_if_datetimelike(arr) return arr.searchsorted(value, side=side, sorter=sorter) # ---- # # diff # # ---- # _diff_special = {"float64", "float32", "int64", "int32", "int16", "int8"} def diff(arr, n: int, axis: int = 0, stacklevel=3): """ difference of n between self, analogous to s-s.shift(n) Parameters ---------- arr : ndarray n : int number of periods axis : int axis to shift on stacklevel : int The stacklevel for the lost dtype warning. Returns ------- shifted """ n = int(n) na = np.nan dtype = arr.dtype if dtype.kind == "b": op = operator.xor else: op = operator.sub if isinstance(dtype, PandasDtype): # PandasArray cannot necessarily hold shifted versions of itself. arr = arr.to_numpy() dtype = arr.dtype if is_extension_array_dtype(dtype): if hasattr(arr, f"__{op.__name__}__"): if axis != 0: raise ValueError(f"cannot diff {type(arr).__name__} on axis={axis}") return op(arr, arr.shift(n)) else: warn( "dtype lost in 'diff()'. In the future this will raise a " "TypeError. Convert to a suitable dtype prior to calling 'diff'.", FutureWarning, stacklevel=stacklevel, ) arr = np.asarray(arr) dtype = arr.dtype is_timedelta = False is_bool = False if needs_i8_conversion(arr.dtype): dtype = np.int64 arr = arr.view("i8") na = iNaT is_timedelta = True elif is_bool_dtype(dtype): # We have to cast in order to be able to hold np.nan dtype = np.object_ is_bool = True elif is_integer_dtype(dtype): # We have to cast in order to be able to hold np.nan # int8, int16 are incompatible with float64, # see https://github.com/cython/cython/issues/2646 if arr.dtype.name in ["int8", "int16"]: dtype = np.float32 else: dtype = np.float64 orig_ndim = arr.ndim if orig_ndim == 1: # reshape so we can always use algos.diff_2d arr = arr.reshape(-1, 1) # TODO: require axis == 0 dtype = np.dtype(dtype) out_arr = np.empty(arr.shape, dtype=dtype) na_indexer = [slice(None)] * arr.ndim na_indexer[axis] = slice(None, n) if n >= 0 else slice(n, None) out_arr[tuple(na_indexer)] = na if arr.ndim == 2 and arr.dtype.name in _diff_special: # TODO: can diff_2d dtype specialization troubles be fixed by defining # out_arr inside diff_2d? algos.diff_2d(arr, out_arr, n, axis, datetimelike=is_timedelta) else: # To keep mypy happy, _res_indexer is a list while res_indexer is # a tuple, ditto for lag_indexer. _res_indexer = [slice(None)] * arr.ndim _res_indexer[axis] = slice(n, None) if n >= 0 else slice(None, n) res_indexer = tuple(_res_indexer) _lag_indexer = [slice(None)] * arr.ndim _lag_indexer[axis] = slice(None, -n) if n > 0 else slice(-n, None) lag_indexer = tuple(_lag_indexer) # need to make sure that we account for na for datelike/timedelta # we don't actually want to subtract these i8 numbers if is_timedelta: res = arr[res_indexer] lag = arr[lag_indexer] mask = (arr[res_indexer] == na) | (arr[lag_indexer] == na) if mask.any(): res = res.copy() res[mask] = 0 lag = lag.copy() lag[mask] = 0 result = res - lag result[mask] = na out_arr[res_indexer] = result elif is_bool: out_arr[res_indexer] = arr[res_indexer] ^ arr[lag_indexer] else: out_arr[res_indexer] = arr[res_indexer] - arr[lag_indexer] if is_timedelta: out_arr = out_arr.view("timedelta64[ns]") if orig_ndim == 1: out_arr = out_arr[:, 0] return out_arr # -------------------------------------------------------------------- # Helper functions # Note: safe_sort is in algorithms.py instead of sorting.py because it is # low-dependency, is used in this module, and used private methods from # this module. def safe_sort( values, codes=None, na_sentinel: int = -1, assume_unique: bool = False, verify: bool = True, ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: """ Sort ``values`` and reorder corresponding ``codes``. ``values`` should be unique if ``codes`` is not None. Safe for use with mixed types (int, str), orders ints before strs. Parameters ---------- values : list-like Sequence; must be unique if ``codes`` is not None. codes : list_like, optional Indices to ``values``. All out of bound indices are treated as "not found" and will be masked with ``na_sentinel``. na_sentinel : int, default -1 Value in ``codes`` to mark "not found". Ignored when ``codes`` is None. assume_unique : bool, default False When True, ``values`` are assumed to be unique, which can speed up the calculation. Ignored when ``codes`` is None. verify : bool, default True Check if codes are out of bound for the values and put out of bound codes equal to na_sentinel. If ``verify=False``, it is assumed there are no out of bound codes. Ignored when ``codes`` is None. .. versionadded:: 0.25.0 Returns ------- ordered : ndarray Sorted ``values`` new_codes : ndarray Reordered ``codes``; returned when ``codes`` is not None. Raises ------ TypeError * If ``values`` is not list-like or if ``codes`` is neither None nor list-like * If ``values`` cannot be sorted ValueError * If ``codes`` is not None and ``values`` contain duplicates. """ if not is_list_like(values): raise TypeError( "Only list-like objects are allowed to be passed to safe_sort as values" ) if not isinstance(values, (np.ndarray, ABCExtensionArray)): # don't convert to string types dtype, _ = infer_dtype_from_array(values) values = np.asarray(values, dtype=dtype) sorter = None if ( not is_extension_array_dtype(values) and lib.infer_dtype(values, skipna=False) == "mixed-integer" ): ordered = _sort_mixed(values) else: try: sorter = values.argsort() ordered = values.take(sorter) except TypeError: # Previous sorters failed or were not applicable, try `_sort_mixed` # which would work, but which fails for special case of 1d arrays # with tuples. if values.size and isinstance(values[0], tuple): ordered = _sort_tuples(values) else: ordered = _sort_mixed(values) # codes: if codes is None: return ordered if not is_list_like(codes): raise TypeError( "Only list-like objects or None are allowed to " "be passed to safe_sort as codes" ) codes = ensure_platform_int(np.asarray(codes)) if not assume_unique and not len(unique(values)) == len(values): raise ValueError("values should be unique if codes is not None") if sorter is None: # mixed types hash_klass, values = get_data_algo(values) t = hash_klass(len(values)) t.map_locations(values) sorter = ensure_platform_int(t.lookup(ordered)) if na_sentinel == -1: # take_nd is faster, but only works for na_sentinels of -1 order2 = sorter.argsort() new_codes = take_nd(order2, codes, fill_value=-1) if verify: mask = (codes < -len(values)) | (codes >= len(values)) else: mask = None else: reverse_indexer = np.empty(len(sorter), dtype=np.int_) reverse_indexer.put(sorter, np.arange(len(sorter))) # Out of bound indices will be masked with `na_sentinel` next, so we # may deal with them here without performance loss using `mode='wrap'` new_codes = reverse_indexer.take(codes, mode="wrap") mask = codes == na_sentinel if verify: mask = mask | (codes < -len(values)) | (codes >= len(values)) if mask is not None: np.putmask(new_codes, mask, na_sentinel) return ordered, ensure_platform_int(new_codes) def _sort_mixed(values): """ order ints before strings in 1d arrays, safe in py3 """ str_pos = np.array([isinstance(x, str) for x in values], dtype=bool) nums = np.sort(values[~str_pos]) strs = np.sort(values[str_pos]) return np.concatenate([nums, np.asarray(strs, dtype=object)]) def _sort_tuples(values: np.ndarray): """ Convert array of tuples (1d) to array or array (2d). We need to keep the columns separately as they contain different types and nans (can't use `np.sort` as it may fail when str and nan are mixed in a column as types cannot be compared). """ from pandas.core.internals.construction import to_arrays from pandas.core.sorting import lexsort_indexer arrays, _ = to_arrays(values, None) indexer = lexsort_indexer(arrays, orders=True) return values[indexer] def union_with_duplicates(lvals: np.ndarray, rvals: np.ndarray) -> np.ndarray: """ Extracts the union from lvals and rvals with respect to duplicates and nans in both arrays. Parameters ---------- lvals: np.ndarray left values which is ordered in front. rvals: np.ndarray right values ordered after lvals. Returns ------- np.ndarray containing the unsorted union of both arrays """ indexer = [] l_count = value_counts(lvals, dropna=False) r_count = value_counts(rvals, dropna=False) l_count, r_count = l_count.align(r_count, fill_value=0) unique_array = unique(np.append(lvals, rvals)) if is_extension_array_dtype(lvals) or is_extension_array_dtype(rvals): unique_array = pd_array(unique_array) for i, value in enumerate(unique_array): indexer += [i] * int(max(l_count[value], r_count[value])) return unique_array.take(indexer)
the-stack_106_32219
# -*- coding: utf-8 -*- """ Created on Wed Feb 13 14:51:46 2019 @author: MAGESHWARAN """ import pandas as pd import seaborn as sns from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPRegressor from sklearn.metrics import r2_score # read hours dataset hour_df = pd.read_csv("hour.csv") print(hour_df.columns) # ----------------------- Feature Selection --------------------- corr_initial = hour_df.corr() # generate heatmap to for correlation heat_map2 = sns.heatmap(corr_initial, linewidth=0.01) # plt.savefig("heat_map2") # create features from category variables, making binary dummy variables dummy_fields = ['season', 'weathersit', 'mnth', 'hr', 'weekday'] for field in dummy_fields: dummies = pd.get_dummies(hour_df[field], prefix = field, drop_first = False) hour_df = pd.concat([hour_df, dummies], axis = 1) # drop features drop_fields = ["instant", "dteday", "season", "yr", "mnth", "weekday", "weathersit", "workingday", "hr", "atemp"] data = hour_df.drop(drop_fields, axis = 1) print(data.columns) corr = data.corr() # generate heatmap to for correlation heat_map = sns.heatmap(corr, linewidth=0.01) # plt.savefig("heat_map") # ------------------------ Feature Scaling -------------------- # scale all the quantitative features quant_features = ["temp", "casual", "registered", "cnt", "hum", "windspeed"] # Store scalings in a dictionary so we can convert back later scaled_features = {} for feature in quant_features: mean, std = data[feature].mean(), data[feature].std() scaled_features[feature] = [mean, std] # used for later purpose # making features with 0 mean and std of 1 data.loc[:, feature] = (data[feature] - mean) / std X = data.drop(["cnt", "casual", "registered"], axis = 1) y = data[["cnt", "casual", "registered"]] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.002) # --------------------- Training and Prediction-------------------- linear_model = MLPRegressor() linear_model.fit(X_train, y_train) y_pred = linear_model.predict(X_test) print("Test score(R2):", r2_score(y_pred, y_test) * 100, "%") print("Test score(model_score):", linear_model.score(X_test, y_test) * 100, "%")
the-stack_106_32220
def checkio(first, second): list1=first.split(',') list2 = second.split(',') set1=set(list1) set2=set(list2) new_set = set1&set2 if len(new_set) == 0: return '' else: return ','.join(sorted(new_set))
the-stack_106_32224
import logging import typing as t from src.error import Error from src.smali_method import SmaliMethod class SmaliClass: def __init__(self, name: str): self.name: str = name self.sig: str = '' self.methods: t.List[SmaliMethod] = [] self.header_block: t.List[str] = [] def __parse_class_header(self, idx: int, file_lines: t.List[str] ) -> t.Tuple[int, t.List[str], str, t.Optional[Error]]: try: sig = file_lines[0].split()[-1][1:-1].strip() except IndexError: return 0, [], '', Error( 'Could not parse class header: {}'.format(self.name)) i = 1 # Skipping the first line header_block: t.List[str] = [] for i in range(idx, len(file_lines)): line = file_lines[i] if '.method' in line: break header_block.append(line) return i, header_block, sig, None def __parse_method(self, idx: int, file_lines: t.List[str] ) -> t.Tuple[int, t.Optional[SmaliMethod], t.Optional[Error]]: i = 0 method_block: t.List[str] = [] for i in range(idx, len(file_lines)): line = file_lines[i] method_block.append(line) if '.end method' in line: break method = SmaliMethod(self.name, method_block[0]) err = method.parse(method_block[1:]) if err: return -1, None, err return i, method, None def parse(self, file_path: str) -> t.Optional[Error]: logging.debug("Parsing SmaliClass: [%s]...", file_path) with open(file_path, 'r') as fd: file_lines = fd.read().splitlines() idx = 0 idx, self.header_block, self.sig, err = self.__parse_class_header( idx, file_lines) if err: return err while idx < len(file_lines): line = file_lines[idx] if '.method' in line: idx, method, err = self.__parse_method(idx, file_lines) if err: return err if not method: raise Exception('FAIL') self.methods.append(method) idx += 1 return None def write(self, fd: t.IO[t.Any]): logging.debug('Writing clazz [%s]', self.name) for line in self.header_block: fd.write(line) fd.write('\n') for method in self.methods: method.write(fd) # Removes the package from a class's name # `com.afjoseph.test.aaa` -> `aaa` def get_simple_name(self) -> str: if not '.' in self.name: return self.name return self.name.split('.')[-1].strip()
the-stack_106_32226
# (c) 2015, Jon Hadfield <[email protected]> """ Description: This lookup takes an AWS region and an RDS instance name and returns the endpoint name. Example Usage: {{ lookup('aws_rds_endpoint_name_from_instance_name', ('eu-west-1', 'mydb')) }} """ from ansible import errors try: import boto.rds except ImportError: raise AnsibleError("aws_rds_endpoint_name_from_instance_name lookup cannot be run without boto installed") class LookupModule(object): def __init__(self, basedir=None, **kwargs): self.basedir = basedir def run(self, terms, variables=None, **kwargs): region = terms[0] instance_name = terms[1] db_conn = boto.rds.connect_to_region(region) db = db_conn.get_all_dbinstances(instance_name) if db and db[0]: return [db[0].endpoint[0]] return None
the-stack_106_32227
import requests from django.core.exceptions import ImproperlyConfigured from allauth.socialaccount.helpers import complete_social_login from allauth.socialaccount.helpers import render_authentication_error from allauth.socialaccount.models import SocialLogin from allauth.socialaccount import app_settings, providers from .provider import PersonaProvider def persona_login(request): assertion = request.POST.get('assertion', '') settings = app_settings.PROVIDERS.get(PersonaProvider.id, {}) audience = settings.get('AUDIENCE', None) if audience is None: raise ImproperlyConfigured( "No Persona audience configured. Please " "add an AUDIENCE item to the " "SOCIALACCOUNT_PROVIDERS['persona'] setting.") resp = requests.post('https://verifier.login.persona.org/verify', {'assertion': assertion, 'audience': audience}) try: resp.raise_for_status() extra_data = resp.json() if extra_data['status'] != 'okay': return render_authentication_error( request, provider_id=PersonaProvider.id, extra_context={'response': extra_data}) except (ValueError, requests.RequestException) as e: return render_authentication_error( request, provider_id=PersonaProvider.id, exception=e) login = providers.registry \ .by_id(PersonaProvider.id) \ .sociallogin_from_response(request, extra_data) login.state = SocialLogin.state_from_request(request) return complete_social_login(request, login)
the-stack_106_32228
#! /usr/bin/env python3 ''' This module provides access to the BankTransaction class Usage: t1 = BankTransaction() t1.info() t2 = BankTransaction(account=BankAccount(account_number=90101)) t2.info() account_list = [BankAccount(subscriber_origin='nn_NO')] t3 = BankTransaction(account=account_list[0]) t4 = BankTransaction(account=account_list[0]) t3.info() t4.info() person_ca = Person() person_ca.create('fr_CA') ba = BankAccount(person=person_ca) transaction = BankTransaction(account=ba) transaction.info() ''' import random from datetime import datetime from .BankAccount import BankAccount actions = { 'Deposit': +1, 'Credit Transfer': +1, 'Withdrawl': -1, 'Debit Payment': -1 } class BankTransaction: ''' The BankTransaction object can be initialised empty or with arguments For each omitted argument, data will be randomly set Arguments: value (float), optional: float number as in `9999.10` or `-1000` Note: if description is provided, value should be also description (str), optional: If not in actions (line 21) and value has `-`, will be a debit If description is in actions, signs in value will be ignored Its recommended to provide a value if description is customised moment (str), optional: If provided, recommended `YYYY-mm-dd HH:MM:SS` format If omitted, current date and time will be provided account (obj), optional: send a constructed Account object to replace account_number Account has precedence over account_number argument account_number (int), optional: recommended to have 4-8 digits or use account argument to use an Account object Attributes: account_number (int): account number for the transaction account_balance (float): if a BankAccount object is provided description (str), moment (str), value (float) ''' def __init__(self, value=None, description=None, moment=None, account=None, account_number=None): if account or not account_number: if not account or not isinstance(account, BankAccount): account = BankAccount(subscriber_name='Jane Doe') account_number = account.account_number operation = None if description: if description in actions: operation = actions[description] else: operation = -1 if value < 0 else +1 else: description = random.choice(list(actions)) operation = actions[description] if not isinstance(value, (float, int)): value = random.random() * (10 ** random.randrange(1,6)) value = round( abs(float(value)), 2 ) * operation if not moment: moment = datetime.now().strftime('%Y-%m-%d %H:%M:%S') self.moment = moment self.account_number = account_number self.value = value self.description = description if account: account_balance = round( account.balance + value, 2 ) self.account_balance = account.balance = account_balance else: self.account_balance = round( value, 2 ) def info(self) -> dict: ''' Return a dictionary with Bank Transaction object data ''' return { 'moment': self.moment, 'account_number': self.account_number, 'value': self.value, 'description': self.description, 'account_balance': self.account_balance } def csv(self) -> str: ''' Return a csv string with Bank Transaction object data ''' return f'"{self.moment}",{self.account_number},{self.value},"{self.description}",{self.account_balance}'.replace('None', '').replace('""', '')
the-stack_106_32229
#!/usr/bin/env python3 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. import argparse import contextlib import glob import os import re import shutil import subprocess import sys import hashlib import platform from amd_hipify import amd_hipify from distutils.version import LooseVersion SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__)) REPO_DIR = os.path.normpath(os.path.join(SCRIPT_DIR, "..", "..")) sys.path.insert(0, os.path.join(REPO_DIR, "tools", "python")) from util import ( # noqa: E402 run, is_windows, is_macOS, is_linux, get_logger) import util.android as android # noqa: E402 log = get_logger("build") class BaseError(Exception): """Base class for errors originating from build.py.""" pass class BuildError(BaseError): """Error from running build steps.""" def __init__(self, *messages): super().__init__("\n".join(messages)) class UsageError(BaseError): """Usage related error.""" def __init__(self, message): super().__init__(message) def _check_python_version(): # According to the BUILD.md, python 3.5+ is required: # Python 2 is definitely not supported and it should be safer to consider # it won't run with python 4: if sys.version_info[0] != 3: raise BuildError( "Bad python major version: expecting python 3, found version " "'{}'".format(sys.version)) if sys.version_info[1] < 6: raise BuildError( "Bad python minor version: expecting python 3.6+, found version " "'{}'".format(sys.version)) def _str_to_bool(s): """Convert string to bool (in argparse context).""" if s.lower() not in ['true', 'false']: raise ValueError('Need bool; got %r' % s) return {'true': True, 'false': False}[s.lower()] _check_python_version() def _openvino_verify_device_type(device_read): choices = ["CPU_FP32", "GPU_FP32", "GPU_FP16", "VAD-M_FP16", "MYRIAD_FP16", "VAD-F_FP32"] status_hetero = True res = False if (device_read in choices): res = True elif (device_read.startswith("HETERO:") or device_read.startswith("MULTI:")): res = True comma_separated_devices = device_read.split(":") comma_separated_devices = comma_separated_devices[1].split(',') if (len(comma_separated_devices) < 2): print("Atleast two devices required in Hetero Mode") status_hetero = False dev_options = ["CPU", "GPU", "MYRIAD", "FPGA", "HDDL"] for dev in comma_separated_devices: if (dev not in dev_options): status_hetero = False break def invalid_hetero_build(): print("\n" + "If trying to build Hetero or Multi, specifiy the supported devices along with it." + + "\n") print("specify the keyword HETERO or MULTI followed by the devices ") print("in the order of priority you want to build" + "\n") print("The different hardware devices that can be added in HETERO or MULTI") print("are ['CPU','GPU','MYRIAD','FPGA','HDDL']" + "\n") print("An example of how to specify the hetero build type. Ex: HETERO:GPU,CPU" + "\n") print("An example of how to specify the MULTI build type. Ex: MULTI:MYRIAD,CPU" + "\n") sys.exit("Wrong Build Type selected") if (res is False): print("\n" + "You have selcted wrong configuration for the build.") print("pick the build type for specific Hardware Device from following options: ", choices) print("\n") if not (device_read.startswith("HETERO:") or device_read.startswith("MULTI:")): invalid_hetero_build() sys.exit("Wrong Build Type selected") if (status_hetero is False): invalid_hetero_build() return device_read def parse_arguments(): parser = argparse.ArgumentParser( description="ONNXRuntime CI build driver.", usage=""" # noqa Default behavior is --update --build --test for native architecture builds. Default behavior is --update --build for cross-compiled builds. The Update phase will update git submodules, and run cmake to generate makefiles. The Build phase will build all projects. The Test phase will run all unit tests, and optionally the ONNX tests. Use the individual flags to only run the specified stages. """) # Main arguments parser.add_argument( "--build_dir", required=True, help="Path to the build directory.") parser.add_argument( "--config", nargs="+", default=["Debug"], choices=["Debug", "MinSizeRel", "Release", "RelWithDebInfo"], help="Configuration(s) to build.") parser.add_argument( "--update", action='store_true', help="Update makefiles.") parser.add_argument("--build", action='store_true', help="Build.") parser.add_argument( "--clean", action='store_true', help="Run 'cmake --build --target clean' for the selected config/s.") parser.add_argument( "--parallel", nargs='?', const='0', default='1', type=int, help="Use parallel build. The optional value specifies the maximum number of parallel jobs. " "If the optional value is 0 or unspecified, it is interpreted as the number of CPUs.") parser.add_argument("--test", action='store_true', help="Run unit tests.") parser.add_argument( "--skip_tests", action='store_true', help="Skip all tests.") # Training options parser.add_argument( "--enable_nvtx_profile", action='store_true', help="Enable NVTX profile in ORT.") parser.add_argument( "--enable_memory_profile", action='store_true', help="Enable memory profile in ORT.") parser.add_argument( "--enable_training", action='store_true', help="Enable training in ORT.") parser.add_argument( "--disable_nccl", action='store_true', help="Disable Nccl.") parser.add_argument( "--mpi_home", help="Path to MPI installation dir") parser.add_argument( "--nccl_home", help="Path to NCCL installation dir") parser.add_argument( "--use_mpi", nargs='?', default=True, const=True, type=_str_to_bool) # enable ONNX tests parser.add_argument( "--enable_onnx_tests", action='store_true', help="""When running the Test phase, run onnx_test_running against available test data directories.""") parser.add_argument("--path_to_protoc_exe", help="Path to protoc exe.") parser.add_argument( "--fuzz_testing", action='store_true', help="Enable Fuzz testing of the onnxruntime.") parser.add_argument( "--enable_symbolic_shape_infer_tests", action='store_true', help="""When running the Test phase, run symbolic shape inference against available test data directories.""") # generate documentaiton parser.add_argument( "--gen_doc", action='store_true', help="Generate documentation on contrib ops") # CUDA related parser.add_argument("--use_cuda", action='store_true', help="Enable CUDA.") parser.add_argument( "--cuda_version", help="The version of CUDA toolkit to use. " "Auto-detect if not specified. e.g. 9.0") parser.add_argument( "--cuda_home", help="Path to CUDA home." "Read from CUDA_HOME environment variable if --use_cuda is true and " "--cuda_home is not specified.") parser.add_argument( "--cudnn_home", help="Path to CUDNN home. " "Read from CUDNN_HOME environment variable if --use_cuda is true and " "--cudnn_home is not specified.") # Python bindings parser.add_argument( "--enable_pybind", action='store_true', help="Enable Python Bindings.") parser.add_argument( "--build_wheel", action='store_true', help="Build Python Wheel.") parser.add_argument( "--wheel_name_suffix", help="Suffix to append to created wheel names. " "This value is currently only used for nightly builds.") parser.add_argument( "--numpy_version", help="Installs a specific version of numpy " "before building the python binding.") parser.add_argument( "--skip-keras-test", action='store_true', help="Skip tests with Keras if keras is installed") # C-Sharp bindings parser.add_argument( "--build_csharp", action='store_true', help="Build C#.Net DLL and NuGet package. This should be only used in CI pipelines. " "For building C# bindings and packaging them into nuget package use --build_nuget arg.") parser.add_argument( "--build_nuget", action='store_true', help="Build C#.Net DLL and NuGet package on the local machine. " "Currently only Windows and Linux platforms are supported.") # Java bindings parser.add_argument( "--build_java", action='store_true', help="Build Java bindings.") # Node.js binding parser.add_argument( "--build_nodejs", action='store_true', help="Build Node.js binding and NPM package.") # Build a shared lib parser.add_argument( "--build_shared_lib", action='store_true', help="Build a shared library for the ONNXRuntime.") # Build options parser.add_argument( "--cmake_extra_defines", nargs="+", help="Extra definitions to pass to CMake during build system " "generation. These are just CMake -D options without the leading -D.") parser.add_argument( "--target", help="Build a specific target, e.g. winml_dll") parser.add_argument( "--x86", action='store_true', help="Create x86 makefiles. Requires --update and no existing cache " "CMake setup. Delete CMakeCache.txt if needed") parser.add_argument( "--arm", action='store_true', help="Create ARM makefiles. Requires --update and no existing cache " "CMake setup. Delete CMakeCache.txt if needed") parser.add_argument( "--arm64", action='store_true', help="Create ARM64 makefiles. Requires --update and no existing cache " "CMake setup. Delete CMakeCache.txt if needed") parser.add_argument( "--msvc_toolset", help="MSVC toolset to use. e.g. 14.11") parser.add_argument("--android", action='store_true', help='Build for Android') parser.add_argument( "--android_abi", default="arm64-v8a", choices=["armeabi-v7a", "arm64-v8a", "x86", "x86_64"], help="Specify the target Android Application Binary Interface (ABI)") parser.add_argument("--android_api", type=int, default=27, help='Android API Level, e.g. 21') parser.add_argument("--android_sdk_path", type=str, help='Path to the Android SDK') parser.add_argument("--android_ndk_path", default="", help="Path to the Android NDK") parser.add_argument("--android_cpp_shared", action="store_true", help="Build with shared libc++ instead of the default static libc++.") parser.add_argument("--android_run_emulator", action="store_true", help="Start up an Android emulator if needed.") parser.add_argument("--ios", action='store_true', help="build for ios") parser.add_argument( "--ios_sysroot", default="", help="Specify the location name of the macOS platform SDK to be used") parser.add_argument( "--ios_toolchain_dir", default="", help="Path to ios toolchain binaries") parser.add_argument( "--ios_toolchain_file", default="", help="Path to ios toolchain file, " "or cmake/onnxruntime_ios.toolchain.cmake will be used") parser.add_argument( "--xcode_code_signing_team_id", default="", help="The development team ID used for code signing in Xcode") parser.add_argument( "--use_xcode", action='store_true', help="Use Xcode as cmake generator, this is only supported on MacOS.") parser.add_argument( "--osx_arch", default="arm64" if platform.machine() == "arm64" else "x86_64", choices=["arm64", "x86_64"], help="Specify the Target specific architectures for macOS and iOS, This is only supported on MacOS") parser.add_argument( "--apple_deploy_target", type=str, help="Specify the minimum version of the target platform " "(e.g. macOS or iOS)" "This is only supported on MacOS") # Arguments needed by CI parser.add_argument( "--cmake_path", default="cmake", help="Path to the CMake program.") parser.add_argument( "--ctest_path", default="ctest", help="Path to the CTest program.") parser.add_argument( "--skip_submodule_sync", action='store_true', help="Don't do a " "'git submodule update'. Makes the Update phase faster.") parser.add_argument( "--use_vstest", action='store_true', help="Use use_vstest for running unitests.") parser.add_argument( "--use_mimalloc", default=['none'], choices=['none', 'stl', 'arena', 'all'], help="Use mimalloc.") parser.add_argument( "--use_dnnl", action='store_true', help="Build with DNNL.") parser.add_argument( "--dnnl_gpu_runtime", action='store', default='', type=str.lower, help="e.g. --dnnl_gpu_runtime ocl") parser.add_argument( "--dnnl_opencl_root", action='store', default='', help="Path to OpenCL SDK. " "e.g. --dnnl_opencl_root \"C:/Program Files (x86)/IntelSWTools/sw_dev_tools/OpenCL/sdk\"") parser.add_argument( "--use_featurizers", action='store_true', help="Build with ML Featurizer support.") parser.add_argument( "--use_openvino", nargs="?", const="CPU_FP32", type=_openvino_verify_device_type, help="Build with OpenVINO for specific hardware.") parser.add_argument( "--use_coreml", action='store_true', help="Build with CoreML support.") parser.add_argument( "--use_nnapi", action='store_true', help="Build with NNAPI support.") parser.add_argument( "--nnapi_min_api", type=int, help="Minimum Android API level to enable NNAPI, should be no less than 27") parser.add_argument( "--use_rknpu", action='store_true', help="Build with RKNPU.") parser.add_argument( "--use_preinstalled_eigen", action='store_true', help="Use pre-installed Eigen.") parser.add_argument("--eigen_path", help="Path to pre-installed Eigen.") parser.add_argument( "--use_openmp", action='store_true', help="Build with OpenMP") parser.add_argument( "--enable_msinternal", action="store_true", help="Enable for Microsoft internal builds only.") parser.add_argument("--llvm_path", help="Path to llvm dir") parser.add_argument( "--use_vitisai", action='store_true', help="Build with Vitis-AI") parser.add_argument( "--use_nuphar", action='store_true', help="Build with nuphar") parser.add_argument( "--use_tensorrt", action='store_true', help="Build with TensorRT") parser.add_argument( "--tensorrt_home", help="Path to TensorRT installation dir") parser.add_argument( "--use_migraphx", action='store_true', help="Build with MIGraphX") parser.add_argument( "--migraphx_home", help="Path to MIGraphX installation dir") parser.add_argument( "--use_full_protobuf", action='store_true', help="Use the full protobuf library") parser.add_argument( "--skip_onnx_tests", action='store_true', help="Explicitly disable " "all onnx related tests. Note: Use --skip_tests to skip all tests.") parser.add_argument( "--skip_winml_tests", action='store_true', help="Explicitly disable all WinML related tests") parser.add_argument( "--skip_nodejs_tests", action='store_true', help="Explicitly disable all Node.js binding tests") parser.add_argument( "--enable_msvc_static_runtime", action='store_true', help="Enable static linking of MSVC runtimes.") parser.add_argument( "--enable_language_interop_ops", action='store_true', help="Enable operator implemented in language other than cpp") parser.add_argument( "--cmake_generator", choices=['Visual Studio 15 2017', 'Visual Studio 16 2019', 'Ninja'], default='Visual Studio 15 2017' if is_windows() else None, help="Specify the generator that CMake invokes. " "This is only supported on Windows") parser.add_argument( "--enable_multi_device_test", action='store_true', help="Test with multi-device. Mostly used for multi-device GPU") parser.add_argument( "--use_dml", action='store_true', help="Build with DirectML.") parser.add_argument( "--use_winml", action='store_true', help="Build with WinML.") parser.add_argument( "--winml_root_namespace_override", type=str, help="Specify the namespace that WinML builds into.") parser.add_argument( "--use_telemetry", action='store_true', help="Only official builds can set this flag to enable telemetry.") parser.add_argument( "--enable_wcos", action='store_true', help="Build for Windows Core OS.") parser.add_argument( "--enable_windows_store", action='store_true', help="Build for Windows Store") parser.add_argument( "--enable_lto", action='store_true', help="Enable Link Time Optimization") parser.add_argument( "--use_acl", nargs="?", const="ACL_1905", choices=["ACL_1902", "ACL_1905", "ACL_1908", "ACL_2002"], help="Build with ACL for ARM architectures.") parser.add_argument( "--acl_home", help="Path to ACL home dir") parser.add_argument( "--acl_libs", help="Path to ACL libraries") parser.add_argument( "--use_armnn", action='store_true', help="Enable ArmNN Execution Provider.") parser.add_argument( "--armnn_relu", action='store_true', help="Use the Relu operator implementation from the ArmNN EP.") parser.add_argument( "--armnn_bn", action='store_true', help="Use the Batch Normalization operator implementation from the ArmNN EP.") parser.add_argument( "--armnn_home", help="Path to ArmNN home dir") parser.add_argument( "--armnn_libs", help="Path to ArmNN libraries") parser.add_argument( "--build_micro_benchmarks", action='store_true', help="Build ONNXRuntime micro-benchmarks.") # options to reduce binary size parser.add_argument("--minimal_build", action='store', const='on', default='off', nargs='?', type=str.lower, help="Create a build that only supports ORT format models. " "See /docs/ONNX_Runtime_Format_Model_Usage.md for more information. " "RTTI is automatically disabled in a minimal build. " "To enable execution providers that compile kernels at runtime (e.g. NNAPI) pass 'extended' " "as a parameter. e.g. '--minimal_build extended'.") parser.add_argument("--include_ops_by_config", type=str, help="include ops from config file. " "See /docs/Reduced_Operator_Kernel_build.md for more information.") parser.add_argument("--enable_reduced_operator_type_support", action='store_true', help='If --include_ops_by_config is specified, and the configuration file was created from ORT ' 'format models with type reduction enabled, limit the types individual operators support ' 'where possible to further reduce the build size. ' 'See /docs/Reduced_Operator_Kernel_build.md for more information.') parser.add_argument("--disable_contrib_ops", action='store_true', help="Disable contrib ops (reduces binary size)") parser.add_argument("--disable_ml_ops", action='store_true', help="Disable traditional ML ops (reduces binary size)") parser.add_argument("--disable_rtti", action='store_true', help="Disable RTTI (reduces binary size)") parser.add_argument("--disable_exceptions", action='store_true', help="Disable exceptions to reduce binary size. Requires --minimal_build.") parser.add_argument("--disable_ort_format_load", action='store_true', help='Disable support for loading ORT format models in a non-minimal build.') parser.add_argument("--use_rocm", action='store_true', help="Build with ROCm") parser.add_argument("--rocm_home", help="Path to ROCm installation dir") # Code coverage parser.add_argument("--code_coverage", action='store_true', help="Generate code coverage when targetting Android (only).") return parser.parse_args() def resolve_executable_path(command_or_path): """Returns the absolute path of an executable.""" executable_path = shutil.which(command_or_path) if executable_path is None: raise BuildError("Failed to resolve executable path for " "'{}'.".format(command_or_path)) return os.path.realpath(executable_path) def get_linux_distro(): try: with open('/etc/os-release', 'r') as f: dist_info = dict( line.strip().split('=', 1) for line in f.readlines()) return dist_info.get('NAME', '').strip('"'), dist_info.get( 'VERSION', '').strip('"') except (IOError, ValueError): return '', '' def is_ubuntu_1604(): dist, ver = get_linux_distro() return dist == 'Ubuntu' and ver.startswith('16.04') def get_config_build_dir(build_dir, config): # build directory per configuration return os.path.join(build_dir, config) def run_subprocess(args, cwd=None, capture_stdout=False, dll_path=None, shell=False, env={}): if isinstance(args, str): raise ValueError("args should be a sequence of strings, not a string") my_env = os.environ.copy() if dll_path: if is_windows(): my_env["PATH"] = dll_path + os.pathsep + my_env["PATH"] else: if "LD_LIBRARY_PATH" in my_env: my_env["LD_LIBRARY_PATH"] += os.pathsep + dll_path else: my_env["LD_LIBRARY_PATH"] = dll_path my_env.update(env) return run(*args, cwd=cwd, capture_stdout=capture_stdout, shell=shell, env=my_env) def update_submodules(source_dir): run_subprocess(["git", "submodule", "sync", "--recursive"], cwd=source_dir) run_subprocess(["git", "submodule", "update", "--init", "--recursive"], cwd=source_dir) def is_docker(): path = '/proc/self/cgroup' return ( os.path.exists('/.dockerenv') or os.path.isfile(path) and any('docker' in line for line in open(path)) ) def install_python_deps(numpy_version=""): dep_packages = ['setuptools', 'wheel', 'pytest'] dep_packages.append('numpy=={}'.format(numpy_version) if numpy_version else 'numpy>=1.16.6') dep_packages.append('sympy>=1.1') dep_packages.append('packaging') dep_packages.append('cerberus') run_subprocess([sys.executable, '-m', 'pip', 'install', '--trusted-host', 'files.pythonhosted.org'] + dep_packages) # We need to install Torch to test certain functionalities of the ORT Python package def install_torch(): # Command works for both Windows run_subprocess([sys.executable, '-m', 'pip', 'install', '--trusted-host', 'files.pythonhosted.org', 'torch===1.5.1+cu101', 'torchvision===0.6.1+cu101', '-f', 'https://download.pytorch.org/whl/torch_stable.html']) def check_md5(filename, expected_md5): if not os.path.exists(filename): return False hash_md5 = hashlib.md5() BLOCKSIZE = 1024 * 64 with open(filename, "rb") as f: buf = f.read(BLOCKSIZE) while len(buf) > 0: hash_md5.update(buf) buf = f.read(BLOCKSIZE) hex = hash_md5.hexdigest() if hex != expected_md5: log.info('md5 mismatch, expect %s, got %s' % (expected_md5, hex)) os.remove(filename) return False return True def setup_test_data(build_dir, configs): # create a shortcut for test models if there is a 'models' # folder in build_dir if is_windows(): src_model_dir = os.path.join(build_dir, 'models') if os.path.exists('C:\\local\\models') and not os.path.exists( src_model_dir): log.debug("creating shortcut %s -> %s" % ( 'C:\\local\\models', src_model_dir)) run_subprocess(['mklink', '/D', '/J', src_model_dir, 'C:\\local\\models'], shell=True) for config in configs: config_build_dir = get_config_build_dir(build_dir, config) os.makedirs(config_build_dir, exist_ok=True) dest_model_dir = os.path.join(config_build_dir, 'models') if os.path.exists('C:\\local\\models') and not os.path.exists( dest_model_dir): log.debug("creating shortcut %s -> %s" % ( 'C:\\local\\models', dest_model_dir)) run_subprocess(['mklink', '/D', '/J', dest_model_dir, 'C:\\local\\models'], shell=True) elif os.path.exists(src_model_dir) and not os.path.exists( dest_model_dir): log.debug("creating shortcut %s -> %s" % ( src_model_dir, dest_model_dir)) run_subprocess(['mklink', '/D', '/J', dest_model_dir, src_model_dir], shell=True) def use_dev_mode(args): if args.use_acl: return 'OFF' if args.use_armnn: return 'OFF' if args.ios and is_macOS(): return 'OFF' return 'ON' def generate_build_tree(cmake_path, source_dir, build_dir, cuda_home, cudnn_home, rocm_home, mpi_home, nccl_home, tensorrt_home, migraphx_home, acl_home, acl_libs, armnn_home, armnn_libs, path_to_protoc_exe, configs, cmake_extra_defines, args, cmake_extra_args): log.info("Generating CMake build tree") cmake_dir = os.path.join(source_dir, "cmake") cmake_args = [ cmake_path, cmake_dir, "-Donnxruntime_RUN_ONNX_TESTS=" + ( "ON" if args.enable_onnx_tests else "OFF"), "-Donnxruntime_BUILD_WINML_TESTS=" + ( "OFF" if args.skip_winml_tests else "ON"), "-Donnxruntime_GENERATE_TEST_REPORTS=ON", "-Donnxruntime_DEV_MODE=" + use_dev_mode(args), "-DPYTHON_EXECUTABLE=" + sys.executable, "-Donnxruntime_USE_CUDA=" + ("ON" if args.use_cuda else "OFF"), "-Donnxruntime_CUDNN_HOME=" + (cudnn_home if args.use_cuda else ""), "-Donnxruntime_USE_FEATURIZERS=" + ( "ON" if args.use_featurizers else "OFF"), "-Donnxruntime_CUDA_HOME=" + (cuda_home if args.use_cuda else ""), "-Donnxruntime_USE_MIMALLOC_STL_ALLOCATOR=" + ( "ON" if args.use_mimalloc == "stl" or args.use_mimalloc == "all" else "OFF"), "-Donnxruntime_USE_MIMALLOC_ARENA_ALLOCATOR=" + ( "ON" if args.use_mimalloc == "arena" or args.use_mimalloc == "all" else "OFF"), "-Donnxruntime_ENABLE_PYTHON=" + ( "ON" if args.enable_pybind else "OFF"), "-Donnxruntime_BUILD_CSHARP=" + ("ON" if args.build_csharp else "OFF"), "-Donnxruntime_BUILD_JAVA=" + ("ON" if args.build_java else "OFF"), "-Donnxruntime_BUILD_NODEJS=" + ("ON" if args.build_nodejs else "OFF"), "-Donnxruntime_BUILD_SHARED_LIB=" + ( "ON" if args.build_shared_lib else "OFF"), "-Donnxruntime_USE_DNNL=" + ("ON" if args.use_dnnl else "OFF"), "-Donnxruntime_DNNL_GPU_RUNTIME=" + (args.dnnl_gpu_runtime if args.use_dnnl else ""), "-Donnxruntime_DNNL_OPENCL_ROOT=" + (args.dnnl_opencl_root if args.use_dnnl else ""), "-Donnxruntime_USE_NNAPI_BUILTIN=" + ("ON" if args.use_nnapi else "OFF"), "-Donnxruntime_USE_RKNPU=" + ("ON" if args.use_rknpu else "OFF"), "-Donnxruntime_USE_OPENMP=" + ( "ON" if args.use_openmp and not ( args.use_nnapi or args.android or (args.ios and is_macOS()) or args.use_rknpu) else "OFF"), "-Donnxruntime_USE_TVM=" + ("ON" if args.use_nuphar else "OFF"), "-Donnxruntime_USE_LLVM=" + ("ON" if args.use_nuphar else "OFF"), "-Donnxruntime_ENABLE_MICROSOFT_INTERNAL=" + ( "ON" if args.enable_msinternal else "OFF"), "-Donnxruntime_USE_VITISAI=" + ("ON" if args.use_vitisai else "OFF"), "-Donnxruntime_USE_NUPHAR=" + ("ON" if args.use_nuphar else "OFF"), "-Donnxruntime_USE_TENSORRT=" + ("ON" if args.use_tensorrt else "OFF"), "-Donnxruntime_TENSORRT_HOME=" + ( tensorrt_home if args.use_tensorrt else ""), # set vars for migraphx "-Donnxruntime_USE_MIGRAPHX=" + ("ON" if args.use_migraphx else "OFF"), "-Donnxruntime_MIGRAPHX_HOME=" + (migraphx_home if args.use_migraphx else ""), # By default - we currently support only cross compiling for # ARM/ARM64 (no native compilation supported through this # script). "-Donnxruntime_CROSS_COMPILING=" + ( "ON" if args.arm64 or args.arm else "OFF"), "-Donnxruntime_DISABLE_CONTRIB_OPS=" + ("ON" if args.disable_contrib_ops else "OFF"), "-Donnxruntime_DISABLE_ML_OPS=" + ("ON" if args.disable_ml_ops else "OFF"), "-Donnxruntime_DISABLE_RTTI=" + ("ON" if args.disable_rtti else "OFF"), "-Donnxruntime_DISABLE_EXCEPTIONS=" + ("ON" if args.disable_exceptions else "OFF"), "-Donnxruntime_DISABLE_ORT_FORMAT_LOAD=" + ("ON" if args.disable_ort_format_load else "OFF"), "-Donnxruntime_MINIMAL_BUILD=" + ("ON" if args.minimal_build != 'off' else "OFF"), "-Donnxruntime_EXTENDED_MINIMAL_BUILD=" + ("ON" if args.minimal_build == 'extended' else "OFF"), "-Donnxruntime_REDUCED_OPS_BUILD=" + ("ON" if args.include_ops_by_config else "OFF"), "-Donnxruntime_MSVC_STATIC_RUNTIME=" + ( "ON" if args.enable_msvc_static_runtime else "OFF"), # enable pyop if it is nightly build "-Donnxruntime_ENABLE_LANGUAGE_INTEROP_OPS=" + ( "ON" if args.enable_language_interop_ops else "OFF"), "-Donnxruntime_USE_DML=" + ("ON" if args.use_dml else "OFF"), "-Donnxruntime_USE_WINML=" + ("ON" if args.use_winml else "OFF"), "-Donnxruntime_USE_TELEMETRY=" + ( "ON" if args.use_telemetry else "OFF"), "-Donnxruntime_ENABLE_LTO=" + ("ON" if args.enable_lto else "OFF"), "-Donnxruntime_USE_ACL=" + ("ON" if args.use_acl else "OFF"), "-Donnxruntime_USE_ACL_1902=" + ( "ON" if args.use_acl == "ACL_1902" else "OFF"), "-Donnxruntime_USE_ACL_1905=" + ( "ON" if args.use_acl == "ACL_1905" else "OFF"), "-Donnxruntime_USE_ACL_1908=" + ( "ON" if args.use_acl == "ACL_1908" else "OFF"), "-Donnxruntime_USE_ACL_2002=" + ( "ON" if args.use_acl == "ACL_2002" else "OFF"), "-Donnxruntime_USE_ARMNN=" + ( "ON" if args.use_armnn else "OFF"), "-Donnxruntime_ARMNN_RELU_USE_CPU=" + ( "OFF" if args.armnn_relu else "ON"), "-Donnxruntime_ARMNN_BN_USE_CPU=" + ( "OFF" if args.armnn_bn else "ON"), # Training related flags "-Donnxruntime_ENABLE_NVTX_PROFILE=" + ( "ON" if args.enable_nvtx_profile else "OFF"), "-Donnxruntime_ENABLE_TRAINING=" + ( "ON" if args.enable_training else "OFF"), # Enable advanced computations such as AVX for some traininig related ops. "-Donnxruntime_ENABLE_CPU_FP16_OPS=" + ( "ON" if args.enable_training else "OFF"), "-Donnxruntime_USE_NCCL=" + ( "OFF" if args.disable_nccl else "ON"), "-Donnxruntime_BUILD_BENCHMARKS=" + ( "ON" if args.build_micro_benchmarks else "OFF"), "-Donnxruntime_USE_ROCM=" + ("ON" if args.use_rocm else "OFF"), "-Donnxruntime_ROCM_HOME=" + (rocm_home if args.use_rocm else ""), "-DOnnxruntime_GCOV_COVERAGE=" + ("ON" if args.code_coverage else "OFF"), "-Donnxruntime_USE_MPI=" + ( "ON" if args.use_mpi else "OFF"), "-Donnxruntime_ENABLE_MEMORY_PROFILE=" + ( "ON" if args.enable_memory_profile else "OFF"), ] if acl_home and os.path.exists(acl_home): cmake_args += ["-Donnxruntime_ACL_HOME=" + acl_home] if acl_libs and os.path.exists(acl_libs): cmake_args += ["-Donnxruntime_ACL_LIBS=" + acl_libs] if armnn_home and os.path.exists(armnn_home): cmake_args += ["-Donnxruntime_ARMNN_HOME=" + armnn_home] if armnn_libs and os.path.exists(armnn_libs): cmake_args += ["-Donnxruntime_ARMNN_LIBS=" + armnn_libs] if mpi_home and os.path.exists(mpi_home): if args.use_mpi: cmake_args += ["-Donnxruntime_MPI_HOME=" + mpi_home] else: log.warning("mpi_home is supplied but use_mpi is set to false." " Build will continue without linking MPI libraries.") if nccl_home and os.path.exists(nccl_home): cmake_args += ["-Donnxruntime_NCCL_HOME=" + nccl_home] if args.winml_root_namespace_override: cmake_args += ["-Donnxruntime_WINML_NAMESPACE_OVERRIDE=" + args.winml_root_namespace_override] if args.use_openvino: cmake_args += ["-Donnxruntime_USE_OPENVINO=ON", "-Donnxruntime_USE_OPENVINO_MYRIAD=" + ( "ON" if args.use_openvino == "MYRIAD_FP16" else "OFF"), "-Donnxruntime_USE_OPENVINO_GPU_FP32=" + ( "ON" if args.use_openvino == "GPU_FP32" else "OFF"), "-Donnxruntime_USE_OPENVINO_GPU_FP16=" + ( "ON" if args.use_openvino == "GPU_FP16" else "OFF"), "-Donnxruntime_USE_OPENVINO_CPU_FP32=" + ( "ON" if args.use_openvino == "CPU_FP32" else "OFF"), "-Donnxruntime_USE_OPENVINO_VAD_M=" + ( "ON" if args.use_openvino == "VAD-M_FP16" else "OFF"), "-Donnxruntime_USE_OPENVINO_VAD_F=" + ( "ON" if args.use_openvino == "VAD-F_FP32" else "OFF"), "-Donnxruntime_USE_OPENVINO_HETERO=" + ( "ON" if args.use_openvino.startswith("HETERO") else "OFF"), "-Donnxruntime_USE_OPENVINO_DEVICE=" + (args.use_openvino), "-Donnxruntime_USE_OPENVINO_MULTI=" + ( "ON" if args.use_openvino.startswith("MULTI") else "OFF")] # TensorRT and OpenVINO providers currently only supports # full_protobuf option. if (args.use_full_protobuf or args.use_tensorrt or args.use_openvino or args.use_vitisai or args.gen_doc): cmake_args += [ "-Donnxruntime_USE_FULL_PROTOBUF=ON", "-DProtobuf_USE_STATIC_LIBS=ON" ] if args.use_nuphar and args.llvm_path is not None: cmake_args += ["-DLLVM_DIR=%s" % args.llvm_path] if args.use_cuda and not is_windows(): nvml_stub_path = cuda_home + "/lib64/stubs" cmake_args += ["-DCUDA_CUDA_LIBRARY=" + nvml_stub_path] if args.use_preinstalled_eigen: cmake_args += ["-Donnxruntime_USE_PREINSTALLED_EIGEN=ON", "-Deigen_SOURCE_PATH=" + args.eigen_path] if args.nnapi_min_api: cmake_args += ["-Donnxruntime_NNAPI_MIN_API=" + str(args.nnapi_min_api)] if args.android: cmake_args += [ "-DCMAKE_TOOLCHAIN_FILE=" + args.android_ndk_path + "/build/cmake/android.toolchain.cmake", "-DANDROID_PLATFORM=android-" + str(args.android_api), "-DANDROID_ABI=" + str(args.android_abi) ] if args.android_cpp_shared: cmake_args += ["-DANDROID_STL=c++_shared"] if is_macOS() and not args.android: cmake_args += ["-DCMAKE_OSX_ARCHITECTURES=" + args.osx_arch] # since cmake 3.19, it uses the xcode latest buildsystem, which is not supported by this project. cmake_verstr = subprocess.check_output(['cmake', '--version']).decode('utf-8').split()[2] if args.use_xcode and LooseVersion(cmake_verstr) >= LooseVersion('3.19.0'): cmake_args += ["-T", "buildsystem=1"] if args.apple_deploy_target: cmake_args += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=" + args.apple_deploy_target] if args.use_coreml: if not is_macOS(): raise BuildError("Build CoreML EP requires macOS") cmake_args += ["-Donnxruntime_USE_COREML=ON"] if args.ios: if is_macOS(): needed_args = [ args.use_xcode, args.ios_sysroot, args.apple_deploy_target, ] arg_names = [ "--use_xcode " + "<need use xcode to cross build iOS on MacOS>", "--ios_sysroot " + "<the location or name of the macOS platform SDK>", "--apple_deploy_target " + "<the minimum version of the target platform>", ] if not all(needed_args): raise BuildError( "iOS build on MacOS canceled due to missing arguments: " + ', '.join( val for val, cond in zip(arg_names, needed_args) if not cond)) cmake_args += [ "-DCMAKE_SYSTEM_NAME=iOS", "-Donnxruntime_BUILD_SHARED_LIB=ON", "-DCMAKE_OSX_SYSROOT=" + args.ios_sysroot, "-DCMAKE_OSX_DEPLOYMENT_TARGET=" + args.apple_deploy_target, # we do not need protoc binary for ios cross build "-Dprotobuf_BUILD_PROTOC_BINARIES=OFF", "-DCMAKE_TOOLCHAIN_FILE=" + ( args.ios_toolchain_file if args.ios_toolchain_file else "../cmake/onnxruntime_ios.toolchain.cmake") ] # Code sign the binaries, if the code signing development team id is provided if args.xcode_code_signing_team_id: cmake_args += ["-DCMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM=" + args.xcode_code_signing_team_id] else: # TODO: the cross compiling on Linux is not officially supported by Apple # and is already broken with the latest codebase, so it should be removed. # We are cross compiling on Linux needed_args = [ args.ios_sysroot, args.arm64 or args.arm, args.ios_toolchain_dir ] arg_names = [ "--ios_sysroot <path to sysroot>", "--arm or --arm64", "--ios_toolchain_dir <path to toolchain>" ] if not all(needed_args): raise BuildError( "iOS build canceled due to missing arguments: " + ', '.join( val for val, cond in zip(arg_names, needed_args) if not cond)) compilers = sorted( glob.glob(args.ios_toolchain_dir + "/bin/*-clang*")) os.environ["PATH"] = os.path.join( args.ios_toolchain_dir, "bin") + os.pathsep + os.environ.get( "PATH", "") os.environ["LD_LIBRARY_PATH"] = os.path.join( args.ios_toolchain_dir, "/lib") + os.pathsep + os.environ.get( "LD_LIBRARY_PATH", "") if len(compilers) != 2: raise BuildError( "error identifying compilers in ios_toolchain_dir") cmake_args += [ "-DCMAKE_OSX_ARCHITECTURES=" + ("arm64" if args.arm64 else "arm"), "-DCMAKE_SYSTEM_NAME=iOSCross", "-Donnxruntime_BUILD_UNIT_TESTS=OFF", "-DCMAKE_OSX_SYSROOT=" + args.ios_sysroot, "-DCMAKE_C_COMPILER=" + compilers[0], "-DCMAKE_CXX_COMPILER=" + compilers[1] ] if path_to_protoc_exe: cmake_args += [ "-DONNX_CUSTOM_PROTOC_EXECUTABLE=%s" % path_to_protoc_exe] if args.fuzz_testing: if not (args.build_shared_lib and is_windows() and args.cmake_generator == 'Visual Studio 16 2019' and args.use_full_protobuf): raise BuildError( "Fuzz test has only be tested with build shared libs option using MSVC on windows") cmake_args += [ "-Donnxruntime_BUILD_UNIT_TESTS=ON", "-Donnxruntime_FUZZ_TEST=ON", "-Donnxruntime_USE_FULL_PROTOBUF=ON"] if args.gen_doc: cmake_args += ["-Donnxruntime_PYBIND_EXPORT_OPSCHEMA=ON"] else: cmake_args += ["-Donnxruntime_PYBIND_EXPORT_OPSCHEMA=OFF"] cmake_args += ["-D{}".format(define) for define in cmake_extra_defines] cmake_args += cmake_extra_args # ADO pipelines will store the pipeline build number # (e.g. 191101-2300.1.master) and source version in environment # variables. If present, use these values to define the # WinML/ORT DLL versions. build_number = os.getenv('Build_BuildNumber') source_version = os.getenv('Build_SourceVersion') if build_number and source_version: build_matches = re.fullmatch( r"(\d\d)(\d\d)(\d\d)(\d\d)\.(\d+)", build_number) if build_matches: YY = build_matches.group(2) MM = build_matches.group(3) DD = build_matches.group(4) # Get ORT major and minor number with open(os.path.join(source_dir, 'VERSION_NUMBER')) as f: first_line = f.readline() ort_version_matches = re.match(r"(\d+).(\d+)", first_line) if not ort_version_matches: raise BuildError("Couldn't read version from VERSION_FILE") ort_major = ort_version_matches.group(1) ort_minor = ort_version_matches.group(2) # Example (BuildNumber: 191101-2300.1.master, # SourceVersion: 0bce7ae6755c792eda558e5d27ded701707dc404) # MajorPart = 1 # MinorPart = 0 # BuildPart = 1911 # PrivatePart = 123 # String = 191101-2300.1.master.0bce7ae cmake_args += [ "-DVERSION_MAJOR_PART={}".format(ort_major), "-DVERSION_MINOR_PART={}".format(ort_minor), "-DVERSION_BUILD_PART={}".format(YY), "-DVERSION_PRIVATE_PART={}{}".format(MM, DD), "-DVERSION_STRING={}.{}.{}.{}".format( ort_major, ort_minor, build_number, source_version[0:7]) ] for config in configs: config_build_dir = get_config_build_dir(build_dir, config) os.makedirs(config_build_dir, exist_ok=True) if args.use_nuphar: os.environ["PATH"] = os.path.join( config_build_dir, "external", "tvm", config) + os.pathsep + os.path.dirname(sys.executable) + os.pathsep + os.environ["PATH"] run_subprocess( cmake_args + [ "-Donnxruntime_ENABLE_MEMLEAK_CHECKER=" + ("ON" if config.lower() == 'debug' and not args.use_nuphar and not args.use_openvino and not args.enable_msvc_static_runtime else "OFF"), "-DCMAKE_BUILD_TYPE={}".format(config)], cwd=config_build_dir) def clean_targets(cmake_path, build_dir, configs): for config in configs: log.info("Cleaning targets for %s configuration", config) build_dir2 = get_config_build_dir(build_dir, config) cmd_args = [cmake_path, "--build", build_dir2, "--config", config, "--target", "clean"] run_subprocess(cmd_args) def build_targets(args, cmake_path, build_dir, configs, num_parallel_jobs, target=None): for config in configs: log.info("Building targets for %s configuration", config) build_dir2 = get_config_build_dir(build_dir, config) cmd_args = [cmake_path, "--build", build_dir2, "--config", config] if target: cmd_args.extend(['--target', target]) build_tool_args = [] if num_parallel_jobs != 1: if is_windows() and args.cmake_generator != 'Ninja': build_tool_args += [ "/maxcpucount:{}".format(num_parallel_jobs), # if nodeReuse is true, msbuild processes will stay around for a bit after the build completes "/nodeReuse:False", ] elif (is_macOS() and args.use_xcode): # CMake will generate correct build tool args for Xcode cmd_args += ["--parallel", str(num_parallel_jobs)] else: build_tool_args += ["-j{}".format(num_parallel_jobs)] if build_tool_args: cmd_args += ["--"] cmd_args += build_tool_args env = {} if args.android: env['ANDROID_SDK_ROOT'] = args.android_sdk_path run_subprocess(cmd_args, env=env) def add_dir_if_exists(directory, dir_list): if os.path.isdir(directory): dir_list.append(directory) def setup_cuda_vars(args): cuda_home = "" cudnn_home = "" if args.use_cuda: cuda_home = args.cuda_home if args.cuda_home else os.getenv( "CUDA_HOME") cudnn_home = args.cudnn_home if args.cudnn_home else os.getenv( "CUDNN_HOME") cuda_home_valid = (cuda_home is not None and os.path.exists(cuda_home)) cudnn_home_valid = (cudnn_home is not None and os.path.exists( cudnn_home)) if not cuda_home_valid or not cudnn_home_valid: raise BuildError( "cuda_home and cudnn_home paths must be specified and valid.", "cuda_home='{}' valid={}. cudnn_home='{}' valid={}" .format( cuda_home, cuda_home_valid, cudnn_home, cudnn_home_valid)) return cuda_home, cudnn_home def setup_tensorrt_vars(args): tensorrt_home = "" if args.use_tensorrt: tensorrt_home = (args.tensorrt_home if args.tensorrt_home else os.getenv("TENSORRT_HOME")) tensorrt_home_valid = (tensorrt_home is not None and os.path.exists(tensorrt_home)) if not tensorrt_home_valid: raise BuildError( "tensorrt_home paths must be specified and valid.", "tensorrt_home='{}' valid={}." .format(tensorrt_home, tensorrt_home_valid)) # Set maximum workspace size in byte for # TensorRT (1GB = 1073741824 bytes). os.environ["ORT_TENSORRT_MAX_WORKSPACE_SIZE"] = "1073741824" # Set maximum number of iterations to detect unsupported nodes # and partition the models for TensorRT. os.environ["ORT_TENSORRT_MAX_PARTITION_ITERATIONS"] = "1000" # Set minimum subgraph node size in graph partitioning # for TensorRT. os.environ["ORT_TENSORRT_MIN_SUBGRAPH_SIZE"] = "1" # Set FP16 flag os.environ["ORT_TENSORRT_FP16_ENABLE"] = "0" return tensorrt_home def setup_migraphx_vars(args): migraphx_home = None if (args.use_migraphx): print("migraphx_home = {}".format(args.migraphx_home)) migraphx_home = args.migraphx_home or os.getenv("MIGRAPHX_HOME") or None migraphx_home_not_valid = (migraphx_home and not os.path.exists(migraphx_home)) if (migraphx_home_not_valid): raise BuildError("migraphx_home paths must be specified and valid.", "migraphx_home='{}' valid={}." .format(migraphx_home, migraphx_home_not_valid)) return migraphx_home or '' def setup_dml_build(args, cmake_path, build_dir, configs): if args.use_dml: for config in configs: # Run the RESTORE_PACKAGES target to perform the initial # NuGet setup. cmd_args = [cmake_path, "--build", get_config_build_dir(build_dir, config), "--config", config, "--target", "RESTORE_PACKAGES"] run_subprocess(cmd_args) def setup_rocm_build(args, configs): rocm_home = None if (args.use_rocm): print("rocm_home = {}".format(args.rocm_home)) rocm_home = args.rocm_home or None rocm_home_not_valid = (rocm_home and not os.path.exists(rocm_home)) if (rocm_home_not_valid): raise BuildError("rocm_home paths must be specified and valid.", "rocm_home='{}' valid={}." .format(rocm_home, rocm_home_not_valid)) for config in configs: amd_hipify(get_config_build_dir(args.build_dir, config)) return rocm_home or '' def run_android_tests(args, source_dir, config, cwd): sdk_tool_paths = android.get_sdk_tool_paths(args.android_sdk_path) device_dir = '/data/local/tmp' def adb_push(src, dest, **kwargs): return run_subprocess([sdk_tool_paths.adb, 'push', src, dest], **kwargs) def adb_shell(*args, **kwargs): return run_subprocess([sdk_tool_paths.adb, 'shell', *args], **kwargs) def run_adb_shell(cmd): # GCOV_PREFIX_STRIP specifies the depth of the directory hierarchy to strip and # GCOV_PREFIX specifies the root directory # for creating the runtime code coverage files. if args.code_coverage: adb_shell( 'cd {0} && GCOV_PREFIX={0} GCOV_PREFIX_STRIP={1} {2}'.format( device_dir, cwd.count(os.sep) + 1, cmd)) else: adb_shell('cd {} && {}'.format(device_dir, cmd)) if args.android_abi == 'x86_64': with contextlib.ExitStack() as context_stack: if args.android_run_emulator: avd_name = "ort_android" system_image = "system-images;android-{};google_apis;{}".format( args.android_api, args.android_abi) android.create_virtual_device(sdk_tool_paths, system_image, avd_name) emulator_proc = context_stack.enter_context( android.start_emulator( sdk_tool_paths=sdk_tool_paths, avd_name=avd_name, extra_args=[ "-partition-size", "2047", "-wipe-data"])) context_stack.callback(android.stop_emulator, emulator_proc) adb_push('testdata', device_dir, cwd=cwd) adb_push( os.path.join(source_dir, 'cmake', 'external', 'onnx', 'onnx', 'backend', 'test'), device_dir, cwd=cwd) adb_push('onnxruntime_test_all', device_dir, cwd=cwd) adb_shell('chmod +x {}/onnxruntime_test_all'.format(device_dir)) adb_push('onnx_test_runner', device_dir, cwd=cwd) adb_shell('chmod +x {}/onnx_test_runner'.format(device_dir)) run_adb_shell('{0}/onnxruntime_test_all'.format(device_dir)) if args.use_nnapi: adb_shell('cd {0} && {0}/onnx_test_runner -e nnapi {0}/test'.format(device_dir)) else: adb_shell('cd {0} && {0}/onnx_test_runner {0}/test'.format(device_dir)) # run shared_lib_test if necessary if args.build_shared_lib: adb_push('libonnxruntime.so', device_dir, cwd=cwd) adb_push('onnxruntime_shared_lib_test', device_dir, cwd=cwd) adb_shell('chmod +x {}/onnxruntime_shared_lib_test'.format(device_dir)) run_adb_shell( 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{0} && {0}/onnxruntime_shared_lib_test'.format( device_dir)) def run_ios_tests(args, source_dir, config, cwd): cpr = run_subprocess(["xcodebuild", "test", "-project", "./onnxruntime.xcodeproj", "-configuration", config, "-scheme", "onnxruntime_test_all_xc", "-destination", "platform=iOS Simulator,OS=latest,name=iPhone SE (2nd generation)"], cwd=cwd) if cpr.returncode == 0: cpr = run_subprocess(["xcodebuild", "test", "-project", "./onnxruntime.xcodeproj", "-configuration", config, "-scheme", "onnxruntime_shared_lib_test_xc", "-destination", "platform=iOS Simulator,OS=latest,name=iPhone SE (2nd generation)"], cwd=cwd) cpr.check_returncode() def run_orttraining_test_orttrainer_frontend_separately(cwd): class TestNameCollecterPlugin: def __init__(self): self.collected = set() def pytest_collection_modifyitems(self, items): for item in items: print('item.name: ', item.name) test_name = item.name start = test_name.find('[') if start > 0: test_name = test_name[:start] self.collected.add(test_name) import pytest plugin = TestNameCollecterPlugin() test_script_filename = os.path.join(cwd, "orttraining_test_orttrainer_frontend.py") pytest.main(['--collect-only', test_script_filename], plugins=[plugin]) for test_name in plugin.collected: run_subprocess([ sys.executable, '-m', 'pytest', 'orttraining_test_orttrainer_frontend.py', '-v', '-k', test_name], cwd=cwd) def run_training_python_frontend_tests(cwd): run_subprocess([sys.executable, 'onnxruntime_test_ort_trainer.py'], cwd=cwd) run_subprocess([sys.executable, 'onnxruntime_test_training_unit_tests.py'], cwd=cwd) run_subprocess([ sys.executable, 'orttraining_test_transformers.py', 'BertModelTest.test_for_pretraining_full_precision_list_input'], cwd=cwd) run_subprocess([ sys.executable, 'orttraining_test_transformers.py', 'BertModelTest.test_for_pretraining_full_precision_dict_input'], cwd=cwd) run_subprocess([ sys.executable, 'orttraining_test_transformers.py', 'BertModelTest.test_for_pretraining_full_precision_list_and_dict_input'], cwd=cwd) # TODO: use run_orttraining_test_orttrainer_frontend_separately to work around a sporadic segfault. # shall revert to run_subprocess call once the segfault issue is resolved. run_orttraining_test_orttrainer_frontend_separately(cwd) # run_subprocess([sys.executable, '-m', 'pytest', '-sv', 'orttraining_test_orttrainer_frontend.py'], cwd=cwd) run_subprocess([sys.executable, '-m', 'pytest', '-sv', 'orttraining_test_orttrainer_bert_toy_onnx.py'], cwd=cwd) run_subprocess([sys.executable, '-m', 'pytest', '-sv', 'orttraining_test_checkpoint_storage.py'], cwd=cwd) run_subprocess([ sys.executable, '-m', 'pytest', '-sv', 'orttraining_test_orttrainer_checkpoint_functions.py'], cwd=cwd) def run_training_python_frontend_e2e_tests(cwd): # frontend tests are to be added here: log.info("Running python frontend e2e tests.") run_subprocess( [sys.executable, 'orttraining_run_frontend_batch_size_test.py', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) import torch ngpus = torch.cuda.device_count() if ngpus > 1: bert_pretrain_script = 'orttraining_run_bert_pretrain.py' # TODO: this test will be replaced with convergence test ported from backend log.debug('RUN: mpirun -n {} ''-x' 'NCCL_DEBUG=INFO'' {} {} {}'.format( ngpus, sys.executable, bert_pretrain_script, 'ORTBertPretrainTest.test_pretrain_convergence')) run_subprocess([ 'mpirun', '-n', str(ngpus), '-x', 'NCCL_DEBUG=INFO', sys.executable, bert_pretrain_script, 'ORTBertPretrainTest.test_pretrain_convergence'], cwd=cwd) log.debug('RUN: mpirun -n {} {} orttraining_run_glue.py'.format(ngpus, sys.executable)) run_subprocess([ 'mpirun', '-n', str(ngpus), '-x', 'NCCL_DEBUG=INFO', sys.executable, 'orttraining_run_glue.py'], cwd=cwd) # with orttraining_run_glue.py. # 1. we like to force to use single GPU (with CUDA_VISIBLE_DEVICES) # for fine-tune tests. # 2. need to run test separately (not to mix between fp16 # and full precision runs. this need to be investigated). run_subprocess( [sys.executable, 'orttraining_run_glue.py', 'ORTGlueTest.test_bert_with_mrpc', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) run_subprocess( [sys.executable, 'orttraining_run_glue.py', 'ORTGlueTest.test_bert_fp16_with_mrpc', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) run_subprocess( [sys.executable, 'orttraining_run_glue.py', 'ORTGlueTest.test_roberta_with_mrpc', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) run_subprocess( [sys.executable, 'orttraining_run_glue.py', 'ORTGlueTest.test_roberta_fp16_with_mrpc', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) run_subprocess( [sys.executable, 'orttraining_run_multiple_choice.py', 'ORTMultipleChoiceTest.test_bert_fp16_with_swag', '-v'], cwd=cwd, env={'CUDA_VISIBLE_DEVICES': '0'}) run_subprocess([sys.executable, 'onnxruntime_test_ort_trainer_with_mixed_precision.py'], cwd=cwd) run_subprocess([ sys.executable, 'orttraining_test_transformers.py', 'BertModelTest.test_for_pretraining_mixed_precision'], cwd=cwd) def run_onnxruntime_tests(args, source_dir, ctest_path, build_dir, configs): for config in configs: log.info("Running tests for %s configuration", config) cwd = get_config_build_dir(build_dir, config) cwd = os.path.abspath(cwd) if args.android: run_android_tests(args, source_dir, config, cwd) continue elif args.ios: run_ios_tests(args, source_dir, config, cwd) continue dll_path_list = [] if args.use_nuphar: dll_path_list.append(os.path.join( build_dir, config, "external", "tvm", config)) if args.use_tensorrt: dll_path_list.append(os.path.join(args.tensorrt_home, 'lib')) dll_path = None if len(dll_path_list) > 0: dll_path = os.pathsep.join(dll_path_list) if ctest_path is None: # Get the "Google Test Adapter" for vstest. if not os.path.exists(os.path.join(cwd, 'googletestadapter.0.17.1')): run_subprocess( ['nuget.exe', 'restore', os.path.join(source_dir, 'packages.config'), '-ConfigFile', os.path.join(source_dir, 'NuGet.config'), '-PackagesDirectory', cwd]) cwd2 = os.path.join(cwd, config) executables = ['onnxruntime_test_all.exe'] if args.build_shared_lib: executables.append('onnxruntime_shared_lib_test.exe') executables.append('onnxruntime_global_thread_pools_test.exe') run_subprocess( ['vstest.console.exe', '--parallel', '--TestAdapterPath:..\\googletestadapter.0.17.1\\build\\_common', # noqa '/Logger:trx', '/Enablecodecoverage', '/Platform:x64', "/Settings:%s" % os.path.join( source_dir, 'cmake\\codeconv.runsettings')] + executables, cwd=cwd2, dll_path=dll_path) else: ctest_cmd = [ctest_path, "--build-config", config, "--verbose", "--timeout", "3600"] run_subprocess(ctest_cmd, cwd=cwd, dll_path=dll_path) if args.enable_pybind: # Disable python tests for TensorRT because many tests are # not supported yet. if args.use_tensorrt: return # Disable python tests in a reduced build as we don't know which ops have been included and which # models can run if args.include_ops_by_config or args.minimal_build != 'off': return if is_windows(): cwd = os.path.join(cwd, config) run_subprocess([sys.executable, 'onnxruntime_test_python.py'], cwd=cwd, dll_path=dll_path) if args.enable_symbolic_shape_infer_tests: run_subprocess([sys.executable, 'onnxruntime_test_python_symbolic_shape_infer.py'], cwd=cwd, dll_path=dll_path) # For CUDA enabled builds test IOBinding feature if args.use_cuda: # We need to have Torch installed to test the IOBinding feature # which currently uses Torch's allocator to allocate GPU memory for testing log.info("Testing IOBinding feature") run_subprocess([sys.executable, 'onnxruntime_test_python_iobinding.py'], cwd=cwd, dll_path=dll_path) if not args.disable_ml_ops: run_subprocess([sys.executable, 'onnxruntime_test_python_mlops.py'], cwd=cwd, dll_path=dll_path) if args.enable_training and args.use_cuda: # run basic frontend tests run_training_python_frontend_tests(cwd=cwd) try: import onnx # noqa onnx_test = True except ImportError as error: log.exception(error) log.warning("onnx is not installed. The ONNX tests will be skipped.") onnx_test = False if onnx_test: run_subprocess([sys.executable, 'onnxruntime_test_python_backend.py'], cwd=cwd, dll_path=dll_path) run_subprocess([sys.executable, '-m', 'unittest', 'discover', '-s', 'quantization'], cwd=cwd, dll_path=dll_path) if not args.disable_ml_ops: run_subprocess([sys.executable, 'onnxruntime_test_python_backend_mlops.py'], cwd=cwd, dll_path=dll_path) run_subprocess([sys.executable, os.path.join(source_dir, 'onnxruntime', 'test', 'onnx', 'gen_test_models.py'), '--output_dir', 'test_models'], cwd=cwd) if not args.skip_onnx_tests: run_subprocess([os.path.join(cwd, 'onnx_test_runner'), 'test_models'], cwd=cwd) if config != 'Debug': run_subprocess([sys.executable, 'onnx_backend_test_series.py'], cwd=cwd, dll_path=dll_path) if not args.skip_keras_test: try: import onnxmltools # noqa import keras # noqa onnxml_test = True except ImportError: log.warning( "onnxmltools and keras are not installed. " "The keras tests will be skipped.") onnxml_test = False if onnxml_test: run_subprocess( [sys.executable, 'onnxruntime_test_python_keras.py'], cwd=cwd, dll_path=dll_path) def nuphar_run_python_tests(build_dir, configs): """nuphar temporary function for running python tests separately as it requires ONNX 1.5.0 """ for config in configs: if config == 'Debug': continue cwd = get_config_build_dir(build_dir, config) if is_windows(): cwd = os.path.join(cwd, config) dll_path = os.path.join(build_dir, config, "external", "tvm", config) # install onnx for shape inference in testing Nuphar scripts # this needs to happen after onnx_test_data preparation which # uses onnx 1.3.0 run_subprocess( [sys.executable, '-m', 'pip', 'install', '--user', 'onnx==1.5.0']) run_subprocess( [sys.executable, 'onnxruntime_test_python_nuphar.py'], cwd=cwd, dll_path=dll_path) def run_nodejs_tests(nodejs_binding_dir): args = ['npm', 'test', '--', '--timeout=2000'] if is_windows(): args = ['cmd', '/c'] + args run_subprocess(args, cwd=nodejs_binding_dir) def build_python_wheel( source_dir, build_dir, configs, use_cuda, use_dnnl, use_tensorrt, use_openvino, use_nuphar, use_vitisai, use_acl, use_armnn, use_dml, wheel_name_suffix, enable_training, nightly_build=False, featurizers_build=False, use_ninja=False): for config in configs: cwd = get_config_build_dir(build_dir, config) if is_windows() and not use_ninja: cwd = os.path.join(cwd, config) args = [sys.executable, os.path.join(source_dir, 'setup.py'), 'bdist_wheel'] # We explicitly override the platform tag in the name of the generated build wheel # so that we can install the wheel on Mac OS X versions 10.12+. # Without this explicit override, we will something like this while building on MacOS 10.14 - # [WARNING] MACOSX_DEPLOYMENT_TARGET is set to a lower value (10.12) # than the version on which the Python interpreter was compiled (10.14) and will be ignored. # Since we need to support 10.12+, we explicitly override the platform tag. # See PR #3626 for more details if is_macOS(): args += ['-p', 'macosx_10_12_x86_64'] # Any combination of the following arguments can be applied if nightly_build: args.append('--nightly_build') if featurizers_build: args.append("--use_featurizers") if wheel_name_suffix: args.append('--wheel_name_suffix={}'.format(wheel_name_suffix)) if enable_training: args.append("--enable_training") # The following arguments are mutually exclusive if use_tensorrt: args.append('--use_tensorrt') elif use_cuda: args.append('--use_cuda') elif use_openvino: args.append('--use_openvino') elif use_dnnl: args.append('--use_dnnl') elif use_nuphar: args.append('--use_nuphar') elif use_vitisai: args.append('--use_vitisai') elif use_acl: args.append('--use_acl') elif use_armnn: args.append('--use_armnn') elif use_dml: args.append('--use_dml') run_subprocess(args, cwd=cwd) def derive_linux_build_property(): if is_windows(): return "/p:IsLinuxBuild=\"false\"" else: return "/p:IsLinuxBuild=\"true\"" def build_nuget_package(source_dir, build_dir, configs, use_cuda, use_openvino, use_tensorrt, use_dnnl): if not (is_windows() or is_linux()): raise BuildError( 'Currently csharp builds and nuget package creation is only supportted ' 'on Windows and Linux platforms.') csharp_build_dir = os.path.join(source_dir, 'csharp') is_linux_build = derive_linux_build_property() # derive package name and execution provider based on the build args execution_provider = "/p:ExecutionProvider=\"None\"" package_name = "/p:OrtPackageId=\"Microsoft.ML.OnnxRuntime\"" if use_openvino: execution_provider = "/p:ExecutionProvider=\"openvino\"" package_name = "/p:OrtPackageId=\"Microsoft.ML.OnnxRuntime.OpenVino\"" elif use_tensorrt: execution_provider = "/p:ExecutionProvider=\"tensorrt\"" package_name = "/p:OrtPackageId=\"Microsoft.ML.OnnxRuntime.TensorRT\"" elif use_dnnl: execution_provider = "/p:ExecutionProvider=\"dnnl\"" package_name = "/p:OrtPackageId=\"Microsoft.ML.OnnxRuntime.DNNL\"" elif use_cuda: package_name = "/p:OrtPackageId=\"Microsoft.ML.OnnxRuntime.Gpu\"" else: pass # set build directory based on build_dir arg native_dir = os.path.normpath(os.path.join(source_dir, build_dir)) ort_build_dir = "/p:OnnxRuntimeBuildDirectory=\"" + native_dir + "\"" # dotnet restore cmd_args = ["dotnet", "restore", "OnnxRuntime.CSharp.sln", "--configfile", "Nuget.CSharp.config"] run_subprocess(cmd_args, cwd=csharp_build_dir) # build csharp bindings and create nuget package for each config for config in configs: if is_linux(): native_build_dir = os.path.join(native_dir, config) cmd_args = ["make", "install", "DESTDIR=.//nuget-staging"] run_subprocess(cmd_args, cwd=native_build_dir) configuration = "/p:Configuration=\"" + config + "\"" cmd_args = ["dotnet", "msbuild", "OnnxRuntime.CSharp.sln", configuration, package_name, is_linux_build, ort_build_dir] run_subprocess(cmd_args, cwd=csharp_build_dir) cmd_args = [ "dotnet", "msbuild", "OnnxRuntime.CSharp.proj", "/t:CreatePackage", package_name, configuration, execution_provider, is_linux_build, ort_build_dir] run_subprocess(cmd_args, cwd=csharp_build_dir) def run_csharp_tests(source_dir, build_dir, use_cuda, use_openvino, use_tensorrt, use_dnnl): # Currently only running tests on windows. if not is_windows(): return csharp_source_dir = os.path.join(source_dir, 'csharp') is_linux_build = derive_linux_build_property() # define macros based on build args macros = "" if use_openvino: macros += "USE_OPENVINO;" if use_tensorrt: macros += "USE_TENSORRT;" if use_dnnl: macros += "USE_DNNL;" if use_cuda: macros += "USE_CUDA;" define_constants = "" if macros != "": define_constants = "/p:DefineConstants=\"" + macros + "\"" # set build directory based on build_dir arg native_build_dir = os.path.normpath(os.path.join(source_dir, build_dir)) ort_build_dir = "/p:OnnxRuntimeBuildDirectory=\"" + native_build_dir + "\"" # Skip pretrained models test. Only run unit tests as part of the build # add "--verbosity", "detailed" to this command if required cmd_args = ["dotnet", "test", "test\\Microsoft.ML.OnnxRuntime.Tests\\Microsoft.ML.OnnxRuntime.Tests.csproj", "--filter", "FullyQualifiedName!=Microsoft.ML.OnnxRuntime.Tests.InferenceTest.TestPreTrainedModels", is_linux_build, define_constants, ort_build_dir] run_subprocess(cmd_args, cwd=csharp_source_dir) def is_cross_compiling_on_apple(args): if not is_macOS(): return False if args.ios: return True if args.osx_arch != platform.machine(): return True return False def build_protoc_for_host(cmake_path, source_dir, build_dir, args): if (args.arm or args.arm64 or args.enable_windows_store) and \ not (is_windows() or is_cross_compiling_on_apple(args)): raise BuildError( 'Currently only support building protoc for Windows host while ' 'cross-compiling for ARM/ARM64/Store and linux cross-compiling iOS') log.info( "Building protoc for host to be used in cross-compiled build process") protoc_build_dir = os.path.join(os.getcwd(), build_dir, 'host_protoc') os.makedirs(protoc_build_dir, exist_ok=True) # Generate step cmd_args = [ cmake_path, os.path.join(source_dir, 'cmake', 'external', 'protobuf', 'cmake'), '-Dprotobuf_BUILD_TESTS=OFF', '-Dprotobuf_WITH_ZLIB_DEFAULT=OFF', '-Dprotobuf_BUILD_SHARED_LIBS=OFF' ] is_ninja = args.cmake_generator == 'Ninja' if args.cmake_generator is not None and not (is_macOS() and args.use_xcode): cmd_args += ['-G', args.cmake_generator] if is_windows(): if not is_ninja: cmd_args += ['-T', 'host=x64'] elif is_macOS(): if args.use_xcode: cmd_args += ['-G', 'Xcode'] # CMake < 3.18 has a bug setting system arch to arm64 (if not specified) for Xcode 12, # protoc for host should be built using host architecture # Explicitly specify the CMAKE_OSX_ARCHITECTURES for x86_64 Mac. cmd_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format( 'arm64' if platform.machine() == 'arm64' else 'x86_64')] run_subprocess(cmd_args, cwd=protoc_build_dir) # Build step cmd_args = [cmake_path, "--build", protoc_build_dir, "--config", "Release", "--target", "protoc"] run_subprocess(cmd_args) # Absolute protoc path is needed for cmake config_dir = '' suffix = '' if (is_windows() and not is_ninja) or (is_macOS() and args.use_xcode): config_dir = 'Release' if is_windows(): suffix = '.exe' expected_protoc_path = os.path.join(protoc_build_dir, config_dir, 'protoc' + suffix) if not os.path.exists(expected_protoc_path): raise BuildError("Couldn't find {}. Host build of protoc failed.".format(expected_protoc_path)) return expected_protoc_path def generate_documentation(source_dir, build_dir, configs): operator_doc_path = os.path.join(source_dir, 'docs', 'ContribOperators.md') opkernel_doc_path = os.path.join(source_dir, 'docs', 'OperatorKernels.md') for config in configs: # Copy the gen_contrib_doc.py. shutil.copy( os.path.join(source_dir, 'tools', 'python', 'gen_contrib_doc.py'), os.path.join(build_dir, config)) shutil.copy( os.path.join(source_dir, 'tools', 'python', 'gen_opkernel_doc.py'), os.path.join(build_dir, config)) run_subprocess( [sys.executable, 'gen_contrib_doc.py', '--output_path', operator_doc_path], cwd=os.path.join(build_dir, config)) run_subprocess( [sys.executable, 'gen_opkernel_doc.py', '--output_path', opkernel_doc_path], cwd=os.path.join(build_dir, config)) docdiff = '' try: docdiff = subprocess.check_output(['git', 'diff', opkernel_doc_path]) except subprocess.CalledProcessError: print('git diff returned non-zero error code') if len(docdiff) > 0: # Show warning instead of throwing exception, because it is # dependent on build configuration for including # execution propviders log.warning( 'The updated opkernel document file ' + str(opkernel_doc_path) + ' is different from the checked in version. Consider ' 'regenerating the file with CPU, DNNL and CUDA providers enabled.') log.debug('diff:\n' + str(docdiff)) docdiff = '' try: docdiff = subprocess.check_output(['git', 'diff', operator_doc_path]) except subprocess.CalledProcessError: print('git diff returned non-zero error code') if len(docdiff) > 0: raise BuildError( 'The updated operator document file ' + str(operator_doc_path) + ' must be checked in.\n diff:\n' + str(docdiff)) def main(): args = parse_arguments() cmake_extra_defines = (args.cmake_extra_defines if args.cmake_extra_defines else []) cross_compiling = args.arm or args.arm64 or args.android # If there was no explicit argument saying what to do, default # to update, build and test (for native builds). if not (args.update or args.clean or args.build or args.test): log.debug( "Defaulting to running update, build " "[and test for native builds].") args.update = True args.build = True if cross_compiling: args.test = args.android_abi == 'x86_64' or args.android_abi == 'arm64-v8a' else: args.test = True if args.skip_tests: args.test = False if args.include_ops_by_config: from exclude_unused_ops_and_types import exclude_unused_ops_and_types exclude_unused_ops_and_types(args.include_ops_by_config, args.enable_reduced_operator_type_support, args.use_cuda) if args.use_tensorrt: args.use_cuda = True if args.build_wheel or args.gen_doc: args.enable_pybind = True if args.build_csharp or args.build_nuget or args.build_java or args.build_nodejs: args.build_shared_lib = True if args.build_nuget and cross_compiling: raise BuildError('Currently nuget package creation is not supported while cross-compiling') if args.enable_pybind and args.disable_exceptions: raise BuildError('Python bindings require exceptions to be enabled.') if args.minimal_build and args.disable_ort_format_load: raise BuildError('Minimal build requires loading ORT format models.') if args.nnapi_min_api: if not args.use_nnapi: raise BuildError("Using --nnapi_min_api requires --use_nnapi") if args.nnapi_min_api < 27: raise BuildError("--nnapi_min_api should be 27+") if args.code_coverage and not args.android: raise BuildError("Using --code_coverage requires --android") # Disabling unit tests for VAD-F as FPGA only supports # models with NCHW layout if args.use_openvino == "VAD-F_FP32": args.test = False configs = set(args.config) # setup paths and directories cmake_path = resolve_executable_path(args.cmake_path) ctest_path = None if args.use_vstest else resolve_executable_path( args.ctest_path) build_dir = args.build_dir script_dir = os.path.realpath(os.path.dirname(__file__)) source_dir = os.path.normpath(os.path.join(script_dir, "..", "..")) # if using cuda, setup cuda paths and env vars cuda_home, cudnn_home = setup_cuda_vars(args) mpi_home = args.mpi_home nccl_home = args.nccl_home acl_home = args.acl_home acl_libs = args.acl_libs armnn_home = args.armnn_home armnn_libs = args.armnn_libs # if using tensorrt, setup tensorrt paths tensorrt_home = setup_tensorrt_vars(args) # if using migraphx, setup migraphx paths migraphx_home = setup_migraphx_vars(args) # if using rocm, setup rocm paths rocm_home = setup_rocm_build(args, configs) os.makedirs(build_dir, exist_ok=True) log.info("Build started") if args.update: cmake_extra_args = [] path_to_protoc_exe = args.path_to_protoc_exe if not args.skip_submodule_sync: update_submodules(source_dir) if is_windows(): if args.cmake_generator == 'Ninja': if args.x86 or args.arm or args.arm64: raise BuildError( "To cross-compile with Ninja, load the toolset " "environment for the target processor (e.g. Cross " "Tools Command Prompt for VS)") cmake_extra_args = ['-G', args.cmake_generator] elif args.x86: cmake_extra_args = [ '-A', 'Win32', '-T', 'host=x64', '-G', args.cmake_generator ] elif args.arm or args.arm64: # Cross-compiling for ARM(64) architecture # First build protoc for host to use during cross-compilation if path_to_protoc_exe is None: path_to_protoc_exe = build_protoc_for_host( cmake_path, source_dir, build_dir, args) if args.arm: cmake_extra_args = ['-A', 'ARM'] else: cmake_extra_args = ['-A', 'ARM64'] cmake_extra_args += ['-G', args.cmake_generator] # Cannot test on host build machine for cross-compiled # builds (Override any user-defined behaviour for test if any) if args.test: log.warning( "Cannot test on host build machine for cross-compiled " "ARM(64) builds. Will skip test running after build.") args.test = False else: if (args.msvc_toolset == '14.16' and args.cmake_generator == 'Visual Studio 16 2019'): # CUDA 10.0 requires _MSC_VER >= 1700 and # _MSC_VER < 1920, aka Visual Studio version # in [2012, 2019). In VS2019, we have to use # Side-by-side minor version MSVC toolsets from # Visual Studio 2017 14.16 is MSVC version # 141 is MSVC Toolset Version # Cuda VS extension should be installed to # C:\Program Files (x86)\Microsoft Visual # Studio\2019\Enterprise\MSBuild\Microsoft\VC\v160\BuildCustomizations # noqa toolset = 'v141,host=x64,version=' + args.msvc_toolset elif args.msvc_toolset: toolset = 'host=x64,version=' + args.msvc_toolset else: toolset = 'host=x64' if args.cuda_version: toolset += ',cuda=' + args.cuda_version cmake_extra_args = [ '-A', 'x64', '-T', toolset, '-G', args.cmake_generator ] if args.enable_windows_store: cmake_extra_args.append( '-DCMAKE_TOOLCHAIN_FILE=' + os.path.join( source_dir, 'cmake', 'store_toolchain.cmake')) if args.enable_wcos: cmake_extra_args.append('-DCMAKE_USER_MAKE_RULES_OVERRIDE=wcos_rules_override.cmake') elif args.cmake_generator is not None and not (is_macOS() and args.use_xcode): cmake_extra_args += ['-G', args.cmake_generator] elif is_macOS(): if args.use_xcode: cmake_extra_args += ['-G', 'Xcode'] if not args.ios and not args.android and \ args.osx_arch == 'arm64' and platform.machine() == 'x86_64': if args.test: log.warning( "Cannot test ARM64 build on X86_64. Will skip test running after build.") args.test = False if (args.android or args.ios or args.enable_windows_store or is_cross_compiling_on_apple(args)) and args.path_to_protoc_exe is None: # Cross-compiling for Android and iOS path_to_protoc_exe = build_protoc_for_host( cmake_path, source_dir, build_dir, args) if is_ubuntu_1604(): if (args.arm or args.arm64): raise BuildError( "Only Windows ARM(64) cross-compiled builds supported " "currently through this script") if not is_docker() and not args.use_acl and not args.use_armnn: install_python_deps() if args.enable_pybind and is_windows(): install_python_deps(args.numpy_version) if args.enable_onnx_tests: setup_test_data(build_dir, configs) generate_build_tree( cmake_path, source_dir, build_dir, cuda_home, cudnn_home, rocm_home, mpi_home, nccl_home, tensorrt_home, migraphx_home, acl_home, acl_libs, armnn_home, armnn_libs, path_to_protoc_exe, configs, cmake_extra_defines, args, cmake_extra_args) if args.clean: clean_targets(cmake_path, build_dir, configs) # if using DML, perform initial nuget package restore setup_dml_build(args, cmake_path, build_dir, configs) if args.build: if args.parallel < 0: raise BuildError("Invalid parallel job count: {}".format(args.parallel)) num_parallel_jobs = os.cpu_count() if args.parallel == 0 else args.parallel build_targets(args, cmake_path, build_dir, configs, num_parallel_jobs, args.target) if args.test: run_onnxruntime_tests(args, source_dir, ctest_path, build_dir, configs) # run nuphar python tests last, as it installs ONNX 1.5.0 if args.enable_pybind and not args.skip_onnx_tests and args.use_nuphar: nuphar_run_python_tests(build_dir, configs) # run node.js binding tests if args.build_nodejs and not args.skip_nodejs_tests: nodejs_binding_dir = os.path.normpath(os.path.join(source_dir, "nodejs")) run_nodejs_tests(nodejs_binding_dir) if args.build: if args.build_wheel: nightly_build = bool(os.getenv('NIGHTLY_BUILD') == '1') build_python_wheel( source_dir, build_dir, configs, args.use_cuda, args.use_dnnl, args.use_tensorrt, args.use_openvino, args.use_nuphar, args.use_vitisai, args.use_acl, args.use_armnn, args.use_dml, args.wheel_name_suffix, args.enable_training, nightly_build=nightly_build, featurizers_build=args.use_featurizers, use_ninja=(args.cmake_generator == 'Ninja') ) if args.build_nuget: build_nuget_package( source_dir, build_dir, configs, args.use_cuda, args.use_openvino, args.use_tensorrt, args.use_dnnl ) if args.test and args.build_nuget: run_csharp_tests( source_dir, build_dir, args.use_cuda, args.use_openvino, args.use_tensorrt, args.use_dnnl) if args.gen_doc and (args.build or args.test): generate_documentation(source_dir, build_dir, configs) log.info("Build complete") if __name__ == "__main__": try: sys.exit(main()) except BaseError as e: log.error(str(e)) sys.exit(1)
the-stack_106_32230
import numpy as np import ants from cinemri.registration import Registrator from cinemri.contour import Contour, get_anterior_wall_data, mask_to_contour from cinemri.utils import numpy_2d_to_ants, average_by_vicinity, plot_vs_on_frame from enum import Enum, unique @unique class VSNormType(Enum): none = 0 # normalise by the average motion along the anterior abdominal wall average_anterior_wall = 1 # normalize by average motion in the vicinity of each point contour_vicinity = 2 @unique class VSNormField(Enum): # use the masked deformation field of the abdominal cavity surroundings rest = 0 # use the entire deformation filed between two frames complete = 1 @unique class VSWarpingField(Enum): # use the masked deformation field of the abdominal cavity surroundings rest = 0 # use deformation filed between abdominal cavity contours contours = 1 class VisceralSlideDetector: @staticmethod def calculate_visceral_slide(deformation_field, contour): """ Calculates visceral slide along the specified contour given the specified deformation field Parameters ---------- deformation_field : ndarray The 2-channels deformation field contour : Contour The the contour along which to calculate visceral slide Returns ------- visceral_slide : ndarray Visceral slide along the specified contour given the specified deformation field """ # Get contour and normal neighbours uv = np.column_stack((contour.u, contour.v)) inner_deformation = deformation_field[contour.y, contour.x] inner_slide = (uv * inner_deformation).sum(1) outer_deformation = deformation_field[contour.y_neighbour, contour.x_neighbour] outer_slide = (uv * outer_deformation).sum(1) # When (x, y) == (x_neighbour, y_neighbour) it means that (x, y) is located # at the border of a frame and a real (x_neighbour, y_neighbour) is outside # of the frame. In this case the inner and the outer deformation is the same # and the visceral slide will be underestimated. # Hence to mitigate it, we set the outer slide to 0 for such point # TODO: think if an option better than this workaround is possible, e.g nearest-neighbour like approach inner_coord = np.column_stack((contour.x, contour.y)) outer_coord = np.column_stack((contour.x_neighbour, contour.y_neighbour)) coords_equal_inds = np.where((inner_coord == outer_coord).all(axis=1))[0] outer_slide[coords_equal_inds] = 0 visceral_slide = inner_slide - outer_slide return visceral_slide @staticmethod def get_motion(deformation_field, x, y, u, v): """ Gets motion along the (x, y) contour in direction specified by (u, v) Parameters ---------- deformation_field : ndarray A deformation filed describing the motion x, y : list of int The coordinates specifying the contour along which to calculate the motion u, v : list if int The components of vectors corresponding to each (x, y) in the direction of which to calculate the motion Returns ------- motion : ndarray of float The motion along the the (x, y) contour in the (u, v) direction """ motion = [] for i in range(len(x)): deformation = deformation_field[y[i], x[i]] current_motion = np.abs(deformation.dot([u[i], v[i]])) motion.append(current_motion) # Replace zeros with highest non 0 zero_placeholder = np.min([value for value in motion if value > 0]) motion = [value if value > 0 else zero_placeholder for value in motion] return np.array(motion) def normalize_vs_by_motion(self, visceral_slide, contour, normalization_type, normalization_df, norm_vicinity): """ Normalises visceral slide by motion according to the specified normalisation type Parameters ---------- visceral_slide : ndarray The visceral slide to normalise contour : Contour The contour for which the visceral slide was calculated normalization_type : VSNormType The type of normalisation to apply normalization_df : ndarray The 2-channels deformation field to use for normalisation norm_vicinity : int The size of vicinity for vicinity normalisation Returns ------- visceral_slide : ndarray A normalised visceral slide """ if normalization_type == VSNormType.average_anterior_wall: x_aw, y_aw, u_aw, v_aw = get_anterior_wall_data(contour.x_neighbour, contour.y_neighbour, contour.u_normal, contour.v_normal) abdominal_wall_motion = self.get_motion(normalization_df, x_aw, y_aw, u_aw, v_aw) visceral_slide = visceral_slide / np.mean(abdominal_wall_motion) elif normalization_type == VSNormType.contour_vicinity: contour_motion = self.get_motion(normalization_df, contour.x_neighbour, contour.y_neighbour, contour.u_normal, contour.v_normal) contour_motion_averaged = average_by_vicinity(contour_motion, norm_vicinity) visceral_slide = visceral_slide / contour_motion_averaged return visceral_slide class VisceralSlideDetectorDF(VisceralSlideDetector): def get_visceral_slide(self, df_cavity, df_rest, df_normalization, moving_mask, normalization_type=VSNormType.none, norm_vicinity=15): """ Calculates visceral slide based on the passed deformation field and abdominal cavity mask and normalises it with specified normalisation option Parameters ---------- df_cavity : ndarray The 2-channels masked deformation field of abdominal cavity content df_rest : ndarray The 2-channels masked deformation field of abdominal cavity surroundings df_normalization : ndarray The 2-channels deformation field to use for normalisation moving_mask : ndarray The abdominal cavity segmentation on a moving frame normalization_type : VSNormType, default = VSNormType.none The type of normalisation to apply norm_vicinity : int, default = 15 The size of vicinity for vicinity normalisation Returns ------- x, y, visceral_slide : ndarray Coordinates of moving_mask contour and absolute values of visceral slide at these coordinates """ df_full = df_cavity + df_rest contour = Contour.from_mask(moving_mask) visceral_slide = self.calculate_visceral_slide(df_full, contour) visceral_slide = np.abs(visceral_slide) # Normalize with the provided option visceral_slide = self.normalize_vs_by_motion(visceral_slide, contour, normalization_type, df_normalization, norm_vicinity) return contour.x, contour.y, visceral_slide class VisceralSlideDetectorReg(VisceralSlideDetector): def __init__(self): self.registrator = Registrator() def get_visceral_slide(self, moving, moving_mask, fixed, fixed_mask=None, normalization_type=VSNormType.none, normalization_field=VSNormField.rest, norm_vicinity=15): """Calculates visceral slide based on the moving and fixed frames and their masks using image registration and normalises it with specified normalisation option Parameters ---------- moving : ndarray Frame of cine MRI series to use as a moving image moving_mask : binary ndarray A binary segmentation of the abdominal cavity on moving frame fixed : ndarray Frame of cine MRI series to use as a fixed image fixed_mask : binary ndarray, optional A binary segmentation of the abdominal cavity on fixed frame normalization_type : VSNormType, default = VSNormType.none A type of visceral slide normalization to apply normalization_field : VSNormField, default=VSNormField.rest Specifies which deformation filed to use for visceral slide normalization norm_vicinity : int, default = 15 A vicinity to use for VSNormType.contour_vicinity normalization type Returns ------- x, y, visceral_slide : ndarray Coordinates of moving_mask contour and absolute values of visceral slide at these coordinates """ moving = moving.astype(np.uint32) fixed = fixed.astype(np.uint32) moving_mask = moving_mask.astype(np.uint8) # We need to calculate the transformation between entire moving and fixed frame # if the moving mask is missing or we want to normalise the VS by the entire deformation filed complete_df_needed = (fixed_mask is None or (normalization_type != VSNormType.none and normalization_field == VSNormField.complete)) if complete_df_needed: # Register moving to fixed without mask transforms, complete_df = self.registrator.register(fixed, moving) if fixed_mask is None: # If the mask of the fixed image is not supplied, compute it through deformation of moving mask # Propagate moving mask to fixed fixed_mask = ants.apply_transforms( fixed=numpy_2d_to_ants(fixed), moving=numpy_2d_to_ants(moving_mask), transformlist=transforms["fwdtransforms"] ).numpy() fixed_mask = fixed_mask.astype(np.uint8) # Compute full deformation field as a sum of abdominal cavity and surroundings deformations deformation_field = self.get_full_deformation_field(fixed, moving, fixed_mask, moving_mask) contour = Contour.from_mask(moving_mask) visceral_slide = self.calculate_visceral_slide(deformation_field, contour) visceral_slide = np.abs(visceral_slide) normalization_df = self.rest_field if normalization_field == VSNormField.rest else complete_df visceral_slide = self.normalize_vs_by_motion(visceral_slide, contour, normalization_type, normalization_df, norm_vicinity) return contour.x, contour.y, visceral_slide def get_full_deformation_field(self, fixed, moving, fixed_cavity_mask, moving_cavity_mask): """ Calculates the full deformation field Parameters ---------- fixed, moving : ndarray A fixed and moving cine-MRI frame fixed_cavity_mask, moving_cavity_mask : ndarray Abdominal cavity segmentation masks on fixed and moving frames Returns ------- """ # Get cavity deformation field self.cavity_field = self.registrator.get_masked_deformation_field(fixed, moving, fixed_cavity_mask, moving_cavity_mask) # Get rest deformation field self.rest_field = self.registrator.get_masked_deformation_field(fixed, moving, 1 - fixed_cavity_mask, 1 - moving_cavity_mask) # Combine deformation fields into one return self.cavity_field + self.rest_field class CumulativeVisceralSlideDetector: @staticmethod def warp_visceral_slide(x, y, visceral_slide, deformation_field): """ Warps visceral slide by deformation field Parameters ---------- x, y : ndarray The coordinates of visceral slide visceral_slide : ndarray The values of visceral slide deformation_field : ndarray A deformation field to perform warping Returns ------- x, y, visceral_slide : list Visceral slide warped by deformation field """ xy_warped = [] for (current_x, current_y) in zip(x, y): u, v = deformation_field[current_y, current_x] xy_warped.append([round(current_x + u), round(current_y + v)]) xy_warped = np.array(xy_warped) visceral_slide_warped = np.column_stack((xy_warped, visceral_slide)) # Warped contour might have duplicated points # Find these points and take an average as VS slide value xy_warped_unique = np.unique(xy_warped, axis=0) visceral_slide_warped_unique = [] for coord in xy_warped_unique: # Find all point with the current coordinate in the warped VS vs_at_coord = np.array([vs for vs in visceral_slide_warped if vs[0] == coord[0] and vs[1] == coord[1]]) avg_vs = np.mean(vs_at_coord[..., 2]) visceral_slide_warped_unique.append(avg_vs) return xy_warped_unique[:, 0], xy_warped_unique[:, 1], visceral_slide_warped_unique @staticmethod def add_visceral_slides(visceral_slide, visceral_slide_warped): """ Adds two visceral slides. Possible coordinates mismatches are handled by choosing a coordinate closest by Euclidean distance Parameters ---------- visceral_slide : tuple of list The coordinates and values of the first visceral slide visceral_slide_warped : tuple of list The coordinates and values of the second visceral slide warped to match the first one Returns ------- visceral_slide : tuple of list The coordinates and values of the first visceral slide computed as addition of the first and the second one """ x_target, y_target, vs_target = visceral_slide x_warped, y_warped, vs_warped = visceral_slide_warped # Since some coordinates might mismatch after deformation, # the closest point of the total VS is used to sum with the current VS value vs_added = [] for (x, y, vs) in zip(x_target, y_target, vs_target): diff = np.sqrt((x - x_warped) ** 2 + (y - y_warped) ** 2) index = np.argmin(diff) vs_added.append(vs + vs_warped[index]) return x_target, y_target, np.array(vs_added) def compute_cumulative_visceral_slide(self, visceral_slides, frames, warping_dfs, plot=False): """ Computes cumulative visceral slide by adding visceral slides between subsequent cine-MRI frames pairs and averaging it Parameters ---------- visceral_slides : list of tuple An ordered list of visceral slides subsequent cine-MRI frames pairs frames : list of ndarray An ordered list of cine-MRI frames that correspond to visceral slides warping_dfs : list of ndarray An ordered list of deformation fields to use for warping the cumulative visceral slide plot : bool, default=False A boolean flag indicating whether to visualise computation by plotting a current visceral slide, a warped cumulative visceral slide and new cumulative visceral slide at each step Returns ------- total_x, total_y, total_vs : ndarray Coordinates and values of cumulative visceral slide """ total_x = total_y = None total_vs = None for i, (x, y, vs) in enumerate(visceral_slides): if plot: frame = frames[i] plot_vs_on_frame(frame, x, y, vs, "VS {}".format(i)) # At the first step, the visceral slide between first two frames is total if total_vs is None: total_x, total_y = x, y total_vs = vs else: # We want to transform the cumulative visceral slide to the frame corresponding to the current # visceral slide. That is the the current moving frame, hence we need the previous transformation # and we need to take the contour of the current moving image as the fixed image. warping_df = warping_dfs[i - 1] total_x_warped, total_y_warped, total_vs_warped = self.warp_visceral_slide(total_x, total_y, total_vs, warping_df) if plot: plot_vs_on_frame(frame, total_x_warped, total_y_warped, total_vs_warped, "Total VS warped {}".format(i - 1)) total_x, total_y, total_vs = self.add_visceral_slides((x, y, vs), (total_x_warped, total_y_warped, total_vs_warped)) if plot: plot_vs_on_frame(frame, total_x, total_y, total_vs, "Total VS {}".format(i - 1)) # Take the average of total visceral slide total_vs /= len(visceral_slides) return total_x, total_y, total_vs class CumulativeVisceralSlideDetectorDF(CumulativeVisceralSlideDetector): def __init__(self): self.vs_detector = VisceralSlideDetectorDF() def get_visceral_slide(self, moving_masks, cavity_dfs, rest_dfs, warping_dfs, normalization_dfs, normalization_type=VSNormType.none, norm_vicinity=15, plot=False): """ Computes cumulative visceral slide based on the specified deformation fields, moving masks and normalization parameters Parameters ---------- moving_masks : list of ndarray An ordered list of abdominal cavity segmentation masks on moving frame for each frames pair of cine-MRI series cavity_dfs : list of ndarray An ordered list of masked abdominal cavity deformation fields rest_dfs : list of ndarray An ordered list of masked abdominal cavity surroundings deformation fields warping_dfs : list of ndarray An ordered list of deformation fields to use for warping of cumulative visceral slide during summation normalization_dfs : list of ndarray An ordered list of deformation fields to use for visceral slide normalization normalization_type : VSNormType, default=VSNormType.none A type of visceral slide normalization to apply norm_vicinity : int, default=15 A vicinity to use for VSNormType.contour_vicinity normalization type plot : bool, default=False A boolean flag indicating whether to visualise computation by plotting a current visceral slide, a warped cumulative visceral slide and new cumulative visceral slide at each step Returns ------- total_x, total_y, total_vs : ndarray Coordinates and values of cumulative visceral slide """ visceral_slides = [] for i in range(len(moving_masks)): moving_mask = moving_masks[i] cavity_df = cavity_dfs[i] rest_df = rest_dfs[i] normalization_df = normalization_dfs[i] x, y, visceral_slide = self.vs_detector.get_visceral_slide(cavity_df, rest_df, normalization_df, moving_mask, normalization_type, norm_vicinity) visceral_slides.append((x, y, visceral_slide)) total_x, total_y, total_vs = self.compute_cumulative_visceral_slide(visceral_slides, moving_masks, warping_dfs, plot) return total_x, total_y, total_vs class CumulativeVisceralSlideDetectorReg(CumulativeVisceralSlideDetector): def __init__(self): self.vs_detector = VisceralSlideDetectorReg() self.registrator = Registrator() def get_visceral_slide(self, series, masks, warping_field=VSWarpingField.contours, normalization_type=VSNormType.none, normalization_field=VSNormField.rest, norm_vicinity=15, plot=False): """ Computes the cumulative visceral slide across the series in a slice Total visceral slide is matched with the current vs by warping it with deformation field and finding the contour point which is the closest to the current one Parameters ---------- series : ndarray A cine-MRI slice to compute the cumulative visceral slide masks : ndarray An abdominal cavity segmentation corresponding to the cine-MRI slice warping_field : VSWarpingField, default=VSWarpingField.contours Specifies which deformation filed to use for visceral slide warping during addition normalization_type : VSNormType, default = VSNormType.none A type of visceral slide normalization to apply normalization_field : VSNormField, default=VSNormField.rest Specifies which deformation filed to use for visceral slide normalization norm_vicinity : int A vicinity to use for VSNormType.contour_vicinity normalization type plot: bool A boolean flag indicating whether to visualise computation by plotting a current visceral slide, a warped cumulative visceral slide and new cumulative visceral slide at each step Returns ------- total_x, total_y, total_vs : ndarray Coordinates and values of cumulative visceral slide """ # First, compute and save visceral slide for each subsequent pair of frames and contours transformation visceral_slides = [] warping_fields = [] for i in range(1, len(series)): print("Processing pair {}".format(i)) # Taking previous frames as moving and the next one as fixed moving = series[i - 1].astype(np.uint32) moving_mask = masks[i - 1].astype(np.uint32) fixed = series[i].astype(np.uint32) fixed_mask = masks[i].astype(np.uint32) # Get visceral slide x, y, visceral_slide = self.vs_detector.get_visceral_slide(moving, moving_mask, fixed, fixed_mask, normalization_type, normalization_field, norm_vicinity) visceral_slides.append((x, y, visceral_slide)) if warping_field == VSWarpingField.contours: _, deformation_field = self.__contour_transforms(fixed_mask, moving_mask, np.iinfo(np.uint16).max) warping_fields.append(deformation_field) else: warping_fields.append(self.vs_detector.rest_field) total_x, total_y, total_vs = self.compute_cumulative_visceral_slide(visceral_slides, series, warping_fields, plot) return total_x, total_y, total_vs def __contour_transforms(self, fixed_mask, moving_mask, contour_value): """ Computes transformation between contours of two masks by converting masks images to contour images and performing image registration Parameters ---------- fixed_mask : ndarray An image of a fixed mask moving_mask : ndarray An image of a moving mask contour_value : int A value to fill in at the contour coordinates Returns ------- transforms, deformation_field Transformations between moving and fixed contours computed by ANTS toolkit """ fixed_contour = mask_to_contour(fixed_mask, contour_value) moving_contour = mask_to_contour(moving_mask, contour_value) return self.registrator.register(fixed_contour, moving_contour)
the-stack_106_32232
from typing import FrozenSet from collections import Iterable from math import log, ceil from mathsat import msat_term, msat_env from mathsat import msat_make_constant, msat_declare_function from mathsat import msat_get_integer_type, msat_get_rational_type, msat_get_bool_type from mathsat import msat_make_and, msat_make_not, msat_make_or, msat_make_iff from mathsat import msat_make_leq, msat_make_equal, msat_make_true from mathsat import msat_make_number, msat_make_plus, msat_make_times from pysmt.environment import Environment as PysmtEnv import pysmt.typing as types from ltl.ltl import TermMap, LTLEncoder from utils import name_next, symb_to_next from hint import Hint, Location delta_name = "delta" def decl_consts(menv: msat_env, name: str, c_type) -> tuple: assert not name.startswith("_"), name s = msat_declare_function(menv, name, c_type) s = msat_make_constant(menv, s) x_s = msat_declare_function(menv, name_next(name), c_type) x_s = msat_make_constant(menv, x_s) return s, x_s def make_enum(menv, v_name: str, enum_size: int): bool_type = msat_get_bool_type(menv) num_bits = ceil(log(enum_size, 2)) b_vars = [] for idx in range(num_bits): c_name = "{}{}".format(v_name, idx) b_vars.append(tuple(decl_consts(menv, c_name, bool_type))) vals = [] x_vals = [] for enum_val in range(enum_size): bit_val = format(enum_val, '0{}b'.format(num_bits)) assert len(bit_val) == num_bits assert all(c in {'0', '1'} for c in bit_val) assign = [b_vars[idx] if c == '1' else (msat_make_not(menv, b_vars[idx][0]), msat_make_not(menv, b_vars[idx][1])) for idx, c in enumerate(reversed(bit_val))] pred = assign[0][0] x_pred = assign[0][1] for it in assign[1:]: pred = msat_make_and(menv, pred, it[0]) x_pred = msat_make_and(menv, x_pred, it[1]) vals.append(pred) x_vals.append(x_pred) assert len(vals) == enum_size assert len(x_vals) == enum_size return b_vars, vals, x_vals def msat_make_minus(menv: msat_env, arg0: msat_term, arg1: msat_term): m_one = msat_make_number(menv, "-1") arg1 = msat_make_times(menv, arg1, m_one) return msat_make_plus(menv, arg0, arg1) def msat_make_lt(menv: msat_env, arg0: msat_term, arg1: msat_term): geq = msat_make_geq(menv, arg0, arg1) return msat_make_not(menv, geq) def msat_make_geq(menv: msat_env, arg0: msat_term, arg1: msat_term): return msat_make_leq(menv, arg1, arg0) def msat_make_gt(menv: msat_env, arg0: msat_term, arg1: msat_term): leq = msat_make_leq(menv, arg0, arg1) return msat_make_not(menv, leq) def msat_make_impl(menv: msat_env, arg0: msat_term, arg1: msat_term): n_arg0 = msat_make_not(menv, arg0) return msat_make_or(menv, n_arg0, arg1) def diverging_symbs(menv: msat_env) -> frozenset: real_type = msat_get_rational_type(menv) delta = msat_declare_function(menv, delta_name, real_type) delta = msat_make_constant(menv, delta) return frozenset([delta]) def check_ltl(menv: msat_env, enc: LTLEncoder) -> (Iterable, msat_term, msat_term, msat_term): assert menv assert isinstance(menv, msat_env) assert enc assert isinstance(enc, LTLEncoder) int_type = msat_get_integer_type(menv) real_type = msat_get_rational_type(menv) r2s, x_r2s = decl_consts(menv, "r2s", int_type) s2r, x_s2r = decl_consts(menv, "s2r", int_type) delta, x_delta = decl_consts(menv, delta_name, real_type) sender = Sender("s", menv, enc, r2s, x_r2s, s2r, x_s2r, delta) receiver = Receiver("r", menv, enc, s2r, x_s2r, r2s, x_r2s, delta) curr2next = {r2s: x_r2s, s2r: x_s2r, delta: x_delta} for comp in [sender, receiver]: for s, x_s in comp.symb2next.items(): curr2next[s] = x_s zero = msat_make_number(menv, "0") init = msat_make_and(menv, receiver.init, sender.init) trans = msat_make_and(menv, receiver.trans, sender.trans) # invar delta >= 0 init = msat_make_and(menv, init, msat_make_geq(menv, delta, zero)) trans = msat_make_and(menv, trans, msat_make_geq(menv, x_delta, zero)) # delta > 0 -> (r2s' = r2s & s2r' = s2r) lhs = msat_make_gt(menv, delta, zero) rhs = msat_make_and(menv, msat_make_equal(menv, x_r2s, r2s), msat_make_equal(menv, x_s2r, s2r)) trans = msat_make_and(menv, trans, msat_make_impl(menv, lhs, rhs)) # (G F !s.stutter) -> G (s.wait_ack -> F s.send) lhs = enc.make_G(enc.make_F(msat_make_not(menv, sender.stutter))) rhs = enc.make_G(msat_make_impl(menv, sender.wait_ack, enc.make_F(sender.send))) ltl = msat_make_impl(menv, lhs, rhs) return TermMap(curr2next), init, trans, ltl class Module: def __init__(self, name: str, menv: msat_env, enc: LTLEncoder, *args, **kwargs): self.name = name self.menv = menv self.enc = enc self.symb2next = {} true = msat_make_true(menv) self.init = true self.trans = true def _symb(self, v_name, v_type): v_name = "{}_{}".format(self.name, v_name) return decl_consts(self.menv, v_name, v_type) def _enum(self, v_name: str, enum_size: int): c_name = "{}_{}".format(self.name, v_name) return make_enum(self.menv, c_name, enum_size) class Sender(Module): def __init__(self, name: str, menv: msat_env, enc: LTLEncoder, in_c, x_in_c, out_c, x_out_c, delta): super().__init__(name, menv, enc) bool_type = msat_get_bool_type(menv) int_type = msat_get_integer_type(menv) real_type = msat_get_rational_type(menv) loc, x_loc = self._symb("l", bool_type) evt, x_evt = self._symb("evt", bool_type) msg_id, x_msg_id = self._symb("msg_id", int_type) timeout, x_timeout = self._symb("timeout", real_type) c, x_c = self._symb("c", real_type) self.move = evt self.stutter = msat_make_not(menv, evt) self.x_move = x_evt self.x_stutter = msat_make_not(menv, x_evt) self.send = loc self.wait_ack = msat_make_not(menv, loc) self.x_send = x_loc self.x_wait_ack = msat_make_not(menv, x_loc) self.symb2next = {loc: x_loc, evt: x_evt, msg_id: x_msg_id, timeout: x_timeout, c: x_c} zero = msat_make_number(menv, "0") one = msat_make_number(menv, "1") base_timeout = one # send & c = 0 & msg_id = 0 self.init = msat_make_and(menv, msat_make_and(menv, self.send, msat_make_equal(menv, c, zero)), msat_make_equal(menv, msg_id, zero)) # invar: wait_ack -> c <= timeout self.init = msat_make_and( menv, self.init, msat_make_impl(menv, self.wait_ack, msat_make_leq(menv, c, timeout))) self.trans = msat_make_impl(menv, self.x_wait_ack, msat_make_leq(menv, x_c, x_timeout)) # delta > 0 | stutter -> l' = l & msg_id' = msg_id & timeout' = timeout & # c' = c + delta & out_c' = out_c lhs = msat_make_or(menv, msat_make_gt(menv, delta, zero), self.stutter) rhs = msat_make_and( menv, msat_make_and(menv, msat_make_iff(menv, x_loc, loc), msat_make_equal(menv, x_msg_id, msg_id)), msat_make_and(menv, msat_make_equal(menv, x_timeout, timeout), msat_make_equal(menv, x_c, msat_make_plus(menv, c, delta)))) rhs = msat_make_and(menv, rhs, msat_make_equal(menv, x_out_c, out_c)) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) disc_t = msat_make_and(menv, self.move, msat_make_equal(menv, delta, zero)) # (send & send') -> # (msg_id' = msg_id & timeout' = base_timeout & c' = 0 & out_c' = out_c) lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.send, self.x_send)) rhs = msat_make_and( menv, msat_make_and(menv, msat_make_equal(menv, x_msg_id, msg_id), msat_make_equal(menv, x_timeout, base_timeout)), msat_make_and(menv, msat_make_equal(menv, x_c, zero), msat_make_equal(menv, x_out_c, out_c))) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (send & wait_ack') -> # (msg_id' = msg_id + 1 & timeout' = base_timeout & c' = 0 & out_c' = out_c) lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.send, self.x_wait_ack)) rhs = msat_make_and( menv, msat_make_and(menv, msat_make_equal(menv, x_msg_id, msat_make_plus(menv, msg_id, one)), msat_make_equal(menv, x_timeout, base_timeout)), msat_make_and(menv, msat_make_equal(menv, x_c, zero), msat_make_equal(menv, x_out_c, out_c))) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait_ack) -> (c' = 0 & out_c' = out_c & # (wait_ack' <-> (in_c != msg_id & c > timeout)) lhs = msat_make_and(menv, disc_t, self.wait_ack) rhs_iff = msat_make_and(menv, msat_make_not(menv, msat_make_equal(menv, in_c, msg_id)), msat_make_geq(menv, c, timeout)) rhs_iff = msat_make_iff(menv, self.x_wait_ack, rhs_iff) rhs = msat_make_and(menv, msat_make_and(menv, msat_make_equal(menv, x_c, zero), msat_make_equal(menv, x_out_c, out_c)), rhs_iff) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait_ack & wait_ack') -> (timeout' > timeout) lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.wait_ack, self.x_wait_ack)) rhs = msat_make_gt(menv, x_timeout, timeout) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait_ack) -> (send' <-> (in_c = msg_id & c < timeout)) lhs = msat_make_and(menv, disc_t, self.wait_ack) rhs = msat_make_iff(menv, self.x_send, msat_make_and(menv, msat_make_equal(menv, in_c, msg_id), msat_make_lt(menv, c, timeout))) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait_ack & send') -> (timeout' = base_timeout) lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.wait_ack, self.x_send)) rhs = msat_make_equal(menv, x_timeout, base_timeout) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) class Receiver(Module): def __init__(self, name: str, menv: msat_env, enc: LTLEncoder, in_c, x_in_c, out_c, x_out_c, delta): super().__init__(name, menv, enc) bool_type = msat_get_bool_type(menv) loc, x_loc = self._symb("l", bool_type) self.wait = loc self.work = msat_make_not(menv, loc) self.x_wait = x_loc self.x_work = msat_make_not(menv, x_loc) self.symb2next = {loc: x_loc} zero = msat_make_number(menv, "0") # wait self.init = self.wait # delta > 0 -> loc' = loc & out_c' = out_c lhs = msat_make_gt(menv, delta, zero) rhs = msat_make_and(menv, msat_make_iff(menv, x_loc, loc), msat_make_equal(menv, x_out_c, out_c)) self.trans = msat_make_impl(menv, lhs, rhs) disc_t = msat_make_equal(menv, delta, zero) # wait -> (wait' <-> in_c = out_c) lhs = msat_make_and(menv, disc_t, self.wait) rhs = msat_make_iff(menv, self.x_wait, msat_make_equal(menv, in_c, out_c)) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait & wait') -> (out_c' = out_c) lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.wait, self.x_wait)) rhs = msat_make_equal(menv, x_out_c, out_c) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # (wait & work') -> out_c' = in_c lhs = msat_make_and(menv, disc_t, msat_make_and(menv, self.wait, self.x_work)) rhs = msat_make_equal(menv, x_out_c, in_c) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) # work -> out_c' = out_c lhs = msat_make_and(menv, disc_t, self.work) rhs = msat_make_equal(menv, x_out_c, out_c) self.trans = msat_make_and(menv, self.trans, msat_make_impl(menv, lhs, rhs)) def hints(env: PysmtEnv) -> FrozenSet[Hint]: assert isinstance(env, PysmtEnv) mgr = env.formula_manager delta = mgr.Symbol(delta_name, types.REAL) r2s = mgr.Symbol("r2s", types.INT) s2r = mgr.Symbol("r2s", types.INT) s_l = mgr.Symbol("s_l", types.BOOL) s_evt = mgr.Symbol("s_evt", types.BOOL) s_msg_id = mgr.Symbol("s_msg_id", types.INT) s_timeout = mgr.Symbol("s_timeout", types.REAL) s_c = mgr.Symbol("s_c", types.REAL) r_l = mgr.Symbol("r_l", types.BOOL) symbs = frozenset([delta, r2s, s2r, s_l, s_evt, s_msg_id, s_timeout, s_c, r_l]) x_delta = symb_to_next(mgr, delta) x_r2s = symb_to_next(mgr, r2s) x_s2r = symb_to_next(mgr, s2r) x_s_l = symb_to_next(mgr, s_l) x_s_evt = symb_to_next(mgr, s_evt) x_s_msg_id = symb_to_next(mgr, s_msg_id) x_s_timeout = symb_to_next(mgr, s_timeout) x_s_c = symb_to_next(mgr, s_c) x_r_l = symb_to_next(mgr, r_l) res = [] r0 = mgr.Real(0) r1 = mgr.Real(1) i0 = mgr.Int(0) i1 = mgr.Int(1) loc0 = Location(env, mgr.Equals(r2s, i0)) loc0.set_progress(0, mgr.Equals(x_r2s, i0)) hint = Hint("h_r2s0", env, frozenset([r2s]), symbs) hint.set_locs([loc0]) res.append(hint) loc0 = Location(env, mgr.Equals(s_msg_id, i0)) loc0.set_progress(0, mgr.Equals(x_s_msg_id, i0)) hint = Hint("h_s_msg_id0", env, frozenset([s_msg_id]), symbs) hint.set_locs([loc0]) res.append(hint) loc0 = Location(env, s_evt) loc0.set_progress(1, mgr.Not(x_s_evt)) loc1 = Location(env, mgr.Not(s_evt)) loc1.set_progress(0, x_s_evt) hint = Hint("h_s_evt1", env, frozenset([s_evt]), symbs) hint.set_locs([loc0, loc1]) res.append(hint) loc0 = Location(env, r_l) loc0.set_progress(1, mgr.Not(x_r_l)) loc1 = Location(env, mgr.Not(r_l)) loc1.set_progress(0, x_r_l) hint = Hint("h_r_l1", env, frozenset([r_l]), symbs) hint.set_locs([loc0, loc1]) res.append(hint) return frozenset(res)
the-stack_106_32239
from pathlib import Path import subprocess as sp def get_model_path(model_name, model_type=None): """ creates the path based on the model_name model_name: string value indicationg the <org>/<model>/<version> model_type: model type for braingen and kwyk model Returns ------- model_path """ # TO DO: model database can be a json file and be updated separately models = {"neuronets/ams/0.1.0": "meningioma_T1wc_128iso_v1.h5", "neuronets/braingen/0.1.0": ["generator_res_8", "generator_res_16", "generator_res_32", "generator_res_64", "generator_res_128", "generator_res_256"], "neuronets/brainy/0.1.0": "brain-extraction-unet-128iso-model.h5", "neuronets/kwyk/0.4.1": ["all_50_wn", "all_50_bwn_09_multi", "all_50_bvwn_multi_prior"], "UCL/SynthSeg/0.1": "SynthSeg.h5" } # model type should be given for braingen and kwyk if model_name in ["braingen","kwyk"] and model_type not in models[model_name]: raise Exception("Model type should be one of {} but it is {}".format( models[model_name], model_type)) root_path = Path(__file__).resolve().parent / "trained-models" if model_name in ["neuronets/braingen/0.1.0", "neuronets/kwyk/0.4.1"]: raise Exception("This model has not added yet.") #model_file = os.path.join(models[model_name],model_type) else: model_file = models[model_name] # create the model path model_path = root_path / model_name / model_file return model_path def load_model(path): """ Returns the model object from file path""" if "kwyk" in path: from nobrainer.pediction import _get_pridictor model = _get_pridictor(path) else: from nobrainer.prediction import _get_model model = _get_model(path) return model def get_repo(org, repo_url, repo_state): """ downoads the related repo in the org/org_repo. org: str, organization name """ repo_path = Path(__file__).resolve().parents[0] / org / "org_repo" if not repo_path.exists(): p0 = sp.run(["git", "clone", repo_url, str(repo_path)], stdout=sp.PIPE, stderr=sp.STDOUT ,text=True) print(p0.stdout) p1 = sp.run(["git", "checkout", repo_state], stdout=sp.PIPE, stderr=sp.STDOUT ,text=True) print(p1.stdout) print(f"{org} repository is downloaded") else: print(f"{org} repository is available locally")
the-stack_106_32242
#!/usr/bin/env python # encoding: utf-8 ''' @author: Jason Lee @license: (C) Copyright @ Jason Lee @contact: [email protected] @file: quick_sort.py @time: 2019/3/28 10:13 @desc: ''' def quick_sort(data): if len(data) == 1: return quick_sort_core(data, 0, len(data) - 1) def quick_sort_core(data, start, end): if len(data) == 1: return id = partition(data, start, end) if id > start: quick_sort_core(data, start, id - 1) if id < end: quick_sort_core(data, id + 1, end) def partition(data, left, right): # compared with data[0], i starts from left, j starts from right i = left j = right while True: while data[i] <= data[left] and i < right: i += 1 while data[j] > data[left] and j > left: j -= 1 # stop when i meets j if i >= j: break data[i], data[j] = data[j], data[i] data[left], data[j] = data[j], data[left] return j if __name__ == '__main__': data = [3,4,1,2,4,5,6] quick_sort(data) print(data)
the-stack_106_32243
# ipa.py - ipa transliteration module # coding: utf-8 # The MIT License (MIT) # Credit for IPA rules - Wikipedia, LionSlayer ... # Copyright (c) 2018 Thura Hlaing # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE # OR OTHER DEALINGS IN THE SOFTWARE. import json import pkgutil class IPA(): table = json.loads( pkgutil.get_data('myanmar', 'data/ipa.json').decode('utf-8') ) vowels = 'aáeèioóôu' @classmethod def normalize(cls, ipa, prev): if prev: ipa = cls.add_ə(ipa, prev) ipa = cls.change_k_to_g(ipa, prev) ipa = cls.change_s_to_z(ipa, prev) ipa = cls.change_p_to_b(ipa, prev) ipa = cls.change_t_to_d(ipa, prev) return ipa @classmethod def add_ə(cls, ipa, prev): prev_len = 0 if prev[-1] == 'ʰ' and len(prev[-2]) == 1: prev_len = 1 if len(prev) == 1 or prev_len == 1: ipa = 'ə' + ipa return ipa @classmethod def change_k_to_g(cls, ipa, prev): # change k to g after vowel sound if ipa.startswith('k') and cls.ends_with_vowel(prev): ipa = 'g' + ipa[1:] return ipa @classmethod def change_s_to_z(cls, ipa, prev): # change s to z after vowel sound if ipa.startswith('s') and cls.ends_with_vowel(prev): ipa = 'z' + ipa[1:] return ipa @classmethod def change_p_to_b(cls, ipa, prev): # change pa to ba after vowel sound if ipa.startswith('p') and cls.has_vowel(ipa): ipa = 'b' + ipa[1:] return ipa @classmethod def change_t_to_d(cls, ipa, prev): # change t to d after vowel sound startswitht = ipa.startswith('t') and not ipa.startswith('th') if startswitht and cls.ends_with_vowel(prev): ipa = 'd' + ipa[1:] return ipa @classmethod def ends_with_vowel(cls, ipa): return ipa[-1] in 'aàeioun' or ipa.endswith('ng') @classmethod def has_vowel(cls, ipa): # if any of cls.vowels exists in IPA return any(ipa.find(v) != -1 for v in cls.vowels)
the-stack_106_32244
# # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. """Unit tests for stringified DAGs.""" import importlib import importlib.util import multiprocessing import os import unittest from datetime import datetime, timedelta, timezone from glob import glob from unittest import mock import pendulum import pytest from dateutil.relativedelta import FR, relativedelta from kubernetes.client import models as k8s from parameterized import parameterized from airflow.hooks.base import BaseHook from airflow.kubernetes.pod_generator import PodGenerator from airflow.models import DAG, Connection, DagBag, TaskInstance from airflow.models.baseoperator import BaseOperator, BaseOperatorLink from airflow.operators.bash import BashOperator from airflow.security import permissions from airflow.serialization.json_schema import load_dag_schema_dict from airflow.serialization.serialized_objects import SerializedBaseOperator, SerializedDAG from airflow.timetables.simple import NullTimetable, OnceTimetable from tests.test_utils.mock_operators import CustomOperator, CustomOpLink, GoogleLink from tests.test_utils.timetables import cron_timetable, delta_timetable executor_config_pod = k8s.V1Pod( metadata=k8s.V1ObjectMeta(name="my-name"), spec=k8s.V1PodSpec( containers=[ k8s.V1Container(name="base", volume_mounts=[k8s.V1VolumeMount(name="my-vol", mount_path="/vol/")]) ] ), ) serialized_simple_dag_ground_truth = { "__version": 1, "dag": { "default_args": { "__type": "dict", "__var": { "depends_on_past": False, "retries": 1, "retry_delay": {"__type": "timedelta", "__var": 300.0}, "max_retry_delay": {"__type": "timedelta", "__var": 600.0}, "sla": {"__type": "timedelta", "__var": 100.0}, }, }, "start_date": 1564617600.0, '_task_group': { '_group_id': None, 'prefix_group_id': True, 'children': {'bash_task': ('operator', 'bash_task'), 'custom_task': ('operator', 'custom_task')}, 'tooltip': '', 'ui_color': 'CornflowerBlue', 'ui_fgcolor': '#000', 'upstream_group_ids': [], 'downstream_group_ids': [], 'upstream_task_ids': [], 'downstream_task_ids': [], }, "is_paused_upon_creation": False, "_dag_id": "simple_dag", "doc_md": "### DAG Tutorial Documentation", "fileloc": None, "tasks": [ { "task_id": "bash_task", "owner": "airflow", "retries": 1, "retry_delay": 300.0, "max_retry_delay": 600.0, "sla": 100.0, "_downstream_task_ids": [], "_inlets": [], "_is_dummy": False, "_outlets": [], "ui_color": "#f0ede4", "ui_fgcolor": "#000", "template_fields": ['bash_command', 'env'], "template_fields_renderers": {'bash_command': 'bash', 'env': 'json'}, "bash_command": "echo {{ task.task_id }}", 'label': 'bash_task', "_task_type": "BashOperator", "_task_module": "airflow.operators.bash", "pool": "default_pool", "executor_config": { '__type': 'dict', '__var': { "pod_override": { '__type': 'k8s.V1Pod', '__var': PodGenerator.serialize_pod(executor_config_pod), } }, }, "doc_md": "### Task Tutorial Documentation", }, { "task_id": "custom_task", "retries": 1, "retry_delay": 300.0, "max_retry_delay": 600.0, "sla": 100.0, "_downstream_task_ids": [], "_inlets": [], "_is_dummy": False, "_outlets": [], "_operator_extra_links": [{"tests.test_utils.mock_operators.CustomOpLink": {}}], "ui_color": "#fff", "ui_fgcolor": "#000", "template_fields": ['bash_command'], "template_fields_renderers": {}, "_task_type": "CustomOperator", "_task_module": "tests.test_utils.mock_operators", "pool": "default_pool", 'label': 'custom_task', }, ], "timezone": "UTC", "_access_control": { "__type": "dict", "__var": { "test_role": { "__type": "set", "__var": [permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT], } }, }, "edge_info": {}, "dag_dependencies": [], }, } ROOT_FOLDER = os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir, os.pardir) ) def make_example_dags(module_path): """Loads DAGs from a module for test.""" dagbag = DagBag(module_path) return dagbag.dags def make_simple_dag(): """Make very simple DAG to verify serialization result.""" with DAG( dag_id='simple_dag', default_args={ "retries": 1, "retry_delay": timedelta(minutes=5), "max_retry_delay": timedelta(minutes=10), "depends_on_past": False, "sla": timedelta(seconds=100), }, start_date=datetime(2019, 8, 1), is_paused_upon_creation=False, access_control={"test_role": {permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT}}, doc_md="### DAG Tutorial Documentation", ) as dag: CustomOperator(task_id='custom_task') BashOperator( task_id='bash_task', bash_command='echo {{ task.task_id }}', owner='airflow', executor_config={"pod_override": executor_config_pod}, doc_md="### Task Tutorial Documentation", ) return {'simple_dag': dag} def make_user_defined_macro_filter_dag(): """Make DAGs with user defined macros and filters using locally defined methods. For Webserver, we do not include ``user_defined_macros`` & ``user_defined_filters``. The examples here test: (1) functions can be successfully displayed on UI; (2) templates with function macros have been rendered before serialization. """ def compute_next_execution_date(dag, execution_date): return dag.following_schedule(execution_date) default_args = {'start_date': datetime(2019, 7, 10)} dag = DAG( 'user_defined_macro_filter_dag', default_args=default_args, user_defined_macros={ 'next_execution_date': compute_next_execution_date, }, user_defined_filters={'hello': lambda name: f'Hello {name}'}, catchup=False, ) BashOperator( task_id='echo', bash_command='echo "{{ next_execution_date(dag, execution_date) }}"', dag=dag, ) return {dag.dag_id: dag} def collect_dags(dag_folder=None): """Collects DAGs to test.""" dags = {} dags.update(make_simple_dag()) dags.update(make_user_defined_macro_filter_dag()) if dag_folder: if isinstance(dag_folder, (list, tuple)): patterns = dag_folder else: patterns = [dag_folder] else: patterns = [ "airflow/example_dags", "airflow/providers/*/example_dags", "airflow/providers/*/*/example_dags", ] for pattern in patterns: for directory in glob(f"{ROOT_FOLDER}/{pattern}"): dags.update(make_example_dags(directory)) # Filter subdags as they are stored in same row in Serialized Dag table dags = {dag_id: dag for dag_id, dag in dags.items() if not dag.is_subdag} return dags def serialize_subprocess(queue, dag_folder): """Validate pickle in a subprocess.""" dags = collect_dags(dag_folder) for dag in dags.values(): queue.put(SerializedDAG.to_json(dag)) queue.put(None) class TestStringifiedDAGs(unittest.TestCase): """Unit tests for stringified DAGs.""" def setUp(self): super().setUp() BaseHook.get_connection = mock.Mock( return_value=Connection( extra=( '{' '"project_id": "mock", ' '"location": "mock", ' '"instance": "mock", ' '"database_type": "postgres", ' '"use_proxy": "False", ' '"use_ssl": "False"' '}' ) ) ) self.maxDiff = None def test_serialization(self): """Serialization and deserialization should work for every DAG and Operator.""" dags = collect_dags() serialized_dags = {} for _, v in dags.items(): dag = SerializedDAG.to_dict(v) SerializedDAG.validate_schema(dag) serialized_dags[v.dag_id] = dag # Compares with the ground truth of JSON string. self.validate_serialized_dag(serialized_dags['simple_dag'], serialized_simple_dag_ground_truth) def validate_serialized_dag(self, json_dag, ground_truth_dag): """Verify serialized DAGs match the ground truth.""" assert json_dag['dag']['fileloc'].split('/')[-1] == 'test_dag_serialization.py' json_dag['dag']['fileloc'] = None def sorted_serialized_dag(dag_dict: dict): """ Sorts the "tasks" list and "access_control" permissions in the serialised dag python dictionary. This is needed as the order of items should not matter but assertEqual would fail if the order of items changes in the dag dictionary """ dag_dict["dag"]["tasks"] = sorted(dag_dict["dag"]["tasks"], key=lambda x: sorted(x.keys())) dag_dict["dag"]["_access_control"]["__var"]["test_role"]["__var"] = sorted( dag_dict["dag"]["_access_control"]["__var"]["test_role"]["__var"] ) return dag_dict assert sorted_serialized_dag(ground_truth_dag) == sorted_serialized_dag(json_dag) def test_deserialization_across_process(self): """A serialized DAG can be deserialized in another process.""" # Since we need to parse the dags twice here (once in the subprocess, # and once here to get a DAG to compare to) we don't want to load all # dags. queue = multiprocessing.Queue() proc = multiprocessing.Process(target=serialize_subprocess, args=(queue, "airflow/example_dags")) proc.daemon = True proc.start() stringified_dags = {} while True: v = queue.get() if v is None: break dag = SerializedDAG.from_json(v) assert isinstance(dag, DAG) stringified_dags[dag.dag_id] = dag dags = collect_dags("airflow/example_dags") assert set(stringified_dags.keys()) == set(dags.keys()) # Verify deserialized DAGs. for dag_id in stringified_dags: self.validate_deserialized_dag(stringified_dags[dag_id], dags[dag_id]) def test_roundtrip_provider_example_dags(self): dags = collect_dags( [ "airflow/providers/*/example_dags", "airflow/providers/*/*/example_dags", ] ) # Verify deserialized DAGs. for dag in dags.values(): serialized_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag)) self.validate_deserialized_dag(serialized_dag, dag) def validate_deserialized_dag(self, serialized_dag, dag): """ Verify that all example DAGs work with DAG Serialization by checking fields between Serialized Dags & non-Serialized Dags """ fields_to_check = dag.get_serialized_fields() - { # Doesn't implement __eq__ properly. Check manually 'timezone', # Need to check fields in it, to exclude functions 'default_args', "_task_group", } for field in fields_to_check: assert getattr(serialized_dag, field) == getattr( dag, field ), f'{dag.dag_id}.{field} does not match' if dag.default_args: for k, v in dag.default_args.items(): if callable(v): # Check we stored _something_. assert k in serialized_dag.default_args else: assert ( v == serialized_dag.default_args[k] ), f'{dag.dag_id}.default_args[{k}] does not match' assert serialized_dag.timezone.name == dag.timezone.name for task_id in dag.task_ids: self.validate_deserialized_task(serialized_dag.get_task(task_id), dag.get_task(task_id)) # Verify that the DAG object has 'full_filepath' attribute # and is equal to fileloc assert serialized_dag.full_filepath == dag.fileloc def validate_deserialized_task( self, serialized_task, task, ): """Verify non-airflow operators are casted to BaseOperator.""" assert isinstance(serialized_task, SerializedBaseOperator) assert not isinstance(task, SerializedBaseOperator) assert isinstance(task, BaseOperator) fields_to_check = task.get_serialized_fields() - { # Checked separately '_task_type', 'subdag', # Type is excluded, so don't check it '_log', # List vs tuple. Check separately 'template_fields', # We store the string, real dag has the actual code 'on_failure_callback', 'on_success_callback', 'on_retry_callback', # Checked separately 'resources', } assert serialized_task.task_type == task.task_type assert set(serialized_task.template_fields) == set(task.template_fields) assert serialized_task.upstream_task_ids == task.upstream_task_ids assert serialized_task.downstream_task_ids == task.downstream_task_ids for field in fields_to_check: assert getattr(serialized_task, field) == getattr( task, field ), f'{task.dag.dag_id}.{task.task_id}.{field} does not match' if serialized_task.resources is None: assert task.resources is None or task.resources == [] else: assert serialized_task.resources == task.resources # Check that for Deserialised task, task.subdag is None for all other Operators # except for the SubDagOperator where task.subdag is an instance of DAG object if task.task_type == "SubDagOperator": assert serialized_task.subdag is not None assert isinstance(serialized_task.subdag, DAG) else: assert serialized_task.subdag is None @parameterized.expand( [ (datetime(2019, 8, 1, tzinfo=timezone.utc), None, datetime(2019, 8, 1, tzinfo=timezone.utc)), ( datetime(2019, 8, 1, tzinfo=timezone.utc), datetime(2019, 8, 2, tzinfo=timezone.utc), datetime(2019, 8, 2, tzinfo=timezone.utc), ), ( datetime(2019, 8, 1, tzinfo=timezone.utc), datetime(2019, 7, 30, tzinfo=timezone.utc), datetime(2019, 8, 1, tzinfo=timezone.utc), ), (pendulum.datetime(2019, 8, 1, tz='UTC'), None, pendulum.datetime(2019, 8, 1, tz='UTC')), ] ) def test_deserialization_start_date(self, dag_start_date, task_start_date, expected_task_start_date): dag = DAG(dag_id='simple_dag', start_date=dag_start_date) BaseOperator(task_id='simple_task', dag=dag, start_date=task_start_date) serialized_dag = SerializedDAG.to_dict(dag) if not task_start_date or dag_start_date >= task_start_date: # If dag.start_date > task.start_date -> task.start_date=dag.start_date # because of the logic in dag.add_task() assert "start_date" not in serialized_dag["dag"]["tasks"][0] else: assert "start_date" in serialized_dag["dag"]["tasks"][0] dag = SerializedDAG.from_dict(serialized_dag) simple_task = dag.task_dict["simple_task"] assert simple_task.start_date == expected_task_start_date def test_deserialization_with_dag_context(self): with DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1, tzinfo=timezone.utc)) as dag: BaseOperator(task_id='simple_task') # should not raise RuntimeError: dictionary changed size during iteration SerializedDAG.to_dict(dag) @parameterized.expand( [ (datetime(2019, 8, 1, tzinfo=timezone.utc), None, datetime(2019, 8, 1, tzinfo=timezone.utc)), ( datetime(2019, 8, 1, tzinfo=timezone.utc), datetime(2019, 8, 2, tzinfo=timezone.utc), datetime(2019, 8, 1, tzinfo=timezone.utc), ), ( datetime(2019, 8, 1, tzinfo=timezone.utc), datetime(2019, 7, 30, tzinfo=timezone.utc), datetime(2019, 7, 30, tzinfo=timezone.utc), ), ] ) def test_deserialization_end_date(self, dag_end_date, task_end_date, expected_task_end_date): dag = DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1), end_date=dag_end_date) BaseOperator(task_id='simple_task', dag=dag, end_date=task_end_date) serialized_dag = SerializedDAG.to_dict(dag) if not task_end_date or dag_end_date <= task_end_date: # If dag.end_date < task.end_date -> task.end_date=dag.end_date # because of the logic in dag.add_task() assert "end_date" not in serialized_dag["dag"]["tasks"][0] else: assert "end_date" in serialized_dag["dag"]["tasks"][0] dag = SerializedDAG.from_dict(serialized_dag) simple_task = dag.task_dict["simple_task"] assert simple_task.end_date == expected_task_end_date @parameterized.expand( [ (None, None, NullTimetable()), ("@weekly", "@weekly", cron_timetable("0 0 * * 0")), ("@once", "@once", OnceTimetable()), ( {"__type": "timedelta", "__var": 86400.0}, timedelta(days=1), delta_timetable(timedelta(days=1)), ), ] ) def test_deserialization_schedule_interval( self, serialized_schedule_interval, expected_schedule_interval, expected_timetable, ): serialized = { "__version": 1, "dag": { "default_args": {"__type": "dict", "__var": {}}, "_dag_id": "simple_dag", "fileloc": __file__, "tasks": [], "timezone": "UTC", "schedule_interval": serialized_schedule_interval, }, } SerializedDAG.validate_schema(serialized) dag = SerializedDAG.from_dict(serialized) assert dag.schedule_interval == expected_schedule_interval assert dag.timetable == expected_timetable @parameterized.expand( [ (relativedelta(days=-1), {"__type": "relativedelta", "__var": {"days": -1}}), (relativedelta(month=1, days=-1), {"__type": "relativedelta", "__var": {"month": 1, "days": -1}}), # Every friday (relativedelta(weekday=FR), {"__type": "relativedelta", "__var": {"weekday": [4]}}), # Every second friday (relativedelta(weekday=FR(2)), {"__type": "relativedelta", "__var": {"weekday": [4, 2]}}), ] ) def test_roundtrip_relativedelta(self, val, expected): serialized = SerializedDAG._serialize(val) assert serialized == expected round_tripped = SerializedDAG._deserialize(serialized) assert val == round_tripped @parameterized.expand( [ (None, {}), ({"param_1": "value_1"}, {"param_1": "value_1"}), ] ) def test_dag_params_roundtrip(self, val, expected_val): """ Test that params work both on Serialized DAGs & Tasks """ dag = DAG(dag_id='simple_dag', params=val) BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1)) serialized_dag = SerializedDAG.to_dict(dag) if val: assert "params" in serialized_dag["dag"] else: assert "params" not in serialized_dag["dag"] deserialized_dag = SerializedDAG.from_dict(serialized_dag) deserialized_simple_task = deserialized_dag.task_dict["simple_task"] assert expected_val == deserialized_dag.params assert expected_val == deserialized_simple_task.params @parameterized.expand( [ (None, {}), ({"param_1": "value_1"}, {"param_1": "value_1"}), ] ) def test_task_params_roundtrip(self, val, expected_val): """ Test that params work both on Serialized DAGs & Tasks """ dag = DAG(dag_id='simple_dag') BaseOperator(task_id='simple_task', dag=dag, params=val, start_date=datetime(2019, 8, 1)) serialized_dag = SerializedDAG.to_dict(dag) if val: assert "params" in serialized_dag["dag"]["tasks"][0] else: assert "params" not in serialized_dag["dag"]["tasks"][0] deserialized_dag = SerializedDAG.from_dict(serialized_dag) deserialized_simple_task = deserialized_dag.task_dict["simple_task"] assert expected_val == deserialized_simple_task.params def test_extra_serialized_field_and_operator_links(self): """ Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links. This tests also depends on GoogleLink() registered as a plugin in tests/plugins/test_plugin.py The function tests that if extra operator links are registered in plugin in ``operator_extra_links`` and the same is also defined in the Operator in ``BaseOperator.operator_extra_links``, it has the correct extra link. """ test_date = datetime(2019, 8, 1) dag = DAG(dag_id='simple_dag', start_date=test_date) CustomOperator(task_id='simple_task', dag=dag, bash_command="true") serialized_dag = SerializedDAG.to_dict(dag) assert "bash_command" in serialized_dag["dag"]["tasks"][0] dag = SerializedDAG.from_dict(serialized_dag) simple_task = dag.task_dict["simple_task"] assert getattr(simple_task, "bash_command") == "true" ######################################################### # Verify Operator Links work with Serialized Operator ######################################################### # Check Serialized version of operator link only contains the inbuilt Op Link assert serialized_dag["dag"]["tasks"][0]["_operator_extra_links"] == [ {'tests.test_utils.mock_operators.CustomOpLink': {}} ] # Test all the extra_links are set assert set(simple_task.extra_links) == {'Google Custom', 'airflow', 'github', 'google'} ti = TaskInstance(task=simple_task, execution_date=test_date) ti.xcom_push('search_query', "dummy_value_1") # Test Deserialized inbuilt link custom_inbuilt_link = simple_task.get_extra_links(test_date, CustomOpLink.name) assert 'http://google.com/custom_base_link?search=dummy_value_1' == custom_inbuilt_link # Test Deserialized link registered via Airflow Plugin google_link_from_plugin = simple_task.get_extra_links(test_date, GoogleLink.name) assert "https://www.google.com" == google_link_from_plugin def test_extra_operator_links_logs_error_for_non_registered_extra_links(self): """ Assert OperatorLinks not registered via Plugins and if it is not an inbuilt Operator Link, it can still deserialize the DAG (does not error) but just logs an error """ class TaskStateLink(BaseOperatorLink): """OperatorLink not registered via Plugins nor a built-in OperatorLink""" name = 'My Link' def get_link(self, operator, dttm): return 'https://www.google.com' class MyOperator(BaseOperator): """Just a DummyOperator using above defined Extra Operator Link""" operator_extra_links = [TaskStateLink()] def execute(self, context): pass with DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1)) as dag: MyOperator(task_id='blah') serialized_dag = SerializedDAG.to_dict(dag) with self.assertLogs("airflow.serialization.serialized_objects", level="ERROR") as log_output: SerializedDAG.from_dict(serialized_dag) received_logs = log_output.output[0] expected_err_msg = ( "Operator Link class 'tests.serialization.test_dag_serialization.TaskStateLink' " "not registered" ) assert expected_err_msg in received_logs def test_extra_serialized_field_and_multiple_operator_links(self): """ Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links. This tests also depends on GoogleLink() registered as a plugin in tests/plugins/test_plugin.py The function tests that if extra operator links are registered in plugin in ``operator_extra_links`` and the same is also defined in the Operator in ``BaseOperator.operator_extra_links``, it has the correct extra link. """ test_date = datetime(2019, 8, 1) dag = DAG(dag_id='simple_dag', start_date=test_date) CustomOperator(task_id='simple_task', dag=dag, bash_command=["echo", "true"]) serialized_dag = SerializedDAG.to_dict(dag) assert "bash_command" in serialized_dag["dag"]["tasks"][0] dag = SerializedDAG.from_dict(serialized_dag) simple_task = dag.task_dict["simple_task"] assert getattr(simple_task, "bash_command") == ["echo", "true"] ######################################################### # Verify Operator Links work with Serialized Operator ######################################################### # Check Serialized version of operator link only contains the inbuilt Op Link assert serialized_dag["dag"]["tasks"][0]["_operator_extra_links"] == [ {'tests.test_utils.mock_operators.CustomBaseIndexOpLink': {'index': 0}}, {'tests.test_utils.mock_operators.CustomBaseIndexOpLink': {'index': 1}}, ] # Test all the extra_links are set assert set(simple_task.extra_links) == { 'BigQuery Console #1', 'BigQuery Console #2', 'airflow', 'github', 'google', } ti = TaskInstance(task=simple_task, execution_date=test_date) ti.xcom_push('search_query', ["dummy_value_1", "dummy_value_2"]) # Test Deserialized inbuilt link #1 custom_inbuilt_link = simple_task.get_extra_links(test_date, "BigQuery Console #1") assert 'https://console.cloud.google.com/bigquery?j=dummy_value_1' == custom_inbuilt_link # Test Deserialized inbuilt link #2 custom_inbuilt_link = simple_task.get_extra_links(test_date, "BigQuery Console #2") assert 'https://console.cloud.google.com/bigquery?j=dummy_value_2' == custom_inbuilt_link # Test Deserialized link registered via Airflow Plugin google_link_from_plugin = simple_task.get_extra_links(test_date, GoogleLink.name) assert "https://www.google.com" == google_link_from_plugin class ClassWithCustomAttributes: """ Class for testing purpose: allows to create objects with custom attributes in one single statement. """ def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) def __str__(self): return f"{self.__class__.__name__}({str(self.__dict__)})" def __repr__(self): return self.__str__() def __eq__(self, other): return self.__dict__ == other.__dict__ def __ne__(self, other): return not self.__eq__(other) @parameterized.expand( [ (None, None), ([], []), ({}, {}), ("{{ task.task_id }}", "{{ task.task_id }}"), (["{{ task.task_id }}", "{{ task.task_id }}"]), ({"foo": "{{ task.task_id }}"}, {"foo": "{{ task.task_id }}"}), ({"foo": {"bar": "{{ task.task_id }}"}}, {"foo": {"bar": "{{ task.task_id }}"}}), ( [{"foo1": {"bar": "{{ task.task_id }}"}}, {"foo2": {"bar": "{{ task.task_id }}"}}], [{"foo1": {"bar": "{{ task.task_id }}"}}, {"foo2": {"bar": "{{ task.task_id }}"}}], ), ( {"foo": {"bar": {"{{ task.task_id }}": ["sar"]}}}, {"foo": {"bar": {"{{ task.task_id }}": ["sar"]}}}, ), ( ClassWithCustomAttributes( att1="{{ task.task_id }}", att2="{{ task.task_id }}", template_fields=["att1"] ), "ClassWithCustomAttributes(" "{'att1': '{{ task.task_id }}', 'att2': '{{ task.task_id }}', 'template_fields': ['att1']})", ), ( ClassWithCustomAttributes( nested1=ClassWithCustomAttributes( att1="{{ task.task_id }}", att2="{{ task.task_id }}", template_fields=["att1"] ), nested2=ClassWithCustomAttributes( att3="{{ task.task_id }}", att4="{{ task.task_id }}", template_fields=["att3"] ), template_fields=["nested1"], ), "ClassWithCustomAttributes(" "{'nested1': ClassWithCustomAttributes({'att1': '{{ task.task_id }}', " "'att2': '{{ task.task_id }}', 'template_fields': ['att1']}), " "'nested2': ClassWithCustomAttributes({'att3': '{{ task.task_id }}', 'att4': " "'{{ task.task_id }}', 'template_fields': ['att3']}), 'template_fields': ['nested1']})", ), ] ) def test_templated_fields_exist_in_serialized_dag(self, templated_field, expected_field): """ Test that templated_fields exists for all Operators in Serialized DAG Since we don't want to inflate arbitrary python objects (it poses a RCE/security risk etc.) we want check that non-"basic" objects are turned in to strings after deserializing. """ dag = DAG("test_serialized_template_fields", start_date=datetime(2019, 8, 1)) with dag: BashOperator(task_id="test", bash_command=templated_field) serialized_dag = SerializedDAG.to_dict(dag) deserialized_dag = SerializedDAG.from_dict(serialized_dag) deserialized_test_task = deserialized_dag.task_dict["test"] assert expected_field == getattr(deserialized_test_task, "bash_command") def test_dag_serialized_fields_with_schema(self): """ Additional Properties are disabled on DAGs. This test verifies that all the keys in DAG.get_serialized_fields are listed in Schema definition. """ dag_schema: dict = load_dag_schema_dict()["definitions"]["dag"]["properties"] # The parameters we add manually in Serialization needs to be ignored ignored_keys: set = { "is_subdag", "tasks", "has_on_success_callback", "has_on_failure_callback", "dag_dependencies", } keys_for_backwards_compat: set = { "_concurrency", } dag_params: set = set(dag_schema.keys()) - ignored_keys - keys_for_backwards_compat assert set(DAG.get_serialized_fields()) == dag_params def test_operator_subclass_changing_base_defaults(self): assert ( BaseOperator(task_id='dummy').do_xcom_push is True ), "Precondition check! If this fails the test won't make sense" class MyOperator(BaseOperator): def __init__(self, do_xcom_push=False, **kwargs): super().__init__(**kwargs) self.do_xcom_push = do_xcom_push op = MyOperator(task_id='dummy') assert op.do_xcom_push is False blob = SerializedBaseOperator.serialize_operator(op) serialized_op = SerializedBaseOperator.deserialize_operator(blob) assert serialized_op.do_xcom_push is False def test_no_new_fields_added_to_base_operator(self): """ This test verifies that there are no new fields added to BaseOperator. And reminds that tests should be added for it. """ base_operator = BaseOperator(task_id="10") fields = base_operator.__dict__ assert { '_BaseOperator__instantiated': True, '_dag': None, '_downstream_task_ids': set(), '_inlets': [], '_log': base_operator.log, '_outlets': [], '_upstream_task_ids': set(), 'depends_on_past': False, 'do_xcom_push': True, 'doc': None, 'doc_json': None, 'doc_md': None, 'doc_rst': None, 'doc_yaml': None, 'email': None, 'email_on_failure': True, 'email_on_retry': True, 'end_date': None, 'execution_timeout': None, 'executor_config': {}, 'inlets': [], 'label': '10', 'max_retry_delay': None, 'on_execute_callback': None, 'on_failure_callback': None, 'on_retry_callback': None, 'on_success_callback': None, 'outlets': [], 'owner': 'airflow', 'params': {}, 'pool': 'default_pool', 'pool_slots': 1, 'priority_weight': 1, 'queue': 'default', 'resources': None, 'retries': 0, 'retry_delay': timedelta(0, 300), 'retry_exponential_backoff': False, 'run_as_user': None, 'sla': None, 'start_date': None, 'subdag': None, 'task_concurrency': None, 'task_id': '10', 'trigger_rule': 'all_success', 'wait_for_downstream': False, 'weight_rule': 'downstream', } == fields, """ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ACTION NEEDED! PLEASE READ THIS CAREFULLY AND CORRECT TESTS CAREFULLY Some fields were added to the BaseOperator! Please add them to the list above and make sure that you add support for DAG serialization - you should add the field to `airflow/serialization/schema.json` - they should have correct type defined there. Note that we do not support versioning yet so you should only add optional fields to BaseOperator. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! """ def test_task_group_serialization(self): """ Test TaskGroup serialization/deserialization. """ from airflow.operators.dummy import DummyOperator from airflow.utils.task_group import TaskGroup execution_date = datetime(2020, 1, 1) with DAG("test_task_group_serialization", start_date=execution_date) as dag: task1 = DummyOperator(task_id="task1") with TaskGroup("group234") as group234: _ = DummyOperator(task_id="task2") with TaskGroup("group34") as group34: _ = DummyOperator(task_id="task3") _ = DummyOperator(task_id="task4") task5 = DummyOperator(task_id="task5") task1 >> group234 group34 >> task5 dag_dict = SerializedDAG.to_dict(dag) SerializedDAG.validate_schema(dag_dict) json_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag)) self.validate_deserialized_dag(json_dag, dag) serialized_dag = SerializedDAG.deserialize_dag(SerializedDAG.serialize_dag(dag)) assert serialized_dag.task_group.children assert serialized_dag.task_group.children.keys() == dag.task_group.children.keys() def check_task_group(node): try: children = node.children.values() except AttributeError: # Round-trip serialization and check the result expected_serialized = SerializedBaseOperator.serialize_operator(dag.get_task(node.task_id)) expected_deserialized = SerializedBaseOperator.deserialize_operator(expected_serialized) expected_dict = SerializedBaseOperator.serialize_operator(expected_deserialized) assert node assert SerializedBaseOperator.serialize_operator(node) == expected_dict return for child in children: check_task_group(child) check_task_group(serialized_dag.task_group) def test_edge_info_serialization(self): """ Tests edge_info serialization/deserialization. """ from airflow.operators.dummy import DummyOperator from airflow.utils.edgemodifier import Label with DAG("test_edge_info_serialization", start_date=datetime(2020, 1, 1)) as dag: task1 = DummyOperator(task_id="task1") task2 = DummyOperator(task_id="task2") task1 >> Label("test label") >> task2 dag_dict = SerializedDAG.to_dict(dag) SerializedDAG.validate_schema(dag_dict) json_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag)) self.validate_deserialized_dag(json_dag, dag) serialized_dag = SerializedDAG.deserialize_dag(SerializedDAG.serialize_dag(dag)) assert serialized_dag.edge_info == dag.edge_info @parameterized.expand( [ ("poke", False), ("reschedule", True), ] ) def test_serialize_sensor(self, mode, expect_custom_deps): from airflow.sensors.base import BaseSensorOperator class DummySensor(BaseSensorOperator): def poke(self, context): return False op = DummySensor(task_id='dummy', mode=mode, poke_interval=23) blob = SerializedBaseOperator.serialize_operator(op) if expect_custom_deps: assert "deps" in blob else: assert "deps" not in blob serialized_op = SerializedBaseOperator.deserialize_operator(blob) assert op.deps == serialized_op.deps @parameterized.expand( [ ({"on_success_callback": lambda x: print("hi")}, True), ({}, False), ] ) def test_dag_on_success_callback_roundtrip(self, passed_success_callback, expected_value): """ Test that when on_success_callback is passed to the DAG, has_on_success_callback is stored in Serialized JSON blob. And when it is de-serialized dag.has_on_success_callback is set to True. When the callback is not set, has_on_success_callback should not be stored in Serialized blob and so default to False on de-serialization """ dag = DAG(dag_id='test_dag_on_success_callback_roundtrip', **passed_success_callback) BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1)) serialized_dag = SerializedDAG.to_dict(dag) if expected_value: assert "has_on_success_callback" in serialized_dag["dag"] else: assert "has_on_success_callback" not in serialized_dag["dag"] deserialized_dag = SerializedDAG.from_dict(serialized_dag) assert deserialized_dag.has_on_success_callback is expected_value @parameterized.expand( [ ({"on_failure_callback": lambda x: print("hi")}, True), ({}, False), ] ) def test_dag_on_failure_callback_roundtrip(self, passed_failure_callback, expected_value): """ Test that when on_failure_callback is passed to the DAG, has_on_failure_callback is stored in Serialized JSON blob. And when it is de-serialized dag.has_on_failure_callback is set to True. When the callback is not set, has_on_failure_callback should not be stored in Serialized blob and so default to False on de-serialization """ dag = DAG(dag_id='test_dag_on_failure_callback_roundtrip', **passed_failure_callback) BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1)) serialized_dag = SerializedDAG.to_dict(dag) if expected_value: assert "has_on_failure_callback" in serialized_dag["dag"] else: assert "has_on_failure_callback" not in serialized_dag["dag"] deserialized_dag = SerializedDAG.from_dict(serialized_dag) assert deserialized_dag.has_on_failure_callback is expected_value @parameterized.expand( [ ( ['task_1', 'task_5', 'task_2', 'task_4'], ['task_1', 'task_5', 'task_2', 'task_4'], ), ( {'task_1', 'task_5', 'task_2', 'task_4'}, ['task_1', 'task_2', 'task_4', 'task_5'], ), ( ('task_1', 'task_5', 'task_2', 'task_4'), ['task_1', 'task_5', 'task_2', 'task_4'], ), ( { "staging_schema": [ {"key:": "foo", "value": "bar"}, {"key:": "this", "value": "that"}, "test_conf", ] }, { "staging_schema": [ {"__type": "dict", "__var": {"key:": "foo", "value": "bar"}}, { "__type": "dict", "__var": {"key:": "this", "value": "that"}, }, "test_conf", ] }, ), ( {"task3": "test3", "task2": "test2", "task1": "test1"}, {"task1": "test1", "task2": "test2", "task3": "test3"}, ), ( ('task_1', 'task_5', 'task_2', 3, ["x", "y"]), ['task_1', 'task_5', 'task_2', 3, ["x", "y"]], ), ] ) def test_serialized_objects_are_sorted(self, object_to_serialized, expected_output): """Test Serialized Sets are sorted while list and tuple preserve order""" serialized_obj = SerializedDAG._serialize(object_to_serialized) if isinstance(serialized_obj, dict) and "__type" in serialized_obj: serialized_obj = serialized_obj["__var"] assert serialized_obj == expected_output def test_kubernetes_optional(): """Serialisation / deserialisation continues to work without kubernetes installed""" def mock__import__(name, globals_=None, locals_=None, fromlist=(), level=0): if level == 0 and name.partition('.')[0] == 'kubernetes': raise ImportError("No module named 'kubernetes'") return importlib.__import__(name, globals=globals_, locals=locals_, fromlist=fromlist, level=level) with mock.patch('builtins.__import__', side_effect=mock__import__) as import_mock: # load module from scratch, this does not replace any already imported # airflow.serialization.serialized_objects module in sys.modules spec = importlib.util.find_spec("airflow.serialization.serialized_objects") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) # if we got this far, the module did not try to load kubernetes, but # did it try to access airflow.kubernetes.*? imported_airflow = { c.args[0].split('.', 2)[1] for c in import_mock.call_args_list if c.args[0].startswith("airflow.") } assert "kubernetes" not in imported_airflow # pod loading is not supported when kubernetes is not available pod_override = { '__type': 'k8s.V1Pod', '__var': PodGenerator.serialize_pod(executor_config_pod), } with pytest.raises(RuntimeError): module.BaseSerialization.from_dict(pod_override) # basic serialization should succeed module.SerializedDAG.to_dict(make_simple_dag()["simple_dag"])
the-stack_106_32245
try: from ub.modules.sql_helper import SESSION, BASE except ImportError: raise AttributeError from sqlalchemy import Column, String, UnicodeText class bot_pm_ban(BASE): __tablename__ = "bot_pm_ban_sql" sender = Column(String(14), primary_key=True) def __init__(self, sender): self.sender = str(sender) bot_pm_ban.__table__.create(checkfirst=True) def is_botpmbanned(sender_id): try: return SESSION.query(bot_pm_ban).all() except BaseException: return None finally: SESSION.close() def botban(sender): adder = bot_pm_ban(str(sender)) SESSION.add(adder) SESSION.commit() def botunban(sender): rem = SESSION.query(bot_pm_ban).get((str(sender))) if rem: SESSION.delete(rem) SESSION.commit()
the-stack_106_32247
import json import tensorflow as tf from tensorflow import keras model = keras.models.load_model('model.h5') with open('dictionary.txt', 'r') as file: diction = json.load(file) def review_encode(s): encoded = [] for word in s: if word.lower() in diction: encoded.append(diction[word.lower()]) else: encoded.append(0) return encoded with open('text.txt', encoding='utf-8') as f: for line in f.readlines(): nline = line.replace(',', '').replace('.', '').replace('/', '').strip().split(' ') encode = review_encode(nline) encode = keras.preprocessing.sequence.pad_sequences([encode], padding='post', maxlen=200) predict = model.predict(encode) # print(line) # print(encode) for i in predict: for t in i: answer = t * 100 print('%.3f' % answer + '%')
the-stack_106_32248
import threading,time import queue # li=[1,2,3,4,5] # def pri(): # while li: # a=li[-1] # print(a) # time.sleep(1) # try: # li.remove(a) # except Exception as e: # print('----',a,e) # # if __name__ == '__main__': # t1 = threading.Thread(target=pri, args=()) # t1.start() # t2 = threading.Thread(target=pri, args=()) # t2.start() # q=queue.LifoQueue() # # q.put(34) # q.put(56) # q.put(12) # # #优先级 # q=queue.PriorityQueue() # q.put([5,100]) # q.put([7,200]) # q.put([3,"hello"]) # q.put([4,{"name":"alex"}]) # if __name__ == '__main__': # while 1: # data = q.get() # print(data) # from contextlib import contextmanager # # # @contextmanager # def make_context(): # print('enter') # try: # yield "ok" # except RuntimeError as err: # print( 'error', err) # finally: # print('exit') # if __name__ == '__main__': # with make_context() as value: # print(value) # def consumer(name): # print("--->ready to eat baozi...") # while True: # new_baozi = yield # print("[%s] is eating baozi %s" % (name,new_baozi)) # #time.sleep(1) # # def producer(): # # r = con.__next__() # r = con2.__next__() # n = 0 # while 1: # time.sleep(1) # print("\033[32;1m[producer]\033[0m is making baozi %s and %s" %(n,n+1) ) # con.send(n) # con2.send(n+1) # # n +=2 # # # if __name__ == '__main__': # con = consumer("c1") # con2 = consumer("c2") # p = producer() # from greenlet import greenlet # # # def test1(): # print(12) # gr2.switch() # print(34) # gr2.switch() # # # def test2(): # print(56) # gr1.switch() # print(78) # # # if __name__ == '__main__': # gr1 = greenlet(test1) # gr2 = greenlet(test2) # gr1.switch() import gevent import requests,time start=time.time() def f(url): print('GET: %s' % url) resp =requests.get(url) data = resp.text print('%d bytes received from %s.' % (len(data), url)) gevent.joinall([ gevent.spawn(f, 'https://www.python.org/'), gevent.spawn(f, 'https://www.yahoo.com/'), gevent.spawn(f, 'https://www.baidu.com/'), gevent.spawn(f, 'https://www.sina.com.cn/'), ]) print("cost time:",time.time()-start)
the-stack_106_32249
import pygame as pg import random from settings import * from termcolor import colored class Player(pg.sprite.Sprite): def __init__(self, game, x, y, health = PLAYER_HEALTH, damage = PLAYER_DAMAGE, armor = PLAYER_ARMOR, weapon = 'weapon1', keys = 0, potions = 0, books = 0, health_upgrade = 0, armor_upgrade = 0, moves = 0, max_health = PLAYER_HEALTH, max_armor = PLAYER_ARMOR, score = 0): self._layer = PLAYER_LAYER self.groups = game.all_sprites pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = game.player_img self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = self.x self.rect.y = self.y try: self.weapon_img = game.item_images[weapon] except KeyError: self.weapon_img = weapon self.coins = int(self.game.load_data[0]) self.health_upgrade = health_upgrade self.max_health = (health_upgrade * 20) + PLAYER_HEALTH self.max_armor = armor_upgrade + PLAYER_ARMOR self.armor_upgrade = armor_upgrade self.health = health self.damage = damage self.armor = armor self.keys = keys self.potions = potions self.books = books self.moves = moves self.score = score def move(self, dx = 0, dy = 0): if not self.collide(dx * TILESIZE, dy * TILESIZE): self.x += dx * TILESIZE self.y += dy * TILESIZE self.game.footstep.play() self.moves += 1 def collide(self, dx = 0, dy = 0): for wall in self.game.walls: if wall.x == self.x + dx and wall.y == self.y + dy: self.game.sound.play() return True for mob in self.game.mobs: if mob.x == self.x + dx and mob.y == self.y + dy: mob.health -= self.damage return True for chest in self.game.chests: if chest.x == self.x + dx and chest.y == self.y + dy: if self.keys > 0: chest.kill() self.random_item(self.game, chest.x, chest.y) self.keys -= 1 self.score += 6 return True self.game.sound.play() return True for interact in self.game.interacts: if interact.x == self.x + dx and interact.y == self.y + dy: print(colored(interact.text, 'blue')) self.game.sound.play() return True for travel in self.game.travels: if travel.x == self.x + dx and travel.y == self.y + dy: if travel.name == 'travel': random_travel = random.choice(TRAVEL_LIST) if random_travel == self.game.map_name[:-4]: self.game.new(f'map.tmx', self.health, self.damage, self.armor, self.weapon_img, self.keys, self.potions, self.books, self.health_upgrade, self.armor_upgrade, self.moves, self.max_health, self.max_armor, self.score) else: self.game.new(f'{random_travel}.tmx', self.health, self.damage, self.armor, self.weapon_img, self.keys, self.potions, self.books, self.health_upgrade, self.armor_upgrade, self.moves, self.max_health, self.max_armor, self.score) else: self.game.new(f'{travel.name}.tmx', self.health, self.damage, self.armor, self.weapon_img, self.keys, self.potions, self.books, self.health_upgrade, self.armor_upgrade, self.moves, self.max_health, self.max_armor, self.score) self.game.run() return True return False def item_ontop(self, x, y): for item in self.game.items: if item.x == self.x and item.y == self.y: if item.type == 'heart' and self.health < self.max_health: item.kill() self.score += 2 self.add_health(ITEMS['heart_amount']) if item.type == 'coin': item.kill() self.score += 2 self.coins += 1 if item.type == 'key': item.kill() self.score += 2 self.keys += 1 if item.type == 'potion': item.kill() self.score += 2 self.potions += 1 if item.type == 'book': item.kill() self.score += 2 self.books += 1 if 'weapon' in item.type: item.kill() self.score += 2 x = str(item.type) + '_amount' self.better_damage(item.type, ITEMS[x]) if 'armor' in item.type: item.kill() self.score += 2 x = str(item.type) + '_amount' self.add_armor(ITEMS[x]) def random_item(self, game, x, y): item = random.choice(list(self.game.item_images)) Item(self.game, x, y, item) def better_damage(self, img, amount): if self.damage < PLAYER_DAMAGE + amount: self.weapon_img = self.game.item_images[img] self.damage = PLAYER_DAMAGE + amount def add_armor(self, amount): self.armor += amount if self.armor > self.max_armor: self.armor = self.max_armor def add_health(self, amount): self.health += amount if self.health > self.max_health: self.health = self.max_health def update(self): self.rect.x = self.x self.rect.y = self.y if self.item_ontop(self.x, self.y): self.x += dx * TILESIZE self.y += dy * TILESIZE class Mob(pg.sprite.Sprite): def __init__(self, game, x, y, type): self._layer = MOB_LAYER self.groups = game.all_sprites, game.mobs pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = game.mob_images[type] self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = x self.rect.y = y self.type = type if 'mob' in self.type: self.health = MOBS[str(self.type) + '_health'] self.damage = MOBS[str(self.type) + '_damage'] def collide(self, dx = 0, dy = 0): for wall in self.game.walls: if wall.x == self.x + dx and wall.y == self.y + dy: return True for chest in self.game.chests: if chest.x == self.x + dx and chest.y == self.y + dy: return True for mob in self.game.mobs: if mob.x == self.x + dx and mob.y == self.y + dy: return True for interact in self.game.interacts: if interact.x == self.x + dx and interact.y == self.y + dy: return True for travel in self.game.travels: if travel.x == self.x + dx and travel.y == self.y + dy: return True return False def player_collide(self, dx = 0, dy = 0): if self.game.player.x == self.x + dx and self.game.player.y == self.y + dy: if self.game.player.armor > 0: self.game.player.armor -= 1 else: self.game.player.health -= self.damage return True return False def move_toward(self): dx = self.game.player.x - self.x dy = self.game.player.y - self.y d = abs(dx) + abs(dy) if dy < 0: if not self.move(dy = -1): self.move(dx = random.randint(-1, 1)) elif dx < 0: if not self.move(dx = -1): self.move(dy = random.randint(-1, 1)) elif dy > 0: if not self.move(dy = 1): self.move(dx = random.randint(-1, 1)) elif dx > 0: if not self.move(dx = 1): self.move(dy = random.randint(-1, 1)) def move(self, dx = 0, dy = 0): if not self.collide(dx * TILESIZE, dy * TILESIZE) and not self.player_collide(dx * TILESIZE, dy * TILESIZE): self.x += dx * TILESIZE self.y += dy * TILESIZE return True return False def check_item(self, x, y): for item in self.game.items: if item.x == self.x and item.y == self.y: return True return False def update(self): self.rect.x = self.x self.rect.y = self.y if self.health <= 0: self.kill() self.game.player.coins += 1 self.game.player.score += 4 rand = random.randint(1, 20) if rand == 1: Player.random_item(self, self.game, self.x, self.y) if not self.check_item(self.x, self.y): self.game.map_img.blit(self.game.skull_img, (self.x, self.y)) class Wall(pg.sprite.Sprite): def __init__(self, game, x, y): self.groups = game.all_sprites, game.walls pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = game.wall_img self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = x self.rect.y = y class Obstacle(pg.sprite.Sprite): def __init__(self, game, x, y, w, h): self.groups = game.walls pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.rect = pg.Rect(x, y, w, h) self.x = x self.y = y class Item(pg.sprite.Sprite): def __init__(self, game, x, y, type): self._layer = ITEMS_LAYER self.groups = game.all_sprites, game.items pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = game.item_images[type] self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = x self.rect.y = y self.type = type class Chest(pg.sprite.Sprite): def __init__(self, game, x, y): self._layer = PLAYER_LAYER self.groups = game.all_sprites, game.chests pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = game.chest_img self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = x self.rect.y = y class Interact(pg.sprite.Sprite): def __init__(self, game, x, y, text): self._layer = WALL_LAYER self.groups = game.interacts pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.rect = pg.Rect(x, y, TILESIZE, TILESIZE) self.x = x self.y = y self.text = text class Travel(pg.sprite.Sprite): def __init__(self, game, x, y, w, h, name): self.groups = game.travels pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.rect = pg.Rect(x, y, w, h) self.x = x self.y = y self.name = name
the-stack_106_32251
import joblib import numpy as np import seldon_core from seldon_core.user_model import SeldonComponent from typing import Dict, List, Union, Iterable import os import logging import yaml logger = logging.getLogger(__name__) JOBLIB_FILE = "model.joblib" class SKLearnServer(SeldonComponent): def __init__(self, model_uri: str = None, method: str = "predict_proba"): super().__init__() self.model_uri = model_uri self.method = method self.ready = False logger.info(f"Model uri: {self.model_uri}") logger.info(f"method: {self.method}") self.load() def load(self): logger.info("load") model_file = os.path.join( seldon_core.Storage.download(self.model_uri), JOBLIB_FILE ) logger.info(f"model file: {model_file}") self._joblib = joblib.load(model_file) self.ready = True def predict( self, X: np.ndarray, names: Iterable[str], meta: Dict = None ) -> Union[np.ndarray, List, str, bytes]: try: if not self.ready: self.load() if self.method == "predict_proba": logger.info("Calling predict_proba") result = self._joblib.predict_proba(X) elif self.method == "decision_function": logger.info("Calling decision_function") result = self._joblib.decision_function(X) else: logger.info("Calling predict") result = self._joblib.predict(X) return result except Exception as ex: logging.exception("Exception during predict") def init_metadata(self): file_path = os.path.join(self.model_uri, "metadata.yaml") try: with open(file_path, "r") as f: return yaml.safe_load(f.read()) except FileNotFoundError: logger.debug(f"metadata file {file_path} does not exist") return {} except yaml.YAMLError: logger.error( f"metadata file {file_path} present but does not contain valid yaml" ) return {}
the-stack_106_32256
import os import torch import argparse from dataset import Dataset from utils import compute_F1, compute_exact_match from torch.utils.data import DataLoader from transformers import AdamW from tqdm import tqdm from trainer import train, valid from transformers import AutoModelForQuestionAnswering, AutoTokenizer, AdamW from torch.utils.tensorboard import SummaryWriter from knockknock import email_sender import datetime now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') writer = SummaryWriter() parser = argparse.ArgumentParser() parser.add_argument('--patience' , type = int, default=3) parser.add_argument('--batch_size' , type = int, default=8) parser.add_argument('--max_epoch' , type = int, default=2) parser.add_argument('--base_trained_model', type = str, default = 'bert-base-uncased', help =" pretrainned model from 🤗") parser.add_argument('--pretrained_model' , type = str, help = 'pretrainned model') parser.add_argument('--gpu_number' , type = int, default = 0, help = 'which GPU will you use?') parser.add_argument('--debugging' , type = bool, default = False, help = "Don't save file") parser.add_argument('--log_file' , type = str, default = f'logs/log_{now_time}.txt',) parser.add_argument('--dev_path' , type = str, default = '../data/MultiWOZ_2.1/dev_data.json') parser.add_argument('--train_path' , type = str, default = '../data/MultiWOZ_2.1/train_data.json') parser.add_argument('--do_train' , default = True, help = 'do train or not', action=argparse.BooleanOptionalAction) args = parser.parse_args() def makedirs(path): try: os.makedirs(path) except OSError: if not os.path.isdir(path): raise args = parser.parse_args() # @email_sender(recipient_emails=["[email protected]"], sender_email="[email protected]") def main(): makedirs("./data"); makedirs("./logs"); makedirs("./model"); # import pdb; pdb.set_trace() tokenizer = AutoTokenizer.from_pretrained(args.base_trained_model, use_fast=True) model = AutoModelForQuestionAnswering.from_pretrained(args.base_trained_model) train_dataset = Dataset(args.train_path, 'train', tokenizer, False) val_dataset = Dataset(args.dev_path, 'dev', tokenizer, False) train_loader = DataLoader(train_dataset, args.batch_size, shuffle=True) dev_loader = DataLoader(val_dataset, args.batch_size, shuffle=True) optimizer = AdamW(model.parameters(), lr=5e-5, weight_decay=0.01) log_file = open(args.log_file, 'w') device = torch.device(f'cuda:{args.gpu_number}' if torch.cuda.is_available() else 'cpu') torch.cuda.set_device(device) # change allocation of current GPU torch.cuda.empty_cache() if args.pretrained_model: print("use trained model") log_file.write("use trained model") model.load_state_dict(torch.load(args.pretrained_model)) log_file.write(str(args)) model.to(device) penalty = 0 min_loss = float('inf') for epoch in range(args.max_epoch): print(f"Epoch : {epoch}") # if args.do_train: # train(model, train_loader, optimizer, device) pred_texts, ans_texts, loss = valid(model, dev_loader, device, tokenizer,log_file) EM, F1 = 0, 0 for iter, (pred_text, ans_text) in enumerate(zip(pred_texts, ans_texts)): EM += compute_exact_match(pred_text, ans_text) F1 += compute_F1(pred_text, ans_text) print("Epoch : %d, EM : %.04f, F1 : %.04f, Loss : %.04f" % (epoch, EM/iter, F1/iter, loss)) log_file.writelines("Epoch : %d, EM : %.04f, F1 : %.04f, Loss : %.04f" % (epoch, EM/iter, F1/iter, loss)) writer.add_scalar("EM", EM/iter, epoch) writer.add_scalar("F1", F1/iter, epoch) writer.add_scalar("loss",loss, epoch) if loss < min_loss: print("New best") min_loss = loss penalty = 0 if not args.debugging: torch.save(model.state_dict(), f"model/{args.now_time}.pt") else: penalty +=1 if penalty>args.patience: print(f"early stopping at epoch {epoch}") break writer.close() log_file.close() return {'EM' : EM/iter, 'F1' : F1/iter} if __name__ =="__main__": main()
the-stack_106_32259
#!/usr/bin/env python3 # Copyright (c) 2014-2020 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test the wallet accounts properly when there are cloned transactions with malleated scriptsigs.""" from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( assert_equal, ) from test_framework.messages import ( COIN, tx_from_hex, ) class TxnMallTest(BitcoinTestFramework): def set_test_params(self): self.num_nodes = 3 self.supports_cli = False def skip_test_if_missing_module(self): self.skip_if_no_wallet() def add_options(self, parser): parser.add_argument("--mineblock", dest="mine_block", default=False, action="store_true", help="Test double-spend of 1-confirmed transaction") parser.add_argument("--segwit", dest="segwit", default=False, action="store_true", help="Test behaviour with SegWit txn (which should fail)") def setup_network(self): # Start with split network: super().setup_network() self.disconnect_nodes(1, 2) def run_test(self): if self.options.segwit: output_type = "p2sh-segwit" else: output_type = "legacy" # All nodes should start with 1,250 CPU: starting_balance = 1250 for i in range(3): assert_equal(self.nodes[i].getbalance(), starting_balance) self.nodes[0].settxfee(.001) node0_address1 = self.nodes[0].getnewaddress(address_type=output_type) node0_txid1 = self.nodes[0].sendtoaddress(node0_address1, 1219) node0_tx1 = self.nodes[0].gettransaction(node0_txid1) node0_address2 = self.nodes[0].getnewaddress(address_type=output_type) node0_txid2 = self.nodes[0].sendtoaddress(node0_address2, 29) node0_tx2 = self.nodes[0].gettransaction(node0_txid2) assert_equal(self.nodes[0].getbalance(), starting_balance + node0_tx1["fee"] + node0_tx2["fee"]) # Coins are sent to node1_address node1_address = self.nodes[1].getnewaddress() # Send tx1, and another transaction tx2 that won't be cloned txid1 = self.nodes[0].sendtoaddress(node1_address, 40) txid2 = self.nodes[0].sendtoaddress(node1_address, 20) # Construct a clone of tx1, to be malleated rawtx1 = self.nodes[0].getrawtransaction(txid1, 1) clone_inputs = [{"txid": rawtx1["vin"][0]["txid"], "vout": rawtx1["vin"][0]["vout"], "sequence": rawtx1["vin"][0]["sequence"]}] clone_outputs = {rawtx1["vout"][0]["scriptPubKey"]["address"]: rawtx1["vout"][0]["value"], rawtx1["vout"][1]["scriptPubKey"]["address"]: rawtx1["vout"][1]["value"]} clone_locktime = rawtx1["locktime"] clone_raw = self.nodes[0].createrawtransaction(clone_inputs, clone_outputs, clone_locktime) # createrawtransaction randomizes the order of its outputs, so swap them if necessary. clone_tx = tx_from_hex(clone_raw) if (rawtx1["vout"][0]["value"] == 40 and clone_tx.vout[0].nValue != 40*COIN or rawtx1["vout"][0]["value"] != 40 and clone_tx.vout[0].nValue == 40*COIN): (clone_tx.vout[0], clone_tx.vout[1]) = (clone_tx.vout[1], clone_tx.vout[0]) # Use a different signature hash type to sign. This creates an equivalent but malleated clone. # Don't send the clone anywhere yet tx1_clone = self.nodes[0].signrawtransactionwithwallet(clone_tx.serialize().hex(), None, "ALL|ANYONECANPAY") assert_equal(tx1_clone["complete"], True) # Have node0 mine a block, if requested: if (self.options.mine_block): self.nodes[0].generate(1) self.sync_blocks(self.nodes[0:2]) tx1 = self.nodes[0].gettransaction(txid1) tx2 = self.nodes[0].gettransaction(txid2) # Node0's balance should be starting balance, plus 50CPU for another # matured block, minus tx1 and tx2 amounts, and minus transaction fees: expected = starting_balance + node0_tx1["fee"] + node0_tx2["fee"] if self.options.mine_block: expected += 50 expected += tx1["amount"] + tx1["fee"] expected += tx2["amount"] + tx2["fee"] assert_equal(self.nodes[0].getbalance(), expected) if self.options.mine_block: assert_equal(tx1["confirmations"], 1) assert_equal(tx2["confirmations"], 1) else: assert_equal(tx1["confirmations"], 0) assert_equal(tx2["confirmations"], 0) # Send clone and its parent to miner self.nodes[2].sendrawtransaction(node0_tx1["hex"]) txid1_clone = self.nodes[2].sendrawtransaction(tx1_clone["hex"]) if self.options.segwit: assert_equal(txid1, txid1_clone) return # ... mine a block... self.nodes[2].generate(1) # Reconnect the split network, and sync chain: self.connect_nodes(1, 2) self.nodes[2].sendrawtransaction(node0_tx2["hex"]) self.nodes[2].sendrawtransaction(tx2["hex"]) self.nodes[2].generate(1) # Mine another block to make sure we sync self.sync_blocks() # Re-fetch transaction info: tx1 = self.nodes[0].gettransaction(txid1) tx1_clone = self.nodes[0].gettransaction(txid1_clone) tx2 = self.nodes[0].gettransaction(txid2) # Verify expected confirmations assert_equal(tx1["confirmations"], -2) assert_equal(tx1_clone["confirmations"], 2) assert_equal(tx2["confirmations"], 1) # Check node0's total balance; should be same as before the clone, + 100 CPU for 2 matured, # less possible orphaned matured subsidy expected += 100 if (self.options.mine_block): expected -= 50 assert_equal(self.nodes[0].getbalance(), expected) if __name__ == '__main__': TxnMallTest().main()
the-stack_106_32260
import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split from sklearn.preprocessing import OneHotEncoder import slicing.slicer as slicer file_name = 'insurance.csv' dataset = pd.read_csv(file_name) attributes_amount = len(dataset.values[0]) # for now working with regression datasets, assuming that target attribute is the last one # currently non-categorical features are not supported and should be binned y = dataset.iloc[:, attributes_amount - 1:attributes_amount].values # starting with one not including id field x = dataset.iloc[:, 0:attributes_amount - 1].values # list of numerical columns non_categorical = [1, 3] for row in x: for attribute in non_categorical: # <attribute - 2> as we already excluded from x id column row[attribute - 1] = int(row[attribute - 1] / 5) # hot encoding of categorical features enc = OneHotEncoder(handle_unknown='ignore') x = enc.fit_transform(x).toarray() complete_x = [] complete_y = [] counter = 0 all_features = enc.get_feature_names() # train model on a whole dataset x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0) for item in x_test: complete_x.append((counter, item)) complete_y.append((counter, y_test[counter])) counter = counter + 1 x_size = counter model = LinearRegression() model.fit(x_train, y_train) preds = (model.predict(x_test) - y_test) ** 2 f_l2 = sum(preds)/x_size errors = [] counter = 0 for pred in preds: errors.append((counter, pred)) counter = counter + 1 # alpha is size significance coefficient # verbose option is for returning debug info while creating slices and printing it # k is number of top-slices we want # w is a weight of error function significance (1 - w) is a size significance propagated into optimization function slicer.process(all_features, model, complete_x, f_l2, x_size, y_test, errors, debug=True, alpha=5, k=10, w=0.5, loss_type=0)
the-stack_106_32261
import tensorflow as tf import numpy as np import os import json # Spectral band names to read related GeoTIFF files band_names = ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09', 'B11', 'B12'] def prep_example(bands, BigEarthNet_19_labels, BigEarthNet_19_labels_multi_hot, patch_name): return tf.train.Example( features=tf.train.Features( feature={ 'B01': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B01']))), 'B02': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B02']))), 'B03': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B03']))), 'B04': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B04']))), 'B05': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B05']))), 'B06': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B06']))), 'B07': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B07']))), 'B08': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B08']))), 'B8A': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B8A']))), 'B09': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B09']))), 'B11': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B11']))), 'B12': tf.train.Feature( int64_list=tf.train.Int64List(value=np.ravel(bands['B12']))), 'BigEarthNet-19_labels': tf.train.Feature( bytes_list=tf.train.BytesList( value=[i.encode('utf-8') for i in BigEarthNet_19_labels])), 'BigEarthNet-19_labels_multi_hot': tf.train.Feature( int64_list=tf.train.Int64List(value=BigEarthNet_19_labels_multi_hot)), 'patch_name': tf.train.Feature( bytes_list=tf.train.BytesList(value=[patch_name.encode('utf-8')])) })) def create_split(root_folder, patch_names, TFRecord_writer, label_indices, GDAL_EXISTED, RASTERIO_EXISTED, UPDATE_JSON): label_conversion = label_indices['label_conversion'] BigEarthNet_19_label_idx = {v: k for k, v in label_indices['BigEarthNet-19_labels'].iteritems()} if GDAL_EXISTED: import gdal elif RASTERIO_EXISTED: import rasterio progress_bar = tf.contrib.keras.utils.Progbar(target = len(patch_names)) for patch_idx, patch_name in enumerate(patch_names): patch_folder_path = os.path.join(root_folder, patch_name) bands = {} for band_name in band_names: # First finds related GeoTIFF path and reads values as an array band_path = os.path.join( patch_folder_path, patch_name + '_' + band_name + '.tif') if GDAL_EXISTED: band_ds = gdal.Open(band_path, gdal.GA_ReadOnly) raster_band = band_ds.GetRasterBand(1) band_data = raster_band.ReadAsArray() bands[band_name] = np.array(band_data) elif RASTERIO_EXISTED: band_ds = rasterio.open(band_path) band_data = np.array(band_ds.read(1)) bands[band_name] = np.array(band_data) original_labels_multi_hot = np.zeros( len(label_indices['original_labels'].keys()), dtype=int) BigEarthNet_19_labels_multi_hot = np.zeros(len(label_conversion),dtype=int) patch_json_path = os.path.join( patch_folder_path, patch_name + '_labels_metadata.json') with open(patch_json_path, 'rb') as f: patch_json = json.load(f) original_labels = patch_json['labels'] for label in original_labels: original_labels_multi_hot[label_indices['original_labels'][label]] = 1 for i in range(len(label_conversion)): BigEarthNet_19_labels_multi_hot[i] = ( np.sum(original_labels_multi_hot[label_conversion[i]]) > 0 ).astype(int) BigEarthNet_19_labels = [] for i in np.where(BigEarthNet_19_labels_multi_hot == 1)[0]: BigEarthNet_19_labels.append(BigEarthNet_19_label_idx[i]) if UPDATE_JSON: patch_json['BigEarthNet_19_labels'] = BigEarthNet_19_labels with open(patch_json_path, 'wb') as f: json.dump(patch_json, f) example = prep_example( bands, BigEarthNet_19_labels, BigEarthNet_19_labels_multi_hot, patch_name ) TFRecord_writer.write(example.SerializeToString()) progress_bar.update(patch_idx) def prep_tf_record_files(root_folder, out_folder, split_names, patch_names_list, label_indices, GDAL_EXISTED, RASTERIO_EXISTED, UPDATE_JSON): try: writer_list = [] for split_name in split_names: writer_list.append( tf.python_io.TFRecordWriter(os.path.join( out_folder, split_name + '.tfrecord')) ) except: print('ERROR: TFRecord writer is not able to write files') exit() for split_idx in range(len(patch_names_list)): print('INFO: creating the split of', split_names[split_idx], 'is started') create_split( root_folder, patch_names_list[split_idx], writer_list[split_idx], label_indices, GDAL_EXISTED, RASTERIO_EXISTED, UPDATE_JSON ) writer_list[split_idx].close()
the-stack_106_32262
import numpy as np import pytest from numpy.testing import assert_allclose from robogym.envs.dactyl.full_perpendicular import make_env, make_simple_env from robogym.utils import rotation def test_cube_mass(): env = make_env(constants=dict(randomize=False)) sim = env.unwrapped.sim cube_id = sim.model.body_name2id("cube:middle") # The mass of the giiker cube is 90g assert_allclose(sim.model.body_subtreemass[cube_id], 0.09, atol=0.005) @pytest.mark.parametrize( "goal_generation", [ "face_curr", "face_free", "face_cube_solver", "unconstrained_cube_solver", "full_unconstrained", "release_cube_solver", ], ) def test_goal_info(goal_generation): constants = { "goal_generation": goal_generation, "randomize_face_angles": False, "randomize": False, } # There is some small chance that cube can get into invalid state in simulation # which will cause cube solver to fail. Fixing the seed here to mitigate this # issue. env = make_env(constants=constants, starting_seed=12312) env.reset() _, _, goal_info = env.unwrapped.goal_info() assert "goal" in goal_info assert "goal_type" in goal_info["goal"] def test_make_simple_env(): env = make_simple_env( parameters={ "simulation_params": dict(cube_appearance="vision", hide_target=True) } ) env.reset() sim = env.sim # there is no wrapper. sticker_geoms = [g for g in sim.model.geom_names if g.startswith("cube:sticker:")] assert len(sticker_geoms) == 9 * 6 def test_observe(): # Test observation matches simulation state. env = make_simple_env() env.reset() simulation = env.mujoco_simulation obs = env.observe() qpos = simulation.qpos qpos[simulation.qpos_idxs["target_all_joints"]] = 0.0 qvel = simulation.qvel qvel[simulation.qvel_idxs["target_all_joints"]] = 0.0 true_obs = { "cube_pos": simulation.get_qpos("cube_position"), "cube_quat": rotation.quat_normalize(simulation.get_qpos("cube_rotation")), "hand_angle": simulation.get_qpos("hand_angle"), "fingertip_pos": simulation.shadow_hand.observe() .fingertip_positions() .flatten(), "qpos": qpos, "qvel": qvel, } for obs_key, true_val in true_obs.items(): assert np.allclose( obs[obs_key], true_val ), f"Value for obs {obs_key} {obs[obs_key]} doesn't match true value {true_val}." def test_informative_obs(): WHITELIST = [ # The position of the goal is zeroed "relative_goal_pos", "noisy_relative_goal_pos", "goal_pos", # Not all episodes end with a fall, i.e. it might be all zeros "fell_down", ] env = make_env(constants=dict(randomize=False, max_timesteps_per_goal=50)) obs = env.reset() done = False all_obs = [obs] while not done: obs, reward, done, info = env.step(env.action_space.sample()) all_obs.append(obs) all_obs.append(env.reset()) # one more reset at the end # Collect all obs and index by key. keys = set(all_obs[0].keys()) assert len(keys) > 0 combined_obs_by_keys = {key: [] for key in keys} for obs in all_obs: assert set(obs.keys()) == keys for key in keys: combined_obs_by_keys[key].append(obs[key]) # Make sure that none of the keys has all-constant obs. for key, obs in combined_obs_by_keys.items(): assert len(obs) == len(all_obs) if key in WHITELIST: continue obs0 = obs[0] equals = [np.array_equal(obs0, obs_i) for obs_i in obs] # If ob0 is equal to all other obs, all obs are equal, i.e. the observation # contains no information whatsoever. This is usually bad (e.g. we had an issue # in the past where qpos was aways set to all-zeros). assert not np.all(equals), "observations for {} are all equal to {}".format( key, obs0 ) def test_min_episode_length(): min_steps = 1000 env_1 = make_env(constants=dict(min_episode_length=min_steps), starting_seed=12312) env_1.reset() # fix seed to avoid stochastic tests num_fallen = 0 for _ in range(min_steps): o, r, d, i = env_1.step(env_1.action_space.sample()) assert not d if i["fell_down"]: num_fallen += 1 assert num_fallen > 0 env_2 = make_env(constants=dict(min_episode_length=-1), starting_seed=12312) env_2.reset() # fix seed to avoid stochastic tests for t in range(min_steps): o, r, d, i = env_2.step(env_2.action_space.sample()) if d: break assert t < min_steps - 1
the-stack_106_32263
import time import electrumx.lib.util as util def sessions_lines(data): '''A generator returning lines for a list of sessions. data is the return value of rpc_sessions().''' fmt = ('{:<6} {:<5} {:>17} {:>5} ' '{:>7} {:>7} {:>5} {:>5} {:>7} ' '{:>7} {:>7} {:>7} {:>7} {:>9} {:>21}') yield fmt.format('ID', 'Flags', 'Client', 'Proto', 'Cost', 'XCost', 'Reqs', 'Txs', 'Subs', 'Recv', 'Recv KB', 'Sent', 'Sent KB', 'Time', 'Peer') for (id_, flags, peer, client, proto, cost, extra_cost, reqs, txs_sent, subs, recv_count, recv_size, send_count, send_size, conn_time) in data: yield fmt.format(id_, flags, client, proto, f'{int(cost):,d}', f'{int(extra_cost):,d}', f'{reqs:,d}', f'{txs_sent:,d}', f'{subs:,d}', f'{recv_count:,d}', f'{recv_size // 1024:,d}', f'{send_count:,d}', f'{send_size // 1024:,d}', util.formatted_time(conn_time, sep=''), peer) def groups_lines(data): '''A generator returning lines for a list of groups. data is the return value of rpc_groups().''' fmt = ('{:<14} {:>9} {:>8} {:>8} {:>6} {:>6} {:>8}' '{:>7} {:>9} {:>7} {:>9}') yield fmt.format('Name', 'Sessions', 'Cost', 'Retained', 'Reqs', 'Txs', 'Subs', 'Recv', 'Recv KB', 'Sent', 'Sent KB') for (name, session_count, cost, retained_cost, reqs, txs_sent, subs, recv_count, recv_size, send_count, send_size) in data: yield fmt.format(name, f'{session_count:,d}', f'{int(cost):,d}', f'{int(retained_cost):,d}', f'{reqs:,d}', f'{txs_sent:,d}', f'{subs:,d}', f'{recv_count:,d}', f'{recv_size // 1024:,d}', f'{send_count:,d}', f'{send_size // 1024:,d}') def peers_lines(data): '''A generator returning lines for a list of peers. data is the return value of rpc_peers().''' def time_fmt(t): if not t: return 'Never' return util.formatted_time(now - t) now = time.time() fmt = ('{:<62} {:<6} {:>5} {:>5} {:<17} {:>4} ' '{:>4} {:>8} {:>11} {:>11} {:>5} {:>20} {:<15}') yield fmt.format('Host', 'Status', 'TCP', 'SSL', 'Server', 'Min', 'Max', 'Pruning', 'Last Good', 'Last Try', 'Tries', 'Source', 'IP Address') for item in data: features = item['features'] hostname = item['host'] host = features['hosts'][hostname] yield fmt.format(hostname[:62], item['status'], host.get('tcp_port') or '', host.get('ssl_port') or '', features['server_version'] or 'unknown', features['protocol_min'], features['protocol_max'], features['pruning'] or '', time_fmt(item['last_good']), time_fmt(item['last_try']), item['try_count'], item['source'][:20], item['ip_addr'] or '')
the-stack_106_32265
# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import collections from contextlib import contextmanager import copy import enum from functools import partial import re import unittest import types import warnings import weakref import functools import itertools as it from absl import logging from absl.testing import absltest, parameterized import numpy as np import concurrent.futures import jax import jax.numpy as jnp from jax import float0, jit, grad, device_put, jacfwd, jacrev, hessian from jax import api, core, lax from jax.core import Primitive from jax.interpreters import ad from jax.interpreters import xla from jax.interpreters.sharded_jit import PartitionSpec as P from jax.lib import xla_bridge as xb from jax import test_util as jtu from jax import tree_util from jax import linear_util as lu import jax._src.util from jax.config import config config.parse_flags_with_absl() FLAGS = config.FLAGS class CPPJitTest(jtu.BufferDonationTestCase): """Shared tests between the Python and the C++ jax,jit implementations. Because the Python implementation supports more features, we need to have the Python tests that extend the C++ tests (and not the other way around). """ @property def jit(self): # Right now, the CPP tests also test the Python code-path when jaxlib is # too old. # TODO(jblespiau,phawkins): Remove this when jaxlib has been released. # This is in the future, because we are making a breaking change to # Tensorflow. return jax.api._cpp_jit def test_jit_of_noncallable(self): self.assertRaisesRegex(TypeError, "Expected a callable value.*", lambda: self.jit(3)) def test_jit_of_generator(self): def gen(x): yield x self.assertRaisesRegex(TypeError, "Expected a function, got a generator function.*", lambda: self.jit(gen)) @parameterized.parameters([ # Integer support (1, 2, 3, 4, 5), # Numpy array support ( np.asarray(1, np.int32), np.asarray(2, np.int32), np.asarray(3, np.int32), np.asarray(4, np.int32), np.asarray(5, np.int32), ), ]) def test_jit_static_args(self, one, two, three, four, five): side = [] # For the CPP jit, we need to clear the cache to prevent cache hits between # parameterized tests. if hasattr(self.jit, "cache_clear"): self.jit.cache_clear() def f(x, y, z, flag=False, flag2=False): del flag2 # unused assert flag side.append(None) return 100 * x + 10 * y + z f1 = self.jit(f, static_argnums=(3, 4)) assert f1(one, two, three, True, False) == 123 assert len(side) == 1 assert f1(one, two, three, True, False) == 123 assert len(side) == 1 # Obvious cache hit. assert f1(two, one, three, True, False) == 213 assert len(side) == 1 # Should cache hit because same signature. assert f1(two, one, three, True, True) == 213 assert len(side) == 2 side[:] = [] f2 = self.jit(f, static_argnums=(0, 2, 3, 4)) assert f2(1, 2, 3, True, False) == 123 assert len(side) == 1 assert f2(1, 3, 3, True, False) == 133 assert len(side) == 1 assert f2(2, 2, 3, True, False) == 223 assert len(side) == 2 assert f2(2, 4, 3, True, False) == 243 assert len(side) == 2 assert f2(2, 4, 3, True, True) == 243 assert len(side) == 3 assert f2(2, 5, 3, True, True) == 253 assert len(side) == 3 def test_static_args_equality(self): class A(): def __hash__(self): return 1 def __eq__(self, other): return isinstance(other, A) side = [] def f(x, static_arg): del static_arg side.append(None) return x * 100 f1 = self.jit(f, static_argnums=(1,)) self.assertEqual(f1(1, A()), 100) self.assertLen(side, 1) self.assertEqual(f1(1, A()), 100) self.assertLen(side, 1) if self.jit == jax.api._cpp_jit: self.assertEqual(f1._cpp_jitted_f._cache_size(), 1) @parameterized.parameters([ (1, 2, 3), ( np.asarray(1, np.int32), np.asarray(2, np.int32), np.asarray(3, np.int32), ), ]) def test_jit_kwargs(self, one, two, three): side = [] # For the CPP jit, we need to clear the cache to prevent cache hits between # parameterized tests. if hasattr(self.jit, "cache_clear"): self.jit.cache_clear() def f(x, y, z): print(x, y, z) side.append(None) return 100 * x + 10 * y + z f = self.jit(f) assert f(one, two, three) == 123 assert len(side) == 1 assert f(one, two, three) == 123 assert len(side) == 1 assert f(one, two, z=three) == 123 assert len(side) == 2 # actually recompiles from kwarg assert f(one, two, z=three) == 123 assert len(side) == 2 # but should still cache f(one, two, z=np.zeros(3)) # doesn't crash if config.x64_enabled: # In the above call, three is of a new type (int64), thus it should # trigger a new compilation. assert len(side) == 3 def test_jit_device(self): device = xb.devices()[-1] x = self.jit(lambda x: x, device=device)(3.) self.assertIsInstance(x, xla.DeviceArray) self.assertEqual(x.device_buffer.device(), device) def test_complex_support(self): self.assertEqual(self.jit(lambda x: x + 1)(1 + 1j), 2 + 1j) def test_jit_with_many_args_works(self): @self.jit def f(args_list): return sum(args_list) self.assertEqual(f(list(range(500))), sum(range(500))) # Jit and Donate arguments def test_jit_donate_argnums_warning_raised(self): x = jnp.array([1.0, 2.0], jnp.float32) y = jnp.array([1, 2], jnp.int32) f = self.jit(lambda x, y: x.sum() + y.sum(), donate_argnums=(0, 1)) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") f(x, y) self.assertLen(w, 1) self.assertTrue(issubclass(w[-1].category, UserWarning)) self.assertIn( "Some donated buffers were not usable: f32[2]{0}, s32[2]{0}", str(w[-1].message)) @jtu.skip_on_devices("cpu") # In/out aliasing not supported on CPU. def test_jit_donate_argnums_invalidates_input(self): # We can't just use `lambda x: x` because JAX simplifies this away to an # empty XLA computation. move = self.jit(lambda x: x + x - x, donate_argnums=0) x = jnp.ones([]) y = move(x) self.assertDeleted(x) self.assertEqual(y, 1.) @jtu.skip_on_devices("cpu") # In/out aliasing not supported on CPU. def test_jit_donate_argnums_static_argnums(self): jit_fun = self.jit( lambda a, b, c, d: ((a + b + c), (a + b + d)), static_argnums=(0, 1), donate_argnums=(2, 3)) c = jax.device_put(jnp.array([1., 1.])) d = jax.device_put(jnp.array([1., 1., 1.])) e, f = jit_fun(1, 2, c, d) np.testing.assert_allclose(e, jnp.array([4., 4.])) np.testing.assert_allclose(f, jnp.array([4., 4., 4.])) self.assertDeleted(c) self.assertDeleted(d) @jtu.skip_on_devices("cpu") # In/out aliasing not supported on CPU. def test_jnp_array_copy(self): # https://github.com/google/jax/issues/3412 @partial(self.jit, donate_argnums=(0,)) def _test(array): return array.at[0].set(77) x = jnp.asarray([0, 1]) x_copy = jnp.array(x, copy=True) with warnings.catch_warnings(): warnings.simplefilter("ignore") _test(x) # donation # Gives: RuntimeError: Invalid argument: CopyToHostAsync() called on invalid buffer. print(x_copy) # doesn't crash def test_jit_global_cache(self): def f(x): assert python_should_be_executing return x python_should_be_executing = True self.jit(f)(2) python_should_be_executing = False self.jit(f)(3) def test_jit_shallow_copy(self): def f(x): return copy.copy(x) self.jit(f)(1) def test_jit_deep_copy(self): def f(x): return copy.deepcopy(x) self.jit(f)(1) def test_disable_jit(self): effects = [] @self.jit def f(x): effects.append(1) return x with api.disable_jit(): f(2) f(2) assert len(effects) == 2 f(2) f(2) assert len(effects) == 3 def test_static_argnum_errors_on_keyword_arguments(self): f = self.jit(lambda x: x, static_argnums=0) msg = ("jitted function has static_argnums=(0,), donate_argnums=() but was " "called with only 0 positional arguments.") with self.assertRaisesRegex(ValueError, re.escape(msg)): f(x=4) def test_static_argnum_on_method(self): class A: @functools.partial(self.jit, static_argnums=(0,)) def my_func_jit(self, x): return x+2 A().my_func_jit(3) def test_static_argnum_on_static_method_is_not_supported(self): with self.assertRaisesRegex(TypeError, "Expected a callable value"): class A: @functools.partial(self.jit, static_argnums=(0,)) @classmethod def my_classmethod_jit(cls, x): return x+2 def test_classmethod_is_not_supported(self): with self.assertRaisesRegex(TypeError, "Expected a callable value"): class A: @functools.partial(self.jit) @staticmethod def my_staticmethod_jit(x): return x + 2 def test_concurrent_jit(self): @self.jit def f(x): return x + x - 3. xs = [np.random.randn(i) for i in range(10)] with concurrent.futures.ThreadPoolExecutor() as executor: futures = [executor.submit(partial(f, x)) for x in xs] ys = [f.result() for f in futures] for x, y in zip(xs, ys): self.assertAllClose(x * 2 - 3., y) def test_trivial_computations(self): x = jnp.array([1, 2, 3]) y = self.jit(lambda x: x)(x) self.assertIs(x, y) z1, z2 = self.jit(lambda x: (x, x))(x) self.assertIs(z1, z2) x1, x2 = jnp.array([1, 2]), jnp.array([2, 3]) z1, z2, z3 = self.jit(lambda x, y: (y, 1, x))(x1, x2) self.assertIs(z1, x2) self.assertIs(z3, x1) self.assertEqual(z2, 1) def test_jit_bad_input(self): def f(x): return x self.assertRaisesRegex( TypeError, ".* 'foo' of type <.*'str'> is not a valid JAX type", lambda: self.jit(f)("foo")) def test_jit_on_all_devices(self): # Verifies we can run the same computation on every device present, even # if they are, for example, different models of GPU. data = np.random.rand(1000).astype(np.float32) f = self.jit(jnp.negative) for device in jax.local_devices(): x = device_put(data, device=device) np.testing.assert_array_equal(-data, f(x)) def test_jit_nested_donate_ignored(self): jit_fun = self.jit(lambda x: self.jit(lambda y: y**2, donate_argnums=0)(x)) a = jax.device_put(jnp.array(1)) # NOTE(mattjj): stopped raising error here and instead just ignored # with self.assertRaisesRegex(ValueError, "nested.*not supported"): # jit_fun(a) jit_fun(a) # doesn't crash def test_jit_reference_dropping(self): x = jnp.ones(10) f = (lambda x: lambda: x)(x) # reference to x in f's closure g = self.jit(f) x = weakref.ref(x) # no more strong ref to x in this scope assert x() is not None # x is still around f() # f runs g() # g runs g() # g runs a second time del f # delete the raw callable assert x() is not None # x is still around g() # g still runs del g # no more references to x assert x() is None # x is gone def test_jit_raises_on_first_invocation_on_non_hashable_static_argnum(self): if self.jit != jax.api._python_jit: raise unittest.SkipTest("this test only applies to _python_jit") f = lambda x, y: x + 3 jitted_f = self.jit(f, static_argnums=(1,)) msg = ("Non-hashable static arguments are not supported, as this can lead " "to unexpected cache-misses. Static argument (index 1) of type " "<class 'numpy.ndarray'> for function <lambda> is non-hashable.") with self.assertRaisesRegex(ValueError, re.escape(msg)): jitted_f(1, np.asarray(1)) def test_cpp_jit_raises_on_non_hashable_static_argnum(self): if self.jit != jax.api._cpp_jit: raise unittest.SkipTest("this test only applies to _cpp_jit") f = lambda x, y: x + 3 jitted_f = jax.api._cpp_jit(f, static_argnums=[1]) jitted_f(1, 1) msg = ("Non-hashable static arguments are not supported. An error occured " "while trying to hash an object of type <class 'numpy.ndarray'>, 1. " "The error was:\nTypeError: unhashable type: 'numpy.ndarray'") with self.assertRaisesRegex(ValueError, re.escape(msg)): jitted_f(1, np.asarray(1)) class HashableWithoutEq: def __hash__(self): return 1 def __eq__(self, other): raise NotImplementedError( "A Python error is as is, without stack trace") with self.assertRaisesRegex( ValueError, re.escape("static arguments should be comparable using __eq__")): jitted_f(1, HashableWithoutEq()) def test_cpp_jitted_function_returns_PyBuffer(self): if self.jit != jax.api._cpp_jit: raise unittest.SkipTest("this test only applies to _cpp_jit") jitted_f = self.jit(lambda a: a + 1) jitted_f(1) self.assertIsInstance(jitted_f(2), xla._CppDeviceArray) @jtu.skip_on_devices("cpu") def test_explicit_backend(self): f = lambda x: x + 1 jitted_f = jit(f, backend=jtu.device_under_test()) jitted_f_cpu = jit(f, backend="cpu") result = jitted_f(1.) result_cpu = jitted_f_cpu(1.) self.assertEqual(result.device_buffer.platform(), jtu.device_under_test()) self.assertEqual(result_cpu.device_buffer.platform(), "cpu") @jtu.skip_on_devices("cpu") def test_mismatched_nested_backends(self): @partial(jit, backend=jtu.device_under_test()) def f(x): return jit(lambda x: x + 1, backend="cpu")(x) with self.assertRaisesRegex( ValueError, f"Outer-jit backend specification {jtu.device_under_test()} must match " f"explicit inner-jit backend specification cpu."): f(1.) def test_omnistaging(self): # See https://github.com/google/jax/issues/5206 if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") key_list = [None] def init(): key, subkey = jax.random.split(key_list[0]) key_list[0] = key return jax.random.normal(subkey, ()) key_list[0] = np.array([2384771982, 3928867769], dtype=np.uint32) init() self.jit(init)() self.assertIsInstance(key_list[0], core.Tracer) def test_jit_wrapped_attributes(self): def f(x: int) -> int: """docstring of f.""" return x + 1 f.some_value = 4 jf = self.jit(f) for attr in ["doc", "name", "module", "qualname", "annotations"]: self.assertEqual( {attr: getattr(f, f"__{attr}__")}, {attr: getattr(jf, f"__{attr}__")}) self.assertEqual(f.some_value, jf.some_value) class PythonJitTest(CPPJitTest): @property def jit(self): return jax.api._python_jit class APITest(jtu.JaxTestCase): def test_grad_bad_input(self): def f(x): return x self.assertRaisesRegex( TypeError, ".* 'foo' of type <.*'str'> is not a valid JAX type", lambda: grad(f)("foo")) def test_grad_argnums(self): def f(x, y, z, flag=False): assert flag return 1.0 * x + 2.0 * y + 3.0 * z assert grad(f)(1.0, 1.0, 1.0, flag=True) == 1.0 assert grad(f, argnums=1)(1.0, 1.0, 1.0, flag=True) == 2.0 assert grad(f, argnums=(2, 0))(1.0, 1.0, 1.0, flag=True) == (3.0, 1.0) def test_value_and_grad_argnums(self): def f(x, y, z, flag=False): assert flag return 1.0 * x + 2.0 * y + 3.0 * z y = f(1.0, 1.0, 1.0, flag=True) assert api.value_and_grad(f)(1.0, 1.0, 1.0, flag=True) == (y, 1.0) assert api.value_and_grad(f, argnums=1)(1.0, 1.0, 1.0, flag=True) == (y, 2.0) assert api.value_and_grad(f, argnums=(2, 0))(1.0, 1.0, 1.0, flag=True) == (y, (3.0, 1.0)) def test_grad_of_jit(self): side = [] @jit def f(x): side.append(None) return x * x assert grad(f)(1.0) == 2.0 assert len(side) == 1 assert grad(f)(2.0) == 4.0 assert len(side) == 1 def test_jit_of_grad(self): side = [] @jit def f(x): side.append(None) return x * x g = jit(grad(f)) assert g(1.0) == 2.0 assert len(side) == 1 assert g(2.0) == 4.0 assert len(side) == 1 def test_bad_input(self): def f(x): return x self.assertRaisesRegex( TypeError, ".* 'foo' of type <.*'str'> is not a valid JAX type", lambda: grad(f)("foo")) self.assertRaisesRegex( TypeError, ".* 'foo' of type <.*'str'> is not a valid JAX type", lambda: jit(f)("foo")) def test_grad_tuple_output(self): jtu.check_raises(lambda: grad(lambda x: (x,x))(1.0), TypeError, "Gradient only defined for scalar-output functions. ") def test_grad_unit_output(self): jtu.check_raises(lambda: grad(lambda x: ())(np.zeros(3)), TypeError, "Gradient only defined for scalar-output functions. ") def test_grad_nonscalar_output(self): jtu.check_raises(lambda: grad(lambda x: x)(np.zeros(3)), TypeError, "Gradient only defined for scalar-output functions. ") def test_unwrapped_numpy(self): def f(x): return np.exp(x) with self.assertRaisesRegex(Exception, "The numpy.ndarray conversion .*"): grad(f)(np.zeros(3)) def test_binop_mismatch(self): def f(x, y): return x + y jtu.check_raises( lambda: f(jnp.zeros(3), jnp.zeros(4)), TypeError, "add got incompatible shapes for broadcasting: (3,), (4,).") jtu.check_raises( lambda: grad(f)(np.zeros(3), np.zeros(4)), TypeError, "add got incompatible shapes for broadcasting: (3,), (4,).") def test_dot_mismatch(self): def f(x, y): return jnp.dot(x, y) self.assertRaisesRegex( TypeError, "Incompatible shapes for dot: got \\(3L?,\\) and \\(4L?,\\).", lambda: grad(f)(np.zeros(3), np.zeros(4))) def test_abstract_error_message(self): for castfun in [float, complex, int]: def f(x): return castfun(x) self.assertRaisesRegex( TypeError, f"[Tt]ry using `x.astype\\({castfun.__name__}\\)`", lambda: jit(f)(1.0)) def test_switch_value_jit(self): def f(x): y = x > 0 if y: return x else: return -x assert grad(f)(1.0) == 1.0 assert grad(f)(-1.0) == -1.0 with self.assertRaisesRegex(core.ConcretizationTypeError, "Abstract tracer value"): jit(f)(1) def test_list_index_err(self): L = [1, 2, 3] def f(n): return L[n] assert jit(f, static_argnums=(0,))(0) == L[0] self.assertRaisesRegex( TypeError, r"The __index__\(\) method was called on the JAX Tracer object.*", lambda: jit(f)(0)) def test_range_err(self): def f(x, n): for i in range(n): x = x + i return x assert jit(f, static_argnums=(1,))(0, 5) == 10 self.assertRaisesRegex( TypeError, r"The __index__\(\) method was called on the JAX Tracer object.*", lambda: jit(f)(0, 5)) def test_cast_int(self): f = lambda x: int(x) self.assertRaisesRegex( TypeError, "('(?:JaxprTracer|DynamicJaxprTracer)' object cannot be interpreted as an integer" "|Abstract tracer value encountered where concrete value is expected.*)", lambda: jit(f)(0)) def test_casts(self): for castfun in [hex, oct]: f = lambda x: castfun(x) self.assertRaisesRegex( TypeError, r"The __index__\(\) method was called on the JAX Tracer object.*", lambda: jit(f)(0)) def test_unimplemented_interpreter_rules(self): foo_p = Primitive('foo') def foo(x): return foo_p.bind(x) jtu.check_raises(lambda: foo(1.0), NotImplementedError, "Evaluation rule for 'foo' not implemented") jtu.check_raises(lambda: jit(foo)(1.0), NotImplementedError, "Abstract evaluation for 'foo' not implemented") jtu.check_raises(lambda: grad(foo)(1.0), NotImplementedError, "Differentiation rule for 'foo' not implemented") foo_p.def_abstract_eval(lambda x: x) jtu.check_raises(lambda: jit(foo)(1.0), NotImplementedError, "XLA translation rule for primitive 'foo' not found") foo_p.def_impl(lambda x: x) ad.defjvp(foo_p, lambda g, x: foo(g)) jtu.check_raises(lambda: grad(foo)(1.0), NotImplementedError, "Transpose rule (for reverse-mode differentiation) for 'foo' not implemented") def test_device_put_and_get(self): x = np.arange(12.).reshape((3, 4)).astype("float32") dx = api.device_put(x) self.assertIsInstance(dx, xla.DeviceArray) x2 = api.device_get(dx) self.assertIsInstance(x2, np.ndarray) assert np.all(x == x2) y = [x, (2 * x, 3 * x)] dy = api.device_put(y) y2 = api.device_get(dy) self.assertIsInstance(y2, list) self.assertIsInstance(y2[0], np.ndarray) assert np.all(y2[0] == x) self.assertIsInstance(y2[1], tuple) self.assertIsInstance(y2[1][0], np.ndarray) assert np.all(y2[1][0] == 2 * x) self.assertIsInstance(y2[1][1], np.ndarray) assert np.all(y2[1][1] == 3 * x) def test_device_get_scalar(self): x = np.arange(12.).reshape((3, 4)).astype("float32") x = api.device_put(x) self.assertIsInstance(x, xla.DeviceArray) y = [x, 2] y2 = api.device_get(y) self.assertIsInstance(y2, list) self.assertIsInstance(y2[0], np.ndarray) assert np.all(y2[0] == x) self.assertIsInstance(y2[1], int) self.assertEqual(y2[1], 2) @parameterized.parameters([(3,)], [(2, 0)]) def test_device_put_across_devices(self, shape): if len(api.local_devices()) < 2: raise unittest.SkipTest("this test requires multiple devices") d1, d2 = api.local_devices()[:2] data = np.random.randn(*shape).astype(np.float32) x = api.device_put(data, device=d1) self.assertEqual(x.device_buffer.device(), d1) y = api.device_put(x, device=d2) self.assertEqual(y.device_buffer.device(), d2) np.testing.assert_array_equal(data, np.array(y)) # Make sure these don't crash api.device_put(x) api.device_put(y) @jtu.skip_on_devices("cpu") def test_device_put_across_platforms(self): default_device = jax.devices()[0] cpu_device = jax.devices("cpu")[0] np_arr = np.array([1,2,3]) scalar = 1 device_arr = jnp.array([1,2,3]) assert device_arr.device_buffer.device() is default_device for val in [np_arr, device_arr, scalar]: x = api.device_put(val, device=cpu_device) self.assertEqual(x.device_buffer.device(), cpu_device) @jtu.skip_on_devices("tpu") def test_jacobian(self): R = np.random.RandomState(0).randn A = R(4, 3) x = R(3) f = lambda x: jnp.dot(A, x) assert np.allclose(jacfwd(f)(x), A) assert np.allclose(jacrev(f)(x), A) f = lambda x: jnp.tanh(jnp.dot(A, x)) assert np.allclose(jacfwd(f)(x), jacrev(f)(x)) @jtu.skip_on_devices("tpu") def test_hessian(self): R = np.random.RandomState(0).randn A = R(4, 4) x = R(4) f = lambda x: jnp.dot(x, jnp.dot(A, x)) assert np.allclose(hessian(f)(x), A + A.T) def test_std_basis(self): basis = api._std_basis(jnp.zeros(3)) assert getattr(basis, "shape", None) == (3, 3) assert np.allclose(basis, np.eye(3)) basis = api._std_basis(jnp.zeros((3, 3))) assert getattr(basis, "shape", None) == (9, 3, 3) assert np.allclose(basis, np.eye(9).reshape(9, 3, 3)) basis = api._std_basis([0., (jnp.zeros(3), jnp.zeros((3, 4)))]) assert isinstance(basis, list) and len(basis) == 2 assert getattr(basis[0], "shape", None) == (16,) assert isinstance(basis[1], tuple) and len(basis[1]) == 2 assert getattr(basis[1][0], "shape", None) == (16, 3) assert getattr(basis[1][1], "shape", None) == (16, 3, 4) @jtu.skip_on_devices("tpu") def test_jacobian_on_pytrees(self): for jacfun in [jacfwd, jacrev]: ans = jacfun(lambda x, y: (x, y))(0., 1.) expected = (1., 0.) self.assertAllClose(ans, expected, check_dtypes=False) ans = jacfun(lambda x, y: (x, y), 1)(0., 1.) expected = (0., 1.) self.assertAllClose(ans, expected, check_dtypes=False) ans = jacfun(lambda x, y: (x, y), (0, 1))(0., 1.) expected = ((1., 0.), (0., 1.),) self.assertAllClose(ans, expected, check_dtypes=False) ans = jacfun(lambda x: x[:2])((1., 2., 3.)) expected = ((1., 0., 0.), (0., 1., 0.)) self.assertAllClose(ans, expected, check_dtypes=False) R = np.random.RandomState(0).randn x = R(2) y = R(3) ans = jacfun(lambda x, y: {'x': x, 'xy': jnp.outer(x, y)})(x, y) expected = {'x': np.eye(2), 'xy': np.kron(np.eye(2), y[:, None]).reshape(2, 3, 2)} self.assertAllClose(ans, expected, check_dtypes=False) @jtu.skip_on_devices("tpu") def test_hessian_on_pytrees(self): ans = hessian(lambda x: jnp.array(x)**2)((1., 2.)) expected = ((np.array([2., 0.]), np.array([0., 0.])), (np.array([0., 0.]), np.array([0., 2.]))) self.assertAllClose(ans, expected, check_dtypes=False) @jtu.skip_on_devices("tpu") def test_issue1372(self): def quad(x): return jnp.dot(x, x) def f(x, u): return quad(x) + quad(u) x, u = jnp.ones(5), jnp.ones(2) rev = jacrev fwd = jacfwd # Diagonal entries self.assertEqual(rev(rev(f, 0), 0)(x, u).shape, (5, 5)) self.assertEqual(rev(fwd(f, 0), 0)(x, u).shape, (5, 5)) self.assertEqual(fwd(rev(f, 0), 0)(x, u).shape, (5, 5)) self.assertEqual(fwd(fwd(f, 0), 0)(x, u).shape, (5, 5)) self.assertEqual(rev(rev(f, 1), 1)(x, u).shape, (2, 2)) self.assertEqual(rev(fwd(f, 1), 1)(x, u).shape, (2, 2)) self.assertEqual(fwd(rev(f, 1), 1)(x, u).shape, (2, 2)) self.assertEqual(fwd(fwd(f, 1), 1)(x, u).shape, (2, 2)) # Off-diagonal entries by reverse-mode on the outside self.assertEqual(rev(rev(f, 1), 0)(x, u).shape, (2, 5)) self.assertEqual(rev(fwd(f, 1), 0)(x, u).shape, (2, 5)) self.assertEqual(rev(rev(f, 0), 1)(x, u).shape, (5, 2)) self.assertEqual(rev(fwd(f, 0), 1)(x, u).shape, (5, 2)) # Off-diagonal entries by forward-mode on the outside self.assertEqual(fwd(rev(f, 1), 0)(x, u).shape, (2, 5)) self.assertEqual(fwd(fwd(f, 1), 0)(x, u).shape, (2, 5)) self.assertEqual(fwd(rev(f, 0), 1)(x, u).shape, (5, 2)) self.assertEqual(fwd(fwd(f, 0), 1)(x, u).shape, (5, 2)) def test_large_device_constant(self): ans = jit(lambda x: 2 * x)(jnp.ones(int(2e6))) # doesn't crash self.assertAllClose(ans, np.ones(int(2e6)) * 2., check_dtypes=False) def test_grad_and_aux_basic(self): g, aux = grad(lambda x: (x**3, [x**2]), has_aux=True)(3.) self.assertAllClose(g, grad(lambda x: x**3)(3.)) self.assertAllClose(aux, [9.], check_dtypes=False) def test_grad_and_aux_error(self): with self.assertRaisesRegex(TypeError, "two-element tuple"): grad(lambda x: (1, 2, 3), has_aux=True)(1.) with self.assertRaisesRegex(TypeError, "two-element tuple"): grad(lambda x: x, has_aux=True)(1.) with self.assertRaisesRegex(TypeError, "two-element tuple"): grad(lambda x: (x,), has_aux=True)(1.) def test_grad_and_aux_nested(self): def f(x): g, aux = grad(lambda x: (x**3, [x**3]), has_aux=True)(x) return aux[0] f2 = lambda x: x**3 self.assertEqual(grad(f)(4.), grad(f2)(4.)) self.assertEqual(jit(grad(f))(4.), grad(f2)(4.)) self.assertEqual(jit(grad(jit(f)))(4.), grad(f2)(4.)) def f(x): g, aux = grad(lambda x: (x**3, [x**3]), has_aux=True)(x) return aux[0] * jnp.sin(x) f2 = lambda x: x**3 * jnp.sin(x) self.assertEqual(grad(f)(4.), grad(f2)(4.)) self.assertEqual(jit(grad(f))(4.), grad(f2)(4.)) self.assertEqual(jit(grad(jit(f)))(4.), grad(f2)(4.)) def test_grad_and_aux_constant(self): g, aux = grad(lambda x: (x**3, [4.]), has_aux=True)(4.) self.assertEqual(g, grad(lambda x: x**3)(4.)) self.assertEqual(aux, [4.]) g, aux = grad(lambda x: (x**3, [x**2, 4.]), has_aux=True)(4.) self.assertEqual(g, grad(lambda x: x**3)(4.)) self.assertEqual(aux, [4.**2, 4.]) def test_grad_and_aux_no_tracers(self): # see https://github.com/google/jax/issues/1950 def f(x): aux = dict(identity=x, p1=x+1) return x ** 2, aux _, aux = jax.grad(f, has_aux=True)(3.) self.assertIsInstance(aux, dict) for val in aux.values(): self.assertNotIsInstance(val, core.Tracer) def test_jvp_mismatched_arguments(self): self.assertRaisesRegex( TypeError, ("primal and tangent arguments to jax.jvp must have the same tree " "structure"), lambda: api.jvp(lambda x, y: x * y, (np.float32(2),), ())) # If primals and tangents must both be tuples or both lists self.assertRaisesRegex( TypeError, ("primal and tangent arguments to jax.jvp must have the same tree " "structure"), lambda: api.jvp(lambda x, y: x * y, (np.float32(2),), [np.float32(2)])) self.assertRaisesRegex( TypeError, "primal and tangent arguments to jax.jvp do not match.", lambda: api.jvp(lambda x: -x, (np.float16(2),), (np.float32(4),))) # If primals and tangents are not of the same shape then raise error fun = lambda x: x+1 with self.assertRaisesRegex( ValueError, "jvp called with different primal and tangent shapes"): api.jvp(fun, (jnp.array([1.,2.,3.]),), (jnp.array([1.,2.,3.,4.]),)) with self.assertRaisesRegex( ValueError, "jvp called with different primal and tangent shapes"): api.jvp(fun, (jnp.float32(10.),), (jnp.array([1.,2.,3.], dtype=jnp.float32),)) with self.assertRaisesRegex( ValueError, "jvp called with different primal and tangent shapes"): api.jvp(fun, (jnp.array([1.,2.,3.], dtype=jnp.float32),), (jnp.float32(20.),)) with self.assertRaisesRegex( ValueError, "jvp called with different primal and tangent shapes"): api.jvp(fun, (jnp.array([1.,2.,3.]),), (20.,)) def test_jvp_non_tuple_arguments(self): def f(x, y): return x + y self.assertRaisesRegex( TypeError, "primal and tangent arguments to jax.jvp must be tuples or lists; found float and tuple.", lambda: api.jvp(f, 0., (1.,))) self.assertRaisesRegex( TypeError, "primal and tangent arguments to jax.jvp must be tuples or lists; found tuple and ndarray.", lambda: api.jvp(f, (0.,), np.array([1., 2.]))) def test_vjp_mismatched_arguments(self): _, pullback = api.vjp(lambda x, y: x * y, np.float32(3), np.float32(4)) self.assertRaisesRegex( TypeError, "Tree structure of cotangent input.*does not match", lambda: pullback((np.float32(7), np.float32(100)))) self.assertRaisesRegex( TypeError, "Type of cotangent input to vjp pullback.*is not the expected tangent type", lambda: pullback((np.float16(42)))) def test_jvp_jit_cached(self): """Bug in caching in presence of JVP and JIT.""" def func(x): def inner(y): return y * x # Must have two calls to the inner jit (the second one hits the cache) res1 = api.jit(inner)(4.) res2 = api.jit(inner)(5.) return res1 + res2 self.assertAllClose((45., 9.), api.jvp(func, (5.,), (1.,))) def test_linear_transpose_abstract(self): x = types.SimpleNamespace(shape=(3,), dtype=np.float32) y = jnp.arange(3, dtype=np.float32) transpose_fun = api.linear_transpose(lambda x: 2 * x, x) z, = transpose_fun(y) self.assertArraysEqual(2 * y, z, check_dtypes=True) def test_linear_transpose_error(self): with self.assertRaisesRegex( TypeError, "linear_transpose only supports float and complex inputs"): api.linear_transpose(lambda x: x, 1) transpose_fun = api.linear_transpose(lambda x: [x, x], 1.0) with self.assertRaisesRegex(TypeError, "cotangent tree does not match"): transpose_fun(1.0) transpose_fun = api.linear_transpose(lambda x: jnp.stack([x, x]), 1.0) with self.assertRaisesRegex(TypeError, "cotangent type does not match"): transpose_fun(1.0) transpose_fun = api.linear_transpose(lambda x: 1j * x, 1.0) with self.assertRaisesRegex(TypeError, "cotangent type does not match"): transpose_fun(1.0) transpose_fun = api.linear_transpose(lambda x: x, 1.0) with self.assertRaisesRegex(TypeError, "cotangent type does not match"): transpose_fun(1j) def test_linear_transpose_complex(self): f = lambda x: (1 + 2j) * x transpose = api.linear_transpose(f, 1j) actual, = transpose(3 + 4j) expected = -5 + 10j self.assertEqual(actual, expected) def test_complex_grad_raises_error(self): self.assertRaises(TypeError, lambda: grad(lambda x: jnp.sin(x))(1 + 2j)) def test_holomorphic_grad(self): out = grad(lambda x: jnp.sin(x), holomorphic=True)(1 + 2j) expected = 2.0327230070196656 - 3.0518977991518j self.assertAllClose(out, expected, check_dtypes=False) def test_nonholomorphic_grad(self): zs = 0.5j * np.arange(5) + np.arange(5) def f(z): return jnp.sum(jnp.cos(jnp.abs(z))) ans = grad(f)(zs) expected = np.array([ 0. +0.j, -0.80430663+0.40215331j, -0.70368982+0.35184491j, 0.1886467 -0.09432335j, 0.86873727-0.43436864j]) self.assertAllClose(ans, expected, check_dtypes=False, atol=jtu.default_gradient_tolerance, rtol=jtu.default_gradient_tolerance) def test_complex_output_jacrev_raises_error(self): self.assertRaises(TypeError, lambda: jacrev(lambda x: jnp.sin(x))(1 + 2j)) def test_nonholomorphic_jacrev(self): # code based on https://github.com/google/jax/issues/603 zs = 0.5j * np.arange(5) + np.arange(5) def f(z): return jnp.cos(jnp.linalg.norm(2 * z)) ans = jacrev(f)(zs) expected = grad(f)(zs) self.assertAllClose(ans, expected) def test_complex_input_jacfwd_raises_error(self): self.assertRaises(TypeError, lambda: jacfwd(lambda x: jnp.sin(x))(1 + 2j)) def test_legacy_devicearray_repr(self): dx = device_put(3.) str(dx.item()) # doesn't crash def test_devicearray_repr(self): x = device_put(jnp.zeros(3)) self.assertIsInstance(x, xla.DeviceArray) repr(x) # doesn't crash x = device_put(jnp.ones(3) + 1j * jnp.ones(3)) self.assertIsInstance(x, xla.DeviceArray) repr(x) # doesn't crash def test_devicearray_delete(self): x = device_put(1.) x.delete() self.assertRaisesRegex(RuntimeError, "DeviceArray has been deleted.", lambda: repr(x)) def test_devicearray_block_until_ready(self): x = device_put(1.) y = x.block_until_ready() # Tests mostly that block_until_ready() does not produce an error. self.assertTrue(y is x) def test_devicearray_weakref_friendly(self): x = device_put(1.) y = weakref.ref(x) self.assertEqual(y(), 1.) del x self.assertIsNone(y()) def test_namedtuple_transparency(self): # See https://github.com/google/jax/issues/446 Point = collections.namedtuple("Point", ["x", "y"]) def f(pt): return jnp.sqrt(pt.x ** 2 + pt.y ** 2) pt = Point(1., 2.) f(pt) # doesn't crash g = api.grad(f)(pt) self.assertIsInstance(g, Point) f_jit = api.jit(f) self.assertAllClose(f(pt), f_jit(pt), check_dtypes=False) def test_namedtuple_subclass_transparency(self): # See https://github.com/google/jax/issues/806 Point = collections.namedtuple("Point", ["x", "y"]) class ZeroPoint(Point): def is_zero(self): return (self.x == 0) and (self.y == 0) pt = ZeroPoint(0., 0.) def f(pt): return 0. if pt.is_zero() else jnp.sqrt(pt.x ** 2 + pt.y ** 2) f(pt) # doesn't crash _ = api.grad(f)(pt) self.assertIsInstance(pt, ZeroPoint) @parameterized.parameters(1, 2, 3) def test_shape_dtype_struct(self, i): s = api.ShapeDtypeStruct(shape=(i, 2, 3), dtype=jnp.float32) self.assertEqual(s.shape, (i, 2, 3)) self.assertEqual(s.dtype, jnp.float32) self.assertEqual(s.ndim, 3) self.assertEqual(s.size, i * 2 * 3) self.assertLen(s, i) for f in (str, repr): self.assertEqual( f(s), "ShapeDtypeStruct(shape=({}, 2, 3), dtype=float32)".format(i)) def test_shape_dtype_struct_scalar(self): s = api.ShapeDtypeStruct(shape=(), dtype=jnp.float32) self.assertEmpty(s.shape) self.assertEqual(s.size, 1) self.assertEqual(s.ndim, 0) with self.assertRaisesRegex(TypeError, "len[(][)] of unsized object"): _ = len(s) def test_eval_shape(self): def fun(x, y): return jnp.tanh(jnp.dot(x, y) + 3.) x = jnp.ones((2, 3)) y = jnp.ones((3, 4)) out_shape = api.eval_shape(fun, x, y) self.assertEqual(out_shape.shape, (2, 4)) def test_eval_shape_constants(self): def fun(): x = jnp.ones((2, 3)) y = jnp.ones((3, 4)) return jnp.tanh(jnp.dot(x, y) + 3.) out_shape = api.eval_shape(fun) self.assertEqual(out_shape.shape, (2, 4)) def test_eval_shape_tuple_unpacking(self): def fun(x, y): a, b = x return a + b + y x = (jnp.ones(2), jnp.ones(2)) y = 3. out_shape = api.eval_shape(fun, x, y) self.assertEqual(out_shape.shape, (2,)) def test_eval_shape_tuple_itemgetting(self): def fun(x, y): return x[0] + x[1] + y x = (jnp.ones(2), jnp.ones(2)) y = 3. out_shape = api.eval_shape(fun, x, y) self.assertEqual(out_shape.shape, (2,)) def test_eval_shape_output_dict(self): def fun(x, y): return {'hi': x[0] + x[1] + y} x = (jnp.ones(2), jnp.ones(2)) y = 3. out_shape = api.eval_shape(fun, x, y) out_shape = tree_util.tree_map(np.shape, out_shape) self.assertEqual(out_shape, {'hi': (2,)}) def test_eval_shape_shape_error(self): def fun(x, y): return jnp.tanh(jnp.dot(x, y) + 3.) x = jnp.ones((3, 3)) y = jnp.ones((4, 4)) self.assertRaises(TypeError, lambda: api.eval_shape(fun, x, y)) def test_eval_shape_duck_typing(self): def fun(A, b, x): return jnp.dot(A, x) + b class MyArgArray(object): def __init__(self, shape, dtype): self.shape = shape self.dtype = dtype A = MyArgArray((3, 4), jnp.float32) b = MyArgArray((5,), jnp.float32) x = MyArgArray((4, 5), jnp.float32) out_shape = api.eval_shape(fun, A, b, x) self.assertEqual(out_shape.shape, (3, 5)) def test_eval_shape_duck_typing2(self): # https://github.com/google/jax/issues/5683 class EasyDict(dict): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.__dict__ = self x = EasyDict(shape=(3,), dtype=np.dtype('float32')) out_shape = api.eval_shape(lambda x: x, x) # doesn't crash self.assertEqual(out_shape.shape, (3,)) def test_eval_shape_names(self): def fun(x, y): return lax.psum(x, 'i') + y class MyArgArray(object): def __init__(self, shape, dtype, named_shape): self.shape = shape self.dtype = dtype self.named_shape = named_shape x = MyArgArray((3, 2), jnp.float32, {'i': 10}) y = MyArgArray((3, 2), jnp.float32, {'j': 5}) with core.extend_axis_env('i', 10, None): with core.extend_axis_env('j', 5, None): out_shape = api.eval_shape(fun, x, y) self.assertEqual(out_shape.named_shape, {'j': 5}) def test_issue_871(self): T = jnp.array([[1., 2.], [3., 4.], [5., 6.]]) x = jnp.array([1, 2, 3]) msg = ("linearized function called on tangent values inconsistent with " "the original primal values") y, f_jvp = api.linearize(jnp.sum, x) with self.assertRaisesRegex(ValueError, msg): f_jvp(T) y, f_jvp = api.linearize(api.jit(jnp.sum), x) with self.assertRaisesRegex(ValueError, msg): f_jvp(T) def test_partial_eval_lower(self): # this is a simplified model of a bug that arose when we first used @jit in # a jvp rule. it's in this file because we want to use make_jaxpr. # NOTE(mattjj): I no longer understand what this was meant to test. My guess # is it was related to staging out the broadcast into a jaxpr to be # transposed, but after #1749 that's no longer a problem. After changing # make_jaxpr (and jit) to stage out sub-calls fully, this test started to # fail; I left it in as skipped because deleting tests feels wrong. raise unittest.SkipTest("obsolete test") @api.jit def f(a, b, c): a = lax.broadcast(a, (2,)) return lax.select(a, b, c) a = np.ones((3, 3), dtype=np.bool_) b = np.ones((2, 3, 3)) c = np.ones((2, 3, 3)) jaxpr = api.make_jaxpr(lambda b, c: f(a, b, c))(b, c) subjaxpr = next(eqn.params["call_jaxpr"] for eqn in jaxpr.jaxpr.eqns if "call_jaxpr" in eqn.params) self.assertEqual(len(subjaxpr.eqns), 1) def test_grad_of_int_errors(self): # Errors without allow_int=True dfn = grad(lambda x: x ** 2) self.assertRaisesRegex( TypeError, (r"grad requires real- or complex-valued inputs \(input dtype that is a " r"sub-dtype of np.floating or np.complexfloating\), but got int.*."), lambda: dfn(3)) def test_jvp_of_int_identity(self): primals = (1,) tangents = (np.zeros(shape=(), dtype=float0),) _, out = api.jvp(lambda x: x, primals, tangents) self.assertEqual(out, np.zeros(shape=(), dtype=float0)) def test_jvp_of_int_add(self): primals = (2,) tangents = (np.zeros(shape=(), dtype=float0),) _, out_tangent = api.jvp(lambda x: x+1, primals, tangents) self.assertEqual(out_tangent, np.zeros(shape=(), dtype=float0)) def test_jit_jvp_of_int(self): primals = (2,) tangents = (np.zeros(shape=(), dtype=float0),) _, out_tangent = api.jvp(jax.jit(lambda x: x+1), primals, tangents) self.assertEqual(out_tangent, np.zeros(shape=(), dtype=float0)) def test_vjp_of_int_index(self): primal, fn_vjp = api.vjp(lambda x, i: x[i], np.ones(2)*2, 1) tangent_x, tangent_i = fn_vjp(1.) self.assertEqual(primal, 2.) self.assertAllClose(tangent_x, jnp.array([0., 1.])) self.assertEqual(tangent_i, np.zeros(shape=(), dtype=float0)) def test_vjp_of_int_shapes(self): out, fn_vjp = api.vjp(lambda x: lax.reshape(x, (2, 2)), np.ones((4, 1), dtype=int)) tangent, = fn_vjp(out) self.assertArraysEqual(tangent, np.zeros(shape=(4, 1), dtype=float0)) def test_jit_vjp_of_int(self): primal, fn_vjp = api.vjp(lambda x, y: x+y, 2, 1) tangent_x, tangent_i = jax.jit(fn_vjp)(1) self.assertEqual(primal, 3) self.assertEqual(tangent_x, np.zeros(shape=(), dtype=float0)) self.assertEqual(tangent_i, np.zeros(shape=(), dtype=float0)) def test_vjp_of_int_fulllike(self): # Regression test for tangent and cotangent mismatch in convert_element_type # transpose rule wrt a ConstVar f = lax.full_like out, vjp = api.vjp(f, np.zeros((2, 2)), 1) self.assertAllClose(out, jnp.ones((2, 2))) tangent_x, tangent_y = vjp(out) self.assertAllClose(tangent_x, jnp.zeros((2, 2))) self.assertEqual(tangent_y, np.zeros(shape=(), dtype=float0)) def test_grad_of_int(self): # Need real-valued output, but testing integer input. out = api.grad(lambda x: x+0., allow_int=True)(1) self.assertEqual(out, np.zeros(shape=(), dtype=float0)) def test_grad_of_bool(self): def cond(pred): return lax.cond(pred, lambda _: 1., lambda _: 2., 1.) value, grd = api.value_and_grad(cond, allow_int=True)(True) self.assertEqual(value, 1.) self.assertEqual(grd, np.zeros(shape=(), dtype=float0)) def test_grad_of_int_index(self): grad_x, grad_i = api.grad(lambda x, i: x[i], argnums=(0, 1), allow_int=True)(np.ones(2), 1) self.assertAllClose(grad_x, jnp.array([0., 1.])) self.assertEqual(grad_i, np.zeros(shape=(), dtype=float0)) def test_jit_grad_of_int(self): grad_f = api.grad(lambda x, i: x[i], argnums=(0, 1), allow_int=True) grad_x, grad_i = jax.jit(grad_f)(np.ones(2), 1) self.assertAllClose(grad_x, jnp.array([0., 1.])) self.assertEqual(grad_i, np.zeros(shape=(), dtype=float0)) def test_float0_reshape(self): # dtype-agnostic operations are supported float0_array = jax.grad(lambda x: jnp.sum(x+0.), allow_int=True)(np.ones((2, 4), dtype=int)) self.assertArraysEqual(float0_array.reshape((4, 2)), np.zeros((4, 2), dtype=float0)) self.assertArraysEqual(float0_array.transpose(), np.zeros((4, 2), dtype=float0)) def test_float0_error(self): # float0 is incompatible with other dtypes float0_array = jax.grad(lambda x: x+0., allow_int=True)(1) error_text = "float0s do not support any operations by design" with self.assertRaisesRegex(TypeError, error_text): # dispatch via DeviceArray _ = float0_array + jnp.zeros(()) with self.assertRaisesRegex(TypeError, error_text): # dispatch via lax _ = lax.add(float0_array, jnp.zeros(())) def test_grad_complex_result_errors(self): dfn = grad(lambda x: x ** 2 + 1j) self.assertRaisesRegex( TypeError, (r"grad requires real-valued outputs \(output dtype that is a " r"sub-dtype of np.floating\), but got complex.*"), lambda: dfn(3.)) def test_holomorphic_grad_of_float_errors(self): dfn = grad(lambda x: x ** 2, holomorphic=True) self.assertRaisesRegex( TypeError, (r"grad with holomorphic=True requires inputs with complex dtype, " r"but got float.*"), lambda: dfn(3.)) def test_holomorphic_jacrev_of_float_errors(self): dfn = jacrev(lambda x: x ** 2, holomorphic=True) self.assertRaisesRegex( TypeError, (r"jacrev with holomorphic=True requires inputs with complex dtype, " r"but got float.*"), lambda: dfn(3.)) def test_holomorphic_jacfwd_of_float_errors(self): dfn = jacfwd(lambda x: x ** 2, holomorphic=True) self.assertRaisesRegex( TypeError, (r"jacfwd with holomorphic=True requires inputs with complex dtype, " r"but got float.*"), lambda: dfn(3.)) def test_jacfwd_of_complex_errors(self): dfn = jacfwd(lambda x: x ** 2) self.assertRaisesRegex( TypeError, (r"jacfwd requires real-valued inputs \(input dtype that is a " r"sub-dtype of np.floating\), but got complex.*"), lambda: dfn(3. + 1j)) def test_xla_computation(self): # these tests basically check the examples in the xla_computation docstring def e(x): return jnp.sin(jnp.cos(x)) c = api.xla_computation(e)(2.) self.assertIn('cosine', c.as_hlo_text()) self.assertIn('sine', c.as_hlo_text()) def f(x): return x - lax.psum(x, 'i') axis_env = [('i', 4)] c = api.xla_computation(f, axis_env=axis_env)(2) self.assertIn('all-reduce', c.as_hlo_text()) self.assertIn('replica_groups={{0,1,2,3}}', c.as_hlo_text()) def g(x): rowsum = lax.psum(x, 'i') colsum = lax.psum(x, 'j') allsum = lax.psum(x, ('i', 'j')) return rowsum, colsum, allsum axis_env = [('i', 4), ('j', 2)] c = api.xla_computation(g, axis_env=axis_env)(5.) self.assertIn('all-reduce', c.as_hlo_text()) self.assertIn('replica_groups={{0,2,4,6},{1,3,5,7}}', c.as_hlo_text()) self.assertIn('replica_groups={{0,1},{2,3},{4,5},{6,7}}', c.as_hlo_text()) self.assertIn('replica_groups={{0,1,2,3,4,5,6,7}}', c.as_hlo_text()) def h(x): rowsum = lax.psum(x, 'i', axis_index_groups=[[0, 1], [2, 3]]) colsum = lax.psum(x, 'j') return rowsum, colsum axis_env = [('i', 4), ('j', 2)] c = api.xla_computation(h, axis_env=axis_env)(5.) self.assertIn('all-reduce', c.as_hlo_text()) self.assertIn('replica_groups={{0,2},{4,6},{1,3},{5,7}}', c.as_hlo_text()) self.assertIn('replica_groups={{0,1},{2,3},{4,5},{6,7}}', c.as_hlo_text()) def test_xla_computation_args(self): def foo(x, y, z): return x + y + z c = api.xla_computation(foo)(1., 2., 3.) self.assertEqual(len(c.program_shape().parameter_shapes()), 3) c = api.xla_computation(foo, tuple_args=True)(1., 2., 3.) param_shapes = c.program_shape().parameter_shapes() self.assertEqual(len(param_shapes), 1) self.assertEqual(param_shapes[0].xla_element_type(), xb.xla_client.PrimitiveType.TUPLE) def test_xla_computation_duck_typing(self): def foo(x, y, z): return x + y + z x = jax.ShapeDtypeStruct((), np.float32) y = jax.ShapeDtypeStruct((), np.float32) z = jax.ShapeDtypeStruct((), np.float32) c = api.xla_computation(foo)(x, y, z) self.assertEqual(len(c.program_shape().parameter_shapes()), 3) c = api.xla_computation(foo, tuple_args=True)(1., 2., 3.) param_shapes = c.program_shape().parameter_shapes() self.assertEqual(len(param_shapes), 1) self.assertEqual(param_shapes[0].xla_element_type(), xb.xla_client.PrimitiveType.TUPLE) def test_staging_out_multi_replica(self): def f(x): return api.pmap(jnp.mean)(x) xla_comp = api.xla_computation(f) xla_comp(jnp.arange(8)).as_hlo_text() # doesn't crash def test_xla_computation_instantiate_constant_outputs(self): def f(): return jnp.zeros((3, 4)) if config.omnistaging_enabled: xla_comp = api.xla_computation(f)() else: xla_comp = api.xla_computation(f, instantiate_const_outputs=True)() out_shape, = xla_comp.program_shape().result_shape().tuple_shapes() self.assertEqual(out_shape.dimensions(), (3, 4)) def test_xla_computation_static_argnums(self): def f(x, y): return x + y xla_comp = api.xla_computation(f, static_argnums=(1,))(2, 3) hlo_text = xla_comp.as_hlo_text() self.assertIn("constant(3)", hlo_text) # The static arguments should be removed from the function being compiled, # thus the function should have only a single argument. self.assertIn("parameter.1", hlo_text) self.assertNotIn("parameter.2", hlo_text) def test_xla_computation_return_shape(self): _, shape_tree = api.xla_computation(lambda x: (x + 1, jnp.zeros(2, jnp.float32)), return_shape=True)(np.int32(1)) expected = (api.ShapeDtypeStruct(shape=(), dtype=jnp.int32), api.ShapeDtypeStruct(shape=(2,), dtype=jnp.float32)) self.assertEqual(shape_tree, expected) def test_xla_computation_partitioned(self): def f(x, y): return jnp.dot(x, y) + 1 x = jax.ShapeDtypeStruct((8, 8), np.float32) y = jax.ShapeDtypeStruct((8, 16), np.float32) xla_comp = api.xla_computation(f, in_parts=(P(2, 2), None), out_parts=P(4, 1))(x, y) hlo_text = xla_comp.as_hlo_text() self.assertIn('sharding={devices=[2,2]0,1,2,3}', hlo_text) self.assertIn('sharding={replicated}', hlo_text) self.assertIn('sharding={{devices=[4,1]0,1,2,3}}', hlo_text) def test_xla_computation_replicated_and_partitioned(self): def f(x, y): return jnp.dot(x, y), lax.psum(x, 'i') x = jax.ShapeDtypeStruct((8, 8), np.float32) y = jax.ShapeDtypeStruct((8, 16), np.float32) axis_env = [('i', 4)] xla_comp = api.xla_computation(f, axis_env=axis_env, in_parts=(P(2, 2), None), out_parts=(P(4, 1), None))(x, y) hlo_text = xla_comp.as_hlo_text() self.assertIn('all-reduce', hlo_text) self.assertIn('replica_groups={{0,1,2,3}}', hlo_text) self.assertIn('sharding={devices=[2,2]0,1,2,3}', hlo_text) self.assertIn('sharding={replicated}', hlo_text) self.assertIn('sharding={{devices=[4,1]0,1,2,3}, {replicated}}', hlo_text) def test_xla_computation_psum_constant(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test requires omnistaging") f = lambda: jax.lax.psum(1, "i") api.xla_computation(f, axis_env=[("i", 2)])() # doesn't crash @jtu.skip_on_devices("cpu", "gpu") @jtu.ignore_warning(message="Some donated buffers were not usable") def test_xla_computation_donate_argnums(self): api.xla_computation(lambda x: None, donate_argnums=(0,))(3) # doesn't crash def test_concurrent_device_get_and_put(self): def f(x): for _ in range(100): y = jax.device_put(x) x = jax.device_get(y) return x xs = [np.random.randn(i) for i in range(10)] with concurrent.futures.ThreadPoolExecutor() as executor: futures = [executor.submit(partial(f, x)) for x in xs] ys = [f.result() for f in futures] for x, y in zip(xs, ys): self.assertAllClose(x, y) def test_dtype_warning(self): # cf. issue #1230 if config.x64_enabled: raise unittest.SkipTest("test only applies when x64 is disabled") def check_warning(warn, nowarn): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") nowarn() # get rid of extra startup warning prev_len = len(w) nowarn() assert len(w) == prev_len warn() assert len(w) > 0 msg = str(w[-1].message) expected_prefix = "Explicitly requested dtype " self.assertEqual(expected_prefix, msg[:len(expected_prefix)]) prev_len = len(w) nowarn() assert len(w) == prev_len check_warning(lambda: jnp.array([1, 2, 3], dtype="float64"), lambda: jnp.array([1, 2, 3], dtype="float32")) check_warning(lambda: jnp.array([1, 2, 3], dtype="float64"), lambda: jnp.array([1, 2, 3], dtype=float)) check_warning(lambda: jnp.ones(3, dtype=np.float64), lambda: jnp.ones(3)) check_warning(lambda: jnp.ones(3, dtype=np.float64), lambda: jnp.ones(3, dtype=float)) check_warning(lambda: jnp.ones_like(3, dtype=np.int64), lambda: jnp.ones_like(3, dtype=np.int32)) check_warning(lambda: jnp.zeros(3, dtype="int64"), lambda: jnp.zeros(3, dtype="int32")) check_warning(lambda: jnp.zeros_like(3, dtype="float64"), lambda: jnp.zeros_like(3, dtype="float32")) check_warning(lambda: jnp.full((2, 3), 1, dtype="int64"), lambda: jnp.full((2, 3), 1)) check_warning(lambda: jnp.ones(3).astype("float64"), lambda: jnp.ones(3).astype("float32")) check_warning(lambda: jnp.eye(3, dtype=np.float64), lambda: jnp.eye(3)) check_warning(lambda: jnp.arange(3, dtype=np.float64), lambda: jnp.arange(3, dtype=np.float32)) check_warning(lambda: jnp.linspace(0, 3, dtype=np.float64), lambda: jnp.linspace(0, 3, dtype=np.float32)) check_warning(lambda: jnp.tri(2, dtype="float64"), lambda: jnp.tri(2, dtype="float32")) check_warning(lambda: jnp.arange(1).astype("float64"), lambda: jnp.arange(1).astype(float)) check_warning(lambda: jnp.arange(1.0).astype("int64"), lambda: jnp.arange(1.0).astype(int)) def test_vmap_preserves_docstr(self): def superfun(a): """Does things with stuff.""" pass self.assertRegex(api.vmap(superfun).__doc__, "\n".join([ "Vectorized version of superfun.*", "", "Original documentation:", "", superfun.__doc__, ])) def test_vmap_in_axes_list(self): # https://github.com/google/jax/issues/2367 dictionary = {'a': 5., 'b': jnp.ones(2)} x = jnp.zeros(3) y = jnp.arange(3.) def f(dct, x, y): return dct['a'] + dct['b'] + x + y out1 = api.vmap(f, (None, 0, 0))(dictionary, x, y) out2 = api.vmap(f, [None, 0, 0])(dictionary, x, y) self.assertAllClose(out1, out2) def test_vmap_in_axes_tree_prefix_error(self): # https://github.com/google/jax/issues/795 self.assertRaisesRegex( ValueError, "vmap in_axes specification must be a tree prefix of the corresponding " r"value, got specification \(0, 0\) for value tree " r"PyTreeDef\(tuple, \[\*\]\).", lambda: api.vmap(lambda x: x, in_axes=(0, 0))(jnp.ones(3)) ) def test_vmap_in_axes_leaf_types(self): with self.assertRaisesRegex( TypeError, r"vmap in_axes must be an int, None, or .*"): api.vmap(lambda x: x, in_axes=(jnp.array([1., 2.]),))(jnp.array([1., 2.])) def test_vmap_out_axes_leaf_types(self): with self.assertRaisesRegex( TypeError, r"vmap out_axes must be an int, None, or .*"): api.vmap(lambda x: x, out_axes=(jnp.array([1., 2.]),))(jnp.array([1., 2.])) def test_vmap_unbatched_object_passthrough_issue_183(self): # https://github.com/google/jax/issues/183 fun = lambda f, x: f(x) vfun = api.vmap(fun, (None, 0)) ans = vfun(lambda x: x + 1, jnp.arange(3)) self.assertAllClose(ans, np.arange(1, 4), check_dtypes=False) def test_vmap_mismatched_axis_sizes_error_message_issue_705(self): # https://github.com/google/jax/issues/705 def h(a, b): return jnp.sum(a) + jnp.sum(b) X = np.random.randn(10, 4) U = np.random.randn(10, 2) with self.assertRaisesRegex( ValueError, "vmap got inconsistent sizes for array axes to be mapped:\n" r"arg 0 has shape \(10, 4\) and axis 0 is to be mapped" "\n" r"arg 1 has shape \(10, 2\) and axis 1 is to be mapped" "\n" "so\n" "arg 0 has an axis to be mapped of size 10\n" "arg 1 has an axis to be mapped of size 2"): api.vmap(h, in_axes=(0, 1))(X, U) with self.assertRaisesRegex( ValueError, "vmap got inconsistent sizes for array axes to be mapped:\n" r"arg 0 has shape \(10, 4\) and axis 0 is to be mapped" "\n" r"arg 1 has shape \(10, 2\) and axis 1 is to be mapped" "\n" r"arg 2 has shape \(10, 4\) and axis 0 is to be mapped" "\n" "so\n" "args 0, 2 have axes to be mapped of size 10\n" "arg 1 has an axis to be mapped of size 2"): api.vmap(lambda x, y, z: None, in_axes=(0, 1, 0))(X, U, X) with self.assertRaisesRegex( ValueError, "vmap got inconsistent sizes for array axes to be mapped:\n" "the tree of axis sizes is:\n" r"\(10, \[2, 2\]\)"): api.vmap(h, in_axes=(0, 1))(X, [U, U]) with self.assertRaisesRegex( ValueError, "vmap got arg 0 of rank 0 but axis to be mapped 0"): # The mapped inputs cannot be scalars api.vmap(lambda x: x)(1.) with self.assertRaisesRegex( ValueError, "vmap must have at least one non-None value in in_axes"): # If the output is mapped, there must be a non-None in_axes api.vmap(lambda x: x, in_axes=None)(jnp.array([1., 2.])) with self.assertRaisesRegex( ValueError, "vmap got arg 0 of rank 1 but axis to be mapped 1"): api.vmap(lambda x: x, in_axes=1)(jnp.array([1., 2.])) # Error is: TypeError: only integer scalar arrays can be converted to a scalar index with self.assertRaisesRegex( ValueError, "vmap out_axes specification must be a tree prefix of the " "corresponding value.*"): api.vmap(lambda x: x, in_axes=0, out_axes=(2, 3))(jnp.array([1., 2.])) with self.assertRaisesRegex( ValueError, "vmap has mapped output but out_axes is None"): # If the output is mapped, then there must be some out_axes specified api.vmap(lambda x: x, out_axes=None)(jnp.array([1., 2.])) def test_vmap_structured_in_axes(self): A, B, C, D = 2, 3, 4, 5 K = 6 # batch size x = np.ones((K, A, B)) # batch axis in different locations y = np.ones((B, K, C)) z = np.ones((C, D, K)) def foo(tree_arg): x, (y, z) = tree_arg return jnp.dot(x, jnp.dot(y, z)) tree = (x, (y, z)) vfoo = api.vmap(foo, in_axes=((0, (1, 2)),)) self.assertEqual(vfoo(tree).shape, (6, 2, 5)) Point = collections.namedtuple("Point", ["x", "y"]) tree = (x, Point(y, z)) vfoo = api.vmap(foo, in_axes=((0, Point(1, 2)),)) self.assertEqual(vfoo(tree).shape, (6, 2, 5)) def foo(tree_arg): x, dct = tree_arg y, z = dct['a'], dct['b'] return jnp.dot(x, jnp.dot(y, z)) tree = (x, {'a': y, 'b': z}) vfoo = api.vmap(foo, in_axes=((0, {'a': 1, 'b': 2}),)) self.assertEqual(vfoo(tree).shape, (6, 2, 5)) tree = (x, collections.OrderedDict([('a', y), ('b', z)])) vfoo = api.vmap( foo, in_axes=((0, collections.OrderedDict([('a', 1), ('b', 2)])),)) self.assertEqual(vfoo(tree).shape, (6, 2, 5)) def test_pmap_global_cache(self): def f(x, y): return x, y x = np.ones((1, 1, 1)) # All defaults with jtu.assert_num_jit_and_pmap_compilations(1): for _ in range(2): api.pmap(f)(x, x) # With axis name with jtu.assert_num_jit_and_pmap_compilations(1): for _ in range(2): api.pmap(f, 'i')(x, x) # With in_axes and out_axes if config.omnistaging_enabled: for x_in, y_in, x_out, y_out in it.product(*((0, 1, 2) for _ in range(4))): with jtu.assert_num_jit_and_pmap_compilations(1): for _ in range(2): api.pmap(f, 'i', in_axes=(x_in, y_in), out_axes=(x_out, y_out))(x, x) # Forward-mode AD on the outside with jtu.assert_num_jit_and_pmap_compilations(1): for _ in range(2): api.jvp(api.pmap(f), (x, x), (x, x)) # Reverse-mode AD on the outside. One compilation for forward, one for backward. with jtu.assert_num_jit_and_pmap_compilations(2): for _ in range(2): api.vjp(api.pmap(f), x, x)[1]((x, x)) def test_device_array_repr(self): rep = jnp.ones(()) + 1. self.assertStartsWith(repr(rep), "DeviceArray") def test_device_array_hash(self): rep = jnp.ones(()) + 1. self.assertIsInstance(rep, jax.interpreters.xla.DeviceArray) msg = "JAX DeviceArray, like numpy.ndarray, is not hashable." with self.assertRaisesRegex(TypeError, msg): hash(rep) with self.assertRaisesRegex(TypeError, msg): hash(rep.device_buffer) def test_grad_without_enough_args_error_message(self): # https://github.com/google/jax/issues/1696 def f(x, y): return x + y df = api.grad(f, argnums=0) self.assertRaisesRegex( TypeError, "differentiating with respect to argnums=0 requires at least 1 " "positional arguments to be passed by the caller, but got only 0 " "positional arguments.", lambda: partial(df, x=0.)(y=1.)) def test_grad_of_jit_compilation_caching(self): if not hasattr(self, "assertLogs"): raise unittest.SkipTest("test requires assertLogs (python 3)") lax.add(1, 2) # make sure some initial warnings are already printed sin = api.jit(jnp.sin) prev_level = logging.get_verbosity() try: logging.set_verbosity('DEBUG') with self.assertLogs(level=logging.DEBUG) as l: ans1 = api.grad(sin)(2.) ans2 = api.grad(sin)(3.) finally: logging.set_verbosity(prev_level) self.assertLen(l.output, 2) self.assertAllClose(ans1, np.cos(2.), check_dtypes=False) self.assertAllClose(ans2, np.cos(3.), check_dtypes=False) def test_trivial_computations(self): x = jnp.array([1, 2, 3]) y = api.jit(lambda x: x)(x) self.assertIs(x, y) z1, z2 = api.jit(lambda x: (x, x))(x) self.assertIs(z1, z2) x1, x2 = jnp.array([1, 2]), jnp.array([2, 3]) z1, z2, z3 = api.jit(lambda x, y: (y, 1, x))(x1, x2) self.assertIs(z1, x2) self.assertIs(z3, x1) self.assertEqual(z2, 1) def test_nested_jit_hoisting(self): @api.jit def f(x, y): z = 2 * x return y + z, 3 @api.jit def g(x): return f(2, x) jaxpr_subcomp = xla.jaxpr_subcomp jaxprs = [] def jaxpr_subcomp_and_collect(c, jaxpr, *args, **kwargs): jaxprs.append(jaxpr) return jaxpr_subcomp(c, jaxpr, *args, **kwargs) try: xla.jaxpr_subcomp = jaxpr_subcomp_and_collect ans = g(3) finally: xla.jaxpr_subcomp = jaxpr_subcomp self.assertEqual(ans, (7, 3)) self.assertLen(jaxprs, 2) outer_jaxpr, inner_jaxpr = jaxprs self.assertLen(outer_jaxpr.eqns, 1) self.assertEqual(outer_jaxpr.eqns[0].primitive.name, 'xla_call') subjaxpr_1 = outer_jaxpr.eqns[0].params["call_jaxpr"] self.assertEqual(str(subjaxpr_1), str(inner_jaxpr)) self.assertLen(inner_jaxpr.eqns, 2 if config.omnistaging_enabled else 3) self.assertEqual(inner_jaxpr.eqns[-2].primitive.name, 'mul') self.assertEqual(inner_jaxpr.eqns[-1].primitive.name, 'add') def test_primitive_compilation_cache(self): with jtu.count_primitive_compiles() as count: lax.add(1, 2) lax.add(2, 3) self.assertEqual(count[0], 1) def test_arange_jit(self): # see https://github.com/google/jax/issues/553 def fun(x): r = jnp.arange(x.shape[0])[x] return r jit(fun)(jnp.array([0, 1, 2], dtype=jnp.int32)) # doesn't crash def helper_save_tracer(self, x): self._saved_tracer = x return x def test_escaped_tracers_different_top_level_traces(self): api.jit(self.helper_save_tracer)(0.) with self.assertRaisesRegex( core.UnexpectedTracerError, "Encountered an unexpected tracer"): api.jit(lambda x: self._saved_tracer)(0.) def test_escaped_tracers_cant_lift_sublevels(self): api.jit(self.helper_save_tracer)(0.) with self.assertRaisesRegex( core.UnexpectedTracerError, re.compile( "Encountered an unexpected tracer", re.DOTALL)): api.jit(lambda x: x)(self._saved_tracer) def test_escaped_tracers_tracer_from_higher_level(self): api.grad(self.helper_save_tracer)(0.) with self.assertRaisesRegex( core.UnexpectedTracerError, re.compile( "Encountered an unexpected tracer.*Tracer from a higher level", re.DOTALL)): api.grad(lambda x: x)(self._saved_tracer) def test_escaped_tracers_incompatible_sublevel(self): def func1(x): api.jit(self.helper_save_tracer)(0.) # Use the tracer return x + self._saved_tracer with self.assertRaisesRegex( core.UnexpectedTracerError, re.compile("Encountered an unexpected tracer", re.DOTALL)): api.jit(func1)(2.) def test_escaped_tracers_cant_lift(self): def func1(x): api.grad(self.helper_save_tracer)(0.) return x + self._saved_tracer with self.assertRaisesRegex( core.UnexpectedTracerError, re.compile("Encountered an unexpected tracer.*Can't lift", re.DOTALL)): api.grad(func1)(2.) def test_escaped_tracers_not_among_input_tracers(self): def func1(x): api.grad(self.helper_save_tracer)(x) # Use the tracer return x + self._saved_tracer with self.assertRaisesRegex( core.UnexpectedTracerError, re.compile( "Encountered an unexpected tracer.*Tracer not among input tracers", re.DOTALL)): api.jit(func1)(2.) def test_escaped_tracer_omnistaging(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") count = 1 @jit def f(): nonlocal count count = jnp.add(count, 1) f() # leaked a tracer! but currently undetected def f(x, c): jnp.add(count, 1) return None, None @jit def g(): lax.scan(f, None, None, length=2) with self.assertRaisesRegex(core.UnexpectedTracerError, "was created on line"): g() def test_escaped_tracer_omnistaging_top_trace(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") count = 1 def f(_, __): nonlocal count count = jnp.add(count, 1) return None, None lax.scan(f, None, None, length=2) # leaked a tracer! (of level 1!) with self.assertRaisesRegex(core.UnexpectedTracerError, "was created on line"): # The following call will try and raise the ones array to the count tracer # level, which is no longer live. jax.jit(jnp.add)(jnp.ones(()), count) def test_pmap_static_kwarg_error_message(self): # https://github.com/google/jax/issues/3007 def f(a, b): return a + b g = jax.pmap(f, static_broadcasted_argnums=(1,)) msg = (r"pmapped function has static_broadcasted_argnums=\(1,\) but was " r"called with only 1 positional argument. All static broadcasted " r"arguments must be passed positionally.") with self.assertRaisesRegex(ValueError, msg): g(jnp.ones((1, 1)), b=1) def test_vmap_unmapped_last(self): @partial(jax.vmap, out_axes=-1) def f(x): return np.zeros((2,)) f(np.zeros((5,))) # TODO(jakevdp): re-enable this if possible. @unittest.skipIf(True, "broken by convert_element_type change.") def test_xla_constant_dedup(self): y = np.array([7, 14], dtype=np.float32) def f(x): return x + y + y x = np.array([1, 2], dtype=np.float32) hlo_lines = jax.xla_computation(f)(x).as_hlo_text().split('\n') hlo_lines = set([s.strip() for s in hlo_lines]) self.assertIn('constant.1 = f32[2]{0} constant({7, 14})', hlo_lines) self.assertNotIn('constant.2 = f32[2]{0} constant({7, 14})', hlo_lines) def test_omnistaging_flag(self): if FLAGS.jax_omnistaging: jaxpr = api.make_jaxpr(lambda: jnp.add(1, 1))() self.assertLen(jaxpr.jaxpr.eqns, 1) else: # omnistaging can be enabled programmatically without setting the flag, # but that shouldn't happen in tests jaxpr = api.make_jaxpr(lambda: jnp.add(1, 1))() self.assertLen(jaxpr.jaxpr.eqns, 0) def test_eval_context(self): @jit def f(): with core.eval_context(): assert jnp.add(1, 1) == 2 f() # doesn't crash def test_concrete_error_because_arg(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") @jax.jit def f(x, y): if x > y: return x else: return y msg = r"at flattened positions \[0, 1\]" with self.assertRaisesRegex(core.ConcretizationTypeError, msg): f(1, 2) def test_concrete_error_because_const(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") @jax.jit def f(): assert jnp.add(1, 1) > 0 msg = "on these lines" with self.assertRaisesRegex(core.ConcretizationTypeError, msg): f() def test_xla_computation_zeros_doesnt_device_put(self): raise unittest.SkipTest("broken test") # TODO(mattjj): fix if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") with jtu.count_device_put() as count: api.xla_computation(lambda: jnp.zeros(3))() self.assertEqual(count[0], 0) def test_join_concrete_arrays_with_omnistaging(self): # https://github.com/google/jax/issues/4622 if not config.omnistaging_enabled: raise unittest.SkipTest("test is omnistaging-specific") x = jnp.array([1., 2., 3.]) y = jnp.array([1., 2., 4.]) @jit def f(): core.lattice_join(core.ConcreteArray(x), core.ConcreteArray(y)) f() # doesn't crash def test_linearize_aval_error(self): # https://github.com/google/jax/issues/4622 f = lambda x: x # these should not error _, f_jvp = api.linearize(f, 1.) f_jvp(1.) _, f_jvp = api.linearize(f, np.ones(2, np.int32)) f_jvp(np.zeros(2, float0)) # these should error _, f_jvp = api.linearize(f, 1.) with self.assertRaisesRegex(ValueError, "tangent values inconsistent"): f_jvp(1) _, f_jvp = api.linearize(f, np.ones(2, np.int32)) with self.assertRaisesRegex(ValueError, "tangent values inconsistent"): f_jvp(np.ones(2, np.int32)) def test_grad_of_token_consuming_primitive(self): # https://github.com/google/jax/issues/5463 tokentest_p = core.Primitive("tokentest") tokentest_p.def_impl(partial(xla.apply_primitive, tokentest_p)) tokentest_p.def_abstract_eval(lambda x, y: x) xla.translations[tokentest_p] = lambda c, x, y: x ad.defjvp(tokentest_p, (lambda g, x, token: x), None) token = jax.lax.create_token(123) arr = jnp.ones((3, 2)) res, vjp_fun = jax.vjp(lambda x: tokentest_p.bind(x, token), arr) # Should not crash. vjp_fun(arr) def test_jit_returning_token(self): x = jax.jit(jax.lax.create_token)(1.0) self.assertIsInstance(x, jax.interpreters.xla.Token) def test_leak_checker_catches_a_jit_leak(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): lst = [] @jit def f(x): lst.append(x) return x with self.assertRaisesRegex(Exception, r"Leaked trace"): f(3) def test_leak_checker_catches_a_pmap_leak(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): lst = [] @api.pmap def f(x): lst.append(x) return x with self.assertRaisesRegex(Exception, r"Leaked trace"): f(np.ones(1)) def test_leak_checker_catches_a_grad_leak(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): lst = [] def f(x): lst.append(x) return x with self.assertRaisesRegex(Exception, r"Leaked trace"): api.grad(f)(3.) def test_leak_checker_avoids_false_positives(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): @jit def f(x): return x f(3) # doesn't crash api.vmap(f)(np.arange(3)) # doesn't crash api.grad(f)(3.) # doesn't crash @api.pmap def f(x): return x f(np.ones(1)) # doesn't crash api.vmap(f)(np.ones((1, 1))) # doesn't crash def test_leak_checker_catches_a_scan_leak(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): lst = [] to_scan = lambda c, x: (lst.append(c) or jnp.sin(c), None) with self.assertRaisesRegex(Exception, r"Leaked trace"): lax.scan(to_scan, 1., np.arange(3.)) def test_leak_checker_avoids_false_positives_scan(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): to_scan = lambda c, x: (jnp.sin(c), None) lax.scan(to_scan, 1., np.arange(3.)) # doesn't crash def test_leak_checker_avoids_false_positives_scan_jvp(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): to_scan = lambda c, x: (c, None) def f(x): lax.scan(to_scan, x, None, length=1) api.jvp(f, (3.,), (1.,)) # doesn't crash def test_leak_checker_avoids_false_positives_scan_vmap(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): to_scan = lambda c, _: (1., None) @api.vmap def f(x): lax.scan(to_scan, x, None, length=1) f(np.arange(5.)) # doesn't crash def test_leak_checker_avoids_false_positives_scan_vmap_2(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): to_scan = lambda c, _: (c, None) @api.vmap def f(x): lax.scan(to_scan, x, None, length=1) f(np.arange(5.)) # doesn't crash def test_leak_checker_catches_a_sublevel_leak(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") with core.checking_leaks(): @jit def f(x): lst = [] @jit def g(x): lst.append(x) return x x = g(x) return x with self.assertRaisesRegex(Exception, r"Leaked sublevel"): f(3) def test_default_backend(self): first_local_device = api.local_devices()[0] self.assertEqual(first_local_device.platform, api.default_backend()) def test_dunder_jax_array(self): # https://github.com/google/jax/pull/4725 class AlexArray: def __init__(self, jax_val): self.jax_val = jax_val def __jax_array__(self): return self.jax_val dtype = property(lambda self: self.jax_val.dtype) shape = property(lambda self: self.jax_val.shape) x = AlexArray(jnp.array([1., 2., 3.])) y = jnp.sin(x) self.assertAllClose(y, jnp.sin(jnp.array([1., 2., 3.]))) y = api.grad(api.jit(lambda x: jnp.sin(x).sum()))(x) self.assertAllClose(y, jnp.cos(jnp.array([1., 2., 3.]))) x = AlexArray(jnp.array([[1., 2., 3.]])) y = api.pmap(jnp.sin)(x) self.assertAllClose(y, jnp.sin(jnp.array([[1., 2., 3.]]))) x = jnp.array(1) a = AlexArray(x) for f in [jnp.isscalar, jnp.size, jnp.shape, jnp.dtype]: self.assertEqual(f(x), f(a)) def test_constant_handler_mro(self): # https://github.com/google/jax/issues/6129 class Foo(enum.IntEnum): bar = 1 @api.pmap def f(_): return Foo.bar ans = f(jnp.arange(1)) # doesn't crash expected = jnp.arange(1) + 1 self.assertAllClose(ans, expected) class RematTest(jtu.JaxTestCase): def test_remat_basic(self): @api.remat def g(x): return lax.sin(lax.sin(x)), 3. def f(x): x, _ = g(x) return x ans = f(2.) expected = np.sin(np.sin(2.)) self.assertAllClose(ans, expected, check_dtypes=False) ans, f_lin = api.linearize(f, 2.) expected = np.sin(np.sin(2.)) self.assertAllClose(ans, expected, check_dtypes=False) ans = f_lin(3.) expected = np.cos(np.sin(2.)) * np.cos(2.) * 3. self.assertAllClose(ans, expected, check_dtypes=False) sin_calls = [] cos_calls = [] sin_impl = lax.sin_p.impl cos_impl = lax.cos_p.impl try: lax.sin_p.def_impl(lambda x: sin_calls.append(1) or sin_impl(x)) lax.cos_p.def_impl(lambda x: cos_calls.append(1) or cos_impl(x)) f_lin(3.) finally: lax.sin_p.def_impl(sin_impl) lax.cos_p.def_impl(cos_impl) self.assertEqual(len(sin_calls), 1) self.assertEqual(len(cos_calls), 2) def test_remat_freevars(self): def f1(x): y = 2 * jnp.sin(x) z = jnp.cos(x) * jnp.sin(y) return z def f2(x): y = 2 * jnp.sin(x) z = api.remat(lambda x: jnp.cos(x) * jnp.sin(y))(x) return z ans, f_lin = api.linearize(f2, 2.) expected, f_lin_expected = api.linearize(f1, 2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = f_lin(3.) expected = f_lin_expected(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_grad_python_control_flow(self): @partial(api.remat, concrete=True) def g(x): if x > 0: return lax.sin(x), 3. else: return lax.cos(x), 4. def f(x): x, _ = g(x) return x ans = f(2.) expected = np.sin(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(f)(2.) expected = np.cos(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_jit(self): @api.remat def g(x): return lax.sin(lax.sin(x)) def f_(x): return g(x) f = api.jit(f_) ans = f(2.) expected = np.sin(np.sin(2.)) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(f)(2.) expected = np.cos(np.sin(2.)) * np.cos(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.grad(f_))(2.) expected = np.cos(np.sin(2.)) * np.cos(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_vmap(self): @api.remat def g(x): return lax.sin(lax.sin(x)) x = np.arange(3.) ans = api.vmap(g)(x) expected = np.sin(np.sin(x)) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jacfwd(g)(x) expected = np.diag(np.cos(np.sin(x)) * np.cos(x)) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jacrev(g)(x) expected = np.diag(np.cos(np.sin(x)) * np.cos(x)) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_higher_order_autodiff(self): def f(x): return lax.cos(lax.sin(x)) g = api.remat(f) ans = api.grad(api.grad(g))(3.) expected = api.grad(api.grad(f))(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_scan(self): to_scan = lambda c, x: (jnp.sin(c), None) def f_noremat(x): y, _ = lax.scan(to_scan, x, np.arange(3.)) return y def f_yesremat(x): y, _ = lax.scan(api.remat(to_scan), x, np.arange(3.)) return y ans = f_yesremat(4.) expected = f_noremat(4.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(f_yesremat)(4.) expected = api.grad(f_noremat)(4.) self.assertAllClose(ans, expected, check_dtypes=False) jaxpr = api.make_jaxpr(api.linearize(f_yesremat, 4.)[1])(1.) scan_eqn, = jaxpr.jaxpr.eqns self.assertIn(' cos ', str(scan_eqn.params['jaxpr'])) jaxpr = api.make_jaxpr(api.vjp(f_yesremat, 4.)[1])(1.) scan_eqn, = jaxpr.jaxpr.eqns self.assertIn(' cos ', str(scan_eqn.params['jaxpr'])) def test_remat_no_redundant_flops(self): # see https://github.com/google/jax/pull/1749#issuecomment-558267584 @api.jit def g(x): return f(2., x) @api.remat def f(x, y): return jnp.sin(x) * y # We swap out sin_p's impl rule to count how many times it's invoked called = [] sin_impl = lax.sin_p.impl try: lax.sin_p.def_impl(lambda x: called.append(1) or sin_impl(x)) api.grad(g)(3.) finally: lax.sin_p.def_impl(sin_impl) num_calls = len(called) self.assertLessEqual(num_calls, 1) def test_remat_binomial_checkpointing(self): def binom_checkpoint(funs): if len(funs) == 1: return funs[0] else: f1 = binom_checkpoint(funs[:len(funs)//2]) f2 = binom_checkpoint(funs[len(funs)//2:]) return api.remat(lambda x: f1(f2(x))) f1 = binom_checkpoint([jnp.sin, jnp.sin, jnp.sin, jnp.sin]) f2 = lambda x: jnp.sin(jnp.sin(jnp.sin(jnp.sin(x)))) x = 4. self.assertAllClose(f1(x), f2(x), check_dtypes=False) self.assertAllClose(api.grad(f1)(x), api.grad(f2)(x), check_dtypes=False) def test_remat_symbolic_zeros(self): # code from https://github.com/google/jax/issues/1907 key = jax.random.PRNGKey(0) key, split = jax.random.split(key) n = 5 def func(D0): def shift(R, dR, **unused_kwargs): return R + dR def apply_fn(R): return D0 * R Rinit = jax.random.uniform(split, (n,3), minval=0.0, maxval=5.0, dtype=jnp.float32) def move(R,i): F = apply_fn(R) return shift(R, 0.001 * F), jnp.array([0.]) move = api.remat(move) R, temp = lax.scan(move, Rinit, jnp.arange(2)) return R[0, 0] api.grad(func)(5.0) # doesn't crash def test_remat_jit2(self): @api.jit def f(x): y = 2 * x @api.remat def g(): return y return g() self.assertAllClose(f(3), 6, check_dtypes=False) def test_remat_nontrivial_env(self): # simplified from https://github.com/google/jax/issues/2030 @api.remat def foo(state, dt=0.5, c=1): u, u_t = state u_tt = c**2 * u u_t = u_t + u_tt * dt return (u, u_t) @partial(api.jit, static_argnums=(1,)) def _multi_step(state, count, dt, c): f = lambda s, _: (foo(s, dt, c), _) return lax.scan(f, state, None, count) def multi_step(state, count, dt=1/jnp.sqrt(2), c=1): return _multi_step(state, count, dt, c) def loss(u0, target, steps, dt=1/jnp.sqrt(2), c=1): init = (u0, jnp.zeros_like(u0)) (uf, _), _ = multi_step(init, steps, dt, c) return ((uf - target) ** 2).mean() target = jnp.zeros((128, 128)) u0 = jnp.ones_like(target) loss(u0, target, 10) # doesn't crash def test_remat_jit3(self): # https://github.com/google/jax/issues/2180 def f(w, x): a = jnp.dot(x, w) b = jnp.einsum("btd,bTd->btT", a, a) c = jnp.einsum("btT,btd->btd", b, a) return jnp.sum(c) w = jnp.ones([1, 1]) x = jnp.ones([1, 1, 1]) f = api.remat(f) api.grad(f)(w, x) # doesn't crash @api.jit def mul(a, b): return a * b def f(w, x): a = mul(w, x) b = mul(a, a) return b w = 1. x = 1. f = api.remat(f) api.grad(f)(w, x) # doesn't crash def test_remat_scan2(self): # https://github.com/google/jax/issues/1963 def scan_bug(x0): f = lambda x, _: (x + 1, None) def scanned_f(x, _): return lax.scan(f, x, xs=None, length=1)[0], None x, _ = jax.remat(scanned_f)(x0, None) return x jax.grad(scan_bug)(1.0) # doesn't crash def test_remat_jit_static_argnum(self): # https://github.com/google/jax/issues/2833 if config.omnistaging_enabled: raise unittest.SkipTest("test only works without omnistaging") # see next test def f(a_bool, y): if a_bool: return y + 1 else: return y api.jit(api.remat(f, concrete=True), static_argnums=0)(True, 1) # no crash def test_remat_jit_static_argnum_omnistaging(self): # https://github.com/google/jax/issues/2833 if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") # see previous test def named_call(f): def named_f(*args): f_ = lu.wrap_init(lambda: (f(*args),)) out, = core.call_p.bind(f_) return out return named_f def f(a_bool, y): if a_bool: return y + 1 else: return y api.jit(named_call(f), static_argnums=0)(True, 1) # no crash def test_remat_eval_counter(self): # https://github.com/google/jax/issues/2737 add_one_p = Primitive('add_one') add_one = add_one_p.bind num_evals = 0 @contextmanager def assertEvals(n): start = num_evals yield assert num_evals - start == n def add_one_impl(x): nonlocal num_evals num_evals += 1 return x + 1 add_one_p.def_impl(add_one_impl) def add_one_jvp(pin, tin): pout = add_one(pin[0]) return pout, pout * tin[0] ad.primitive_jvps[add_one_p] = add_one_jvp add_one_p.def_abstract_eval(lambda x: x) v = np.zeros((1,)) f = jax.remat(add_one) g = jax.remat(lambda x: add_one(f(x))) # 2 calls needed to evaluate g with assertEvals(2): _, vjp = jax.vjp(g, v) # 2 calls made while transposing g, 1 call made while transposing f with assertEvals(3): vjp(v) @jax._src.util.curry def call(f, *args): return jax.core.call( jax.linear_util.wrap_init(lambda *args: [f(*args)]), *args, name='foo')[0] f = call(add_one) g = jax.remat(lambda x: add_one(f(x))) # 2 calls needed to evaluate g with assertEvals(2): _, vjp = jax.vjp(g, v) # 2 calls made while transposing g, no reevaluation for transposition of f with assertEvals(2): vjp(v) def test_escaped_tracer_remat(self): # b/169779185 if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def f(): seq = [jnp.zeros([])] def g(): seq[0] += 1 # this is line 7 btw return seq[0] api.remat(g)() api.remat(g)() with self.assertRaisesRegex(core.UnexpectedTracerError, "global state"): api.jit(f)() class JaxprTest(jtu.JaxTestCase): def test_scalar_literals(self): jaxpr = api.make_jaxpr(lambda x: x + 2)(42) self.assertLen(jaxpr.jaxpr.constvars, 0) def test_abstract_inputs(self): jaxpr = api.make_jaxpr(lambda x: x + 2.)( types.SimpleNamespace(shape=(), dtype=np.float32)) self.assertEqual(jaxpr.in_avals[0].shape, ()) self.assertEqual(jaxpr.in_avals[0].dtype, np.float32) def test_const(self): def fun(x): return (x, 1., np.zeros(1)) if config.omnistaging_enabled: expected = """ { lambda a ; b. let in (b, 1.0, a) } """ else: expected = """ { lambda b ; a. let in (a, 1.0, b) } """ jaxpr = api.make_jaxpr(fun)(0.) self.assertMultiLineStrippedEqual(expected, str(jaxpr)) def test_cond(self): def f(x): return lax.cond(x >= 0., x + 1., lambda xt: xt + x, x + 2., lambda xf: xf - x) if config.omnistaging_enabled: expected = """ { lambda ; a. let b = ge a 0.0 c = add a 1.0 d = add a 2.0 e = convert_element_type[ new_dtype=int32 weak_type=False ] b f = cond[ branches=( { lambda ; e_ a b c. let d = sub c a in (d,) } { lambda ; a f_ b c. let d = add b a in (d,) } ) linear=(False, False, False, False) ] e a a c d in (f,) } """ else: expected = """ { lambda ; a. let b = ge a 0.0 c = convert_element_type[ new_dtype=int32 weak_type=False ] b d = convert_element_type[ new_dtype=float32 weak_type=False ] a e = convert_element_type[ new_dtype=float32 weak_type=False ] a f = add a 1.0 g = add a 2.0 h = cond[ branches=( { lambda ; e_ c a b. let d = sub b c in (d,) } { lambda ; c f_ a b. let d = add a c in (d,) } ) linear=(False, False, False, False) ] c d e f g in (h,) } """ jaxpr = api.make_jaxpr(f)(3.) self.assertMultiLineStrippedEqual(expected, str(jaxpr)) def test_make_jaxpr_static_argnums(self): def f(x, y): return x + y jaxpr = api.make_jaxpr(f, static_argnums=(1,))(2, 3) self.assertIn('3', str(jaxpr)) def test_make_jaxpr_return_shape(self): _, shape_tree = api.make_jaxpr(lambda x: (x + 1, jnp.zeros(2, jnp.float32)), return_shape=True)(np.int32(1)) expected = (api.ShapeDtypeStruct(shape=(), dtype=jnp.int32), api.ShapeDtypeStruct(shape=(2,), dtype=jnp.float32)) self.assertEqual(shape_tree, expected) def test_make_jaxpr_axis_env(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def f(x): return x - lax.psum(x, 'i') jaxpr = api.make_jaxpr(f, axis_env=[('i', 4)])(2) self.assertIn('psum', str(jaxpr)) def test_make_jaxpr_named(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def f(x): return x - lax.psum(x, 'i') x = types.SimpleNamespace( shape=(2, 3), dtype=jnp.float32, named_shape={'i': 10}) jaxpr = api.make_jaxpr(f, axis_env=[('i', 10)])(x) named_shapes = [v.aval.named_shape for v in jaxpr.jaxpr.eqns[1].invars] self.assertEqual(named_shapes, [{'i': 10}, {}]) class CustomJVPTest(jtu.JaxTestCase): def test_basic(self): @api.custom_jvp def f(x): return jnp.sin(x) def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * jnp.cos(x) * g f.defjvp(f_jvp) x = 3. self.assertAllClose(f(x), jnp.sin(x)) self.assertAllClose(api.jvp(f, (x,), (1.,)), (jnp.sin(x), 2 * jnp.cos(x))) self.assertAllClose(api.grad(f)(x), 2 * jnp.cos(x)) def test_invariance(self): @api.custom_jvp def f(x): return jnp.cos(2 * x) / 2. def f_jvp(primals, tangents): x, = primals g, = tangents return (f(x), 3 * g) f.defjvp(f_jvp) def f2(x): y, _ = api.jvp(f, (x,), (x,)) return y def f3(x): y, _ = api.jvp(f2, (x,), (x,)) return y x = 1. self.assertAllClose(api.jvp(f, (x,), (x,)), api.jvp(f2, (x,), (x,)), check_dtypes=False) self.assertAllClose(api.jvp(f, (x,), (x,)), api.jvp(f3, (x,), (x,)), check_dtypes=False) def test_python_control_flow(self): @api.custom_jvp def f(x): if x > 0: return jnp.sin(x) else: return jnp.cos(x) def f_jvp(primals, tangents): x, = primals g, = tangents if x > 0: return f(x), 2 * g else: return f(x), 3 * g f.defjvp(f_jvp) x = 2. self.assertAllClose(f(x), jnp.sin(x)) self.assertAllClose(f(-x), jnp.cos(-x)) self.assertAllClose(api.jvp(f, (x,), (1.,)), (jnp.sin(x), 2.), check_dtypes=False) self.assertAllClose(api.jvp(f, (-x,), (1.,)), (jnp.cos(-x), 3.), check_dtypes=False) self.assertAllClose(api.grad(f)(x), 2., check_dtypes=False) self.assertAllClose(api.grad(f)(-x), 3., check_dtypes=False) def test_vmap(self): @api.custom_jvp def f(x): assert jnp.ndim(x) == 0 return jnp.sin(x) def f_jvp(primals, tangents): x, = primals g, = tangents assert jnp.ndim(x) == jnp.ndim(g) == 0 return f(x), 2 * jnp.cos(x) * g f.defjvp(f_jvp) x = jnp.arange(3.) xx = jnp.arange(6.).reshape(2, 3) # vmap of f self.assertAllClose(api.vmap(f)(x), jnp.sin(x)) self.assertAllClose(api.vmap(api.vmap(f))(xx), jnp.sin(xx)) # vmap of jvp of f self.assertAllClose(api.vmap(lambda x: api.jvp(f, (x,), (x,)))(x), (jnp.sin(x), 2 * jnp.cos(x) * x)) self.assertAllClose(api.vmap(api.vmap(lambda x: api.jvp(f, (x,), (x,))))(xx), (jnp.sin(xx), 2 * jnp.cos(xx) * xx)) # jvp of vmap of f self.assertAllClose(api.jvp(api.vmap(f), (x,), (x,)), (jnp.sin(x), 2 * jnp.cos(x) * x)) self.assertAllClose(api.jvp(api.vmap(api.vmap(f)), (xx,), (xx,)), (jnp.sin(xx), 2 * jnp.cos(xx) * xx)) # vmap of jvp of vmap of f self.assertAllClose(api.vmap(lambda x: api.jvp(api.vmap(f), (x,), (x,)))(xx), (jnp.sin(xx), 2 * jnp.cos(xx) * xx)) def test_jit(self): @api.custom_jvp def f(x): return jnp.sin(x) def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * jnp.cos(x) * g f.defjvp(f_jvp) x = 3. # jit self.assertAllClose(api.jit(f)(x), jnp.sin(x)) self.assertAllClose(api.jit(api.jit(f))(x), jnp.sin(x)) # jit of jvp self.assertAllClose(api.jit(lambda x: api.jvp(f, (x,), (x,)))(x), (jnp.sin(x), 2 * jnp.cos(x) * x), check_dtypes=False) # jvp of jit self.assertAllClose(api.jvp(api.jit(f), (x,), (x,)), (jnp.sin(x), 2 * jnp.cos(x) * x), check_dtypes=False) def test_pytrees(self): @api.custom_jvp def f(x): return {'b': jnp.sin(x['a'])} def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), {'b': 2 * jnp.cos(x['a']) * g['a']} f.defjvp(f_jvp) x = {'a': 3.} self.assertAllClose(f(x)['b'], jnp.sin(x['a'])) self.assertAllClose(api.jvp(f, (x,), (x,)), ({'b': jnp.sin(x['a'])}, {'b': 2 * jnp.cos(x['a']) * x['a']}), check_dtypes=False) def test_kwargs(self): # from https://github.com/google/jax/issues/1938 @api.custom_jvp def my_fun(x, y, c=1.): return c * (x + y) def my_jvp(primals, tangents): x, y, c = primals t_x, t_y, t_c = tangents return my_fun(x, y, c), t_c my_fun.defjvp(my_jvp) f = lambda x, y: jnp.square(my_fun(x, y, c=2.)).sum() f(10., 5.) # doesn't crash api.jvp(f, (10., 5.), (1., 1.)) # doesn't crash def test_initial_style(self): @api.custom_jvp def f(x): return 3 * x def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * g f.defjvp(f_jvp) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.grad(foo)(3.) expected = 2. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.jit(foo))(3.) expected = 2. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.grad(foo))(3.) expected = 2. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.grad(foo))(3.) expected = 0. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.grad(api.jit(foo)))(3.) expected = 0. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.jit(api.grad(foo)))(3.) expected = 0. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.grad(api.grad(foo)))(3.) expected = 0. self.assertAllClose(ans, expected, check_dtypes=False) def test_initial_style_vmap(self): @api.custom_jvp def f(x): assert jnp.ndim(x) == 0 return 3 * x def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * g f.defjvp(f_jvp) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.vmap(foo)(jnp.ones(3)) expected = 3. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.vmap(api.jit(foo))(jnp.ones(3)) expected = 3. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.vmap(foo))(jnp.ones(3)) expected = 3. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.vmap(foo)(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.vmap(api.jit(foo))(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.jit(api.vmap(foo))(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.jit(lambda x: api.vmap(foo)(x).sum()))(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.grad(lambda x: api.vmap(foo)(x).sum()))(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) def test_closed_over_tracers_error_message(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def f(x): @api.custom_jvp def g(y): return x + y def g_jvp(primals, tangents): return g(x), 2 * primals[0] g.defjvp(g_jvp) return g(1.) self.assertRaises(ad.CustomJVPException, lambda: api.jvp(f, (3.,), (1.,))) self.assertRaises(ad.CustomJVPException, lambda: api.grad(f)(3.)) def test_nondiff_arg(self): @partial(api.custom_jvp, nondiff_argnums=(0,)) def app(f, x): return f(x) def app_jvp(f, primals, tangents): (x,), (t,) = primals, tangents return app(f, x), 3 * t app.defjvp(app_jvp) ans = app(lambda x: 2 * x, 1) expected = 2 self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jvp(lambda x: app(lambda y: 2 * y, x), (1.,), (1.,)) expected = (2., 3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_nondiff_arg_jit_tracer(self): @partial(api.custom_jvp, nondiff_argnums=(0,)) def f(x, y): return x * y def f_jvp(x, primals, tangents): (y,), (t_y,) = primals, tangents return f(x, y), 5 * t_y f.defjvp(f_jvp) @jit def g(x, y): return f(x, y) ans = api.jvp(lambda y: g(2., y), (3.,), (1.,)) expected = (6., 5.) self.assertAllClose(ans, expected, check_dtypes=False) def test_nondiff_arg_hiding_jvp_tracer(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def f(x): @partial(api.custom_jvp, nondiff_argnums=(0,)) def g(h, x): return h(x) @g.defjvp def g_jvp(h, primals, tangents): x, = primals t, = tangents return g(h, x), 2. * t h = lambda y: x + y # capture x return g(h, x) with self.assertRaisesRegex(ad.CustomJVPException, "Detected differentiation"): api.jvp(f, (2.,), (1.,)) def test_vmap_axes(self): raise unittest.SkipTest("TODO") # TODO(mattjj): write test def test_pmap(self): raise unittest.SkipTest("TODO") # TODO(mattjj): write test def test_missing_jvp_rule_error_message(self): @api.custom_jvp def foo(x): return x ** 2 self.assertRaisesRegex( AttributeError, r"No JVP defined for custom_jvp function foo using defjvp.", lambda: foo(2)) self.assertRaisesRegex( AttributeError, r"No JVP defined for custom_jvp function foo using defjvp.", lambda: api.jvp(foo, (2.,), (1.,))) self.assertRaisesRegex( AttributeError, r"No JVP defined for custom_jvp function foo using defjvp.", lambda: api.grad(foo)(2.)) def test_jvp_rule_inconsistent_pytree_structures_error_message(self): @api.custom_jvp def f(x): return (x**2,) @f.defjvp def foo_jvp(primals, tangents): x, = primals t, = tangents return f(x), [2 * x * t, x] f(2.) # doesn't crash self.assertRaisesRegex( TypeError, re.escape( "Custom JVP rule must produce primal and tangent outputs " "with equal container (pytree) structures, but got " "{} and {} respectively.".format( tree_util.tree_structure((1,)), tree_util.tree_structure([1, 2])) ), lambda: api.jvp(f, (2.,), (1.,))) def test_primal_tangent_aval_disagreement_error_message(self): @api.custom_jvp def f(x): return x ** 2 @f.defjvp def foo_jvp(primals, tangents): x, = primals t, = tangents return f(x), jnp.reshape(t, (1,)) f(2.) # doesn't crash self.assertRaisesRegex( TypeError, re.escape( "Custom JVP rule must produce primal and tangent outputs " "with equal shapes and dtypes, but got float32[] and float32[1] " "respectively."), lambda: api.jvp(f, (jnp.float32(2.),), (jnp.float32(1.),))) def test_jvp_rule_doesnt_return_pair_error_message(self): # https://github.com/google/jax/issues/2516 @api.custom_jvp def f(x): return x ** 2 @f.defjvp def foo_jvp(primals, tangents): x, = primals t, = tangents return t f(2.) # doesn't crash self.assertRaisesRegex( TypeError, re.escape( "Custom JVP rule must produce a pair (list or tuple of length two) " "representing primal and tangent outputs, got 1.0"), lambda: api.jvp(f, (2.,), (1.,))) def test_multiple_rule_invocations(self): @jax.custom_jvp def expit(x): return 1 / (1 + lax.exp(-x)) @expit.defjvp def _expit_jvp(primals, tangents): (x,), (t,) = primals, tangents ans = expit(x) t_out = t * ans * (1 - ans) return ans, t_out def scanned_fun(c, _): return [expit(c[0])] + [c[i-1] + c[i] for i in range(1, len(c))], None def foo(x): c, _ = lax.scan(scanned_fun, [x, 0., 0., 0., 0.], None, length=10) return c[-1] # just make sure these don't crash foo(3.) grad(foo)(3.) grad(lambda x: jax.vmap(foo)(x).sum())(jnp.arange(3.)) def test_hard_stuff(self): arr = jnp.ones((5, 2, 2)) api.jit(jax.vmap(jnp.linalg.det))(arr) # doesn't crash def test_hard_stuff2(self): @jax.custom_jvp def f(x): return lax.tie_in(x, np.zeros(x.shape, x.dtype)) @f.defjvp def f_jvp(primals, tangents): x, = primals t, = tangents return f(x), t # don't crash jax.jit(jax.vmap(f))(jnp.arange(3.)) jax.jit(jax.vmap(jax.grad(f)))(jnp.arange(3.)) jax.jit(jax.grad(lambda x: jax.vmap(f)(x).sum()))(jnp.arange(3.)) jax.grad(lambda x: jax.vmap(f)(x).sum())(jnp.arange(3.)) jax.jvp(jax.vmap(f), (jnp.arange(3.),), (jnp.ones(3),)) def test_hard_stuff3(self): @jax.custom_jvp def relu(x): return jnp.maximum(x, 0) @relu.defjvp def _relu_jvp(primals, tangents): x, = primals t, = tangents return relu(x), lax.select(x > 0, t, lax.full_like(t, 0)) def scanned_fun(c, _): return [relu(c[0])] + [c[i-1] + c[i] for i in range(1, len(c))], None def f(x): c, _ = lax.scan(scanned_fun, [x, 0., 0., 0., 0.], None, length=10) return c[-1] # don't crash jax.jit(jax.vmap(f))(jnp.arange(3.)) jax.jit(jax.vmap(jax.grad(f)))(jnp.arange(3.)) jax.jit(jax.grad(lambda x: jax.vmap(f)(x).sum()))(jnp.arange(3.)) jax.grad(lambda x: jax.vmap(f)(x).sum())(jnp.arange(3.)) jax.jvp(jax.jit(jax.vmap(f)), (jnp.arange(3.),), (jnp.ones(3),)) def test_eval_shape(self): @jax.custom_jvp def expit(x): return 1 / (1 + lax.exp(-x)) @expit.defjvp def _expit_jvp(primals, tangents): (x,), (t,) = primals, tangents ans = expit(x) t_out = t * ans * (1 - ans) return ans, t_out # don't crash api.eval_shape(expit, jnp.ones((2, 3))) api.eval_shape(api.grad(lambda x: expit(x).sum()), jnp.ones((2, 3))) def test_jaxpr_zeros(self): # from https://github.com/google/jax/issues/2657 @api.custom_jvp def f(A, b): return A @ b def f_jvp(primals, tangents): A, b = primals dA, db = tangents z = f(A, b) dz = A @ db + dA @ b return z, dz f.defjvp(f_jvp) def experiment(theta): def step(q, _): z = f(jnp.eye(3), jnp.ones(3) * theta) q += z[0] return q, q q = 0. q, _ = lax.scan(step, q, None, 4) return q grad(experiment)(1.) # doesn't crash def test_linear_in_scan(self): @api.custom_jvp def f(x): return -x @f.defjvp def f_jvp(primals, tangents): x, = primals x_dot, = tangents return f(x), f(x_dot) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.grad(foo)(3.) expected = -1. self.assertAllClose(ans, expected, check_dtypes=False) def test_custom_jvps_first_rule_is_none(self): # https://github.com/google/jax/issues/3389 @api.custom_jvp def f(x, y): return x ** 2 * y f.defjvps(None, lambda x_dot, primal_out, x, y: 2 * x * y * x_dot) ans = grad(f, 1)(2., 3.) # doesn't crash expected = 12. self.assertAllClose(ans, expected, check_dtypes=False) def test_concurrent_initial_style(self): # https://github.com/google/jax/issues/3843 def unroll(param, sequence): def scan_f(prev_state, inputs): return prev_state, jax.nn.sigmoid(param * inputs) return jnp.sum(jax.lax.scan(scan_f, None, sequence)[1]) def run(): return jax.grad(unroll)(jnp.array(1.0), jnp.array([1.0])) expected = run() # we just don't want this to crash n_workers = 2 with concurrent.futures.ThreadPoolExecutor(max_workers=n_workers) as e: futures = [] for _ in range(n_workers): futures.append(e.submit(run)) results = [f.result() for f in futures] for ans in results: self.assertAllClose(ans, expected) def test_nondiff_argnums_vmap_tracer(self): # https://github.com/google/jax/issues/3964 if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") @partial(jax.custom_jvp, nondiff_argnums=(0, 2)) def sample(shape, param, seed): return jax.random.uniform(key=seed, shape=shape, minval=param) @sample.defjvp def sample_jvp(shape, seed, primals, tangents): param, = primals dparam, = tangents dparam = jnp.broadcast_to(dparam, shape) samples = sample(shape, param, seed) return samples, samples * dparam # dummy jvp for proof of concept # check these don't crash jax.vmap(lambda seed: sample((2,3), 1., seed))( jax.random.split(jax.random.PRNGKey(1), 10)) jax.jvp(lambda x: sample((2, 3), x, jax.random.PRNGKey(1)), (1.,), (1.,)) def test_fun_with_nested_calls_2(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") def call(f, *args): f = api.custom_jvp(f) f.defjvp(lambda primals, tangents: (f(*primals), sum(tangents))) return f(*args) def fun_with_nested_calls_2(x): def bar(y): def baz(w): q = call(lambda x: y, x) q = q + call(lambda: y) q = q + call(lambda y: w + y, y) q = call(lambda w: call(jnp.sin, x) * y, 1.0) + q return q return api.jit(baz)(x) return call(bar, x) # test these don't crash self.assertAllClose(api.jit(fun_with_nested_calls_2)(3.), fun_with_nested_calls_2(3.)) api.vmap(fun_with_nested_calls_2)(jnp.arange(3.)) def test_closure_with_vmap(self): if not config.omnistaging_enabled: raise unittest.SkipTest("test only works with omnistaging") # https://github.com/google/jax/issues/3822 alpha = np.float32(2.) def sample(seed): @api.custom_jvp def f(alpha): return jax.random.gamma(seed, alpha, shape=[]) @f.defjvp def f_jvp(primal, tangent): alpha = primal dalpha = tangent sample = f(alpha) partial_alpha = lax.random_gamma_grad(alpha, sample) return sample, partial_alpha * dalpha return f(alpha) api.vmap(sample)(jax.random.split(jax.random.PRNGKey(1), 3)) # don't crash def test_float0(self): @api.custom_jvp def f(x, y): return x, y def f_jvp(primals, _): # we need a defined (non-float0) tangent to trigger the rule return primals, (2., 1) f.defjvp(f_jvp) primals = (2., 3) tangents = (np.ones(()), np.zeros((), float0),) expected_tangents = (2., np.zeros((), float0)) self.assertArraysEqual(api.jvp(f, primals, tangents), (primals, expected_tangents)) def test_float0_initial_style(self): @api.custom_jvp def f(x, y): return x, y def f_jvp(primals, _): x, y = primals return (x, y), (2., 1) f.defjvp(f_jvp) def foo(x, y): out, _ = lax.scan(lambda c, _: (f(*c), None), (x, y), None, length=1) return out primals = (2., 3) tangents = (np.ones(()), np.zeros((), float0),) expected_tangents = (2., np.zeros((), float0)) self.assertArraysEqual(api.jvp(foo, primals, tangents), (primals, expected_tangents)) def test_remat(self): @api.custom_jvp def f(x): return jnp.sin(x) def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * jnp.cos(x) * g f.defjvp(f_jvp) @api.remat def g(x): return f(f(x)) ans = g(2.) expected = np.sin(np.sin(2.)) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(g)(2.) expected = 4. * api.grad(lambda x: jnp.sin(jnp.sin(x)))(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_higher_order(self): @api.custom_jvp def f(x): return jnp.sin(x) def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * jnp.cos(x) * g f.defjvp(f_jvp) def g(x): return f(f(x)) ans = api.grad(api.grad(api.remat(g)))(2.) expected = api.grad(api.grad(g))(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.remat(api.grad(g)))(2.) expected = api.grad(api.grad(g))(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.grad(api.grad(api.remat(g))))(2.) expected = api.grad(api.grad(api.grad(g)))(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_initial_style_vmap_2(self): # This is like test_initial_style_vmap except the primal function closes # over an array constant. y = jnp.array([1., 2., 3.]) @api.custom_jvp def f(x): assert jnp.ndim(x) == 0 return 3 * x * jnp.sum(y) def f_jvp(primals, tangents): x, = primals g, = tangents return f(x), 2 * g f.defjvp(f_jvp) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.grad(lambda x: api.vmap(foo)(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.vmap(api.jit(foo))(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.jit(api.vmap(foo))(x).sum())(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.jit(lambda x: api.vmap(foo)(x).sum()))(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.jit(api.grad(lambda x: api.vmap(foo)(x).sum()))(jnp.ones(3)) expected = 2. * jnp.ones(3) self.assertAllClose(ans, expected, check_dtypes=False) class CustomVJPTest(jtu.JaxTestCase): def test_basic(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) x = 3. self.assertAllClose(f(x), jnp.sin(x)) self.assertAllClose(api.grad(f)(x), 2 * jnp.cos(x)) self.assertAllClose(api.value_and_grad(f)(x), (jnp.sin(x), 2 * jnp.cos(x))) def test_invariance(self): @api.custom_vjp def f(x): return jnp.cos(2 * x) / 2. def f_fwd(x): return (f(x), x) def f_rev(x, g): return (g * 3,) f.defvjp(f_fwd, f_rev) def f2(x): y, _ = api.value_and_grad(f)(x) return y def f3(x): y, _ = api.value_and_grad(f2)(x) return y x = 1. self.assertAllClose(f(x), f2(x), check_dtypes=False) self.assertAllClose(f(x), f3(x), check_dtypes=False) self.assertAllClose(api.grad(f)(x), api.grad(f2)(x), check_dtypes=False) self.assertAllClose(api.grad(f)(x), api.grad(f3)(x), check_dtypes=False) def test_python_control_flow(self): @api.custom_vjp def f(x): if x > 0: return jnp.sin(x) else: return jnp.cos(x) def f_fwd(x): if x > 0: return f(x), x else: return f(x), x def f_rev(x, g): if x > 0: return (2 * g,) else: return (3 * g,) f.defvjp(f_fwd, f_rev) x = 2. self.assertAllClose(f(x), jnp.sin(x)) self.assertAllClose(f(-x), jnp.cos(-x)) self.assertAllClose(api.value_and_grad(f)(x), (jnp.sin(x), 2.), check_dtypes=False) self.assertAllClose(api.value_and_grad(f)(-x), (jnp.cos(-x), 3.), check_dtypes=False) def test_vmap(self): @api.custom_vjp def f(x): assert jnp.ndim(x) == 0 return jnp.sin(x) def f_fwd(x): assert jnp.ndim(x) == 0 return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) x = jnp.arange(3.) xx = jnp.arange(6.).reshape(2, 3) # vmap of f self.assertAllClose(api.vmap(f)(x), jnp.sin(x)) self.assertAllClose(api.vmap(api.vmap(f))(xx), jnp.sin(xx)) # vmap of grad of f self.assertAllClose(api.vmap(api.grad(f))(x), 2 * jnp.cos(x)) self.assertAllClose(api.vmap(api.value_and_grad(f))(x), (jnp.sin(x), 2 * jnp.cos(x))) self.assertAllClose(api.vmap(api.vmap(api.grad(f)))(xx), 2 * jnp.cos(xx)) self.assertAllClose(api.vmap(api.vmap(api.value_and_grad(f)))(xx), (jnp.sin(xx), 2 * jnp.cos(xx))) # grad of vmap of f self.assertAllClose(api.grad(lambda x: api.vmap(f)(x).sum())(x), 2 * jnp.cos(x)) self.assertAllClose(api.grad(lambda x: api.vmap(api.vmap(f))(x).sum())(xx), 2 * jnp.cos(xx)) # vmap of grad of vmap of f self.assertAllClose(api.vmap(api.grad(lambda x: api.vmap(f)(x).sum()))(xx), 2 * jnp.cos(xx)) def test_jit(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) x = 3. # jit self.assertAllClose(api.jit(f)(x), jnp.sin(x)) self.assertAllClose(api.jit(api.jit(f))(x), jnp.sin(x)) # jit of grad self.assertAllClose(api.jit(api.grad(f))(x), 2 * jnp.cos(x), check_dtypes=False) # grad of jit self.assertAllClose(api.grad(api.jit(f))(x), 2 * jnp.cos(x), check_dtypes=False) def test_pytrees(self): @api.custom_vjp def f(x): return {'b': jnp.sin(x['a'])} def f_fwd(x): return f(x), {'r': jnp.cos(x['a'])} def f_bwd(res, g): cos_x = res['r'] return ({'a': 2 * cos_x * g['b']},) f.defvjp(f_fwd, f_bwd) x = {'a': 3.} self.assertAllClose(f(x)['b'], jnp.sin(x['a'])) self.assertAllClose(api.grad(lambda x: f(x)['b'])(x), {'a': 2 * jnp.cos(x['a'])}) def test_jvp_error(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) self.assertRaisesRegex( TypeError, r"can't apply forward-mode autodiff \(jvp\) to a custom_vjp function.", lambda: api.jvp(f, (3.,), (1.,))) self.assertRaisesRegex( TypeError, r"can't apply forward-mode autodiff \(jvp\) to a custom_vjp function.", lambda: api.jvp(api.vmap(f), (jnp.arange(3.),), (jnp.ones(3),))) self.assertRaisesRegex( TypeError, r"can't apply forward-mode autodiff \(jvp\) to a custom_vjp function.", lambda: api.jvp(jit(f), (3.,), (1.,))) def test_kwargs(self): # from https://github.com/google/jax/issues/1938 @api.custom_vjp def my_fun(x, y, c=1.): return c * (x + y) my_fun.defvjp(lambda x, y, c=1.: (my_fun(c, y, c), None), lambda _, g: (g, g, g)) f = lambda x, y: jnp.square(my_fun(x, y, c=2.)).sum() f(10., 5.) # doesn't crash api.grad(f)(10., 5.) # doesn't crash def test_initial_style(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.grad(foo)(3.) expected = 2. * jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.grad(foo))(3.) expected = -2. * jnp.sin(3.) self.assertAllClose(ans, expected) def test_initial_style_vmap(self): @api.custom_vjp def f(x): assert jnp.ndim(x) == 0 return 3 * x def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.vmap(foo)(jnp.arange(3.)) expected = 3. * jnp.arange(3.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.vmap(foo)(x).sum())(jnp.arange(3.)) expected = 2. * jnp.cos(jnp.arange(3.)) self.assertAllClose(ans, expected, check_dtypes=False) def test_nondiff_arg(self): @partial(api.custom_vjp, nondiff_argnums=(0,)) def app(f, x): return f(x) def app_fwd(f, x): return app(f, x), jnp.cos(x) def app_rev(f, cos_x, g): return (cos_x * g,) app.defvjp(app_fwd, app_rev) ans = app(lambda x: 2 * x, 1) expected = 2 self.assertAllClose(ans, expected, check_dtypes=False) ans = api.value_and_grad(lambda x: app(lambda y: 2 * y, x))(1.) expected = (2., jnp.cos(1.)) self.assertAllClose(ans, expected, check_dtypes=False) def test_nondiff_arg_tracer(self): # This test is now skipped because we decided not to support this behavior # anymore (namely, nondiff args can't be tracers), but # test_closed_over_tracer is a replacement test for analogous behavior that # we do support raise unittest.SkipTest("removed support for tracers in nondiff args") @partial(api.custom_vjp, nondiff_argnums=(0,)) def f(x, y): return x * y def f_fwd(x, y): return f(x, y), jnp.cos(y) def f_rev(x, cos_y, g): return (cos_y * g,) f.defvjp(f_fwd, f_rev) @jit def g(x, y): return f(x, y) ans = g(2, 3.) expected = 6. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(g, 1)(2., 3.) expected = jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_closed_over_tracer(self): # This test is similar to test_nondiff_arg_tracer except it uses lexical # closure rather than the nondiff_argnums mechanism. We decided to disallow # tracers in nondiff_argnums to greatly simplify bookkeeping while still # supporting the cases for which it is necessary. def outer(x): @api.custom_vjp def f(y): return x * y def f_fwd(y): return f(y), jnp.cos(y) def f_rev(cos_y, g): return (cos_y * g,) f.defvjp(f_fwd, f_rev) return f @jit def g(x, y): return outer(x)(y) ans = g(2, 3.) expected = 6. self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(g, 1)(2., 3.) expected = jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_closed_over_tracer2(self): def outer(x): @api.custom_vjp def f(y): return x * y def f_fwd(y): return f(y), jnp.cos(y) def f_rev(cos_y, g): return (cos_y * g,) f.defvjp(f_fwd, f_rev) return f @api.vmap def g(x): return outer(x)(3.) ans = g(np.arange(3.)) expected = np.arange(3.) * 3 self.assertAllClose(ans, expected, check_dtypes=False) def test_closed_over_tracer3(self): def outer(x): @api.custom_vjp def f(y): return x * y def f_fwd(y): return f(y), (x, jnp.cos(y)) def f_rev(res, g): x, cos_y = res return (cos_y * g * x,) f.defvjp(f_fwd, f_rev) return api.grad(f) @api.vmap def g(x): return outer(x)(3.) ans = g(np.arange(3.)) expected = np.cos(3.) * np.arange(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_nondiff_arg_tracer_error(self): # This is similar to the old (now skipped) test_nondiff_arg_tracer, except # we're testing for the error message that that usage pattern now raises. @partial(api.custom_vjp, nondiff_argnums=(0,)) def f(x, y): return x * y def f_fwd(x, y): return f(x, y), jnp.cos(y) def f_rev(x, cos_y, g): return (cos_y * g,) f.defvjp(f_fwd, f_rev) @jit def g(x, y): return f(x, y) with self.assertRaisesRegex(core.UnexpectedTracerError, "custom_vjp"): _ = g(2, 3.) with self.assertRaisesRegex(core.UnexpectedTracerError, "custom_vjp"): _ = api.grad(g, 1)(2., 3.) def test_vmap_axes(self): raise unittest.SkipTest("TODO") # TODO(mattjj): write test def test_pmap(self): raise unittest.SkipTest("TODO") # TODO(mattjj): write test def test_missing_vjp_rule_error(self): @api.custom_vjp def foo(x): return x ** 2 self.assertRaisesRegex( AttributeError, r"No VJP defined for custom_vjp function foo using defvjp.", lambda: foo(2)) self.assertRaisesRegex( AttributeError, r"No VJP defined for custom_vjp function foo using defvjp.", lambda: api.grad(foo)(2.)) def test_vjp_rule_inconsistent_pytree_structures_error(self): @api.custom_vjp def f(x): return x def foo_fwd(x): return x, None def foo_bwd(_, g): return (g, g) f.defvjp(foo_fwd, foo_bwd) f(2) # doesn't crash self.assertRaisesRegex( TypeError, re.escape( "Custom VJP rule must produce an output with the same container " "(pytree) structure as the args tuple of the primal function, " "and in particular must produce a tuple of length equal to the " "number of arguments to the primal function, but got VJP output " "structure {} for primal input structure {}.".format( tree_util.tree_structure((1, 1)), tree_util.tree_structure((1,))) ), lambda: api.grad(f)(2.)) def test_vjp_bwd_returns_non_tuple_error(self): @api.custom_vjp def f(x): return x def foo_fwd(x): return x, None def foo_bwd(_, g): return 2. * g # Should be a tuple f.defvjp(foo_fwd, foo_bwd) with self.assertRaisesRegex(TypeError, "Custom VJP rule .* must produce a tuple"): api.grad(f)(3.) def test_issue2511(self): arr = jnp.ones((5, 2, 2)) foo = lambda x: api.vmap(jnp.linalg.det, (0,))(x) api.jit(foo)(arr) # doesn't crash def test_lowering_out_of_traces(self): # https://github.com/google/jax/issues/2578 class F(collections.namedtuple("F", ["a"])): def __call__(self, x): return jax.nn.relu(self.a) * x @jax.jit def g(f, x): return f(x) jax.grad(g, argnums=(1,))(F(2.0), 0.) # doesn't crash def test_nondiff_argnums_stop_gradient(self): # This test is now skipped because we decided not to support this behavior # anymore (namely, nondiff args can't be tracers), but test_clip_gradient is # a replacement showing behavior we do support. raise unittest.SkipTest("removed support for tracers in nondiff args") # https://github.com/google/jax/issues/2784 @partial(api.custom_vjp, nondiff_argnums=(0, 1)) def _clip_gradient(lo, hi, x): return x # identity function def clip_gradient_fwd(lo, hi, x): # return x, None return x, (hi, ) def clip_gradient_bwd(lo, hi, _, g): return (jnp.clip(g, lo, hi),) _clip_gradient.defvjp(clip_gradient_fwd, clip_gradient_bwd) def clip_gradient(x): lo = -1 hi = x + 1 # causes things to break return _clip_gradient(lo, hi, x) jax.grad(clip_gradient)(1.) # doesn't crash def test_clip_gradient(self): # https://github.com/google/jax/issues/2784 @api.custom_vjp def _clip_gradient(lo, hi, x): return x # identity function when not differentiating def clip_gradient_fwd(lo, hi, x): return x, (lo, hi,) def clip_gradient_bwd(res, g): lo, hi = res return (None, None, jnp.clip(g, lo, hi),) _clip_gradient.defvjp(clip_gradient_fwd, clip_gradient_bwd) def clip_gradient(x): lo = -0.1 hi = x + 0.1 return _clip_gradient(lo, hi, x) g = jax.grad(clip_gradient)(0.1) # doesn't crash self.assertAllClose(g, jnp.array(0.2)) def test_nestable_vjp(self): # Verify that https://github.com/google/jax/issues/3667 is resolved. def f(x): return x ** 2 @api.custom_vjp def g(x): return f(x) def g_fwd(x): y, f_vjp = api.vjp(f, x) return y, f_vjp def g_bwd(f_vjp, y_bar): return f_vjp(y_bar) g.defvjp(g_fwd, g_bwd) # Check that VJP can be nested in simple situations. For this to pass, # vjp has to return a PyTree. _, g_vjp = api.vjp(g, 1.0) y, = g_vjp(1.0) self.assertAllClose(y, jnp.array(2.0)) # Check that VJP can be nested in complex situations. For this to pass, # vjp can't treat the closed-over tracer x as a static argument. @jit def z(x): _, g_vjp = api.vjp(g, x) return g_vjp y, = z(1.0)(3.0) self.assertAllClose(y, jnp.array(6.0)) def test_initial_style_vmap_2(self): # https://github.com/google/jax/issues/4173 x = jnp.ones((10, 3)) # Create the custom function @api.custom_vjp def custom_fun(x): return x.sum() def forward(x): return x.sum(), (jnp.ones_like(x),) def backward(res, g): return g * res[0], custom_fun.defvjp(forward, backward) def train_fun(x): def summed_fun(x): return api.vmap(custom_fun)(x).sum() return api.grad(summed_fun)(x) def scan_body(carry, inputs): x = carry return carry, train_fun(x) scan_range = jnp.arange(4) lax.scan(scan_body, x, scan_range) # don't crash def test_initial_style_vmap_3(self): # This is like test_initial_style_vmap except the primal function closes # over an array constant. y = jnp.array([1., 2., 3.]) @api.custom_vjp def f(x): assert jnp.ndim(x) == 0 return 3 * x * jnp.sum(y) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) def foo(x): out, _ = lax.scan(lambda c, _: (f(c), None), x, None, length=1) return out ans = api.vmap(foo)(jnp.arange(3.)) expected = 3. * jnp.arange(3.) * 6 self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(lambda x: api.vmap(foo)(x).sum())(jnp.arange(3.)) expected = 2. * jnp.cos(jnp.arange(3.)) self.assertAllClose(ans, expected, check_dtypes=False) def test_bwd_closes_over_tracer(self): def f(y): @jax.custom_vjp def f(x): return 2. * jnp.sin(x) def fwd(x): return f(x), () def bwd(_, g): return (2. * jnp.cos(y) * g,) # capture! f.defvjp(fwd, bwd) return jax.grad(f)(1.) ans = jax.jit(f)(2.) self.assertAllClose(ans, 2. * jnp.cos(2.)) ans = jax.vmap(f)(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.jit(jax.vmap(f))(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.vmap(jax.jit(f))(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.grad(f)(4.) self.assertAllClose(ans, -2. * jnp.sin(4.)) def test_fwd_closes_over_tracer(self): def f(y): @jax.custom_vjp def f(x): return 2. * jnp.sin(x) def fwd(x): return f(x), y def bwd(y, g): return (2. * jnp.cos(y) * g,) # capture! f.defvjp(fwd, bwd) return jax.grad(f)(1.) ans = jax.jit(f)(2.) self.assertAllClose(ans, 2. * jnp.cos(2.)) ans = jax.vmap(f)(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.jit(jax.vmap(f))(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.vmap(jax.jit(f))(jnp.arange(3.)) self.assertAllClose(ans, 2. * jnp.cos(jnp.arange(3.))) ans = jax.grad(f)(4.) self.assertAllClose(ans, -2. * jnp.sin(4.)) def test_float0(self): @api.custom_vjp def f(x, _): return x def f_fwd(x, _): # we need a defined (non-float0) tangent to trigger the rule return x, (2., 1) def f_rev(*_): return (2., 1) f.defvjp(f_fwd, f_rev) x = 2. y = 3 self.assertEqual(api.grad(f, allow_int=True, argnums=(0, 1))(x, y), (2., np.zeros(shape=(), dtype=float0))) def test_float0_initial_style(self): @api.custom_vjp def f(x): return x def f_fwd(x): return x, (2., x) def f_rev(*_): return ((2., 1),) f.defvjp(f_fwd, f_rev) def foo(x, y): out, _ = lax.scan(lambda c, _: (f(c), None), (x, y), None, length=1) return out[0] x = 2. y = 3 self.assertEqual(api.grad(foo, allow_int=True, argnums=(0, 1))(x, y), (2., np.zeros(shape=(), dtype=float0))) def test_remat(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) @api.remat def g(x): return f(f(x)) ans = g(2.) expected = np.sin(np.sin(2.)) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(g)(2.) expected = 4. * api.grad(lambda x: jnp.sin(jnp.sin(x)))(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_remat_higher_order(self): @api.custom_vjp def f(x): return jnp.sin(x) def f_fwd(x): return f(x), jnp.cos(x) def f_rev(cos_x, g): return (2 * cos_x * g,) f.defvjp(f_fwd, f_rev) def g(x): return f(f(x)) ans = api.grad(api.grad(api.remat(g)))(2.) expected = api.grad(api.grad(g))(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.remat(api.grad(g)))(2.) expected = api.grad(api.grad(g))(2.) self.assertAllClose(ans, expected, check_dtypes=False) ans = api.grad(api.grad(api.grad(api.remat(g))))(2.) expected = api.grad(api.grad(api.grad(g)))(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_bwd_nones(self): @api.custom_vjp def f(x, y): return x * jnp.sin(y) def f_fwd(x, y): return f(x, y), jnp.cos(y) def f_rev(cos, g): return (None, 2 * cos * g) f.defvjp(f_fwd, f_rev) ans = api.grad(lambda x: f(x, x))(3.) expected = 2 * jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_bwd_nones_vmap(self): @api.custom_vjp def f(x, y): return x * jnp.sin(y) def f_fwd(x, y): return f(x, y), jnp.cos(y) def f_rev(cos, g): return (None, 2 * cos * g) f.defvjp(f_fwd, f_rev) ans = api.grad(lambda x: api.vmap(f)(x, x).sum())(jnp.arange(3.)) expected = 2 * jnp.cos(jnp.arange(3.)) self.assertAllClose(ans, expected, check_dtypes=False) def test_bwd_nones_pytree(self): @api.custom_vjp def f(xs, y): x1, x2 = xs return x1 * x2 * jnp.sin(y) def f_fwd(xs, y): return f(xs, y), jnp.cos(y) def f_rev(cos, g): return (None, 2 * cos * g) f.defvjp(f_fwd, f_rev) ans = api.grad(lambda x: f((x, x), x))(3.) expected = 2 * jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_custom_vjp_closure_4521(self): # https://github.com/google/jax/issues/4521 @api.custom_vjp def g(x, y): return None def g_fwd(x, y): return None, y def g_bwd(residuals, z_bar): assert False g.defvjp(g_fwd, g_bwd) def f(xs, y): v_g = api.vmap(g, in_axes=(0, None), out_axes=None) v_g(xs, y) def scan_body(xs, _): y = jnp.zeros(1) _, vjp_f = api.vjp(f, xs, y) vjp_f(None) return xs, None lax.scan(scan_body, jnp.ones(5), None, 100) # doesn't crash def test_float0_bwd_none(self): @api.custom_vjp def f(i, x): return jnp.sin(x) def f_fwd(i, x): return f(i, x), jnp.cos(x) def f_rev(cos_x, g): return (None, 2 * cos_x * g) f.defvjp(f_fwd, f_rev) ans = api.grad(f, 1)(jnp.array([1, 2]), 3.) # doesn't crash expected = 2 * jnp.cos(3.) self.assertAllClose(ans, expected, check_dtypes=False) def test_custom_gradient(self): @api.custom_gradient def f(x): return x ** 2, lambda g: (g * x,) self.assertAllClose(f(3.), 9., check_dtypes=False) self.assertAllClose(api.grad(f)(3.), 3., check_dtypes=False) self.assertAllClose(api.grad(api.grad(f))(3.), 1., check_dtypes=False) def test_custom_gradient_2(self): @api.custom_gradient def f(x, y): return x * y, lambda g: (y, x) self.assertAllClose(f(3., 4.), 12., check_dtypes=False) self.assertAllClose(api.grad(f, argnums=(0, 1))(3., 4.), (4., 3.), check_dtypes=False) def test_custom_gradient_3(self): @api.custom_gradient def f(x): vjp = lambda g: (jnp.cos(x) * jnp.array([3., 4., 5.]),) return jnp.sum(jnp.sin(x)), vjp self.assertAllClose(f(jnp.arange(3)), jnp.sum(jnp.sin(jnp.arange(3.))), check_dtypes=False) self.assertAllClose( api.grad(f)(jnp.arange(3.)), api.grad(lambda x: jnp.sum(jnp.sin(x)))(jnp.arange(3.)) * jnp.array([3., 4., 5.]), check_dtypes=False) def test_custom_gradient_can_return_singleton_value_in_vjp(self): @api.custom_gradient def f(x): return x ** 2, lambda g: g * x self.assertAllClose(f(3.), 9., check_dtypes=False) self.assertAllClose(api.grad(f)(3.), 3., check_dtypes=False) self.assertAllClose(api.grad(api.grad(f))(3.), 1., check_dtypes=False) def test_closure_convert(self): def minimize(objective_fn, x0): converted_fn, aux_args = api.closure_convert(objective_fn, x0) return _minimize(converted_fn, x0, *aux_args) @partial(api.custom_vjp, nondiff_argnums=(0,)) def _minimize(objective_fn, x0, *args): _ = objective_fn(x0, *args) return jnp.cos(x0) def fwd(objective_fn, x0, *args): y = _minimize(objective_fn, x0, *args) return y, (y, args) def rev(objective_fn, res, g): y, args = res x0_bar = 17. * y args_bars = [42. * a for a in args] return (x0_bar, *args_bars) _minimize.defvjp(fwd, rev) def obj(c, x): return jnp.sum((x - c) ** 2.) def solve(c, x): def closure(x): return obj(c, x) return jnp.sum(minimize(closure, x)) c, x = jnp.ones(2), jnp.zeros(2) self.assertAllClose(solve(c, x), 2.0, check_dtypes=False) g_c, g_x = api.grad(solve, argnums=(0, 1))(c, x) self.assertAllClose(g_c, 42. * jnp.ones(2), check_dtypes=False) self.assertAllClose(g_x, 17. * jnp.ones(2), check_dtypes=False) class CustomTransposeTest(jtu.JaxTestCase): def transpose(self, f, x_example): def transposed(y): x, = api.linear_transpose(f, x_example)(y) return x return transposed def test_linear_call(self): def f(x, y): def fn(r, x): return x / r def tp(r, t): return t / r return x + api.linear_call(fn, tp, y, x) def f_ref(x, y): return x + x / y x = jnp.ones(2) * 6. y = jnp.ones(2) * 3. self.assertAllClose(f(x, y), f_ref(x, y)) f1 = lambda x: f(x, y) f1_ref = lambda x: f_ref(x, y) self.assertAllClose(self.transpose(f1, x)(x), self.transpose(f1_ref, x)(x)) def test_linear_call_incorrect_transpose(self): def f(x, y): def fn(r, x): return x / r def tp(r, t): return t / (2. * r) # nb: not the true transpose return x + api.linear_call(fn, tp, y, x) def f_ref(x, y): return x + x / y x = jnp.ones(2) * 6. y = jnp.ones(2) * 3. self.assertAllClose(f(x, y), f_ref(x, y)) f1 = lambda x: f(x, y) f1_ref = lambda x: f_ref(x, 2. * y) # nb: double the reference divisor self.assertAllClose(self.transpose(f1, x)(x), self.transpose(f1_ref, x)(x)) def test_linear_call_transpose_transpose_transpose(self): def fn(r, x): return x / r def tp(r, t): return t / (2. * r) # nb: untrue transpose def f_(x, y): return x + api.linear_call(fn, tp, y, x) x = jnp.ones(2) * 6. y = jnp.ones(2) * 3. f = lambda x: f_(x, y) ft = self.transpose(f, x) ftt = self.transpose(ft, x) fttt = self.transpose(ftt, x) self.assertAllClose(ft(x), x + tp(y, x)) self.assertAllClose(f(x), ftt(x)) self.assertAllClose(ft(x), fttt(x)) def test_linear_call_scalar_to_vector(self): def f(c, x): def fn(_, x): return [x, x] def tp(_, t): t1, t2 = t return t1 + t2 return api.linear_call(fn, tp, (), c * x) def f_ref(c, x): return [c * x, c * x] c, x = 2., 3. t = [4., 5.] self.assertAllClose(f(c, x), f_ref(c, x)) self.assertAllClose(self.transpose(partial(f, c), x)(t), self.transpose(partial(f_ref, c), x)(t)) def test_linear_call_nested(self): # identity function with an untrue transpose of 0 def id_(x): def f(_, x): return x def t(_, t): return 0. return api.linear_call(f, t, (), x) # identity function with an untrue transpose of 7, and where both # forward and transpose have custom transpositions that should # never end up invoked. def f(x): def f_(_, x): return id_(x) def t_(_, t): return id_(7.) return api.linear_call(f_, t_, (), x) x = 5. id_t = self.transpose(id_, x) id_tt = self.transpose(id_t, x) ft = self.transpose(f, x) ftt = self.transpose(ft, x) fttt = self.transpose(ftt, x) self.assertAllClose(id_(x), x) self.assertAllClose(id_t(x), 0.) self.assertAllClose(id_tt(x), x) self.assertAllClose(f(x), x) self.assertAllClose(ft(x), 7.) self.assertAllClose(ftt(x), x) self.assertAllClose(fttt(x), 7.) class InvertibleADTest(jtu.JaxTestCase): def test_invertible_basic(self): def f(x): return (jnp.exp(x) * 4) * x finv = jax.invertible(f) x = jnp.ones((5,)) if config.omnistaging_enabled: expected = """ { lambda ; a b. let c = exp a d = mul c 4.0 e = mul d a f = mul b a g = div e a h = mul b g i = div g 4.0 j = mul f 4.0 _ = log i k = mul j i l = add_any h k in (l,) } """ else: expected = """ { lambda ; a b. let c = exp a d = mul c 4.0 e = mul d a f = div e a g = mul b f h = mul b a i = mul h 4.0 j = div f 4.0 k = mul i j l = add_any g k in (l,) } """ jaxpr = jax.make_jaxpr(lambda p, ct: jax.vjp(finv, p)[1](ct))(x, x) self.assertMultiLineStrippedEqual(expected, str(jaxpr)) self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f(x)))(x), jax.value_and_grad(lambda x: np.sum(finv(x)))(x), check_dtypes=True) def test_invertible_blocks(self): # NB: This is the reversible ResNet block def mk_reversible_block(f, g): @jax.custom_ivjp def rev_block(x1, x2): y1 = f(x2) + x1 y2 = g(y1) + x2 return y1, y2 @rev_block.defivjp def rev_block_ivjp(xs, ys, dys): (y1, y2) = ys (dy1, dy2) = dys dgo, dx2 = dy2, dy2 go, gvjp = jax.vjp(g, y1) dy1 += gvjp(dgo)[0] del gvjp x2 = y2 - go dfo, dx1 = dy1, dy1 fo, fvjp = jax.vjp(f, x2) dx2 += fvjp(dfo)[0] del fvjp x1 = y1 - fo return (x1, x2), (dx1, dx2) return rev_block rev_block = mk_reversible_block(jnp.sin, jnp.cos) def g(x1, x2): for i in range(2): x1, x2 = rev_block(x1, x2) return x1, x2 def reduce(f, x1, x2): y1, y2 = f(x1, x2) return np.sum(y1) + np.sum(y2) x = np.ones((1,)) # FIXME: This breaks when argnums is left as default (i.e. 0), because JVP prunes # zero tangents from call primitives. self.assertAllClose(jax.value_and_grad(partial(reduce, jax.invertible(g)), argnums=(0, 1))(x, x + 2), jax.value_and_grad(partial(reduce, g), argnums=(0, 1))(x, x + 2), check_dtypes=True) def test_invertible_partial_diff(self): # Check that we don't have to differentiate with respect to inputs # of the invertible function. def f(x, y): return (jnp.exp(x) * 4) * x, y + 4 finv = jax.invertible(f) o = np.ones((5,)) self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f(x, o)[0]))(o), jax.value_and_grad(lambda x: np.sum(finv(x, o)[0]))(o), check_dtypes=True) def test_invertible_pytree(self): def f(x, y): return jnp.exp(x[0]) * x[1] + y finv = jax.invertible(f) o = np.ones((5,)) self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f((x, x), x)[0]))(o), jax.value_and_grad(lambda x: np.sum(finv((x, x), x)[0]))(o), check_dtypes=True) class DeprecatedCustomTransformsTest(jtu.JaxTestCase): def test_defvjp_all(self): foo_p = Primitive('foo') def foo(x): return 2. * foo_p.bind(x) ad.defvjp_all(foo_p, lambda x: (x**2, lambda g: (4 * g * jnp.sin(x),))) val_ans, grad_ans = api.value_and_grad(foo)(3.) self.assertAllClose(val_ans, 2 * 3.**2, check_dtypes=False) self.assertAllClose(grad_ans, 4 * 2 * np.sin(3.), check_dtypes=False) def test_defvjp_all_const(self): foo_p = Primitive('foo') def foo(x): return foo_p.bind(x) ad.defvjp_all(foo_p, lambda x: (x**2, lambda g: (12.,))) val_ans, grad_ans = api.value_and_grad(foo)(3.) self.assertAllClose(val_ans, 9., check_dtypes=False) self.assertAllClose(grad_ans, 12.) def test_defvjp_all_higher_order_revmode(self): foo_p = Primitive('foo') def foo(x): return 2. * foo_p.bind(x) ad.defvjp_all(foo_p, lambda x: (x**2, lambda g: (g * x ** 2,))) ans = api.grad(api.grad(foo))(3.) self.assertAllClose(ans, 2 * 2 * 3., check_dtypes=False) def test_defvjp_all_multiple_arguments(self): # also tests passing in symbolic zero tangents b/c we differentiate wrt only # the first argument in one case foo_p = Primitive('foo') def foo(x, y): return foo_p.bind(x, y) def vjpfun(x, y): out = x**2 + y**3 vjp = lambda g: (g + x + y, g * x * 9.) return out, vjp ad.defvjp_all(foo_p, vjpfun) val_ans, grad_ans = api.value_and_grad(foo)(3., 4.) self.assertAllClose(val_ans, 3.**2 + 4.**3, check_dtypes=False) self.assertAllClose(grad_ans, 1. + 3. + 4., check_dtypes=False) ans = api.grad(foo, (0, 1))(3., 4.) self.assertAllClose(ans, (1. + 3. + 4., 1. * 3. * 9.), check_dtypes=False) def test_defvjp_all_custom_transforms(self): @api.custom_transforms def foo(x): return jnp.sin(x) api.defvjp_all(foo, lambda x: (jnp.sin(x), lambda g: (g * x,))) val_ans, grad_ans = api.value_and_grad(foo)(3.) self.assertAllClose(val_ans, np.sin(3.), check_dtypes=False) self.assertAllClose(grad_ans, 3., check_dtypes=False) # TODO(mattjj): add defvjp_all test with pytree arguments def test_defvjp(self): @api.custom_transforms def foo(x, y): return jnp.sin(x * y) api.defvjp(foo, None, lambda g, _, x, y: g * x * y) val_ans, grad_ans = api.value_and_grad(foo)(3., 4.) self.assertAllClose(val_ans, np.sin(3. * 4.), check_dtypes=False) self.assertAllClose(grad_ans, 0., check_dtypes=False) ans_0, ans_1 = api.grad(foo, (0, 1))(3., 4.) self.assertAllClose(ans_0, 0., check_dtypes=False) self.assertAllClose(ans_1, 3. * 4., check_dtypes=False) def test_defvjp_higher_order(self): @api.custom_transforms def foo(x): return jnp.sin(2. * x) api.defvjp(foo, lambda g, _, x: g * jnp.cos(x)) ans = api.grad(api.grad(foo))(2.) expected = api.grad(api.grad(jnp.sin))(2.) self.assertAllClose(ans, expected, check_dtypes=False) def test_defvjp_use_ans(self): @api.custom_transforms def foo(x, y): return jnp.sin(x * y) api.defvjp(foo, None, lambda g, ans, x, y: g * x * y + jnp.cos(ans)) val_ans, grad_ans = api.value_and_grad(foo, 1)(3., 4.) self.assertAllClose(val_ans, np.sin(3. * 4.), check_dtypes=False) self.assertAllClose(grad_ans, 3. * 4. + np.cos(np.sin(3. * 4)), check_dtypes=False) def test_custom_transforms_eval_with_pytrees(self): @api.custom_transforms def f(x): a, b = x[0], x[1] return {'hi': 2 * a, 'bye': 2 * b} ans = f((1, 2)) self.assertEqual(ans, {'hi': 2 * 1, 'bye': 2 * 2}) def test_custom_transforms_jit_with_pytrees(self): @api.custom_transforms def f(x): a, b = x[0], x[1] return {'hi': 2 * a, 'bye': 2 * b} ans = jit(f)((1, 2)) self.assertEqual(ans, {'hi': 2 * 1, 'bye': 2 * 2}) def test_custom_transforms_jit_with_pytrees_consts(self): # The purpose of this test is to exercise the custom_transforms default # translation rule in how it deals with constants that are too large to be # treated as literals (at the time of writing). z = np.arange(10.) @api.custom_transforms def f(x): a, b = x[0], x[1] return {'hi': 2 * a, 'bye': z * b} ans = jit(f)((1, 2)) self.assertAllClose(ans, {'hi': 2 * 1, 'bye': z * 2}, check_dtypes=False) def test_custom_transforms_jvp_with_pytrees(self): @api.custom_transforms def f(x): a, b = x[0], x[1] return {'hi': 2 * a, 'bye': 2 * b} ans, out_tangent = api.jvp(f, ((1., 2.),), ((3., 4.),)) self.assertEqual(ans, {'hi': 2 * 1, 'bye': 2 * 2}) self.assertEqual(out_tangent, {'hi': 2 * 3, 'bye': 2 * 4}) def test_custom_transforms_vmap_with_pytrees(self): raise unittest.SkipTest("Test deprecated custom_transforms") @api.custom_transforms def f(x): a, b = x[0], x[1] return {'hi': 2 * a, 'bye': 2 * b} ans = api.vmap(f)((np.arange(3), np.ones((3, 2)))) expected = {'hi': 2 * np.arange(3), 'bye': 2 * np.ones((3, 2))} self.assertAllClose(ans, expected, check_dtypes=False) def test_custom_transforms_jvp_with_closure(self): def f(x): @api.custom_transforms def g(y): return x * y return g(x) ans = api.grad(f)(1.) expected = 2. self.assertAllClose(ans, expected, check_dtypes=False) def test_custom_vjp_zeros(self): @api.custom_transforms def f(x, y): return 2 * x, 3 * y def f_vjp(x, y): return (2 * x, 3 * y), lambda ts: (4 * ts[0], 5 * ts[1]) api.defvjp_all(f, f_vjp, ) api.grad(lambda x, y: f(x, y)[0])(1., 2.) # doesn't crash def test_custom_transforms_vjp_nones(self): core.skip_checks = True # Fails with checks # issue raised by jsnoek@ and jumper@ @jax.custom_transforms def solve(a, b): return jnp.dot(jnp.linalg.inv(a), b) # print(solve(a, b)) def solve_vjp(a, b): x = solve(a, b) def vjp(x_tangent): dx = jnp.dot(solve(a, x_tangent), x.T) out = (dx, b * 0.) return out return x, vjp jax.defvjp_all(solve, solve_vjp) gf = grad(lambda a,b: jnp.sum(solve(a, b))) n = 3 a_in = jnp.linspace(0, 1, n)[:, None] a = jnp.dot(a_in, a_in.T) + jnp.eye(n) * 0.1 real_x = np.random.RandomState(0).randn(n) b = jnp.dot(a + jnp.eye(a.shape[0]), real_x) print(gf(a, b)) # doesn't crash class BufferDonationTest(jtu.BufferDonationTestCase): @jtu.skip_on_devices("cpu") # In/out aliasing not supported on CPU. def test_pmap_donate_argnums_invalidates_input(self): move = api.pmap(lambda x: x + x - x, donate_argnums=0) n = jax.local_device_count() x = api.pmap(lambda x: x)(jnp.ones([n])) y = move(x) self.assertDeleted(x) np.testing.assert_allclose(y, [1.] * n) def test_pmap_nested_donate_ignored(self): pmap_fun = jit(lambda x: api.pmap(lambda y: y ** 2, donate_argnums=0)(x)) a = api.pmap(lambda x: x)(jnp.array([1])) # NOTE(mattjj): stopped raising error here and instead just ignored # with self.assertRaisesRegex(ValueError, "nested.*not supported"): # pmap_fun(a) pmap_fun(a) # doesn't crash class NamedCallTest(jtu.JaxTestCase): def test_default_name(self): @api.named_call def my_test_function(x): return x**2 @jax.jit def f(x): return my_test_function(x) c = jax.xla_computation(f)(2) self.assertIn("my_test_function", c.as_hlo_text()) def test_non_jaxtype_arg(self): # For the test to fail without the invalid JaxType filter we need to pass # in a valid JaxType that forces the invalid Jaxtype to be raised to an # abstract value. def f(not_a_jaxtype, a_jaxtype): # then Jax needs to try and evaluate the abstractified non-JaxType if not_a_jaxtype: return a_jaxtype return 0 f = api.named_call(f, name="test") out = jax.jit(f, static_argnums=(0,))("not a Jaxtype", 1) self.assertEqual(out, 1) @parameterized.parameters(jax.jit, jax.grad, jax.vmap, jax.remat) def test_jax_transforms(self, transform): f = jnp.sum x = jnp.array([1.]) unnamed_out = transform(f)(x) named_out = transform(api.named_call(f, name="test"))(x) self.assertEqual(unnamed_out, named_out) def test_static_argnums(self): f = api.named_call(lambda x, y: y if x else None, name="test") f = jax.jit(f, static_argnums=(0,)) out = f(True, 5) self.assertEqual(out, 5) def test_partial_eval(self): f = api.named_call(lambda x, y: y if x else None, name="test") f = jax.jit(functools.partial(f, True)) out = f(5) self.assertEqual(out, 5) if __name__ == '__main__': absltest.main(testLoader=jtu.JaxTestLoader())
the-stack_106_32267
#!/usr/bin/env python3 # Copyright (c) 2015-2016 The XRJV1 Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. # # Test PrioritiseTransaction code # from test_framework.test_framework import XRJV1TestFramework from test_framework.util import * from test_framework.mininode import COIN, MAX_BLOCK_BASE_SIZE class PrioritiseTransactionTest(XRJV1TestFramework): def __init__(self): super().__init__() self.setup_clean_chain = True self.num_nodes = 1 self.txouts = gen_return_txouts() def setup_network(self): self.nodes = [] self.is_network_split = False self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-printpriority=1"])) self.relayfee = self.nodes[0].getnetworkinfo()['relayfee'] def run_test(self): utxo_count = 90 utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], utxo_count) base_fee = self.relayfee*100 # our transactions are smaller than 100kb txids = [] # Create 3 batches of transactions at 3 different fee rate levels range_size = utxo_count // 3 for i in range(3): txids.append([]) start_range = i * range_size end_range = start_range + range_size txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[start_range:end_range], end_range - start_range, (i+1)*base_fee) # Make sure that the size of each group of transactions exceeds # MAX_BLOCK_BASE_SIZE -- otherwise the test needs to be revised to create # more transactions. mempool = self.nodes[0].getrawmempool(True) sizes = [0, 0, 0] for i in range(3): for j in txids[i]: assert(j in mempool) sizes[i] += mempool[j]['size'] assert(sizes[i] > MAX_BLOCK_BASE_SIZE) # Fail => raise utxo_count # add a fee delta to something in the cheapest bucket and make sure it gets mined # also check that a different entry in the cheapest bucket is NOT mined (lower # the priority to ensure its not mined due to priority) self.nodes[0].prioritisetransaction(txids[0][0], 0, int(3*base_fee*COIN)) self.nodes[0].prioritisetransaction(txids[0][1], -1e15, 0) self.nodes[0].generate(1) mempool = self.nodes[0].getrawmempool() print("Assert that prioritised transaction was mined") assert(txids[0][0] not in mempool) assert(txids[0][1] in mempool) high_fee_tx = None for x in txids[2]: if x not in mempool: high_fee_tx = x # Something high-fee should have been mined! assert(high_fee_tx != None) # Add a prioritisation before a tx is in the mempool (de-prioritising a # high-fee transaction so that it's now low fee). self.nodes[0].prioritisetransaction(high_fee_tx, -1e15, -int(2*base_fee*COIN)) # Add everything back to mempool self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) # Check to make sure our high fee rate tx is back in the mempool mempool = self.nodes[0].getrawmempool() assert(high_fee_tx in mempool) # Now verify the modified-high feerate transaction isn't mined before # the other high fee transactions. Keep mining until our mempool has # decreased by all the high fee size that we calculated above. while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]): self.nodes[0].generate(1) # High fee transaction should not have been mined, but other high fee rate # transactions should have been. mempool = self.nodes[0].getrawmempool() print("Assert that de-prioritised transaction is still in mempool") assert(high_fee_tx in mempool) for x in txids[2]: if (x != high_fee_tx): assert(x not in mempool) # Create a free, low priority transaction. Should be rejected. utxo_list = self.nodes[0].listunspent() assert(len(utxo_list) > 0) utxo = utxo_list[0] inputs = [] outputs = {} inputs.append({"txid" : utxo["txid"], "vout" : utxo["vout"]}) outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee raw_tx = self.nodes[0].createrawtransaction(inputs, outputs) tx_hex = self.nodes[0].signrawtransaction(raw_tx)["hex"] txid = self.nodes[0].sendrawtransaction(tx_hex) # A tx that spends an in-mempool tx has 0 priority, so we can use it to # test the effect of using prioritise transaction for mempool acceptance inputs = [] inputs.append({"txid": txid, "vout": 0}) outputs = {} outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee raw_tx2 = self.nodes[0].createrawtransaction(inputs, outputs) tx2_hex = self.nodes[0].signrawtransaction(raw_tx2)["hex"] tx2_id = self.nodes[0].decoderawtransaction(tx2_hex)["txid"] try: self.nodes[0].sendrawtransaction(tx2_hex) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) # insufficient fee assert(tx2_id not in self.nodes[0].getrawmempool()) else: assert(False) # This is a less than 1000-byte transaction, so just set the fee # to be the minimum for a 1000 byte transaction and check that it is # accepted. self.nodes[0].prioritisetransaction(tx2_id, 0, int(self.relayfee*COIN)) print("Assert that prioritised free transaction is accepted to mempool") assert_equal(self.nodes[0].sendrawtransaction(tx2_hex), tx2_id) assert(tx2_id in self.nodes[0].getrawmempool()) if __name__ == '__main__': PrioritiseTransactionTest().main()
the-stack_106_32268
# # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. """ A TaskGroup is a collection of closely related tasks on the same DAG that should be grouped together when the DAG is displayed graphically. """ import functools from inspect import signature from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar, overload from airflow.utils.task_group import TaskGroup if TYPE_CHECKING: from airflow.models import DAG F = TypeVar("F", bound=Callable[..., Any]) task_group_sig = signature(TaskGroup.__init__) # This covers the @task_group() case. Annotations are copied from the TaskGroup # class, only providing a default to 'group_id' (this is optional for the # decorator and defaults to the decorated function's name). Please keep them in # sync with TaskGroup when you can! Note that since this is an overload, these # argument defaults aren't actually used at runtime--the real implementation # does not use them, and simply rely on TaskGroup's defaults, so it's not # disastrous if they go out of sync with TaskGroup. @overload def task_group( group_id: Optional[str] = None, prefix_group_id: bool = True, parent_group: Optional["TaskGroup"] = None, dag: Optional["DAG"] = None, default_args: Optional[Dict[str, Any]] = None, tooltip: str = "", ui_color: str = "CornflowerBlue", ui_fgcolor: str = "#000", add_suffix_on_collision: bool = False, ) -> Callable[[F], F]: ... # This covers the @task_group case (no parentheses). @overload def task_group(python_callable: F) -> F: ... def task_group(python_callable=None, *tg_args, **tg_kwargs): """ Python TaskGroup decorator. This wraps a function into an Airflow TaskGroup. When used as the ``@task_group()`` form, all arguments are forwarded to the underlying TaskGroup class. Can be used to parametrize TaskGroup. :param python_callable: Function to decorate. :param tg_args: Positional arguments for the TaskGroup object. :param tg_kwargs: Keyword arguments for the TaskGroup object. """ def wrapper(f): # Setting group_id as function name if not given in kwarg group_id if not tg_args and 'group_id' not in tg_kwargs: tg_kwargs['group_id'] = f.__name__ task_group_bound_args = task_group_sig.bind_partial(*tg_args, **tg_kwargs) @functools.wraps(f) def factory(*args, **kwargs): # Generate signature for decorated function and bind the arguments when called # we do this to extract parameters so we can annotate them on the DAG object. # In addition, this fails if we are missing any args/kwargs with TypeError as expected. # Apply defaults to capture default values if set. # Initialize TaskGroup with bound arguments with TaskGroup( *task_group_bound_args.args, add_suffix_on_collision=True, **task_group_bound_args.kwargs, ): # Invoke function to run Tasks inside the TaskGroup return f(*args, **kwargs) return factory if callable(python_callable): return wrapper(python_callable) return wrapper
the-stack_106_32269
#!/usr/bin/env python # coding: utf-8 # In[1]: # import libs import pandas as pd # # Dataset # [SP500 Since 1950](https://www.kaggle.com/datasets/benjibb/sp500-since-1950?resource=download) # In[2]: df = pd.read_csv('GSPC.csv') # In[3]: df # In[4]: df.info() # In[5]: df.drop('Date', axis=1, inplace=True) # In[10]: df.sample(5) # In[11]: df[-5::] # In[ ]: # separar a úlitma linha do dataframe futuro = df[-1::] # In[14]: futuro # In[15]: presente = df.drop(df[-1::].index, axis=0) # In[16]: presente.tail() # In[17]: presente['target'] = presente['Close'][1:len(presente)].reset_index(drop=True) # In[20]: presente.tail() # In[19]: presente.head() # In[22]: prev = presente[-1::].drop('target', axis =1) # In[23]: prev # In[24]: treino = presente.drop(presente[-1::].index, axis=0) # In[26]: treino # In[31]: treino.loc[treino['target'] > treino['Close'], 'target'] = 1 treino.loc[treino['target'] != 1, 'target'] = 0 treino['target'] = treino['target'].astype(int) # In[32]: treino # In[37]: y = treino['target'] X = treino.drop('target', axis=1) # In[34]: y # In[38]: X # In[39]: from sklearn.model_selection import train_test_split X_tr, X_ts, y_tr, y_ts = train_test_split(X,y, test_size = 0.3) from sklearn.ensemble import ExtraTreesClassifier modelo = ExtraTreesClassifier() modelo.fit(X_tr, y_tr) resultado = modelo.score(X_ts, y_ts) print (f'Acurácia: {resultado}') # In[40]: prev # In[43]: modelo.predict(prev) # In[42]: futuro # In[44]: prev['target'] = modelo.predict(prev) # In[45]: prev # In[46]: futuro # In[47]: presente # In[48]: presente = presente.append(futuro, sort=True) # In[49]: presente.tail() # In[ ]:
the-stack_106_32270
text = input() result_string = [] digits = [int(i) for i in text if i.isdigit()] non_digits = [i for i in text if not i.isdigit()] take_list = [num for idx, num in enumerate(digits) if idx % 2 == 0] skip_list = [num for idx, num in enumerate(digits) if idx % 2 != 0] take_skip_list = list(zip(take_list, skip_list)) start = 0 end = 0 for step in take_skip_list: take = step[0] skip = step[1] if step[0] != 0: end += take result_string += non_digits[start: end] start += take if skip != 0: end = start + skip start += skip print("".join(result_string))
the-stack_106_32272
import torch from esm import pretrained, ProteinBertModel class FBModel(object): def __init__(self, name, repr_layer=[-1], random_init=False): self.name_ = name self.repr_layer_ = repr_layer model, alphabet = pretrained.load_model_and_alphabet(name) if random_init: # ESM-1b with random initialization, for computational control. model = ProteinBertModel( args=model.args, alphabet=alphabet, ) model.eval() if torch.cuda.is_available(): model = model.cuda() self.model_ = model self.alphabet_ = alphabet self.unk_idx_ = alphabet.tok_to_idx['<unk>'] assert(all( -(model.num_layers + 1) <= i <= model.num_layers for i in [ -1 ] )) self.repr_layers_ = [ (i + model.num_layers + 1) % (model.num_layers + 1) for i in [ -1 ] ] self.vocabulary_ = { tok: self.alphabet_.tok_to_idx[tok] for tok in self.alphabet_.tok_to_idx if '<' not in tok and tok != '.' and tok != '-' }
the-stack_106_32273
#!/usr/bin/python # -*- coding: utf-8 -*- # 'local_data_dir': '/Users/eric/data/mms', # example of setting your local data directory on macOS # 'local_data_dir': 'c:\users\eric\data\mms', and Windows import os CONFIG = {'local_data_dir': 'pydata', 'debug_mode': False, 'download_only': False, 'no_download': False} # override local data directory with environment variables if os.environ.get('ROOT_DATA_DIR'): CONFIG['local_data_dir'] = \ os.sep.join([os.environ['ROOT_DATA_DIR'], 'mms']) if os.environ.get('MMS_DATA_DIR'): CONFIG['local_data_dir'] = os.environ['MMS_DATA_DIR']
the-stack_106_32274
""" This module implements runtime logic to orchestrate the following steps 1. Attach to a target application 2. Resolve and activate probes 3. Resolve and program pmc events 4. Collect profile data for reporting Author: Manikandan Dhamodharan, Morgan Stanley """ import logging from xpedite.txn.classifier import DefaultClassifier from xpedite.types import ResultOrder LOGGER = logging.getLogger(__name__) class AbstractRuntime(object): """ Base class for xpedite runtime to orchestrate a profile session. The Abstract runtime provides implemetation to resolve/enable probes and pmu events """ def __init__(self, app, probes): """ Creates a new instance of Abstract runtime The constructor also instantiates caches for pmu events and topdown metrics :param app: an instance of xpedite app, to interact with target application :type app: xpedite.profiler.app.XpediteApp :param probes: List of probes to be enabled for the current profile session """ from xpedite.profiler.resolver import ProbeResolver from xpedite.pmu.eventsDb import EventsDbCache from xpedite.pmu.topdown import TopdownCache from xpedite.profiler.app import pingApp pingApp(app) self.app = app self.probes = probes self.probeResolver = ProbeResolver() self.cpuInfo = None self.eventsDbCache = EventsDbCache() self.topdownCache = TopdownCache(self.eventsDbCache) self.topdownMetrics = None self.eventSet = None @staticmethod def formatProbes(probes): """ Formats a list of probes to string :param probes: List of probes to be enabled for the current profile session """ probeStr = '' for probe in probes: probeStr = probeStr + '\n\t{}'.format(probe) return probeStr def enableProbes(self, probes): """ Enables the list of given probes :param probes: List of probes to be enabled for the current profile session """ from xpedite.profiler.probeAdmin import ProbeAdmin LOGGER.debug('Enabling probes %s', self.formatProbes(probes)) if probes: if self.eventSet: errMsg = ProbeAdmin.enablePMU(self.app, self.eventSet) if errMsg: msg = 'failed to enable PMU ({})'.format(errMsg) LOGGER.error(msg) raise Exception(msg) (errCount, errMsg) = ProbeAdmin.updateProbes(self.app, probes, targetState=True) if errCount > 0: msg = 'failed to enable probes ({} error(s))\n{}'.format(errCount, errMsg) LOGGER.error(msg) raise Exception(msg) else: LOGGER.warn('failed to enable probes - Invalid or empty probes argument') def resolveProbes(self, probes): """ Checks the validity of the list of given probes :param probes: List of probes to be enabled for the current profile session """ from xpedite.types.probe import AnchoredProbe anchoredProbes = [] LOGGER.debug('Resolving probes %s', self.formatProbes(probes)) for probe in probes: if not probe.isAnchored(): resolvedProbes = self.probeResolver.resolveAnchoredProbe(self.app, probe) if resolvedProbes: for rp in resolvedProbes: anchoredProbe = AnchoredProbe( probe.name, filePath=rp.filePath, lineNo=rp.lineNo, attributes=rp.attributes, isActive=rp.isActive, sysName=rp.sysName ) anchoredProbes.append(anchoredProbe) LOGGER.debug('Resolved probe %s to anchored probe %s', probe, anchoredProbe) else: raise Exception('probe {} cannot be located in app. Please check if it\'s a valid probe'.format( probe.sysName )) else: anchoredProbes.append(probe) return anchoredProbes @staticmethod def resolveEvents(eventsDb, cpuSet, events): """ Resolves a list of given pmu events from events database :param eventsDb: Handle to database of PMU events for the target cpu :param events: List of PMU events to be enabled for the current profile session :param cpuSet: List of cpu, where the userspace pmu collection will be enabled """ from xpedite.pmu.pmuctrl import PMUCtrl return PMUCtrl.resolveEvents(eventsDb, cpuSet, events) @staticmethod def aggregatePmc(pmc): """ Aggreagtes given pmu events to create a unique list of events :param pmc: PMU events to be enabled for the current profile session """ from collections import OrderedDict events = OrderedDict() for counter in pmc: if isinstance(counter, list): for event in counter: events.update({event:0}) else: events.update({counter:0}) return events.keys() def resolveTopdownMetrics(self, pmc): """ Resolves pmu events for given topdown metrics. The method resolves a list of pmu events, for one or more nodes in the topdown hierarchy :param pmc: PMU events to be enabled for the current profile session """ import copy from xpedite.pmu.event import TopdownMetrics from xpedite.pmu.event import Event, TopdownNode, Metric pmc = copy.copy(pmc) topdownNodes = [i for i, counter in enumerate(pmc) if isinstance(counter, (TopdownNode, Metric))] if topdownNodes: topdown = self.topdownCache.get(self.cpuInfo.cpuId) self.topdownMetrics = TopdownMetrics() for index in topdownNodes: node = pmc[index] topdownNode = self.topdownMetrics.add(topdown, node) pmc[index] = [Event( event.name.title().replace('_', '').replace(' ', ''), event.name ) for event in topdownNode.events] return pmc class Runtime(AbstractRuntime): """Xpedite suite runtime to orchestrate profile session""" def __init__(self, app, probes, pmc=None, cpuSet=None, pollInterval=4, samplesFileSize=None, benchmarkProbes=None): """ Creates a new profiler runtime Construction of the runtime will execute the following steps 1. Starts the xpedite app to attach to profiling target 2. Queries and resolves location of probes in profile info 3. Load events and topdown database for the target cpu's micro architecture 4. Resolves pmu events and topdown metrics from events database/topdown hierarchy 5. Opens xpedite device driver to program pmu events and enable userspace pmc collection 6. Activates resolved probes and begins sample collection in the target process :param app: an instance of xpedite app, to interact with target application :type app: xpedite.profiler.app.XpediteApp :param probes: List of probes to be enabled for the current profile session :param pmc: PMU events to be enabled for the current profile session :param cpuSet: List of cpu, where the userspace pmu collection will be enabled :type cpuSet: int :param pollInterval: Sample collection period in milli seconds :type pollInterval: int :param samplesFileSize: Max size of data files used to store samples :type samplesFileSize: int :param benchmarkProbes: optional map to override probes used for benchmarks, defaults to active probes of the current profile session """ from xpedite.dependencies import Package, DEPENDENCY_LOADER DEPENDENCY_LOADER.load(Package.Numpy, Package.FuncTools) if len(probes) < 2: raise Exception('invalid request - profiling needs at least two named probes to be enabled. Found only {}'.format( probes )) try: AbstractRuntime.__init__(self, app, probes) self.benchmarkProbes = benchmarkProbes self.cpuInfo = app.getCpuInfo() eventsDb = self.eventsDbCache.get(self.cpuInfo.cpuId) if pmc else None if pmc: LOGGER.debug('detected %s', eventsDb.uarchSpec) pmc = self.resolveTopdownMetrics(pmc) pmc = self.aggregatePmc(pmc) if not self.app.dryRun: if pmc: self.eventSet = self.app.enablePMU(eventsDb, cpuSet, pmc) anchoredProbes = self.resolveProbes(probes) self.enableProbes(anchoredProbes) self.app.beginProfile(pollInterval, samplesFileSize) else: if pmc: self.eventSet = self.resolveEvents(eventsDb, cpuSet, pmc) LOGGER.warn('DRY Run selected - xpedite won\'t enable probes') except Exception as ex: LOGGER.exception('failed to start profiling') raise ex def report(self, reportName=None, benchmarkPaths=None, classifier=DefaultClassifier(), txnFilter=None, reportThreshold=3000, resultOrder=ResultOrder.WorstToBest): """ Ends active profile session and generates reports. This method executes the following steps 1. Ends samples collection and disconnects tcp connection to target 2. Gathers sample files for the current profile session and loads elapsed time and pmu counters 3. Groups related counters to build transactions and timelines 4. Generates html report and stores results :param reportName: Name of the profile report (Default value = None) :type reportName: str :param benchmarkPaths: List of stored reports from previous runs, for benchmarking (Default value = None) :param classifier: Predicate to classify transactions into different categories (Default value = DefaultClassifier() :type classifier: xpedite.txn.classifier.ProbeDataClassifier :param txnFilter: Lambda to filter transactions prior to report generation :type txnFilter: callable accepting a txn instance and returns a bool :param reportThreshold: Threshold for number of transactions rendered in html reports (Default value = 3000) :type reportThreshold: int :param resultOrder: Default sort order of transactions in latency constituent reports :type resultOrder: xpedite.pmu.ResultOrder """ from xpedite.profiler.reportgenerator import ReportGenerator from xpedite.txn.repo import TxnRepoFactory from xpedite.pmu.event import Event try: if not self.app.dryRun: try: self.app.endProfile() except Exception: pass if self.eventSet: self.app.disablePMU() repoFactory = TxnRepoFactory() pmc = [Event(req.name, req.uarchName) for req in self.eventSet.requests()] if self.eventSet else [] repo = repoFactory.buildTxnRepo( self.app, self.cpuInfo, self.probes, self.topdownCache, self.topdownMetrics, pmc, self.benchmarkProbes, benchmarkPaths ) reportName = reportName if reportName else self.app.name reportGenerator = ReportGenerator(reportName) return reportGenerator.generateReport( self.app, repo, classifier, resultOrder, reportThreshold, txnFilter, benchmarkPaths ) except Exception as ex: LOGGER.exception('failed to generate report') raise ex
the-stack_106_32275
from datetime import datetime import flask from config import Config import requests class OlhoVivoClient(): """ An Client that centralizes the comunication with OlhoVivo API """ def __init__(self): self.url = Config.OLHOVIVO_URL self.token = Config.OLHOVIVO_KEY self.session = requests.session() self.is_connected = False self._connect() def _connect(self): """ Initialize the authentication with OlhoVivo API""" endpoint = self.url + '/Login/Autenticar?token=' + self.token response = self.session.post(endpoint) self.is_connected = response.status_code == 200 return self.is_connected def _get(self, endpoint): """ Default get request for all methods""" url = self.url + endpoint response = self.session.get(url) return response def lines(self, term): """ Search lines by a term in OlhoVivo API""" # Need Improvement if self.is_connected: endpoint = f'/Linha/Buscar?termosBusca={term}' response = self._get(endpoint) lines = response.json() line_objects = [] for line in lines: line_objects.append(Line.fromdict(line)) return line_objects def busstops_of_line(self, code): if self.is_connected: endpoint = f'/Parada/BuscarParadasPorLinha?codigoLinha={code}' response = self._get(endpoint) busstops = response.json() busstop_objects = [] for busstop in busstops: busstop_objects.append(BusStop.fromdict(busstop)) return busstop_objects def preview(self, line, busstop): if self.is_connected: endpoint = f'/Previsao?codigoParada={busstop}&codigoLinha={line}' response = self._get(endpoint) prevision = response.json() try: buses_on_the_way = prevision['p']['l'][0]['vs'] # Lista de veiculos e suas previsoes except TypeError: buses_on_the_way = [] finally: previsions = [] for p in buses_on_the_way: previsions.append(Prevision.fromdict(p)) return previsions class Line(): """ Bus Lines of SPTrans """ # Needs improvement def __init__(self, **kwargs): self.__dict__.update(kwargs) def __repr__(self): """ Define how a Line object will be printed """ return f"{self.lt}-{self.tl} - From {self.get_origin()} To {self.get_destiny()}" def get_origin(self): if self.sl == 1: return self.tp else: return self.ts def get_destiny(self): if self.sl == 2: return self.tp else: return self.ts @classmethod def fromdict(cls, attr : dict): """ Instance a Line object from a dictionary """ # Implement rules here return Line(**attr) class BusStop(): """ Bus Stops """ # Needs improvement def __init__(self, **kwargs): self.__dict__.update(kwargs) @classmethod def fromdict(cls, attr : dict): """ Instance a BusStop object from a dictionary """ # Implement rules here return cls(**attr) def __str__(self): return f"Parada {self.cp} | Nome {self.np} | Endereço: {self.ed}" class Prevision(): """ Prevision for a bus """ # Needs improvement def __init__(self, **kwargs): self.__dict__.update(kwargs) @classmethod def fromdict(cls, attr : dict): """ Instance a prevision object from a dictionary """ # Implement rules here return cls(**attr) def __str__(self): return f"Bus {self.p} | Prevision {self.t} | Localization - Lat:{self.py} x Long: {self.px}"
the-stack_106_32276
import sys if len(sys.argv) != 3: print('Uso ex09-08.py LARGURA LINHAS') else: try: LARGURA = int(sys.argv[1]) LINHA = int(sys.argv[2]) except: print('Voce informou valores invalidos') else: nome_do_arquivo = 'mobydick.txt' def verifica_pagina(arquivo, linha, pagina): if(linha==linhas): rodape = f'= {nome_do_arquivo} - Pagina: {pagina} =' arquivo.write(rodape.center(LARGURA - 1) + '\n') pagina += 1 linha = 1 return linha, pagina def escreve(arquivo, linha, nlinhas, pagina): arquivo.write(linha+'\n') return verifica_pagina(arquivo, nlinhas, pagina) entrada = open(nome_do_arquivo, encoding='utf-8') saida = open('saida_paginada.txt', 'w', encoding='utf-8') pagina = 1 linhas = 1 for linha in entrada.readlines(): palavras = linha.rstrip().split(" ") linha = '' for p in palavras: p = p.strip() if len(linha) + len(p) + 1 > LARGURA: linhas, pagina = escreve(saida, linha, linhas, pagina) linha = '' linha += p+'' if(linha != ''): linhas, pagina = escreve(saida, linha, linhas, pagina) while(linhas!=1): linhas, pagina = escreve(saida, '', linha, pagina) entrada.close() saida.close()
the-stack_106_32277
#!/usr/bin/env python #pylint: skip-file # This source code is licensed under the Apache license found in the # LICENSE file in the root directory of this project. class ActionProperty(object): def __init__(self): """ Attributes: swaggerTypes (dict): The key is attribute name and the value is attribute type. attributeMap (dict): The key is attribute name and the value is json key in definition. """ self.swaggerTypes = { 'bandwidthProfileId': 'str', 'priorityLevel': 'str', 'experienceLevel': 'str', 'destinations': 'list[str]', 'pathPreference': 'str', 'maintainExperience': 'str', 'trustLevel': 'str', 'pathControlFlag': 'bool', 'pathPreferenceFlag': 'bool', 'PrimaryPathPref': 'list[str]', 'SecondaryPathPref': 'list[str]', 'PathOfLastResort': 'str', 'TertiaryPathPref': 'list[str]', 'relevanceLevel': 'str' } self.attributeMap = { 'bandwidthProfileId': 'bandwidthProfileId', 'priorityLevel': 'priorityLevel', 'experienceLevel': 'experienceLevel', 'destinations': 'destinations', 'pathPreference': 'pathPreference', 'maintainExperience': 'maintainExperience', 'trustLevel': 'trustLevel', 'pathControlFlag': 'pathControlFlag', 'pathPreferenceFlag': 'pathPreferenceFlag', 'PrimaryPathPref': 'PrimaryPathPref', 'SecondaryPathPref': 'SecondaryPathPref', 'PathOfLastResort': 'PathOfLastResort', 'TertiaryPathPref': 'TertiaryPathPref', 'relevanceLevel': 'relevanceLevel' } #ID of the bandwidth profile self.bandwidthProfileId = None # str #priority level for a policy self.priorityLevel = None # str #experience level for a policy self.experienceLevel = None # str self.destinations = None # list[str] #path preference for a policy self.pathPreference = None # str self.maintainExperience = None # str #trust level for a policy self.trustLevel = None # str #path control flag self.pathControlFlag = None # bool #path preference flag self.pathPreferenceFlag = None # bool self.PrimaryPathPref = None # list[str] self.SecondaryPathPref = None # list[str] self.PathOfLastResort = None # str self.TertiaryPathPref = None # list[str] #relevance level for a policy self.relevanceLevel = None # str
the-stack_106_32278
import re import subprocess import sys import pytest import ray from ray.test_utils import run_string_as_driver_nonblocking def test_worker_stdout(): script = """ import ray import sys ray.init(num_cpus=2) @ray.remote def foo(out_str, err_str): print(out_str) print(err_str, file=sys.stderr) ray.get(foo.remote("abc", "def")) """ proc = run_string_as_driver_nonblocking(script) out_str = proc.stdout.read().decode("ascii") err_str = proc.stderr.read().decode("ascii") assert out_str.endswith("abc\n") assert err_str.split("\n")[-2].endswith("def") def test_output(): # Use subprocess to execute the __main__ below. outputs = subprocess.check_output( [sys.executable, __file__, "_ray_instance"], stderr=subprocess.STDOUT).decode() lines = outputs.split("\n") for line in lines: print(line) assert len(lines) == 3, lines logging_header = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}\sINFO\s" assert re.match( logging_header + r"resource_spec.py:\d+ -- Starting Ray with [0-9\.]+ " r"GiB memory available for workers and up to [0-9\.]+ GiB " r"for objects. You can adjust these settings with .*?.", lines[0]) assert re.match( logging_header + r"services.py:\d+ -- View the Ray dashboard at .*?localhost:\d+?.*", lines[1]) if __name__ == "__main__": if len(sys.argv) > 1 and sys.argv[1] == "_ray_instance": ray.init(num_cpus=1) ray.shutdown() else: sys.exit(pytest.main(["-v", __file__]))
the-stack_106_32280
# -*- coding: utf-8 -*- # Unit tests for cache framework # Uses whatever cache backend is set in the test settings file. from __future__ import absolute_import, unicode_literals import hashlib import os import random import re import string import tempfile import time import warnings import pickle from django.conf import settings from django.core import management from django.core.cache import get_cache from django.core.cache.backends.base import (CacheKeyWarning, InvalidCacheBackendError) from django.core.context_processors import csrf from django.db import router, transaction from django.core.cache.utils import make_template_fragment_key from django.http import (HttpResponse, HttpRequest, StreamingHttpResponse, QueryDict) from django.middleware.cache import (FetchFromCacheMiddleware, UpdateCacheMiddleware, CacheMiddleware) from django.middleware.csrf import CsrfViewMiddleware from django.template import Template from django.template.response import TemplateResponse from django.test import TestCase, TransactionTestCase, RequestFactory from django.test.utils import override_settings, IgnorePendingDeprecationWarningsMixin from django.utils import six, timezone, translation, unittest from django.utils.cache import (patch_vary_headers, get_cache_key, learn_cache_key, patch_cache_control, patch_response_headers) from django.utils.encoding import force_text from django.views.decorators.cache import cache_page from .models import Poll, expensive_calculation # functions/classes for complex data type tests def f(): return 42 class C: def m(n): return 24 class DummyCacheTests(unittest.TestCase): # The Dummy cache backend doesn't really behave like a test backend, # so it has different test requirements. backend_name = 'django.core.cache.backends.dummy.DummyCache' def setUp(self): self.cache = get_cache(self.backend_name) def test_simple(self): "Dummy cache backend ignores cache set calls" self.cache.set("key", "value") self.assertEqual(self.cache.get("key"), None) def test_add(self): "Add doesn't do anything in dummy cache backend" self.cache.add("addkey1", "value") result = self.cache.add("addkey1", "newvalue") self.assertEqual(result, True) self.assertEqual(self.cache.get("addkey1"), None) def test_non_existent(self): "Non-existent keys aren't found in the dummy cache backend" self.assertEqual(self.cache.get("does_not_exist"), None) self.assertEqual(self.cache.get("does_not_exist", "bang!"), "bang!") def test_get_many(self): "get_many returns nothing for the dummy cache backend" self.cache.set('a', 'a') self.cache.set('b', 'b') self.cache.set('c', 'c') self.cache.set('d', 'd') self.assertEqual(self.cache.get_many(['a', 'c', 'd']), {}) self.assertEqual(self.cache.get_many(['a', 'b', 'e']), {}) def test_delete(self): "Cache deletion is transparently ignored on the dummy cache backend" self.cache.set("key1", "spam") self.cache.set("key2", "eggs") self.assertEqual(self.cache.get("key1"), None) self.cache.delete("key1") self.assertEqual(self.cache.get("key1"), None) self.assertEqual(self.cache.get("key2"), None) def test_has_key(self): "The has_key method doesn't ever return True for the dummy cache backend" self.cache.set("hello1", "goodbye1") self.assertEqual(self.cache.has_key("hello1"), False) self.assertEqual(self.cache.has_key("goodbye1"), False) def test_in(self): "The in operator doesn't ever return True for the dummy cache backend" self.cache.set("hello2", "goodbye2") self.assertEqual("hello2" in self.cache, False) self.assertEqual("goodbye2" in self.cache, False) def test_incr(self): "Dummy cache values can't be incremented" self.cache.set('answer', 42) self.assertRaises(ValueError, self.cache.incr, 'answer') self.assertRaises(ValueError, self.cache.incr, 'does_not_exist') def test_decr(self): "Dummy cache values can't be decremented" self.cache.set('answer', 42) self.assertRaises(ValueError, self.cache.decr, 'answer') self.assertRaises(ValueError, self.cache.decr, 'does_not_exist') def test_data_types(self): "All data types are ignored equally by the dummy cache" stuff = { 'string' : 'this is a string', 'int' : 42, 'list' : [1, 2, 3, 4], 'tuple' : (1, 2, 3, 4), 'dict' : {'A': 1, 'B' : 2}, 'function' : f, 'class' : C, } self.cache.set("stuff", stuff) self.assertEqual(self.cache.get("stuff"), None) def test_expiration(self): "Expiration has no effect on the dummy cache" self.cache.set('expire1', 'very quickly', 1) self.cache.set('expire2', 'very quickly', 1) self.cache.set('expire3', 'very quickly', 1) time.sleep(2) self.assertEqual(self.cache.get("expire1"), None) self.cache.add("expire2", "newvalue") self.assertEqual(self.cache.get("expire2"), None) self.assertEqual(self.cache.has_key("expire3"), False) def test_unicode(self): "Unicode values are ignored by the dummy cache" stuff = { 'ascii': 'ascii_value', 'unicode_ascii': 'Iñtërnâtiônàlizætiøn1', 'Iñtërnâtiônàlizætiøn': 'Iñtërnâtiônàlizætiøn2', 'ascii2': {'x' : 1 } } for (key, value) in stuff.items(): self.cache.set(key, value) self.assertEqual(self.cache.get(key), None) def test_set_many(self): "set_many does nothing for the dummy cache backend" self.cache.set_many({'a': 1, 'b': 2}) self.cache.set_many({'a': 1, 'b': 2}, timeout=2, version='1') def test_delete_many(self): "delete_many does nothing for the dummy cache backend" self.cache.delete_many(['a', 'b']) def test_clear(self): "clear does nothing for the dummy cache backend" self.cache.clear() def test_incr_version(self): "Dummy cache versions can't be incremented" self.cache.set('answer', 42) self.assertRaises(ValueError, self.cache.incr_version, 'answer') self.assertRaises(ValueError, self.cache.incr_version, 'does_not_exist') def test_decr_version(self): "Dummy cache versions can't be decremented" self.cache.set('answer', 42) self.assertRaises(ValueError, self.cache.decr_version, 'answer') self.assertRaises(ValueError, self.cache.decr_version, 'does_not_exist') class BaseCacheTests(object): # A common set of tests to apply to all cache backends def _get_request_cache(self, path): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } request.path = request.path_info = path request._cache_update_cache = True request.method = 'GET' return request def test_simple(self): # Simple cache set/get works self.cache.set("key", "value") self.assertEqual(self.cache.get("key"), "value") def test_add(self): # A key can be added to a cache self.cache.add("addkey1", "value") result = self.cache.add("addkey1", "newvalue") self.assertEqual(result, False) self.assertEqual(self.cache.get("addkey1"), "value") def test_prefix(self): # Test for same cache key conflicts between shared backend self.cache.set('somekey', 'value') # should not be set in the prefixed cache self.assertFalse(self.prefix_cache.has_key('somekey')) self.prefix_cache.set('somekey', 'value2') self.assertEqual(self.cache.get('somekey'), 'value') self.assertEqual(self.prefix_cache.get('somekey'), 'value2') def test_non_existent(self): # Non-existent cache keys return as None/default # get with non-existent keys self.assertEqual(self.cache.get("does_not_exist"), None) self.assertEqual(self.cache.get("does_not_exist", "bang!"), "bang!") def test_get_many(self): # Multiple cache keys can be returned using get_many self.cache.set('a', 'a') self.cache.set('b', 'b') self.cache.set('c', 'c') self.cache.set('d', 'd') self.assertEqual(self.cache.get_many(['a', 'c', 'd']), {'a' : 'a', 'c' : 'c', 'd' : 'd'}) self.assertEqual(self.cache.get_many(['a', 'b', 'e']), {'a' : 'a', 'b' : 'b'}) def test_delete(self): # Cache keys can be deleted self.cache.set("key1", "spam") self.cache.set("key2", "eggs") self.assertEqual(self.cache.get("key1"), "spam") self.cache.delete("key1") self.assertEqual(self.cache.get("key1"), None) self.assertEqual(self.cache.get("key2"), "eggs") def test_has_key(self): # The cache can be inspected for cache keys self.cache.set("hello1", "goodbye1") self.assertEqual(self.cache.has_key("hello1"), True) self.assertEqual(self.cache.has_key("goodbye1"), False) def test_in(self): # The in operator can be used to inspect cache contents self.cache.set("hello2", "goodbye2") self.assertEqual("hello2" in self.cache, True) self.assertEqual("goodbye2" in self.cache, False) def test_incr(self): # Cache values can be incremented self.cache.set('answer', 41) self.assertEqual(self.cache.incr('answer'), 42) self.assertEqual(self.cache.get('answer'), 42) self.assertEqual(self.cache.incr('answer', 10), 52) self.assertEqual(self.cache.get('answer'), 52) self.assertEqual(self.cache.incr('answer', -10), 42) self.assertRaises(ValueError, self.cache.incr, 'does_not_exist') def test_decr(self): # Cache values can be decremented self.cache.set('answer', 43) self.assertEqual(self.cache.decr('answer'), 42) self.assertEqual(self.cache.get('answer'), 42) self.assertEqual(self.cache.decr('answer', 10), 32) self.assertEqual(self.cache.get('answer'), 32) self.assertEqual(self.cache.decr('answer', -10), 42) self.assertRaises(ValueError, self.cache.decr, 'does_not_exist') def test_close(self): self.assertTrue(hasattr(self.cache, 'close')) self.cache.close() def test_data_types(self): # Many different data types can be cached stuff = { 'string' : 'this is a string', 'int' : 42, 'list' : [1, 2, 3, 4], 'tuple' : (1, 2, 3, 4), 'dict' : {'A': 1, 'B' : 2}, 'function' : f, 'class' : C, } self.cache.set("stuff", stuff) self.assertEqual(self.cache.get("stuff"), stuff) def test_cache_read_for_model_instance(self): # Don't want fields with callable as default to be called on cache read expensive_calculation.num_runs = 0 Poll.objects.all().delete() my_poll = Poll.objects.create(question="Well?") self.assertEqual(Poll.objects.count(), 1) pub_date = my_poll.pub_date self.cache.set('question', my_poll) cached_poll = self.cache.get('question') self.assertEqual(cached_poll.pub_date, pub_date) # We only want the default expensive calculation run once self.assertEqual(expensive_calculation.num_runs, 1) def test_cache_write_for_model_instance_with_deferred(self): # Don't want fields with callable as default to be called on cache write expensive_calculation.num_runs = 0 Poll.objects.all().delete() my_poll = Poll.objects.create(question="What?") self.assertEqual(expensive_calculation.num_runs, 1) defer_qs = Poll.objects.all().defer('question') self.assertEqual(defer_qs.count(), 1) self.assertEqual(expensive_calculation.num_runs, 1) self.cache.set('deferred_queryset', defer_qs) # cache set should not re-evaluate default functions self.assertEqual(expensive_calculation.num_runs, 1) def test_cache_read_for_model_instance_with_deferred(self): # Don't want fields with callable as default to be called on cache read expensive_calculation.num_runs = 0 Poll.objects.all().delete() my_poll = Poll.objects.create(question="What?") self.assertEqual(expensive_calculation.num_runs, 1) defer_qs = Poll.objects.all().defer('question') self.assertEqual(defer_qs.count(), 1) self.cache.set('deferred_queryset', defer_qs) self.assertEqual(expensive_calculation.num_runs, 1) runs_before_cache_read = expensive_calculation.num_runs cached_polls = self.cache.get('deferred_queryset') # We only want the default expensive calculation run on creation and set self.assertEqual(expensive_calculation.num_runs, runs_before_cache_read) def test_expiration(self): # Cache values can be set to expire self.cache.set('expire1', 'very quickly', 1) self.cache.set('expire2', 'very quickly', 1) self.cache.set('expire3', 'very quickly', 1) time.sleep(2) self.assertEqual(self.cache.get("expire1"), None) self.cache.add("expire2", "newvalue") self.assertEqual(self.cache.get("expire2"), "newvalue") self.assertEqual(self.cache.has_key("expire3"), False) def test_unicode(self): # Unicode values can be cached stuff = { 'ascii': 'ascii_value', 'unicode_ascii': 'Iñtërnâtiônàlizætiøn1', 'Iñtërnâtiônàlizætiøn': 'Iñtërnâtiônàlizætiøn2', 'ascii2': {'x' : 1 } } # Test `set` for (key, value) in stuff.items(): self.cache.set(key, value) self.assertEqual(self.cache.get(key), value) # Test `add` for (key, value) in stuff.items(): self.cache.delete(key) self.cache.add(key, value) self.assertEqual(self.cache.get(key), value) # Test `set_many` for (key, value) in stuff.items(): self.cache.delete(key) self.cache.set_many(stuff) for (key, value) in stuff.items(): self.assertEqual(self.cache.get(key), value) def test_binary_string(self): # Binary strings should be cacheable from zlib import compress, decompress value = 'value_to_be_compressed' compressed_value = compress(value.encode()) # Test set self.cache.set('binary1', compressed_value) compressed_result = self.cache.get('binary1') self.assertEqual(compressed_value, compressed_result) self.assertEqual(value, decompress(compressed_result).decode()) # Test add self.cache.add('binary1-add', compressed_value) compressed_result = self.cache.get('binary1-add') self.assertEqual(compressed_value, compressed_result) self.assertEqual(value, decompress(compressed_result).decode()) # Test set_many self.cache.set_many({'binary1-set_many': compressed_value}) compressed_result = self.cache.get('binary1-set_many') self.assertEqual(compressed_value, compressed_result) self.assertEqual(value, decompress(compressed_result).decode()) def test_set_many(self): # Multiple keys can be set using set_many self.cache.set_many({"key1": "spam", "key2": "eggs"}) self.assertEqual(self.cache.get("key1"), "spam") self.assertEqual(self.cache.get("key2"), "eggs") def test_set_many_expiration(self): # set_many takes a second ``timeout`` parameter self.cache.set_many({"key1": "spam", "key2": "eggs"}, 1) time.sleep(2) self.assertEqual(self.cache.get("key1"), None) self.assertEqual(self.cache.get("key2"), None) def test_delete_many(self): # Multiple keys can be deleted using delete_many self.cache.set("key1", "spam") self.cache.set("key2", "eggs") self.cache.set("key3", "ham") self.cache.delete_many(["key1", "key2"]) self.assertEqual(self.cache.get("key1"), None) self.assertEqual(self.cache.get("key2"), None) self.assertEqual(self.cache.get("key3"), "ham") def test_clear(self): # The cache can be emptied using clear self.cache.set("key1", "spam") self.cache.set("key2", "eggs") self.cache.clear() self.assertEqual(self.cache.get("key1"), None) self.assertEqual(self.cache.get("key2"), None) def test_long_timeout(self): ''' Using a timeout greater than 30 days makes memcached think it is an absolute expiration timestamp instead of a relative offset. Test that we honour this convention. Refs #12399. ''' self.cache.set('key1', 'eggs', 60*60*24*30 + 1) #30 days + 1 second self.assertEqual(self.cache.get('key1'), 'eggs') self.cache.add('key2', 'ham', 60*60*24*30 + 1) self.assertEqual(self.cache.get('key2'), 'ham') self.cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 60*60*24*30 + 1) self.assertEqual(self.cache.get('key3'), 'sausage') self.assertEqual(self.cache.get('key4'), 'lobster bisque') def test_forever_timeout(self): ''' Passing in None into timeout results in a value that is cached forever ''' self.cache.set('key1', 'eggs', None) self.assertEqual(self.cache.get('key1'), 'eggs') self.cache.add('key2', 'ham', None) self.assertEqual(self.cache.get('key2'), 'ham') self.cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, None) self.assertEqual(self.cache.get('key3'), 'sausage') self.assertEqual(self.cache.get('key4'), 'lobster bisque') def test_zero_timeout(self): ''' Passing in None into timeout results in a value that is cached forever ''' self.cache.set('key1', 'eggs', 0) self.assertEqual(self.cache.get('key1'), None) self.cache.add('key2', 'ham', 0) self.assertEqual(self.cache.get('key2'), None) self.cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 0) self.assertEqual(self.cache.get('key3'), None) self.assertEqual(self.cache.get('key4'), None) def test_float_timeout(self): # Make sure a timeout given as a float doesn't crash anything. self.cache.set("key1", "spam", 100.2) self.assertEqual(self.cache.get("key1"), "spam") def perform_cull_test(self, initial_count, final_count): """This is implemented as a utility method, because only some of the backends implement culling. The culling algorithm also varies slightly, so the final number of entries will vary between backends""" # Create initial cache key entries. This will overflow the cache, causing a cull for i in range(1, initial_count): self.cache.set('cull%d' % i, 'value', 1000) count = 0 # Count how many keys are left in the cache. for i in range(1, initial_count): if self.cache.has_key('cull%d' % i): count = count + 1 self.assertEqual(count, final_count) def test_invalid_keys(self): """ All the builtin backends (except memcached, see below) should warn on keys that would be refused by memcached. This encourages portable caching code without making it too difficult to use production backends with more liberal key rules. Refs #6447. """ # mimic custom ``make_key`` method being defined since the default will # never show the below warnings def func(key, *args): return key old_func = self.cache.key_func self.cache.key_func = func try: with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") # memcached does not allow whitespace or control characters in keys self.cache.set('key with spaces', 'value') self.assertEqual(len(w), 2) self.assertIsInstance(w[0].message, CacheKeyWarning) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") # memcached limits key length to 250 self.cache.set('a' * 251, 'value') self.assertEqual(len(w), 1) self.assertIsInstance(w[0].message, CacheKeyWarning) finally: self.cache.key_func = old_func def test_cache_versioning_get_set(self): # set, using default version = 1 self.cache.set('answer1', 42) self.assertEqual(self.cache.get('answer1'), 42) self.assertEqual(self.cache.get('answer1', version=1), 42) self.assertEqual(self.cache.get('answer1', version=2), None) self.assertEqual(self.v2_cache.get('answer1'), None) self.assertEqual(self.v2_cache.get('answer1', version=1), 42) self.assertEqual(self.v2_cache.get('answer1', version=2), None) # set, default version = 1, but manually override version = 2 self.cache.set('answer2', 42, version=2) self.assertEqual(self.cache.get('answer2'), None) self.assertEqual(self.cache.get('answer2', version=1), None) self.assertEqual(self.cache.get('answer2', version=2), 42) self.assertEqual(self.v2_cache.get('answer2'), 42) self.assertEqual(self.v2_cache.get('answer2', version=1), None) self.assertEqual(self.v2_cache.get('answer2', version=2), 42) # v2 set, using default version = 2 self.v2_cache.set('answer3', 42) self.assertEqual(self.cache.get('answer3'), None) self.assertEqual(self.cache.get('answer3', version=1), None) self.assertEqual(self.cache.get('answer3', version=2), 42) self.assertEqual(self.v2_cache.get('answer3'), 42) self.assertEqual(self.v2_cache.get('answer3', version=1), None) self.assertEqual(self.v2_cache.get('answer3', version=2), 42) # v2 set, default version = 2, but manually override version = 1 self.v2_cache.set('answer4', 42, version=1) self.assertEqual(self.cache.get('answer4'), 42) self.assertEqual(self.cache.get('answer4', version=1), 42) self.assertEqual(self.cache.get('answer4', version=2), None) self.assertEqual(self.v2_cache.get('answer4'), None) self.assertEqual(self.v2_cache.get('answer4', version=1), 42) self.assertEqual(self.v2_cache.get('answer4', version=2), None) def test_cache_versioning_add(self): # add, default version = 1, but manually override version = 2 self.cache.add('answer1', 42, version=2) self.assertEqual(self.cache.get('answer1', version=1), None) self.assertEqual(self.cache.get('answer1', version=2), 42) self.cache.add('answer1', 37, version=2) self.assertEqual(self.cache.get('answer1', version=1), None) self.assertEqual(self.cache.get('answer1', version=2), 42) self.cache.add('answer1', 37, version=1) self.assertEqual(self.cache.get('answer1', version=1), 37) self.assertEqual(self.cache.get('answer1', version=2), 42) # v2 add, using default version = 2 self.v2_cache.add('answer2', 42) self.assertEqual(self.cache.get('answer2', version=1), None) self.assertEqual(self.cache.get('answer2', version=2), 42) self.v2_cache.add('answer2', 37) self.assertEqual(self.cache.get('answer2', version=1), None) self.assertEqual(self.cache.get('answer2', version=2), 42) self.v2_cache.add('answer2', 37, version=1) self.assertEqual(self.cache.get('answer2', version=1), 37) self.assertEqual(self.cache.get('answer2', version=2), 42) # v2 add, default version = 2, but manually override version = 1 self.v2_cache.add('answer3', 42, version=1) self.assertEqual(self.cache.get('answer3', version=1), 42) self.assertEqual(self.cache.get('answer3', version=2), None) self.v2_cache.add('answer3', 37, version=1) self.assertEqual(self.cache.get('answer3', version=1), 42) self.assertEqual(self.cache.get('answer3', version=2), None) self.v2_cache.add('answer3', 37) self.assertEqual(self.cache.get('answer3', version=1), 42) self.assertEqual(self.cache.get('answer3', version=2), 37) def test_cache_versioning_has_key(self): self.cache.set('answer1', 42) # has_key self.assertTrue(self.cache.has_key('answer1')) self.assertTrue(self.cache.has_key('answer1', version=1)) self.assertFalse(self.cache.has_key('answer1', version=2)) self.assertFalse(self.v2_cache.has_key('answer1')) self.assertTrue(self.v2_cache.has_key('answer1', version=1)) self.assertFalse(self.v2_cache.has_key('answer1', version=2)) def test_cache_versioning_delete(self): self.cache.set('answer1', 37, version=1) self.cache.set('answer1', 42, version=2) self.cache.delete('answer1') self.assertEqual(self.cache.get('answer1', version=1), None) self.assertEqual(self.cache.get('answer1', version=2), 42) self.cache.set('answer2', 37, version=1) self.cache.set('answer2', 42, version=2) self.cache.delete('answer2', version=2) self.assertEqual(self.cache.get('answer2', version=1), 37) self.assertEqual(self.cache.get('answer2', version=2), None) self.cache.set('answer3', 37, version=1) self.cache.set('answer3', 42, version=2) self.v2_cache.delete('answer3') self.assertEqual(self.cache.get('answer3', version=1), 37) self.assertEqual(self.cache.get('answer3', version=2), None) self.cache.set('answer4', 37, version=1) self.cache.set('answer4', 42, version=2) self.v2_cache.delete('answer4', version=1) self.assertEqual(self.cache.get('answer4', version=1), None) self.assertEqual(self.cache.get('answer4', version=2), 42) def test_cache_versioning_incr_decr(self): self.cache.set('answer1', 37, version=1) self.cache.set('answer1', 42, version=2) self.cache.incr('answer1') self.assertEqual(self.cache.get('answer1', version=1), 38) self.assertEqual(self.cache.get('answer1', version=2), 42) self.cache.decr('answer1') self.assertEqual(self.cache.get('answer1', version=1), 37) self.assertEqual(self.cache.get('answer1', version=2), 42) self.cache.set('answer2', 37, version=1) self.cache.set('answer2', 42, version=2) self.cache.incr('answer2', version=2) self.assertEqual(self.cache.get('answer2', version=1), 37) self.assertEqual(self.cache.get('answer2', version=2), 43) self.cache.decr('answer2', version=2) self.assertEqual(self.cache.get('answer2', version=1), 37) self.assertEqual(self.cache.get('answer2', version=2), 42) self.cache.set('answer3', 37, version=1) self.cache.set('answer3', 42, version=2) self.v2_cache.incr('answer3') self.assertEqual(self.cache.get('answer3', version=1), 37) self.assertEqual(self.cache.get('answer3', version=2), 43) self.v2_cache.decr('answer3') self.assertEqual(self.cache.get('answer3', version=1), 37) self.assertEqual(self.cache.get('answer3', version=2), 42) self.cache.set('answer4', 37, version=1) self.cache.set('answer4', 42, version=2) self.v2_cache.incr('answer4', version=1) self.assertEqual(self.cache.get('answer4', version=1), 38) self.assertEqual(self.cache.get('answer4', version=2), 42) self.v2_cache.decr('answer4', version=1) self.assertEqual(self.cache.get('answer4', version=1), 37) self.assertEqual(self.cache.get('answer4', version=2), 42) def test_cache_versioning_get_set_many(self): # set, using default version = 1 self.cache.set_many({'ford1': 37, 'arthur1': 42}) self.assertEqual(self.cache.get_many(['ford1','arthur1']), {'ford1': 37, 'arthur1': 42}) self.assertEqual(self.cache.get_many(['ford1','arthur1'], version=1), {'ford1': 37, 'arthur1': 42}) self.assertEqual(self.cache.get_many(['ford1','arthur1'], version=2), {}) self.assertEqual(self.v2_cache.get_many(['ford1','arthur1']), {}) self.assertEqual(self.v2_cache.get_many(['ford1','arthur1'], version=1), {'ford1': 37, 'arthur1': 42}) self.assertEqual(self.v2_cache.get_many(['ford1','arthur1'], version=2), {}) # set, default version = 1, but manually override version = 2 self.cache.set_many({'ford2': 37, 'arthur2': 42}, version=2) self.assertEqual(self.cache.get_many(['ford2','arthur2']), {}) self.assertEqual(self.cache.get_many(['ford2','arthur2'], version=1), {}) self.assertEqual(self.cache.get_many(['ford2','arthur2'], version=2), {'ford2': 37, 'arthur2': 42}) self.assertEqual(self.v2_cache.get_many(['ford2','arthur2']), {'ford2': 37, 'arthur2': 42}) self.assertEqual(self.v2_cache.get_many(['ford2','arthur2'], version=1), {}) self.assertEqual(self.v2_cache.get_many(['ford2','arthur2'], version=2), {'ford2': 37, 'arthur2': 42}) # v2 set, using default version = 2 self.v2_cache.set_many({'ford3': 37, 'arthur3': 42}) self.assertEqual(self.cache.get_many(['ford3','arthur3']), {}) self.assertEqual(self.cache.get_many(['ford3','arthur3'], version=1), {}) self.assertEqual(self.cache.get_many(['ford3','arthur3'], version=2), {'ford3': 37, 'arthur3': 42}) self.assertEqual(self.v2_cache.get_many(['ford3','arthur3']), {'ford3': 37, 'arthur3': 42}) self.assertEqual(self.v2_cache.get_many(['ford3','arthur3'], version=1), {}) self.assertEqual(self.v2_cache.get_many(['ford3','arthur3'], version=2), {'ford3': 37, 'arthur3': 42}) # v2 set, default version = 2, but manually override version = 1 self.v2_cache.set_many({'ford4': 37, 'arthur4': 42}, version=1) self.assertEqual(self.cache.get_many(['ford4','arthur4']), {'ford4': 37, 'arthur4': 42}) self.assertEqual(self.cache.get_many(['ford4','arthur4'], version=1), {'ford4': 37, 'arthur4': 42}) self.assertEqual(self.cache.get_many(['ford4','arthur4'], version=2), {}) self.assertEqual(self.v2_cache.get_many(['ford4','arthur4']), {}) self.assertEqual(self.v2_cache.get_many(['ford4','arthur4'], version=1), {'ford4': 37, 'arthur4': 42}) self.assertEqual(self.v2_cache.get_many(['ford4','arthur4'], version=2), {}) def test_incr_version(self): self.cache.set('answer', 42, version=2) self.assertEqual(self.cache.get('answer'), None) self.assertEqual(self.cache.get('answer', version=1), None) self.assertEqual(self.cache.get('answer', version=2), 42) self.assertEqual(self.cache.get('answer', version=3), None) self.assertEqual(self.cache.incr_version('answer', version=2), 3) self.assertEqual(self.cache.get('answer'), None) self.assertEqual(self.cache.get('answer', version=1), None) self.assertEqual(self.cache.get('answer', version=2), None) self.assertEqual(self.cache.get('answer', version=3), 42) self.v2_cache.set('answer2', 42) self.assertEqual(self.v2_cache.get('answer2'), 42) self.assertEqual(self.v2_cache.get('answer2', version=1), None) self.assertEqual(self.v2_cache.get('answer2', version=2), 42) self.assertEqual(self.v2_cache.get('answer2', version=3), None) self.assertEqual(self.v2_cache.incr_version('answer2'), 3) self.assertEqual(self.v2_cache.get('answer2'), None) self.assertEqual(self.v2_cache.get('answer2', version=1), None) self.assertEqual(self.v2_cache.get('answer2', version=2), None) self.assertEqual(self.v2_cache.get('answer2', version=3), 42) self.assertRaises(ValueError, self.cache.incr_version, 'does_not_exist') def test_decr_version(self): self.cache.set('answer', 42, version=2) self.assertEqual(self.cache.get('answer'), None) self.assertEqual(self.cache.get('answer', version=1), None) self.assertEqual(self.cache.get('answer', version=2), 42) self.assertEqual(self.cache.decr_version('answer', version=2), 1) self.assertEqual(self.cache.get('answer'), 42) self.assertEqual(self.cache.get('answer', version=1), 42) self.assertEqual(self.cache.get('answer', version=2), None) self.v2_cache.set('answer2', 42) self.assertEqual(self.v2_cache.get('answer2'), 42) self.assertEqual(self.v2_cache.get('answer2', version=1), None) self.assertEqual(self.v2_cache.get('answer2', version=2), 42) self.assertEqual(self.v2_cache.decr_version('answer2'), 1) self.assertEqual(self.v2_cache.get('answer2'), None) self.assertEqual(self.v2_cache.get('answer2', version=1), 42) self.assertEqual(self.v2_cache.get('answer2', version=2), None) self.assertRaises(ValueError, self.cache.decr_version, 'does_not_exist', version=2) def test_custom_key_func(self): # Two caches with different key functions aren't visible to each other self.cache.set('answer1', 42) self.assertEqual(self.cache.get('answer1'), 42) self.assertEqual(self.custom_key_cache.get('answer1'), None) self.assertEqual(self.custom_key_cache2.get('answer1'), None) self.custom_key_cache.set('answer2', 42) self.assertEqual(self.cache.get('answer2'), None) self.assertEqual(self.custom_key_cache.get('answer2'), 42) self.assertEqual(self.custom_key_cache2.get('answer2'), 42) def test_cache_write_unpickable_object(self): update_middleware = UpdateCacheMiddleware() update_middleware.cache = self.cache fetch_middleware = FetchFromCacheMiddleware() fetch_middleware.cache = self.cache request = self._get_request_cache('/cache/test') get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertEqual(get_cache_data, None) response = HttpResponse() content = 'Testing cookie serialization.' response.content = content response.set_cookie('foo', 'bar') update_middleware.process_response(request, response) get_cache_data = fetch_middleware.process_request(request) self.assertNotEqual(get_cache_data, None) self.assertEqual(get_cache_data.content, content.encode('utf-8')) self.assertEqual(get_cache_data.cookies, response.cookies) update_middleware.process_response(request, get_cache_data) get_cache_data = fetch_middleware.process_request(request) self.assertNotEqual(get_cache_data, None) self.assertEqual(get_cache_data.content, content.encode('utf-8')) self.assertEqual(get_cache_data.cookies, response.cookies) def custom_key_func(key, key_prefix, version): "A customized cache key function" return 'CUSTOM-' + '-'.join([key_prefix, str(version), key]) class DBCacheTests(BaseCacheTests, TransactionTestCase): available_apps = ['cache'] backend_name = 'django.core.cache.backends.db.DatabaseCache' def setUp(self): # Spaces are used in the table name to ensure quoting/escaping is working self._table_name = 'test cache table' management.call_command('createcachetable', self._table_name, verbosity=0, interactive=False) self.cache = get_cache(self.backend_name, LOCATION=self._table_name, OPTIONS={'MAX_ENTRIES': 30}) self.prefix_cache = get_cache(self.backend_name, LOCATION=self._table_name, KEY_PREFIX='cacheprefix') self.v2_cache = get_cache(self.backend_name, LOCATION=self._table_name, VERSION=2) self.custom_key_cache = get_cache(self.backend_name, LOCATION=self._table_name, KEY_FUNCTION=custom_key_func) self.custom_key_cache2 = get_cache(self.backend_name, LOCATION=self._table_name, KEY_FUNCTION='cache.tests.custom_key_func') def tearDown(self): from django.db import connection cursor = connection.cursor() cursor.execute('DROP TABLE %s' % connection.ops.quote_name(self._table_name)) connection.commit() def test_cull(self): self.perform_cull_test(50, 29) def test_zero_cull(self): self.cache = get_cache(self.backend_name, LOCATION=self._table_name, OPTIONS={'MAX_ENTRIES': 30, 'CULL_FREQUENCY': 0}) self.perform_cull_test(50, 18) def test_old_initialization(self): self.cache = get_cache('db://%s?max_entries=30&cull_frequency=0' % self._table_name) self.perform_cull_test(50, 18) def test_second_call_doesnt_crash(self): with six.assertRaisesRegex(self, management.CommandError, "Cache table 'test cache table' could not be created"): management.call_command( 'createcachetable', self._table_name, verbosity=0, interactive=False ) def test_clear_commits_transaction(self): # Ensure the database transaction is committed (#19896) self.cache.set("key1", "spam") self.cache.clear() transaction.rollback() self.assertEqual(self.cache.get("key1"), None) @override_settings(USE_TZ=True) class DBCacheWithTimeZoneTests(DBCacheTests): pass class DBCacheRouter(object): """A router that puts the cache table on the 'other' database.""" def db_for_read(self, model, **hints): if model._meta.app_label == 'django_cache': return 'other' def db_for_write(self, model, **hints): if model._meta.app_label == 'django_cache': return 'other' def allow_syncdb(self, db, model): if model._meta.app_label == 'django_cache': return db == 'other' class CreateCacheTableForDBCacheTests(TestCase): multi_db = True def test_createcachetable_observes_database_router(self): old_routers = router.routers try: router.routers = [DBCacheRouter()] # cache table should not be created on 'default' with self.assertNumQueries(0, using='default'): management.call_command('createcachetable', 'cache_table', database='default', verbosity=0, interactive=False) # cache table should be created on 'other' # one query is used to create the table and another one the index with self.assertNumQueries(2, using='other'): management.call_command('createcachetable', 'cache_table', database='other', verbosity=0, interactive=False) finally: router.routers = old_routers class LocMemCacheTests(unittest.TestCase, BaseCacheTests): backend_name = 'django.core.cache.backends.locmem.LocMemCache' def setUp(self): self.cache = get_cache(self.backend_name, OPTIONS={'MAX_ENTRIES': 30}) self.prefix_cache = get_cache(self.backend_name, KEY_PREFIX='cacheprefix') self.v2_cache = get_cache(self.backend_name, VERSION=2) self.custom_key_cache = get_cache(self.backend_name, OPTIONS={'MAX_ENTRIES': 30}, KEY_FUNCTION=custom_key_func) self.custom_key_cache2 = get_cache(self.backend_name, OPTIONS={'MAX_ENTRIES': 30}, KEY_FUNCTION='cache.tests.custom_key_func') # LocMem requires a hack to make the other caches # share a data store with the 'normal' cache. self.prefix_cache._cache = self.cache._cache self.prefix_cache._expire_info = self.cache._expire_info self.v2_cache._cache = self.cache._cache self.v2_cache._expire_info = self.cache._expire_info self.custom_key_cache._cache = self.cache._cache self.custom_key_cache._expire_info = self.cache._expire_info self.custom_key_cache2._cache = self.cache._cache self.custom_key_cache2._expire_info = self.cache._expire_info def tearDown(self): self.cache.clear() def test_cull(self): self.perform_cull_test(50, 29) def test_zero_cull(self): self.cache = get_cache(self.backend_name, OPTIONS={'MAX_ENTRIES': 30, 'CULL_FREQUENCY': 0}) self.perform_cull_test(50, 19) def test_old_initialization(self): self.cache = get_cache('locmem://?max_entries=30&cull_frequency=0') self.perform_cull_test(50, 19) def test_multiple_caches(self): "Check that multiple locmem caches are isolated" mirror_cache = get_cache(self.backend_name) other_cache = get_cache(self.backend_name, LOCATION='other') self.cache.set('value1', 42) self.assertEqual(mirror_cache.get('value1'), 42) self.assertEqual(other_cache.get('value1'), None) def test_incr_decr_timeout(self): """incr/decr does not modify expiry time (matches memcached behavior)""" key = 'value' _key = self.cache.make_key(key) self.cache.set(key, 1, timeout=self.cache.default_timeout*10) expire = self.cache._expire_info[_key] self.cache.incr(key) self.assertEqual(expire, self.cache._expire_info[_key]) self.cache.decr(key) self.assertEqual(expire, self.cache._expire_info[_key]) # memcached backend isn't guaranteed to be available. # To check the memcached backend, the test settings file will # need to contain at least one cache backend setting that points at # your memcache server. @unittest.skipUnless( any(cache['BACKEND'].startswith('django.core.cache.backends.memcached.') for cache in settings.CACHES.values()), "memcached not available") class MemcachedCacheTests(unittest.TestCase, BaseCacheTests): def setUp(self): for cache_key, cache in settings.CACHES.items(): if cache['BACKEND'].startswith('django.core.cache.backends.memcached.'): break random_prefix = ''.join(random.choice(string.ascii_letters) for x in range(10)) self.cache = get_cache(cache_key) self.prefix_cache = get_cache(cache_key, KEY_PREFIX=random_prefix) self.v2_cache = get_cache(cache_key, VERSION=2) self.custom_key_cache = get_cache(cache_key, KEY_FUNCTION=custom_key_func) self.custom_key_cache2 = get_cache(cache_key, KEY_FUNCTION='cache.tests.custom_key_func') def tearDown(self): self.cache.clear() def test_invalid_keys(self): """ On memcached, we don't introduce a duplicate key validation step (for speed reasons), we just let the memcached API library raise its own exception on bad keys. Refs #6447. In order to be memcached-API-library agnostic, we only assert that a generic exception of some kind is raised. """ # memcached does not allow whitespace or control characters in keys self.assertRaises(Exception, self.cache.set, 'key with spaces', 'value') # memcached limits key length to 250 self.assertRaises(Exception, self.cache.set, 'a' * 251, 'value') # Explicitly display a skipped test if no configured cache uses MemcachedCache @unittest.skipUnless( any(cache['BACKEND'] == 'django.core.cache.backends.memcached.MemcachedCache' for cache in settings.CACHES.values()), "cache with python-memcached library not available") def test_memcached_uses_highest_pickle_version(self): # Regression test for #19810 for cache_key, cache in settings.CACHES.items(): if cache['BACKEND'] == 'django.core.cache.backends.memcached.MemcachedCache': self.assertEqual(get_cache(cache_key)._cache.pickleProtocol, pickle.HIGHEST_PROTOCOL) class FileBasedCacheTests(unittest.TestCase, BaseCacheTests): """ Specific test cases for the file-based cache. """ backend_name = 'django.core.cache.backends.filebased.FileBasedCache' def setUp(self): self.dirname = tempfile.mkdtemp() self.cache = get_cache(self.backend_name, LOCATION=self.dirname, OPTIONS={'MAX_ENTRIES': 30}) self.prefix_cache = get_cache(self.backend_name, LOCATION=self.dirname, KEY_PREFIX='cacheprefix') self.v2_cache = get_cache(self.backend_name, LOCATION=self.dirname, VERSION=2) self.custom_key_cache = get_cache(self.backend_name, LOCATION=self.dirname, KEY_FUNCTION=custom_key_func) self.custom_key_cache2 = get_cache(self.backend_name, LOCATION=self.dirname, KEY_FUNCTION='cache.tests.custom_key_func') def tearDown(self): self.cache.clear() def test_hashing(self): """Test that keys are hashed into subdirectories correctly""" self.cache.set("foo", "bar") key = self.cache.make_key("foo") keyhash = hashlib.md5(key.encode()).hexdigest() keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:]) self.assertTrue(os.path.exists(keypath)) def test_subdirectory_removal(self): """ Make sure that the created subdirectories are correctly removed when empty. """ self.cache.set("foo", "bar") key = self.cache.make_key("foo") keyhash = hashlib.md5(key.encode()).hexdigest() keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:]) self.assertTrue(os.path.exists(keypath)) self.cache.delete("foo") self.assertTrue(not os.path.exists(keypath)) self.assertTrue(not os.path.exists(os.path.dirname(keypath))) self.assertTrue(not os.path.exists(os.path.dirname(os.path.dirname(keypath)))) def test_cull(self): self.perform_cull_test(50, 29) def test_old_initialization(self): self.cache = get_cache('file://%s?max_entries=30' % self.dirname) self.perform_cull_test(50, 29) class CustomCacheKeyValidationTests(unittest.TestCase): """ Tests for the ability to mixin a custom ``validate_key`` method to a custom cache backend that otherwise inherits from a builtin backend, and override the default key validation. Refs #6447. """ def test_custom_key_validation(self): cache = get_cache('cache.liberal_backend://') # this key is both longer than 250 characters, and has spaces key = 'some key with spaces' * 15 val = 'a value' cache.set(key, val) self.assertEqual(cache.get(key), val) class GetCacheTests(unittest.TestCase): def test_simple(self): cache = get_cache('locmem://') from django.core.cache.backends.locmem import LocMemCache self.assertIsInstance(cache, LocMemCache) from django.core.cache import cache self.assertIsInstance(cache, get_cache('default').__class__) cache = get_cache( 'django.core.cache.backends.dummy.DummyCache', **{'TIMEOUT': 120}) self.assertEqual(cache.default_timeout, 120) self.assertRaises(InvalidCacheBackendError, get_cache, 'does_not_exist') def test_close(self): from django.core import signals cache = get_cache('cache.closeable_cache.CacheClass') self.assertFalse(cache.closed) signals.request_finished.send(self.__class__) self.assertTrue(cache.closed) @override_settings( CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix', CACHE_MIDDLEWARE_SECONDS=1, CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', }, }, USE_I18N=False, ) class CacheUtils(TestCase): """TestCase for django.utils.cache functions.""" def setUp(self): self.path = '/cache/test/' self.cache = get_cache('default') def tearDown(self): self.cache.clear() def _get_request(self, path, method='GET'): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } request.method = method request.path = request.path_info = "/cache/%s" % path return request def test_patch_vary_headers(self): headers = ( # Initial vary, new headers, resulting vary. (None, ('Accept-Encoding',), 'Accept-Encoding'), ('Accept-Encoding', ('accept-encoding',), 'Accept-Encoding'), ('Accept-Encoding', ('ACCEPT-ENCODING',), 'Accept-Encoding'), ('Cookie', ('Accept-Encoding',), 'Cookie, Accept-Encoding'), ('Cookie, Accept-Encoding', ('Accept-Encoding',), 'Cookie, Accept-Encoding'), ('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), (None, ('Accept-Encoding', 'COOKIE'), 'Accept-Encoding, COOKIE'), ('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), ('Cookie , Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), ) for initial_vary, newheaders, resulting_vary in headers: response = HttpResponse() if initial_vary is not None: response['Vary'] = initial_vary patch_vary_headers(response, newheaders) self.assertEqual(response['Vary'], resulting_vary) def test_get_cache_key(self): request = self._get_request(self.path) response = HttpResponse() key_prefix = 'localprefix' # Expect None if no headers have been set yet. self.assertEqual(get_cache_key(request), None) # Set headers to an empty list. learn_cache_key(request, response) self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e') # Verify that a specified key_prefix is taken into account. learn_cache_key(request, response, key_prefix=key_prefix) self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e') def test_get_cache_key_with_query(self): request = self._get_request(self.path + '?test=1') response = HttpResponse() # Expect None if no headers have been set yet. self.assertEqual(get_cache_key(request), None) # Set headers to an empty list. learn_cache_key(request, response) # Verify that the querystring is taken into account. self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.bd889c5a59603af44333ed21504db3cd.d41d8cd98f00b204e9800998ecf8427e') def test_learn_cache_key(self): request = self._get_request(self.path, 'HEAD') response = HttpResponse() response['Vary'] = 'Pony' # Make sure that the Vary header is added to the key hash learn_cache_key(request, response) self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e') def test_patch_cache_control(self): tests = ( # Initial Cache-Control, kwargs to patch_cache_control, expected Cache-Control parts (None, {'private' : True}, set(['private'])), # Test whether private/public attributes are mutually exclusive ('private', {'private' : True}, set(['private'])), ('private', {'public' : True}, set(['public'])), ('public', {'public' : True}, set(['public'])), ('public', {'private' : True}, set(['private'])), ('must-revalidate,max-age=60,private', {'public' : True}, set(['must-revalidate', 'max-age=60', 'public'])), ('must-revalidate,max-age=60,public', {'private' : True}, set(['must-revalidate', 'max-age=60', 'private'])), ('must-revalidate,max-age=60', {'public' : True}, set(['must-revalidate', 'max-age=60', 'public'])), ) cc_delim_re = re.compile(r'\s*,\s*') for initial_cc, newheaders, expected_cc in tests: response = HttpResponse() if initial_cc is not None: response['Cache-Control'] = initial_cc patch_cache_control(response, **newheaders) parts = set(cc_delim_re.split(response['Cache-Control'])) self.assertEqual(parts, expected_cc) @override_settings( CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'KEY_PREFIX': 'cacheprefix', }, }, ) class PrefixedCacheUtils(CacheUtils): pass @override_settings( CACHE_MIDDLEWARE_SECONDS=60, CACHE_MIDDLEWARE_KEY_PREFIX='test', CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', }, }, ) class CacheHEADTest(TestCase): def setUp(self): self.path = '/cache/test/' self.cache = get_cache('default') def tearDown(self): self.cache.clear() def _get_request(self, method): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } request.method = method request.path = request.path_info = self.path return request def _get_request_cache(self, method): request = self._get_request(method) request._cache_update_cache = True return request def _set_cache(self, request, msg): response = HttpResponse() response.content = msg return UpdateCacheMiddleware().process_response(request, response) def test_head_caches_correctly(self): test_content = 'test content' request = self._get_request_cache('HEAD') self._set_cache(request, test_content) request = self._get_request('HEAD') get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertNotEqual(get_cache_data, None) self.assertEqual(test_content.encode(), get_cache_data.content) def test_head_with_cached_get(self): test_content = 'test content' request = self._get_request_cache('GET') self._set_cache(request, test_content) request = self._get_request('HEAD') get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertNotEqual(get_cache_data, None) self.assertEqual(test_content.encode(), get_cache_data.content) @override_settings( CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix', CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', }, }, LANGUAGES=( ('en', 'English'), ('es', 'Spanish'), ), ) class CacheI18nTest(TestCase): def setUp(self): self.path = '/cache/test/' self.cache = get_cache('default') def tearDown(self): self.cache.clear() def _get_request(self, method='GET'): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } request.method = method request.path = request.path_info = self.path return request def _get_request_cache(self, query_string=None): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } if query_string: request.META['QUERY_STRING'] = query_string request.GET = QueryDict(query_string) request.path = request.path_info = self.path request._cache_update_cache = True request.method = 'GET' request.session = {} return request @override_settings(USE_I18N=True, USE_L10N=False, USE_TZ=False) def test_cache_key_i18n_translation(self): request = self._get_request() lang = translation.get_language() response = HttpResponse() key = learn_cache_key(request, response) self.assertIn(lang, key, "Cache keys should include the language name when translation is active") key2 = get_cache_key(request) self.assertEqual(key, key2) def check_accept_language_vary(self, accept_language, vary, reference_key): request = self._get_request() request.META['HTTP_ACCEPT_LANGUAGE'] = accept_language request.META['HTTP_ACCEPT_ENCODING'] = 'gzip;q=1.0, identity; q=0.5, *;q=0' response = HttpResponse() response['Vary'] = vary key = learn_cache_key(request, response) key2 = get_cache_key(request) self.assertEqual(key, reference_key) self.assertEqual(key2, reference_key) @override_settings(USE_I18N=True, USE_L10N=False, USE_TZ=False) def test_cache_key_i18n_translation_accept_language(self): lang = translation.get_language() self.assertEqual(lang, 'en') request = self._get_request() request.META['HTTP_ACCEPT_ENCODING'] = 'gzip;q=1.0, identity; q=0.5, *;q=0' response = HttpResponse() response['Vary'] = 'accept-encoding' key = learn_cache_key(request, response) self.assertIn(lang, key, "Cache keys should include the language name when translation is active") self.check_accept_language_vary( 'en-us', 'cookie, accept-language, accept-encoding', key ) self.check_accept_language_vary( 'en-US', 'cookie, accept-encoding, accept-language', key ) self.check_accept_language_vary( 'en-US,en;q=0.8', 'accept-encoding, accept-language, cookie', key ) self.check_accept_language_vary( 'en-US,en;q=0.8,ko;q=0.6', 'accept-language, cookie, accept-encoding', key ) self.check_accept_language_vary( 'ko-kr,ko;q=0.8,en-us;q=0.5,en;q=0.3 ', 'accept-encoding, cookie, accept-language', key ) self.check_accept_language_vary( 'ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4', 'accept-language, accept-encoding, cookie', key ) self.check_accept_language_vary( 'ko;q=1.0,en;q=0.5', 'cookie, accept-language, accept-encoding', key ) self.check_accept_language_vary( 'ko, en', 'cookie, accept-encoding, accept-language', key ) self.check_accept_language_vary( 'ko-KR, en-US', 'accept-encoding, accept-language, cookie', key ) @override_settings(USE_I18N=False, USE_L10N=True, USE_TZ=False) def test_cache_key_i18n_formatting(self): request = self._get_request() lang = translation.get_language() response = HttpResponse() key = learn_cache_key(request, response) self.assertIn(lang, key, "Cache keys should include the language name when formatting is active") key2 = get_cache_key(request) self.assertEqual(key, key2) @override_settings(USE_I18N=False, USE_L10N=False, USE_TZ=True) def test_cache_key_i18n_timezone(self): request = self._get_request() # This is tightly coupled to the implementation, # but it's the most straightforward way to test the key. tz = force_text(timezone.get_current_timezone_name(), errors='ignore') tz = tz.encode('ascii', 'ignore').decode('ascii').replace(' ', '_') response = HttpResponse() key = learn_cache_key(request, response) self.assertIn(tz, key, "Cache keys should include the time zone name when time zones are active") key2 = get_cache_key(request) self.assertEqual(key, key2) @override_settings(USE_I18N=False, USE_L10N=False) def test_cache_key_no_i18n (self): request = self._get_request() lang = translation.get_language() tz = force_text(timezone.get_current_timezone_name(), errors='ignore') tz = tz.encode('ascii', 'ignore').decode('ascii').replace(' ', '_') response = HttpResponse() key = learn_cache_key(request, response) self.assertNotIn(lang, key, "Cache keys shouldn't include the language name when i18n isn't active") self.assertNotIn(tz, key, "Cache keys shouldn't include the time zone name when i18n isn't active") @override_settings(USE_I18N=False, USE_L10N=False, USE_TZ=True) def test_cache_key_with_non_ascii_tzname(self): # Regression test for #17476 class CustomTzName(timezone.UTC): name = '' def tzname(self, dt): return self.name request = self._get_request() response = HttpResponse() with timezone.override(CustomTzName()): CustomTzName.name = 'Hora estándar de Argentina'.encode('UTF-8') # UTF-8 string sanitized_name = 'Hora_estndar_de_Argentina' self.assertIn(sanitized_name, learn_cache_key(request, response), "Cache keys should include the time zone name when time zones are active") CustomTzName.name = 'Hora estándar de Argentina' # unicode sanitized_name = 'Hora_estndar_de_Argentina' self.assertIn(sanitized_name, learn_cache_key(request, response), "Cache keys should include the time zone name when time zones are active") @override_settings( CACHE_MIDDLEWARE_KEY_PREFIX="test", CACHE_MIDDLEWARE_SECONDS=60, USE_ETAGS=True, USE_I18N=True, ) def test_middleware(self): def set_cache(request, lang, msg): translation.activate(lang) response = HttpResponse() response.content = msg return UpdateCacheMiddleware().process_response(request, response) # cache with non empty request.GET request = self._get_request_cache(query_string='foo=bar&other=true') get_cache_data = FetchFromCacheMiddleware().process_request(request) # first access, cache must return None self.assertEqual(get_cache_data, None) response = HttpResponse() content = 'Check for cache with QUERY_STRING' response.content = content UpdateCacheMiddleware().process_response(request, response) get_cache_data = FetchFromCacheMiddleware().process_request(request) # cache must return content self.assertNotEqual(get_cache_data, None) self.assertEqual(get_cache_data.content, content.encode()) # different QUERY_STRING, cache must be empty request = self._get_request_cache(query_string='foo=bar&somethingelse=true') get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertEqual(get_cache_data, None) # i18n tests en_message ="Hello world!" es_message ="Hola mundo!" request = self._get_request_cache() set_cache(request, 'en', en_message) get_cache_data = FetchFromCacheMiddleware().process_request(request) # Check that we can recover the cache self.assertNotEqual(get_cache_data, None) self.assertEqual(get_cache_data.content, en_message.encode()) # Check that we use etags self.assertTrue(get_cache_data.has_header('ETag')) # Check that we can disable etags with self.settings(USE_ETAGS=False): request._cache_update_cache = True set_cache(request, 'en', en_message) get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertFalse(get_cache_data.has_header('ETag')) # change the session language and set content request = self._get_request_cache() set_cache(request, 'es', es_message) # change again the language translation.activate('en') # retrieve the content from cache get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertEqual(get_cache_data.content, en_message.encode()) # change again the language translation.activate('es') get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertEqual(get_cache_data.content, es_message.encode()) # reset the language translation.deactivate() @override_settings( CACHE_MIDDLEWARE_KEY_PREFIX="test", CACHE_MIDDLEWARE_SECONDS=60, USE_ETAGS=True, ) def test_middleware_doesnt_cache_streaming_response(self): request = self._get_request() get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertIsNone(get_cache_data) # This test passes on Python < 3.3 even without the corresponding code # in UpdateCacheMiddleware, because pickling a StreamingHttpResponse # fails (http://bugs.python.org/issue14288). LocMemCache silently # swallows the exception and doesn't store the response in cache. content = ['Check for cache with streaming content.'] response = StreamingHttpResponse(content) UpdateCacheMiddleware().process_response(request, response) get_cache_data = FetchFromCacheMiddleware().process_request(request) self.assertIsNone(get_cache_data) @override_settings( CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'KEY_PREFIX': 'cacheprefix' }, }, ) class PrefixedCacheI18nTest(CacheI18nTest): pass def hello_world_view(request, value): return HttpResponse('Hello World %s' % value) def csrf_view(request): return HttpResponse(csrf(request)['csrf_token']) @override_settings( CACHE_MIDDLEWARE_ALIAS='other', CACHE_MIDDLEWARE_KEY_PREFIX='middlewareprefix', CACHE_MIDDLEWARE_SECONDS=30, CACHE_MIDDLEWARE_ANONYMOUS_ONLY=False, CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', }, 'other': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'other', 'TIMEOUT': '1', }, }, ) class CacheMiddlewareTest(IgnorePendingDeprecationWarningsMixin, TestCase): def setUp(self): super(CacheMiddlewareTest, self).setUp() self.factory = RequestFactory() self.default_cache = get_cache('default') self.other_cache = get_cache('other') def tearDown(self): self.default_cache.clear() self.other_cache.clear() super(CacheMiddlewareTest, self).tearDown() def test_constructor(self): """ Ensure the constructor is correctly distinguishing between usage of CacheMiddleware as Middleware vs. usage of CacheMiddleware as view decorator and setting attributes appropriately. """ # If no arguments are passed in construction, it's being used as middleware. middleware = CacheMiddleware() # Now test object attributes against values defined in setUp above self.assertEqual(middleware.cache_timeout, 30) self.assertEqual(middleware.key_prefix, 'middlewareprefix') self.assertEqual(middleware.cache_alias, 'other') self.assertEqual(middleware.cache_anonymous_only, False) # If arguments are being passed in construction, it's being used as a decorator. # First, test with "defaults": as_view_decorator = CacheMiddleware(cache_alias=None, key_prefix=None) self.assertEqual(as_view_decorator.cache_timeout, 300) # Timeout value for 'default' cache, i.e. 300 self.assertEqual(as_view_decorator.key_prefix, '') self.assertEqual(as_view_decorator.cache_alias, 'default') # Value of DEFAULT_CACHE_ALIAS from django.core.cache self.assertEqual(as_view_decorator.cache_anonymous_only, False) # Next, test with custom values: as_view_decorator_with_custom = CacheMiddleware(cache_anonymous_only=True, cache_timeout=60, cache_alias='other', key_prefix='foo') self.assertEqual(as_view_decorator_with_custom.cache_timeout, 60) self.assertEqual(as_view_decorator_with_custom.key_prefix, 'foo') self.assertEqual(as_view_decorator_with_custom.cache_alias, 'other') self.assertEqual(as_view_decorator_with_custom.cache_anonymous_only, True) def test_middleware(self): middleware = CacheMiddleware() prefix_middleware = CacheMiddleware(key_prefix='prefix1') timeout_middleware = CacheMiddleware(cache_timeout=1) request = self.factory.get('/view/') # Put the request through the request middleware result = middleware.process_request(request) self.assertEqual(result, None) response = hello_world_view(request, '1') # Now put the response through the response middleware response = middleware.process_response(request, response) # Repeating the request should result in a cache hit result = middleware.process_request(request) self.assertNotEqual(result, None) self.assertEqual(result.content, b'Hello World 1') # The same request through a different middleware won't hit result = prefix_middleware.process_request(request) self.assertEqual(result, None) # The same request with a timeout _will_ hit result = timeout_middleware.process_request(request) self.assertNotEqual(result, None) self.assertEqual(result.content, b'Hello World 1') @override_settings(CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True) def test_cache_middleware_anonymous_only_wont_cause_session_access(self): """ The cache middleware shouldn't cause a session access due to CACHE_MIDDLEWARE_ANONYMOUS_ONLY if nothing else has accessed the session. Refs 13283 """ from django.contrib.sessions.middleware import SessionMiddleware from django.contrib.auth.middleware import AuthenticationMiddleware middleware = CacheMiddleware() session_middleware = SessionMiddleware() auth_middleware = AuthenticationMiddleware() request = self.factory.get('/view_anon/') # Put the request through the request middleware session_middleware.process_request(request) auth_middleware.process_request(request) result = middleware.process_request(request) self.assertEqual(result, None) response = hello_world_view(request, '1') # Now put the response through the response middleware session_middleware.process_response(request, response) response = middleware.process_response(request, response) self.assertEqual(request.session.accessed, False) @override_settings(CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True) def test_cache_middleware_anonymous_only_with_cache_page(self): """CACHE_MIDDLEWARE_ANONYMOUS_ONLY should still be effective when used with the cache_page decorator: the response to a request from an authenticated user should not be cached.""" request = self.factory.get('/view_anon/') class MockAuthenticatedUser(object): def is_authenticated(self): return True class MockAccessedSession(object): accessed = True request.user = MockAuthenticatedUser() request.session = MockAccessedSession() response = cache_page(60)(hello_world_view)(request, '1') self.assertFalse("Cache-Control" in response) def test_view_decorator(self): # decorate the same view with different cache decorators default_view = cache_page(3)(hello_world_view) default_with_prefix_view = cache_page(3, key_prefix='prefix1')(hello_world_view) explicit_default_view = cache_page(3, cache='default')(hello_world_view) explicit_default_with_prefix_view = cache_page(3, cache='default', key_prefix='prefix1')(hello_world_view) other_view = cache_page(1, cache='other')(hello_world_view) other_with_prefix_view = cache_page(1, cache='other', key_prefix='prefix2')(hello_world_view) request = self.factory.get('/view/') # Request the view once response = default_view(request, '1') self.assertEqual(response.content, b'Hello World 1') # Request again -- hit the cache response = default_view(request, '2') self.assertEqual(response.content, b'Hello World 1') # Requesting the same view with the explicit cache should yield the same result response = explicit_default_view(request, '3') self.assertEqual(response.content, b'Hello World 1') # Requesting with a prefix will hit a different cache key response = explicit_default_with_prefix_view(request, '4') self.assertEqual(response.content, b'Hello World 4') # Hitting the same view again gives a cache hit response = explicit_default_with_prefix_view(request, '5') self.assertEqual(response.content, b'Hello World 4') # And going back to the implicit cache will hit the same cache response = default_with_prefix_view(request, '6') self.assertEqual(response.content, b'Hello World 4') # Requesting from an alternate cache won't hit cache response = other_view(request, '7') self.assertEqual(response.content, b'Hello World 7') # But a repeated hit will hit cache response = other_view(request, '8') self.assertEqual(response.content, b'Hello World 7') # And prefixing the alternate cache yields yet another cache entry response = other_with_prefix_view(request, '9') self.assertEqual(response.content, b'Hello World 9') # But if we wait a couple of seconds... time.sleep(2) # ... the default cache will still hit cache = get_cache('default') response = default_view(request, '11') self.assertEqual(response.content, b'Hello World 1') # ... the default cache with a prefix will still hit response = default_with_prefix_view(request, '12') self.assertEqual(response.content, b'Hello World 4') # ... the explicit default cache will still hit response = explicit_default_view(request, '13') self.assertEqual(response.content, b'Hello World 1') # ... the explicit default cache with a prefix will still hit response = explicit_default_with_prefix_view(request, '14') self.assertEqual(response.content, b'Hello World 4') # .. but a rapidly expiring cache won't hit response = other_view(request, '15') self.assertEqual(response.content, b'Hello World 15') # .. even if it has a prefix response = other_with_prefix_view(request, '16') self.assertEqual(response.content, b'Hello World 16') def test_sensitive_cookie_not_cached(self): """ Django must prevent caching of responses that set a user-specific (and maybe security sensitive) cookie in response to a cookie-less request. """ csrf_middleware = CsrfViewMiddleware() cache_middleware = CacheMiddleware() request = self.factory.get('/view/') self.assertIsNone(cache_middleware.process_request(request)) csrf_middleware.process_view(request, csrf_view, (), {}) response = csrf_view(request) response = csrf_middleware.process_response(request, response) response = cache_middleware.process_response(request, response) # Inserting a CSRF cookie in a cookie-less request prevented caching. self.assertIsNone(cache_middleware.process_request(request)) @override_settings( CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix', CACHE_MIDDLEWARE_SECONDS=1, CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', }, }, USE_I18N=False, ) class TestWithTemplateResponse(TestCase): """ Tests various headers w/ TemplateResponse. Most are probably redundant since they manipulate the same object anyway but the Etag header is 'special' because it relies on the content being complete (which is not necessarily always the case with a TemplateResponse) """ def setUp(self): self.path = '/cache/test/' self.cache = get_cache('default') def tearDown(self): self.cache.clear() def _get_request(self, path, method='GET'): request = HttpRequest() request.META = { 'SERVER_NAME': 'testserver', 'SERVER_PORT': 80, } request.method = method request.path = request.path_info = "/cache/%s" % path return request def test_patch_vary_headers(self): headers = ( # Initial vary, new headers, resulting vary. (None, ('Accept-Encoding',), 'Accept-Encoding'), ('Accept-Encoding', ('accept-encoding',), 'Accept-Encoding'), ('Accept-Encoding', ('ACCEPT-ENCODING',), 'Accept-Encoding'), ('Cookie', ('Accept-Encoding',), 'Cookie, Accept-Encoding'), ('Cookie, Accept-Encoding', ('Accept-Encoding',), 'Cookie, Accept-Encoding'), ('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), (None, ('Accept-Encoding', 'COOKIE'), 'Accept-Encoding, COOKIE'), ('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), ('Cookie , Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'), ) for initial_vary, newheaders, resulting_vary in headers: response = TemplateResponse(HttpResponse(), Template("This is a test")) if initial_vary is not None: response['Vary'] = initial_vary patch_vary_headers(response, newheaders) self.assertEqual(response['Vary'], resulting_vary) def test_get_cache_key(self): request = self._get_request(self.path) response = TemplateResponse(HttpResponse(), Template("This is a test")) key_prefix = 'localprefix' # Expect None if no headers have been set yet. self.assertEqual(get_cache_key(request), None) # Set headers to an empty list. learn_cache_key(request, response) self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e') # Verify that a specified key_prefix is taken into account. learn_cache_key(request, response, key_prefix=key_prefix) self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e') def test_get_cache_key_with_query(self): request = self._get_request(self.path + '?test=1') response = TemplateResponse(HttpResponse(), Template("This is a test")) # Expect None if no headers have been set yet. self.assertEqual(get_cache_key(request), None) # Set headers to an empty list. learn_cache_key(request, response) # Verify that the querystring is taken into account. self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.bd889c5a59603af44333ed21504db3cd.d41d8cd98f00b204e9800998ecf8427e') @override_settings(USE_ETAGS=False) def test_without_etag(self): response = TemplateResponse(HttpResponse(), Template("This is a test")) self.assertFalse(response.has_header('ETag')) patch_response_headers(response) self.assertFalse(response.has_header('ETag')) response = response.render() self.assertFalse(response.has_header('ETag')) @override_settings(USE_ETAGS=True) def test_with_etag(self): response = TemplateResponse(HttpResponse(), Template("This is a test")) self.assertFalse(response.has_header('ETag')) patch_response_headers(response) self.assertFalse(response.has_header('ETag')) response = response.render() self.assertTrue(response.has_header('ETag')) class TestEtagWithAdmin(TestCase): # See https://code.djangoproject.com/ticket/16003 urls = "admin_views.urls" def test_admin(self): with self.settings(USE_ETAGS=False): response = self.client.get('/test_admin/admin/') self.assertEqual(response.status_code, 200) self.assertFalse(response.has_header('ETag')) with self.settings(USE_ETAGS=True): response = self.client.get('/test_admin/admin/') self.assertEqual(response.status_code, 200) self.assertTrue(response.has_header('ETag')) class TestMakeTemplateFragmentKey(TestCase): def test_without_vary_on(self): key = make_template_fragment_key('a.fragment') self.assertEqual(key, 'template.cache.a.fragment.d41d8cd98f00b204e9800998ecf8427e') def test_with_one_vary_on(self): key = make_template_fragment_key('foo', ['abc']) self.assertEqual(key, 'template.cache.foo.900150983cd24fb0d6963f7d28e17f72') def test_with_many_vary_on(self): key = make_template_fragment_key('bar', ['abc', 'def']) self.assertEqual(key, 'template.cache.bar.4b35f12ab03cec09beec4c21b2d2fa88') def test_proper_escaping(self): key = make_template_fragment_key('spam', ['abc:def%']) self.assertEqual(key, 'template.cache.spam.f27688177baec990cdf3fbd9d9c3f469')
the-stack_106_32283
# COM3110/4155/6155: Text Processing # Regular Expressions Lab Class import sys, re #------------------------------ testRE = re.compile('(logic|sicstus)', re.I) #------------------------------ with open('RGX_DATA.html') as infs: linenum = 0 for line in infs: linenum += 1 if line.strip() == '': continue print(' ', '-' * 100, '[%d]' % linenum, '\n TEXT:', line, end='') m = testRE.search(line) if m: print('** TEST-RE:', m.group(1)) # mm = testRE.finditer(line) # for m in mm: # print('** TEST-RE:', m.group(1))
the-stack_106_32284
import os import sys sys.path.append(os.path.normpath(os.path.join(os.path.abspath(__file__), '..', '..', '..', "common"))) from env_indigo import * indigo = Indigo() bingo = Bingo.createDatabaseFile(indigo, "get_indigo_object_bug", 'molecule') for item in ("C1=CC=CC=C1", "C1=CN=CC=C1"): bingo.insert(indigo.loadMolecule(item)) result = bingo.searchSim(indigo.loadMolecule("C1=CC=CC=C1"), 0.3, 1.0, "tanimoto") while result.next(): print(result.getCurrentId(), result.getCurrentSimilarityValue(), result.getIndigoObject().smiles()) bingo.close()
the-stack_106_32285
""" Test the memory module. """ # Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org> # Copyright (c) 2009 Gael Varoquaux # License: BSD Style, 3 clauses. import shutil import os import os.path from tempfile import mkdtemp import pickle import warnings import io import sys import time import nose from joblib.memory import Memory, MemorizedFunc, NotMemorizedFunc, MemorizedResult from joblib.memory import NotMemorizedResult, _FUNCTION_HASHES from joblib.test.common import with_numpy, np from joblib.testing import assert_raises_regex from joblib._compat import PY3_OR_LATER ############################################################################### # Module-level variables for the tests def f(x, y=1): """ A module-level function for testing purposes. """ return x ** 2 + y ############################################################################### # Test fixtures env = dict() def setup_module(): """ Test setup. """ cachedir = mkdtemp() env['dir'] = cachedir if os.path.exists(cachedir): shutil.rmtree(cachedir) # Don't make the cachedir, Memory should be able to do that on the fly print(80 * '_') print('test_memory setup (%s)' % env['dir']) print(80 * '_') def _rmtree_onerror(func, path, excinfo): print('!' * 79) print('os function failed: %r' % func) print('file to be removed: %s' % path) print('exception was: %r' % excinfo[1]) print('!' * 79) def teardown_module(): """ Test teardown. """ shutil.rmtree(env['dir'], False, _rmtree_onerror) print(80 * '_') print('test_memory teardown (%s)' % env['dir']) print(80 * '_') ############################################################################### # Helper function for the tests def check_identity_lazy(func, accumulator): """ Given a function and an accumulator (a list that grows every time the function is called), check that the function can be decorated by memory to be a lazy identity. """ # Call each function with several arguments, and check that it is # evaluated only once per argument. memory = Memory(cachedir=env['dir'], verbose=0) memory.clear(warn=False) func = memory.cache(func) for i in range(3): for _ in range(2): yield nose.tools.assert_equal, func(i), i yield nose.tools.assert_equal, len(accumulator), i + 1 ############################################################################### # Tests def test_memory_integration(): """ Simple test of memory lazy evaluation. """ accumulator = list() # Rmk: this function has the same name than a module-level function, # thus it serves as a test to see that both are identified # as different. def f(l): accumulator.append(1) return l for test in check_identity_lazy(f, accumulator): yield test # Now test clearing for compress in (False, True): for mmap_mode in ('r', None): # We turn verbosity on to smoke test the verbosity code, however, # we capture it, as it is ugly try: # To smoke-test verbosity, we capture stdout orig_stdout = sys.stdout orig_stderr = sys.stdout if PY3_OR_LATER: sys.stderr = io.StringIO() sys.stderr = io.StringIO() else: sys.stdout = io.BytesIO() sys.stderr = io.BytesIO() memory = Memory(cachedir=env['dir'], verbose=10, mmap_mode=mmap_mode, compress=compress) # First clear the cache directory, to check that our code can # handle that # NOTE: this line would raise an exception, as the database file is # still open; we ignore the error since we want to test what # happens if the directory disappears shutil.rmtree(env['dir'], ignore_errors=True) g = memory.cache(f) g(1) g.clear(warn=False) current_accumulator = len(accumulator) out = g(1) finally: sys.stdout = orig_stdout sys.stderr = orig_stderr yield nose.tools.assert_equal, len(accumulator), \ current_accumulator + 1 # Also, check that Memory.eval works similarly yield nose.tools.assert_equal, memory.eval(f, 1), out yield nose.tools.assert_equal, len(accumulator), \ current_accumulator + 1 # Now do a smoke test with a function defined in __main__, as the name # mangling rules are more complex f.__module__ = '__main__' memory = Memory(cachedir=env['dir'], verbose=0) memory.cache(f)(1) def test_no_memory(): """ Test memory with cachedir=None: no memoize """ accumulator = list() def ff(l): accumulator.append(1) return l mem = Memory(cachedir=None, verbose=0) gg = mem.cache(ff) for _ in range(4): current_accumulator = len(accumulator) gg(1) yield nose.tools.assert_equal, len(accumulator), \ current_accumulator + 1 def test_memory_kwarg(): " Test memory with a function with keyword arguments." accumulator = list() def g(l=None, m=1): accumulator.append(1) return l for test in check_identity_lazy(g, accumulator): yield test memory = Memory(cachedir=env['dir'], verbose=0) g = memory.cache(g) # Smoke test with an explicit keyword argument: nose.tools.assert_equal(g(l=30, m=2), 30) def test_memory_lambda(): " Test memory with a function with a lambda." accumulator = list() def helper(x): """ A helper function to define l as a lambda. """ accumulator.append(1) return x l = lambda x: helper(x) for test in check_identity_lazy(l, accumulator): yield test def test_memory_name_collision(): " Check that name collisions with functions will raise warnings" memory = Memory(cachedir=env['dir'], verbose=0) @memory.cache def name_collision(x): """ A first function called name_collision """ return x a = name_collision @memory.cache def name_collision(x): """ A second function called name_collision """ return x b = name_collision if not hasattr(warnings, 'catch_warnings'): # catch_warnings is new in Python 2.6 return with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # This is a temporary workaround until we get rid of # inspect.getargspec, see # https://github.com/joblib/joblib/issues/247 warnings.simplefilter("ignore", DeprecationWarning) a(1) b(1) yield nose.tools.assert_equal, len(w), 1 yield nose.tools.assert_true, "collision" in str(w[-1].message) def test_memory_warning_lambda_collisions(): # Check that multiple use of lambda will raise collisions memory = Memory(cachedir=env['dir'], verbose=0) # For isolation with other tests memory.clear() a = lambda x: x a = memory.cache(a) b = lambda x: x + 1 b = memory.cache(b) with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # This is a temporary workaround until we get rid of # inspect.getargspec, see # https://github.com/joblib/joblib/issues/247 warnings.simplefilter("ignore", DeprecationWarning) nose.tools.assert_equal(0, a(0)) nose.tools.assert_equal(2, b(1)) nose.tools.assert_equal(1, a(1)) # In recent Python versions, we can retrieve the code of lambdas, # thus nothing is raised nose.tools.assert_equal(len(w), 4) def test_memory_warning_collision_detection(): # Check that collisions impossible to detect will raise appropriate # warnings. memory = Memory(cachedir=env['dir'], verbose=0) # For isolation with other tests memory.clear() a1 = eval('lambda x: x') a1 = memory.cache(a1) b1 = eval('lambda x: x+1') b1 = memory.cache(b1) if not hasattr(warnings, 'catch_warnings'): # catch_warnings is new in Python 2.6 return with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # This is a temporary workaround until we get rid of # inspect.getargspec, see # https://github.com/joblib/joblib/issues/247 warnings.simplefilter("ignore", DeprecationWarning) a1(1) b1(1) a1(0) yield nose.tools.assert_equal, len(w), 2 yield nose.tools.assert_true, \ "cannot detect" in str(w[-1].message).lower() def test_memory_partial(): " Test memory with functools.partial." accumulator = list() def func(x, y): """ A helper function to define l as a lambda. """ accumulator.append(1) return y import functools function = functools.partial(func, 1) for test in check_identity_lazy(function, accumulator): yield test def test_memory_eval(): " Smoke test memory with a function with a function defined in an eval." memory = Memory(cachedir=env['dir'], verbose=0) m = eval('lambda x: x') mm = memory.cache(m) yield nose.tools.assert_equal, 1, mm(1) def count_and_append(x=[]): """ A function with a side effect in its arguments. Return the lenght of its argument and append one element. """ len_x = len(x) x.append(None) return len_x def test_argument_change(): """ Check that if a function has a side effect in its arguments, it should use the hash of changing arguments. """ mem = Memory(cachedir=env['dir'], verbose=0) func = mem.cache(count_and_append) # call the function for the first time, is should cache it with # argument x=[] assert func() == 0 # the second time the argument is x=[None], which is not cached # yet, so the functions should be called a second time assert func() == 1 @with_numpy def test_memory_numpy(): " Test memory with a function with numpy arrays." # Check with memmapping and without. for mmap_mode in (None, 'r'): accumulator = list() def n(l=None): accumulator.append(1) return l memory = Memory(cachedir=env['dir'], mmap_mode=mmap_mode, verbose=0) memory.clear(warn=False) cached_n = memory.cache(n) rnd = np.random.RandomState(0) for i in range(3): a = rnd.random_sample((10, 10)) for _ in range(3): yield nose.tools.assert_true, np.all(cached_n(a) == a) yield nose.tools.assert_equal, len(accumulator), i + 1 @with_numpy def test_memory_numpy_check_mmap_mode(): """Check that mmap_mode is respected even at the first call""" memory = Memory(cachedir=env['dir'], mmap_mode='r', verbose=0) memory.clear(warn=False) @memory.cache() def twice(a): return a * 2 a = np.ones(3) b = twice(a) c = twice(a) nose.tools.assert_true(isinstance(c, np.memmap)) nose.tools.assert_equal(c.mode, 'r') nose.tools.assert_true(isinstance(b, np.memmap)) nose.tools.assert_equal(b.mode, 'r') def test_memory_exception(): """ Smoketest the exception handling of Memory. """ memory = Memory(cachedir=env['dir'], verbose=0) class MyException(Exception): pass @memory.cache def h(exc=0): if exc: raise MyException # Call once, to initialise the cache h() for _ in range(3): # Call 3 times, to be sure that the Exception is always raised yield nose.tools.assert_raises, MyException, h, 1 def test_memory_ignore(): " Test the ignore feature of memory " memory = Memory(cachedir=env['dir'], verbose=0) accumulator = list() @memory.cache(ignore=['y']) def z(x, y=1): accumulator.append(1) yield nose.tools.assert_equal, z.ignore, ['y'] z(0, y=1) yield nose.tools.assert_equal, len(accumulator), 1 z(0, y=1) yield nose.tools.assert_equal, len(accumulator), 1 z(0, y=2) yield nose.tools.assert_equal, len(accumulator), 1 def test_partial_decoration(): "Check cache may be called with kwargs before decorating" memory = Memory(cachedir=env['dir'], verbose=0) test_values = [ (['x'], 100, 'r'), ([], 10, None), ] for ignore, verbose, mmap_mode in test_values: @memory.cache(ignore=ignore, verbose=verbose, mmap_mode=mmap_mode) def z(x): pass yield nose.tools.assert_equal, z.ignore, ignore yield nose.tools.assert_equal, z._verbose, verbose yield nose.tools.assert_equal, z.mmap_mode, mmap_mode def test_func_dir(): # Test the creation of the memory cache directory for the function. memory = Memory(cachedir=env['dir'], verbose=0) memory.clear() path = __name__.split('.') path.append('f') path = os.path.join(env['dir'], 'joblib', *path) g = memory.cache(f) # Test that the function directory is created on demand yield nose.tools.assert_equal, g._get_func_dir(), path yield nose.tools.assert_true, os.path.exists(path) # Test that the code is stored. # For the following test to be robust to previous execution, we clear # the in-memory store _FUNCTION_HASHES.clear() yield nose.tools.assert_false, \ g._check_previous_func_code() yield nose.tools.assert_true, \ os.path.exists(os.path.join(path, 'func_code.py')) yield nose.tools.assert_true, \ g._check_previous_func_code() # Test the robustness to failure of loading previous results. dir, _ = g.get_output_dir(1) a = g(1) yield nose.tools.assert_true, os.path.exists(dir) os.remove(os.path.join(dir, 'output.pkl')) yield nose.tools.assert_equal, a, g(1) def test_persistence(): # Test the memorized functions can be pickled and restored. memory = Memory(cachedir=env['dir'], verbose=0) g = memory.cache(f) output = g(1) h = pickle.loads(pickle.dumps(g)) output_dir, _ = g.get_output_dir(1) yield nose.tools.assert_equal, output, h.load_output(output_dir) memory2 = pickle.loads(pickle.dumps(memory)) yield nose.tools.assert_equal, memory.cachedir, memory2.cachedir # Smoke test that pickling a memory with cachedir=None works memory = Memory(cachedir=None, verbose=0) pickle.loads(pickle.dumps(memory)) g = memory.cache(f) gp = pickle.loads(pickle.dumps(g)) gp(1) def test_call_and_shelve(): """Test MemorizedFunc outputting a reference to cache. """ for func, Result in zip((MemorizedFunc(f, env['dir']), NotMemorizedFunc(f), Memory(cachedir=env['dir']).cache(f), Memory(cachedir=None).cache(f), ), (MemorizedResult, NotMemorizedResult, MemorizedResult, NotMemorizedResult)): nose.tools.assert_equal(func(2), 5) result = func.call_and_shelve(2) nose.tools.assert_true(isinstance(result, Result)) nose.tools.assert_equal(result.get(), 5) result.clear() nose.tools.assert_raises(KeyError, result.get) result.clear() # Do nothing if there is no cache. def test_memorized_pickling(): for func in (MemorizedFunc(f, env['dir']), NotMemorizedFunc(f)): filename = os.path.join(env['dir'], 'pickling_test.dat') result = func.call_and_shelve(2) with open(filename, 'wb') as fp: pickle.dump(result, fp) with open(filename, 'rb') as fp: result2 = pickle.load(fp) nose.tools.assert_equal(result2.get(), result.get()) os.remove(filename) def test_memorized_repr(): func = MemorizedFunc(f, env['dir']) result = func.call_and_shelve(2) func2 = MemorizedFunc(f, env['dir']) result2 = func2.call_and_shelve(2) nose.tools.assert_equal(result.get(), result2.get()) nose.tools.assert_equal(repr(func), repr(func2)) # Smoke test on deprecated methods func.format_signature(2) func.format_call(2) # Smoke test with NotMemorizedFunc func = NotMemorizedFunc(f) repr(func) repr(func.call_and_shelve(2)) # Smoke test for message output (increase code coverage) func = MemorizedFunc(f, env['dir'], verbose=11, timestamp=time.time()) result = func.call_and_shelve(11) result.get() func = MemorizedFunc(f, env['dir'], verbose=11) result = func.call_and_shelve(11) result.get() func = MemorizedFunc(f, env['dir'], verbose=5, timestamp=time.time()) result = func.call_and_shelve(11) result.get() func = MemorizedFunc(f, env['dir'], verbose=5) result = func.call_and_shelve(11) result.get() def test_memory_file_modification(): # Test that modifying a Python file after loading it does not lead to # Recomputation dir_name = os.path.join(env['dir'], 'tmp_import') if not os.path.exists(dir_name): os.mkdir(dir_name) filename = os.path.join(dir_name, 'tmp_joblib_.py') content = 'def f(x):\n print(x)\n return x\n' with open(filename, 'w') as module_file: module_file.write(content) # Load the module: sys.path.append(dir_name) import tmp_joblib_ as tmp mem = Memory(cachedir=env['dir'], verbose=0) f = mem.cache(tmp.f) # Capture sys.stdout to count how many time f is called orig_stdout = sys.stdout if PY3_OR_LATER: my_stdout = io.StringIO() else: my_stdout = io.BytesIO() try: sys.stdout = my_stdout # First call f a few times f(1) f(2) f(1) # Now modify the module where f is stored without modifying f with open(filename, 'w') as module_file: module_file.write('\n\n' + content) # And call f a couple more times f(1) f(1) # Flush the .pyc files shutil.rmtree(dir_name) os.mkdir(dir_name) # Now modify the module where f is stored, modifying f content = 'def f(x):\n print("x=%s" % x)\n return x\n' with open(filename, 'w') as module_file: module_file.write(content) # And call f more times prior to reloading: the cache should not be # invalidated at this point as the active function definition has not # changed in memory yet. f(1) f(1) # Now reload my_stdout.write('Reloading\n') sys.modules.pop('tmp_joblib_') import tmp_joblib_ as tmp f = mem.cache(tmp.f) # And call f more times f(1) f(1) finally: sys.stdout = orig_stdout nose.tools.assert_equal(my_stdout.getvalue(), '1\n2\nReloading\nx=1\n') def _function_to_cache(a, b): # Just a place holder function to be mutated by tests pass def _sum(a, b): return a + b def _product(a, b): return a * b def test_memory_in_memory_function_code_change(): _function_to_cache.__code__ = _sum.__code__ mem = Memory(cachedir=env['dir'], verbose=0) f = mem.cache(_function_to_cache) nose.tools.assert_equal(f(1, 2), 3) nose.tools.assert_equal(f(1, 2), 3) with warnings.catch_warnings(record=True): # ignore name collision warnings warnings.simplefilter("always") # Check that inline function modification triggers a cache invalidation _function_to_cache.__code__ = _product.__code__ nose.tools.assert_equal(f(1, 2), 2) nose.tools.assert_equal(f(1, 2), 2) def test_clear_memory_with_none_cachedir(): mem = Memory(cachedir=None) mem.clear() if PY3_OR_LATER: exec(""" def func_with_kwonly_args(a, b, *, kw1='kw1', kw2='kw2'): return a, b, kw1, kw2 def func_with_signature(a: int, b: float) -> float: return a + b """) def test_memory_func_with_kwonly_args(): mem = Memory(cachedir=env['dir'], verbose=0) func_cached = mem.cache(func_with_kwonly_args) nose.tools.assert_equal(func_cached(1, 2, kw1=3), (1, 2, 3, 'kw2')) # Making sure that providing a keyword-only argument by # position raises an exception assert_raises_regex( ValueError, "Keyword-only parameter 'kw1' was passed as positional parameter", func_cached, 1, 2, 3, {'kw2': 4}) # Keyword-only parameter passed by position with cached call # should still raise ValueError func_cached(1, 2, kw1=3, kw2=4) assert_raises_regex( ValueError, "Keyword-only parameter 'kw1' was passed as positional parameter", func_cached, 1, 2, 3, {'kw2': 4}) # Test 'ignore' parameter func_cached = mem.cache(func_with_kwonly_args, ignore=['kw2']) nose.tools.assert_equal(func_cached(1, 2, kw1=3, kw2=4), (1, 2, 3, 4)) nose.tools.assert_equal(func_cached(1, 2, kw1=3, kw2='ignored'), (1, 2, 3, 4)) def test_memory_func_with_signature(): mem = Memory(cachedir=env['dir'], verbose=0) func_cached = mem.cache(func_with_signature) nose.tools.assert_equal(func_cached(1, 2.), 3.)
the-stack_106_32289
from pymaze.maze import Maze from pymaze.solver import DepthFirstBacktracker from pymaze.solver import BiDirectional from pymaze.solver import BreadthFirst class MazeManager(object): """A manager that abstracts the interaction with the library's components. The graphs, animations, maze creation, and solutions are all handled through the manager. Attributes: mazes (list): It is possible to have more than one maze. They are stored inside this variable. media_name (string): The filename for animations and images quiet_mode (bool): When true, information is not shown on the console """ def __init__(self): self.mazes = [] self.media_name = "" self.quiet_mode = False def add_maze(self, row, col, id=0): """Add a maze to the manager. We give the maze an index of the total number of mazes in the manager. As long as we don't add functionality to delete mazes from the manager, the ids will always be unique. Note that the id will always be greater than 0 because we add 1 to the length of self.mazes, which is set after the id assignment Args: row (int): The height of the maze col (int): The width of the maze id (int): The optional unique id of the maze. Returns Maze: The newly created maze """ if id != 0: self.mazes.append(Maze(row, col, id)) else: if len(self.mazes) < 1: self.mazes.append(Maze(row, col, 0)) else: self.mazes.append(Maze(row, col, len(self.mazes) + 1)) return self.mazes[-1] def add_existing_maze(self, maze, override=True): """Add an already existing maze to the manager. Note that it is assumed that the maze already has an id. If the id already exists, the function will fail. To assign a new, unique id to the maze, set the overwrite flag to true. Args: maze: The maze that will be added to the manager override (bool): A flag that you can set to bypass checking the id Returns: True: If the maze was added to the manager False: If the maze could not be added to the manager """ # Check if there is a maze with the same id. If there is a conflict, return False if self.check_matching_id(maze.id) is None: if override: if len(self.mazes) < 1: maze.id = 0 else: maze.id = self.mazes.__len__()+1 else: return False self.mazes.append(maze) return maze def get_maze(self, id): """Get a maze by its id. Args: id (int): The id of the desired maze Return: Maze: Returns the maze if it was found. None: If no maze was found """ for maze in self.mazes: if maze.id == id: return maze print("Unable to locate maze") return None def get_mazes(self): """Get all of the mazes that the manager is holding""" return self.mazes def get_maze_count(self): """Gets the number of mazes that the manager is holding""" return self.mazes.__len__() def solve_maze(self, maze_id, method, neighbor_method="fancy"): """ Called to solve a maze by a particular method. The method is specified by a string. The options are 1. DepthFirstBacktracker 2. 3. Args: maze_id (int): The id of the maze that will be solved method (string): The name of the method (see above) neighbor_method: """ maze = self.get_maze(maze_id) if maze is None: print("Unable to locate maze. Exiting solver.") return None """DEVNOTE: When adding a new solution method, call it from here. Also update the list of names in the documentation above""" if method == "DepthFirstBacktracker": solver = DepthFirstBacktracker(maze, neighbor_method, self.quiet_mode) maze.solution_path = solver.solve() elif method == "BiDirectional": solver = BiDirectional(maze, neighbor_method, self.quiet_mode) maze.solution_path = solver.solve() elif method == "BreadthFirst": solver = BreadthFirst(maze, neighbor_method, self.quiet_mode) maze.solution_path = solver.solve() def check_matching_id(self, id): """Check if the id already belongs to an existing maze Args: id (int): The id to be checked Returns: """ return next((maze for maze in self.mazes if maze .id == id), None) def set_filename(self, filename): """ Sets the filename for saving animations and images Args: filename (string): The name of the file without an extension """ self.media_name = filename def set_quiet_mode(self, enabled): """ Enables/Disables the quiet mode Args: enabled (bool): True when quiet mode is on, False when it is off """ self.quiet_mode=enabled
the-stack_106_32290
# test dataset with opinion scores (os) in dictionary style with repetitions dataset_name = 'test_dataset_os_as_dict_with_repetitions' yuv_fmt = 'yuv420p' width = 1920 height = 1080 ref_score = 5.0 ref_videos = [ {'content_id': 0, 'content_name': 'foo', 'path': 'foo.png'}, {'content_id': 1, 'content_name': 'bar', 'path': 'bar.png'} ] dis_videos = [ {'asset_id': 0, 'content_id': 0, 'os': {'Tom': [3, 2], 'Jerry': 4, 'Pinokio': 1}, 'path': 'baz1.png'}, {'asset_id': 1, 'content_id': 1, 'os': {'Tom': [2, 2], 'Jerry': 1, 'Pinokio': [3, 3, 1]}, 'path': 'baz2.png'}, {'asset_id': 2, 'content_id': 0, 'os': {'Tom': 4, 'Jerry': 1, 'Pinokio': 3}, 'path': 'baz3.png'} ]
the-stack_106_32291
# This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. bl_info = { "name" : "XBOX", "author" : "Kevin Masson", "description" : "", "blender" : (2, 80, 0), "version" : (0, 0, 1), "location" : "", "warning" : "", "category" : "Generic" } from . import auto_load auto_load.init() def register(): auto_load.register() def unregister(): auto_load.unregister()
the-stack_106_32292
#!/usr/bin/env python # -*- coding: utf-8 -*- from collections import OrderedDict import re from textwrap import dedent as dd import glfw from glfw import gl class Shader(object): '''Wrapper for opengl boilerplate code''' def __init__(self, source): assert glfw.core.init(), 'Error: GLFW could not be initialized' self.inputs = OrderedDict() self.outputs = OrderedDict() self.uniforms = OrderedDict() self.source = dd('\n'.join([l for l in source.split('\n') if l.strip()])) self.parse(source) self.compiled = False @property def shader(self): if not hasattr(self, '_id'): self._id = gl.create_shader(self.opengl_type) return self._id def compile(self): '''Compiles and checks output''' if not self.compiled: shader_id = self.shader gl.shader_source(shader_id, self.source) gl.compile_shader(shader_id) result = gl.get_shaderiv(shader_id, gl.COMPILE_STATUS) log_length = gl.get_shaderiv(shader_id, gl.INFO_LOG_LENGTH) log = '' if log_length != 0: log = gl.get_shader_info_log(shader_id) if log.strip(): assert result == gl.TRUE and log_length == 0, log self.compiled = True return shader_id def attach(self, program): if not self.compiled: self.compile() gl.attach_shader(program.program, self.shader) def detach(self, program): if self.shader is not None: gl.detach_shader(program.program, self.shader) def delete(self): if self.shader is not None: gl.delete_shader(self.shader) def cleanup(self, program): self.detach(program) self.delete() def __del__(self): self.delete() def __contains__(self, key): return key in self.inputs or key in self.uniforms def __getitem__(self, key): if key not in self.inputs and key not in self.uniforms: raise KeyError('Could not set "{}"'.format(key)) else: if key in self.inputs: return self.inputs[key] elif key in self.uniforms: return self.uniforms[key] def __setitem__(self, key, val): if key in self.inputs or key in self.uniforms: setattr(self, key, val) else: raise KeyError('Could not set "{}"'.format(key)) def __iter__(self): for key in self.inputs: yield key for key in self.uniforms: yield key def set_context(self, version): major, minor = version glfw.core.window_hint(glfw.FOCUSED, False) glfw.core.window_hint(glfw.CONTEXT_VERSION_MAJOR, major) glfw.core.window_hint(glfw.CONTEXT_VERSION_MINOR, minor) profile = glfw.OPENGL_ANY_PROFILE if version < (3, 2) else glfw.OPENGL_CORE_PROFILE glfw.core.window_hint(glfw.OPENGL_PROFILE, profile) # Setup forward compatibility if able forward_compat = False if version < (3, 0) else True glfw.core.window_hint(glfw.OPENGL_FORWARD_COMPAT, forward_compat) # Keep the window invisible glfw.core.window_hint(glfw.VISIBLE, False) win = glfw.create_window(title='test', width=1, height=1) if win is not None: glfw.core.destroy_window(win) return major, minor def parse(self, source): '''Parses source looking for context required as well as inputs and uniforms''' opengl_mapping = { (1, 1): (2, 0), (1, 2): (2, 1), (1, 3): (3, 0), (1, 4): (3, 1), (1, 5): (3, 2), } version_pattern = r'^\#version\s+(?P<version>[0-9]+)\s*$' inputs2_pattern = ("\s*GLSL_TYPE\s+" "((highp|mediump|lowp)\s+)?" "(?P<vartype>\w+)\s+" "(?P<varname>\w+)\s*" "(\[(?P<varsize>\d+)\])?" "(\s*\=\s*(?P<vardefault>[0-9.]+))?" "\s*;" ) inputs_pattern = ( r'(?P<direction>(in|out|uniform))\s+' r'((highp|mediump|lowp)\s+)?' r'(?P<vartype>\w+)\s+' r'(?P<varname>\w+)\s*' r'(\s*\=\s*(?P=vartype)?(?P<vardefault>(.+)))?' r'\;' ) version_eng = re.compile(version_pattern) self.version = major, minor = (3, 2) engines = ( [re.compile(inputs_pattern)] + [ re.compile(inputs2_pattern.replace('GLSL_TYPE', kind), flags=re.MULTILINE) for kind in ('uniform', 'attribute', 'varying', 'const') ] ) for line in source.split('\n'): line = line.strip() if version_eng.search(line): data = [m.groupdict() for m in version_eng.finditer(line)][0] version = tuple([int(c) for c in data['version']][:2]) self.version = opengl_mapping.get(version, version) for eng in engines: if eng.search(line): data = [m.groupdict() for m in eng.finditer(line)][0] varname = data['varname'] vartype = data['vartype'] direction = data['direction'] default = data['vardefault'] if direction == 'in': setattr(self, varname, vartype) self.inputs[varname] = vartype elif direction == 'out': setattr(self, varname, vartype) self.outputs[varname] = vartype elif direction == 'uniform': setattr(self, varname, vartype) if default: self.uniforms[varname] = ('uniform', vartype, default) else: self.uniforms[varname] = ('uniform', vartype, ) break self.set_context(self.version) def __repr__(self): cname = self.__class__.__name__ version = self.version inputs = '' uniforms = '' if self.inputs.keys(): inputs = 'inputs=[{}]'.format(', '.join(a for a in self.inputs.keys())) if self.uniforms.keys(): uniforms = 'uniforms=[{}]'.format(', '.join(a for a in self.uniforms.keys())) if inputs: uniforms = ' {}'.format(uniforms) string = '<{cname}{version} {inputs}{uniforms}>'.format(**locals()) return string class VertexShader(Shader): opengl_type = gl.VERTEX_SHADER class FragmentShader(Shader): opengl_type = gl.FRAGMENT_SHADER class GeometryShader(Shader): opengl_type = gl.GEOMETRY_SHADER class TessellationControlShader(Shader): opengl_type = gl.TESS_CONTROL_SHADER class TessellationEvaluationShader(Shader): opengl_type = gl.TESS_EVALUATION_SHADER
the-stack_106_32293
import _plotly_utils.basevalidators class GeoValidator(_plotly_utils.basevalidators.CompoundValidator): def __init__(self, plotly_name="geo", parent_name="layout", **kwargs): super(GeoValidator, self).__init__( plotly_name=plotly_name, parent_name=parent_name, data_class_str=kwargs.pop("data_class_str", "Geo"), data_docs=kwargs.pop( "data_docs", """ bgcolor Set the background color of the map center :class:`plotly.graph_objects.layout.geo.Center` instance or dict with compatible properties coastlinecolor Sets the coastline color. coastlinewidth Sets the coastline stroke width (in px). countrycolor Sets line color of the country boundaries. countrywidth Sets line width (in px) of the country boundaries. domain :class:`plotly.graph_objects.layout.geo.Domain` instance or dict with compatible properties fitbounds Determines if this subplot's view settings are auto-computed to fit trace data. On scoped maps, setting `fitbounds` leads to `center.lon` and `center.lat` getting auto-filled. On maps with a non-clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, and `projection.rotation.lon` getting auto-filled. On maps with a clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, `projection.rotation.lon`, `projection.rotation.lat`, `lonaxis.range` and `lonaxis.range` getting auto-filled. If "locations", only the trace's visible locations are considered in the `fitbounds` computations. If "geojson", the entire trace input `geojson` (if provided) is considered in the `fitbounds` computations, Defaults to False. framecolor Sets the color the frame. framewidth Sets the stroke width (in px) of the frame. lakecolor Sets the color of the lakes. landcolor Sets the land mass color. lataxis :class:`plotly.graph_objects.layout.geo.Lataxis ` instance or dict with compatible properties lonaxis :class:`plotly.graph_objects.layout.geo.Lonaxis ` instance or dict with compatible properties oceancolor Sets the ocean color projection :class:`plotly.graph_objects.layout.geo.Project ion` instance or dict with compatible properties resolution Sets the resolution of the base layers. The values have units of km/mm e.g. 110 corresponds to a scale ratio of 1:110,000,000. rivercolor Sets color of the rivers. riverwidth Sets the stroke width (in px) of the rivers. scope Set the scope of the map. showcoastlines Sets whether or not the coastlines are drawn. showcountries Sets whether or not country boundaries are drawn. showframe Sets whether or not a frame is drawn around the map. showlakes Sets whether or not lakes are drawn. showland Sets whether or not land masses are filled in color. showocean Sets whether or not oceans are filled in color. showrivers Sets whether or not rivers are drawn. showsubunits Sets whether or not boundaries of subunits within countries (e.g. states, provinces) are drawn. subunitcolor Sets the color of the subunits boundaries. subunitwidth Sets the stroke width (in px) of the subunits boundaries. uirevision Controls persistence of user-driven changes in the view (projection and center). Defaults to `layout.uirevision`. visible Sets the default visibility of the base layers. """, ), **kwargs )
the-stack_106_32299
#!/usr/bin/env python """Trivial example scheduler :Authors: Eric H. Neilsen, Jr. :Organization: Fermi National Accelerator Laboratory """ __docformat__ = "restructuredtext en" import json import os import posix import datetime import logging import json import time import datetime from collections import OrderedDict from argparse import ArgumentParser from ConfigParser import ConfigParser from obstac import Scheduler class ExampleScheduler(Scheduler): def make_script(self): # This method get called when autoobs is first enabled, and when # time the SISPI OCS queue is changed while the autoobs is still # enabled with open(self.queue_fname, 'r') as fp: sispi_queue = json.load(fp) logging.debug("Found %d exposure(s) on the SISPI/OCS queue." % len(sispi_queue)) with open(self.in_progress_fname, 'r') as fp: in_progress = json.load(fp) # If we don't want to add anything, return an empty list if len(sispi_queue) >= self.min_queue_len: logging.info("Queue is already %d exposures long, not adding anything" % len(sispi_queue)) # Add an empty script so autoobs knows the scheduler "passed" with open(self.output_fname, 'w') as fp: json.dump([], fp, indent=4) os.chmod(self.output_fname, 0o666) return try: self.expid += 1 except: self.expid = 1 # Follow Meeus chapter 12 to calculate LST mjd = 40587+time.time()/86400 century = (mjd - 51544.5)/36525 gmst = 280.46061837 + 360.98564736629*(mjd-51544.5) + 0.000387933*century*century - century*century*century/38710000 lst = (gmst + self.longitude) % 360 exposure = OrderedDict([ ("expType", "object"), ("object", "test_%d" % self.expid), ("seqid", "Sequence of 1 test exposure"), ("exptime", 90), ("wait", "False"), ("count", 1), ("filter", "z"), ("program", "test"), ("RA", lst), ("dec", self.latitude)]) # List of exposures to add to the queue # In this case, it is a list of just one exposure, but # it can be any number. exposures = [exposure] with open(self.output_fname, 'w') as fp: logging.info("Sending %d exposure(s) to the SISPI/OCS queue." % len(exposures)) json.dump(exposures, fp, indent=4) os.chmod(self.output_fname, 0o666) if __name__ == "__main__": logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG) parser = ArgumentParser('Simple sample scheduler') parser.add_argument("config", help="the configuration file") args = parser.parse_args() scheduler = ExampleScheduler(args.config) scheduler.min_queue_len = 5 scheduler()
the-stack_106_32301
# Author: Rishabh Sharma <[email protected]> # This module was developed under funding provided by # Google Summer of Code 2014 from ..client import GenericClient import os import tarfile from functools import partial from collections import OrderedDict from astropy.time import Time from astropy.time import TimeDelta import astropy.units as u import sunpy from sunpy.util import replacement_filename from sunpy.net.dataretriever.client import simple_path from sunpy.net.download import Downloader, Results __all__ = ['NOAAIndicesClient', 'NOAAPredictClient', 'SRSClient'] class NOAAIndicesClient(GenericClient): @staticmethod def _get_default_uri(): """Return the url to download indices""" return ["ftp://ftp.swpc.noaa.gov/pub/weekly/RecentIndices.txt"] def _get_url_for_timerange(self, timerange, **kwargs): """ Helper function: """ return NOAAIndicesClient._get_default_uri() def _makeimap(self): """ Helper Function:used to hold information about source. """ self.map_['source'] = 'sdic' self.map_['instrument'] = 'noaa-indices' self.map_['physobs'] = 'sunspot number' self.map_['provider'] = 'swpc' @classmethod def _can_handle_query(cls, *query): """ Answers whether client can service the query. Parameters ---------- query : list of query objects Returns ------- boolean answer as to whether client can service the query """ chkattr = ['Time', 'Instrument'] chklist = [x.__class__.__name__ in chkattr for x in query] for x in query: if x.__class__.__name__ == 'Instrument' and x.value == 'noaa-indices': return all(chklist) return False class NOAAPredictClient(GenericClient): @staticmethod def _get_default_uri(): """Return the url to download indices""" return ["http://services.swpc.noaa.gov/text/predicted-sunspot-radio-flux.txt"] def _get_url_for_timerange(self, timerange, **kwargs): """ Helper function: """ return NOAAPredictClient._get_default_uri() def _makeimap(self): """ Helper Function:used to hold information about source. """ self.map_['source'] = 'ises' self.map_['instrument'] = 'noaa-predict' self.map_['physobs'] = 'sunspot number' self.map_['provider'] = 'swpc' @classmethod def _can_handle_query(cls, *query): """ Answers whether client can service the query. Parameters ---------- query : list of query objects Returns ------- boolean answer as to whether client can service the query """ chkattr = ['Time', 'Instrument'] chklist = [x.__class__.__name__ in chkattr for x in query] for x in query: if x.__class__.__name__ == 'Instrument' and x.value.lower() == 'noaa-predict': return all(chklist) return False class SRSClient(GenericClient): @staticmethod def _get_default_uri(): today = Time.now() year = today.strftime('%Y') date = today.strftime('%Y%m%d') return [('ftp://ftp.swpc.noaa.gov/pub/warehouse/', '{0}/SRS/{1}SRS.txt').format(year, date)] def _get_url_for_timerange(self, timerange, **kwargs): if not timerange: return SRSClient._get_default_uri() result = list() base_url = 'ftp://ftp.swpc.noaa.gov/pub/warehouse/' total_days = int(timerange.days) + 1 all_dates = timerange.split(total_days) today_year = Time.now().strftime('%Y') for day in all_dates: if today_year == day.end.strftime('%Y'): suffix = '{0}/SRS/{1}SRS.txt'.format( day.end.strftime('%Y'), day.end.strftime('%Y%m%d')) else: suffix = '{0}/{1}_SRS.tar.gz'.format( day.end.strftime('%Y'), day.end.strftime('%Y')) url = base_url + suffix result.append(url) return result def fetch(self, qres, path=None, error_callback=None, **kwargs): """ Download a set of results. Parameters ---------- qres : `~sunpy.net.dataretriever.QueryResponse` Results to download. Returns ------- Results Object """ urls = [qrblock.url for qrblock in qres] filenames = [] local_filenames = [] for i, [url, qre] in enumerate(zip(urls, qres)): name = url.split('/')[-1] # temporary fix !!! coz All QRBs have same start_time values day = Time(qre.time.start.strftime('%Y-%m-%d')) + TimeDelta(i*u.day) if name not in filenames: filenames.append(name) if name.endswith('.gz'): local_filenames.append('{}SRS.txt'.format(day.strftime('%Y%m%d'))) else: local_filenames.append(name) # Files to be actually downloaded paths = self._get_full_filenames(qres, filenames, path) # Those files that will be present after get returns local_paths = self._get_full_filenames(qres, local_filenames, path) res = Results(lambda x: None, 0, lambda map_: self._link(map_)) # remove duplicate urls. This will make paths and urls to have same number of elements. # OrderedDict is required to maintain ordering because it will be zipped with paths later urls = list(OrderedDict.fromkeys(urls)) dobj = Downloader(max_conn=len(urls), max_total=len(urls)) # We cast to list here in list(zip... to force execution of # res.require([x]) at the start of the loop. for aurl, ncall, fname in list(zip(urls, map(lambda x: res.require([x]), urls), paths)): dobj.download(aurl, fname, ncall, error_callback) res.wait() res2 = Results(lambda x: None, 0) for fname, srs_filename in zip(local_paths, local_filenames): fname = fname.args[0] name = fname.split('/')[-1] past_year = False for i, fname2 in enumerate(paths): fname2 = fname2.args[0] if fname2.endswith('.txt'): continue year = fname2.split('/')[-1] year = year.split('_SRS')[0] if year in name: TarFile = tarfile.open(fname2) filepath = fname.rpartition('/')[0] member = TarFile.getmember('SRS/' + srs_filename) member.name = name TarFile.extract(member, path=filepath) TarFile.close() callback = res2.require([fname]) callback({'path': fname}) past_year = True break if past_year is False: callback = res2.require([fname]) callback({'path': fname}) return res2 def _makeimap(self): self.map_['source'] = 'swpc' self.map_['instrument'] = 'SOON' self.map_['physobs'] = 'SRS' self.map_['source'] = 'NOAA/USAF' @classmethod def _can_handle_query(cls, *query): """ Answers whether client can service the query. Parameters ---------- query : list of query objects Returns ------- boolean answer as to whether client can service the query """ chkattr = ["Time", "Instrument"] chklist = [x.__class__.__name__ in chkattr for x in query] for x in query: if x.__class__.__name__ == "Instrument" and\ str(x.value).lower() in ["soon", "srs_table"]: return True return False
the-stack_106_32303
from devito.tools import memoized_meth from devito import VectorTimeFunction, TensorTimeFunction from examples.seismic import Receiver from examples.seismic.elastic.operators import ForwardOperator class ElasticWaveSolver(object): """ Solver object that provides operators for seismic inversion problems and encapsulates the time and space discretization for a given problem setup. Parameters ---------- model : Model Physical model with domain parameters. geometry : AcquisitionGeometry Geometry object that contains the source (SparseTimeFunction) and receivers (SparseTimeFunction) and their position. space_order : int, optional Order of the spatial stencil discretisation. Defaults to 4. """ def __init__(self, model, geometry, space_order=4, **kwargs): self.model = model self.geometry = geometry self.space_order = space_order # Time step can be \sqrt{3}=1.73 bigger with 4th order self.dt = self.model.critical_dt # Cache compiler options self._kwargs = kwargs @memoized_meth def op_fwd(self, save=None): """Cached operator for forward runs with buffered wavefield""" return ForwardOperator(self.model, save=save, geometry=self.geometry, space_order=self.space_order, **self._kwargs) def forward(self, src=None, rec1=None, rec2=None, lam=None, mu=None, b=None, v=None, tau=None, save=None, **kwargs): """ Forward modelling function that creates the necessary data objects for running a forward modelling operator. Parameters ---------- src : SparseTimeFunction or array_like, optional Time series data for the injected source term. rec1 : SparseTimeFunction or array_like, optional The interpolated receiver data of the pressure (tzz). rec2 : SparseTimeFunction or array_like, optional The interpolated receiver data of the particle velocities. v : VectorTimeFunction, optional The computed particle velocity. tau : TensorTimeFunction, optional The computed symmetric stress tensor. lam : Function, optional The time-constant first Lame parameter `rho * (vp**2 - 2 * vs **2)`. mu : Function, optional The Shear modulus `(rho * vs*2)`. b : Function, optional The time-constant inverse density (b=1 for water). save : int or Buffer, optional Option to store the entire (unrolled) wavefield. Returns ------- Rec1(tzz), Rec2(div(v)), particle velocities v, stress tensor tau and performance summary. """ # Source term is read-only, so re-use the default src = src or self.geometry.src # Create a new receiver object to store the result rec1 = rec1 or Receiver(name='rec1', grid=self.model.grid, time_range=self.geometry.time_axis, coordinates=self.geometry.rec_positions) rec2 = rec2 or Receiver(name='rec2', grid=self.model.grid, time_range=self.geometry.time_axis, coordinates=self.geometry.rec_positions) # Create all the fields vx, vz, tau_xx, tau_zz, tau_xz save_t = src.nt if save else None v = VectorTimeFunction(name='v', grid=self.model.grid, save=save_t, space_order=self.space_order, time_order=1) tau = TensorTimeFunction(name='tau', grid=self.model.grid, save=save_t, space_order=self.space_order, time_order=1) kwargs.update({k.name: k for k in v}) kwargs.update({k.name: k for k in tau}) # Pick Lame parameters from model unless explicitly provided kwargs.update(self.model.physical_params(lam=lam, mu=mu, b=b)) # Execute operator and return wavefield and receiver data summary = self.op_fwd(save).apply(src=src, rec1=rec1, rec2=rec2, dt=kwargs.pop('dt', self.dt), **kwargs) return rec1, rec2, v, tau, summary
the-stack_106_32304
# Copyright 2017 Google, Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """A base class definition for trainable optimizers.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import collections import itertools import tensorflow as tf from tensorflow.python.framework import tensor_shape OPTIMIZER_SCOPE = "LOL" _LOCAL_VARIABLE_PREFIX = "local_state_" _LOCAL_STATE_VARIABLE_COLLECTION = "local_state_collection" EPSILON = 1e-6 class TrainableOptimizer(tf.compat.v1.train.Optimizer): """Base class for trainable optimizers. A trainable optimizer is an optimizer that has parameters that can themselves be learned (meta-optimized). Subclasses must implement: _compute_update(self, param, grad, state) """ def __init__(self, name, state_keys, use_attention=False, use_log_objective=False, obj_train_max_multiplier=-1, use_second_derivatives=True, use_numerator_epsilon=False, **kwargs): """Initializes the optimizer with the given name and settings. Args: name: The name string for this optimizer. state_keys: The names of any required state variables (list) use_attention: Whether this optimizer uses attention (Default: True) use_log_objective: Whether this optimizer uses the logarithm of the objective when computing the loss (Default: False) obj_train_max_multiplier: The maximum multiplier for the increase in the objective before meta-training is stopped. If <= 0, meta-training is not stopped early. (Default: -1) use_second_derivatives: Whether this optimizer uses second derivatives in meta-training. This should be set to False if some second derivatives in the meta-training problem set are not defined in Tensorflow. (Default: True) use_numerator_epsilon: Whether to use epsilon in the numerator when scaling the problem objective during meta-training. (Default: False) **kwargs: Any additional keyword arguments. """ self.use_second_derivatives = use_second_derivatives self.state_keys = sorted(state_keys) self.use_attention = use_attention self.use_log_objective = use_log_objective self.obj_train_max_multiplier = obj_train_max_multiplier self.use_numerator_epsilon = use_numerator_epsilon use_locking = False super(TrainableOptimizer, self).__init__(use_locking, name) def _create_slots(self, var_list): """Creates all slots needed by the variables. Args: var_list: A list of `Variable` objects. """ for var in var_list: init_states = self._initialize_state(var) for slot_name in sorted(init_states): slot_var_name = "{}_{}".format(self.get_name(), slot_name) value = init_states[slot_name] self._get_or_make_slot(var, value, slot_name, slot_var_name) def _initialize_state(self, var): """Initializes any state required for this variable. Args: var: a tensor containing parameters to be optimized Returns: state: a dictionary mapping state keys to initial state values (tensors) """ return {} def _initialize_global_state(self): """Initializes any global state values.""" return [] def _apply_common(self, grad, var): """Applies the optimizer updates to the variables. Note: this should only get called via _apply_dense or _apply_sparse when using the optimizer via optimizer.minimize or optimizer.apply_gradients. During meta-training, the optimizer.train function should be used to construct an optimization path that is differentiable. Args: grad: A tensor representing the gradient. var: A tf.Variable with the same shape as grad. Returns: update_op: A tensorflow op that assigns new values to the variable, and also defines dependencies that update the state variables for the optimizer. """ state = {key: self.get_slot(var, key) for key in self.get_slot_names()} new_var, new_state = self._compute_update(var, grad, state) state_assign_ops = [tf.compat.v1.assign(state_var, new_state[key]) for key, state_var in state.items()] with tf.control_dependencies(state_assign_ops): update_op = var.assign(new_var) return update_op def _apply_dense(self, grad, var): """Adds ops to apply dense gradients to 'var'.""" return self._apply_common(grad, var) def _apply_sparse(self, grad, var): """Adds ops to apply sparse gradients to 'var'.""" return self._apply_common(grad, var) def _compute_update(self, param, grad, state): """Computes the update step for optimization. Args: param: A tensor of parameters to optimize. grad: The gradient tensor of the objective with respect to the parameters. (It has the same shape as param.) state: A dictionary containing any extra state required by the optimizer. Returns: updated_params: The updated parameters. updated_state: The dictionary of updated state variable(s). """ raise NotImplementedError def _compute_updates(self, params, grads, states, global_state): """Maps the compute update functions for each parameter. This function can be overriden by a subclass if the subclass wants to combine information across the different parameters in the list. Args: params: A list of parameter tensors. grads: A list of gradients corresponding to each parameter. states: A list of state variables corresponding to each parameter. global_state: A list of global state variables for the problem. Returns: new_params: The updated parameters. new_states: The updated states. new_global_state: The updated global state. attention_params: A list of attention parameters. This is the same as new_params if the optimizer does not use attention. """ # Zip up the arguments to _compute_update. args = zip(params, grads, states) # Call compute_update on each set of parameter/gradient/state args. new_params, new_states = zip(*list( itertools.starmap(self._compute_update, args))) # Global state is unused in the basic case, just pass it through. return list(new_params), list(new_states), global_state, list(new_params) def train(self, problem, dataset, dataset_val=None, sample_meta_loss=None, meta_method="average"): """Creates graph operations to train the optimizer. Args: problem: A problem_generator.Problem instance to train on. dataset: A datasets.Dataset tuple to use when training. dataset_val: A datasets.Dataset tuple used to compute the meta objective meta_method: "average" - meta objective is averaged over all steps "last" - meta objective is just of the last step Returns: meta_objective: A tensorflow operation for computing the meta-objective obj_weights: A tensor placeholder for feeding in the objective weights obj_values: The subproblem objective values during optimization batches: The batch indexes tensor for overriding with feed_dict first_unroll: A placeholder signifying if this is a first unroll (this will propagate the gradients slightly differently). reset_state: A placeholder signifying that the rnn state should be reset. output_state: The final state of the optimizer init_loop_vars_to_override: Local variables that can be assigned to propagate the optimizer and problem state for unrolling final_loop_vals: Final values of the loop variables that can be assigned to init_loop_vars_to_override. """ # Placeholder for the objective weights obj_weights = tf.compat.v1.placeholder(tf.float32) num_iter = tf.shape(obj_weights)[0] # Unpack the dataset and generate the minibatches for training # For train by train, the train set and val set will be the same if dataset_val is None: dataset_val = dataset data_train, labels_train = dataset data_val, labels_val = dataset_val if sample_meta_loss is not None and sample_meta_loss == len(labels_val): sample_meta_loss = None # This makes the code runs faster because there will be no sampling process; otherwise, the code will sample out all the data explicitly. # Convert the ndarrays to tensors so we can pass them back in via feed_dict data_train = tf.constant(data_train) labels_train = tf.constant(labels_train) data_val = tf.constant(data_val) labels_val = tf.constant(labels_val) batches = tf.compat.v1.placeholder(tf.int32) batches_val = tf.compat.v1.placeholder(tf.int32) first_unroll = tf.compat.v1.placeholder_with_default(False, []) reset_state = tf.compat.v1.placeholder_with_default(False, []) training_output = collections.namedtuple("TrainingOutput", ["metaobj", "obj_weights", "problem_objectives", "initial_obj", "batches", "first_unroll", "reset_state", "output_state", "init_loop_vars", "output_loop_vars", "batches_val"]) def loop_body(itr, obj_accum, params, attend_params, flattened_states, global_state, all_obj, unused_init_obj, batches, batches_val): """Body of the meta-training while loop for optimizing a sub-problem. Args: itr: The current meta-training iteration. obj_accum: The accumulated objective over all training steps so far. params: The parameters of the sub-problem. attend_params: The parameters of the sub-problems at the attended location. flattened_states: The states of the trainable optimizer, sorted and flattened into a list (since a while loop can't handle nested lists or dictionaries). global_state: The global state of the optimizer. all_obj: The list of all objective values in the training process. unused_init_obj: The initial objective (unused here, but needed in the variable list because it's used in a stopping condition in the loop_cond.) data: The data for this problem. labels: The labels corresponding to the data. batches: The batch indexes needed for shuffled minibatch creation. batches_val: If sample_meta_loss is not None, we need to sample a number of data when we compute the meta objective. This is the batch indices for the sampled data. Note that all the batches here for different iterations are sampled independently instead of splitting the whole dataset evenly. Returns: itr: The updated meta-training iteration. obj_accum: The updated accumulated objective. params: The new parameters of the sub-problem. attend_params: The new parameters of the sub-problems at the attended location. flattened_states: The new states of the trainable optimizer. global_state: The updated global state. all_obj: The updates list of all objective values. unused_init_obj: The initial objective. data: The data for this problem. labels: The labels corresponding to the data. batches: The batch indexes needed for shuffled minibatch creation. batches_val: The batch indices for meta objective computation. """ batch_indices = tf.gather(batches, itr) batch_data = tf.gather(data_train, batch_indices) batch_labels = tf.gather(labels_train, batch_indices) # obj: used to compute meta obj; current_obj: inner obj # Compute the objective over the entire val dataset (full batch). if sample_meta_loss is None: obj = problem.objective(params, data_val, labels_val) else: print("{} samples will be randomly sampled when evaluating the meta-objective.".format(sample_meta_loss)) batch_indices_val = tf.gather(batches_val, itr) batch_data_val = tf.gather(data_val, batch_indices_val) batch_labels_val = tf.gather(labels_val, batch_indices_val) obj = problem.objective(params, batch_data_val, batch_labels_val) # Compute the gradients on just the current batch if self.use_attention: current_obj = problem.objective(attend_params, batch_data, batch_labels) grads = problem.gradients(current_obj, attend_params) else: current_obj = problem.objective(params, batch_data, batch_labels) grads = problem.gradients(current_obj, params) if not self.use_second_derivatives: new_grads = [] for grad in grads: if isinstance(grad, tf.IndexedSlices): new_grads.append(tf.IndexedSlices(tf.stop_gradient(grad.values), grad.indices)) else: new_grads.append(tf.stop_gradient(grad)) grads = new_grads # store the objective value for the entire problem at each iteration all_obj = tf.concat([all_obj, tf.reshape(obj, (1,))], 0) # accumulate the weighted objective for the entire dataset acc = tf.gather(obj_weights, itr) * obj obj_accum = tf.add(obj_accum, acc) # Set the shape to keep the shape invariant for obj_accum. Without this, # the graph builder thinks the tensor shape is unknown on the 2nd iter. obj_accum.set_shape([]) # convert flattened_states to dictionaries dict_states = [dict(zip(self.state_keys, flat_state)) for flat_state in flattened_states] # compute the new parameters and states args = (params, grads, dict_states, global_state) updates = self._compute_updates(*args) new_params, new_states, new_global_state, new_attend_params = updates # flatten the states new_flattened_states = [flatten_and_sort(item_dict) for item_dict in new_states] return [itr + 1, obj_accum, new_params, new_attend_params, new_flattened_states, new_global_state, all_obj, unused_init_obj, batches, batches_val] def loop_cond(itr, obj_accum, unused_params, unused_attend_params, unused_flattened_states, unused_global_state, all_obj, init_obj, *args): """Termination conditions of the sub-problem optimization loop.""" del args # unused cond1 = tf.less(itr, num_iter) # We've run < num_iter times cond2 = tf.math.is_finite(obj_accum) # The objective is still finite if self.obj_train_max_multiplier > 0: current_obj = tf.gather(all_obj, itr) # Account for negative init_obj too max_diff = (self.obj_train_max_multiplier - 1) * tf.abs(init_obj) max_obj = init_obj + max_diff # The objective is a reasonable multiplier of the original objective cond3 = tf.less(current_obj, max_obj) return tf.logical_and(tf.logical_and(cond1, cond2), cond3, name="training_loop_cond") else: return tf.logical_and(cond1, cond2, name="training_loop_cond") # for the optimizer.objective() call in init: # otherwise, the optimizer.objective(data, labels) call may cause memory issues if sample_meta_loss is None: # The data here are used to compute init_obj init = self._initialize_training_loop_parameters( problem, data_val, labels_val, batches, first_unroll, reset_state, batches_val) else: print("{} samples will be randomly sampled when evaluating the meta-objective.".format(sample_meta_loss)) init = self._initialize_training_loop_parameters( problem, data_val[:sample_meta_loss, :], labels_val[:sample_meta_loss], batches, first_unroll, reset_state, batches_val) # The data here is just used to initialize the obj_init loop_vars, invariants, initial_obj, init_loop_vars_to_override = init loop_output = tf.while_loop(loop_cond, loop_body, loop_vars, swap_memory=True, shape_invariants=invariants) if meta_method == "average": meta_obj, problem_objectives = loop_output[1], loop_output[6] elif meta_method == "last": meta_obj, problem_objectives = loop_output[6][-1], loop_output[6] else: raise ValueError("meta_method {} not recognized.".format(meta_method)) # The meta objective is normalized by the initial objective at the start of # the series of partial unrolls. # We don't rescale now #scaled_meta_objective = self.scale_objective(meta_obj, problem_objectives, initial_obj) if self.use_log_objective: scaled_meta_objective = tf.log(meta_obj) else: scaled_meta_objective = meta_obj final_loop_vals = ([initial_obj] + loop_output[2] + loop_output[3] + loop_output[5]) final_loop_vals.extend(itertools.chain(*loop_output[4])) return training_output(scaled_meta_objective, # = metaobj obj_weights, problem_objectives, # all the inner objectives initial_obj, batches, first_unroll, reset_state, loop_output[4], # = output_state init_loop_vars_to_override, # = init_loop_vars final_loop_vals, # = output_loop_vars batches_val) def _initialize_training_loop_parameters( self, problem, data, labels, batches, first_unroll, reset_state, batches_val): """Initializes the vars and params needed for the training process. Args: problem: The problem being optimized. data: The data for the problem used to compute init_obj. labels: The corresponding labels for the data used to compute init_obj. batches: The indexes needed to create shuffled batches of the data. first_unroll: Whether this is the first unroll in a partial unrolling. reset_state: Whether RNN state variables should be reset. Returns: loop_vars: The while loop variables for training. invariants: The corresponding variable shapes (required by while loop). initial_obj: The initial objective (used later for scaling). init_loop_vars_to_override: The loop vars that can be overridden when performing training via partial unrolls. """ # Extract these separately so we don't have to make inter-variable # dependencies. initial_tensors = problem.init_tensors() return_initial_tensor_values = first_unroll # This is like a switch, if it is the first unroll, the initial_params will just be the randomly sampled initial_tensors; otherwise, it will get the values locally stored. initial_params_vars, initial_params = local_state_variables( initial_tensors, return_initial_tensor_values) initial_attend_params_vars, initial_attend_params = local_state_variables( initial_tensors, return_initial_tensor_values) # Recalculate the initial objective for the list on each partial unroll with # the new initial_params. initial_obj holds the value from the very first # unroll. initial_obj_init = problem.objective(initial_params, data, labels) return_initial_obj_init = first_unroll [initial_obj_var], [initial_obj] = local_state_variables( [initial_obj_init], return_initial_obj_init) # Initialize the loop variables. initial_itr = tf.constant(0, dtype=tf.int32) initial_meta_obj = tf.constant(0, dtype=tf.float32) # N.B. the use of initial_obj_init here rather than initial_obj initial_problem_objectives = tf.reshape(initial_obj_init, (1,)) # Initialize the extra state. initial_state_vars = [] initial_state = [] state_shapes = [] return_initial_state_values = reset_state for param in initial_tensors: param_state_vars, param_state = local_state_variables( flatten_and_sort(self._initialize_state(param)), return_initial_state_values) initial_state_vars.append(param_state_vars) initial_state.append(param_state) state_shapes.append([f.get_shape() for f in param_state]) # Initialize any global (problem-level) state. initial_global_state_vars, initial_global_state = local_state_variables( self._initialize_global_state(), return_initial_state_values) global_shapes = [] for item in initial_global_state: global_shapes.append(item.get_shape()) # build the list of loop variables: loop_vars = [ initial_itr, initial_meta_obj, initial_params, # Local variables. initial_attend_params, # Local variables. initial_state, # Local variables. initial_global_state, # Local variables. initial_problem_objectives, initial_obj, # Local variable. batches, batches_val ] invariants = [ initial_itr.get_shape(), initial_meta_obj.get_shape(), [t.get_shape() for t in initial_params], [t.get_shape() for t in initial_attend_params], state_shapes, global_shapes, tensor_shape.TensorShape([None]), # The problem objectives list grows initial_obj.get_shape(), tensor_shape.unknown_shape(), # Placeholder shapes are unknown tensor_shape.unknown_shape() ] # Initialize local variables that we will override with final tensors at the # next iter. init_loop_vars_to_override = ( [initial_obj_var] + initial_params_vars + initial_attend_params_vars + initial_global_state_vars) init_loop_vars_to_override.extend(itertools.chain(*initial_state_vars)) return loop_vars, invariants, initial_obj, init_loop_vars_to_override def scale_objective(self, total_obj, all_objs, initial_obj, obj_scale_eps=1e-6): """Normalizes the objective based on the initial objective value. Args: total_obj: The total accumulated objective over the training run. all_objs: A list of all the individual objectives over the training run. initial_obj: The initial objective value. obj_scale_eps: The epsilon value to use in computations for stability. Returns: The scaled objective as a single value. """ if self.use_log_objective: if self.use_numerator_epsilon: scaled_problem_obj = ((all_objs + obj_scale_eps) / (initial_obj + obj_scale_eps)) log_scaled_problem_obj = tf.log(scaled_problem_obj) else: scaled_problem_obj = all_objs / (initial_obj + obj_scale_eps) log_scaled_problem_obj = tf.log(scaled_problem_obj + obj_scale_eps) return tf.reduce_mean(log_scaled_problem_obj) else: return total_obj / (initial_obj + obj_scale_eps) def local_state_variables(init_values, return_init_values): """Create local variables initialized from init_values. This will create local variables from a list of init_values. Each variable will be named based on the value's shape and dtype. As a convenience, a boolean tensor allows you to return value from the created local variable or from the original init value. Args: init_values: iterable of tensors return_init_values: boolean tensor Returns: local_vars: list of the created local variables. vals: if return_init_values is true, then this returns the values of init_values. Otherwise it returns the values of the local_vars. """ if not init_values: return [], [] # This generates a harmless warning when saving the metagraph. variable_use_count = tf.compat.v1.get_collection_ref(_LOCAL_STATE_VARIABLE_COLLECTION) if not variable_use_count: variable_use_count.append(collections.defaultdict(int)) variable_use_count = variable_use_count[0] # count the number of times that the name is used, to avoid name collision local_vars = [] with tf.compat.v1.variable_scope(OPTIMIZER_SCOPE): # We can't use the init_value as an initializer as init_value may # itself depend on some problem variables. This would produce # inter-variable initialization order dependence which TensorFlow # sucks at making easy. for init_value in init_values: name = create_local_state_variable_name(init_value) unique_name = name + "_" + str(variable_use_count[name]) variable_use_count[name] += 1 # The overarching idea here is to be able to reuse variables between # different sessions on the same TensorFlow master without errors. By # uniquifying based on the type and name we mirror the checks made inside # TensorFlow, while still allowing some memory reuse. Ultimately this is a # hack due to the broken Session.reset(). local_vars.append( tf.compat.v1.get_local_variable( unique_name, initializer=tf.zeros( init_value.get_shape(), dtype=init_value.dtype))) # It makes things a lot simpler if we use the init_value the first # iteration, instead of the variable itself. It allows us to propagate # gradients through it as well as simplifying initialization. The variable # ends up assigned to after the first iteration. vals = tf.cond(return_init_values, lambda: init_values, lambda: local_vars) if len(init_values) == 1: # tf.cond extracts elements from singleton lists. vals = [vals] return local_vars, vals def create_local_state_variable_name(tensor): """Create a name of the variable based on its type and shape.""" if not tensor.get_shape().is_fully_defined(): raise ValueError("Need a fully specified shape to create a local variable.") return (_LOCAL_VARIABLE_PREFIX + "_".join( map(str, tensor.get_shape().as_list())) + "_" + tensor.dtype.name) def is_local_state_variable(op): """Returns if this op is a local state variable created for training.""" return op.node_def.op in ["Variable", "VariableV2"] and op.name.startswith( OPTIMIZER_SCOPE + "/" + _LOCAL_VARIABLE_PREFIX) def flatten_and_sort(dictionary): """Flattens a dictionary into a list of values sorted by the keys.""" return [dictionary[k] for k in sorted(dictionary.keys())]
the-stack_106_32308
# coding: utf-8 import tushare as ts import pandas as pd import datetime g = {} # 定义行业类别 g.index = 'industry' # 定义全局参数值 g.indexThre = 0.2 #站上pastDay日均线的行业比重 g.pastDay = 30 # 过去pastDay日参数 g.topK = 6 # if g.index == 'index': # 定义行业指数list以便去股票 g.indexList = ['000928.XSHG', '000929.XSHG', '000930.XSHG', '000931.XSHG', '000932.XSHG', '000933.XSHG', '000934.XSHG', '000935.XSHG', '000936.XSHG', '000937.XSHG', '000938.XSHG'] elif g.index == 'industry': # 定义行业list以便取股票 g.indexList = ['A01','A02','A03','A04','A05','B06', \ 'B07','B08','B09','B11','C13','C14','C15','C17','C18', \ 'C19','C20','C21','C22','C23','C24','C25','C26','C27', \ 'C28','C29','C30','C31','C32','C33','C34','C35','C36', \ 'C37','C38','C39','C40','C41','C42','D44','D45','D46', \ 'E47','E48','E50','F51','F52','G53','G54','G55','G56', \ 'G58','G59','H61','H62','I63','I64','I65','J66','J67', \ 'J68','J69','K70','L71','L72','M73','M74','N77','N78', \ 'P82','Q83','R85','R86','R87','S90'] # 计算相对强弱RPS值 def calRPS(stocks, curDate, preDate): # 初始化参数信息 numStocks = len(stocks) rankValue = [] # 计算涨跌幅 for code in stocks: # 获取过去pastDay的指数值 lastDf = ts.get_hist_data( code=code, start=preDate, end=curDate, ktype='D') lastDf.sort(columns='close') lastClosePrice = float(lastDf.iloc[0]) firstClosePrice = float(lastDf.iloc[-1]) # 计算涨跌幅 errCloseOpen = [lastClosePrice - firstClosePrice] rankValue += errCloseOpen # 根据周涨跌幅排名 rpsStocks = {'code': stocks, 'rankValue': rankValue} rpsStocks = pd.DataFrame(rpsStocks) rpsStocks = rpsStocks.sort('rankValue', ascending=False) stocks = list(rpsStocks['code']) # 计算RPS值 rpsValue = [99 - (100 * i / numStocks) for i in range(numStocks)] rpsStocks = {'code': stocks, 'rpsValue': rpsValue} rpsStocks = pd.DataFrame(rpsStocks) return rpsStocks # 股票池:取强舍弱 def findStockPool(indexList, curDate, preDate, index='index'): topK = g.topK stocks = [] rpsValue = [] industryCode = [] # 从每个行业中选取RPS值最高的topK只股票 # for eachIndustry in industryList: for eachIndex in indexList: # 取出该行业的股票 if index == 'index': stocks = get_index_stocks(eachIndex) elif index == 'industry': stocks = get_industry_stocks(eachIndex) else: return 'Error index order' # 计算股票的相对强弱RPS值 rpsStocks = calRPS(stocks, curDate, preDate) stocks.append(rpsStocks[:topK]['code']) # rpsValue += list(rpsStocks[:topK]['rpsValue']) return stocks # 选股:单均线动量策略 def selectStocks(stocks, curDate, data): # 初始化 returnStocks = [] # 筛选当且仅当当日收盘价在5日均线以上的股票 for code in stocks: closePrice = ts.get_hist_data( code=code, start=curDate, end=curDate, ktype='D') closePrice.sort(columns='close') closePrice = float(closePrice.iloc[-1]) ma5 = data[code].mavg(5, 'close') ma15 = data[code].mavg(15, 'close') # if closePrice > ma5: if closePrice > ma5 and ma5 > ma15: returnStocks.append(code) else: continue return returnStocks # 止损:牛熊分界线 def calBuySign(indexList, pastDay, data, index='index'): # 初始化 indexThre = g.indexThre # 计算过去几天的指数均值,判断是否满足牛熊分界值 count = 0 if index == 'index': for eachIndex in indexList: avgPrice = data[eachIndex].mavg(pastDay, 'close') if data[eachIndex].mavg(1, 'close') > avgPrice: count += 1 else: continue elif index == 'industry': for eachIndustry in indexList: stocks = get_industry_stocks(eachIndustry) pastValue = 0 curValue = 0 for eachStocks in stocks: # pastValue += data[eachStocks].mavg(pastDay,'close') # curValue += data[eachStocks].mavg(1,'close') stocksPastPrice = data[eachStocks].mavg(pastDay, 'close') stocksCurrPrice = data[eachStocks].price if stocksPastPrice is None or stocksCurrPrice is None: continue else: pastValue += stocksPastPrice curValue += stocksCurrPrice if curValue > pastValue: count += 1 else: continue else: return 'Error index order.' # 根据行业比重发出牛熊市场信号 if float(count) / len(indexList) > indexThre: return True else: return False # 每个单位时间(如果按天回测,则每天调用一次,如果按分钟,则每分钟调用一次)调用一次 def handle_data(context, data): # 初始化参数 index = g.index indexList = g.indexList indexThre = g.indexThre pastDay = g.pastDay curDate = datetime.date.today() preDate = curDate + datetime.timedelta(days=-pastDay) curDate = str(curDate) preDate = str(preDate) # 获取资金余额 cash = context.portfolio.cash topK = g.topK numSell = 0 numBuy = 0 # 牛熊分界线发布止损信号 buySign = calBuySign(indexList, pastDay, data, index) # buySign = True if buySign == True: # 取强舍弱选股:根据相对RPS指标选取各个行业中最强势的股票形成股票池 candidateStocks = findStockPool(indexList, curDate, preDate, index) # 根据均线策略从股票池中选股买卖 stocks = selectStocks(candidateStocks, curDate, preDate, data) countStocks = len(stocks) if countStocks > topK: rpsStocks = calRPS(stocks, curDate, preDate) stocks = list(rpsStocks[:topK]['code']) else: pass countStocks = len(stocks) # 判断当前是否持有目前股票,若已持有股票在新的候选池里则继续持有,否则卖出 for security in context.portfolio.positions.keys(): if security in stocks: continue else: order_target(security, 0) numSell += 1 # print("Selling %s" %(security)) # 根据股票池买入股票 for security in stocks: # 获取股票基本信息:是否停牌、是否ST,持股头寸、股价等 currentData = get_current_data() pauseSign = currentData[security].paused STInfo = get_extras( 'is_st', security, start_date=preDate, end_date=curDate) STSign = STInfo.iloc[-1] stocksAmount = context.portfolio.positions[security].amount stocksPrice = data[security].price if not pauseSign and not STSign.bool(): # 购买该股票,获得可购买的股票数量 buyAmount = int((cash / countStocks) / stocksPrice) order(security, buyAmount) numBuy += 1 # print("Buying %s" % (security)) else: continue else: # 将目前所有的股票卖出 for security in context.portfolio.positions: # 全部卖出 order_target(security, 0) numSell += 1 # 记录这次卖出 # print("Selling %s" % (security))
the-stack_106_32309
# # CanvasRenderAgg.py -- for rendering into a ImageViewAgg widget # # Eric Jeschke ([email protected]) # # Copyright (c) Eric R. Jeschke. All rights reserved. # This is open-source software licensed under a BSD license. # Please see the file LICENSE.txt for details. import math import aggdraw as agg from . import AggHelp from itertools import chain # force registration of all canvas types import ginga.canvas.types.all class RenderContext(object): def __init__(self, viewer): self.viewer = viewer # TODO: encapsulate this drawable self.cr = AggHelp.AggContext(self.viewer.get_surface()) self.pen = None self.brush = None self.font = None def set_line_from_shape(self, shape): # TODO: support line width and style alpha = getattr(shape, 'alpha', 1.0) self.pen = self.cr.get_pen(shape.color, alpha=alpha) def set_fill_from_shape(self, shape): fill = getattr(shape, 'fill', False) if fill: if hasattr(shape, 'fillcolor') and shape.fillcolor: color = shape.fillcolor else: color = shape.color alpha = getattr(shape, 'alpha', 1.0) alpha = getattr(shape, 'fillalpha', alpha) self.brush = self.cr.get_brush(color, alpha=alpha) else: self.brush = None def set_font_from_shape(self, shape): if hasattr(shape, 'font'): if hasattr(shape, 'fontsize') and shape.fontsize is not None: fontsize = shape.fontsize else: fontsize = shape.scale_font(self.viewer) alpha = getattr(shape, 'alpha', 1.0) self.font = self.cr.get_font(shape.font, fontsize, shape.color, alpha=alpha) else: self.font = None def initialize_from_shape(self, shape, line=True, fill=True, font=True): if line: self.set_line_from_shape(shape) if fill: self.set_fill_from_shape(shape) if font: self.set_font_from_shape(shape) def set_line(self, color, alpha=1.0, linewidth=1, style='solid'): # TODO: support line width and style self.pen = self.cr.get_pen(color, alpha=alpha) def set_fill(self, color, alpha=1.0): if color is None: self.brush = None else: self.brush = self.cr.get_brush(color, alpha=alpha) def set_font(self, fontname, fontsize, color='black', alpha=1.0): self.font = self.cr.get_font(fontname, fontsize, color, alpha=alpha) def text_extents(self, text): return self.cr.text_extents(text, self.font) def get_affine_transform(self, cx, cy, rot_deg): x, y = 0, 0 # old center nx, ny = cx, cy # new center sx = sy = 1.0 # new scale cosine = math.cos(math.radians(rot_deg)) sine = math.sin(math.radians(rot_deg)) a = cosine / sx b = sine / sx c = x - nx*a - ny*b d = -sine / sy e = cosine / sy f = y - nx*d - ny*e return (a, b, c, d, e, f) ##### DRAWING OPERATIONS ##### def draw_text(self, cx, cy, text, rot_deg=0.0): wd, ht = self.cr.text_extents(text, self.font) self.cr.canvas.text((cx, cy-ht), text, self.font) ## affine = self.get_affine_transform(cx, cy-ht, rot_deg) ## self.cr.canvas.settransform(affine) ## self.cr.canvas.text((0, 0), text, self.font) ## # reset default transform ## self.cr.canvas.settransform() def draw_polygon(self, cpoints): self.cr.canvas.polygon(list(chain.from_iterable(cpoints)), self.pen, self.brush) def draw_circle(self, cx, cy, cradius): self.cr.canvas.ellipse((cx-cradius, cy-cradius, cx+cradius, cy+cradius), self.pen, self.brush) def draw_bezier_curve(self, cp): # there is a bug in path handling of some versions of aggdraw-- # aggdraw here is ok: path = agg.Path() path.moveto(cp[0][0], cp[0][1]) path.curveto(cp[1][0], cp[1][1], cp[2][0], cp[2][1], cp[3][0], cp[3][1]) self.cr.canvas.path(path, self.pen, self.brush) def draw_ellipse_bezier(self, cp): # draw 4 bezier curves to make the ellipse because there seems # to be a bug in aggdraw ellipse drawing function path = agg.Path() path.moveto(cp[0][0], cp[0][1]) path.curveto(cp[1][0], cp[1][1], cp[2][0], cp[2][1], cp[3][0], cp[3][1]) path.curveto(cp[4][0], cp[4][1], cp[5][0], cp[5][1], cp[6][0], cp[6][1]) path.curveto(cp[7][0], cp[7][1], cp[8][0], cp[8][1], cp[9][0], cp[9][1]) path.curveto(cp[10][0], cp[10][1], cp[11][0], cp[11][1], cp[12][0], cp[12][1]) self.cr.canvas.path(path, self.pen, self.brush) def draw_line(self, cx1, cy1, cx2, cy2): self.cr.canvas.line((cx1, cy1, cx2, cy2), self.pen) def draw_path(self, cp): # TODO: is there a more efficient way in aggdraw to do this? path = agg.Path() path.moveto(cp[0][0], cp[0][1]) for pt in cp[1:]: path.lineto(pt[0], pt[1]) self.cr.canvas.path(path, self.pen, self.brush) class CanvasRenderer(object): def __init__(self, viewer): self.viewer = viewer def setup_cr(self, shape): cr = RenderContext(self.viewer) cr.initialize_from_shape(shape, font=False) return cr def get_dimensions(self, shape): cr = self.setup_cr(shape) cr.set_font_from_shape(shape) return cr.text_extents(shape.text) #END
the-stack_106_32311
print("テーブル名を入力してください") table = input() #print("カラム数を入力してください") #colum = int(input()) print("csvデータを張り付けてね") mail=[] while(True): i = input() if(i=="end"): break test=i.split(",") test2='"' for n in range(len(test[0])): test2.append(test[0][n]) mail.append() for i in mail: print("INSERT INTO " + table + " VALUES (" + i +");")
the-stack_106_32313
""" Newsreader - Site Copyright (c) 2018 Trevor Bramwell <[email protected]> SPDX-License-Identifier: Apache-2.0 """ import requests from bs4 import BeautifulSoup from .article import Article class Site(): """A site represents a news source and contains a list of articles after being parsed""" name = "NPR" def __init__(self, url): self.url = url self.articles = [] def parse(self): """Parse a site and extract the articles""" # logging.info("Parsing: %s", self.url) page = requests.get(self.url) soup = BeautifulSoup(page.content, 'html5lib') links = soup.body.ul.find_all('li') for link in links: # logging.info("Adding article: %s", link) href = "%s%s" % (self.url, link.a['href']) article = Article(self.name, link.string, href) self.articles.append(article) def get_articles(self): """Return articles from the site, requires the site have been parsed first""" return self.articles
the-stack_106_32314
#!/usr/bin/env python from distutils.core import setup LONG_DESCRIPTION = \ '''The program reads one or more input FASTA files. For each file it computes a variety of statistics, and then prints a summary of the statistics as output. The goal is to provide a solid foundation for new bioinformatics command line tools, and is an ideal starting place for new projects.''' setup( name='biodemo', version='0.1.0.0', author='Anna Syme', author_email='[email protected]', packages=['biodemo'], package_dir={'biodemo': 'biodemo'}, entry_points={ 'console_scripts': ['biodemo = biodemo.biodemo:main'] }, url='https://github.com/GITHUB_USERNAME/biodemo', license='LICENSE', description=('A prototypical bioinformatics command line tool'), long_description=(LONG_DESCRIPTION), install_requires=["biopython"], )
the-stack_106_32315
import tvm import numpy as np from tvm import relay from tvm.relay.ir_pass import alpha_equal from tvm.relay.ir_builder import convert def test_tensor_type_alpha_equal(): t1 = relay.TensorType((3, 4), "float32") t2 = relay.TensorType((3, 4), "float32") t3 = relay.TensorType((3, 4, 5), "float32") assert t1 == t2 assert t1 != t3 t1 = relay.TensorType((), "float32") t2 = relay.TensorType((), "float32") assert t1 == t2 def test_incomplete_type_alpha_equal(): t1 = relay.IncompleteType(relay.Kind.Shape) t2 = relay.IncompleteType(relay.Kind.Type) t3 = relay.IncompleteType(relay.Kind.Type) # only equal when there is pointer equality assert t2 == t2 assert t1 == t1 assert t1 != t2 assert t2 != t3 def test_type_param_alpha_equal(): t1 = relay.TypeParam("v1", relay.Kind.Type) t2 = relay.TypeParam("v2", relay.Kind.Shape) t3 = relay.TypeParam("v3", relay.Kind.Type) # only pointer equality and eq_map allow equal params assert t1 == t1 assert t2 == t2 assert t1 != t2 # different kind assert t1 != t3 # not in eq_map # function types are the only way to put type params # in eq map ft1 = relay.FuncType(tvm.convert([]), t1, tvm.convert([t1]), tvm.convert([])) ft2 = relay.FuncType(tvm.convert([]), t3, tvm.convert([t3]), tvm.convert([])) # actually an invalid type because t2 is wrong kind ft3 = relay.FuncType(tvm.convert([]), t2, tvm.convert([t2]), tvm.convert([])) assert ft1 == ft2 assert ft1 != ft3 # kinds still do not match def test_func_type_alpha_equal(): t1 = relay.TensorType((1, 2), "float32") t2 = relay.TensorType((1, 2, 3), "float32") tp1 = relay.TypeParam("v1", relay.Kind.Type) tp2 = relay.TypeParam("v2", relay.Kind.Type) tp3 = relay.TypeParam("v3", relay.Kind.Shape) tp4 = relay.TypeParam("v3", relay.Kind.Shape) broadcast = tvm.get_env_func("tvm.relay.type_relation.Broadcast") identity = tvm.get_env_func("tvm.relay.type_relation.Identity") tr1 = relay.TypeRelation(broadcast, tvm.convert([tp1, tp3]), 1, None) tr2 = relay.TypeRelation(broadcast, tvm.convert([tp2, tp4]), 1, None) tr3 = relay.TypeRelation(identity, tvm.convert([tp1, tp3]), 1, None) ft = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp1, tp3]), tvm.convert([tr1])) translate_vars = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp2, tp4]), tvm.convert([tr2])) assert ft == translate_vars different_args = relay.FuncType(tvm.convert([t1]), tp1, tvm.convert([tp1, tp3]), tvm.convert([tr1])) assert ft != different_args different_order = relay.FuncType(tvm.convert([t2, t1]), tp1, tvm.convert([tp1, tp3]), tvm.convert([tr1])) assert ft != different_order no_rel = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp1, tp3]), tvm.convert([])) assert ft != no_rel more_vars = relay.FuncType(tvm.convert([t1, t2]), tp2, tvm.convert([tp1, tp2, tp3]), tvm.convert([tr1])) assert ft != more_vars all_the_vars = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp1, tp2, tp3, tp4]), tvm.convert([tr1, tr2])) assert ft != all_the_vars different_rel = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp1, tp3]), tvm.convert([tr3])) assert ft != different_rel more_rels = relay.FuncType(tvm.convert([t1, t2]), tp1, tvm.convert([tp1, tp3]), tvm.convert([tr1, tr3])) assert ft != more_rels def test_tuple_type_alpha_equal(): t1 = relay.TensorType((1, 2, 3), "float32") t2 = relay.TensorType((1, 2, 3, 4), "float32") tp1 = relay.TypeParam("v1", relay.Kind.Type) tp2 = relay.TypeParam("v2", relay.Kind.Type) tup1 = relay.TupleType(tvm.convert([t1, t2, tp1])) tup2 = relay.TupleType(tvm.convert([t1, t2, tp1])) tup3 = relay.TupleType(tvm.convert([t2, t1, tp1])) tup4 = relay.TupleType(tvm.convert([t1, t2, tp2])) # as long as types are alpha-equal and in same order, # tuples should be alpha-equal assert tup1 == tup2 assert tup1 != tup3 assert tup1 != tup4 def test_type_relation_alpha_equal(): t1 = relay.TensorType((1, 2), "float32") t2 = relay.TensorType((1, 2, 3), "float32") t3 = relay.TensorType((1, 2, 3, 4), "float32") # functions are compared only by pointer equality so # we need to be sure to use the same pointers broadcast = tvm.get_env_func("tvm.relay.type_relation.Broadcast") identity = tvm.get_env_func("tvm.relay.type_relation.Identity") # attrs are also compared only by pointer equality attr1 = tvm.make.node("attrs.TestAttrs", name="attr", padding=(3,4)) attr2 = tvm.make.node("attrs.TestAttrs", name="attr", padding=(3,4)) tr = relay.TypeRelation(broadcast, tvm.convert([t1, t2]), 1, attr1) same = relay.TypeRelation(broadcast, tvm.convert([t1, t2]), 1, attr1) diff_func = relay.TypeRelation(identity, tvm.convert([t1, t2]), 1, attr1) diff_order = relay.TypeRelation(broadcast, tvm.convert([t2, t1]), 1, attr1) diff_args = relay.TypeRelation(broadcast, tvm.convert([t2, t3]), 1, attr1) diff_attr = relay.TypeRelation(broadcast, tvm.convert([t1, t2]), 1, attr2) bigger = relay.TypeRelation(identity, tvm.convert([t1, t3, t2]), 2, attr1) diff_num_inputs = relay.TypeRelation(identity, tvm.convert([t1, t3, t2]), 1, attr2) # func, number of args, input count, and order should be the same assert tr == same assert tr != diff_func assert tr != diff_order assert tr != diff_args assert tr != diff_attr assert tr != bigger assert bigger != diff_num_inputs def test_constant_alpha_equal(): x = convert(1) y = convert(2) assert alpha_equal(x, x) assert not alpha_equal(x, y) assert alpha_equal(x, convert(1)) def test_var_alpha_equal(): v1 = relay.Var("v1") v2 = relay.Var("v2") # normally only pointer equality assert alpha_equal(v1, v1) assert not alpha_equal(v1, v2) # let node allows for setting the eq_map l1 = relay.Let(v1, convert(1), v1) l2 = relay.Let(v2, convert(1), v2) l3 = relay.Let(v1, convert(1), v2) assert alpha_equal(l1, l2) assert not alpha_equal(l1, l3) def test_global_var_alpha_equal(): v1 = relay.GlobalVar("v1") v2 = relay.GlobalVar("v2") # only pointer equality suffices (smoke test) assert alpha_equal(v1, v1) assert not alpha_equal(v1, v2) def test_tuple_alpha_equal(): v1 = relay.Var("v1") v2 = relay.Var("v2") # unit value is a valid tuple assert alpha_equal(relay.Tuple([]), relay.Tuple([])) tup = relay.Tuple([v1, convert(2), convert(3), relay.Tuple([convert(4)])]) same = relay.Tuple([v1, convert(2), convert(3), relay.Tuple([convert(4)])]) assert alpha_equal(tup, same) # use the eq_map let_tup = relay.Let(v1, tup, v1) let_mapped = relay.Let(v2, relay.Tuple([v2, convert(2), convert(3), relay.Tuple([convert(4)])]), v2) assert alpha_equal(let_tup, let_mapped) more_fields = relay.Tuple([v1, convert(2), convert(3), relay.Tuple([convert(4)]), v2]) assert not alpha_equal(tup, more_fields) fewer_fields = relay.Tuple([v1, convert(2), convert(3)]) assert not alpha_equal(tup, fewer_fields) different_end = relay.Tuple([v1, convert(2), convert(3), relay.Tuple([convert(5)])]) assert not alpha_equal(tup, different_end) different_start = relay.Tuple([v2, convert(2), convert(3), relay.Tuple([convert(4)])]) assert not alpha_equal(tup, different_start) longer_at_end = relay.Tuple([v1, convert(2), convert(3), relay.Tuple([convert(4), convert(5)])]) assert not alpha_equal(tup, longer_at_end) def test_tuple_get_item_alpha_equal(): x = relay.Var('x') y = relay.Var('y') assert not alpha_equal(relay.TupleGetItem(x, 1), relay.TupleGetItem(y, 1)) assert not alpha_equal(relay.TupleGetItem(x, 1), relay.TupleGetItem(x, 2)) assert alpha_equal(relay.TupleGetItem(x, 1), relay.TupleGetItem(x, 1)) def test_function_alpha_equal(): tt1 = relay.TensorType((1, 2, 3), "float32") tt2 = relay.TensorType((4, 5, 6), "int8") tt3 = relay.TupleType([tt1, tt2]) v1 = relay.Var("v1", tt1) v2 = relay.Var("v2", tt2) v3 = relay.Var("v3", tt3) v4 = relay.Var("v4", tt2) vret = relay.Constant(tvm.nd.array(np.ones(1))) tp1 = relay.TypeParam("tp1", relay.Kind.Type) tp2 = relay.TypeParam("tp2", relay.Kind.Type) tp3 = relay.TypeParam("tp3", relay.Kind.Shape) tp4 = relay.TypeParam("tp4", relay.Kind.Shape) basic_args = [relay.Var("v3", tt1), relay.Var("v4", tt2)] basic_tps = [tp1, tp2] func = relay.Function([v1, v2], tt2, v1, basic_tps) mapped = relay.Function(basic_args, tt2, basic_args[0], basic_tps) assert alpha_equal(func, mapped) fewer_params = relay.Function([relay.Var("v4", tt2)], tt2, v4, basic_tps) assert not alpha_equal(func, fewer_params) more_params = relay.Function([relay.Var("v3", tt1), relay.Var("v4", tt2), relay.Var("v2", tt2)], tt2, v4, basic_tps) assert not alpha_equal(func, more_params) params_unordered = relay.Function([v2, v1], tt2, v1, basic_tps) assert not alpha_equal(func, params_unordered) params_mismatch = relay.Function([v1, v3], tt2, v1, basic_tps) assert not alpha_equal(func, params_mismatch) # also would not typecheck ret_type_mismatch = relay.Function(basic_args, tt1, v4, basic_tps) assert not alpha_equal(func, ret_type_mismatch) # also mis-typed different_body = relay.Function(basic_args, tt2, v3, basic_tps) assert not alpha_equal(func, different_body) fewer_type_params = relay.Function(basic_args, tt2, v4, [tp1]) assert not alpha_equal(func, fewer_type_params) more_type_params = relay.Function(basic_args, tt2, v4, [tp1, tp2, tp3]) assert not alpha_equal(func, more_type_params) type_params_unordered = relay.Function(basic_args, tt2, v4, [tp2, tp1]) assert not alpha_equal(func, type_params_unordered) different_type_params = relay.Function(basic_args, tt2, v4, [tp3, tp4]) assert not alpha_equal(func, different_type_params) # a well-typed example that also differs in body, ret type, and type params tupled_example = relay.Function(basic_args, tt3, relay.Tuple([v3, v4])) assert not alpha_equal(func, tupled_example) def test_call_alpha_equal(): v1 = relay.Var("v1") v2 = relay.Var("v2") # attrs are compared only by pointer equality attr1 = tvm.make.node("attrs.TestAttrs", name="attr", padding=(3,4)) attr2 = tvm.make.node("attrs.TestAttrs", name="attr", padding=(3,4)) tt1 = relay.TensorType((1, 2, 3), "float32") tt2 = relay.TensorType((), "int8") basic_args = [convert(1), convert(2), v2, relay.Tuple([])] # manually writing out args to ensure that args does not rely on # pointer equality call = relay.Call(v1, [convert(1), convert(2), v2, relay.Tuple([])], attr1, [tt1]) same = relay.Call(v1, basic_args, attr1, [tt1]) assert alpha_equal(call, same) different_fn = relay.Call(v2, basic_args, attr1, [tt1]) assert not alpha_equal(call, different_fn) fewer_args = relay.Call(v1, [convert(1), convert(2), v2], attr1, [tt1]) assert not alpha_equal(call, fewer_args) reordered_args = relay.Call(v1, [convert(2), convert(1), relay.Tuple([]), v2], attr1, [tt1]) assert not alpha_equal(call, reordered_args) different_args = relay.Call(v1, [convert(1), convert(2), convert(3)], attr1, [tt1]) assert not alpha_equal(call, different_args) more_args = relay.Call(v1, [convert(1), convert(2), v2, relay.Tuple([]), convert(3), convert(4)], attr1, [tt1]) assert not alpha_equal(call, more_args) different_attrs = relay.Call(v1, basic_args, attr2, [tt1]) assert not alpha_equal(call, different_attrs) no_type_args = relay.Call(v1, basic_args, attr1) assert not alpha_equal(call, no_type_args) more_type_args = relay.Call(v1, basic_args, attr1, [tt1, tt2]) assert not alpha_equal(call, more_type_args) different_type_arg = relay.Call(v1, basic_args, attr1, [tt2]) assert not alpha_equal(call, different_type_arg) def test_let_alpha_equal(): tt1 = relay.TensorType((), "float32") tt2 = relay.TensorType((), "int8") v1 = relay.Var("v1") v1_wtype = relay.Var("v1", tt1) v2 = relay.Var("v2") v3 = relay.Var("v3") let = relay.Let(v1, convert(2), v1) mapped = relay.Let(v2, convert(2), v2) assert alpha_equal(let, mapped) mismatched_var = relay.Let(v2, convert(2), v3) assert not alpha_equal(let, mismatched_var) different_value = relay.Let(v2, convert(3), v2) assert not alpha_equal(let, different_value) different_body = relay.Let(v2, convert(3), convert(12)) assert not alpha_equal(let, different_body) # specified types must match let_with_type = relay.Let(v1_wtype, convert(2), v1_wtype) same_type = relay.Let(v1_wtype, convert(2), v1_wtype) assert alpha_equal(let_with_type, same_type) assert not alpha_equal(let, let_with_type) v2 = relay.Var("v1", tt2) different_type = relay.Let(v2, convert(2), v2) assert not alpha_equal(let_with_type, different_type) def test_if_alpha_equal(): v1 = relay.Var("v1") v2 = relay.Var("v2") if_sample = relay.If(v1, convert(1), relay.Tuple([convert(2), convert(3)])) same = relay.If(v1, convert(1), relay.Tuple([convert(2), convert(3)])) assert alpha_equal(if_sample, same) different_cond = relay.If(v2, convert(1), relay.Tuple([convert(2), convert(3)])) assert not alpha_equal(if_sample, different_cond) different_true = relay.If(v1, convert(2), relay.Tuple([convert(2), convert(3)])) assert not alpha_equal(if_sample, different_true) different_false = relay.If(v1, convert(1), relay.Tuple([])) assert not alpha_equal(if_sample, different_false) def test_op_alpha_equal(): # only checks names op1 = relay.op.get("add") op2 = relay.op.get("add") assert alpha_equal(op1, op2) op3 = relay.op.get("take") assert not alpha_equal(op1, op3) if __name__ == "__main__": test_tensor_type_alpha_equal() test_incomplete_type_alpha_equal() test_constant_alpha_equal() test_func_type_alpha_equal() test_tuple_type_alpha_equal() test_type_relation_alpha_equal() test_constant_alpha_equal() test_global_var_alpha_equal() test_tuple_alpha_equal() test_tuple_get_item_alpha_equal() test_function_alpha_equal() test_call_alpha_equal() test_let_alpha_equal() test_if_alpha_equal() test_op_alpha_equal()
the-stack_106_32316
import os from bokeh.layouts import gridplot from bokeh.plotting import figure, show, save, output_file from bokeh.models import ColumnDataSource, HoverTool, LinearColorMapper, BasicTicker, PrintfTickFormatter, ColorBar, Range1d from bokeh.transform import transform from bokeh.palettes import RdBu, Spectral, RdYlBu, RdGy, YlGnBu, Inferno, Plasma, PuBu, Greys, Magma, Viridis def plot_voltage(project_name, voltage_df, ss_code=None, ss_config=None): # Check for data to plot if voltage_df is None: return # If there is no data, than we cannot create a plot if voltage_df.empty: return # Create a default subsystem query string ss_str = "_{}_{}".format(ss_config, ss_code) TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom" # Create plot plot = figure(tools=[TOOLS], title="{} - Voltage".format(project_name), x_axis_type="datetime") # Combine the data into a Data frame for ColumnDataSource for the plot plot.line(x='datetime', y='voltage', source=ColumnDataSource(voltage_df), line_width=5, line_color="Goldenrod") # Set the labels plot.xaxis.axis_label = "Date/Time" plot.yaxis.axis_label = 'Voltage' # Set the tool tip plot.select_one(HoverTool).tooltips = [ ('ENS Num', '@ensnum'), ('Date/Time', '@datetime{%F}'), ('Voltage', '@voltage'), ] plot.select_one(HoverTool).formatters = { 'datetime': 'datetime' # use 'datetime' formatter for 'datetime' field } plot.select_one(HoverTool).mode = 'vline' # display a tooltip whenever the cursor is vertically in line with a glyph # Save plot to HTML file_name = project_name + '{}_voltage.html'.format(ss_str) file_name = os.path.join('html', file_name) output_file(file_name, title="{} - Voltage".format(project_name)) save(gridplot([[plot]], sizing_mode='stretch_both')) # Just save to file
the-stack_106_32317
import os import pickle import gendist import torchvision import numpy as np import pandas as pd import matplotlib.pyplot as plt from datetime import datetime from tqdm import tqdm from loguru import logger from augly import image from jax.flatten_util import ravel_pytree def processor(X, angle): X_shift = image.aug_np_wrapper(X, image.rotate, degrees=angle) size_im = X_shift.shape[0] size_pad = (28 - size_im) // 2 size_pad_mod = (28 - size_im) % 2 X_shift = np.pad(X_shift, (size_pad, size_pad + size_pad_mod)) return X_shift def predict_shifted_dataset(ix_seed, X_batch, processor, config, wmodel, wparams, dmodel, proj, fn_reconstruct): """ Parameters ---------- ix_seed: array X_batch: array ... wmodel: model for the latent space wparams: trained weights for the latent space dmodel: model for the observed space dparams: trained model for the observed weights """ x_seed = X_batch[ix] x_shift = processor.process_single(x_seed, **config).ravel() predicted_weights = wmodel.apply(wparams, x_shift) predicted_weights = proj.inverse_transform(predicted_weights) predicted_weights = fn_reconstruct(predicted_weights) X_batch_shift = processor(X_batch, config) y_batch_hat = dmodel.apply(predicted_weights, X_batch_shift) return y_batch_hat path_experiment = "./outputs/2203221129/" path_data_model = os.path.join(path_experiment, "output", "data-model-result.pkl") path_meta_model = os.path.join(path_experiment, "output", "meta-model.pkl") path_results = os.path.join(path_experiment, "output", "accuracy.pkl") with open(path_data_model, "rb") as f: data_model_results = pickle.load(f) with open(path_meta_model, "rb") as f: meta_model_results = pickle.load(f) now_str = datetime.now().strftime("%Y%m%d%H%M") file_log = f"trench_test_{now_str}.log" path_logger = os.path.join(path_experiment, "logs", file_log) logger.remove() logger.add(path_logger, rotation="5mb") mnist_test = torchvision.datasets.MNIST(root=".", train=False, download=True) X_test = np.array(mnist_test.data) / 255 y_test = np.array(mnist_test.targets) proc_class = gendist.processing.Factory(processor) pca = meta_model_results["projection_model"] meta_model = gendist.models.MLPWeightsV1(pca.n_components) data_model = gendist.models.MLPDataV1(10) _, fn_reconstruct_params = ravel_pytree(data_model_results["params"][0]) accuracy_configs_learned = [] ixs = np.arange(5) for config in tqdm(data_model_results["configs"]): acc_dict = {} for ix in ixs: y_test_hat = predict_shifted_dataset(ix, X_test, proc_class, config, meta_model, meta_model_results["params"], data_model, pca, fn_reconstruct_params) y_test_hat = y_test_hat.argmax(axis=1) accuracy_learned = (y_test_hat == y_test).mean().item() acc_dict[ix] = accuracy_learned accuracy_configs_learned.append(acc_dict) angle = config["angle"] logger_row = "|".join([format(v, "0.2%") for v in acc_dict.values()]) logger_row = f"{angle=:0.4f} | " + logger_row logger.info(logger_row) pd.DataFrame(acc_dict).to_pickle(path_results)
the-stack_106_32318
import pytest @pytest.fixture def document_0(publication): return { 'references': [publication['identifiers'][0]], } @pytest.fixture def document_base(lab, award): return { 'award': award['uuid'], 'lab': lab['uuid'], 'document_type': 'growth protocol', } @pytest.fixture def document_1(document_base): item = document_base.copy() item.update({ 'schema_version': '2', 'status': 'CURRENT', 'award': '4d462953-2da5-4fcf-a695-7206f2d5cf45' }) return item @pytest.fixture def document_3(root, document, publication): item = root.get_by_uuid(document['uuid']) properties = item.properties.copy() properties.update({ 'schema_version': '3', 'references': [publication['identifiers'][0]], }) return properties def test_document_0_upgrade(upgrader, document_0, publication): value = upgrader.upgrade('document', document_0, target_version='2') assert value['schema_version'] == '2' assert value['references'] == [publication['identifiers'][0]] def test_document_upgrade_status(upgrader, document_1): value = upgrader.upgrade('document', document_1, target_version='3') assert value['schema_version'] == '3' assert value['status'] == 'in progress' def test_document_upgrade_status_encode2(upgrader, document_1): document_1['award'] = '366388ac-685d-415c-b0bb-834ffafdf094' value = upgrader.upgrade('document', document_1, target_version='3') assert value['schema_version'] == '3' assert value['status'] == 'released' def test_document_upgrade_status_deleted(upgrader, document_1): document_1['status'] = 'DELETED' value = upgrader.upgrade('document', document_1, target_version='3') assert value['schema_version'] == '3' assert value['status'] == 'deleted' def test_document_upgrade_references(root, upgrader, document, document_3, publication, threadlocals, dummy_request): context = root.get_by_uuid(document['uuid']) dummy_request.context = context value = upgrader.upgrade('document', document_3, target_version='4', context=context) assert value['schema_version'] == '4' assert value['references'] == [publication['uuid']] def test_document_upgrade_status_replaced(upgrader, document_base): document_base['status'] = 'replaced' document_base['schema_version'] = '7' value = upgrader.upgrade('document', document_base, current_version='7', target_version='8') assert value['schema_version'] == '8' assert value['status'] == 'deleted'
the-stack_106_32319
"""modify isotopes table Revision ID: 8e68245fe95a Revises: a5189c25d85e Create Date: 2017-01-07 15:11:16.650856 """ # revision identifiers, used by Alembic. revision = "8e68245fe95a" down_revision = "a5189c25d85e" branch_labels = None depends_on = None from alembic import op import sqlalchemy as sa def upgrade(): op.add_column("isotopes", sa.Column("mass_uncertainty", sa.Float)) op.add_column("isotopes", sa.Column("is_radioactive", sa.Boolean)) op.add_column("isotopes", sa.Column("half_life", sa.Float)) op.add_column("isotopes", sa.Column("half_life_unit", sa.String)) def downgrade(): with op.batch_alter_table("isotopes") as batch_op: batch_op.drop_column("mass_uncertainty") batch_op.drop_column("is_radioactive") batch_op.drop_column("half_life") batch_op.drop_column("half_life_unit")
the-stack_106_32320
from __future__ import annotations import os import signal import subprocess as sp from enum import Enum, auto from threading import Thread from typing import Callable, List from pyutils import exc from .util import find_executable, kill # Public classes class OutputAction(Enum): """Output actions.""" PRINT = auto() DISCARD = auto() STORE = auto() class Task: """Spawn processes and easily capture their output.""" @property def name(self) -> str: return os.path.basename(self.path) @property def pid(self) -> int | None: return self._process.pid if self._process else None @property def stdout(self) -> str | None: return self._completed.stdout if self._completed else None @property def stderr(self) -> str | None: return self._completed.stderr if self._completed else None @property def exit_code(self) -> int | None: return self._completed.returncode if self._completed else None @classmethod def spawn(cls, executable: str, args: List[str] | None = None, output_action: OutputAction = OutputAction.STORE, input_path: str | None = None) -> Task: """Convenience factory method: builds, runs and returns a task.""" task = cls(executable, args=args, output_action=output_action, input_path=input_path) task.run() return task @classmethod def copying(cls, task: Task) -> Task: return cls(task.path, args=task.args, output_action=task.output_action, input_path=task.input_path) @classmethod def jar(cls, jar: str, jar_args: List[str] | None = None, jvm_opts: List[str] | None = None, output_action: OutputAction = OutputAction.STORE, input_path: str | None = None) -> Task: return cls('java', java_args(jar, jar_args=jar_args, jvm_opts=jvm_opts), output_action=output_action, input_path=input_path) def __init__(self, executable: str, args: List[str] | None = None, output_action: OutputAction = OutputAction.STORE, input_path: str | None = None) -> None: exc.raise_if_falsy(executable=executable, output_action=output_action) if not os.path.isabs(executable): executable = find_executable(executable) self.path = executable self.args = args self.output_action = output_action self.input_path = input_path self._completed: sp.CompletedProcess | None = None self._process: sp.Popen | None = None def run(self, wait: bool = True, timeout: float | None = None) -> Task: """Run the task.""" stdin = None try: handle = None if self.output_action == OutputAction.DISCARD: handle = sp.DEVNULL elif self.output_action == OutputAction.STORE: handle = sp.PIPE if self.input_path: stdin = open(self.input_path) self._process = sp.Popen(self._popen_args, stdout=handle, stderr=handle, stdin=stdin, universal_newlines=True) if wait: self.wait(timeout=timeout) except Exception as e: try: if stdin: stdin.close() exc.re_raise_new_message(e, f'Failed to call process: {self.path}') except Exception: raise e return self def wait(self, timeout: float | None = None) -> Task: """Wait for the task to exit.""" try: stdout, stderr = self._process.communicate(timeout=timeout) except sp.TimeoutExpired: self.send_signal(sig=signal.SIGKILL, children=True) stdout, stderr = self._process.communicate() raise sp.TimeoutExpired(self._process.args, timeout, output=stdout, stderr=stderr) except Exception: self.send_signal(sig=signal.SIGKILL, children=True) raise retcode = self._process.poll() if stdout: stdout = stdout.strip() if stderr: stderr = stderr.strip() self._completed = sp.CompletedProcess(self._popen_args, retcode, stdout, stderr) return self def run_async(self, timeout: float | None = None, exit_handler: Callable[[Task, Exception], None] | None = None) -> Task: """Run the task asynchronously.""" bg_proc = Thread(target=self._run_async_thread, args=[timeout, exit_handler]) bg_proc.daemon = True bg_proc.start() return self def send_signal(self, sig: int = signal.SIGKILL, children: bool = False) -> Task: """Send a signal to the task.""" if self._process and self._process.pid is not None: kill(self._process.pid, sig=sig, children=children) return self def raise_if_failed(self, ensure_output: bool = False, message: str | None = None) -> Task: """Raise an IOError if the task returned with a non-zero exit code.""" auto_msg = None should_raise = False if self.exit_code: auto_msg = f'Process "{self.name}" returned exit code: {self.exit_code:d}' should_raise = True elif ensure_output and not self.stdout: auto_msg = f'Process "{self.name}" returned no output.' should_raise = True if should_raise: err_lines = [] proc_out = self.stderr.strip() if self.stderr else None if not proc_out: proc_out = self.stdout.strip() if self.stdout else None for msg in [message, auto_msg, proc_out]: if msg: err_lines.append(msg) raise IOError('\n'.join(err_lines)) return self # Protected methods @property def _popen_args(self) -> List[str]: args = [self.path] if self.args: args.extend(self.args) return args def _run_async_thread(self, timeout: float | None, exit_handler: Callable[[Task, Exception], None] | None) -> None: err = None try: self.run(timeout=timeout) except Exception as e: err = e finally: if exit_handler: exit_handler(self, err) def java_args(jar: str, jar_args: List[str] | None = None, jvm_opts: List[str] | None = None) -> List[str]: """ Returns the argument list to pass to the JVM in order to launch the given Jar. :param jar: Path to the jar file. :param jar_args: Args to pass to the jar. :param jvm_opts: Args to pass to the JVM. :return: Argument list. """ args = [] if jvm_opts: args.extend(jvm_opts) args.extend(('-jar', jar)) if jar_args: args.extend(jar_args) return args
the-stack_106_32322
import dbm import logging import os from pathlib import Path import shutil import tempfile from django.apps import apps from django.utils.module_loading import import_string from .classes import DefinedStorage, PassthroughStorage from .settings import setting_temporary_directory logger = logging.getLogger(name=__name__) def NamedTemporaryFile(*args, **kwargs): kwargs.update({'dir': setting_temporary_directory.value}) return tempfile.NamedTemporaryFile(*args, **kwargs) class PassthroughStorageProcessor(object): def __init__( self, app_label, defined_storage_name, log_file, model_name, file_attribute='file' ): self.app_label = app_label self.defined_storage_name = defined_storage_name self.file_attribute = file_attribute self.log_file = log_file self.model_name = model_name def _update_entry(self, key): if not self.reverse: self.database[key] = '1' else: try: del self.database[key] except KeyError: pass def _inclusion_condition(self, key): if self.reverse: return key in self.database else: return key not in self.database def execute(self, reverse=False): self.reverse = reverse model = apps.get_model( app_label=self.app_label, model_name=self.model_name ) storage_instance = DefinedStorage.get( name=self.defined_storage_name ).get_storage_instance() if isinstance(storage_instance, PassthroughStorage): ContentType = apps.get_model( app_label='contenttypes', model_name='ContentType' ) content_type = ContentType.objects.get_for_model(model=model) self.database = dbm.open(self.log_file, flag='c') for instance in model.objects.all(): key = '{}.{}'.format(content_type.name, instance.pk) if self._inclusion_condition(key=key): file_name = getattr(instance, self.file_attribute).name content = storage_instance.open( name=file_name, mode='rb', _direct=not self.reverse ) storage_instance.delete(name=file_name) storage_instance.save( name=file_name, content=content, _direct=self.reverse ) self._update_entry(key=key) self.database.close def TemporaryFile(*args, **kwargs): kwargs.update({'dir': setting_temporary_directory.value}) return tempfile.TemporaryFile(*args, **kwargs) def fs_cleanup(filename, suppress_exceptions=True): """ Tries to remove the given filename. Ignores non-existent files. """ try: os.remove(filename) except OSError: try: shutil.rmtree(filename) except OSError: if suppress_exceptions: pass else: raise def get_storage_subclass(dotted_path): """ Import a storage class and return a subclass that will always return eq True to avoid creating a new migration when for runtime storage class changes. Used now only by historic migrations. """ imported_storage_class = import_string(dotted_path=dotted_path) class StorageSubclass(imported_storage_class): def __init__(self, *args, **kwargs): return super(StorageSubclass, self).__init__(*args, **kwargs) def __eq__(self, other): return True def deconstruct(self): return ('mayan.apps.storage.classes.FakeStorageSubclass', (), {}) return StorageSubclass def mkdtemp(*args, **kwargs): """ Creates a temporary directory in the most secure manner possible. There are no race conditions in the directory's creation. The directory is readable, writable, and searchable only by the creating user ID. """ kwargs.update({'dir': setting_temporary_directory.value}) return tempfile.mkdtemp(*args, **kwargs) def mkstemp(*args, **kwargs): kwargs.update({'dir': setting_temporary_directory.value}) return tempfile.mkstemp(*args, **kwargs) def patch_files(path=None, replace_list=None): """ Search and replace content from a list of file based on a pattern replace_list[ { 'filename_pattern': '*.css', 'content_patterns': [ { 'search': '', 'replace': '', } ] } ] """ file_open_mode = 'r+' path_object = Path(path) for replace_entry in replace_list or []: for path_entry in path_object.glob('**/{}'.format(replace_entry['filename_pattern'])): if path_entry.is_file(): for pattern in replace_entry['content_patterns']: with path_entry.open(mode=file_open_mode) as source_file_object: with tempfile.TemporaryFile(mode=file_open_mode) as temporary_file_object: source_position = 0 destination_position = 0 while(True): source_file_object.seek(source_position) letter = source_file_object.read(1) if len(letter) == 0: break else: if letter == pattern['search'][0]: text = '{}{}'.format(letter, source_file_object.read(len(pattern['search']) - 1)) temporary_file_object.seek(destination_position) if text == pattern['search']: text = pattern['replace'] source_position = source_position + len(pattern['search']) destination_position = destination_position + len(pattern['replace']) temporary_file_object.write(text) else: source_position = source_position + 1 destination_position = destination_position + 1 temporary_file_object.write(letter) else: source_position = source_position + 1 destination_position = destination_position + 1 temporary_file_object.write(letter) source_file_object.seek(0) source_file_object.truncate() temporary_file_object.seek(0) shutil.copyfileobj(fsrc=temporary_file_object, fdst=source_file_object) def validate_path(path): if not os.path.exists(path): # If doesn't exist try to create it try: os.mkdir(path) except Exception as exception: logger.debug('unhandled exception: %s', exception) return False # Check if it is writable try: fd, test_filepath = tempfile.mkstemp(dir=path) os.close(fd) os.unlink(test_filepath) except Exception as exception: logger.debug('unhandled exception: %s', exception) return False return True
the-stack_106_32325
import importlib import torch.utils.data from data.base_data_loader import BaseDataLoader from data.base_dataset import BaseDataset import numpy def find_dataset_using_name(dataset_name): # Given the option --dataset [datasetname], # the file "data/datasetname_dataset.py" # will be imported. dataset_filename = "data." + dataset_name + "_dataset" datasetlib = importlib.import_module(dataset_filename) # In the file, the class called DatasetNameDataset() will # be instantiated. It has to be a subclass of BaseDataset, # and it is case-insensitive. dataset = None target_dataset_name = dataset_name.replace('_', '') + 'dataset' for name, cls in datasetlib.__dict__.items(): if name.lower() == target_dataset_name.lower() \ and issubclass(cls, BaseDataset): dataset = cls if dataset is None: print("In %s.py, there should be a subclass of BaseDataset with class name that matches %s in lowercase." % (dataset_filename, target_dataset_name)) exit(0) return dataset def get_option_setter(dataset_name): dataset_class = find_dataset_using_name(dataset_name) return dataset_class.modify_commandline_options def create_dataset(opt): dataset = find_dataset_using_name(opt.dataset) instance = dataset() instance.initialize(opt) print("dataset [%s] was created" % (instance.name())) return instance def CreateDataLoader(opt): data_loader = CustomDatasetDataLoader() data_loader.initialize(opt) return data_loader # Wrapper class of Dataset class that performs # multi-threaded data loading class CustomDatasetDataLoader(BaseDataLoader): def name(self): return 'CustomDatasetDataLoader' def initialize(self, opt): BaseDataLoader.initialize(self, opt) self.dataset = create_dataset(opt) ''' self.dataloader = torch.utils.data.DataLoader( self.dataset, batch_size=opt.batch_size, shuffle=not opt.serial_batches, num_workers=int(opt.num_threads), worker_init_fn=lambda worker_id: numpy.random.seed(opt.seed + worker_id)) ''' self.dataloader = torch.utils.data.DataLoader( self.dataset, batch_size=opt.batch_size, shuffle=not opt.serial_batches, num_workers= 0, worker_init_fn=lambda worker_id: numpy.random.seed(opt.seed + worker_id)) def load_data(self): return self def __len__(self): return len(self.dataset) def __iter__(self): for i, data in enumerate(self.dataloader): yield data
the-stack_106_32326
from google.protobuf.json_format import MessageToJson class EmailComparetor: def compareEmailPb(self, oldPb, newPb): if (oldPb.localPart != ''): if (newPb.localPart != ''): None else: assert False, self.errorString(errorString="Local Part", newPb=newPb) if (oldPb.domain != ''): if (newPb.domain != ''): None else: assert False, self.errorString(errorString="Domain", newPb=newPb) def errorString(self, errorString, newPb): return errorString + "Cannot be Empty" + MessageToJson(newPb)
the-stack_106_32327
from scipy import signal import numpy as np import dtw from grbpy.burst import Burst import matplotlib.pyplot as plt import csv import os import pickle data_path = os.path.join('..','batse_data') # select the matrix type matrix_type = 'euclid' # adds a 25% buffer tot eh t90 time when False no_buffer = True # this is just a placeholder if one wants to truncate # the matrix build to only a few bursts. good for testing begin_with_burst = 999999 def get_burst_data(burst_num): '''this function is for parsing in burst data''' burst_info = burst_dict[burst_num] file_path = os.path.join(data_path,burst_info['burst_file']) grb = Burst(file_path) grb.parse_batse_file() burst_data = grb.sum_chan_data header_names = grb.header_names.split() header_data = grb.header_data.split() meta_dict = {} for i in range(len(header_data)): meta_dict[header_names[i]] = int(header_data[i]) time = (np.arange(meta_dict['npts'])-meta_dict['nlasc'])*0.064 t90_start = float(dur_dict[burst_num]['t90_start']) t90_end = float(dur_dict[burst_num]['t90_start']) + float(dur_dict[burst_num]['t90']) return time, burst_data, t90_start, t90_end def remove_background(background_dict,burst_data,time): '''this function removes the background from a burst''' return burst_data-float(background_dict['intercept'])-(time*float(background_dict['slope'])) def norm_time(time): '''this function normalizes time of a burst''' return (time-min(time))/(max(time)-min(time)) def norm_data(data): '''this function normalizes data of a burst''' return data/max(data) # parse in burst_info.csv burst_dict = {} with open(os.path.join('data','burst_info.csv'), newline='') as f: for row in csv.DictReader(f, delimiter=','): burst_dict[str(row['burst_num'])] = row # parse in background_table.csv background_dict = {} with open(os.path.join('data','background_table.csv'), newline='') as f: for row in csv.DictReader(f, delimiter=','): background_dict[str(row['burst_num'])] = row # parse in duration_table.csv dur_dict = {} with open(os.path.join('data','duration_table.csv'), newline='') as f: for row in csv.DictReader(f, delimiter=','): dur_dict[str(row['trig'])] = row # inits distance_matrix = [] burst_list = [] # looping through bursts for burst_num_1 in background_dict: if int(burst_num_1) > begin_with_burst: next else: # build burst list burst_list.append(background_dict[burst_num_1]['burst_num']) # inits calc_matrix = [] # looping through bursts for burst_num_2 in background_dict: # convenient way to ensure an upper triangular matrix if int(burst_num_2) > begin_with_burst: next else: # convenient way to ensure an upper triangular matrix if int(burst_num_2) > int(burst_num_1): # build buffers t90_buffer_1 = float(dur_dict[burst_num_1]['t90']) * 0.25 t90_buffer_2 = float(dur_dict[burst_num_2]['t90']) * 0.25 # parse in burst data from file time_1, burst_data_1, t90_start_1, t90_end_1 = get_burst_data(burst_num_1) time_2, burst_data_2, t90_start_2, t90_end_2 = get_burst_data(burst_num_2) # remove background burst_data_2 = remove_background(background_dict[burst_num_2],burst_data_2,time_2) burst_data_1 = remove_background(background_dict[burst_num_1],burst_data_1,time_1) # find the length of each burst vector for late use len_t90_time_1 = len(time_1[(time_1 > float(t90_start_1)) & (time_1 < float(t90_end_1))]) len_t90_time_2 = len(time_2[(time_2 > float(t90_start_2)) & (time_2 < float(t90_end_2))]) if no_buffer: # build the t90 window for each bursts time and data t90_data_1 = burst_data_1[(time_1 > float(t90_start_1)) & (time_1 < float(t90_end_1))] t90_time_1 = time_1[(time_1 > float(t90_start_1)) & (time_1 < float(t90_end_1))] t90_data_2= burst_data_2[(time_2 > float(t90_start_2)) & (time_2 < float(t90_end_2))] t90_time_2 = time_2[(time_2 > float(t90_start_2)) & (time_2 < float(t90_end_2))] else: # build the t90+buffer window for each bursts time and data t90_data_buffer_1 = burst_data_1[(time_1 > (float(t90_start_1)-t90_buffer_1)) & (time_1 < (float(t90_end_1)+t90_buffer_1))] t90_time_buffer_1 = time_1[(time_1 > (float(t90_start_1)-t90_buffer_1)) & (time_1 < (float(t90_end_1)+t90_buffer_1))] t90_data_buffer_2= burst_data_2[(time_2 > (float(t90_start_2)-t90_buffer_2)) & (time_2 < (float(t90_end_2)+t90_buffer_2))] t90_time_buffer_2 = time_2[(time_2 > (float(t90_start_2)-t90_buffer_2)) & (time_2 < (float(t90_end_2)+t90_buffer_2))] # This is a check to make sure the longer vector is the one that is resampled if len_t90_time_1 < len_t90_time_2: if no_buffer: # resample the longer vector resampled_burst, resampled_time = signal.resample(t90_data_2, len(t90_time_1), t=time_2) # rename the other burst other_burst, other_time = t90_data_1, t90_time_1 else: # resample the longer vector resampled_burst, resampled_time = signal.resample(t90_data_buffer_2, len(t90_time_buffer_1), t=time_2) # rename the other burst other_burst, other_time = t90_data_buffer_1, t90_time_buffer_1 elif len_t90_time_1 > len_t90_time_2: if no_buffer: # resample the longer vector resampled_burst, resampled_time = signal.resample(t90_data_1, len(t90_time_2), t=time_1) # rename the other burst other_burst, other_time = t90_data_2, t90_time_2 else: # resample the longer vector resampled_burst, resampled_time = signal.resample(t90_data_buffer_1, len(t90_time_buffer_2), t=time_1) # rename the other burst other_burst, other_time = t90_data_buffer_2, t90_time_buffer_2 else: next # normalize the scale of each vector form 0 to 1 norm_resampled = norm_data(resampled_burst) norm_other = norm_data(other_burst) ################################# # Zero Normalized Cross Correlation if matrix_type == 'corr': norm_resampled = (norm_resampled - np.mean(norm_resampled)) / (np.std(norm_resampled)) norm_other = (norm_other - np.mean(norm_other)) / (np.std(norm_other)) corr = signal.correlate(norm_resampled,norm_other) / max(len(norm_resampled), len(norm_other)) calc = max(corr) ################################# # Euclidean Norm elif matrix_type == 'euclid': calc = np.linalg.norm(norm_resampled-norm_other) ################################# # Normalized Manhattan Distance elif matrix_type == 'norm': calc = np.linalg.norm(norm_resampled-norm_other, ord=1)/len(resampled_burst) ################################# # Dynamic Time Warping elif matrix_type == 'dtw': DTW = dtw.dtw(norm_resampled,norm_other) calc = DTW.normalizedDistance else: print('unsupported matrix_type') next print('burst 1:',burst_num_1,'- burst 2',burst_num_2,'-',matrix_type,'dist:',calc) # append to the distance matrix distance_matrix.append(calc) # write out the matrix to a python pickle file with open(os.path.join('data',matrix_type+'_burst_list'+('_no_buffer' if no_buffer else '')+'.pkl'), 'wb') as f: pickle.dump(burst_list, f) # write out the burst list to a python pickle file with open(os.path.join('data',matrix_type+'_matrix'+('_no_buffer' if no_buffer else '')+'.pkl'), 'wb') as f: pickle.dump(distance_matrix, f)
the-stack_106_32328
# Copyright 2012 by Wibowo Arindrarto. All rights reserved. # This file is part of the Biopython distribution and governed by your # choice of the "Biopython License Agreement" or the "BSD 3-Clause License". # Please see the LICENSE file that should have been included as part of this # package. """Biopython interface for sequence search program outputs. The SearchIO submodule provides parsers, indexers, and writers for outputs from various sequence search programs. It provides an API similar to SeqIO and AlignIO, with the following main functions: ``parse``, ``read``, ``to_dict``, ``index``, ``index_db``, ``write``, and ``convert``. SearchIO parses a search output file's contents into a hierarchy of four nested objects: QueryResult, Hit, HSP, and HSPFragment. Each of them models a part of the search output file: - QueryResult represents a search query. This is the main object returned by the input functions and it contains all other objects. - Hit represents a database hit, - HSP represents high-scoring alignment region(s) in the hit, - HSPFragment represents a contiguous alignment within the HSP In addition to the four objects above, SearchIO is also tightly integrated with the SeqRecord objects (see SeqIO) and MultipleSeqAlignment objects (see AlignIO). SeqRecord objects are used to store the actual matching hit and query sequences, while MultipleSeqAlignment objects stores the alignment between them. A detailed description of these objects' features and their example usages are available in their respective documentations. Input ===== The main function for parsing search output files is Bio.SearchIO.parse(...). This function parses a given search output file and returns a generator object that yields one QueryResult object per iteration. ``parse`` takes two arguments: 1) a file handle or a filename of the input file (the search output file) and 2) the format name. >>> from Bio import SearchIO >>> for qresult in SearchIO.parse('Blast/mirna.xml', 'blast-xml'): ... print("%s %s" % (qresult.id, qresult.description)) ... 33211 mir_1 33212 mir_2 33213 mir_3 SearchIO also provides the Bio.SearchIO.read(...) function, which is intended for use on search output files containing only one query. ``read`` returns one QueryResult object and will raise an exception if the source file contains more than one queries: >>> qresult = SearchIO.read('Blast/xml_2226_blastp_004.xml', 'blast-xml') >>> print("%s %s" % (qresult.id, qresult.description)) ... gi|11464971:4-101 pleckstrin [Mus musculus] >>> SearchIO.read('Blast/mirna.xml', 'blast-xml') Traceback (most recent call last): ... ValueError: ... For accessing search results of large output files, you may use the indexing functions Bio.SearchIO.index(...) or Bio.SearchIO.index_db(...). They have a similar interface to their counterparts in SeqIO and AlignIO, with the addition of optional, format-specific keyword arguments. Output ====== SearchIO has writing support for several formats, accessible from the Bio.SearchIO.write(...) function. This function returns a tuple of four numbers: the number of QueryResult, Hit, HSP, and HSPFragment written:: qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml') SearchIO.write(qresults, 'results.tab', 'blast-tab') <stdout> (3, 239, 277, 277) Note that different writers may require different attribute values of the SearchIO objects. This limits the scope of writable search results to search results possessing the required attributes. For example, the writer for HMMER domain table output requires the conditional e-value attribute from each HSP object, among others. If you try to write to the HMMER domain table format and your HSPs do not have this attribute, an exception will be raised. Conversion ========== SearchIO provides a shortcut function Bio.SearchIO.convert(...) to convert a given file into another format. Under the hood, ``convert`` simply parses a given output file and writes it to another using the ``parse`` and ``write`` functions. Note that the same restrictions found in Bio.SearchIO.write(...) applies to the convert function as well. Conventions =========== The main goal of creating SearchIO is to have a common, easy to use interface across different search output files. As such, we have also created some conventions / standards for SearchIO that extend beyond the common object model. These conventions apply to all files parsed by SearchIO, regardless of their individual formats. Python-style sequence coordinates --------------------------------- When storing sequence coordinates (start and end values), SearchIO uses the Python-style slice convention: zero-based and half-open intervals. For example, if in a BLAST XML output file the start and end coordinates of an HSP are 10 and 28, they would become 9 and 28 in SearchIO. The start coordinate becomes 9 because Python indices start from zero, while the end coordinate remains 28 as Python slices omit the last item in an interval. Beside giving you the benefits of standardization, this convention also makes the coordinates usable for slicing sequences. For example, given a full query sequence and the start and end coordinates of an HSP, one can use the coordinates to extract part of the query sequence that results in the database hit. When these objects are written to an output file using SearchIO.write(...), the coordinate values are restored to their respective format's convention. Using the example above, if the HSP would be written to an XML file, the start and end coordinates would become 10 and 28 again. Sequence coordinate order ------------------------- Some search output format reverses the start and end coordinate sequences according to the sequence's strand. For example, in BLAST plain text format if the matching strand lies in the minus orientation, then the start coordinate will always be bigger than the end coordinate. In SearchIO, start coordinates are always smaller than the end coordinates, regardless of their originating strand. This ensures consistency when using the coordinates to slice full sequences. Note that this coordinate order convention is only enforced in the HSPFragment level. If an HSP object has several HSPFragment objects, each individual fragment will conform to this convention. But the order of the fragments within the HSP object follows what the search output file uses. Similar to the coordinate style convention, the start and end coordinates' order are restored to their respective formats when the objects are written using Bio.SearchIO.write(...). Frames and strand values ------------------------ SearchIO only allows -1, 0, 1 and None as strand values. For frames, the only allowed values are integers from -3 to 3 (inclusive) and None. Both of these are standard Biopython conventions. Supported Formats ================= Below is a list of search program output formats supported by SearchIO. Support for parsing, indexing, and writing: - blast-tab - BLAST+ tabular output. Both variants without comments (-m 6 flag) and with comments (-m 7 flag) are supported. - blast-xml - BLAST+ XML output. - blat-psl - The default output of BLAT (PSL format). Variants with or without header are both supported. PSLX (PSL + sequences) is also supported. - hmmer3-tab - HMMER3 table output. - hmmer3-domtab - HMMER3 domain table output. When using this format, the program name has to be specified. For example, for parsing hmmscan output, the name would be 'hmmscan-domtab'. Support for parsing and indexing: - exonerate-text - Exonerate plain text output. - exonerate-vulgar - Exonerate vulgar line. - exonerate-cigar - Exonerate cigar line. - fasta-m10 - Bill Pearson's FASTA -m 10 output. - hmmer3-text - HMMER3 regular text output format. Supported HMMER3 subprograms are hmmscan, hmmsearch, and phmmer. - hmmer2-text - HMMER2 regular text output format. Supported HMMER2 subprograms are hmmpfam, hmmsearch. Support for parsing: - blast-text - BLAST+ plain text output. - hhsuite2-text - HHSUITE plain text output. Each of these formats have different keyword arguments available for use with the main SearchIO functions. More details and examples are available in each of the format's documentation. """ import sys from Bio.File import as_handle from Bio.SearchIO._model import QueryResult, Hit, HSP, HSPFragment from Bio.SearchIO._utils import get_processor __all__ = ("read", "parse", "to_dict", "index", "index_db", "write", "convert") # dictionary of supported formats for parse() and read() _ITERATOR_MAP = { "blast-tab": ("BlastIO", "BlastTabParser"), "blast-text": ("BlastIO", "BlastTextParser"), "blast-xml": ("BlastIO", "BlastXmlParser"), "blat-psl": ("BlatIO", "BlatPslParser"), "exonerate-cigar": ("ExonerateIO", "ExonerateCigarParser"), "exonerate-text": ("ExonerateIO", "ExonerateTextParser"), "exonerate-vulgar": ("ExonerateIO", "ExonerateVulgarParser"), "fasta-m10": ("FastaIO", "FastaM10Parser"), "hhsuite2-text": ("HHsuiteIO", "Hhsuite2TextParser"), "hhsuite3-text": ("HHsuiteIO", "Hhsuite2TextParser"), "hmmer2-text": ("HmmerIO", "Hmmer2TextParser"), "hmmer3-text": ("HmmerIO", "Hmmer3TextParser"), "hmmer3-tab": ("HmmerIO", "Hmmer3TabParser"), # for hmmer3-domtab, the specific program is part of the format name # as we need it distinguish hit / target coordinates "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitParser"), "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryParser"), "interproscan-xml": ("InterproscanIO", "InterproscanXmlParser"), "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryParser"), } # dictionary of supported formats for index() _INDEXER_MAP = { "blast-tab": ("BlastIO", "BlastTabIndexer"), "blast-xml": ("BlastIO", "BlastXmlIndexer"), "blat-psl": ("BlatIO", "BlatPslIndexer"), "exonerate-cigar": ("ExonerateIO", "ExonerateCigarIndexer"), "exonerate-text": ("ExonerateIO", "ExonerateTextIndexer"), "exonerate-vulgar": ("ExonerateIO", "ExonerateVulgarIndexer"), "fasta-m10": ("FastaIO", "FastaM10Indexer"), "hmmer2-text": ("HmmerIO", "Hmmer2TextIndexer"), "hmmer3-text": ("HmmerIO", "Hmmer3TextIndexer"), "hmmer3-tab": ("HmmerIO", "Hmmer3TabIndexer"), "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitIndexer"), "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryIndexer"), "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryIndexer"), } # dictionary of supported formats for write() _WRITER_MAP = { "blast-tab": ("BlastIO", "BlastTabWriter"), "blast-xml": ("BlastIO", "BlastXmlWriter"), "blat-psl": ("BlatIO", "BlatPslWriter"), "hmmer3-tab": ("HmmerIO", "Hmmer3TabWriter"), "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitWriter"), "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryWriter"), "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryWriter"), } def parse(handle, format=None, **kwargs): """Iterate over search tool output file as QueryResult objects. Arguments: - handle - Handle to the file, or the filename as a string. - format - Lower case string denoting one of the supported formats. - kwargs - Format-specific keyword arguments. This function is used to iterate over each query in a given search output file: >>> from Bio import SearchIO >>> qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml') >>> qresults <generator object ...> >>> for qresult in qresults: ... print("Search %s has %i hits" % (qresult.id, len(qresult))) ... Search 33211 has 100 hits Search 33212 has 44 hits Search 33213 has 95 hits Depending on the file format, ``parse`` may also accept additional keyword argument(s) that modifies the behavior of the format parser. Here is a simple example, where the keyword argument enables parsing of a commented BLAST tabular output file: >>> from Bio import SearchIO >>> for qresult in SearchIO.parse('Blast/mirna.tab', 'blast-tab', comments=True): ... print("Search %s has %i hits" % (qresult.id, len(qresult))) ... Search 33211 has 100 hits Search 33212 has 44 hits Search 33213 has 95 hits """ # get the iterator object and do error checking iterator = get_processor(format, _ITERATOR_MAP) # HACK: force BLAST XML decoding to use utf-8 handle_kwargs = {} if format == "blast-xml": handle_kwargs["encoding"] = "utf-8" # and start iterating with as_handle(handle, "rU", **handle_kwargs) as source_file: generator = iterator(source_file, **kwargs) yield from generator def read(handle, format=None, **kwargs): """Turn a search output file containing one query into a single QueryResult. - handle - Handle to the file, or the filename as a string. - format - Lower case string denoting one of the supported formats. - kwargs - Format-specific keyword arguments. ``read`` is used for parsing search output files containing exactly one query: >>> from Bio import SearchIO >>> qresult = SearchIO.read('Blast/xml_2226_blastp_004.xml', 'blast-xml') >>> print("%s %s" % (qresult.id, qresult.description)) ... gi|11464971:4-101 pleckstrin [Mus musculus] If the given handle has no results, an exception will be raised: >>> from Bio import SearchIO >>> qresult = SearchIO.read('Blast/tab_2226_tblastn_002.txt', 'blast-tab') Traceback (most recent call last): ... ValueError: No query results found in handle Similarly, if the given handle has more than one results, an exception will also be raised: >>> from Bio import SearchIO >>> qresult = SearchIO.read('Blast/tab_2226_tblastn_001.txt', 'blast-tab') Traceback (most recent call last): ... ValueError: More than one query results found in handle Like ``parse``, ``read`` may also accept keyword argument(s) depending on the search output file format. """ generator = parse(handle, format, **kwargs) try: first = next(generator) except StopIteration: raise ValueError("No query results found in handle") else: try: second = next(generator) except StopIteration: second = None if second is not None: raise ValueError("More than one query results found in handle") return first def to_dict(qresults, key_function=None): """Turn a QueryResult iterator or list into a dictionary. - qresults - Iterable returning QueryResult objects. - key_function - Optional callback function which when given a QueryResult object should return a unique key for the dictionary. Defaults to using .id of the result. This function enables access of QueryResult objects from a single search output file using its identifier. >>> from Bio import SearchIO >>> qresults = SearchIO.parse('Blast/wnts.xml', 'blast-xml') >>> search_dict = SearchIO.to_dict(qresults) >>> list(search_dict) ['gi|195230749:301-1383', 'gi|325053704:108-1166', ..., 'gi|53729353:216-1313'] >>> search_dict['gi|156630997:105-1160'] QueryResult(id='gi|156630997:105-1160', 5 hits) By default, the dictionary key is the QueryResult's string ID. This may be changed by supplying a callback function that returns the desired identifier. Here is an example using a function that removes the 'gi|' part in the beginning of the QueryResult ID. >>> from Bio import SearchIO >>> qresults = SearchIO.parse('Blast/wnts.xml', 'blast-xml') >>> key_func = lambda qresult: qresult.id.split('|')[1] >>> search_dict = SearchIO.to_dict(qresults, key_func) >>> list(search_dict) ['195230749:301-1383', '325053704:108-1166', ..., '53729353:216-1313'] >>> search_dict['156630997:105-1160'] QueryResult(id='gi|156630997:105-1160', 5 hits) Note that the callback function does not change the QueryResult's ID value. It only changes the key value used to retrieve the associated QueryResult. As this function loads all QueryResult objects into memory, it may be unsuitable for dealing with files containing many queries. In that case, it is recommended that you use either ``index`` or ``index_db``. Since Python 3.7, the default dict class maintains key order, meaning this dictionary will reflect the order of records given to it. For CPython and PyPy, this was already implemented for Python 3.6, so effectively you can always assume the record order is preserved. """ # This comment stops black style adding a blank line here, which causes flake8 D202. def _default_key_function(rec): return rec.id if key_function is None: key_function = _default_key_function qdict = {} for qresult in qresults: key = key_function(qresult) if key in qdict: raise ValueError("Duplicate key %r" % key) qdict[key] = qresult return qdict def index(filename, format=None, key_function=None, **kwargs): """Indexes a search output file and returns a dictionary-like object. - filename - string giving name of file to be indexed - format - Lower case string denoting one of the supported formats. - key_function - Optional callback function which when given a QueryResult should return a unique key for the dictionary. - kwargs - Format-specific keyword arguments. Index returns a pseudo-dictionary object with QueryResult objects as its values and a string identifier as its keys. The function is mainly useful for dealing with large search output files, as it enables access to any given QueryResult object much faster than using parse or read. Index works by storing in-memory the start locations of all queries in a file. When a user requested access to the query, this function will jump to its start position, parse the whole query, and return it as a QueryResult object: >>> from Bio import SearchIO >>> search_idx = SearchIO.index('Blast/wnts.xml', 'blast-xml') >>> search_idx SearchIO.index('Blast/wnts.xml', 'blast-xml', key_function=None) >>> sorted(search_idx) ['gi|156630997:105-1160', 'gi|195230749:301-1383', ..., 'gi|53729353:216-1313'] >>> search_idx['gi|195230749:301-1383'] QueryResult(id='gi|195230749:301-1383', 5 hits) >>> search_idx.close() If the file is BGZF compressed, this is detected automatically. Ordinary GZIP files are not supported: >>> from Bio import SearchIO >>> search_idx = SearchIO.index('Blast/wnts.xml.bgz', 'blast-xml') >>> search_idx SearchIO.index('Blast/wnts.xml.bgz', 'blast-xml', key_function=None) >>> search_idx['gi|195230749:301-1383'] QueryResult(id='gi|195230749:301-1383', 5 hits) >>> search_idx.close() You can supply a custom callback function to alter the default identifier string. This function should accept as its input the QueryResult ID string and return a modified version of it. >>> from Bio import SearchIO >>> key_func = lambda id: id.split('|')[1] >>> search_idx = SearchIO.index('Blast/wnts.xml', 'blast-xml', key_func) >>> search_idx SearchIO.index('Blast/wnts.xml', 'blast-xml', key_function=<function <lambda> at ...>) >>> sorted(search_idx) ['156630997:105-1160', ..., '371502086:108-1205', '53729353:216-1313'] >>> search_idx['156630997:105-1160'] QueryResult(id='gi|156630997:105-1160', 5 hits) >>> search_idx.close() Note that the callback function does not change the QueryResult's ID value. It only changes the key value used to retrieve the associated QueryResult. """ if not isinstance(filename, str): raise TypeError("Need a filename (not a handle)") from Bio.File import _IndexedSeqFileDict proxy_class = get_processor(format, _INDEXER_MAP) repr = "SearchIO.index(%r, %r, key_function=%r)" % (filename, format, key_function) return _IndexedSeqFileDict( proxy_class(filename, **kwargs), key_function, repr, "QueryResult" ) def index_db(index_filename, filenames=None, format=None, key_function=None, **kwargs): """Indexes several search output files into an SQLite database. - index_filename - The SQLite filename. - filenames - List of strings specifying file(s) to be indexed, or when indexing a single file this can be given as a string. (optional if reloading an existing index, but must match) - format - Lower case string denoting one of the supported formats. (optional if reloading an existing index, but must match) - key_function - Optional callback function which when given a QueryResult identifier string should return a unique key for the dictionary. - kwargs - Format-specific keyword arguments. The ``index_db`` function is similar to ``index`` in that it indexes the start position of all queries from search output files. The main difference is instead of storing these indices in-memory, they are written to disk as an SQLite database file. This allows the indices to persist between Python sessions. This enables access to any queries in the file without any indexing overhead, provided it has been indexed at least once. >>> from Bio import SearchIO >>> idx_filename = ":memory:" # Use a real filename, this is in RAM only! >>> db_idx = SearchIO.index_db(idx_filename, 'Blast/mirna.xml', 'blast-xml') >>> sorted(db_idx) ['33211', '33212', '33213'] >>> db_idx['33212'] QueryResult(id='33212', 44 hits) >>> db_idx.close() ``index_db`` can also index multiple files and store them in the same database, making it easier to group multiple search files and access them from a single interface. >>> from Bio import SearchIO >>> idx_filename = ":memory:" # Use a real filename, this is in RAM only! >>> files = ['Blast/mirna.xml', 'Blast/wnts.xml'] >>> db_idx = SearchIO.index_db(idx_filename, files, 'blast-xml') >>> sorted(db_idx) ['33211', '33212', '33213', 'gi|156630997:105-1160', ..., 'gi|53729353:216-1313'] >>> db_idx['33212'] QueryResult(id='33212', 44 hits) >>> db_idx.close() One common example where this is helpful is if you had a large set of query sequences (say ten thousand) which you split into ten query files of one thousand sequences each in order to run as ten separate BLAST jobs on a cluster. You could use ``index_db`` to index the ten BLAST output files together for seamless access to all the results as one dictionary. Note that ':memory:' rather than an index filename tells SQLite to hold the index database in memory. This is useful for quick tests, but using the Bio.SearchIO.index(...) function instead would use less memory. BGZF compressed files are supported, and detected automatically. Ordinary GZIP compressed files are not supported. See also Bio.SearchIO.index(), Bio.SearchIO.to_dict(), and the Python module glob which is useful for building lists of files. """ # cast filenames to list if it's a string # (can we check if it's a string or a generator?) if isinstance(filenames, str): filenames = [filenames] from Bio.File import _SQLiteManySeqFilesDict repr = "SearchIO.index_db(%r, filenames=%r, format=%r, key_function=%r, ...)" % ( index_filename, filenames, format, key_function, ) def proxy_factory(format, filename=None): """Given a filename returns proxy object, else boolean if format OK.""" if filename: return get_processor(format, _INDEXER_MAP)(filename, **kwargs) else: return format in _INDEXER_MAP return _SQLiteManySeqFilesDict( index_filename, filenames, proxy_factory, format, key_function, repr ) def write(qresults, handle, format=None, **kwargs): """Write QueryResult objects to a file in the given format. - qresults - An iterator returning QueryResult objects or a single QueryResult object. - handle - Handle to the file, or the filename as a string. - format - Lower case string denoting one of the supported formats. - kwargs - Format-specific keyword arguments. The ``write`` function writes QueryResult object(s) into the given output handle / filename. You can supply it with a single QueryResult object or an iterable returning one or more QueryResult objects. In both cases, the function will return a tuple of four values: the number of QueryResult, Hit, HSP, and HSPFragment objects it writes to the output file:: from Bio import SearchIO qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml') SearchIO.write(qresults, 'results.tab', 'blast-tab') <stdout> (3, 239, 277, 277) The output of different formats may be adjusted using the format-specific keyword arguments. Here is an example that writes BLAT PSL output file with a header:: from Bio import SearchIO qresults = SearchIO.parse('Blat/psl_34_001.psl', 'blat-psl') SearchIO.write(qresults, 'results.tab', 'blat-psl', header=True) <stdout> (2, 13, 22, 26) """ # turn qresults into an iterator if it's a single QueryResult object if isinstance(qresults, QueryResult): qresults = iter([qresults]) else: qresults = iter(qresults) # get the writer object and do error checking writer_class = get_processor(format, _WRITER_MAP) # write to the handle with as_handle(handle, "w") as target_file: writer = writer_class(target_file, **kwargs) # count how many qresults, hits, and hsps qresult_count, hit_count, hsp_count, frag_count = writer.write_file(qresults) return qresult_count, hit_count, hsp_count, frag_count def convert(in_file, in_format, out_file, out_format, in_kwargs=None, out_kwargs=None): """Convert between two search output formats, return number of records. - in_file - Handle to the input file, or the filename as string. - in_format - Lower case string denoting the format of the input file. - out_file - Handle to the output file, or the filename as string. - out_format - Lower case string denoting the format of the output file. - in_kwargs - Dictionary of keyword arguments for the input function. - out_kwargs - Dictionary of keyword arguments for the output function. The convert function is a shortcut function for ``parse`` and ``write``. It has the same return type as ``write``. Format-specific arguments may be passed to the convert function, but only as dictionaries. Here is an example of using ``convert`` to convert from a BLAST+ XML file into a tabular file with comments:: from Bio import SearchIO in_file = 'Blast/mirna.xml' in_fmt = 'blast-xml' out_file = 'results.tab' out_fmt = 'blast-tab' out_kwarg = {'comments': True} SearchIO.convert(in_file, in_fmt, out_file, out_fmt, out_kwargs=out_kwarg) <stdout> (3, 239, 277, 277) Given that different search output file provide different statistics and different level of details, the convert function is limited only to converting formats that have the same statistics and for conversion to formats with the same level of detail, or less. For example, converting from a BLAST+ XML output to a HMMER table file is not possible, as these are two search programs with different kinds of statistics. In theory, you may provide the necessary values required by the HMMER table file (e.g. conditional e-values, envelope coordinates, etc). However, these values are likely to hold little meaning as they are not true HMMER-computed values. Another example is converting from BLAST+ XML to BLAST+ tabular file. This is possible, as BLAST+ XML provide all the values necessary to create a BLAST+ tabular file. However, the reverse conversion may not be possible. There are more details covered in the XML file that are not found in a tabular file (e.g. the lambda and kappa values) """ if in_kwargs is None: in_kwargs = {} if out_kwargs is None: out_kwargs = {} qresults = parse(in_file, in_format, **in_kwargs) return write(qresults, out_file, out_format, **out_kwargs) # if not used as a module, run the doctest if __name__ == "__main__": from Bio._utils import run_doctest run_doctest()
the-stack_106_32329
import pygame as pg from settings import * class Player(pg.sprite.Sprite): def __init__(self, game, x, y): self.groups = game.all_sprites pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = pg.Surface((TILESIZE, TILESIZE)) self.image.fill(YELLOW) self.rect = self.image.get_rect() self.x = x self.y = y def move(self, dx=0, dy=0): if self.collide_with_walls(dx, dy)==False: self.x += dx self.y += dy def collide_with_walls(self, dx=0, dy=0): for wall in self.game.walls: if wall.x == self.x + dx and wall.y == self.y + dy: return True return False def update(self): self.rect.x = self.x * TILESIZE self.rect.y = self.y * TILESIZE class Wall(pg.sprite.Sprite): def __init__(self, game, x, y): self.groups = game.all_sprites, game.walls pg.sprite.Sprite.__init__(self, self.groups) self.game = game self.image = pg.Surface((TILESIZE, TILESIZE)) self.image.fill(GREEN) self.rect = self.image.get_rect() self.x = x self.y = y self.rect.x = x * TILESIZE self.rect.y = y * TILESIZE
the-stack_106_32331
from typing import Tuple, FrozenSet from collections import Iterable from mathsat import msat_term, msat_env from mathsat import msat_make_constant, msat_declare_function from mathsat import msat_get_integer_type, msat_get_rational_type, msat_get_bool_type from mathsat import msat_make_and, msat_make_not, msat_make_or from mathsat import msat_make_leq, msat_make_equal from mathsat import msat_make_number, msat_make_plus from pysmt.environment import Environment as PysmtEnv import pysmt.typing as types from ltl.ltl import TermMap, LTLEncoder from utils import name_next, symb_to_next from hint import Hint, Location def msat_make_lt(menv: msat_env, arg0: msat_term, arg1: msat_term): geq = msat_make_geq(menv, arg0, arg1) return msat_make_not(menv, geq) def msat_make_geq(menv: msat_env, arg0: msat_term, arg1: msat_term): return msat_make_leq(menv, arg1, arg0) def msat_make_gt(menv: msat_env, arg0: msat_term, arg1: msat_term): leq = msat_make_leq(menv, arg0, arg1) return msat_make_not(menv, leq) def msat_make_impl(menv: msat_env, arg0: msat_term, arg1: msat_term): n_arg0 = msat_make_not(menv, arg0) return msat_make_or(menv, n_arg0, arg1) def check_ltl(menv: msat_env, enc: LTLEncoder) -> Tuple[Iterable, msat_term, msat_term, msat_term]: assert menv assert isinstance(menv, msat_env) assert enc assert isinstance(enc, LTLEncoder) bool_type = msat_get_bool_type(menv) real_type = msat_get_rational_type(menv) i = msat_declare_function(menv, "i", real_type) i = msat_make_constant(menv, i) r = msat_declare_function(menv, "r", real_type) r = msat_make_constant(menv, r) l = msat_declare_function(menv, "l", real_type) l = msat_make_constant(menv, l) inc_i = msat_declare_function(menv, "inc_i", bool_type) inc_i = msat_make_constant(menv, inc_i) x_i = msat_declare_function(menv, name_next("i"), real_type) x_i = msat_make_constant(menv, x_i) x_r = msat_declare_function(menv, name_next("r"), real_type) x_r = msat_make_constant(menv, x_r) x_l = msat_declare_function(menv, name_next("l"), real_type) x_l = msat_make_constant(menv, x_l) x_inc_i = msat_declare_function(menv, name_next("inc_i"), bool_type) x_inc_i = msat_make_constant(menv, x_inc_i) curr2next = {i: x_i, r: x_r, l: x_l, inc_i: x_inc_i} zero = msat_make_number(menv, "0") one = msat_make_number(menv, "1") r_gt_0 = msat_make_gt(menv, r, zero) r_lt_l = msat_make_lt(menv, r, l) i_geq_0 = msat_make_geq(menv, i, zero) init = msat_make_and(menv, r_gt_0, r_lt_l) init = msat_make_and(menv, init, msat_make_and(menv, i_geq_0, msat_make_not(menv, inc_i))) init = msat_make_and(menv, init, msat_make_gt(menv, l, zero)) # r' = r trans = msat_make_equal(menv, x_r, r) # i < l -> ((inc_i' & i' = i + 1) | (!inc_i' & i' = i)) & l' = l i_lt_l = msat_make_lt(menv, i, l) x_i_eq_i_p_1 = msat_make_and(menv, x_inc_i, msat_make_equal(menv, x_i, msat_make_plus(menv, i, one))) x_i_eq_i = msat_make_and(menv, msat_make_not(menv, x_inc_i), msat_make_equal(menv, x_i, i)) x_i_eq_i_p_1_or_i = msat_make_or(menv, x_i_eq_i_p_1, x_i_eq_i) x_l_eq_l = msat_make_equal(menv, x_l, l) x_i_eq_i_p_1_or_i_and_x_l_eq_l = msat_make_and(menv, x_i_eq_i_p_1_or_i, x_l_eq_l) trans = msat_make_and(menv, trans, msat_make_impl(menv, i_lt_l, x_i_eq_i_p_1_or_i_and_x_l_eq_l)) # i >= l -> i' = 0 & l' = l + 1 & !inc_i' i_geq_l = msat_make_geq(menv, i, l) x_i_eq_0 = msat_make_equal(menv, x_i, zero) x_l_eq_l_p_1 = msat_make_equal(menv, x_l, msat_make_plus(menv, l, one)) x_i_eq_0_and_x_l_eq_l_p_1 = msat_make_and(menv, msat_make_and(menv, x_i_eq_0, x_l_eq_l_p_1), msat_make_not(menv, x_inc_i)) trans = msat_make_and(menv, trans, msat_make_impl(menv, i_geq_l, x_i_eq_0_and_x_l_eq_l_p_1)) # (G F inc_i) -> ! G F r > i G_F_x_i_gt_i = enc.make_G(enc.make_F(inc_i)) r_gt_i = msat_make_gt(menv, r, i) n_G_F_r_gt_i = msat_make_not(menv, enc.make_G(enc.make_F(r_gt_i))) ltl = msat_make_impl(menv, G_F_x_i_gt_i, n_G_F_r_gt_i) return TermMap(curr2next), init, trans, ltl def hints(env: PysmtEnv) -> FrozenSet[Hint]: assert isinstance(env, PysmtEnv) mgr = env.formula_manager i = mgr.Symbol("i", types.REAL) r = mgr.Symbol("r", types.REAL) l = mgr.Symbol("l", types.REAL) inc_i = mgr.Symbol("inc_i", types.BOOL) symbs = frozenset([i, r, l, inc_i]) x_i = symb_to_next(mgr, i) x_r = symb_to_next(mgr, r) x_l = symb_to_next(mgr, l) x_inc_i = symb_to_next(mgr, inc_i) res = [] n0 = mgr.Real(0) n1 = mgr.Real(1) stutter = mgr.Equals(x_i, i) loc = Location(env, mgr.GE(i, n0), stutterT=stutter) loc.set_progress(0, mgr.Equals(x_i, mgr.Plus(i, n1))) h_i = Hint("h_i0", env, frozenset([i]), symbs) h_i.set_locs([loc]) res.append(h_i) loc = Location(env, mgr.GE(r, n0)) loc.set_progress(0, mgr.Equals(x_r, mgr.Plus(r, n1))) h_r = Hint("h_r0", env, frozenset([r]), symbs) h_r.set_locs([loc]) res.append(h_r) loc = Location(env, mgr.GE(l, n0)) loc.set_progress(0, mgr.Equals(x_l, mgr.Plus(l, n1))) h_l = Hint("h_l0", env, frozenset([l]), symbs) h_l.set_locs([loc]) res.append(h_l) loc = Location(env, inc_i) loc.set_progress(0, x_inc_i) h_inc = Hint("h_inc0", env, frozenset([inc_i]), symbs) h_inc.set_locs([loc]) res.append(h_inc) stutter = mgr.Equals(x_i, i) loc = Location(env, mgr.LE(i, n0), stutterT=stutter) loc.set_progress(0, mgr.Equals(x_i, mgr.Minus(i, n1))) h_i = Hint("h_i1", env, frozenset([i]), symbs) h_i.set_locs([loc]) res.append(h_i) loc = Location(env, mgr.LE(r, n0)) loc.set_progress(0, mgr.Equals(x_r, mgr.Minus(r, n1))) h_r = Hint("h_r1", env, frozenset([r]), symbs) h_r.set_locs([loc]) res.append(h_r) loc = Location(env, mgr.LE(l, n0)) loc.set_progress(0, mgr.Equals(x_l, mgr.Minus(l, n1))) h_l = Hint("h_l1", env, frozenset([l]), symbs) h_l.set_locs([loc]) res.append(h_l) loc0 = Location(env, mgr.GE(i, n0)) loc0.set_progress(1, mgr.Equals(x_i, mgr.Plus(i, n1))) loc1 = Location(env, mgr.GE(i, n0)) loc1.set_progress(0, mgr.Equals(x_i, i)) h_i = Hint("h_i2", env, frozenset([i]), symbs) h_i.set_locs([loc0, loc1]) res.append(h_i) loc0 = Location(env, mgr.Not(inc_i)) loc0.set_progress(1, x_inc_i) loc1 = Location(env, inc_i) loc1.set_progress(0, mgr.Not(x_inc_i)) h_inc = Hint("h_inc2", env, frozenset([inc_i]), symbs) h_inc.set_locs([loc0, loc1]) res.append(h_inc) loc0 = Location(env, mgr.GE(i, n0), mgr.GE(l, n0), stutterT=mgr.Equals(x_i, mgr.Plus(i, l))) loc0.set_progress(1, mgr.Equals(x_i, mgr.Plus(i, n1))) loc1 = Location(env, mgr.GE(i, n0)) loc1.set_progress(0, mgr.Equals(x_i, i)) h_i = Hint("h_i3", env, frozenset([i]), symbs) h_i.set_locs([loc0, loc1]) res.append(h_i) loc0 = Location(env, mgr.GE(r, n0), mgr.GE(i, n0), stutterT=mgr.Equals(x_r, mgr.Plus(r, i))) loc0.set_progress(1, mgr.Equals(x_r, r)) loc1 = Location(env, mgr.GE(r, n0)) loc1.set_progress(0, mgr.Equals(x_r, mgr.Plus(r, n1))) h_r = Hint("h_r3", env, frozenset([r]), symbs) h_r.set_locs([loc0, loc1]) res.append(h_r) loc0 = Location(env, mgr.GE(l, n0), mgr.GE(r, n0), stutterT=mgr.Equals(x_l, mgr.Plus(l, r))) loc0.set_progress(1, mgr.Equals(x_l, mgr.Plus(l, n1))) loc1 = Location(env, mgr.GE(l, n0)) loc1.set_progress(0, mgr.Equals(x_l, l)) h_l = Hint("h_l3", env, frozenset([l]), symbs) h_l.set_locs([loc0, loc1]) res.append(h_l) loc0 = Location(env, mgr.GE(i, n0)) loc0.set_progress(1, mgr.Equals(x_i, mgr.Plus(i, n1))) loc1 = Location(env, mgr.GE(i, n0)) loc1.set_progress(2, mgr.Equals(x_i, i)) loc2 = Location(env, mgr.GE(i, n0)) loc2.set_progress(0, mgr.Equals(x_i, i)) h_i = Hint("h_i4", env, frozenset([i]), symbs) h_i.set_locs([loc0, loc1, loc2]) res.append(h_i) loc0 = Location(env, mgr.GE(r, n0)) loc0.set_progress(1, mgr.Equals(x_r, r)) loc1 = Location(env, mgr.GE(r, n0)) loc1.set_progress(2, mgr.Equals(x_r, mgr.Plus(r, n1))) loc2 = Location(env, mgr.GE(r, n0)) loc2.set_progress(0, mgr.Equals(x_r, r)) h_r = Hint("h_r4", env, frozenset([r]), symbs) h_r.set_locs([loc0, loc1, loc2]) res.append(h_r) loc0 = Location(env, mgr.Not(inc_i)) loc0.set_progress(1, x_inc_i) loc1 = Location(env, inc_i, stutterT=x_inc_i) loc1.set_progress(2, mgr.Not(x_inc_i)) loc2 = Location(env, mgr.Not(inc_i)) loc2.set_progress(0, mgr.Not(x_inc_i)) h_inc = Hint("h_inc4", env, frozenset([inc_i]), symbs) h_inc.set_locs([loc0, loc1, loc2]) res.append(h_inc) return frozenset(res)
the-stack_106_32334
""" TencentBlueKing is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaSCommunity Edition) available. Copyright (C) 2017-2018 THL A29 Limited, a Tencent company. All rights reserved. Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://opensource.org/licenses/MIT Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ("module_intent", "0002_auto_20201009_1142"), ] operations = [ migrations.AlterField( model_name="intent", name="status", field=models.BooleanField(default=True, verbose_name="意图状态"), ), ]
the-stack_106_32335
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Copyright (c) 2020 by Inria Authoried by Xiaoyu BIE ([email protected]) License agreement in LICENSE.txt """ import datetime import scipy.io as sio import os import sys import argparse from matplotlib import ticker from tqdm import tqdm import torch import numpy as np import librosa import soundfile as sf import matplotlib.pyplot as plt from dvae.learning_algo import LearningAlgorithm from dvae.learning_algo_ss import LearningAlgorithm_ss from dvae.utils.eval_metric import compute_median, EvalMetrics from dvae.utils.random_seeders import set_random_seeds set_random_seeds(666) class Options: def __init__(self): self.parser = argparse.ArgumentParser() self.opt = None def _initial(self): # Basic config file self.parser.add_argument('--ss', action='store_true', help='schedule sampling') self.parser.add_argument('--cfg', type=str, default=None, help='config path') self.parser.add_argument('--saved_dict', type=str, default=None, help='trained model dict') self.parser.add_argument('--date', type=str, default=None, help='date and time when save training') # Dataset self.parser.add_argument('--test_dir', type=str, default='./data/clean_speech/wsj0_si_et_05', help='test dataset') # Restuls directory self.parser.add_argument('--ret_dir', type=str, default='./data/tmp', help='tmp dir for audio reconstruction') def get_params(self): self._initial() self.opt = self.parser.parse_args() params = vars(self.opt) return params params = Options().get_params() if params['ss']: learning_algo = LearningAlgorithm_ss(params=params) else: learning_algo = LearningAlgorithm(params=params) learning_algo.build_model() dvae = learning_algo.model dvae.load_state_dict(torch.load(params['saved_dict'], map_location='cpu')) eval_metrics = EvalMetrics(metric='all') dvae.eval() cfg = learning_algo.cfg print('Total params: %.2fM' % (sum(p.numel() for p in dvae.parameters()) / 1000000.0)) # Load configs data_path = cfg.get('User', 'data_path') sequence_len = cfg.getint('DataFrame', 'sequence_len') dataset_name = cfg.get('DataFrame', 'dataset_name') saved_root = cfg.get('User', 'saved_root') if saved_root == "./saved_model": saved_root = "./eval_model" z_dim = cfg.getint('Network','z_dim') tag = cfg.get('Network', 'tag') date = '2022-03-' + params["date"] filename = "{}_{}_{}_z_dim={}".format(dataset_name, date, tag, z_dim) save_dir = os.path.join(saved_root, filename) + '/' rat_data = sio.loadmat(data_path) ## load trial information idx_split = rat_data["trial"][0] ## load spike data spike_by_neuron_use = rat_data["spikes"] ## load locations locations_vec = rat_data["loc"][0] u = np.array( np.array_split( np.hstack((locations_vec.reshape(-1, 1), np.zeros((locations_vec.shape[0], 2)))), idx_split[1:-1], axis=0 ) ) x_all = np.array(np.array_split(spike_by_neuron_use, idx_split[1:-1], axis=0)) trial_ls = [len(x) for x in x_all] num_trial = len(x_all) for ii in range(len(u)): u[ii][:, int(ii % 2) + 1] = 1 # add zero samples by sequence length, will be remove when plotting max_seq_len = np.max([len(trial) for trial in x_all]) # 351 min_seq_len = np.min([len(trial) for trial in x_all]) # 70 temp = torch.zeros((len(x_all), sequence_len, x_all[0].shape[1])) for i, x in enumerate(x_all): sample = torch.FloatTensor(x) if sequence_len <= len(sample): sample = sample[:sequence_len] elif sequence_len > len(sample): s_len, x_dim = sample.shape zeros = torch.zeros(sequence_len - s_len, x_dim) sample = torch.cat([sample, zeros], 0) # if sequence_len <= min_seq_len: # sample = sample[:sequence_len] # elif sequence_len >= max_seq_len: # s_len, x_dim = sample.shape # zeros = torch.zeros(sequence_len - s_len, x_dim) # sample = torch.cat([sample, zeros], 0) # assert sample.shape[0] == max_seq_len temp[i] = sample x_all = temp x_all = x_all.permute(1, 0, 2) with torch.no_grad(): outputs = dvae.inference(x_all) _, z_mean, _ = outputs z_mean = z_mean.permute(1, 0, 2).reshape(-1, 2).numpy() def get_tc_rd(y, hd, hd_bins): # compute empirical tunning curve of data tuning_curve = np.zeros((len(hd_bins) - 1, y.shape[1])) for ii in range(len(hd_bins) - 1): data_pos = (hd >= hd_bins[ii]) * (hd <= hd_bins[ii + 1]) tuning_curve[ii, :] = y[data_pos, :].mean(axis=0) return tuning_curve ## posterior mean # We need the direction information for hue # and the location information for shade # So we restore u_all, which should only be used # for these two purposes from now. temp = [] ind = 0 for ii in range(num_trial): length = min(trial_ls[ii], sequence_len) z_m = z_mean[ind:ind+length] temp.append(z_m) ind = ind + sequence_len z_mean = np.concatenate(temp) locations_vec = rat_data['loc'][0] u_all = np.array( np.array_split(np.hstack((locations_vec.reshape(-1, 1), np.zeros((locations_vec.shape[0], 2)))), idx_split[1:-1], axis=0)) temp = [] for u in u_all: temp.append(u[:sequence_len]) u_all = temp for ii in range(len(u_all)): u_all[ii][:, int(ii % 2) + 1] = 1; ll = 11 hd_bins = np.linspace(0, 1.6, ll) select = np.concatenate(u_all)[:, 1] == 1 print(z_mean.shape) # print(u_all.shape) tc1 = get_tc_rd(z_mean[select], np.concatenate(u_all)[select, 0], hd_bins) # plt.plot(np.concatenate(u_all)[select, 0], color='r') select = np.concatenate(u_all)[:, 2] == 1 tc2 = get_tc_rd(z_mean[select], np.concatenate(u_all)[select, 0], hd_bins) # plt.plot(np.concatenate(u_all)[select, 0], color='b') dis_mat = np.zeros((len(tc1), len(tc2))) for jj in range(len(tc1)): dis_mat[jj] = np.sqrt(np.square(tc1[jj] - tc2).sum(axis=-1)) ll = 5000 fig = plt.figure(figsize=(5.5, 4)) ax = plt.subplot(111) # fig.add_subplot(111, projection='3d') fsz = 14 ## learn locations select = np.concatenate(u_all)[:ll, 1] == 1 im = ax.scatter( z_mean[:ll][select][:, 0], z_mean[:ll][select][:, 1], s=1, c=np.concatenate(u_all)[:ll][select, 0], cmap="Reds", vmin=0, vmax=1.6, ) ax.plot(tc1[:, 0], tc1[:, 1], c="black") cbar = plt.colorbar(im) cbar.ax.tick_params(labelsize=14) tick_locator = ticker.MaxNLocator(nbins=5) cbar.locator = tick_locator cbar.update_ticks() ## learn locations select = np.concatenate(u_all)[:ll][:, 1] == 0 im = ax.scatter( z_mean[:ll][select][:, 0], z_mean[:ll][select][:, 1], s=1, c=np.concatenate(u_all)[:ll][select, 0], cmap="Blues", vmin=0, vmax=1.6, ) ax.plot(tc2[:, 0], tc2[:, 1], c="black") cbar = plt.colorbar(im) cbar.ax.tick_params(labelsize=14) tick_locator = ticker.MaxNLocator(nbins=5) cbar.locator = tick_locator cbar.update_ticks() ax.set_xlabel("Latent 1", fontsize=fsz) ax.set_ylabel("Latent 2", fontsize=fsz) ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) plt.setp(ax.get_xticklabels(), fontsize=fsz) plt.setp(ax.get_yticklabels(), fontsize=fsz) ax.xaxis.set_major_locator(ticker.MaxNLocator(nbins=4, min_n_ticks=4, prune=None)) ax.yaxis.set_major_locator(ticker.MaxNLocator(nbins=4, min_n_ticks=4, prune=None)) plt.savefig(save_dir + "z") plt.show()
the-stack_106_32336
""" Given two words A and B, find the minimum number of steps required to convert A to B. (each operation is counted as 1 step.) You have the following 3 operations permitted on a word: Insert a character Delete a character Replace a character Example : edit distance between "Anshuman" and "Antihuman" is 2. Operation 1: Replace s with t. Operation 2: Insert i. """ class Solution: # @param A : string # @param B : string # @return an integer def minDistance(self, A, B): n = len(A) m = len(B) dp = [[0 for x in xrange(m + 1)] for x in xrange(n + 1)] for i in xrange(n + 1): for j in xrange(m + 1): if i == 0: dp[i][j] = j elif j == 0: dp[i][j] = i elif A[i - 1] == B[j - 1]: dp[i][j] = dp[i - 1][j - 1] else: dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1 return dp[n][m]
the-stack_106_32337
import io import asyncio import discord import random import asyncio import random import datetime import config import discord from utils.embed import Embed import traceback from discord import errors from discord.ext import commands from discord.ext import commands class general(commands.Cog): def __init__(self, bot): self.bot = bot @commands.Cog.listener() async def on_guild_join(self, guild): if guild.owner.id == 898755879766204416: return await guild.leave() await self.bot.change_presence(status=discord.Status.online, activity=discord.Activity(name="짱구야 도움 | 서버: {}".format(len(self.bot.guilds)), type=discord.ActivityType.playing)) if guild.id in [653083797763522580, 786470326732587008, 608711879858192479]: return em = discord.Embed( title="초대해줘서 고마워요!", description=""" 짱구봇을 초대주셔서 감사드립니다. 짱구봇은 편한시스템을 가지고 있는 짱구입니다. 도움말은 `짱구야 도움`, 프리픽스는 `짱구야 `,`짱구야`,`ㄱ `,`ㄱ` 입니다. """ ) em.set_thumbnail(url=self.bot.user.avatar_url) em.set_image( url="https://cdn.discordapp.com/attachments/915556934977998879/917754253701951499/c265877614d80026.png") try: await guild.owner.send(embed=em) except errors.HTTPException: # errors.Forbidden when does not have permission # except error as error mean except (error, error) <- does not working in python 3.10 ch = self.bot.get_channel((random.choice(guild.channels)).id) await ch.send(embed=em) em = discord.Embed( description=f"{guild.name}({guild.id})에 접속함\n서버수 : {len(self.bot.guilds)}" ) em.timestamp = datetime.datetime.utcnow() await self.bot.get_channel(915551578730164234).send(embed=em) @commands.Cog.listener() async def on_guild_remove(self, guild): await self.bot.change_presence(status=discord.Status.online, activity=discord.Activity(name="짱구야 도움 | 서버: {}".format(len(self.bot.guilds)), type=discord.ActivityType.playing)) em = discord.Embed( description=f"{guild.name}({guild.id})에서 나감\n서버수 : {len(self.bot.guilds)}" ) em.timestamp = datetime.datetime.utcnow() await self.bot.get_channel(915551578730164234).send(embed=em) @commands.Cog.listener() async def on_message_edit(self, before, after): embed=discord.Embed(title="메시지수정로그", color=0x00FFFF) embed.set_footer(text=f"멤버 이름 :{before.author.name} • Message ID: {before.id}") embed.timestamp = datetime.datetime.utcnow() embed.add_field(name='수정전:', value=before.content , inline=False) embed.add_field(name="수정후:", value=after.content , inline=False) embed.set_thumbnail(url="https://cdn.discordapp.com/icons/915551354800451616/f27061c35e3f1dc203b3564cd864e99a.webp?size=96") channel = self.bot.get_channel(915555627332435988) await channel.send(embed=embed) @commands.Cog.listener() async def on_message_delete(self, message): embed = discord.Embed(title="메시지 삭제로그", color= 0x0000ff) embed.add_field(name="**메시지삭제**", value=f"메시지 : {message.content} \n \n 삭제됨") embed.set_thumbnail(url="https://cdn.discordapp.com/icons/915551354800451616/f27061c35e3f1dc203b3564cd864e99a.webp?size=96") embed.timestamp = datetime.datetime.utcnow() embed.colour = (0x000ff) dele = self.bot.get_channel(915555627332435988) await dele.send(embed=embed) #에러로그 @commands.Cog.listener() async def on_command(self, ctx): self.logger.info(f"{ctx.author}({ctx.author.id}) - {ctx.message.content}") await self.bot.get_channel(int(config.BotSettings.logging_channel)).send(f"{ctx.author}({ctx.author.id}) - `{ctx.message.content}`") await self.bot.get_channel(int(config.BotSettings.stafflog)).send(f"{ctx.author}({ctx.author.id}) - `{ctx.message.content}`") #일반로그 @commands.Cog.listener() async def on_command(self, ctx): channel = self.bot.get_channel(915555649990053918) embed = discord.Embed( title ="일반로그", description= f"닉네임 : {ctx.author} \n \n 아이디 : {ctx.author.id} \n \n 명령어로그 : {ctx.message.content}", color= 0x0000ff ).set_thumbnail(url="https://cdn.discordapp.com/icons/915551354800451616/f27061c35e3f1dc203b3564cd864e99a.webp?size=96") embed.timestamp = datetime.datetime.utcnow() embed.add_field(name="서버", value=f"{ctx.guild.name} 에서 사용됨") await channel.send(embed=embed) @commands.Cog.listener() async def on_command_error(self, ctx, error): ignoredError = ( commands.CommandNotFound, commands.errors.CheckFailure, commands.CheckFailure, ) if isinstance(error, ignoredError): return elif isinstance(error, commands.CommandOnCooldown): cooldown = int(error.retry_after) hours = cooldown // 3600 minutes = (cooldown % 3600) // 60 seconds = cooldown % 60 time = [] if not hours == 0: time.append(f"{hours}시간") if not minutes == 0: time.append(f"{minutes}분") if not seconds == 0: time.append(f"{seconds}초") embed = Embed.warn( timestamp=ctx.message.created_at, description=f"사용하신 명령어는 ``{' '.join(time)}`` 뒤에 사용하실 수 있습니다.", ) Embed.user_footer(embed, ctx) return await ctx.send(embed=embed, hidden=True) elif isinstance(error, commands.MissingPermissions): a = "" for p in error.missing_perms: if str(p) == "manage_messages": p = "메시지 관리" elif str(p) == "kick_members": p = "멤버 추방" elif str(p) == "ban_members": p = "멤버 차단" elif str(p) == "administrator": p = "관리자" elif str(p) == "create_instant_invite": p = "초대링크 생성" elif str(p) == "manage_channels": p = "채널 관리" elif str(p) == "manage_guild": p = "서버 관리" elif str(p) == "add_reactions": p = "메시지 반응 추가" elif str(p) == "view_audit_log": p = "감사 로그 보기" elif str(p) == "read_messages": p = "메시지 읽기" elif str(p) == "send_messages": p = "메시지 보내기" elif str(p) == "read_message_history": p = "이전 메시지 읽기" elif str(p) == "mute_members": p = "멤버 음소거 시키기" elif str(p) == "move_members": p = "멤버 채널 이동시키기" elif str(p) == "change_nickname": p = "자기자신의 닉네임 변경하기" elif str(p) == "manage_nicknames": p = "다른유저의 닉네임 변경하기" elif str(p) == "manage_roles": p = "역활 관리하기" elif str(p) == "manage_webhooks": p = "웹훅크 관리하기" elif str(p) == "manage_emojis": p = "이모지 관리하기" elif str(p) == "use_slash_commands": p = "/ 명령어 사용" if p != error.missing_perms[len(error.missing_perms) - 1]: a += f"{p}, " else: a += f"{p}" embed = Embed.warn( timestamp=ctx.message.created_at, description=f"당신의 권한이 부족합니다.\n\n> 필요 권한 : {str(a)}", ) Embed.user_footer(embed, ctx) return await ctx.send( embed=embed, hidden=True, ) elif isinstance(error, commands.BotMissingPermissions): a = "" for p in error.missing_perms: if str(p) == "manage_messages": p = "메시지 관리" elif str(p) == "kick_members": p = "멤버 추방" elif str(p) == "ban_members": p = "멤버 차단" elif str(p) == "administrator": p = "관리자" elif str(p) == "create_instant_invite": p = "초대링크 생성" elif str(p) == "manage_channels": p = "채널 관리" elif str(p) == "manage_guild": p = "서버 관리" elif str(p) == "add_reactions": p = "메시지 반응 추가" elif str(p) == "view_audit_log": p = "감사 로그 보기" elif str(p) == "read_messages": p = "메시지 읽기" elif str(p) == "send_messages": p = "메시지 보내기" elif str(p) == "read_message_history": p = "이전 메시지 읽기" elif str(p) == "mute_members": p = "멤버 음소거 시키기" elif str(p) == "move_members": p = "멤버 채널 이동시키기" elif str(p) == "change_nickname": p = "자기자신의 닉네임 변경하기" elif str(p) == "manage_nicknames": p = "다른유저의 닉네임 변경하기" elif str(p) == "manage_roles": p = "역활 관리하기" elif str(p) == "manage_webhooks": p = "웹훅크 관리하기" elif str(p) == "manage_emojis": p = "이모지 관리하기" elif str(p) == "use_slash_commands": p = "/ 명령어 사용" if p != error.missing_perms[len(error.missing_perms) - 1]: a += f"{p}, " else: a += f"{p}" embed = Embed.warn( timestamp=ctx.message.created_at, description=f"봇의 권한이 부족합니다.\n\n> 필요 권한 : {str(a)}", ) Embed.user_footer(embed, ctx) return await ctx.send( embed=embed, ) elif isinstance(error, commands.MissingRequiredArgument): embed = Embed.warn( timestamp=ctx.message.created_at, description="필요한 값이 존재하지 않습니다." ) Embed.user_footer(embed, ctx) return await ctx.send( embed=embed, hidden=True, ) elif isinstance(error, commands.MemberNotFound): embed = Embed.warn(timestamp=ctx.message.created_at, description="존재하지 않는 멤버입니다.") Embed.user_footer(embed, ctx) return await ctx.send( embed=embed, hidden=True, ) else: tb = traceback.format_exception(type(error), error, error.__traceback__) err = [line.rstrip() for line in tb] errstr = "\n".join(err) # f = open(f"logs/{code}.log", "a", encoding="utf-8") # f.write(f"{ctx.author}({ctx.author.id}) -{ctx.message.content}\n에러 발생 일시: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") # f.write("\n\n") # f.write(errstr) # f.close() embed = Embed.error( timestamp=ctx.message.created_at, description=f"```py\n{errstr}\n```" ) Embed.user_footer(embed, ctx) print(errstr) return await ctx.send( embed=embed, ) def setup(bot): bot.add_cog(general(bot))
the-stack_106_32338
# coding: utf-8 from __future__ import unicode_literals from .common import InfoExtractor from ..compat import compat_urlparse from ..utils import ( fix_xml_ampersands, float_or_none, xpath_with_ns, xpath_text, ) class KarriereVideosIE(InfoExtractor): _VALID_URL = r'https?://(?:www\.)?karrierevideos\.at(?:/[^/]+)+/(?P<id>[^/]+)' _TESTS = [{ 'url': 'http://www.karrierevideos.at/berufsvideos/mittlere-hoehere-schulen/altenpflegerin', 'info_dict': { 'id': '32c91', 'ext': 'flv', 'title': 'AltenpflegerIn', 'description': 'md5:dbadd1259fde2159a9b28667cb664ae2', 'thumbnail': r're:^http://.*\.png', }, 'params': { # rtmp download 'skip_download': True, } }, { # broken ampersands 'url': 'http://www.karrierevideos.at/orientierung/vaeterkarenz-und-neue-chancen-fuer-muetter-baby-was-nun', 'info_dict': { 'id': '5sniu', 'ext': 'flv', 'title': 'Väterkarenz und neue Chancen für Mütter - "Baby - was nun?"', 'description': 'md5:97092c6ad1fd7d38e9d6a5fdeb2bcc33', 'thumbnail': r're:^http://.*\.png', }, 'params': { # rtmp download 'skip_download': True, } }] def _real_extract(self, url): video_id = self._match_id(url) webpage = self._download_webpage(url, video_id) title = (self._html_search_meta('title', webpage, default=None) or self._search_regex(r'<h1 class="title">([^<]+)</h1>', webpage, 'video title')) video_id = self._search_regex( r'/config/video/(.+?)\.xml', webpage, 'video id') # Server returns malformed headers # Force Accept-Encoding: * to prevent gzipped results playlist = self._download_xml( 'http://www.karrierevideos.at/player-playlist.xml.php?p=%s' % video_id, video_id, transform_source=fix_xml_ampersands, headers={'Accept-Encoding': '*'}) NS_MAP = { 'jwplayer': 'http://developer.longtailvideo.com/trac/wiki/FlashFormats' } def ns(path): return xpath_with_ns(path, NS_MAP) item = playlist.find('./tracklist/item') video_file = xpath_text( item, ns('./jwplayer:file'), 'video url', fatal=True) streamer = xpath_text( item, ns('./jwplayer:streamer'), 'streamer', fatal=True) uploader = xpath_text( item, ns('./jwplayer:author'), 'uploader') duration = float_or_none( xpath_text(item, ns('./jwplayer:duration'), 'duration')) description = self._html_search_regex( r'(?s)<div class="leadtext">(.+?)</div>', webpage, 'description') thumbnail = self._html_search_meta( 'thumbnail', webpage, 'thumbnail') if thumbnail: thumbnail = compat_urlparse.urljoin(url, thumbnail) return { 'id': video_id, 'url': streamer.replace('rtmpt', 'rtmp'), 'play_path': 'mp4:%s' % video_file, 'ext': 'flv', 'title': title, 'description': description, 'thumbnail': thumbnail, 'uploader': uploader, 'duration': duration, }
the-stack_106_32339
# coding: utf-8 # ---------------------------------------------------------------- # <copyright company="Aspose" file="CreateFolderRequest.py"> # Copyright (c) 2018-2019 Aspose Pty Ltd. All rights reserved. # </copyright> # <summary> # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # </summary> # ----------------------------------------------------------------- from asposecadcloud.models.requests.cad_request import CadRequest from asposecadcloud.models.requests.http_request import HttpRequest class CreateFolderRequest(CadRequest): """ Request model for create_folder operation. Initializes a new instance. :param path Folder path to create e.g. 'folder_1/folder_2/' :param storage_name Storage name """ def __init__(self, path, storage_name=None): CadRequest.__init__(self) self.path = path self.storage_name = storage_name def to_http_info(self, config): """ Prepares initial info for HTTP request :param config: CAD API configuration :type: asposecadcloud.Configuration :return: http_request configured http request :rtype: Configuration.models.requests.HttpRequest """ # verify the required parameter 'path' is set if self.path is None: raise ValueError("Missing the required parameter `path` when calling `create_folder`") collection_formats = {} path = '/cad/storage/folder/{path}' path_params = {} if self.path is not None: path_params[self._lowercase_first_letter('path')] = self.path query_params = [] if self._lowercase_first_letter('storageName') in path: path = path.replace('{' + self._lowercase_first_letter('storageName' + '}'), self.storage_name if self.storage_name is not None else '') else: if self.storage_name is not None: query_params.append((self._lowercase_first_letter('storageName'), self.storage_name)) header_params = {} form_params = [] local_var_files = [] body_params = None # HTTP header `Accept` header_params['Accept'] = self._select_header_accept( ['application/json']) # HTTP header `Content-Type` header_params['Content-Type'] = 'multipart/form-data' if form_params or local_var_files else self._select_header_content_type( ['application/json']) # Authentication setting auth_settings = ['JWT'] return HttpRequest(path, path_params, query_params, header_params, form_params, body_params, local_var_files, collection_formats, auth_settings)
the-stack_106_32341
from .base_atari_env import BaseAtariEnv, base_env_wrapper_fn, parallel_wrapper_fn import os def raw_env(**kwargs): mode = 33 num_players = 4 return BaseAtariEnv(game="pong", num_players=num_players, mode_num=mode, env_name=os.path.basename(__file__)[:-3], **kwargs) env = base_env_wrapper_fn(raw_env) parallel_env = parallel_wrapper_fn(env)
the-stack_106_32342
""" Utility functions to sync and work with Open Humans data in a local filesystem. """ import csv import hashlib import logging import os import re import arrow from humanfriendly import format_size, parse_size import requests MAX_FILE_DEFAULT = parse_size('128m') def strip_zip_suffix(filename): if filename.endswith('.gz'): return filename[:-3] elif filename.endswith('.bz2'): return filename[:-4] else: return filename def guess_tags(filename): tags = [] stripped_filename = strip_zip_suffix(filename) if stripped_filename.endswith('.vcf'): tags.append('vcf') if stripped_filename.endswith('.json'): tags.append('json') if stripped_filename.endswith('.csv'): tags.append('csv') return tags def characterize_local_files(filedir, max_bytes=MAX_FILE_DEFAULT): """ Collate local file info as preperation for Open Humans upload. Note: Files with filesize > max_bytes are not included in returned info. """ file_data = {} logging.info('Characterizing files in {}'.format(filedir)) for filename in os.listdir(filedir): filepath = os.path.join(filedir, filename) file_stats = os.stat(filepath) creation_date = arrow.get(file_stats.st_ctime).isoformat() file_size = file_stats.st_size if file_size <= max_bytes: file_md5 = hashlib.md5() with open(filepath, "rb") as f: for chunk in iter(lambda: f.read(4096), b""): file_md5.update(chunk) md5 = file_md5.hexdigest() file_data[filename] = { 'tags': guess_tags(filename), 'description': '', 'md5': md5, 'creation_date': creation_date, } return file_data def validate_metadata(target_dir, metadata): """ Check that the files listed in metadata exactly match files in target dir. """ file_list = os.listdir(target_dir) for filename in file_list: if filename not in metadata: return False for filename in metadata: if filename not in file_list: return False return True def load_metadata_csv_single_user(csv_in, header, tags_idx): """ Return the metadata as requested for a single user. """ metadata = {} for row in csv_in: if row[0] == 'None' and [x == 'NA' for x in row[1:]]: break metadata[row[0]] = { header[i]: row[i] for i in range(1, len(header)) if i != tags_idx } metadata[row[0]]['tags'] = [t.strip() for t in row[tags_idx].split(',') if t.strip()] return metadata def load_metadata_csv_multi_user(csv_in, header, tags_idx): """ Return the metadata as requested for a single user. """ metadata = {} for row in csv_in: if row[0] not in metadata: metadata[row[0]] = {} if row[1] == 'None' and all([x == 'NA' for x in row[2:]]): continue metadata[row[0]][row[1]] = { header[i]: row[i] for i in range(2, len(header)) if i != tags_idx } metadata[row[0]][row[1]]['tags'] = [t.strip() for t in row[tags_idx].split(',') if t.strip()] return metadata def load_metadata_csv(input_filepath): """ Return dict of metadata. Format is either dict (filenames are keys) or dict-of-dicts (project member IDs as top level keys, then filenames as keys). """ with open(input_filepath) as f: csv_in = csv.reader(f) header = next(csv_in) try: tags_idx = header.index('tags') except ValueError: tags_idx = None if header[0] == 'project_member_id': metadata = load_metadata_csv_multi_user(csv_in, header, tags_idx) elif header[0] == 'filename': metadata = load_metadata_csv_single_user(csv_in, header, tags_idx) return metadata def mk_metadata_csv(filedir, outputfilepath, max_bytes=MAX_FILE_DEFAULT): with open(outputfilepath, 'w') as outputfile: csv_out = csv.writer(outputfile) subdirs = [os.path.join(filedir, i) for i in os.listdir(filedir) if os.path.isdir(os.path.join(filedir, i))] if subdirs: logging.info('Making metadata for subdirs of {}'.format(filedir)) if not all([re.match('^[0-9]{8}$', os.path.basename(d)) for d in subdirs]): raise ValueError("Subdirs not all project member ID format!") csv_out.writerow(['project_member_id', 'filename', 'tags', 'description', 'md5', 'creation_date']) for subdir in subdirs: file_info = characterize_local_files( filedir=subdir, max_bytes=max_bytes) proj_member_id = os.path.basename(subdir) if not file_info: csv_out.writerow([proj_member_id, 'None', 'NA', 'NA', 'NA', 'NA']) continue for filename in file_info: csv_out.writerow([proj_member_id, filename, ', '.join(file_info[filename]['tags']), file_info[filename]['description'], file_info[filename]['md5'], file_info[filename]['creation_date'], ]) else: csv_out.writerow(['filename', 'tags', 'description', 'md5', 'creation_date']) file_info = characterize_local_files( filedir=filedir, max_bytes=max_bytes) for filename in file_info: csv_out.writerow([filename, ', '.join(file_info[filename]['tags']), file_info[filename]['description'], file_info[filename]['md5'], file_info[filename]['creation_date'], ]) def download_file(download_url, target_filepath, max_bytes=MAX_FILE_DEFAULT): """ Download a file. """ response = requests.get(download_url, stream=True) size = int(response.headers['Content-Length']) if size > max_bytes: logging.info('Skipping {}, {} > {}'.format( target_filepath, format_size(size), format_size(max_bytes))) return logging.info('Downloading {} ({})'.format( target_filepath, format_size(size))) if os.path.exists(target_filepath): stat = os.stat(target_filepath) if stat.st_size == size: logging.info('Skipping, file exists and is the right ' 'size: {}'.format(target_filepath)) return else: logging.info('Replacing, file exists and is the wrong ' 'size: {}'.format(target_filepath)) os.remove(target_filepath) with open(target_filepath, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): if chunk: f.write(chunk) logging.info('Download complete: {}'.format(target_filepath)) def read_id_list(filepath): if not filepath: return None id_list = [] with open(filepath) as f: for line in f: line = line.rstrip() if not re.match('^[0-9]{8}$', line): raise('Each line in whitelist or blacklist is expected ' 'to contain an eight digit ID, and nothing else.') else: id_list.append(line) return id_list
the-stack_106_32344
# ------------------------------------------------------------------------------ # Copyright (c) Microsoft # Licensed under the MIT License. # The code is based on HigherHRNet-Human-Pose-Estimation. # (https://github.com/HRNet/HigherHRNet-Human-Pose-Estimation) # Modified by Zigang Geng ([email protected]). # ------------------------------------------------------------------------------ from __future__ import absolute_import from __future__ import division from __future__ import print_function import os from yacs.config import CfgNode as CN _C = CN() _C.OUTPUT_DIR = '' _C.NAME = 'regression' _C.LOG_DIR = '' _C.DATA_DIR = '' _C.GPUS = (0,) _C.WORKERS = 4 _C.PRINT_FREQ = 20 _C.AUTO_RESUME = False _C.PIN_MEMORY = True _C.RANK = 0 _C.VERBOSE = True _C.DIST_BACKEND = 'nccl' _C.MULTIPROCESSING_DISTRIBUTED = True # Cudnn related params _C.CUDNN = CN() _C.CUDNN.BENCHMARK = True #This flag allows you to enable the inbuilt cudnn auto-tuner to find the best algorithm to use for your hardware. _C.CUDNN.DETERMINISTIC = False _C.CUDNN.ENABLED = True # common params for NETWORK _C.MODEL = CN() _C.MODEL.NAME = 'hrnet_dekr' _C.MODEL.INIT_WEIGHTS = True _C.MODEL.PRETRAINED = '' _C.MODEL.NUM_JOINTS = 17 _C.MODEL.SPEC = CN(new_allowed=True) _C.LOSS = CN() _C.LOSS.WITH_HEATMAPS_LOSS = True _C.LOSS.HEATMAPS_LOSS_FACTOR = 1.0 _C.LOSS.WITH_OFFSETS_LOSS = True _C.LOSS.OFFSETS_LOSS_FACTOR = 1.0 # DATASET related params _C.DATASET = CN() _C.DATASET.ROOT = '' _C.DATASET.DATASET = 'coco_kpt' _C.DATASET.DATASET_TEST = '' _C.DATASET.NUM_JOINTS = 17 _C.DATASET.MAX_NUM_PEOPLE = 30 _C.DATASET.TRAIN = 'train2017' _C.DATASET.TEST = 'val2017' _C.DATASET.DATA_FORMAT = 'jpg' # training data augmentation _C.DATASET.MAX_ROTATION = 30 _C.DATASET.MIN_SCALE = 0.75 _C.DATASET.MAX_SCALE = 1.25 _C.DATASET.SCALE_TYPE = 'short' _C.DATASET.MAX_TRANSLATE = 40 _C.DATASET.INPUT_SIZE = 512 _C.DATASET.OUTPUT_SIZE = 128 _C.DATASET.FLIP = 0.5 # heatmap generator _C.DATASET.SIGMA = 2.0 _C.DATASET.CENTER_SIGMA = 4.0 _C.DATASET.BG_WEIGHT = 0.1 # offset generator _C.DATASET.OFFSET_RADIUS = 4 # train _C.TRAIN = CN() _C.TRAIN.LR_FACTOR = 0.1 _C.TRAIN.LR_STEP = [90, 110] _C.TRAIN.LR = 0.001 _C.TRAIN.OPTIMIZER = 'adam' _C.TRAIN.MOMENTUM = 0.9 _C.TRAIN.WD = 0.0001 _C.TRAIN.NESTEROV = False _C.TRAIN.GAMMA1 = 0.99 _C.TRAIN.GAMMA2 = 0.0 _C.TRAIN.BEGIN_EPOCH = 0 _C.TRAIN.END_EPOCH = 140 _C.TRAIN.RESUME = False _C.TRAIN.CHECKPOINT = '' _C.TRAIN.IMAGES_PER_GPU = 32 _C.TRAIN.SHUFFLE = True # testing _C.TEST = CN() # size of images for each device _C.TEST.IMAGES_PER_GPU = 32 _C.TEST.FLIP_TEST = True _C.TEST.SCALE_FACTOR = [1] _C.TEST.MODEL_FILE = '' _C.TEST.POOL_THRESHOLD1 = 300 _C.TEST.POOL_THRESHOLD2 = 200 _C.TEST.NMS_THRE = 0.15 _C.TEST.NMS_NUM_THRE = 10 _C.TEST.KEYPOINT_THRESHOLD = 0.01 _C.TEST.DECREASE = 1.0 _C.TEST.MATCH_HMP = False _C.TEST.ADJUST_THRESHOLD = 0.05 _C.TEST.MAX_ABSORB_DISTANCE = 75 _C.TEST.GUASSIAN_KERNEL = 6 _C.TEST.LOG_PROGRESS = True _C.RESCORE = CN() _C.RESCORE.VALID = True _C.RESCORE.GET_DATA = False _C.RESCORE.END_EPOCH = 20 _C.RESCORE.LR = 0.001 _C.RESCORE.HIDDEN_LAYER = 256 _C.RESCORE.BATCHSIZE = 1024 _C.RESCORE.MODEL_FILE = 'model/rescore/final_rescore_coco_kpt.pth' _C.RESCORE.DATA_FILE = 'data/rescore_data/rescore_dataset_train_coco_kpt' def update_config(cfg, args): #Make this CfgNode and all of its children mutable. cfg.defrost() ## load values from a file and list cfg.merge_from_file(args.cfg) cfg.merge_from_list(args.opts) if not os.path.exists(cfg.DATASET.ROOT): cfg.DATASET.ROOT = os.path.join( cfg.DATA_DIR, cfg.DATASET.ROOT ) cfg.MODEL.PRETRAINED = os.path.join( cfg.DATA_DIR, cfg.MODEL.PRETRAINED ) if cfg.TEST.MODEL_FILE: cfg.TEST.MODEL_FILE = os.path.join( cfg.DATA_DIR, cfg.TEST.MODEL_FILE ) cfg.freeze() if __name__ == '__main__': import sys with open(sys.argv[1], 'w') as f: print(_C, file=f)
the-stack_106_32345
import enum import subprocess import os import tempfile try: from importlib.resources import path except ImportError: # use backport for python < 3.7 from importlib_resources import path __all__ = ["subroutinize", "OutputFormat", "Error"] class OutputFormat(enum.Enum): CFF = "cff" CFF2 = "cff2" try: from ._version import version as __version__ except ImportError: __version__ = "0.0.0+unknown" class Error(Exception): pass def _run_embedded_tx(*args, **kwargs): """Run the embedded tx executable with the list of positional arguments. Return a subprocess.CompletedProcess object with the following attributes: args, returncode, stdout, stderr. All keyword arguments are forwarded to subprocess.run function. """ with path(__name__, "tx") as tx_cli: return subprocess.run([tx_cli] + list(args), **kwargs) def subroutinize(fontdata: bytes, output_format=OutputFormat.CFF2) -> bytes: """Run subroutinizer on the input font data and return processed output.""" if not isinstance(fontdata, bytes): raise TypeError(f"expected bytes, found {type(fontdata).__name__}") output_format = OutputFormat(output_format) # We can't read from stdin because of this issue: # https://github.com/adobe-type-tools/afdko/issues/937 with tempfile.NamedTemporaryFile(prefix="tx-", delete=False) as tmp: tmp.write(fontdata) try: # write to stdout and capture output result = _run_embedded_tx( f"-{output_format.value}", "+S", "+b", tmp.name, capture_output=True, check=True, ) except subprocess.CalledProcessError as e: raise Error(e.stderr.decode()) finally: os.remove(tmp.name) return result.stdout
the-stack_106_32347
"""The data layer used during training to train a Fast R-CNN network. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import torch.utils.data as data from PIL import Image import torch from model.utils.config import cfg from roi_data_layer.minibatch import get_minibatch, get_minibatch from model.rpn.bbox_transform import bbox_transform_inv, clip_boxes import numpy as np import random import time import pdb class roibatchLoader(data.Dataset): def __init__(self, roidb, ratio_list, ratio_index, batch_size, num_classes, training=True, normalize=None): self._roidb = roidb self._num_classes = num_classes # we make the height of image consistent to trim_height, trim_width self.trim_height = cfg.TRAIN.TRIM_HEIGHT self.trim_width = cfg.TRAIN.TRIM_WIDTH self.max_num_box = cfg.MAX_NUM_GT_BOXES self.training = training self.normalize = normalize self.ratio_list = ratio_list self.ratio_index = ratio_index self.batch_size = batch_size self.data_size = len(self.ratio_list) # given the ratio_list, we want to make the ratio same for each batch. self.ratio_list_batch = torch.Tensor(self.data_size).zero_() num_batch = int(np.ceil(len(ratio_index) / batch_size)) for i in range(num_batch): left_idx = i*batch_size right_idx = min((i+1)*batch_size-1, self.data_size-1) if ratio_list[right_idx] < 1: # for ratio < 1, we preserve the leftmost in each batch. target_ratio = ratio_list[left_idx] elif ratio_list[left_idx] > 1: # for ratio > 1, we preserve the rightmost in each batch. target_ratio = ratio_list[right_idx] else: # for ratio cross 1, we make it to be 1. target_ratio = 1 # self.ratio_list_batch[left_idx:(right_idx+1)] = torch.tensor(target_ratio.astype(np.float64)) # trainset ratio list ,each batch is same number target_ratio = np.float64(target_ratio) self.ratio_list_batch[left_idx:(right_idx+1)] = torch.tensor(target_ratio.astype(np.float64)) def __getitem__(self, index): if self.training: index_ratio = int(self.ratio_index[index]) else: index_ratio = index # get the anchor index for current sample index # here we set the anchor index to the last one # sample in this group minibatch_db = [self._roidb[index_ratio]] blobs = get_minibatch(minibatch_db, self._num_classes) data = torch.from_numpy(blobs['data']) im_info = torch.from_numpy(blobs['im_info']) # we need to random shuffle the bounding box. data_height, data_width = data.size(1), data.size(2) if self.training: np.random.shuffle(blobs['gt_boxes']) gt_boxes = torch.from_numpy(blobs['gt_boxes']) ######################################################## # padding the input image to fixed size for each group # ######################################################## # NOTE1: need to cope with the case where a group cover both conditions. (done) # NOTE2: need to consider the situation for the tail samples. (no worry) # NOTE3: need to implement a parallel data loader. (no worry) # get the index range # if the image need to crop, crop to the target size. ratio = self.ratio_list_batch[index] if self._roidb[index_ratio]['need_crop']: if ratio < 1: # this means that data_width << data_height, we need to crop the # data_height min_y = int(torch.min(gt_boxes[:,1])) max_y = int(torch.max(gt_boxes[:,3])) trim_size = int(np.floor(data_width / ratio)) if trim_size > data_height: trim_size = data_height box_region = max_y - min_y + 1 if min_y == 0: y_s = 0 else: if (box_region-trim_size) < 0: y_s_min = max(max_y-trim_size, 0) y_s_max = min(min_y, data_height-trim_size) if y_s_min == y_s_max: y_s = y_s_min else: y_s = np.random.choice(range(y_s_min, y_s_max)) else: y_s_add = int((box_region-trim_size)/2) if y_s_add == 0: y_s = min_y else: y_s = np.random.choice(range(min_y, min_y+y_s_add)) # crop the image data = data[:, y_s:(y_s + trim_size), :, :] # shift y coordiante of gt_boxes gt_boxes[:, 1] = gt_boxes[:, 1] - float(y_s) gt_boxes[:, 3] = gt_boxes[:, 3] - float(y_s) # update gt bounding box according the trip gt_boxes[:, 1].clamp_(0, trim_size - 1) gt_boxes[:, 3].clamp_(0, trim_size - 1) else: # this means that data_width >> data_height, we need to crop the # data_width min_x = int(torch.min(gt_boxes[:,0])) max_x = int(torch.max(gt_boxes[:,2])) trim_size = int(np.ceil(data_height * ratio)) if trim_size > data_width: trim_size = data_width box_region = max_x - min_x + 1 if min_x == 0: x_s = 0 else: if (box_region-trim_size) < 0: x_s_min = max(max_x-trim_size, 0) x_s_max = min(min_x, data_width-trim_size) if x_s_min == x_s_max: x_s = x_s_min else: x_s = np.random.choice(range(x_s_min, x_s_max)) else: x_s_add = int((box_region-trim_size)/2) if x_s_add == 0: x_s = min_x else: x_s = np.random.choice(range(min_x, min_x+x_s_add)) # crop the image data = data[:, :, x_s:(x_s + trim_size), :] # shift x coordiante of gt_boxes gt_boxes[:, 0] = gt_boxes[:, 0] - float(x_s) gt_boxes[:, 2] = gt_boxes[:, 2] - float(x_s) # update gt bounding box according the trip gt_boxes[:, 0].clamp_(0, trim_size - 1) gt_boxes[:, 2].clamp_(0, trim_size - 1) # based on the ratio, padding the image. if ratio < 1: # this means that data_width < data_height trim_size = int(np.floor(data_width / ratio)) padding_data = torch.FloatTensor(int(np.ceil(data_width / ratio)), \ data_width, 3).zero_() padding_data[:data_height, :, :] = data[0] # update im_info im_info[0, 0] = padding_data.size(0) # print("height %d %d \n" %(index, anchor_idx)) elif ratio > 1: # this means that data_width > data_height # if the image need to crop. padding_data = torch.FloatTensor(data_height, \ int(np.ceil(data_height * ratio)), 3).zero_() padding_data[:, :data_width, :] = data[0] im_info[0, 1] = padding_data.size(1) else: trim_size = min(data_height, data_width) padding_data = torch.FloatTensor(trim_size, trim_size, 3).zero_() padding_data = data[0][:trim_size, :trim_size, :] # gt_boxes.clamp_(0, trim_size) gt_boxes[:, :4].clamp_(0, trim_size) im_info[0, 0] = trim_size im_info[0, 1] = trim_size # check the bounding box: not_keep = (gt_boxes[:,0] == gt_boxes[:,2]) | (gt_boxes[:,1] == gt_boxes[:,3]) keep = torch.nonzero(not_keep == 0).view(-1) gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() if keep.numel() != 0: gt_boxes = gt_boxes[keep] num_boxes = min(gt_boxes.size(0), self.max_num_box) gt_boxes_padding[:num_boxes,:] = gt_boxes[:num_boxes] else: num_boxes = 0 # permute trim_data to adapt to downstream processing padding_data = padding_data.permute(2, 0, 1).contiguous() im_info = im_info.view(3) return padding_data, im_info, gt_boxes_padding, num_boxes else: data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) im_info = im_info.view(3) gt_boxes = torch.FloatTensor([1,1,1,1,1]) num_boxes = 0 return data, im_info, gt_boxes, num_boxes def __len__(self): return len(self._roidb)
the-stack_106_32348
""" This strdiff computes differences in two strings from etutils.strdiff import strdiff A= strdiff(string1, string2, <optional>) INPUT: data: datamatrix rows = features colums = samples OPTIONAL OUTPUT output DESCRIPTION Compute differences in strings EXAMPLE from etutils.strdiff import strdiff string1 = 'MeGaaaaaa-image' string2 = 'megaimage' string1 = 'IGADKYFHARGNYDAA AWOOH' string2 = 'KGADKYFHARGNYEAA W' [out, outstring] = strdiff(string1, string2, methodtype='exact') print("%d differences\n\n%s" %(out, outstring)) string1 = 'MeGaaaaaa-image' string2 = 'megaimage' [out, _] = strdiff(string1, string2) string1 = 'MeGa-image' string2 = 'megaimage hyphypehoera' [out, _] = strdiff(string1, string2) [out, _] = strdiff(string2, string1) SEE ALSO stringmagnet """ #print(__doc__) #-------------------------------------------------------------------------- # Name : strdiff.py # Author : E.Taskesen # Contact : [email protected] # Date : Nov. 2017 #-------------------------------------------------------------------------- #%% Libraries import numpy as np import difflib #%% def strdiff(string1, string2, methodtype='', no_match_c=' ', match_c='|'): #%% DECLARATIONS # Make dictionary to store Parameters outdiff='' Param = {} Param['methodtype'] = methodtype Param['no_match_c'] = no_match_c Param['match_c'] = match_c #%% Lower string1=string1.lower() string2=string2.lower() #%% Similar characters overall if Param['methodtype']=='': out=np.sum(np.in1d(list(string1), list(string2))==False) #%% Compute number of changes if Param['methodtype']=='ratio': out=difflib.SequenceMatcher(None, string1, string2).ratio() #%% Exact matching if Param['methodtype']=='exact': if len(string2) < len(string1): string1, string2 = string2, string1 result = '' n_diff = 0 #% char search for c1, c2 in zip(string1, string2): if c1 == c2: result += Param['match_c'] else: result += Param['no_match_c'] n_diff += 1 delta = len(string2) - len(string1) result += delta * Param['no_match_c'] n_diff += delta out=n_diff #% Make nice word-difference outdiff = string1+'\n'+result+'\n'+string2 return(out,outdiff)
the-stack_106_32349
from typing import Any, Dict, Optional, Union import httpx from ...client import Client from ...models.conn_record import ConnRecord from ...types import UNSET, Response, Unset def _get_kwargs( conn_id: str, *, client: Client, mediation_id: Union[Unset, None, str] = UNSET, my_endpoint: Union[Unset, None, str] = UNSET, my_label: Union[Unset, None, str] = UNSET, ) -> Dict[str, Any]: url = "{}/connections/{conn_id}/accept-invitation".format(client.base_url, conn_id=conn_id) headers: Dict[str, Any] = client.get_headers() cookies: Dict[str, Any] = client.get_cookies() params: Dict[str, Any] = { "mediation_id": mediation_id, "my_endpoint": my_endpoint, "my_label": my_label, } params = {k: v for k, v in params.items() if v is not UNSET and v is not None} return { "url": url, "headers": headers, "cookies": cookies, "timeout": client.get_timeout(), "params": params, } def _parse_response(*, response: httpx.Response) -> Optional[ConnRecord]: if response.status_code == 200: response_200 = ConnRecord.from_dict(response.json()) return response_200 return None def _build_response(*, response: httpx.Response) -> Response[ConnRecord]: return Response( status_code=response.status_code, content=response.content, headers=response.headers, parsed=_parse_response(response=response), ) def sync_detailed( conn_id: str, *, client: Client, mediation_id: Union[Unset, None, str] = UNSET, my_endpoint: Union[Unset, None, str] = UNSET, my_label: Union[Unset, None, str] = UNSET, ) -> Response[ConnRecord]: kwargs = _get_kwargs( conn_id=conn_id, client=client, mediation_id=mediation_id, my_endpoint=my_endpoint, my_label=my_label, ) response = httpx.post( verify=client.verify_ssl, **kwargs, ) return _build_response(response=response) def sync( conn_id: str, *, client: Client, mediation_id: Union[Unset, None, str] = UNSET, my_endpoint: Union[Unset, None, str] = UNSET, my_label: Union[Unset, None, str] = UNSET, ) -> Optional[ConnRecord]: """ """ return sync_detailed( conn_id=conn_id, client=client, mediation_id=mediation_id, my_endpoint=my_endpoint, my_label=my_label, ).parsed async def asyncio_detailed( conn_id: str, *, client: Client, mediation_id: Union[Unset, None, str] = UNSET, my_endpoint: Union[Unset, None, str] = UNSET, my_label: Union[Unset, None, str] = UNSET, ) -> Response[ConnRecord]: kwargs = _get_kwargs( conn_id=conn_id, client=client, mediation_id=mediation_id, my_endpoint=my_endpoint, my_label=my_label, ) async with httpx.AsyncClient(verify=client.verify_ssl) as _client: response = await _client.post(**kwargs) return _build_response(response=response) async def asyncio( conn_id: str, *, client: Client, mediation_id: Union[Unset, None, str] = UNSET, my_endpoint: Union[Unset, None, str] = UNSET, my_label: Union[Unset, None, str] = UNSET, ) -> Optional[ConnRecord]: """ """ return ( await asyncio_detailed( conn_id=conn_id, client=client, mediation_id=mediation_id, my_endpoint=my_endpoint, my_label=my_label, ) ).parsed
the-stack_106_32350
#-*-coding: utf-8 -*- # regular expressions module import re as reg def find_int_in_str(string=None): """ trouver les nombres entiers dans une chaine de caractere en ignorant les signes :param string: str :reutrn: ['float', 'float', ...] """ response = [] if string: # si la chaine n'est pas vide response = reg.findall("([0.0-9.9]+)", string) # on cherche les floatants return [float(integer) for integer in response]
the-stack_106_32351
#!/usr/bin/env python # -*- coding: utf-8 -*- ### # Copyright (2016-2020) Hewlett Packard Enterprise Development LP # # Licensed under the Apache License, Version 2.0 (the "License"); # You may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ### from __future__ import (absolute_import, division, print_function) __metaclass__ = type import mock import pytest import yaml from ansible_collections.hpe.oneview.tests.unit.utils.hpe_test_utils import OneViewBaseTest from ansible_collections.hpe.oneview.tests.unit.utils.oneview_module_loader import StoragePoolModule FAKE_MSG_ERROR = 'Fake message error' YAML_STORAGE_POOL = """ config: "{{ config }}" state: present data: storageSystemUri: "/rest/storage-systems/TXQ1010307" poolName: "FST_CPG2" """ YAML_STORAGE_POOL_500 = """ config: "{{ config }}" state: present data: storageSystemUri: "/rest/storage-systems/TXQ1010307" name: "FST_CPG2" isManaged: True """ YAML_STORAGE_POOL_ABSENT_500 = """ config: "{{ config }}" state: absent data: storageSystemUri: "/rest/storage-systems/TXQ1010307" name: "FST_CPG2" """ YAML_STORAGE_POOL_MISSING_KEY = """ config: "{{ config }}" state: present data: storageSystemUri: "/rest/storage-systems/TXQ1010307" """ YAML_STORAGE_POOL_ABSENT = """ config: "{{ config }}" state: absent data: poolName: "FST_CPG2" """ DICT_DEFAULT_STORAGE_POOL = yaml.load(YAML_STORAGE_POOL)["data"] DICT_DEFAULT_STORAGE_POOL_500 = yaml.load(YAML_STORAGE_POOL_500)["data"] @pytest.mark.resource(TestStoragePoolModule='storage_pools') class TestStoragePoolModule(OneViewBaseTest): @pytest.fixture(autouse=True) def specific_set_up(self, setUp): self.mock_ov_client.api_version = 300 def test_should_create_new_storage_pool(self): self.resource.get_by_name.return_value = [] self.resource.data = {"poolName": "name"} self.resource.add.return_value = self.resource self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL) StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=True, msg=StoragePoolModule.MSG_CREATED, ansible_facts=dict(storage_pool={"poolName": "name"}) ) def test_should_do_nothing_when_storage_pool_already_exist(self): self.resource.data = DICT_DEFAULT_STORAGE_POOL self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL) StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=False, msg=StoragePoolModule.MSG_ALREADY_PRESENT, ansible_facts=dict(storage_pool=DICT_DEFAULT_STORAGE_POOL) ) def test_should_remove_storage_pool(self): self.resource.data = DICT_DEFAULT_STORAGE_POOL self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_ABSENT) StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=True, msg=StoragePoolModule.MSG_DELETED ) def test_should_do_nothing_when_storage_pool_not_exist(self): self.mock_ov_client.api_version = 500 self.resource.get_by_name.return_value = None self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_ABSENT) StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=False, msg=StoragePoolModule.MSG_ALREADY_ABSENT, ansible_facts=dict(storage_pool=None) ) def test_should_fail_when_key_is_missing_api300(self): self.mock_ov_client.api_version = 300 self.resource.data = DICT_DEFAULT_STORAGE_POOL self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_MISSING_KEY) StoragePoolModule().run() self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=StoragePoolModule.MSG_MANDATORY_FIELD_MISSING) def test_should_fail_when_key_is_missing_api500(self): self.mock_ov_client.api_version = 500 self.resource.data = DICT_DEFAULT_STORAGE_POOL self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_MISSING_KEY) StoragePoolModule().run() self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=StoragePoolModule.MSG_MANDATORY_FIELD_MISSING) def test_update_when_storage_pool_already_exists_and_is_different_api500(self): self.mock_ov_client.api_version = 500 update_params = yaml.load(YAML_STORAGE_POOL_500) update_params['data']['isManaged'] = False self.mock_ansible_module.params = update_params self.resource.data = DICT_DEFAULT_STORAGE_POOL_500 self.mock_ov_client.storage_pools.update.return_value = update_params StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=True, msg=StoragePoolModule.MSG_UPDATED, ansible_facts=dict(storage_pool=DICT_DEFAULT_STORAGE_POOL_500) ) def test_update_should_do_nothing_when_storage_pool_already_exists_and_is_equal_api500(self): self.mock_ov_client.api_version = 500 self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_500) self.resource.data = DICT_DEFAULT_STORAGE_POOL_500 StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=False, msg=StoragePoolModule.MSG_ALREADY_PRESENT, ansible_facts=dict(storage_pool=DICT_DEFAULT_STORAGE_POOL_500) ) def test_update_should_do_nothing_when_storage_pool_is_absent_and_do_not_exists_api500(self): self.mock_ov_client.api_version = 500 self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_ABSENT_500) self.resource.get_by_name.return_value = None StoragePoolModule().run() self.mock_ansible_module.exit_json.assert_called_once_with( changed=False, msg=StoragePoolModule.MSG_ALREADY_ABSENT, ansible_facts=dict(storage_pool=None) ) def test_should_fail_when_present_but_storage_pool_is_absent_api500(self): self.mock_ov_client.api_version = 500 self.resource.get_by_name.return_value = None self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_500) StoragePoolModule().run() self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=StoragePoolModule.MSG_RESOURCE_NOT_FOUND) def test_should_fail_when_absent_but_storage_pool_exists_api500(self): self.mock_ov_client.api_version = 500 self.resource.data = DICT_DEFAULT_STORAGE_POOL_500 self.mock_ansible_module.params = yaml.load(YAML_STORAGE_POOL_ABSENT_500) StoragePoolModule().run() self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=StoragePoolModule.MSG_RESOURCE_FOUND) if __name__ == '__main__': pytest.main([__file__])
the-stack_106_32354
from django import forms from django.forms.models import ModelForm from django.utils.translation import ugettext_lazy as _ from itdagene.app.workschedule.models import Worker, WorkerInSchedule, WorkSchedule from itdagene.core.models import Preference class WorkScheduleForm(ModelForm): invites = forms.MultipleChoiceField(label=_("Add worker"), required=False) class Meta: model = WorkSchedule fields = ("title", "date", "start_time", "end_time", "description", "invites") def __init__(self, *args, **kwargs): super(WorkScheduleForm, self).__init__(*args, **kwargs) workers = Worker.objects.filter( preference=Preference.current_preference().year ).order_by("name") self.fields["invites"].choices = [ (worker.pk, worker.name) for worker in workers ] self.fields["invites"].widget.attrs["class"] = "chosen" def save(self, commit=True): workschedule = super(WorkScheduleForm, self).save(commit=commit) for i in self.cleaned_data["invites"]: WorkerInSchedule.objects.get_or_create(schedule=workschedule, worker_id=i) return workschedule class WorkerForm(ModelForm): class Meta: model = Worker fields = ("name", "phone", "email", "t_shirt_size") def __init__(self, *args, **kwargs): super(WorkerForm, self).__init__(*args, **kwargs) def save(self): pref = Preference.current_preference() worker = super(WorkerForm, self).save(commit=False) worker.preference = pref.year worker.save() return worker
the-stack_106_32356
# stolen from https://djangostars.com/blog/how-to-create-and-deploy-a-telegram-bot/ import requests from bottle import Bottle, response, request as bottle_request class BotHandlerMixin: BOT_URL = None def get_chat_id(self, data): """ Method to extract chat id from telegram request. """ chat_id = data['message']['chat']['id'] return chat_id def get_message(self, data): """ Method to extract message id from telegram request. """ message_text = data['message']['text'] return message_text def send_message(self, prepared_data): """ Prepared data should be json which includes at least `chat_id` and `text` """ message_url = self.BOT_URL + 'sendMessage' requests.post(message_url, json=prepared_data) class TelegramBot(BotHandlerMixin, Bottle): BOT_URL = 'https://api.telegram.org/****************/' def __init__(self, *args, **kwargs): super(TelegramBot, self).__init__() self.route('/', callback=self.post_handler, method="POST") def change_text_message(self, text): return text[::-1] def prepare_data_for_answer(self, data): message = self.get_message(data) answer = self.change_text_message(message) chat_id = self.get_chat_id(data) json_data = { "chat_id": chat_id, "text": answer, } return json_data def post_handler(self): data = bottle_request.json answer_data = self.prepare_data_for_answer(data) self.send_message(answer_data) return response if __name__ == '__main__': app = TelegramBot() app.run(host='localhost', port=8080)
the-stack_106_32359
import pandas as pd import datetime from sklearn.model_selection import train_test_split import os, sys sys.path.insert(0, os.path.abspath("..")) from src.utils.utils import save_df def ingest_file(path): """Reads data from a csv located at path and returns a dataframe Parameters: path (string): Path where the csv file resides Returns: dataframe """ df = pd.read_csv(path) return df def generate_label(df): """Generates in the passed data frame a variable called `label` which is equal to 1 when `codigo_cierre` is (F) or (N) and 0 in any other case Parameters: df (dataframe) """ df['label'] = df['codigo_cierre'].str.split(' ', n=1, expand=False) df['label'] = df['label'].apply(lambda x: x[0][1]) df['label'] = df['label'].apply(lambda x: 1 if x == 'F' or x == 'N' else 0) return df def drop_cols(df): """Drops unused columns from passed dataframe. The variables that are eliminated are: - codigo_cierre - fecha_cierre - año_cierre - mes_cierre - hora_cierre - latitud - longitud - clas_con_f_alarma - delegacion_cierre - geopoint Parameters: df (dataframe) """ dropped_columns = ['codigo_cierre', 'fecha_cierre', 'año_cierre', 'mes_cierre', 'hora_cierre', 'latitud', 'longitud', 'clas_con_f_alarma', 'delegacion_cierre', 'geopoint'] df.drop(dropped_columns, axis='columns', inplace=True) return df def save_ingestion(df, path): save_df(df, path) def date_transformation(col, df): # arreglamos los strings de fechas # fix Dates # 31/02/19 --> 31/02/2019 for ano in range(2013,2021): string_correccion_ano = str(ano) string_correccion_ano=string_correccion_ano[-2:] print(string_correccion_ano) for mes in range (1,13): if(mes<10): string_correccion_mes = '0'+str(mes) else: string_correccion_mes = str(mes) for dia in range(1, 32): elemento = dia if(elemento<10): string_correccion = '0'+str(dia)+'/'+string_correccion_mes+'/'+string_correccion_ano string_correcto = '0'+str(dia)+'/'+string_correccion_mes+'/20'+string_correccion_ano else: string_correccion = str(dia)+'/'+string_correccion_mes+'/'+string_correccion_ano string_correcto = str(dia)+'/'+string_correccion_mes+'/20'+string_correccion_ano #print(string_correccion) df.loc[df[col] == string_correccion, col] = string_correcto # Convertir columna en datetime df[col]=pd.to_datetime(df[col], format='%d/%m/%Y') return df def ingest(input_path, output_path): df = ingest_file(input_path) df = generate_label(df) df = drop_cols(df) save_ingestion(df, output_path)
the-stack_106_32361
import mmcv import numpy as np import torch from mmdet.core import bbox2roi, build_assigner, build_sampler from mmdet.core.evaluation.bbox_overlaps import bbox_overlaps from mmdet.models.dense_heads import (AnchorHead, CornerHead, FCOSHead, FSAFHead, GuidedAnchorHead, PAAHead, SABLRetinaHead, TransformerHead, VFNetHead, YOLACTHead, YOLACTProtonet, YOLACTSegmHead, paa_head) from mmdet.models.dense_heads.paa_head import levels_to_images from mmdet.models.roi_heads.bbox_heads import BBoxHead, SABLHead from mmdet.models.roi_heads.mask_heads import FCNMaskHead, MaskIoUHead def test_paa_head_loss(): """Tests paa head loss when truth is empty and non-empty.""" class mock_skm(object): def GaussianMixture(self, *args, **kwargs): return self def fit(self, loss): pass def predict(self, loss): components = np.zeros_like(loss, dtype=np.long) return components.reshape(-1) def score_samples(self, loss): scores = np.random.random(len(loss)) return scores paa_head.skm = mock_skm() s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] train_cfg = mmcv.Config( dict( assigner=dict( type='MaxIoUAssigner', pos_iou_thr=0.1, neg_iou_thr=0.1, min_pos_iou=0, ignore_iof_thr=-1), allowed_border=-1, pos_weight=-1, debug=False)) # since Focal Loss is not supported on CPU self = PAAHead( num_classes=4, in_channels=1, train_cfg=train_cfg, loss_cls=dict( type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), loss_bbox=dict(type='GIoULoss', loss_weight=1.3), loss_centerness=dict( type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)) feat = [ torch.rand(1, 1, s // feat_size, s // feat_size) for feat_size in [4, 8, 16, 32, 64] ] self.init_weights() cls_scores, bbox_preds, iou_preds = self(feat) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_bboxes_ignore = None empty_gt_losses = self.loss(cls_scores, bbox_preds, iou_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there should # be no box loss. empty_cls_loss = empty_gt_losses['loss_cls'] empty_box_loss = empty_gt_losses['loss_bbox'] empty_iou_loss = empty_gt_losses['loss_iou'] assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') assert empty_iou_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero for # random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] one_gt_losses = self.loss(cls_scores, bbox_preds, iou_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = one_gt_losses['loss_cls'] onegt_box_loss = one_gt_losses['loss_bbox'] onegt_iou_loss = one_gt_losses['loss_iou'] assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' assert onegt_iou_loss.item() > 0, 'box loss should be non-zero' n, c, h, w = 10, 4, 20, 20 mlvl_tensor = [torch.ones(n, c, h, w) for i in range(5)] results = levels_to_images(mlvl_tensor) assert len(results) == n assert results[0].size() == (h * w * 5, c) assert self.with_score_voting cls_scores = [torch.ones(4, 5, 5)] bbox_preds = [torch.ones(4, 5, 5)] iou_preds = [torch.ones(1, 5, 5)] mlvl_anchors = [torch.ones(5 * 5, 4)] img_shape = None scale_factor = [0.5, 0.5] cfg = mmcv.Config( dict( nms_pre=1000, min_bbox_size=0, score_thr=0.05, nms=dict(type='nms', iou_threshold=0.6), max_per_img=100)) rescale = False self._get_bboxes_single( cls_scores, bbox_preds, iou_preds, mlvl_anchors, img_shape, scale_factor, cfg, rescale=rescale) def test_fcos_head_loss(): """Tests fcos head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] train_cfg = mmcv.Config( dict( assigner=dict( type='MaxIoUAssigner', pos_iou_thr=0.5, neg_iou_thr=0.4, min_pos_iou=0, ignore_iof_thr=-1), allowed_border=-1, pos_weight=-1, debug=False)) # since Focal Loss is not supported on CPU self = FCOSHead( num_classes=4, in_channels=1, train_cfg=train_cfg, loss_cls=dict( type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)) feat = [ torch.rand(1, 1, s // feat_size, s // feat_size) for feat_size in [4, 8, 16, 32, 64] ] cls_scores, bbox_preds, centerness = self.forward(feat) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_bboxes_ignore = None empty_gt_losses = self.loss(cls_scores, bbox_preds, centerness, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there should # be no box loss. empty_cls_loss = empty_gt_losses['loss_cls'] empty_box_loss = empty_gt_losses['loss_bbox'] assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero for # random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] one_gt_losses = self.loss(cls_scores, bbox_preds, centerness, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = one_gt_losses['loss_cls'] onegt_box_loss = one_gt_losses['loss_bbox'] assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' def test_vfnet_head_loss(): """Tests vfnet head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] train_cfg = mmcv.Config( dict( assigner=dict(type='ATSSAssigner', topk=9), allowed_border=-1, pos_weight=-1, debug=False)) # since Focal Loss is not supported on CPU self = VFNetHead( num_classes=4, in_channels=1, train_cfg=train_cfg, loss_cls=dict(type='VarifocalLoss', use_sigmoid=True, loss_weight=1.0)) if torch.cuda.is_available(): self.cuda() feat = [ torch.rand(1, 1, s // feat_size, s // feat_size).cuda() for feat_size in [4, 8, 16, 32, 64] ] cls_scores, bbox_preds, bbox_preds_refine = self.forward(feat) # Test that empty ground truth encourages the network to predict # background gt_bboxes = [torch.empty((0, 4)).cuda()] gt_labels = [torch.LongTensor([]).cuda()] gt_bboxes_ignore = None empty_gt_losses = self.loss(cls_scores, bbox_preds, bbox_preds_refine, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there # should be no box loss. empty_cls_loss = empty_gt_losses['loss_cls'] empty_box_loss = empty_gt_losses['loss_bbox'] assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero # for random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]).cuda(), ] gt_labels = [torch.LongTensor([2]).cuda()] one_gt_losses = self.loss(cls_scores, bbox_preds, bbox_preds_refine, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = one_gt_losses['loss_cls'] onegt_box_loss = one_gt_losses['loss_bbox'] assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' def test_anchor_head_loss(): """Tests anchor head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] cfg = mmcv.Config( dict( assigner=dict( type='MaxIoUAssigner', pos_iou_thr=0.7, neg_iou_thr=0.3, min_pos_iou=0.3, match_low_quality=True, ignore_iof_thr=-1), sampler=dict( type='RandomSampler', num=256, pos_fraction=0.5, neg_pos_ub=-1, add_gt_as_proposals=False), allowed_border=0, pos_weight=-1, debug=False)) self = AnchorHead(num_classes=4, in_channels=1, train_cfg=cfg) # Anchor head expects a multiple levels of features per image feat = [ torch.rand(1, 1, s // (2**(i + 2)), s // (2**(i + 2))) for i in range(len(self.anchor_generator.strides)) ] cls_scores, bbox_preds = self.forward(feat) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_bboxes_ignore = None empty_gt_losses = self.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there should # be no box loss. empty_cls_loss = sum(empty_gt_losses['loss_cls']) empty_box_loss = sum(empty_gt_losses['loss_bbox']) assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero for # random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] one_gt_losses = self.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = sum(one_gt_losses['loss_cls']) onegt_box_loss = sum(one_gt_losses['loss_bbox']) assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' def test_fsaf_head_loss(): """Tests anchor head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] cfg = dict( reg_decoded_bbox=True, anchor_generator=dict( type='AnchorGenerator', octave_base_scale=1, scales_per_octave=1, ratios=[1.0], strides=[8, 16, 32, 64, 128]), bbox_coder=dict(type='TBLRBBoxCoder', normalizer=4.0), loss_cls=dict( type='FocalLoss', use_sigmoid=True, gamma=2.0, alpha=0.25, loss_weight=1.0, reduction='none'), loss_bbox=dict( type='IoULoss', eps=1e-6, loss_weight=1.0, reduction='none')) train_cfg = mmcv.Config( dict( assigner=dict( type='CenterRegionAssigner', pos_scale=0.2, neg_scale=0.2, min_pos_iof=0.01), allowed_border=-1, pos_weight=-1, debug=False)) head = FSAFHead(num_classes=4, in_channels=1, train_cfg=train_cfg, **cfg) if torch.cuda.is_available(): head.cuda() # FSAF head expects a multiple levels of features per image feat = [ torch.rand(1, 1, s // (2**(i + 2)), s // (2**(i + 2))).cuda() for i in range(len(head.anchor_generator.strides)) ] cls_scores, bbox_preds = head.forward(feat) gt_bboxes_ignore = None # When truth is non-empty then both cls and box loss should be nonzero # for random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]).cuda(), ] gt_labels = [torch.LongTensor([2]).cuda()] one_gt_losses = head.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = sum(one_gt_losses['loss_cls']) onegt_box_loss = sum(one_gt_losses['loss_bbox']) assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' # Test that empty ground truth encourages the network to predict bkg gt_bboxes = [torch.empty((0, 4)).cuda()] gt_labels = [torch.LongTensor([]).cuda()] empty_gt_losses = head.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there # should be no box loss. empty_cls_loss = sum(empty_gt_losses['loss_cls']) empty_box_loss = sum(empty_gt_losses['loss_bbox']) assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') def test_ga_anchor_head_loss(): """Tests anchor head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] cfg = mmcv.Config( dict( assigner=dict( type='MaxIoUAssigner', pos_iou_thr=0.7, neg_iou_thr=0.3, min_pos_iou=0.3, match_low_quality=True, ignore_iof_thr=-1), sampler=dict( type='RandomSampler', num=256, pos_fraction=0.5, neg_pos_ub=-1, add_gt_as_proposals=False), ga_assigner=dict( type='ApproxMaxIoUAssigner', pos_iou_thr=0.7, neg_iou_thr=0.3, min_pos_iou=0.3, ignore_iof_thr=-1), ga_sampler=dict( type='RandomSampler', num=256, pos_fraction=0.5, neg_pos_ub=-1, add_gt_as_proposals=False), allowed_border=-1, center_ratio=0.2, ignore_ratio=0.5, pos_weight=-1, debug=False)) head = GuidedAnchorHead(num_classes=4, in_channels=4, train_cfg=cfg) # Anchor head expects a multiple levels of features per image if torch.cuda.is_available(): head.cuda() feat = [ torch.rand(1, 4, s // (2**(i + 2)), s // (2**(i + 2))).cuda() for i in range(len(head.approx_anchor_generator.base_anchors)) ] cls_scores, bbox_preds, shape_preds, loc_preds = head.forward(feat) # Test that empty ground truth encourages the network to predict # background gt_bboxes = [torch.empty((0, 4)).cuda()] gt_labels = [torch.LongTensor([]).cuda()] gt_bboxes_ignore = None empty_gt_losses = head.loss(cls_scores, bbox_preds, shape_preds, loc_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there # should be no box loss. empty_cls_loss = sum(empty_gt_losses['loss_cls']) empty_box_loss = sum(empty_gt_losses['loss_bbox']) assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero # for random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]).cuda(), ] gt_labels = [torch.LongTensor([2]).cuda()] one_gt_losses = head.loss(cls_scores, bbox_preds, shape_preds, loc_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = sum(one_gt_losses['loss_cls']) onegt_box_loss = sum(one_gt_losses['loss_bbox']) assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_loss.item() > 0, 'box loss should be non-zero' def test_bbox_head_loss(): """Tests bbox head loss when truth is empty and non-empty.""" self = BBoxHead(in_channels=8, roi_feat_size=3) # Dummy proposals proposal_list = [ torch.Tensor([[23.6667, 23.8757, 228.6326, 153.8874]]), ] target_cfg = mmcv.Config(dict(pos_weight=1)) # Test bbox loss when truth is empty gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] sampling_results = _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels) bbox_targets = self.get_targets(sampling_results, gt_bboxes, gt_labels, target_cfg) labels, label_weights, bbox_targets, bbox_weights = bbox_targets # Create dummy features "extracted" for each sampled bbox num_sampled = sum(len(res.bboxes) for res in sampling_results) rois = bbox2roi([res.bboxes for res in sampling_results]) dummy_feats = torch.rand(num_sampled, 8 * 3 * 3) cls_scores, bbox_preds = self.forward(dummy_feats) losses = self.loss(cls_scores, bbox_preds, rois, labels, label_weights, bbox_targets, bbox_weights) assert losses.get('loss_cls', 0) > 0, 'cls-loss should be non-zero' assert losses.get('loss_bbox', 0) == 0, 'empty gt loss should be zero' # Test bbox loss when truth is non-empty gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] sampling_results = _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels) rois = bbox2roi([res.bboxes for res in sampling_results]) bbox_targets = self.get_targets(sampling_results, gt_bboxes, gt_labels, target_cfg) labels, label_weights, bbox_targets, bbox_weights = bbox_targets # Create dummy features "extracted" for each sampled bbox num_sampled = sum(len(res.bboxes) for res in sampling_results) dummy_feats = torch.rand(num_sampled, 8 * 3 * 3) cls_scores, bbox_preds = self.forward(dummy_feats) losses = self.loss(cls_scores, bbox_preds, rois, labels, label_weights, bbox_targets, bbox_weights) assert losses.get('loss_cls', 0) > 0, 'cls-loss should be non-zero' assert losses.get('loss_bbox', 0) > 0, 'box-loss should be non-zero' def test_sabl_bbox_head_loss(): """Tests bbox head loss when truth is empty and non-empty.""" self = SABLHead( num_classes=4, cls_in_channels=3, reg_in_channels=3, cls_out_channels=3, reg_offset_out_channels=3, reg_cls_out_channels=3, roi_feat_size=7) # Dummy proposals proposal_list = [ torch.Tensor([[23.6667, 23.8757, 228.6326, 153.8874]]), ] target_cfg = mmcv.Config(dict(pos_weight=1)) # Test bbox loss when truth is empty gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] sampling_results = _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels) bbox_targets = self.get_targets(sampling_results, gt_bboxes, gt_labels, target_cfg) labels, label_weights, bbox_targets, bbox_weights = bbox_targets # Create dummy features "extracted" for each sampled bbox num_sampled = sum(len(res.bboxes) for res in sampling_results) rois = bbox2roi([res.bboxes for res in sampling_results]) dummy_feats = torch.rand(num_sampled, 3, 7, 7) cls_scores, bbox_preds = self.forward(dummy_feats) losses = self.loss(cls_scores, bbox_preds, rois, labels, label_weights, bbox_targets, bbox_weights) assert losses.get('loss_cls', 0) > 0, 'cls-loss should be non-zero' assert losses.get('loss_bbox_cls', 0) == 0, 'empty gt bbox-cls-loss should be zero' assert losses.get('loss_bbox_reg', 0) == 0, 'empty gt bbox-reg-loss should be zero' # Test bbox loss when truth is non-empty gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] sampling_results = _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels) rois = bbox2roi([res.bboxes for res in sampling_results]) bbox_targets = self.get_targets(sampling_results, gt_bboxes, gt_labels, target_cfg) labels, label_weights, bbox_targets, bbox_weights = bbox_targets # Create dummy features "extracted" for each sampled bbox num_sampled = sum(len(res.bboxes) for res in sampling_results) dummy_feats = torch.rand(num_sampled, 3, 7, 7) cls_scores, bbox_preds = self.forward(dummy_feats) losses = self.loss(cls_scores, bbox_preds, rois, labels, label_weights, bbox_targets, bbox_weights) assert losses.get('loss_bbox_cls', 0) > 0, 'empty gt bbox-cls-loss should be zero' assert losses.get('loss_bbox_reg', 0) > 0, 'empty gt bbox-reg-loss should be zero' def test_sabl_retina_head_loss(): """Tests anchor head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] cfg = mmcv.Config( dict( assigner=dict( type='ApproxMaxIoUAssigner', pos_iou_thr=0.5, neg_iou_thr=0.4, min_pos_iou=0.0, ignore_iof_thr=-1), allowed_border=-1, pos_weight=-1, debug=False)) head = SABLRetinaHead( num_classes=4, in_channels=3, feat_channels=10, loss_cls=dict( type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), train_cfg=cfg) if torch.cuda.is_available(): head.cuda() # Anchor head expects a multiple levels of features per image feat = [ torch.rand(1, 3, s // (2**(i + 2)), s // (2**(i + 2))).cuda() for i in range(len(head.approx_anchor_generator.base_anchors)) ] cls_scores, bbox_preds = head.forward(feat) # Test that empty ground truth encourages the network # to predict background gt_bboxes = [torch.empty((0, 4)).cuda()] gt_labels = [torch.LongTensor([]).cuda()] gt_bboxes_ignore = None empty_gt_losses = head.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there # should be no box loss. empty_cls_loss = sum(empty_gt_losses['loss_cls']) empty_box_cls_loss = sum(empty_gt_losses['loss_bbox_cls']) empty_box_reg_loss = sum(empty_gt_losses['loss_bbox_reg']) assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_cls_loss.item() == 0, ( 'there should be no box cls loss when there are no true boxes') assert empty_box_reg_loss.item() == 0, ( 'there should be no box reg loss when there are no true boxes') # When truth is non-empty then both cls and box loss should # be nonzero for random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]).cuda(), ] gt_labels = [torch.LongTensor([2]).cuda()] one_gt_losses = head.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_cls_loss = sum(one_gt_losses['loss_cls']) onegt_box_cls_loss = sum(one_gt_losses['loss_bbox_cls']) onegt_box_reg_loss = sum(one_gt_losses['loss_bbox_reg']) assert onegt_cls_loss.item() > 0, 'cls loss should be non-zero' assert onegt_box_cls_loss.item() > 0, 'box loss cls should be non-zero' assert onegt_box_reg_loss.item() > 0, 'box loss reg should be non-zero' def test_refine_boxes(): """Mirrors the doctest in ``mmdet.models.bbox_heads.bbox_head.BBoxHead.refine_boxes`` but checks for multiple values of n_roi / n_img.""" self = BBoxHead(reg_class_agnostic=True) test_settings = [ # Corner case: less rois than images { 'n_roi': 2, 'n_img': 4, 'rng': 34285940 }, # Corner case: no images { 'n_roi': 0, 'n_img': 0, 'rng': 52925222 }, # Corner cases: few images / rois { 'n_roi': 1, 'n_img': 1, 'rng': 1200281 }, { 'n_roi': 2, 'n_img': 1, 'rng': 1200282 }, { 'n_roi': 2, 'n_img': 2, 'rng': 1200283 }, { 'n_roi': 1, 'n_img': 2, 'rng': 1200284 }, # Corner case: no rois few images { 'n_roi': 0, 'n_img': 1, 'rng': 23955860 }, { 'n_roi': 0, 'n_img': 2, 'rng': 25830516 }, # Corner case: no rois many images { 'n_roi': 0, 'n_img': 10, 'rng': 671346 }, { 'n_roi': 0, 'n_img': 20, 'rng': 699807 }, # Corner case: cal_similarity num rois and images { 'n_roi': 20, 'n_img': 20, 'rng': 1200238 }, { 'n_roi': 10, 'n_img': 20, 'rng': 1200238 }, { 'n_roi': 5, 'n_img': 5, 'rng': 1200238 }, # ---------------------------------- # Common case: more rois than images { 'n_roi': 100, 'n_img': 1, 'rng': 337156 }, { 'n_roi': 150, 'n_img': 2, 'rng': 275898 }, { 'n_roi': 500, 'n_img': 5, 'rng': 4903221 }, ] for demokw in test_settings: try: n_roi = demokw['n_roi'] n_img = demokw['n_img'] rng = demokw['rng'] print(f'Test refine_boxes case: {demokw!r}') tup = _demodata_refine_boxes(n_roi, n_img, rng=rng) rois, labels, bbox_preds, pos_is_gts, img_metas = tup bboxes_list = self.refine_bboxes(rois, labels, bbox_preds, pos_is_gts, img_metas) assert len(bboxes_list) == n_img assert sum(map(len, bboxes_list)) <= n_roi assert all(b.shape[1] == 4 for b in bboxes_list) except Exception: print(f'Test failed with demokw={demokw!r}') raise def _demodata_refine_boxes(n_roi, n_img, rng=0): """Create random test data for the ``mmdet.models.bbox_heads.bbox_head.BBoxHead.refine_boxes`` method.""" import numpy as np from mmdet.core.bbox.demodata import random_boxes from mmdet.core.bbox.demodata import ensure_rng try: import kwarray except ImportError: import pytest pytest.skip('kwarray is required for this test') scale = 512 rng = ensure_rng(rng) img_metas = [{'img_shape': (scale, scale)} for _ in range(n_img)] # Create rois in the expected format roi_boxes = random_boxes(n_roi, scale=scale, rng=rng) if n_img == 0: assert n_roi == 0, 'cannot have any rois if there are no images' img_ids = torch.empty((0, ), dtype=torch.long) roi_boxes = torch.empty((0, 4), dtype=torch.float32) else: img_ids = rng.randint(0, n_img, (n_roi, )) img_ids = torch.from_numpy(img_ids) rois = torch.cat([img_ids[:, None].float(), roi_boxes], dim=1) # Create other args labels = rng.randint(0, 2, (n_roi, )) labels = torch.from_numpy(labels).long() bbox_preds = random_boxes(n_roi, scale=scale, rng=rng) # For each image, pretend random positive boxes are gts is_label_pos = (labels.numpy() > 0).astype(np.int) lbl_per_img = kwarray.group_items(is_label_pos, img_ids.numpy()) pos_per_img = [sum(lbl_per_img.get(gid, [])) for gid in range(n_img)] # randomly generate with numpy then sort with torch _pos_is_gts = [ rng.randint(0, 2, (npos, )).astype(np.uint8) for npos in pos_per_img ] pos_is_gts = [ torch.from_numpy(p).sort(descending=True)[0] for p in _pos_is_gts ] return rois, labels, bbox_preds, pos_is_gts, img_metas def test_mask_head_loss(): """Test mask head loss when mask target is empty.""" self = FCNMaskHead( num_convs=1, roi_feat_size=6, in_channels=8, conv_out_channels=8, num_classes=8) # Dummy proposals proposal_list = [ torch.Tensor([[23.6667, 23.8757, 228.6326, 153.8874]]), ] gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] sampling_results = _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels) # create dummy mask import numpy as np from mmdet.core import BitmapMasks dummy_mask = np.random.randint(0, 2, (1, 160, 240), dtype=np.uint8) gt_masks = [BitmapMasks(dummy_mask, 160, 240)] # create dummy train_cfg train_cfg = mmcv.Config(dict(mask_size=12, mask_thr_binary=0.5)) # Create dummy features "extracted" for each sampled bbox num_sampled = sum(len(res.bboxes) for res in sampling_results) dummy_feats = torch.rand(num_sampled, 8, 6, 6) mask_pred = self.forward(dummy_feats) mask_targets = self.get_targets(sampling_results, gt_masks, train_cfg) pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results]) loss_mask = self.loss(mask_pred, mask_targets, pos_labels) onegt_mask_loss = sum(loss_mask['loss_mask']) assert onegt_mask_loss.item() > 0, 'mask loss should be non-zero' # test mask_iou_head mask_iou_head = MaskIoUHead( num_convs=1, num_fcs=1, roi_feat_size=6, in_channels=8, conv_out_channels=8, fc_out_channels=8, num_classes=8) pos_mask_pred = mask_pred[range(mask_pred.size(0)), pos_labels] mask_iou_pred = mask_iou_head(dummy_feats, pos_mask_pred) pos_mask_iou_pred = mask_iou_pred[range(mask_iou_pred.size(0)), pos_labels] mask_iou_targets = mask_iou_head.get_targets(sampling_results, gt_masks, pos_mask_pred, mask_targets, train_cfg) loss_mask_iou = mask_iou_head.loss(pos_mask_iou_pred, mask_iou_targets) onegt_mask_iou_loss = loss_mask_iou['loss_mask_iou'].sum() assert onegt_mask_iou_loss.item() >= 0 def _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels): """Create sample results that can be passed to BBoxHead.get_targets.""" num_imgs = 1 feat = torch.rand(1, 1, 3, 3) assign_config = dict( type='MaxIoUAssigner', pos_iou_thr=0.5, neg_iou_thr=0.5, min_pos_iou=0.5, ignore_iof_thr=-1) sampler_config = dict( type='RandomSampler', num=512, pos_fraction=0.25, neg_pos_ub=-1, add_gt_as_proposals=True) bbox_assigner = build_assigner(assign_config) bbox_sampler = build_sampler(sampler_config) gt_bboxes_ignore = [None for _ in range(num_imgs)] sampling_results = [] for i in range(num_imgs): assign_result = bbox_assigner.assign(proposal_list[i], gt_bboxes[i], gt_bboxes_ignore[i], gt_labels[i]) sampling_result = bbox_sampler.sample( assign_result, proposal_list[i], gt_bboxes[i], gt_labels[i], feats=feat) sampling_results.append(sampling_result) return sampling_results def test_corner_head_loss(): """Tests corner head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] self = CornerHead(num_classes=4, in_channels=1) # Corner head expects a multiple levels of features per image feat = [ torch.rand(1, 1, s // 4, s // 4) for _ in range(self.num_feat_levels) ] tl_heats, br_heats, tl_embs, br_embs, tl_offs, br_offs = self.forward(feat) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_bboxes_ignore = None empty_gt_losses = self.loss(tl_heats, br_heats, tl_embs, br_embs, tl_offs, br_offs, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) empty_det_loss = sum(empty_gt_losses['det_loss']) empty_push_loss = sum(empty_gt_losses['push_loss']) empty_pull_loss = sum(empty_gt_losses['pull_loss']) empty_off_loss = sum(empty_gt_losses['off_loss']) assert empty_det_loss.item() > 0, 'det loss should be non-zero' assert empty_push_loss.item() == 0, ( 'there should be no push loss when there are no true boxes') assert empty_pull_loss.item() == 0, ( 'there should be no pull loss when there are no true boxes') assert empty_off_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # When truth is non-empty then both cls and box loss should be nonzero for # random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] one_gt_losses = self.loss(tl_heats, br_heats, tl_embs, br_embs, tl_offs, br_offs, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) onegt_det_loss = sum(one_gt_losses['det_loss']) onegt_push_loss = sum(one_gt_losses['push_loss']) onegt_pull_loss = sum(one_gt_losses['pull_loss']) onegt_off_loss = sum(one_gt_losses['off_loss']) assert onegt_det_loss.item() > 0, 'det loss should be non-zero' assert onegt_push_loss.item() == 0, ( 'there should be no push loss when there are only one true box') assert onegt_pull_loss.item() > 0, 'pull loss should be non-zero' assert onegt_off_loss.item() > 0, 'off loss should be non-zero' gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874], [123.6667, 123.8757, 138.6326, 251.8874]]), ] gt_labels = [torch.LongTensor([2, 3])] # equalize the corners' embedding value of different objects to make the # push_loss larger than 0 gt_bboxes_ind = (gt_bboxes[0] // 4).int().tolist() for tl_emb_feat, br_emb_feat in zip(tl_embs, br_embs): tl_emb_feat[:, :, gt_bboxes_ind[0][1], gt_bboxes_ind[0][0]] = tl_emb_feat[:, :, gt_bboxes_ind[1][1], gt_bboxes_ind[1][0]] br_emb_feat[:, :, gt_bboxes_ind[0][3], gt_bboxes_ind[0][2]] = br_emb_feat[:, :, gt_bboxes_ind[1][3], gt_bboxes_ind[1][2]] two_gt_losses = self.loss(tl_heats, br_heats, tl_embs, br_embs, tl_offs, br_offs, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) twogt_det_loss = sum(two_gt_losses['det_loss']) twogt_push_loss = sum(two_gt_losses['push_loss']) twogt_pull_loss = sum(two_gt_losses['pull_loss']) twogt_off_loss = sum(two_gt_losses['off_loss']) assert twogt_det_loss.item() > 0, 'det loss should be non-zero' assert twogt_push_loss.item() > 0, 'push loss should be non-zero' assert twogt_pull_loss.item() > 0, 'pull loss should be non-zero' assert twogt_off_loss.item() > 0, 'off loss should be non-zero' def test_corner_head_encode_and_decode_heatmap(): """Tests corner head generating and decoding the heatmap.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3), 'border': (0, 0, 0, 0) }] gt_bboxes = [ torch.Tensor([[10, 20, 200, 240], [40, 50, 100, 200], [10, 20, 200, 240]]) ] gt_labels = [torch.LongTensor([1, 1, 2])] self = CornerHead(num_classes=4, in_channels=1, corner_emb_channels=1) feat = [ torch.rand(1, 1, s // 4, s // 4) for _ in range(self.num_feat_levels) ] targets = self.get_targets( gt_bboxes, gt_labels, feat[0].shape, img_metas[0]['pad_shape'], with_corner_emb=self.with_corner_emb) gt_tl_heatmap = targets['topleft_heatmap'] gt_br_heatmap = targets['bottomright_heatmap'] gt_tl_offset = targets['topleft_offset'] gt_br_offset = targets['bottomright_offset'] embedding = targets['corner_embedding'] [top, left], [bottom, right] = embedding[0][0] gt_tl_embedding_heatmap = torch.zeros([1, 1, s // 4, s // 4]) gt_br_embedding_heatmap = torch.zeros([1, 1, s // 4, s // 4]) gt_tl_embedding_heatmap[0, 0, top, left] = 1 gt_br_embedding_heatmap[0, 0, bottom, right] = 1 batch_bboxes, batch_scores, batch_clses = self.decode_heatmap( tl_heat=gt_tl_heatmap, br_heat=gt_br_heatmap, tl_off=gt_tl_offset, br_off=gt_br_offset, tl_emb=gt_tl_embedding_heatmap, br_emb=gt_br_embedding_heatmap, img_meta=img_metas[0], k=100, kernel=3, distance_threshold=0.5) bboxes = batch_bboxes.view(-1, 4) scores = batch_scores.view(-1, 1) clses = batch_clses.view(-1, 1) idx = scores.argsort(dim=0, descending=True) bboxes = bboxes[idx].view(-1, 4) scores = scores[idx].view(-1) clses = clses[idx].view(-1) valid_bboxes = bboxes[torch.where(scores > 0.05)] valid_labels = clses[torch.where(scores > 0.05)] max_coordinate = valid_bboxes.max() offsets = valid_labels.to(valid_bboxes) * (max_coordinate + 1) gt_offsets = gt_labels[0].to(gt_bboxes[0]) * (max_coordinate + 1) offset_bboxes = valid_bboxes + offsets[:, None] offset_gtbboxes = gt_bboxes[0] + gt_offsets[:, None] iou_matrix = bbox_overlaps(offset_bboxes.numpy(), offset_gtbboxes.numpy()) assert (iou_matrix == 1).sum() == 3 def test_yolact_head_loss(): """Tests yolact head losses when truth is empty and non-empty.""" s = 550 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3) }] train_cfg = mmcv.Config( dict( assigner=dict( type='MaxIoUAssigner', pos_iou_thr=0.5, neg_iou_thr=0.4, min_pos_iou=0., ignore_iof_thr=-1, gt_max_assign_all=False), smoothl1_beta=1., allowed_border=-1, pos_weight=-1, neg_pos_ratio=3, debug=False, min_gt_box_wh=[4.0, 4.0])) bbox_head = YOLACTHead( num_classes=80, in_channels=256, feat_channels=256, anchor_generator=dict( type='AnchorGenerator', octave_base_scale=3, scales_per_octave=1, base_sizes=[8, 16, 32, 64, 128], ratios=[0.5, 1.0, 2.0], strides=[550.0 / x for x in [69, 35, 18, 9, 5]], centers=[(550 * 0.5 / x, 550 * 0.5 / x) for x in [69, 35, 18, 9, 5]]), bbox_coder=dict( type='DeltaXYWHBBoxCoder', target_means=[.0, .0, .0, .0], target_stds=[0.1, 0.1, 0.2, 0.2]), loss_cls=dict( type='CrossEntropyLoss', use_sigmoid=False, reduction='none', loss_weight=1.0), loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.5), num_head_convs=1, num_protos=32, use_ohem=True, train_cfg=train_cfg) segm_head = YOLACTSegmHead( in_channels=256, num_classes=80, loss_segm=dict( type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)) mask_head = YOLACTProtonet( num_classes=80, in_channels=256, num_protos=32, max_masks_to_train=100, loss_mask_weight=6.125) feat = [ torch.rand(1, 256, feat_size, feat_size) for feat_size in [69, 35, 18, 9, 5] ] cls_score, bbox_pred, coeff_pred = bbox_head.forward(feat) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_masks = [torch.empty((0, 550, 550))] gt_bboxes_ignore = None empty_gt_losses, sampling_results = bbox_head.loss( cls_score, bbox_pred, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore=gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there should # be no box loss. empty_cls_loss = sum(empty_gt_losses['loss_cls']) empty_box_loss = sum(empty_gt_losses['loss_bbox']) assert empty_cls_loss.item() > 0, 'cls loss should be non-zero' assert empty_box_loss.item() == 0, ( 'there should be no box loss when there are no true boxes') # Test segm head and mask head segm_head_outs = segm_head(feat[0]) empty_segm_loss = segm_head.loss(segm_head_outs, gt_masks, gt_labels) mask_pred = mask_head(feat[0], coeff_pred, gt_bboxes, img_metas, sampling_results) empty_mask_loss = mask_head.loss(mask_pred, gt_masks, gt_bboxes, img_metas, sampling_results) # When there is no truth, the segm and mask loss should be zero. empty_segm_loss = sum(empty_segm_loss['loss_segm']) empty_mask_loss = sum(empty_mask_loss['loss_mask']) assert empty_segm_loss.item() == 0, ( 'there should be no segm loss when there are no true boxes') assert empty_mask_loss == 0, ( 'there should be no mask loss when there are no true boxes') # When truth is non-empty then cls, box, mask, segm loss should be # nonzero for random inputs. gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] gt_masks = [(torch.rand((1, 550, 550)) > 0.5).float()] one_gt_losses, sampling_results = bbox_head.loss( cls_score, bbox_pred, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore=gt_bboxes_ignore) one_gt_cls_loss = sum(one_gt_losses['loss_cls']) one_gt_box_loss = sum(one_gt_losses['loss_bbox']) assert one_gt_cls_loss.item() > 0, 'cls loss should be non-zero' assert one_gt_box_loss.item() > 0, 'box loss should be non-zero' one_gt_segm_loss = segm_head.loss(segm_head_outs, gt_masks, gt_labels) mask_pred = mask_head(feat[0], coeff_pred, gt_bboxes, img_metas, sampling_results) one_gt_mask_loss = mask_head.loss(mask_pred, gt_masks, gt_bboxes, img_metas, sampling_results) one_gt_segm_loss = sum(one_gt_segm_loss['loss_segm']) one_gt_mask_loss = sum(one_gt_mask_loss['loss_mask']) assert one_gt_segm_loss.item() > 0, 'segm loss should be non-zero' assert one_gt_mask_loss.item() > 0, 'mask loss should be non-zero' def test_transformer_head_loss(): """Tests transformer head loss when truth is empty and non-empty.""" s = 256 img_metas = [{ 'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3), 'batch_input_shape': (s, s) }] train_cfg = dict( assigner=dict( type='HungarianAssigner', cls_cost=dict(type='ClassificationCost', weight=1.0), reg_cost=dict(type='BBoxL1Cost', weight=5.0), iou_cost=dict(type='IoUCost', iou_mode='giou', weight=2.0))) transformer_cfg = dict( type='Transformer', embed_dims=4, num_heads=1, num_encoder_layers=1, num_decoder_layers=1, feedforward_channels=1, dropout=0.1, act_cfg=dict(type='ReLU', inplace=True), norm_cfg=dict(type='LN'), num_fcs=2, pre_norm=False, return_intermediate_dec=True) positional_encoding_cfg = dict( type='SinePositionalEncoding', num_feats=2, normalize=True) self = TransformerHead( num_classes=4, in_channels=1, num_fcs=2, train_cfg=train_cfg, transformer=transformer_cfg, positional_encoding=positional_encoding_cfg) self.init_weights() feat = [ torch.rand(1, 1, s // feat_size, s // feat_size) for feat_size in [4, 8, 16, 32, 64] ] cls_scores, bbox_preds = self.forward(feat, img_metas) # Test that empty ground truth encourages the network to predict background gt_bboxes = [torch.empty((0, 4))] gt_labels = [torch.LongTensor([])] gt_bboxes_ignore = None empty_gt_losses = self.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) # When there is no truth, the cls loss should be nonzero but there should # be no box loss. for key, loss in empty_gt_losses.items(): if 'cls' in key: assert loss.item() > 0, 'cls loss should be non-zero' elif 'bbox' in key: assert loss.item( ) == 0, 'there should be no box loss when there are no true boxes' elif 'iou' in key: assert loss.item( ) == 0, 'there should be no iou loss when there are no true boxes' # When truth is non-empty then both cls and box loss should be nonzero for # random inputs gt_bboxes = [ torch.Tensor([[23.6667, 23.8757, 238.6326, 151.8874]]), ] gt_labels = [torch.LongTensor([2])] one_gt_losses = self.loss(cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas, gt_bboxes_ignore) for loss in one_gt_losses.values(): assert loss.item( ) > 0, 'cls loss, or box loss, or iou loss should be non-zero' # test forward_train self.forward_train(feat, img_metas, gt_bboxes, gt_labels) # test inference mode self.get_bboxes(cls_scores, bbox_preds, img_metas, rescale=True)