bool:\\n\\n cmd = f'kubectl --context={k8s_ctx} get pvc {pvc_name} -o json'\\n\\n if dry_run:\\n logging.info(cmd)\\n return True\\n\\n p = safe_exec(cmd)\\n if not p.stdout:\\n return False\\n\\n json_output = json.loads(p.stdout.decode())\\n if 'status' not in json_output or 'phase' not in json_output['status']:\\n return False\\n\\n logging.debug(f\\\"PVC {pvc_name} status: {json_output['status']['phase']}\\\")\\n return json_output['status']['phase'] == 'Bound'\",\n \"def main():\\n\\n args = cli.get_args()\\n\\n audit = {}\\n try:\\n service_instance,content = connect_vc(args.host,args.user,args.password,args.port)\\n\\n if sys.stdout.isatty():\\n print(\\\"vCenter: %s\\\" % args.host)\\n \\n content = service_instance.RetrieveContent()\\n\\n container = content.rootFolder # starting point to look into\\n datacenters = get_datacenters(content)\\n for dc in datacenters:\\n datacenters[dc]['clusters'] = get_clusters(datacenters[dc]['dc'])\\n\\n datacenters[dc]['vms'] = get_vms(datacenters[dc]['dc'].vmFolder)\\n \\n get_nets(dc)\\n get_dstores(dc)\\n\\n vmcount=0\\n \\n for dc in datacenters:\\n for vm in sorted(datacenters[dc]['vms'],key=lambda s: s.lower()):\\n vmcount+=1\\n v = datacenters[dc]['vms'][vm]\\n c = find_cluster(datacenters[dc]['clusters'],v.runtime.host.name)\\n vort = \\\"Template\\\" if v.summary.config.template == True else \\\"VM\\\"\\n audit[v.name]={}\\n audit[v.name]['datacenter'] = dc\\n audit[v.name]['cluster'] = c\\n audit[v.name]['type'] = vort\\n audit[v.name]['hostname'] = v.summary.guest.hostName\\n audit[v.name]['guestid'] = v.config.guestId\\n audit[v.name]['fullname'] = v.summary.config.guestFullName\\n audit[v.name]['state'] = v.runtime.powerState\\n audit[v.name]['ip'] = v.guest.ipAddress\\n if sys.stdout.isatty():\\n print(vmcount,\\\"Guests processed\\\",end='\\\\r')\\n sys.stdout.flush()\\n# print(\\\"%-15s:%-10s %-8s %-30s %-30s %s %s %s %s\\\" % (dc, c, vort,v.name,v.summary.guest.hostName, v.config.guestId, v.summary.config.guestFullName,v.guest.guestState,v.guest.ipAddress ))\\n #print vort, v.name, v.summary.guest.hostName, v.guest.guestId, v.summary.config.guestFullName,v.guest.guestState,v.guest.ipAddress #,v.summary\\n# print(\\\"\\\\ncount:\\\",vmcount)\\n \\n print(json.dumps(audit, indent=4, separators=(',', ': ')))\\n \\n except vmodl.MethodFault as error:\\n print(\\\"Caught vmodl fault : \\\" + error.msg)\\n return -1\\n\\n return 0\",\n \"def get_pods(self, **kw):\\n resource = self.pods\\n\\n try:\\n pod_data = resource.get(**kw)\\n log.info(pod_data)\\n except exceptions.NotFoundError:\\n log.error(\\\"Failed to get pods: resource not found.\\\")\\n raise\\n except Exception:\\n log.error(\\\"Unexpected error.\\\")\\n raise\\n\\n return [item.metadata.name for item in pod_data.items]\",\n \"def print_vm_info(virtual_machine):\\n config = virtual_machine.config\\n print(\\\"Name : \\\", config.name)\\n print(\\\"Template : \\\", config.template)\\n print(\\\"Guest : \\\", config.guestFullName)\\n print(\\\"Instance UUID : \\\", config.instanceUuid)\\n print(\\\"Bios UUID : \\\", config.uuid)\\n print(\\\"\\\")\",\n \"def get_logs(k8s_ctx: str, label: str, containers: List[str], dry_run: bool = False):\\n for c in containers:\\n cmd = f'kubectl --context={k8s_ctx} logs -l {label} -c {c} --timestamps --since=24h --tail=-1'\\n if dry_run:\\n logging.info(cmd)\\n else:\\n try:\\n # kubectl logs command can fail if the pod/container is gone, so we suppress error.\\n # We can't combine it into one try-except-finally, because safe_exec should report\\n # the command used in DEBUG level using old format with timestamps. New bare format\\n # is used only after successful invocation of kubectl logs.\\n proc = safe_exec(cmd)\\n try:\\n # Temporarily modify format for logging because we import true timestamps\\n # from Kubernetes and don't need logging timestamps, so we just copy logs\\n # verbatim.\\n root_logger = logging.getLogger()\\n orig_formatter = root_logger.handlers[0].formatter\\n root_logger.handlers[0].setFormatter(logging.Formatter(fmt='%(message)s'))\\n for line in proc.stdout.decode().split('\\\\n'):\\n if line:\\n logging.info(line)\\n finally:\\n # Ensure logging is restored to previous format\\n # type is ignored because orig_formatter can be None\\n # and there does not seem to be any other way to get\\n # the original formatter from root logger\\n root_logger.handlers[0].setFormatter(orig_formatter) # type: ignore\\n except SafeExecError:\\n pass\",\n \"def get_pvc_dict():\\n template = textwrap.dedent(\\n \\\"\\\"\\\"\\n kind: PersistentVolumeClaim\\n apiVersion: v1\\n metadata:\\n name: fio-target\\n spec:\\n storageClassName: None\\n accessModes: [\\\"ReadWriteOnce\\\"]\\n resources:\\n requests:\\n storage: None\\n \\\"\\\"\\\"\\n )\\n pvc_dict = yaml.safe_load(template)\\n return pvc_dict\",\n \"def _GetPod(self) -> Dict[str, Any]:\\n stdout, _, _ = RunKubectlCommand(['get', 'pod', self.name, '-o', 'yaml'])\\n pod = yaml.safe_load(stdout)\\n self.ip_address = pod.get('status', {}).get('podIP')\\n return pod\",\n \"def show_vdcs(self):\\n for v in self.vdcs:\\n print v\",\n \"def _get_deployment_logs(namespace, name, tail_lines=TAIL_LINES_DEFAULT):\\n pods = []\\n try:\\n api_response = k8s_client.list_namespaced_pod(namespace, label_selector='release={}'.format(name))\\n for api_items in api_response.items:\\n pods.append(api_items.metadata.name)\\n except ApiException as e:\\n print(\\\"Exception when calling CoreV1Api->list_namespaced_pod: %s\\\\n\\\" % e)\\n\\n # Iterate over list of pods and concatenate logs\\n logs = \\\"\\\"\\n try:\\n for pod in pods:\\n logs += pod + \\\"\\\\n\\\"\\n logs += k8s_client.read_namespaced_pod_log(pod, namespace, tail_lines=tail_lines)\\n except ApiException as e:\\n logging.error(\\\"Exception when calling CoreV1Api->read_namespaced_pod_log: %s\\\\n\\\" % e)\\n return logs\",\n \"def print_vm_info(virtual_machine):\\n summary = virtual_machine.summary\\n print(summary.runtime.host)\\n print(\\\"Name : \\\", summary.config.name)\\n print(\\\"Template : \\\", summary.config.template)\\n print(\\\"Path : \\\", summary.config.vmPathName)\\n print(\\\"Guest : \\\", summary.config.guestFullName)\\n print(\\\"Instance UUID : \\\", summary.config.instanceUuid)\\n print(\\\"Bios UUID : \\\", summary.config.uuid)\\n annotation = summary.config.annotation\\n if annotation:\\n print(\\\"Annotation : \\\", annotation)\\n print(\\\"State : \\\", summary.runtime.powerState)\\n if summary.guest is not None:\\n ip_address = summary.guest.ipAddress\\n tools_version = summary.guest.toolsStatus\\n if tools_version is not None:\\n print(\\\"VMware-tools: \\\", tools_version)\\n else:\\n print(\\\"Vmware-tools: None\\\")\\n if ip_address:\\n print(\\\"IP : \\\", ip_address)\\n else:\\n print(\\\"IP : None\\\")\\n if summary.runtime.question is not None:\\n print(\\\"Question : \\\", summary.runtime.question.text)\\n print(\\\"\\\")\",\n \"def get_notebook_pvcs(nb):\\n pvcs = []\\n if not nb[\\\"spec\\\"][\\\"template\\\"][\\\"spec\\\"][\\\"volumes\\\"]:\\n return []\\n\\n vols = nb[\\\"spec\\\"][\\\"template\\\"][\\\"spec\\\"][\\\"volumes\\\"]\\n for vol in vols:\\n # Check if the volume is a pvc\\n if not vol.get(\\\"persistentVolumeClaim\\\"):\\n continue\\n pvcs.append(vol[\\\"persistentVolumeClaim\\\"][\\\"claimName\\\"])\\n\\n return pvcs\",\n \"def get_pod_logs(self, label_selector, namespace, container):\\n pods = self.get_pods(label_selector, namespace).items\\n return [\\n self.core_client.read_namespaced_pod_log(\\n name=pod.metadata.name, namespace=namespace, container=container\\n )\\n for pod in pods\\n ]\",\n \"def get_info(self):\\n return {'q_ref': self.q_ref, 'v_ref': self.v_ref, 'U': self.U, 'type': 'POD'}\",\n \"def collect_persistent_volume(namespace, k8s_cli, resources_out, collect_func, retries):\\n resource = \\\"PersistentVolume\\\"\\n output = collect_pv_by_pvc_names(namespace, k8s_cli, collect_func, retries)\\n if output:\\n resources_out[\\\"PersistentVolume\\\"] = output\\n logger.info(\\\"Namespace '%s': + Collected %s\\\", namespace, resource)\",\n \"def check_pod_pvc_status(self, skip_replication_resources=False):\\n config.switch_to_cluster_by_name(self.preferred_primary_cluster)\\n dr_helpers.wait_for_all_resources_creation(\\n self.workload_pvc_count,\\n self.workload_pod_count,\\n self.workload_namespace,\\n skip_replication_resources=skip_replication_resources,\\n )\",\n \"def check_server(k8s_ctx: str, dry_run: bool = False):\\n cmd = f'kubectl --context={k8s_ctx} version --short'\\n if dry_run:\\n logging.info(cmd)\\n else:\\n safe_exec(cmd)\",\n \"def test_vcmp(self):\\r\\n if self.flask_app.config.get('VMCP_KEY'):\\r\\n self.flask_app.config.pop('VMCP_KEY')\\r\\n res = self.app.get('api/vmcp', follow_redirects=True)\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 501, err\\r\\n assert err['status_code'] == 501, err\\r\\n assert err['status'] == \\\"failed\\\", err\\r\\n assert err['target'] == \\\"vmcp\\\", err\\r\\n assert err['action'] == \\\"GET\\\", err\",\n \"def logvvc(varstring, header = '***', type = 'info'):\\n # ANSI Colour codes for terminal output\\n CLR_R = '\\\\u001B[31m'\\n CLR_LR = '\\\\u001B[91m'\\n CLR_LG = '\\\\u001B[92m'\\n CLR_LY = '\\\\u001B[93m'\\n CLR_LB = '\\\\u001B[94m'\\n CLR_LM = '\\\\u001B[95m'\\n CLR_LC = '\\\\u001B[96m'\\n RESET = '\\\\u001B[0m'\\n REVERSE_VIDEO = \\\"\\\\u001B[7m\\\"\\n\\n fallback_type = 'lb'\\n codes = {\\n 'info': CLR_LG,\\n 'warn': CLR_R, \\n 'error': REVERSE_VIDEO, \\n 'lr': CLR_LR,\\n 'ly': CLR_LY,\\n 'lb': CLR_LB,\\n 'lm': CLR_LM,\\n 'lc': CLR_LC\\n }\\n code = codes[type if type in codes else fallback_type]\\n\\n names = varstring.split(' ')\\n fs = f\\\"f'{code}{header} \\\"\\n for name in names:\\n fs += \\\"{\\\" + name + \\\"=}, \\\"\\n fs = fs[:-2] + \\\";{RESET}'\\\"\\n print(eval(fs))\",\n \"def print_metadata():\\n data = {\\n 'python_implementation': platform.python_implementation(),\\n 'python_version_info': tuple(sys.version_info),\\n 'pickle_protocol': pickle.HIGHEST_PROTOCOL,\\n }\\n if sys.version_info < (3,):\\n out_stream = sys.stdout\\n else:\\n out_stream = sys.stdout.buffer\\n out_stream.write(json.dumps(data).encode(_IPC_ENCODING) + b'\\\\n')\",\n \"def show_current_vdc(self):\\n if self._check_for_7k():\\n self.get_current_vdc()\\n print self.current_vdc\",\n \"def status(self):\\n\\n client = self.connect()\\n if not client.sys.is_initialized():\\n print(\\\"Vault is not initialized\\\")\\n return\\n else:\\n print(\\\"Vault is initialized\\\")\\n\\n if client.sys.is_sealed():\\n print(\\\"Vault is sealed\\\")\\n print(client.seal_status)\\n return\\n else:\\n print(\\\"Vault is unsealed\\\")\\n\\n # read in the Vault access token\\n client = self.connect(VAULT_TOKEN)\\n print()\\n print(\\\"Key Status\\\")\\n print(json.dumps(client.key_status))\\n\\n print()\\n print(\\\"HA Status\\\")\\n print(json.dumps(client.ha_status))\\n\\n print()\\n print(\\\"Secret Backends\\\")\\n print(json.dumps(client.sys.list_mounted_secrets_engines(), indent=True))\\n\\n print()\\n print(\\\"Policies\\\")\\n print(json.dumps(client.sys.list_policies()))\\n\\n print()\\n print(\\\"Audit Backends\\\")\\n print(json.dumps(client.sys.list_enabled_audit_devices(), indent=True))\\n\\n print()\\n print(\\\"Auth Backends\\\")\\n print(json.dumps(client.sys.list_auth_methods(), indent=True))\",\n \"def label_persistent_disk(cfg: ElasticBlastConfig, pv_claim: str) -> None:\\n\\n use_local_ssd = cfg.cluster.use_local_ssd\\n if use_local_ssd:\\n return\\n dry_run = cfg.cluster.dry_run\\n cluster_name = cfg.cluster.name\\n labels = cfg.cluster.labels\\n get_pv_cmd = f'kubectl --context={cfg.appstate.k8s_ctx} get pv -o custom-columns=CLAIM:.spec.claimRef.name,PDNAME:.spec.csi.volumeHandle'\\n if dry_run:\\n logging.info(get_pv_cmd)\\n pd_name = f'disk_name_with_claim_{pv_claim}'\\n else:\\n proc = safe_exec(get_pv_cmd)\\n output = proc.stdout.decode()\\n pd_name = ''\\n for line in output.split('\\\\n'):\\n parts = line.split()\\n if len(parts) < 2:\\n continue\\n if parts[0] == pv_claim:\\n pd_name = parts[1].split('/')[-1]\\n if not pd_name:\\n logging.debug(f'kubectl get pv returned\\\\n{output}')\\n raise LookupError(f\\\"Disk with claim '{pv_claim}' can't be found in cluster '{cluster_name}'\\\")\\n zone = cfg.gcp.zone\\n cmd = f'gcloud compute disks update {pd_name} --update-labels {labels} --zone {zone} --project {cfg.gcp.project}'\\n if dry_run:\\n logging.info(cmd)\\n else:\\n safe_exec(cmd)\",\n \"def collect_logs_from_pod(namespace, pod, logs_dir, k8s_cli):\\n containers = get_list_of_containers_from_pod(namespace, pod, k8s_cli)\\n init_containers = get_list_of_init_containers_from_pod(namespace, pod, k8s_cli)\\n containers.extend(init_containers)\\n if containers is None:\\n logger.warning(\\\"Namespace '%s' Could not get containers for pod: %s list - \\\"\\n \\\"skipping pods logs collection\\\", namespace, pod)\\n return\\n for container in containers:\\n cmd = \\\"{} logs -c {} -n {} {}\\\" \\\\\\n .format(k8s_cli, container, namespace, pod)\\n with open(os.path.join(logs_dir, \\\"{}-{}.log\\\".format(pod, container)),\\n \\\"w+\\\", encoding='UTF-8') as file_handle:\\n _, output = run_shell_command(cmd)\\n file_handle.write(output)\\n\\n # operator and admission containers restart after changing the operator-environment-configmap\\n # getting the logs of the containers before the restart can help us with debugging potential bugs\\n get_logs_before_restart_cmd = \\\"{} logs -c {} -n {} {} -p\\\" \\\\\\n .format(k8s_cli, container, namespace, pod)\\n err_code, output = run_shell_command(get_logs_before_restart_cmd)\\n container_log_before_restart_file = os.path.join(logs_dir,\\n '{}-{}-instance-before-restart.log'.format(pod, container))\\n if err_code == 0: # Previous container instance found; did restart.\\n with open(container_log_before_restart_file, \\\"w+\\\", encoding='UTF-8') as file_handle:\\n file_handle.write(output)\\n\\n logger.info(\\\"Namespace '%s': + %s-%s\\\", namespace, pod, container)\",\n \"def get_vdcs(self):\\n if self._check_for_7k():\\n self.logger.debug('Getting VDC information from {}'.format(self.host))\\n vdcxml = self._ncc.nxoscli('show vdc')\\n vdcparsed = _begin_parse(vdcxml)\\n vdcschema = parse_get_nsmap(vdcparsed)\\n showvdc = parse_xml_heirarchy('ROW_vdc', ['vdc_id', 'vdc_name', 'state'], vdcschema,\\n vdcparsed)\\n vdcs = {}\\n for v in showvdc:\\n self.logger.debug(\\n 'VDC {} {} {} on {}'.format(v['vdc_id'], v['vdc_name'], v['state'], self.host))\\n vdcs[v['vdc_name']] = VDC(**v)\\n if v['vdc_id'] == '1':\\n self.default_vdc = v['vdc_name']\\n self.vdcs = vdcs\\n self.logger.debug(vdcs)\",\n \"def test_aws_service_api_vm_details_get(self):\\n pass\",\n \"def _write_log(kubectl: KubectlInterface, pod: KubernetesResource, tail: int, output_dir: Text,\\n noparse: bool = False) -> Optional[List[Tuple[Optional[Text], Text]]]:\\n # if this pod is not a SAS-provided resource, skip it\\n if not pod.is_sas_resource():\\n return\\n\\n # get the containerStatuses for this pod\\n container_statuses: List[Dict] = pod.get_status_value(KubernetesResource.Keys.CONTAINER_STATUSES)\\n\\n # create list of tuples to hold information about failed containers/pods\\n err_info: List[Tuple[Optional[Text], Text]] = list()\\n\\n if not container_statuses:\\n err_info.append((None, pod.get_name()))\\n return err_info\\n\\n # for each container status in the list, gather status and print values and log into file\\n for container_status_dict in container_statuses:\\n # create object to get container status values\\n container_status = _ContainerStatus(container_status_dict)\\n\\n # build the output file name\\n # if there is only one container, only include the pod name in the log file name\\n if len(container_statuses) == 1:\\n output_file_path = f\\\"{output_dir}{os.sep}{pod.get_name()}.log\\\"\\n # if there is more than one container, include both the pod and container name in the log file name\\n else:\\n output_file_path = f\\\"{output_dir}{os.sep}{pod.get_name()}_{container_status.get_name()}.log\\\"\\n\\n # open the output file for writing\\n with open(output_file_path, \\\"w\\\", encoding=\\\"utf-8\\\") as output_file:\\n # template for a line in the log header\\n header_tmpl = \\\"# {:<25} {}\\\\n\\\"\\n\\n # write status information at the top of the log\\n output_file.write((\\\"#\\\" * 50) + \\\"\\\\n\\\")\\n output_file.write(\\\"# Container Status\\\\n\\\")\\n output_file.write(\\\"#\\\\n\\\")\\n output_file.writelines(header_tmpl.format(\\\"sas-component-name:\\\", pod.get_sas_component_name()))\\n output_file.writelines(header_tmpl.format(\\\"sas-component-version:\\\",\\n pod.get_sas_component_version()))\\n for key, value in container_status.get_headers_dict().items():\\n output_file.writelines(header_tmpl.format(f\\\"{key}:\\\", value))\\n\\n # close the status header\\n output_file.writelines((\\\"#\\\" * 50) + \\\"\\\\n\\\\n\\\")\\n\\n # call kubectl to get the log for this container\\n log: List[AnyStr] = list()\\n try:\\n log = kubectl.logs(pod_name=pod.get_name(), container_name=container_status.get_name(),\\n prefix=False, tail=tail)\\n except CalledProcessError as container_err:\\n # container log has error, we'll retrieve log from initContainers\\n # add log from previous container call\\n\\n # add anything returned in the raised error\\n if container_err.stdout:\\n log += str(container_err.stdout.decode()).splitlines()\\n\\n if container_err.stderr:\\n log += str(container_err.stderr.decode()).splitlines()\\n\\n initcontainers: Optional[List[Dict]] = pod.get_spec_value(KubernetesResource.Keys.INIT_CONTAINERS)\\n if initcontainers:\\n for initcontainer in initcontainers:\\n container_name: Optional[Text] = initcontainer.get(\\\"name\\\")\\n log += [\\\"\\\\n\\\" + \\\"#\\\" * 50] + [f\\\"# Log from initContainer: {container_name}\\\"] + [\\\"#\\\" * 50]\\n try:\\n log += kubectl.logs(pod_name=pod.get_name(), container_name=container_name,\\n prefix=False, tail=tail)\\n except CalledProcessError as initcontainer_err:\\n # add anything returned in the raised error\\n if initcontainer_err.stdout:\\n log += str(initcontainer_err.stdout.decode()).splitlines()\\n\\n if initcontainer_err.stderr:\\n log += str(initcontainer_err.stderr.decode()).splitlines()\\n\\n err_msg = (f\\\"ERROR: A log could not be retrieved for the container \\\"\\n f\\\"[{container_status.get_name()}] \\\"\\n f\\\"in pod [{pod.get_name()}] in namespace [{kubectl.get_namespace()}]\\\")\\n err_info.append((container_status.get_name(), pod.get_name()))\\n log += [err_msg]\\n\\n # parse any structured logging\\n if noparse:\\n output_file.write(\\\"\\\\n\\\".join(log))\\n else:\\n file_content = SASStructuredLoggingParser.parse_log(log)\\n # write the retrieved log to the file\\n output_file.write(\\\"Beginning log...\\\\n\\\\n\\\")\\n output_file.write(\\\"\\\\n\\\".join(file_content))\\n\\n return err_info\",\n \"def test_show_vcs_resources(mgmt_session):\\n vcs_resource = rift.vcs.vcs.VcsResource(mgmt_session)\\n vcs_resource_info = None\\n\\n # Get vcs resources\\n vcs_resource_info = vcs_resource.get_vcs_resource()\\n\\n # Verify there are VM entries in the vcs resource info container\\n vms = [vm for vm in vcs_resource_info.vm]\\n if len(vms) == 0:\\n raise AssertionError(\\\"No entries found in vcs resource info\\\")\",\n \"def vprint(msg):\\n if defaults.verbose:\\n print(msg)\",\n \"def collect_cluster_info(output_dir, k8s_cli):\\n collect_helper(output_dir, cmd=\\\"{} cluster-info\\\".format(k8s_cli),\\n file_name=\\\"cluster_info\\\", resource_name=\\\"cluster-info\\\")\",\n \"def _vprint(self, string):\\n if self.verbose:\\n print(string)\",\n \"def print_properties(props):\\n if props and props.provisioning_state:\\n print(\\\"\\\\tProperties:\\\")\\n print(\\\"\\\\t\\\\tProvisioning State: {}\\\".format(props.provisioning_state))\",\n \"def print_properties(props):\\n if props and hasattr(props, 'provisioning_state'):\\n print(\\\"\\\\tProperties:\\\")\\n print(\\\"\\\\t\\\\tProvisioning State: {}\\\".format(props.provisioning_state))\\n print(\\\"\\\\n\\\\n\\\")\",\n \"def get_details(self):\\n status = []\\n for key, container in self.containers.items():\\n container.details = container.daemon.connection.inspect_container(self.config['release_name'])\\n status.append(container.details)\\n return status\",\n \"def print_properties(props):\\n if props and props.provisioning_state:\\n print(\\\"\\\\tProperties:\\\")\\n print(\\\"\\\\t\\\\tProvisioning State: {}\\\".format(props.provisioning_state))\\n print(\\\"\\\\n\\\\n\\\")\",\n \"def ovs_vswitchd(self, event):\\n ret = self.get_results_stats(event.results, key_by_date=False)\\n if ret:\\n return {'ovs-vswitchd': ret}, 'logs'\",\n \"def print_info(self):\\n\\t\\t\\n\\t\\tweighted_snapshots = np.sqrt(self.weights)*self.snapshots.T\\n\\t\\teigenvectors,eigenvalues,__ = np.linalg.svd(weighted_snapshots.T, full_matrices=False)\\n\\t\\tself.pod_basis = np.transpose(np.power(self.weights,-0.5)*eigenvectors.T)\\n\\t\\t\\n\\t\\tself.cvt_handler = cvt.Cvt(self.mu_values, self.snapshots, self.pod_basis, self.weights)\\n\\t\\tself.cvt_handler.add_new_point()\\n\\t\\t\\t\\n\\t\\tprint ('Maximum error on the tassellation: ' + str(self.cvt_handler.max_error))\\n\\t\\tprint ('New baricentric parameter value added to the triangulation ' + str(self.cvt_handler.mu_values[:,-1]) + '\\\\n')\",\n \"def host_info(vm_hostname):\\n with _get_vm(vm_hostname) as vm:\\n\\n if vm.dataset_obj['datacenter_type'] != 'kvm.dct':\\n raise NotImplementedError(\\n 'This operation is not yet supported for {}'.format(\\n vm.dataset_obj['datacenter_type'])\\n )\\n\\n info = vm.info()\\n\\n # Disconnect fabric now to avoid messages after the table\\n disconnect_all()\\n\\n categories = (\\n ('General', (\\n 'hypervisor',\\n 'status',\\n )),\\n ('Network', (\\n 'intern_ip',\\n 'mac_address',\\n )),\\n ('Resources', (\\n 'num_cpu',\\n 'max_cpus',\\n 'memory',\\n 'memory_free',\\n 'max_mem',\\n 'disk',\\n 'disk_size_gib',\\n 'disk_free_gib',\\n )),\\n # Anything else will appear in this section\\n ('Other', None),\\n )\\n\\n def _progress_bar(free_key, capacity_key, result_key, unit):\\n \\\"\\\"\\\"Helper to show nice progress bars.\\\"\\\"\\\"\\n if free_key not in info or capacity_key not in info:\\n return\\n free = info[free_key]\\n del info[free_key]\\n capacity = info[capacity_key]\\n del info[capacity_key]\\n\\n simple_stats = (\\n 'Current: {} {unit}\\\\n'\\n 'Free: {} {unit}\\\\n'\\n 'Max: {} {unit}'.format(\\n capacity - free, free, capacity, unit=unit))\\n\\n if not 0 <= free <= capacity > 0:\\n log.warning(\\n '{} ({}) and {} ({}) have weird ratio, skipping progress '\\n 'calculation'.format(\\n free_key, free, capacity_key, capacity)\\n )\\n info[result_key] = red(simple_stats)\\n return\\n\\n assert 0 <= free <= capacity\\n ratio = 1 - float(free) / float(capacity)\\n if ratio >= 0.9:\\n color = red\\n elif ratio >= 0.8:\\n color = yellow\\n else:\\n color = green\\n\\n max_bars = 20\\n num_bars = int(round(ratio * max_bars))\\n info[result_key] = (\\n '[{}{}] {}%\\\\n{}'.format(\\n color('#' * num_bars), ' ' * (max_bars - num_bars),\\n int(round(ratio * 100)),\\n simple_stats,\\n )\\n )\\n\\n _progress_bar('memory_free', 'memory', 'memory', 'MiB')\\n _progress_bar('disk_free_gib', 'disk_size_gib', 'disk', 'GiB')\\n\\n max_key_len = max(len(k) for k in info.keys())\\n for category, keys in categories:\\n # Handle 'Other' section by defaulting to all keys\\n keys = list(keys or info.keys())\\n\\n # Any info available for the category?\\n if not any(k in info for k in keys):\\n continue\\n\\n print('')\\n print(white(category, bold=True))\\n for k in keys:\\n if k not in info:\\n continue\\n\\n # Properly re-indent multiline values\\n value = str(info.pop(k))\\n value = ('\\\\n' + ' ' * (max_key_len + 3)).join(\\n value.splitlines()\\n )\\n print('{} : {}'.format(k.ljust(max_key_len), value))\",\n \"def getContainerInitLog(self,node,vmid):\\n data = self.connect('get','nodes/%s/lxc/%s/initlog' % (node,vmid),None)\\n return data\",\n \"def main():\\n pods = openshift_object.get_running_pods()\\n me = openshift_object.get_self()\\n routes = openshift_object.get_routes()\\n nodes = openshift_object.get_nodes()\\n pvc = openshift_object.get_pvcs()\\n pv = openshift_object.get_pv()\\n project = openshift_object.get_projects()\\n return jsonify({\\n \\\"pods\\\": pods,\\n \\\"me\\\": me,\\n \\\"routes\\\": routes, \\n \\\"nodes\\\":nodes,\\n \\\"pvcs\\\":pvc,\\n \\\"pv\\\":pv,\\n \\\"projects\\\":project})\",\n \"def vprint(string):\\n global verbose\\n if verbose:\\n print(string)\",\n \"def delete_pvc(pvc_name, created_objects):\\r\\n\\r\\n api_instance = client.CoreV1Api()\\r\\n try:\\r\\n api_response = api_instance.read_namespaced_persistent_volume_claim(\\r\\n name=pvc_name, namespace=namespace_value, pretty=True)\\r\\n LOGGER.debug(str(api_response))\\r\\n except ApiException as e:\\r\\n LOGGER.error(\\r\\n f\\\"Exception when calling CoreV1Api->read_namespaced_persistent_volume_claim: {e}\\\")\\r\\n LOGGER.error(f\\\"PVC {pvc_name} does not exists on the cluster\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\\r\\n\\r\\n volume_name = api_response.spec.volume_name\\r\\n\\r\\n if keep_objects:\\r\\n return volume_name\\r\\n\\r\\n api_instance = client.CoreV1Api()\\r\\n try:\\r\\n LOGGER.info(f'PVC Delete : Deleting pvc {pvc_name}')\\r\\n api_response = api_instance.delete_namespaced_persistent_volume_claim(\\r\\n name=pvc_name, namespace=namespace_value, pretty=True, grace_period_seconds=0)\\r\\n LOGGER.debug(str(api_response))\\r\\n if pvc_name[0:12] == \\\"restored-pvc\\\":\\r\\n created_objects[\\\"restore_pvc\\\"].remove(pvc_name)\\r\\n else:\\r\\n created_objects[\\\"pvc\\\"].remove(pvc_name)\\r\\n return volume_name\\r\\n except ApiException as e:\\r\\n LOGGER.error(\\r\\n f\\\"Exception when calling CoreV1Api->delete_namespaced_persistent_volume_claim: {e}\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def get_volumes(patient, pet_folder, struct_folders, number, volumes, plot_data=False):\\n print(\\\"--------------------------------------------------------------------------------------\\\")\\n print(\\\"Patient {:02d}: {}\\\".format(number, patient))\\n # get all dicom image's paths\\n dicom_images = [pet_folder+\\\"/\\\"+f for f in os.listdir(pet_folder) if f.lower().endswith(\\\".dcm\\\")]\\n dicom_images.sort()\\n # get information from dicom header\\n dicom_info = dicom.read_file(dicom_images[0])\\n pixel_shape = (int(dicom_info.Rows), int(dicom_info.Columns), int(dicom_info.NumberOfSlices))\\n pixel_spacing = (float(dicom_info.PixelSpacing[0]), float(dicom_info.PixelSpacing[1]),\\n float(dicom_info.SliceThickness))\\n print(\\\" Pixel spacing: {}\\\".format(pixel_spacing))\\n # create 3D array for pet image\\n pet_image = np.zeros(pixel_shape, dtype=dicom_info.pixel_array.dtype)\\n for i, dicom_img in enumerate(dicom_images):\\n ds = dicom.read_file(dicom_img)\\n pet_image[:, :, i] = ds.pixel_array\\n # create contours structure\\n mtv_variables = []\\n for struct_folder in struct_folders:\\n # extract contours labels and index from lvol.txt\\n lvoltxt_file = struct_folder + \\\"/lvol.txt\\\"\\n with open(lvoltxt_file) as f:\\n lines = f.readlines()\\n for i, line in enumerate(lines):\\n if (\\\"mtv\\\" in line.lower() and (\\\"cervix\\\" in line.lower() or \\\"tumor\\\" in line.lower()) and\\n \\\"nodal\\\" not in line.lower() and \\\"nodes\\\" not in line.lower() and\\n \\\"ring\\\" not in line.lower() and \\\"opt\\\" not in line.lower()):\\n struct = line.strip().split(\\\"|\\\")\\n mtv_variables.append((int(struct[0]), struct[-1], struct_folder))\\n # return nothing if no mtv contours were found\\n if len(mtv_variables) == 0:\\n return [], volumes, []\\n # add contours to original image and plot it\\n prev_folder = None\\n patient_volumes = [pet_image]\\n print(\\\" Possible MTV contours:\\\")\\n for mtv_idx, mtv_label, mtv_folder in mtv_variables:\\n # read and transform data from nii file\\n if prev_folder != mtv_folder:\\n # only read mtv_folder if it has changed\\n nii_obj = nib.load(mtv_folder + \\\"/lvol.nii\\\")\\n nii_data = nii_obj.get_data()\\n volume = np.zeros(nii_data.shape[:3], dtype=int)\\n for i in range(nii_data.shape[-1]):\\n volume += nii_data[:, :, :, 0, i] << (8 * i)\\n volume = np.swapaxes(volume, 0, 1)\\n volume = np.flip(volume, 2)\\n print(\\\" * Structures folder: {}\\\".format(mtv_folder.split(\\\"/\\\")[-1]))\\n print(\\\" MTV_index:\\\", mtv_idx)\\n print(\\\" MTV_label:\\\", mtv_label.split(\\\"/\\\")[-1])\\n prev_folder = mtv_folder\\n # create 3D matrix with 1s where ROI is and 0s everwhere else\\n try:\\n tumor_volume = (np.bitwise_and(volume, 2 ** mtv_idx) > 0) * 1\\n except TypeError:\\n print(\\\"Error while reading volume for index: {}, label: {}!\\\".format(mtv_idx,\\n mtv_label))\\n patient_volumes.append(())\\n continue\\n # find bounding box for volume\\n mask_range = [[pixel_shape[0], pixel_shape[1], pixel_shape[2]], [-1, -1, -1]]\\n tumor_exists = False\\n for xx in range(pixel_shape[0]):\\n for yy in range(pixel_shape[1]):\\n for zz in range(pixel_shape[2]):\\n if tumor_volume[xx, yy, zz]:\\n tumor_exists = True\\n mask_range[0][0] = min(mask_range[0][0], xx)\\n mask_range[0][1] = min(mask_range[0][1], yy)\\n mask_range[0][2] = min(mask_range[0][2], zz)\\n mask_range[1][0] = max(mask_range[1][0], xx)\\n mask_range[1][1] = max(mask_range[1][1], yy)\\n mask_range[1][2] = max(mask_range[1][2], zz)\\n # continue if the mask is all 0s\\n if not tumor_exists:\\n print(\\\"Volume not found for index: {}, label: {}!\\\".format(mtv_idx, mtv_label))\\n patient_volumes.append(())\\n continue\\n # Get ROI\\n current_volume = pet_image[mask_range[0][0]:mask_range[1][0]+1,\\n mask_range[0][1]:mask_range[1][1]+1,\\n mask_range[0][2]:mask_range[1][2]+1]\\n current_mask = tumor_volume[mask_range[0][0]:mask_range[1][0]+1,\\n mask_range[0][1]:mask_range[1][1]+1,\\n mask_range[0][2]:mask_range[1][2]+1]\\n # Add volumes to patient_volumes\\n patient_volumes.append((current_mask, mtv_label, mask_range, mtv_folder))\\n # Plot volumes\\n if plot_data:\\n plot_pet_medians(pet_image, pixel_spacing, mask=tumor_volume, median=0, fig_num=0,\\n patient=patient, mask_name=mtv_label.split(\\\"/\\\")[-1])\\n plot_pet_medians(pet_image, pixel_spacing, mask=tumor_volume, median=1, fig_num=1,\\n patient=patient, mask_name=mtv_label.split(\\\"/\\\")[-1])\\n plot_pet_medians(pet_image, pixel_spacing, mask=tumor_volume, median=2, fig_num=2,\\n patient=patient, mask_name=mtv_label.split(\\\"/\\\")[-1])\\n input(\\\"press ENTER to continue... \\\")\\n plot_pet_volume(current_volume, pixel_shape, pixel_spacing, mask=current_mask,\\n patient=patient, mask_name=mtv_label.split(\\\"/\\\")[-1])\\n volumes[patient] = patient_volumes\\n return mtv_variables, volumes, pixel_spacing\",\n \"def delete_finalizers(k8s_ctx: str, dry_run: bool = False):\\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\\n for storage_obj in run_commands([cmd], dry_run):\\n cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '\\n cmd += '{\\\"metadata\\\":{\\\"finalizers\\\":null}}'\\n logging.debug(cmd)\\n if dry_run:\\n logging.debug(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n logging.debug(p.stdout.decode().rstrip())\",\n \"def get_vpc_gcp_info_output(instance_id: Optional[pulumi.Input[Optional[int]]] = None,\\n vpc_id: Optional[pulumi.Input[Optional[str]]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetVpcGcpInfoResult]:\\n ...\",\n \"def debug(self):\\n try:\\n super(FaucetTopoTestBase, self).debug()\\n except Exception:\\n pprint.pprint(self.host_information)\\n raise\",\n \"def test_read_namespaced_deployment_log_log(self):\\n pass\",\n \"def test_showWithCustomerTag(self):\\n expectedOut = [r\\\"ID\\\\s*NAME\\\\s*STATUS\\\\s*SEVERITY\\\"]\\n allAlerts = util.allAlerts\\n # Only this alert has both tags.\\n expectedAlerts = [util.Alert.kubernetesSkynetTag]\\n for r in expectedAlerts:\\n expectedOut.append(\\n util.SummaryLineProcessor.expectedAlertSummaryLineRegex(r))\\n self.summaryRsrcs(\\\"alert\\\",\\n allAlerts,\\n expectedOut,\\n rsrcAdditionalParams=[\\n \\\"--customerTag\\\", \\\"kubernetes\\\",\\n \\\"--customerTag\\\", \\\"skynet\\\"])\\n\\n expectedOut = [r\\\"ID\\\\s*NAME\\\\s*DESCRIPTION\\\"]\\n allDashboards = util.allDashboards\\n # Only this dashboard has both tags.\\n expectedDashboards = [util.Dashboard.skynetApplier]\\n for r in expectedDashboards:\\n expectedOut.append(\\n util.SummaryLineProcessor.expectedDashboardSummaryLineRegex(r))\\n self.summaryRsrcs(\\\"dashboard\\\",\\n allDashboards,\\n expectedOut,\\n rsrcAdditionalParams=[\\n \\\"--customerTag\\\", \\\"kubernetes\\\",\\n \\\"--customerTag\\\", \\\"skynet\\\"])\",\n \"def print_cluster_properties(redshift_client):\\n cluster_properties = get_cluster_properties(redshift_client)\\n print('HOST: %s' % cluster_properties['Endpoint']['Address'])\\n property_keys = [\\n 'ClusterIdentifier', 'NodeType', 'ClusterStatus', 'MasterUsername',\\n 'DBName', 'Endpoint', 'NumberOfNodes', 'VpcId'\\n ]\\n property_tuples = [\\n (k, v) for k, v in cluster_properties.items() if k in property_keys\\n ]\\n dfshow = pd.DataFrame(data=property_tuples, columns=['Key', 'Value'])\\n print(dfshow)\",\n \"def printPCAresults(pc_ana, param_list, print_components=False):\\n print(f'explained variance ratio '\\n f'({pc_ana.components_.shape[0]} components): '\\n f'{sum(pc_ana.explained_variance_ratio_):2.2f} '\\n f'({pc_ana.explained_variance_ratio_.round(2)})')\\n if print_components:\\n for j, principal_component in enumerate(pc_ana.components_):\\n print(f'Principal component {j+1}')\\n for idx, lbl in enumerate(param_list):\\n print(f'{principal_component[idx]: 2.4f} * {lbl}')\\n print()\",\n \"def kubectl(self, *args: str, **kwargs) -> str:\\n return KindClusterUpstream.kubectl(self, *args, **kwargs)\",\n \"def main():\\n # pylint: disable-msg=too-many-locals\\n # pylint: disable-msg=too-many-branches\\n # pylint: disable-msg=too-many-statements\\n # pylint: disable-msg=too-many-return-statements\\n # pylint: disable-msg=broad-except\\n\\n # Components Schemas\\n # The 'kubernetes' service in service-parameter has a section per k8s\\n # component to manage its configurations. Only the 'extraVolumes' parameters\\n # are saved in a different section (check available sections in module\\n # description)\\n # The kubeadm command (used to update components), however, expects a\\n # configuration file with a different structure per component. Each component\\n # has also different sections, for example: root, extraArgs, etc.\\n # Therefore, these schemas are created to map the (sysinv) service parameters\\n # kubernetes sections to the expected structure.\\n apiserver_schema = {\\n 'root': {\\n 'timeoutForControlPlane': 'timeoutForControlPlane'\\n },\\n 'extraArgs': {\\n 'oidc_issuer_url': 'oidc-issuer-url',\\n 'oidc_client_id': 'oidc-client-id',\\n 'oidc_username_claim': 'oidc-username-claim',\\n 'oidc_groups_claim': 'oidc-groups-claim',\\n 'admission_plugins': 'enable-admission-plugins',\\n },\\n 'extraVolumes': {},\\n }\\n\\n controller_manager_schema = {\\n 'root': {},\\n }\\n\\n scheduler_schema = {\\n 'root': {},\\n }\\n\\n kubelet_schema = {\\n 'root': {},\\n }\\n\\n etcd_schema = {\\n 'root': {},\\n 'external': {\\n 'etcd_cafile': 'caFile',\\n 'etcd_certfile': 'certFile',\\n 'etcd_keyfile': 'keyFile',\\n 'etcd_servers': 'endpoints'\\n }\\n }\\n\\n # Args Parameters\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--hieradata_path\\\", default=\\\"/tmp/puppet/hieradata\\\")\\n parser.add_argument(\\\"--hieradata_file\\\", default=\\\"system.yaml\\\")\\n parser.add_argument(\\\"--backup_path\\\", default=\\\"/etc/kubernetes/backup\\\")\\n parser.add_argument(\\\"--kubeadm_cm_file\\\", default=\\\"/tmp/cluster_configmap.yaml\\\")\\n parser.add_argument(\\\"--kubeadm_cm_bak_file\\\", default=\\\"configmap.yaml\\\")\\n parser.add_argument(\\\"--configmap_patched_file\\\",\\n default=\\\"/tmp/cluster_configmap_patched.yaml\\\")\\n parser.add_argument(\\\"--cluster_config_file\\\", default=\\\"/tmp/cluster_config.yaml\\\")\\n parser.add_argument(\\\"--cluster_config_bak_file\\\", default=\\\"cluster_config.yaml\\\")\\n parser.add_argument(\\\"--kubeadm_kubelet_config_file\\\", default=\\\"/tmp/kubeadm_kubelet_config.yaml\\\")\\n parser.add_argument(\\\"--kubeadm_kubelet_config_bak_file\\\",\\n default=\\\"/etc/kubernetes/backup/kubeadm_kubelet_config.yaml\\\")\\n parser.add_argument(\\\"--kubelet_latest_config_file\\\", default=\\\"/var/lib/kubelet/config.yaml\\\")\\n parser.add_argument(\\\"--kubelet_bak_config_file\\\", default=\\\"/var/lib/kubelet/config.yaml.bak\\\")\\n parser.add_argument(\\\"--kubelet_error_log\\\", default=\\\"/tmp/kubelet_errors.log\\\")\\n parser.add_argument(\\\"--k8s_configmaps_init_flag\\\", default=\\\"/tmp/.sysinv_k8s_configmaps_initialized\\\")\\n\\n parser.add_argument(\\\"--automatic_recovery\\\", default=True)\\n parser.add_argument(\\\"--timeout\\\", default=RECOVERY_TIMEOUT)\\n parser.add_argument(\\\"--tries\\\", default=RECOVERY_TRIES)\\n parser.add_argument(\\\"--try_sleep\\\", default=RECOVERY_TRY_SLEEP)\\n\\n parser.add_argument(\\\"--etcd_cafile\\\", default='')\\n parser.add_argument(\\\"--etcd_certfile\\\", default='')\\n parser.add_argument(\\\"--etcd_keyfile\\\", default='')\\n parser.add_argument(\\\"--etcd_servers\\\", default='')\\n args = parser.parse_args()\\n\\n hieradata_file = os.path.join(args.hieradata_path, args.hieradata_file)\\n kubeadm_cm_file = args.kubeadm_cm_file\\n kubeadm_cm_bak_file = os.path.join(args.backup_path, args.kubeadm_cm_bak_file)\\n cluster_config_file = args.cluster_config_file\\n cluster_config_bak_file = os.path.join(args.backup_path, args.cluster_config_bak_file)\\n configmap_patched_file = args.configmap_patched_file\\n\\n kubeadm_kubelet_config_file = args.kubeadm_kubelet_config_file\\n kubeadm_kubelet_config_bak_file = args.kubeadm_kubelet_config_bak_file\\n kubelet_latest_config_file = args.kubelet_latest_config_file\\n kubelet_bak_config_file = args.kubelet_bak_config_file\\n kubelet_error_log = args.kubelet_error_log\\n k8s_configmaps_init_flag = args.k8s_configmaps_init_flag\\n\\n automatic_recovery = args.automatic_recovery\\n timeout = args.timeout\\n tries = args.tries\\n try_sleep = args.try_sleep\\n\\n etcd_cafile = args.etcd_cafile\\n etcd_certfile = args.etcd_certfile\\n etcd_keyfile = args.etcd_keyfile\\n etcd_servers = args.etcd_servers\\n\\n rc = 2\\n\\n # -----------------------------------------------------------------------------\\n # Backup k8s cluster and kubelet configuration\\n # -----------------------------------------------------------------------------\\n # This flag will avoid any error when you try to run this script manually\\n # and kube-apiserver is down.\\n is_k8s_apiserver_up = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=APISERVER_READYZ_ENDPOINT)\\n\\n # K8s control-plane backup config files\\n if not os.path.isfile(kubeadm_cm_bak_file) or\\\\\\n not os.path.isfile(cluster_config_bak_file):\\n LOG.debug(\\\"No backup files founded for K8s control-plane components.\\\")\\n if is_k8s_apiserver_up:\\n LOG.debug(\\\"Creating backup from current k8s config.\\\")\\n export_k8s_kubeadm_configmap(kubeadm_cm_bak_file)\\n export_k8s_cluster_configuration(cluster_config_bak_file)\\n else:\\n msg = \\\"Apiserver is down and there is not backup file.\\\"\\n LOG.error(msg)\\n return 2\\n\\n # Kubeadm with Kubelet backup config file\\n if not os.path.isfile(kubeadm_kubelet_config_bak_file):\\n LOG.debug(\\\"No backup file founded for Kubelet.\\\")\\n try:\\n shutil.copyfile(kubelet_latest_config_file, kubelet_bak_config_file)\\n except Exception as e:\\n LOG.error('Creating kubelet bak config file. %s', e)\\n return 3\\n if generates_kubeadm_config_file(\\n kubeadm_config_file=kubeadm_kubelet_config_bak_file,\\n kubelet_bak_config_file=kubelet_bak_config_file) != 0:\\n return 3\\n\\n # -----------------------------------------------------------------------------\\n # Initialize k8s configmaps\\n # -----------------------------------------------------------------------------\\n if not os.path.isfile(k8s_configmaps_init_flag):\\n initialize_k8s_configmaps(\\n hieradata_file, k8s_configmaps_init_flag,\\n apiserver_schema, controller_manager_schema,\\n scheduler_schema, kubelet_schema, etcd_schema)\\n\\n # -----------------------------------------------------------------------------\\n # Load current applied k8s cluster configuration\\n # -----------------------------------------------------------------------------\\n LOG.debug('Exporting current config to file.')\\n if export_k8s_kubeadm_configmap(kubeadm_cm_file) != 0:\\n LOG.debug(\\\"k8s is not running, copy configmap backup file\\\")\\n cmd = [\\\"cp\\\", kubeadm_cm_bak_file, kubeadm_cm_file]\\n\\n if _exec_cmd(cmd) != 0:\\n msg = \\\"Fail copying configmap backup file.\\\"\\n LOG.error(msg)\\n return 3\\n\\n try:\\n LOG.debug('Loading current config from file.')\\n with open(kubeadm_cm_file, 'r') as file:\\n kubeadm_cfg = yaml.load(file, Loader=yaml.RoundTripLoader)\\n cluster_cfg = yaml.load(\\n kubeadm_cfg['data']['ClusterConfiguration'], Loader=yaml.RoundTripLoader)\\n except Exception as e:\\n msg = str('Loading configmap from file. {}'.format(e))\\n LOG.error(msg)\\n return 3\\n\\n # -----------------------------------------------------------------------------\\n # Pre updating tasks\\n # -----------------------------------------------------------------------------\\n # Run mandatory tasks before the update proccess starts\\n if pre_k8s_updating_tasks(post_k8s_tasks, parameters_to_preserve) != 0:\\n LOG.error('Running pre updating tasks.')\\n return 3\\n\\n # -----------------------------------------------------------------------------\\n # Load k8s service-parameters from hieradata\\n # (updated by user through sysinv > service-parameter)\\n # -----------------------------------------------------------------------------\\n service_params = get_service_parameters_from_hieradata(\\n hieradata_file, apiserver_schema, controller_manager_schema,\\n scheduler_schema, kubelet_schema, etcd_schema)\\n\\n # -----------------------------------------------------------------------------\\n # Building cluster_cfg from service-parameters/hieradata\\n # The current (preloaded) cluster configuration is taken as base.\\n # New cluster config from hieradata overrides pre existing values.\\n # -----------------------------------------------------------------------------\\n # Config section --------------------------------------------------------------\\n if 'automatic_recovery' in service_params['config'].keys():\\n # this value is set by sysinv, and its values are 'true' or 'false'\\n value = service_params['config']['automatic_recovery']\\n automatic_recovery = value == 'true'\\n\\n if 'timeout' in service_params['config'].keys():\\n timeout = int(service_params['config']['timeout'])\\n\\n if 'tries' in service_params['config'].keys():\\n tries = int(service_params['config']['tries'])\\n\\n if 'try_sleep' in service_params['config'].keys():\\n try_sleep = int(service_params['config']['try_sleep'])\\n\\n # kube-apiserver section ------------------------------------------------------\\n for param, value in service_params['apiServer'].items():\\n if param in apiserver_schema['root'].keys():\\n cluster_cfg['apiServer'][param] = value\\n else:\\n # By default all not known params will be placed in\\n # section 'extraArgs'\\n if 'extraArgs' not in cluster_cfg['apiServer'].keys():\\n cluster_cfg['apiServer']['extraArgs'] = {}\\n if param == 'enable-admission-plugins':\\n value = _validate_admission_plugins(value)\\n cluster_cfg['apiServer']['extraArgs'][param] = value\\n else:\\n cluster_cfg['apiServer']['extraArgs'][param] = value\\n\\n # remove all parameters in 'extraArgs' not present in service-parameter.\\n if 'extraArgs' in cluster_cfg['apiServer'].keys():\\n for param in list(cluster_cfg['apiServer']['extraArgs'].keys()):\\n if param not in service_params['apiServer']:\\n cluster_cfg['apiServer']['extraArgs'].pop(param)\\n\\n # add/replace parameters from last valid k8s manifests that are required\\n # not to be modified during the upgrade process\\n for param, value in parameters_to_preserve.items():\\n cluster_cfg['apiServer']['extraArgs'][param] = value\\n\\n # apiserver_volumes section\\n if cluster_cfg['apiServer'] and 'extraVolumes' in cluster_cfg['apiServer']:\\n cluster_cfg['apiServer'].pop('extraVolumes')\\n for param, value in service_params['apiServerVolumes'].items():\\n if 'extraVolumes' not in cluster_cfg['apiServer'].keys():\\n cluster_cfg['apiServer']['extraVolumes'] = []\\n volume_dict, _ = sp.parse_volume_string_to_dict({'name': param, 'value': value})\\n cluster_cfg['apiServer']['extraVolumes'].append(volume_dict)\\n if export_configmap_from_volume(volume_dict, 'kube_apiserver_volumes') != 0:\\n LOG.error('Exporting configmap from volume: %s', str(volume_dict))\\n return 3\\n\\n # controller manager section --------------------------------------------------\\n for param, value in service_params['controllerManager'].items():\\n if param in controller_manager_schema['root'].keys():\\n cluster_cfg['controllerManager'][param] = value\\n else:\\n # By default all not known params will be place in\\n # section 'extraArgs'\\n if 'extraArgs' not in cluster_cfg['controllerManager'].keys():\\n cluster_cfg['controllerManager']['extraArgs'] = {}\\n cluster_cfg['controllerManager']['extraArgs'][param] = value\\n\\n # remove all parameters in 'extraArgs' not present in service-parameter.\\n if 'extraArgs' in cluster_cfg['controllerManager'].keys():\\n for param in list(cluster_cfg['controllerManager']['extraArgs'].keys()):\\n if param not in service_params['controllerManager']:\\n cluster_cfg['controllerManager']['extraArgs'].pop(param)\\n\\n # controller_manager_volumes section\\n if cluster_cfg['controllerManager'] and 'extraVolumes' in cluster_cfg['controllerManager']:\\n cluster_cfg['controllerManager'].pop('extraVolumes')\\n for param, value in service_params['controllerManagerVolumes'].items():\\n if 'extraVolumes' not in cluster_cfg['controllerManager'].keys():\\n cluster_cfg['controllerManager']['extraVolumes'] = []\\n volume_dict, _ = sp.parse_volume_string_to_dict({'name': param, 'value': value})\\n cluster_cfg['controllerManager']['extraVolumes'].append(volume_dict)\\n if export_configmap_from_volume(volume_dict, 'kube_controller_manager_volumes') != 0:\\n LOG.error('Exporting configmap from volume: %s', str(volume_dict))\\n return 3\\n\\n # scheduler section -----------------------------------------------------------\\n for param, value in service_params['scheduler'].items():\\n if param in scheduler_schema['root'].keys():\\n cluster_cfg['scheduler'][param] = value\\n else:\\n # By default all not known params will be place in\\n # section 'extraArgs'\\n if 'extraArgs' not in cluster_cfg['scheduler'].keys():\\n cluster_cfg['scheduler']['extraArgs'] = {}\\n cluster_cfg['scheduler']['extraArgs'][param] = value\\n\\n # remove all parameters not present in service-parameter.\\n if 'extraArgs' in cluster_cfg['scheduler'].keys():\\n for param in list(cluster_cfg['scheduler']['extraArgs'].keys()):\\n if param not in service_params['scheduler']:\\n cluster_cfg['scheduler']['extraArgs'].pop(param)\\n\\n # scheduler_volumes section\\n if cluster_cfg['scheduler'] and 'extraVolumes' in cluster_cfg['scheduler']:\\n cluster_cfg['scheduler'].pop('extraVolumes')\\n for param, value in service_params['schedulerVolumes'].items():\\n if 'extraVolumes' not in cluster_cfg['scheduler'].keys():\\n cluster_cfg['scheduler']['extraVolumes'] = []\\n volume_dict, _ = sp.parse_volume_string_to_dict({'name': param, 'value': value})\\n cluster_cfg['scheduler']['extraVolumes'].append(volume_dict)\\n if export_configmap_from_volume(volume_dict, 'kube_scheduler_volumes') != 0:\\n LOG.error('Exporting configmap from volume: %s', str(volume_dict))\\n return 3\\n\\n # etcd section ----------------------------------------------------------------\\n for param, value in service_params['etcd'].items():\\n # Prioritize user-defined arguments, otherwise, the values are taken from hieradata.\\n value = etcd_cafile if param == 'caFile' and etcd_cafile else value\\n value = etcd_certfile if param == 'certFile' and etcd_certfile else value\\n value = etcd_keyfile if param == 'keyFile' and etcd_keyfile else value\\n value = etcd_servers if param == 'endpoints' and etcd_servers else value\\n\\n # By default all not known params will be place in section 'external'\\n if param in etcd_schema['root'].keys():\\n cluster_cfg['etcd'][param] = value\\n else:\\n # params saved like list (value should be separated by comma)\\n if param == 'endpoints':\\n cluster_cfg['etcd']['external'][param] = value.split(',')\\n # by default params are saved like strings\\n else:\\n cluster_cfg['etcd']['external'][param] = value\\n\\n # -----------------------------------------------------------------------------\\n # Patch kubeadm configmap\\n # -----------------------------------------------------------------------------\\n # Ensure the yaml is constructed with proper formatting and tabbing\\n cluster_cfg_str = yaml.dump(\\n cluster_cfg, Dumper=yaml.RoundTripDumper, default_flow_style=False)\\n cluster_cfg_str = yaml.scalarstring.PreservedScalarString(cluster_cfg_str)\\n kubeadm_cfg['data']['ClusterConfiguration'] = cluster_cfg_str\\n\\n # Save updated kubeadm-config into file\\n try:\\n with open(kubeadm_cm_file, 'w') as file:\\n yaml.dump(kubeadm_cfg, file, Dumper=yaml.RoundTripDumper,\\n default_flow_style=False)\\n except Exception as e:\\n LOG.error('Saving updated kubeadm-config into file. %s', e)\\n return 3\\n\\n # Patch kubeadm-config configmap with the updated configuration.\\n if patch_k8s_kubeadm_configmap(kubeadm_cm_file) != 0:\\n LOG.error('Patching kubeadm-config configmap.')\\n return 3\\n\\n # Export the updated k8s cluster configuration\\n if export_k8s_cluster_configuration(cluster_config_file) != 0:\\n LOG.error('Exportando k8s cluster configuration.')\\n return 3\\n\\n # -----------------------------------------------------------------------------\\n # Update k8s kube-apiserver\\n # -----------------------------------------------------------------------------\\n update_k8s_control_plane_components(\\n cluster_config_file, target_component='apiserver')\\n\\n # Wait for kube-apiserver to be up before executing next steps\\n is_k8s_apiserver_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=APISERVER_READYZ_ENDPOINT)\\n\\n # Check kube-apiserver health, then backup and restore\\n if automatic_recovery:\\n if not is_k8s_apiserver_healthy:\\n LOG.debug('kube-apiserver is not responding, intializing restore.')\\n restore_rc = restore_k8s_control_plane_config(\\n kubeadm_cm_bak_file, cluster_config_bak_file, configmap_patched_file,\\n tries=tries, try_sleep=try_sleep, timeout=timeout)\\n if restore_rc == 2:\\n LOG.error(\\\"kube-apiserver has failed to start using backup configuration.\\\")\\n return 2\\n if restore_rc == 1:\\n return 1\\n\\n # Run mandatory tasks after the update proccess has finished\\n post_k8s_updating_tasks(post_k8s_tasks)\\n\\n # -----------------------------------------------------------------------------\\n # Update k8s kube-controller-manager\\n # -----------------------------------------------------------------------------\\n update_k8s_control_plane_components(\\n cluster_config_file, target_component='controller-manager')\\n\\n # Wait for controller-manager to be up\\n is_k8s_component_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=CONTROLLER_MANAGER_HEALTHZ_ENDPOINT)\\n\\n # Check kube-controller-manager health, then backup and restore\\n if automatic_recovery:\\n if not is_k8s_component_healthy:\\n LOG.debug('kube-controller-manager is not responding, intializing restore.')\\n restore_rc = restore_k8s_control_plane_config(\\n kubeadm_cm_bak_file, cluster_config_bak_file, configmap_patched_file,\\n tries=tries, try_sleep=try_sleep, timeout=timeout)\\n\\n if restore_rc == 2:\\n msg = \\\"kube-controller-manager has failed to start \\\" +\\\\\\n \\\"using backup configuration.\\\"\\n LOG.error(msg)\\n return 2\\n if restore_rc == 1:\\n return 1\\n\\n # -----------------------------------------------------------------------------\\n # Update k8s kube-scheduler\\n # -----------------------------------------------------------------------------\\n update_k8s_control_plane_components(\\n cluster_config_file, target_component='scheduler')\\n\\n # Wait for scheduler to be up\\n LOG.debug('Waiting for kube-scheduler be online.')\\n is_k8s_component_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=SCHEDULER_HEALTHZ_ENDPOINT)\\n\\n # Check kube-scheduler health, then backup and restore\\n if automatic_recovery:\\n if not is_k8s_component_healthy:\\n LOG.debug('kube-scheduler is not responding, intializing restore.')\\n restore_rc = restore_k8s_control_plane_config(\\n kubeadm_cm_bak_file, cluster_config_bak_file, configmap_patched_file,\\n tries=tries, try_sleep=try_sleep, timeout=timeout)\\n if restore_rc == 2:\\n LOG.error(\\\"kube-scheduler has failed to start using backup configuration.\\\")\\n return 2\\n if restore_rc == 1:\\n return 1\\n\\n # -----------------------------------------------------------------------------\\n # Update Kubelet\\n # -----------------------------------------------------------------------------\\n LOG.debug('Starting the kubelet update')\\n\\n # Building kubelet_cfg from service-parameters (hieradata)\\n kubelet_cfg = get_kubelet_cfg_from_service_parameters(service_params)\\n\\n # Generates kubeadmin config file with KubeletConfiguration\\n rc = generates_kubeadm_config_file(\\n kubeadm_config_file=kubeadm_kubelet_config_file,\\n new_kubelet_cfg=kubelet_cfg,\\n kubelet_bak_config_file=kubelet_bak_config_file,\\n cluster_cfg=cluster_cfg)\\n if rc != 0:\\n return 3\\n\\n # Updating Kubelet\\n if update_k8s_kubelet(kubeadm_kubelet_config_file, kubelet_error_log) != 0:\\n is_k8s_component_healthy = False\\n else:\\n LOG.debug('Waiting for kubelet be online.')\\n is_k8s_component_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=KUBELET_HEALTHZ_ENDPOINT)\\n\\n if not is_k8s_component_healthy:\\n if not automatic_recovery:\\n LOG.debug('Automatic recovery not enabled, exiting...')\\n return 2\\n\\n # Restore Kubelet and Control-Plane (failure case)\\n msg = 'Kubelet is not responding or an error occurred, initializing restore.'\\n LOG.debug(msg)\\n kubelet_restore_rc = restore_k8s_kubelet_config(\\n kubeadm_kubelet_config_bak_file,\\n error_log_file=kubelet_error_log + '.autorecovery',\\n tries=tries, try_sleep=try_sleep, timeout=timeout)\\n\\n if kubelet_restore_rc == 1:\\n return 1\\n return 2\\n\\n # -----------------------------------------------------------------------------\\n # Update backup files with latest configuration\\n # -----------------------------------------------------------------------------\\n LOG.debug(\\\"Check all k8s control-plane components are up and running.\\\")\\n is_k8s_apiserver_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=APISERVER_READYZ_ENDPOINT)\\n is_k8s_controller_manager_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=CONTROLLER_MANAGER_HEALTHZ_ENDPOINT)\\n is_k8s_scheduler_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=SCHEDULER_HEALTHZ_ENDPOINT)\\n is_k8s_kubelet_healthy = k8s_health_check(\\n timeout=timeout, try_sleep=try_sleep, tries=tries,\\n healthz_endpoint=KUBELET_HEALTHZ_ENDPOINT)\\n\\n LOG.debug(\\\"Updating backup files with latest configuration ...\\\")\\n if is_k8s_apiserver_healthy and is_k8s_controller_manager_healthy and\\\\\\n is_k8s_scheduler_healthy and is_k8s_kubelet_healthy:\\n # Update kubelet configmap and backup config file\\n update_kubelet_bak_config_files(\\n kubeadm_kubelet_config_file, kubeadm_kubelet_config_bak_file,\\n kubelet_latest_config_file, kubelet_bak_config_file)\\n update_kubelet_configmap(kubelet_latest_config_file)\\n\\n # Update control-plane backup files\\n export_k8s_kubeadm_configmap(kubeadm_cm_bak_file)\\n export_k8s_cluster_configuration(cluster_config_bak_file)\\n\\n LOG.debug(\\\"Successfully Updated.\\\")\\n return 0\\n\\n return rc\",\n \"def get_pods(namespace, k8s_cli, selector=\\\"\\\"):\\n if selector:\\n selector = '--selector=\\\"{}\\\"'.format(selector)\\n cmd = '{} get pod -n {} {} -o json '.format(k8s_cli, namespace, selector)\\n return_code, out = run_shell_command(cmd)\\n if return_code:\\n logger.warning(\\\"Failed to get pods: %s\\\", out)\\n return None\\n return json.loads(out)['items']\",\n \"def pprint(metrics: dict, fmt: str = \\\"katib\\\"):\\n if fmt == \\\"katib\\\":\\n # Format print to default Katib::StdOut to reduce need for additional user config\\n # https://www.kubeflow.org/docs/components/katib/experiment/#metrics-collector\\n print(\\\"epoch {}:\\\".format(metrics[\\\"epoch\\\"]))\\n for k, v in metrics.items():\\n if k == \\\"epoch\\\":\\n continue\\n print(\\\"{}={}\\\".format(k, v))\\n print()\\n else:\\n print(metrics)\",\n \"def test_aws_service_api_vm_get(self):\\n pass\",\n \"def logs(self, container: Container) -> str:\",\n \"def print_logs(self, shell=False):\\n for l, v in self.logs(shell).items():\\n print('\\\\n### Container ', l, ', id ', v.get('id', 'None'), ' ###\\\\n')\\n for part in ['stdout', 'stderr']:\\n print('##', part, '##')\\n print(v[part])\",\n \"def list_pods(req, resp):\\n namespace = req.params['namespace']\\n return _get_all_pods(namespace)\",\n \"def collect_k8s_version_info(ns_output_dir, k8s_cli):\\n cmd = f\\\"{k8s_cli} version -o yaml\\\"\\n collect_helper(ns_output_dir, cmd, \\\"Version.yaml\\\", \\\"Version\\\")\",\n \"def pv(self, *args, **kwargs):\\n return _image.image_pv(self, *args, **kwargs)\",\n \"def getting_info(self, cloud_path):\\n\\t\\telog(\\\"getting info on {}\\\".format(cloud_path))\",\n \"def do_show(cs, args):\\n opts = {}\\n opts['id'] = args.container\\n opts['all_projects'] = args.all_projects\\n opts = zun_utils.remove_null_parms(**opts)\\n container = cs.containers.get(**opts)\\n if args.format == 'json':\\n print(jsonutils.dumps(container._info, indent=4, sort_keys=True))\\n elif args.format == 'yaml':\\n print(yaml.safe_dump(container._info, default_flow_style=False))\\n elif args.format == 'table':\\n _show_container(container)\",\n \"def get_notebooks_using_pvc(pvc, notebooks):\\n mounted_notebooks = []\\n\\n for nb in notebooks:\\n pvcs = get_notebook_pvcs(nb)\\n if pvc in pvcs:\\n mounted_notebooks.append(nb[\\\"metadata\\\"][\\\"name\\\"])\\n\\n return mounted_notebooks\",\n \"def printInvokeMap(self):\\n self.log.debug(\\\"Invoke map:\\\")\\n for key, value in self.invokeMap.iteritems():\\n self.log.debug(\\\"%s => %s\\\" % (key, value))\",\n \"def print_variables(self):\\n\\n logging.debug(\\n \\\"The broker address \\\" + str(\\n self.broker_address) + \\\" transport \\\" + self.tTransport + \\\" the port is \\\" + str(\\n self.tPort))\",\n \"def got_info(self, cloud_obj):\",\n \"def test_nodelog_kubelet(self):\\n nodelog_url = self.BUILD_DIR + 'nodelog?pod=abc&junit=junit_01.xml'\\n init_build(self.BUILD_DIR)\\n write(self.BUILD_DIR + 'artifacts/tmp-node-image/junit_01.xml', JUNIT_SUITE)\\n write(self.BUILD_DIR + 'artifacts/tmp-node-image/kubelet.log',\\n 'abc\\\\nEvent(api.ObjectReference{Name:\\\"abc\\\", UID:\\\"podabc\\\"})\\\\n')\\n response = app.get('/build' + nodelog_url)\\n self.assertIn(\\\"Wrap line\\\", response)\",\n \"def v_print(msg):\\n if (VERBOSE == 1):\\n print(msg)\",\n \"def print_verbose(self) -> None:\\n print(self)\\n if self.meta is not None:\\n print(self.meta.__repr__())\",\n \"def collect_pods_logs(namespace, output_dir, k8s_cli, logs_from_all_pods=False):\\n logger.info(\\\"Namespace '%s': Collecting pods' logs:\\\", namespace)\\n logs_dir = os.path.join(output_dir, \\\"pods\\\")\\n\\n if logs_from_all_pods:\\n pods = get_pod_names(namespace, k8s_cli)\\n else:\\n pods = []\\n for selector in [\\\"app=redis-enterprise\\\", \\\"name=redis-enterprise-operator\\\"]:\\n pods.extend(get_pod_names(namespace, k8s_cli, selector))\\n\\n if not pods:\\n logger.warning(\\\"Namespace '%s' Could not get pods list - \\\"\\n \\\"skipping pods logs collection\\\", namespace)\\n return\\n\\n make_dir(logs_dir)\\n\\n for pod in pods:\\n collect_logs_from_pod(namespace, pod, logs_dir, k8s_cli)\",\n \"def test_show_container_privilege(self):\\n pass\",\n \"def details(self):\\n print \\\"ABC - Deployer.details()\\\"\",\n \"def write_out_v(vc2ptmk, ofn):\\n print \\\"Writing out verbose to [{}]\\\".format(ofn)\\n with codecs.open(ofn, \\\"w\\\", \\\"utf8\\\") as ofd:\\n for (co, uri), infos in sorted(vc2ptmk.items()):\\n for di in infos:\\n ol = u\\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\n\\\".format(\\n co, uri, di[\\\"ptmk\\\"], di[\\\"spk\\\"], di[\\\"sco\\\"])\\n ofd.write(ol)\",\n \"def get_volume_info(host, disk_object, dc_obj):\\n host_resource = get_host_resource_by_name(host)\\n\\n vol_id = disk_object.get_image_id()\\n sd_id = disk_object.get_storage_domains().get_storage_domain()[0].get_id()\\n image_id = disk_object.get_id()\\n sp_id = dc_obj.get_id()\\n\\n args = {\\n \\\"storagepoolID\\\": sp_id,\\n \\\"storagedomainID\\\": sd_id,\\n \\\"imageID\\\": image_id,\\n \\\"volumeID\\\": vol_id,\\n }\\n\\n return host_resource.vds_client(cmd=\\\"Volume.getInfo\\\", args=args)\",\n \"def print_status(data):\\n print \\\"0x%x:0x%x:0x%x:0x%x:0x%x:%d:%d:%d:%d:%d:%d:%d:%d\\\" % (\\n data['sysVer'], data['barVer'], data['uvVer'], data['rccVer'],\\n data['windVer'], data['batteryRain'], data['batteryUV'],\\n data['batteryWind'], data['battery5'], data['battery4'],\\n data['battery3'], data['battery2'], data['battery1'])\",\n \"def test_vmcp_01(self):\\r\\n # Even though the key does not exists, let's patch it to test\\r\\n # all the errors\\r\\n with patch('os.path.exists', return_value=True):\\r\\n res = self.app.get('api/vmcp', follow_redirects=True)\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status_code'] == 415, err\\r\\n assert err['status'] == \\\"failed\\\", err\\r\\n assert err['target'] == \\\"vmcp\\\", err\\r\\n assert err['action'] == \\\"GET\\\", err\\r\\n assert err['exception_msg'] == 'cvm_salt parameter is missing'\",\n \"def get_kubernetes_cluster_output(name: Optional[pulumi.Input[str]] = None,\\n tags: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetKubernetesClusterResult]:\\n ...\",\n \"def vector_info(map, layer=1):\\n\\n s = read_command('v.info', flags='get', layer=layer, map=map)\\n\\n kv = parse_key_val(s)\\n for k in ['north', 'south', 'east', 'west', 'top', 'bottom']:\\n kv[k] = float(kv[k])\\n for k in ['level', 'num_dblinks']:\\n kv[k] = int(kv[k])\\n for k in ['nodes', 'points', 'lines', 'boundaries', 'centroids', 'areas',\\n 'islands', 'primitives']:\\n kv[k] = int(kv[k])\\n if 'map3d' in kv:\\n kv['map3d'] = bool(int(kv['map3d']))\\n if kv['map3d']:\\n for k in ['faces', 'kernels', 'volumes', 'holes']:\\n kv[k] = int(kv[k])\\n\\n return kv\",\n \"def print_if_verbose(self, log):\\n\\n if self.verbose:\\n print(log)\\n return log\",\n \"def show_vnic(client, resource_group_name, vm_name, nic_name):\\n virtual_machine = client.get(resource_group_name, vm_name)\\n for nic in virtual_machine.nics:\\n if nic.virtual_nic_name == nic_name:\\n return nic\\n return None\",\n \"def print_metadata_stats(sector=6, filesystem=None):\\n\\n assert isinstance(filesystem, str)\\n\\n if filesystem in ['phtess2', 'php1']:\\n fs = f\\\"/nfs/{filesystem}\\\"\\n projdir = f'{fs}/ar0/TESS/PROJ/lbouma/cdips'\\n lcdirectory = f'/nfs/phtess2/ar0/TESS/PROJ/lbouma/CDIPS_LCS/sector-{sector}/'\\n catdir = '/nfs/phtess1/ar1/TESS/PROJ/lbouma/'\\n elif filesystem in ['wh1', 'wh2']:\\n projdir = \\\"/ar1/PROJ/luke/proj/cdips\\\"\\n lcdirectory = f'/ar1/PROJ/luke/proj/CDIPS_LCS/sector-{sector}/'\\n catdir = '/ar1/local/cdips/catalogs/'\\n\\n statsdir = join(projdir, 'results', 'cdips_lc_stats', f'sector-{sector}')\\n if not os.path.exists(statsdir): os.mkdir(statsdir)\\n statsfile = os.path.join(statsdir,'cdips_lc_statistics.txt')\\n\\n stats = ap.read_stats_file(statsfile, fovcathasgaiaids=True)\\n N_lcs = len(stats)\\n\\n print('CDIPS LIGHTCURVES STATS FOR SECTOR {}'.format(sector))\\n print(42*'-')\\n print('total N_lcs: {}'.format(N_lcs))\\n\\n for apn in [1,2,3]:\\n N_nan = len(stats[stats['ndet_tf{}'.format(apn)]==0])\\n print('for ap {}, {} ({:.1f}%) are all nan, leaving {} ok lcs'.\\n format(apn, N_nan, N_nan/N_lcs*100, N_lcs-N_nan))\\n\\n print('\\\\nsanity check: {} TF1 LCs have stdev > 0'.\\n format(len(stats[stats['stdev_tf1'] > 0])))\\n\\n print('Finished print_metadata_stats!')\",\n \"def inspect(self):\\n print(cf_inspect(self))\",\n \"def getContainerStatus(self,node,vmid):\\n data = self.connect('get','nodes/%s/lxc/%s/status/current' % (node,vmid),None)\\n return data\",\n \"def vs_dump(event):\\n get_vs(event['c']).dump()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61853266","0.5792927","0.5758242","0.57081366","0.5688722","0.5639404","0.55854255","0.5542733","0.55318034","0.5493715","0.5396289","0.53871465","0.53501064","0.5298621","0.5275156","0.5263584","0.5230812","0.5208932","0.51616544","0.5160978","0.51508194","0.51507145","0.51424116","0.5135254","0.50872064","0.5058841","0.50560886","0.50360864","0.50318676","0.4959431","0.49586082","0.49296114","0.48342374","0.48172346","0.4816656","0.47752762","0.47523466","0.4746408","0.4726231","0.47185233","0.47073153","0.4691745","0.46816745","0.46725005","0.46676037","0.4663618","0.46464244","0.46355745","0.462608","0.46223673","0.46179435","0.46178916","0.45956743","0.45877418","0.45811814","0.4576031","0.45726308","0.4558509","0.45577836","0.45442826","0.45387194","0.45367488","0.45342895","0.45320618","0.45298418","0.4529558","0.45254448","0.45207527","0.4511263","0.45033538","0.44938704","0.44851878","0.44805825","0.44765604","0.4471103","0.44514206","0.44479197","0.44474","0.44465452","0.4422731","0.44210708","0.44086468","0.44068986","0.4397486","0.4391772","0.43905658","0.43831998","0.43830898","0.43823695","0.4380887","0.4379474","0.43751657","0.43698937","0.43663985","0.43532422","0.43507853","0.43420646","0.43388295","0.43373448","0.43362352"],"string":"[\n \"0.61853266\",\n \"0.5792927\",\n \"0.5758242\",\n \"0.57081366\",\n \"0.5688722\",\n \"0.5639404\",\n \"0.55854255\",\n \"0.5542733\",\n \"0.55318034\",\n \"0.5493715\",\n \"0.5396289\",\n \"0.53871465\",\n \"0.53501064\",\n \"0.5298621\",\n \"0.5275156\",\n \"0.5263584\",\n \"0.5230812\",\n \"0.5208932\",\n \"0.51616544\",\n \"0.5160978\",\n \"0.51508194\",\n \"0.51507145\",\n \"0.51424116\",\n \"0.5135254\",\n \"0.50872064\",\n \"0.5058841\",\n \"0.50560886\",\n \"0.50360864\",\n \"0.50318676\",\n \"0.4959431\",\n \"0.49586082\",\n \"0.49296114\",\n \"0.48342374\",\n \"0.48172346\",\n \"0.4816656\",\n \"0.47752762\",\n \"0.47523466\",\n \"0.4746408\",\n \"0.4726231\",\n \"0.47185233\",\n \"0.47073153\",\n \"0.4691745\",\n \"0.46816745\",\n \"0.46725005\",\n \"0.46676037\",\n \"0.4663618\",\n \"0.46464244\",\n \"0.46355745\",\n \"0.462608\",\n \"0.46223673\",\n \"0.46179435\",\n \"0.46178916\",\n \"0.45956743\",\n \"0.45877418\",\n \"0.45811814\",\n \"0.4576031\",\n \"0.45726308\",\n \"0.4558509\",\n \"0.45577836\",\n \"0.45442826\",\n \"0.45387194\",\n \"0.45367488\",\n \"0.45342895\",\n \"0.45320618\",\n \"0.45298418\",\n \"0.4529558\",\n \"0.45254448\",\n \"0.45207527\",\n \"0.4511263\",\n \"0.45033538\",\n \"0.44938704\",\n \"0.44851878\",\n \"0.44805825\",\n \"0.44765604\",\n \"0.4471103\",\n \"0.44514206\",\n \"0.44479197\",\n \"0.44474\",\n \"0.44465452\",\n \"0.4422731\",\n \"0.44210708\",\n \"0.44086468\",\n \"0.44068986\",\n \"0.4397486\",\n \"0.4391772\",\n \"0.43905658\",\n \"0.43831998\",\n \"0.43830898\",\n \"0.43823695\",\n \"0.4380887\",\n \"0.4379474\",\n \"0.43751657\",\n \"0.43698937\",\n \"0.43663985\",\n \"0.43532422\",\n \"0.43507853\",\n \"0.43420646\",\n \"0.43388295\",\n \"0.43373448\",\n \"0.43362352\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6945199"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78696,"cells":{"query":{"kind":"string","value":"Delete all volume snapshots associated with the kubernetes cluster"},"document":{"kind":"string","value":"def delete_volume_snapshots(k8s_ctx: str, dry_run: bool = False):\n # We are not using --force=true here to do a graceful deletion. Volume\n # snapshot does not need to wait for any pod or job to be deleted and it\n # is fine if deletion takes some time. --ignore-not-found defaults to true\n # if --all is used.\n cmd = f'kubectl --context={k8s_ctx} delete volumesnapshot --all'\n if dry_run:\n logging.info(cmd)\n return\n safe_exec(cmd)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def snap_delete_all(mnode):\n cmd = \"gluster snapshot delete all --mode=script\"\n return g.run(mnode, cmd)","def delete_volume_snapshot(volume_snapshots):\n if type(volume_snapshots) is not list:\n volumes = [volume_snapshots]\n command = 'cinder snapshot-delete %s' % \\\n \" \".join(snapshot['id'] for snapshot in volume_snapshots)\n d = Popen(command.split(), stdout=STDOUT, stderr=STDERR).communicate()[0]","def delete_all(k8s_ctx: str, dry_run: bool = False) -> List[str]:\n commands1 = [f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=setup',\n f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=blast']\n commands2 = [f'kubectl --context={k8s_ctx} delete pvc --all --force=true',\n f'kubectl --context={k8s_ctx} delete pv --all --force=true',\n f'kubectl --context={k8s_ctx} delete volumesnapshots --all --ignore-not-found=true --force=true']\n\n def run_commands(commands: List[str], dry_run: bool) -> List[str]:\n \"\"\" Run the commands in the argument list and return the names of the relevant k8s objects.\n This function is specific to delete_all.\n \"\"\"\n result = []\n for cmd in commands:\n if dry_run:\n logging.info(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n for line in p.stdout.decode().split('\\n'):\n if line:\n if line.startswith('No resources found'):\n # nothing was deleted\n break\n fields = line.rstrip().split()\n if len(fields) > 1:\n result.append(fields[1])\n else:\n result.append(fields[0])\n return result\n\n def delete_finalizers(k8s_ctx: str, dry_run: bool = False):\n \"\"\" Delete finalizers to ensure PV and PVC get deleted\n https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#finalizers\n \"\"\"\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\n for storage_obj in run_commands([cmd], dry_run):\n cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '\n cmd += '{\"metadata\":{\"finalizers\":null}}'\n logging.debug(cmd)\n if dry_run:\n logging.debug(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n logging.debug(p.stdout.decode().rstrip())\n\n def inspect_storage_objects_for_debugging(k8s_ctx: str, dry_run: bool = False):\n \"\"\" Retrieve information about PV and PVC from kubectl and log it for debugging purposes. \"\"\"\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\n for storage_obj in run_commands([cmd], dry_run):\n cmd = f'kubectl --context={k8s_ctx} describe {storage_obj}'\n if dry_run:\n logging.debug(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n for line in p.stdout.decode().split('\\n'):\n if line.startswith(\"Status\") or line.startswith(\"Finalizers\"):\n logging.debug(f'{storage_obj} {line}')\n\n inspect_storage_objects_for_debugging(k8s_ctx, dry_run)\n # Delete the jobs first, wait, then delete the pvc and pv\n deleted1 = run_commands(commands1, dry_run)\n if not dry_run:\n secs2sleep = int(os.getenv('ELB_PAUSE_AFTER_INIT_PV', str(ELB_PAUSE_AFTER_INIT_PV)))\n time.sleep(secs2sleep)\n delete_finalizers(k8s_ctx, dry_run)\n inspect_storage_objects_for_debugging(k8s_ctx, dry_run)\n deleted2 = run_commands(commands2, dry_run)\n return deleted1 + deleted2","def delete_volumes(volumes):\n if type(volumes) is not list:\n volumes = [volumes]\n for volume in volumes:\n command = 'cinder delete %s' % volume['id']\n a = Popen(command.split(), stdout=STDOUT, stderr=STDERR).communicate()[0]","def destroy_cluster(self, log_level=\"DEBUG\"):\n super(AWSIPI, self).destroy_cluster(log_level)\n\n try:\n # Retrieve cluster name and AWS region from metadata\n cluster_name = self.ocp_deployment.metadata.get(\"clusterName\")\n # Find and delete volumes\n volume_pattern = f\"{cluster_name}*\"\n logger.debug(f\"Finding volumes with pattern: {volume_pattern}\")\n volumes = self.aws.get_volumes_by_name_pattern(volume_pattern)\n logger.debug(f\"Found volumes: \\n {volumes}\")\n for volume in volumes:\n self.aws.detach_and_delete_volume(\n self.aws.ec2_resource.Volume(volume['id'])\n )\n except Exception:\n logger.error(traceback.format_exc())","def delete(self):\n for lv in self.logical_volumes:\n self.delete_lv(lv_name=lv)\n\n super().delete()","def detach_all_volumes(self):\n nova_connection = self.source_connection.get_nova_connection(self.source_region_name)\n loop = asyncio.get_event_loop()\n try:\n loop.run_until_complete(self.resource_manager.detach_all_volume(nova_connection))\n except:\n raise","def database_volume_snapshot_delete(volume_snapshot_uuid):\n db = database_get()\n session = db.session()\n query = session.query(model.VolumeSnapshot)\n query.filter(model.VolumeSnapshot.uuid == volume_snapshot_uuid).delete()\n session.commit()","def cli(env, snapshot_id):\n block_manager = SoftLayer.BlockStorageManager(env.client)\n deleted = block_manager.delete_snapshot(snapshot_id)\n\n if deleted:\n click.echo('Snapshot %s deleted' % snapshot_id)","def delete_finalizers(k8s_ctx: str, dry_run: bool = False):\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\n for storage_obj in run_commands([cmd], dry_run):\n cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '\n cmd += '{\"metadata\":{\"finalizers\":null}}'\n logging.debug(cmd)\n if dry_run:\n logging.debug(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n logging.debug(p.stdout.decode().rstrip())","def reap_snapshots(vcenter, logger):\n all_users = vcenter.get_by_name(name=const.INF_VCENTER_USERS_DIR, vimtype=vim.Folder)\n for username in all_users.childEntity:\n vms = vcenter.get_by_name(name=username.name, vimtype=vim.Folder)\n for vm in vms.childEntity:\n if vm.snapshot:\n vm_snaps = _get_snapshots(vm.snapshot.rootSnapshotList)\n for snap in vm_snaps:\n if is_expired(snap.name):\n logger.info(\"deleteing snap {} of VM {} owned by {}\".format(snap, vm.name, username))\n consume_task(snap.snapshot.RemoveSnapshot_Task(removeChildren=False))","def resources_cleanup(namespace, image_uuids=None):\n resources = [\n constants.DEPLOYMENT,\n constants.POD,\n constants.VOLUME_REPLICATION_GROUP,\n constants.VOLUME_REPLICATION,\n constants.PVC,\n constants.PV,\n ]\n log.info(\"Cleaning up leftover resources in managed clusters\")\n for cluster in get_non_acm_cluster_config():\n config.switch_ctx(cluster.MULTICLUSTER[\"multicluster_index\"])\n for resource in resources:\n sleep(10) # Wait 10 seconds before getting the list of items\n log.info(f\"Cleaning up {resource} resources\")\n ocp_obj = ocp.OCP(kind=resource, namespace=namespace)\n item_list = ocp_obj.get()[\"items\"]\n for item in item_list:\n resource_name = item[\"metadata\"][\"name\"]\n try:\n if resource == constants.PV:\n if item[\"spec\"][\"claimRef\"][\"namespace\"] != namespace:\n continue\n ocp_obj.delete(resource_name=resource_name)\n ocp_obj.wait_for_delete(resource_name=resource_name)\n else:\n ocp_obj.delete(resource_name=resource_name, wait=False)\n ocp_obj.patch(\n resource_name=resource_name,\n params='{\"metadata\": {\"finalizers\":null}}',\n format_type=\"merge\",\n )\n ocp_obj.wait_for_delete(resource_name=resource_name)\n\n except CommandFailed as ex:\n if \"NotFound\" in str(ex):\n log.info(\n f\"{resource} {resource_name} got deleted successfully\"\n )\n else:\n raise ex\n\n for cluster in get_non_acm_cluster_config():\n config.switch_ctx(cluster.MULTICLUSTER[\"multicluster_index\"])\n for image_uuid in image_uuids:\n delete_volume_in_backend(\n img_uuid=image_uuid,\n pool_name=constants.DEFAULT_CEPHBLOCKPOOL,\n disable_mirroring=True,\n )","def tearDown(self):\n\n LOG.debug(\"\\n*** Starting cleanup...\")\n client = self._get_client()\n\n # Get list of snapshots\n #LOG.debug(\"- Getting list of snapshots\")\n #resp, snapshots = self._execute_request(client, \"snapshots\", \"GET\", \"\")\n #snapshots = json.loads(snapshots)\n\n # Delete all orphaned instances and snapshots\n LOG.debug(\"- Deleting orphaned instances:\")\n resp, content = self._execute_request(client, \"instances\", \"GET\", \"\")\n content = json.loads(content)\n\n for each in content['instances']:\n# LOG.debug(\"EACH: %s\" % each)\n if each['name'] == INSTANCE_NAME:\n #for snapshot in snapshots['snapshots']:\n # # If any snapshots belong to an instance to be deleted, delete the snapshots too\n # if snapshot['instanceId'] == each['id']:\n # LOG.debug(\"Deleting snapshot: %s\" % snapshot['id'])\n # resp, content = self._execute_request(client, \"snapshots/\" + snapshot['id'], \"DELETE\", \"\")\n # LOG.debug(resp)\n # LOG.debug(content)\n LOG.debug(\"Deleting instance: %s\" % each['id'])\n resp, content = self._execute_request(client, \"instances/\" + each['id'], \"DELETE\", \"\")\n LOG.debug(resp)\n LOG.debug(content)","def delete_vs(vs_name, created_objects):\r\n if keep_objects:\r\n return\r\n custom_object_api_instance = client.CustomObjectsApi()\r\n try:\r\n custom_object_api_response = custom_object_api_instance.delete_namespaced_custom_object(\r\n group=\"snapshot.storage.k8s.io\",\r\n version=\"v1\",\r\n plural=\"volumesnapshots\",\r\n name=vs_name,\r\n namespace=namespace_value\r\n )\r\n LOGGER.debug(custom_object_api_response)\r\n LOGGER.info(f\"Volume Snapshot Delete : {vs_name} deleted\")\r\n created_objects[\"vs\"].remove(vs_name)\r\n except ApiException as e:\r\n LOGGER.error(f\"Exception when calling CustomObjectsApi->delete_cluster_custom_object: {e}\")\r\n clean_with_created_objects(created_objects)\r\n assert False","def snap_delete_by_volumename(mnode, volname):\n\n cmd = \"gluster snapshot delete volume %s --mode=script\" % volname\n return g.run(mnode, cmd)","def test_aws_service_api_snapshot_delete(self):\n pass","def delete_snapshot(self, snapshot):\n aname = \"cinder_v%s.delete_snapshot\" % self.version\n with atomic.ActionTimer(self, aname):\n self._get_client().volume_snapshots.delete(snapshot)\n bench_utils.wait_for_status(\n snapshot,\n ready_statuses=[\"deleted\"],\n check_deletion=True,\n update_resource=self._update_resource,\n timeout=CONF.openstack.cinder_volume_delete_timeout,\n check_interval=(CONF.openstack\n .cinder_volume_delete_poll_interval)\n )","def test_aws_service_api_volume_delete(self):\n pass","def destroy_snapshot(snapname, dataset='', recursive=True, zpool=None):\n fullsnapname = \"%s%s@%s\" % (zpool, dataset, snapname)\n print \"Destroying snapshot '%s'\" % fullsnapname\n if recursive:\n command = 'zfs destroy -r %s' % fullsnapname\n else:\n command = 'zfs destroy %s' % fullsnapname\n #print \"Exec '%s'\" % command\n assert command.find('@') != -1 # we are not destroying datasets, only snapshots\n p = subprocess.Popen(command.split(' '))\n p.wait()\n if p.returncode != 0 and p.returncode != 1: # 1 = snapshot did not exist. We can stand that\n raise Exception(\"Error executing '%s': %d\" % (command, p.returncode))","def _DeleteAllFromDefaultNamespace(self):\n run_cmd = [\n 'delete', 'all', '--all', '-n', 'default'\n ]\n RunKubectlCommand(run_cmd)\n\n run_cmd = [\n 'delete', 'pvc', '--all', '-n', 'default'\n ]\n RunKubectlCommand(run_cmd)\n # There maybe a slight race if resources are cleaned up in the background\n # where deleting the cluster immediately prevents the PVCs from being\n # deleted.\n logging.info('Sleeping for %s seconds to give resources time to delete.',\n RESOURCE_DELETE_SLEEP_SECONDS)\n time.sleep(RESOURCE_DELETE_SLEEP_SECONDS)","def destroy_all(self):\n self.log.info(\"Destroying the %s cluster\" % self.cluster_name)\n for n in self.all_nodes:\n n.destroy()\n remove(self.save_file)","def _delete_all_containers(self):\n for container_ref in self.created_entities['container']:\n self.barbicanclient.containers.delete(container_ref)","def test_volume_snapshot_create_get_list_delete(self):\n volume = self.create_volume()\n self.addCleanup(self.delete_volume, volume['id'])\n\n s_name = data_utils.rand_name(self.__class__.__name__ + '-Snapshot')\n # Create snapshot\n snapshot = self.snapshots_client.create_snapshot(\n volume_id=volume['id'],\n display_name=s_name)['snapshot']\n\n def delete_snapshot(snapshot_id):\n waiters.wait_for_volume_resource_status(self.snapshots_client,\n snapshot_id,\n 'available')\n # Delete snapshot\n self.snapshots_client.delete_snapshot(snapshot_id)\n self.snapshots_client.wait_for_resource_deletion(snapshot_id)\n\n self.addCleanup(delete_snapshot, snapshot['id'])\n self.assertEqual(volume['id'], snapshot['volumeId'])\n # Get snapshot\n fetched_snapshot = self.snapshots_client.show_snapshot(\n snapshot['id'])['snapshot']\n self.assertEqual(s_name, fetched_snapshot['displayName'])\n self.assertEqual(volume['id'], fetched_snapshot['volumeId'])\n # Fetch all snapshots\n snapshots = self.snapshots_client.list_snapshots()['snapshots']\n self.assertIn(snapshot['id'], map(lambda x: x['id'], snapshots))","def delete_volume(self, volume):\n nfs_share = volume.get('provider_location')\n if nfs_share:\n nms = self.share2nms[nfs_share]\n vol, parent_folder = self._get_share_datasets(nfs_share)\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\n mount_path = self.remote_path(volume).strip(\n '/%s' % self.VOLUME_FILE_NAME)\n if mount_path in self._remotefsclient._read_mounts():\n cinder.privsep.fs.umount(mount_path)\n try:\n props = nms.folder.get_child_props(folder, 'origin') or {}\n nms.folder.destroy(folder, '-r')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Folder %s does not exist, it was '\n 'already deleted.', folder)\n return\n raise\n self._get_capacity_info(nfs_share)\n origin = props.get('origin')\n if origin and self._is_clone_snapshot_name(origin):\n try:\n nms.snapshot.destroy(origin, '')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Snapshot %s does not exist, it was '\n 'already deleted.', origin)\n return\n raise","def delete(config: Config, ami: str) -> None:\n\n ec2_client = boto3.client(\"ec2\", region_name=config.get(\"region\", None))\n\n response = describe(config, ami, show_snapshot_id=True)\n\n ec2_client.deregister_image(ImageId=ami)\n\n ec2_client.delete_snapshot(SnapshotId=response[0][\"SnapshotId\"])","def snap_delete(mnode, snapname):\n\n cmd = \"gluster snapshot delete %s --mode=script\" % snapname\n return g.run(mnode, cmd)","def cleanup_detach_snapshot(ec2, aws_account_id, dry_run=True):\n images = ec2.images.filter(Owners=[aws_account_id])\n images = [image.id for image in images]\n for snapshot in ec2.snapshots.filter(OwnerIds=[aws_account_id]):\n r = re.match(r\".*for (ami-.*) from.*\", snapshot.description)\n if r:\n if r.groups()[0] not in images:\n logger.info(\"Deleting %s\" % snapshot.snapshot_id)\n if not dry_run:\n snapshot.delete(DryRun=dry_run)\n else:\n logger.info(\" skipped as dry_run is true\")","def cleanup():\n cmd='docker rmi --force $(docker images -a -q)'\n bash_command(\"Deleting all images\", cmd)","def delete_old(self):\n retention_time = Host().get_retention_time()\n snapshots = self._list_snapshots()\n\n for snap in snapshots['Snapshots']:\n snapshot_id = snap['SnapshotId']\n start_time = snap['StartTime']\n if start_time <= retention_time:\n self.resource.delete_snapshot(\n SnapshotId=snapshot_id,\n DryRun=DRY_RUN\n )\n self.deleted_ids.append(snapshot_id)\n\n notify = Notifier()\n notify.send(self.created_id, self.deleted_ids)","def delete_metadata(self, snapshot, keys):\n response_list = []\n snapshot_id = base.getid(snapshot)\n for k in keys:\n resp, body = self._delete(\"/snapshots/%s/metadata/%s\" %\n (snapshot_id, k))\n response_list.append(resp)\n\n return common_base.ListWithMeta([], response_list)","def purge_all(self, df, dry_run=True):\n if not dry_run:\n for image in df[\"image_name\"]:\n logging.info(\"Deleting image: % s\" % image)\n\n delete_cmd = [\n \"az\",\n \"acr\",\n \"repository\",\n \"delete\",\n \"-n\",\n self.name,\n \"--image\",\n image,\n \"--yes\",\n ]\n\n result = run_cmd(delete_cmd)\n\n if result[\"returncode\"] != 0:\n logging.error(result[\"err_msg\"])\n raise AzureError(result[\"err_msg\"])\n\n logging.info(\"Image successfully deleted\")","def destroy(self, log_level=''):\n # Get all the additional volumes and detach,delete.\n volumes = self.utils.get_volumes_with_tag(\n {'cluster_name': config.ENV_DATA['cluster_name']}\n )\n self.flexy_instance.destroy()\n self.utils.detach_and_delete_vols(volumes)","def test_csi_volumesnapshot_basic(set_random_backupstore, # NOQA\n volumesnapshotclass, # NOQA\n volumesnapshot, # NOQA\n client, # NOQA\n core_api, # NOQA\n volume_name, # NOQA\n csi_pv, # NOQA\n pvc, # NOQA\n pod_make, # NOQA\n volsnapshotclass_delete_policy, # NOQA\n backup_is_deleted): # NOQA\n\n csisnapclass = \\\n volumesnapshotclass(name=\"snapshotclass\",\n deletepolicy=volsnapshotclass_delete_policy)\n\n pod_name, pv_name, pvc_name, md5sum = \\\n prepare_pod_with_data_in_mb(client, core_api,\n csi_pv, pvc, pod_make,\n volume_name,\n data_path=\"/data/test\")\n\n # Create volumeSnapshot test\n csivolsnap = volumesnapshot(volume_name + \"-volumesnapshot\",\n \"default\",\n csisnapclass[\"metadata\"][\"name\"],\n \"persistentVolumeClaimName\",\n pvc_name)\n\n volume = client.by_id_volume(volume_name)\n\n for i in range(RETRY_COUNTS):\n snapshots = volume.snapshotList()\n if len(snapshots) == 2:\n break\n time.sleep(RETRY_INTERVAL)\n\n lh_snapshot = None\n snapshots = volume.snapshotList()\n for snapshot in snapshots:\n if snapshot[\"name\"] == \"snapshot-\" + csivolsnap[\"metadata\"][\"uid\"]:\n lh_snapshot = snapshot\n assert lh_snapshot is not None\n\n wait_for_volumesnapshot_ready(csivolsnap[\"metadata\"][\"name\"],\n csivolsnap[\"metadata\"][\"namespace\"])\n\n bv1, b = find_backup(client, volume_name, lh_snapshot[\"name\"])\n\n assert b[\"snapshotName\"] == lh_snapshot[\"name\"]\n\n restore_pvc_name = pvc[\"metadata\"][\"name\"] + \"-restore\"\n restore_pvc_size = pvc[\"spec\"][\"resources\"][\"requests\"][\"storage\"]\n\n restore_csi_volume_snapshot(core_api,\n client,\n csivolsnap,\n restore_pvc_name,\n restore_pvc_size)\n\n restore_pod = pod_make()\n restore_pod_name = restore_pod[\"metadata\"][\"name\"]\n restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]\n\n create_and_wait_pod(core_api, restore_pod)\n restore_md5sum = \\\n get_pod_data_md5sum(core_api, restore_pod_name, path=\"/data/test\")\n assert restore_md5sum == md5sum\n\n # Delete volumeSnapshot test\n delete_volumesnapshot(csivolsnap[\"metadata\"][\"name\"], \"default\")\n\n if backup_is_deleted is False:\n find_backup(client, volume_name, b[\"snapshotName\"])\n else:\n wait_for_backup_delete(client, volume_name, b[\"name\"])","def delete_snapshot(self, snapshot_id):\r\n\r\n self.iscsi_svc.deleteObject(id=snapshot_id)","def check_vs_deleted(vs_name, created_objects):\r\n if keep_objects:\r\n return\r\n api_instance = client.CustomObjectsApi()\r\n val = 0\r\n while val < 12:\r\n try:\r\n api_response = api_instance.get_namespaced_custom_object(\r\n group=\"snapshot.storage.k8s.io\",\r\n version=\"v1\",\r\n plural=\"volumesnapshots\",\r\n name=vs_name,\r\n namespace=namespace_value\r\n )\r\n LOGGER.debug(api_response)\r\n time.sleep(15)\r\n LOGGER.info(f\"Volume Snapshot Delete : Checking deletion for {vs_name}\")\r\n val += 1\r\n except ApiException:\r\n LOGGER.info(f\"Volume Snapshot Delete : {vs_name} deletion confirmed\")\r\n return\r\n LOGGER.error(f\"Volume Snapshot Delete : {vs_name} is not deleted , asserting\")\r\n clean_with_created_objects(created_objects)\r\n assert False","def terminate_volumes(db, context, instance_id):\n volume_api = volume.API()\n for bdm in db.block_device_mapping_get_all_by_instance(context,\n instance_id):\n #LOG.debug(_(\"terminating bdm %s\") % bdm)\n if bdm['volume_id'] and bdm['delete_on_termination']:\n volume_api.delete(context, bdm['volume_id'])\n db.block_device_mapping_destroy(context, bdm['id'])","def _snapshot_destroy(self, dir_path, snapshot_name):\n try:\n self.fs.rmdir(self._snapshot_path(dir_path, snapshot_name))\n except cephfs.ObjectNotFound:\n log.warn(\"Snapshot was already gone: {0}\".format(snapshot_name))","def DeleteContainers(self):\n for container in itertools.chain(*list(self.containers.values())):\n container.Delete()","def vm_snapshot_remove_all(self, vm_moid):\n result = DataResult()\n try:\n vm_mor = self.get_vm_mor(vm_moid)\n task_mor = vm_mor.RemoveAllSnapshots()\n result.task_key = task_mor._moId\n except Exception as ex:\n LOG.exception(ex)\n result.status = False\n result.message = \"Remove all snapshots for vm error: %s \" % str(ex)\n return result","def cleanup_infrastructure_storage(config, datacenter):\n print \"Removing storage devices in datacenter %s...\" % datacenter.getName()\n for device in datacenter.listStorageDevices():\n device.delete()","def delete_all_representations(model_admin, request, queryset):\n Representation.objects.filter(image__in=queryset).delete()","def nuke_all_ebs(older_than_seconds, logger):\n\n #### Nuke all volumes ####\n response = EC2.describe_volumes()\n time_delete = time.time() - older_than_seconds\n\n for volume in response['Volumes']:\n\n if volume['CreateTime'].timestamp() < time_delete:\n for volumestate in volume['Attachments']:\n if volumestate['State'] == 'detached' or \\\n volumestate['State'] == 'busy':\n\n # Nuke all ebs volume\n EC2.delete_volume(VolumeId=volume['VolumeId'])\n logger.info(\"Nuke EBS Volume %s\", volume['VolumeId'])\n\n #### Nuke all snapshots ####\n# response = EC2.describe_snapshots()\n\n#\n# for snapshot in response['Snapshots']:\n# print(snapshot)\n# if snapshot['StartTime'].timestamp() < time_delete and \\\n# snapshot['OwnerAlias'] == 'self':\n#\n# # Nuke all ebs volume\n# EC2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])\n\n #### Nuke all ebs lifecycle manager ####\n response = DLM.get_lifecycle_policies()\n\n for ebslifecycle in response['Policies']:\n\n detailedresponse = DLM.get_lifecycle_policy(PolicyId=ebslifecycle['PolicyId'])\n\n if detailedresponse['Policy']['DateCreated'].timestamp() < time_delete:\n\n # Nuke all ebs volume\n DLM.delete_lifecycle_policy(PolicyId=detailedresponse['Policy']['PolicyId'])\n logger.info(\"Nuke EBS Lifecycle Policy %s\", detailedresponse['Policy']['PolicyId'])","def delete_all_images(self, index):\n self.__accessed_image[:] = False\n self.__check_delete_images()","def delete_all_runtimes(self):\n self.compute_handler.delete_all_runtimes()","def verify_no_snapshot_reingestion(c: Composition) -> None:\n c.run(\"testdrive\", \"wait-for-snapshot.td\", \"postgres-disable-select-permission.td\")\n\n restart_mz(c)\n\n c.run(\n \"testdrive\",\n \"delete-rows-t1.td\",\n \"delete-rows-t2.td\",\n \"alter-table.td\",\n \"alter-mz.td\",\n )","def delete_vs_content(vs_content_name, created_objects):\r\n if keep_objects:\r\n return\r\n custom_object_api_instance = client.CustomObjectsApi()\r\n try:\r\n custom_object_api_response = custom_object_api_instance.delete_cluster_custom_object(\r\n group=\"snapshot.storage.k8s.io\",\r\n version=\"v1\",\r\n plural=\"volumesnapshotcontents\",\r\n name=vs_content_name\r\n )\r\n LOGGER.debug(custom_object_api_response)\r\n created_objects[\"vscontent\"].remove(vs_content_name)\r\n LOGGER.info(f\"Volume Snapshot Content Delete : {vs_content_name} deleted\")\r\n except ApiException as e:\r\n LOGGER.error(f\"Exception when calling CustomObjectsApi->delete_cluster_custom_object_0: {e}\")\r\n clean_with_created_objects(created_objects)\r\n assert False","def delete(self):\n for i in set(self.instances.values()):\n i.delete()\n shutil.rmtree(self.dirpath, True)","def test_delete_snapshot(self):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n snapshot = {'id': '1', 'name': 'volume1',\n 'display_name': '',\n 'volume_type_id': type_ref['id'],\n 'size': 10,\n 'provider_id': 'snap10'}\n self.driver.delete_snapshot(snapshot)\n expected = {'name': 'snap10'}\n self.assertDictMatch(expected, self.deleted)","def detach(self, storages):\n self.tracer.info(\"%s.attach method called\" % self.__class__.__name__)\n\n # init variables & arrays\n all_pds = []\n all_vgs = []\n unmount_err = 0\n\n # reload global.ini\n self._cfg.reload()\n\n # connect to Google API\n conn = self.api_conn()\n\n # fetch the GCE zone for this host\n zone = self.get_zone(conn, HOSTNAME)\n\n for storage in storages:\n # fetch pd & dev variables for specified partition & usage\n connectionData = self._getConnectionDataForLun(storage.get(\"partition\"), storage.get(\"usage_type\"))\n try:\n pd = connectionData[\"pd\"]\n dev = connectionData[\"dev\"]\n except:\n raise Exception(\"pd or dev not set in global.ini\")\n\n # fetch the host which currently owns the disk & the file path\n path = storage.get(\"path\")\n\n # try to unmount the file system twice\n self._forcedUnmount(dev, path, 2)\n\n # if it's still mounted, try killing blocking processes and umount again\n if os.path.ismount(path):\n self._lsof_and_kill(path)\n self._forcedUnmount(dev, path, 2)\n\n # if still mounted, raise exception. The taking over node will stonith this host\n if os.path.ismount(path):\n self.tracer.warning(\"A PID belonging to someone other than SIDADM is blocking the unmount. This node will be fenced\")\n self._umount(path, lazy=True)\n mount_err = 1\n\n # add to list of devices.\n all_pds.append(pd)\n\n # check to see if the device is a VG. If so, add it to the list of VG's\n all_vgs.append(self.get_vg(dev))\n\n # Stop each unique VG\n all_vgs = list(set(all_vgs))\n for vg in all_vgs:\n Helper._runOsCommand(\"sudo /sbin/vgchange -an %s\" % vg, self.tracer)\n self.tracer.info(\"stopping volume group %s\" % (vg))\n\n # for each unique disk detected, detach it using Google API's\n all_pds = list(set(all_pds))\n for pd_member in all_pds:\n self.detach_pd(conn, HOSTNAME, pd_member)\n\n # if there was an error unmounting, self fence\n if unmount_err == 1:\n self.fence(conn, pdhost)\n\n # tell HANA we successfully detached\n return 0","def database_volume_delete(volume_uuid):\n db = database_get()\n session = db.session()\n query = session.query(model.Volume)\n query.filter(model.Volume.uuid == volume_uuid).delete()\n session.commit()","def _cleanup_deleted_os_disks(self):\n try:\n disks = self.disks.list_by_resource_group(\n CONF.azure.resource_group)\n except Exception as e:\n LOG.warning(_LW(\"Unable to delete disks\"\n \" in Azure because %(reason)s\"),\n dict(reason=six.text_type(e)))\n return\n # blobs is and iterable obj, although it's empty.\n if not disks:\n LOG.info(_LI('No residual Disk in Azure'))\n return\n for i in disks:\n if self._is_os_disk(i.name) and not i.owner_id:\n try:\n self.disks.delete(CONF.azure.resource_group, i.name)\n except Exception as e:\n LOG.warning(_LW(\"Unable to delete os disk %(disk)s\"\n \"in Azure because %(reason)s\"),\n dict(disk=i.name,\n reason=six.text_type(e)))\n else:\n LOG.info(_LI(\"Delete residual os disk: %s in\"\n \" Azure\"), i.name)\n else:\n LOG.info(_LI('Delete all residual disks in Azure'))","def cleanup(cloud, prefix, timeout=600, interval=10):\n global RECYCLE\n\n # Get nodes with prefix\n procs, nodes = [], cloud.get_nodes_by_prefix(prefix)\n if nodes:\n log.info(f\"Nodes with prefix '{prefix}' are {', '.join(nodes)}\")\n else:\n log.error(f\"No nodes are available with prefix '{prefix}'\")\n\n # Start deleting nodes in parallel\n for node in nodes:\n proc = mp.Process(target=delete_node, args=(node, cloud, timeout, interval))\n proc.start()\n procs.append(proc)\n\n # Wait till all nodes gets cleaned\n [p.join() for p in procs]\n\n # Get nodes woth prefix\n procs, volumes = [], cloud.get_volumes_by_prefix(prefix)\n if volumes:\n log.info(f\"Volumes with prefix '{prefix}' are {', '.join(volumes)}\")\n else:\n log.error(f\"No volumes available with prefix '{prefix}'.\")\n\n # Start deleting volumes in parallel\n for volume in volumes:\n proc = mp.Process(target=delete_volume, args=(volume, cloud, timeout, interval))\n proc.start()\n procs.append(proc)\n\n # Wait till all volumes gets cleaned\n [p.join() for p in procs]\n\n # Check if any resource deletion failed\n stale = [r.name for r in RECYCLE if r.state]\n if stale:\n msg = f\"Failed to clean resources {', '.join(stale)}\"\n log.error(msg)\n raise OperationFailedError(msg)\n\n return True","def destroy_all(self) -> None:\n try:\n containers = self.docker.containers.list(\n all=True,\n filters={\n 'label': LABEL_TASK_ID,\n },\n )\n\n for container in containers:\n container.remove(force=True)\n\n except requests.exceptions.ConnectionError:\n raise ProviderError('Docker engine unavailable')","def deleteShards():\n os.popen('rm *_shard')","def delete_snapshot(self, snapshot):\n self._impl.delete_snapshot(snapshot)","def list_volumes(self):\n print '# Listing existing volumes'\n self.compute.list_volumes()","def run(connection, volume_id, interval='daily', max_snapshots=0, name=''):\n try:\n volumes = connection.get_all_volumes([volume_id])\n except EC2ResponseError as error:\n logging.error(kayvee.formatLog(\"ebs-snapshots\", \"error\", \"failed to connect to AWS\", {\"msg\": error.message}))\n return\n\n for volume in volumes:\n _ensure_snapshot(connection, volume, interval, name)\n _remove_old_snapshots(connection, volume, max_snapshots)","def delete_images(region, image_id_list):\n conn = boto.ec2.connect_to_region(region)\n for image_id in image_id_list:\n sys.stderr.write('Deleting {}\\n'.format(image_id))\n conn.deregister_image(image_id, delete_snapshot=True)","def destroy(name, call=None):\n if call == \"function\":\n raise SaltCloudSystemExit(\n \"The destroy action must be called with -d, --destroy, -a or --action.\"\n )\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroying instance\",\n \"salt/cloud/{}/destroying\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n datacenter_id = get_datacenter_id()\n conn = get_conn()\n node = get_node(conn, name)\n attached_volumes = None\n\n delete_volumes = config.get_cloud_config_value(\n \"delete_volumes\", get_configured_provider(), __opts__, search_global=False\n )\n # Get volumes before the server is deleted\n attached_volumes = conn.get_attached_volumes(\n datacenter_id=datacenter_id, server_id=node[\"id\"]\n )\n\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\"id\"])\n\n # The server is deleted and now is safe to delete the volumes\n if delete_volumes:\n for vol in attached_volumes[\"items\"]:\n log.debug(\"Deleting volume %s\", vol[\"id\"])\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\"id\"])\n log.debug(\"Deleted volume %s\", vol[\"id\"])\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroyed instance\",\n \"salt/cloud/{}/destroyed\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n if __opts__.get(\"update_cachedir\", False) is True:\n __utils__[\"cloud.delete_minion_cachedir\"](\n name, _get_active_provider_name().split(\":\")[0], __opts__\n )\n\n return True","def vm_snapshotlist(args):\n snapshot = args.snapshot\n name = args.name\n config = Kconfig(client=args.client, debug=args.debug, region=args.region, zone=args.zone, namespace=args.namespace)\n k = config.k\n common.pprint(\"Listing snapshots of %s...\" % name)\n snapshots = k.snapshot(snapshot, name, listing=True)\n if isinstance(snapshots, dict):\n common.pprint(\"Vm %s not found\" % name, color='red')\n return\n else:\n for snapshot in snapshots:\n print(snapshot)\n return","def destroy(self):\r\n\r\n return self.driver.destroy_volume(volume=self)","def delete_snapshot(SnapshotId=None):\n pass","def delete_snapshot(self, context, snapshot_id):\n caller_context = context\n context = context.elevated()\n snapshot_ref = self.db.snapshot_get(context, snapshot_id)\n project_id = snapshot_ref['project_id']\n\n LOG.info(_(\"snapshot %s: deleting\"), snapshot_ref['id'])\n self._notify_about_snapshot_usage(\n context, snapshot_ref, \"delete.start\")\n\n try:\n LOG.debug(_(\"snapshot %s: deleting\"), snapshot_ref['id'])\n\n # Pass context so that drivers that want to use it, can,\n # but it is not a requirement for all drivers.\n snapshot_ref['context'] = caller_context\n\n self._delete_snapshot_cascaded(context, snapshot_id)\n except exception.SnapshotIsBusy:\n LOG.error(_(\"Cannot delete snapshot %s: snapshot is busy\"),\n snapshot_ref['id'])\n self.db.snapshot_update(context,\n snapshot_ref['id'],\n {'status': 'available'})\n return True\n except Exception:\n with excutils.save_and_reraise_exception():\n self.db.snapshot_update(context,\n snapshot_ref['id'],\n {'status': 'error_deleting'})\n\n # Get reservations\n try:\n if CONF.no_snapshot_gb_quota:\n reserve_opts = {'snapshots': -1}\n else:\n reserve_opts = {\n 'snapshots': -1,\n 'gigabytes': -snapshot_ref['volume_size'],\n }\n volume_ref = self.db.volume_get(context, snapshot_ref['volume_id'])\n QUOTAS.add_volume_type_opts(context,\n reserve_opts,\n volume_ref.get('volume_type_id'))\n reservations = QUOTAS.reserve(context,\n project_id=project_id,\n **reserve_opts)\n except Exception:\n reservations = None\n LOG.exception(_(\"Failed to update usages deleting snapshot\"))\n self.db.volume_glance_metadata_delete_by_snapshot(context, snapshot_id)\n self.db.snapshot_destroy(context, snapshot_id)\n LOG.info(_(\"snapshot %s: deleted successfully\"), snapshot_ref['id'])\n self._notify_about_snapshot_usage(context, snapshot_ref, \"delete.end\")\n\n # Commit the reservations\n if reservations:\n QUOTAS.commit(context, reservations, project_id=project_id)\n return True","def main(pods_fname):\n \n pods = ReadPodsToBeDeleted(pods_fname)\n\n print(\"To remove PODs: {0}\".format(len(pods)))\n \n for pod in pods:\n cmd = \"kubectl delete pod \" + pod\n rc = 0\n for k in range(0, 12): # several attempts to make a pod\n rc = subprocess.call(cmd, shell=True)\n if rc == 0:\n break\n\n if rc != 0:\n print(\"Cannot delete pod {0}\".format(pod))\n sys.exit(1)","def delete(self):\r\n return self.connection.delete_volume(self.id)","def cleanup_mounts(mounts):\n if isinstance(mounts, str):\n mounts = [mounts]\n\n g.log.info(\"Start cleanup mounts\")\n all_mounts_procs = []\n valid_mounts = []\n for mount_obj in mounts:\n g.log.info(\"Cleaning up data from %s:%s\", mount_obj.client_system,\n mount_obj.mountpoint)\n if (not mount_obj.mountpoint or\n (os.path.realpath(os.path.abspath(mount_obj.mountpoint))\n is '/')):\n g.log.error(\"%s on %s is not a valid mount point\",\n mount_obj.mountpoint, mount_obj.client_system)\n continue\n cmd = \"rm -rf %s/*\" % (mount_obj.mountpoint)\n proc = g.run_async(mount_obj.client_system, cmd,\n user=mount_obj.user)\n all_mounts_procs.append(proc)\n valid_mounts.append(mount_obj)\n g.log.info(\"rm -rf on all clients is complete. Validating \"\n \"deletion now...\")\n\n # Get cleanup status\n _rc_rmdir = True\n for i, proc in enumerate(all_mounts_procs):\n ret, out, err = proc.async_communicate()\n if ret != 0 or out or err:\n g.log.error(\"Deleting files/dirs Failed on %s:%s\",\n valid_mounts[i].client_system,\n valid_mounts[i].mountpoint)\n _rc_rmdir = False\n else:\n g.log.info(\"Deleting files/dirs is successful on %s:%s\",\n valid_mounts[i].client_system,\n valid_mounts[i].mountpoint)\n if _rc_rmdir:\n g.log.info(\"Successfully deleted files/dirs from all mounts\")\n else:\n g.log.error(\"Deleting files/dirs failed on some of the mounts\")\n\n # Check if mount points are empty\n ignore_dirs_list = [\".trashcan\"]\n ignore_dirs = \"\\|\".join(ignore_dirs_list)\n all_mounts_procs = []\n for mount_obj in mounts:\n cmd = (\"find %s -mindepth 1 | grep -ve '%s'\" %\n (mount_obj.mountpoint, ignore_dirs))\n proc = g.run_async(mount_obj.client_system, cmd,\n user=mount_obj.user)\n all_mounts_procs.append(proc)\n\n # Get cleanup status\n _rc_lookup = True\n for i, proc in enumerate(all_mounts_procs):\n ret, out, err = proc.async_communicate()\n if ret == 0:\n g.log.error(\"Mount %s on %s is still having entries:\\n%s\",\n mounts[i].mountpoint, mounts[i].client_system, out)\n _rc_lookup = False\n else:\n g.log.info(\"Mount %s on %s is cleaned up\\n%s\",\n mounts[i].mountpoint, mounts[i].client_system, out)\n if _rc_lookup:\n g.log.info(\"All the mounts are successfully cleaned up\")\n else:\n g.log.error(\"Failed to cleanup all mounts\")\n\n # List mounts entries\n g.log.info(\"Listing mounts entries:\")\n list_all_files_and_dirs_mounts(mounts)\n\n return _rc_lookup","def volume_delete_by_storage(context, storage_id):\n _volume_get_query(context).filter_by(storage_id=storage_id).delete()","def purge():\n all_hashes = read_all()\n used_hashes = read_used()\n\n for kind, hashes in used_hashes.items():\n to_remove = all_hashes[kind].difference(hashes)\n if kind == 'evs':\n delete_from_directory_by_hashes(EV_DIRECTORY, to_remove)\n elif kind == 'cache':\n delete_from_directory_by_hashes(CACHE_DIRECTORY, to_remove)\n elif kind == 'seeds':\n delete_from_directory_by_hashes(SEED_DIRECTORY, to_remove)\n\n reset_used()","def test_delete_volumes(self, volumes_count, volumes_steps,\n create_volumes):\n volume_names = list(generate_ids('volume', count=volumes_count))\n create_volumes(volume_names)","async def purge_snapshots(self):\n now = datetime.now(timezone.utc)\n\n snapshots_purged = []\n for slug, expires in self._snapshots_expiry.copy().items():\n if expires < now:\n if await self._purge_snapshot(slug):\n snapshots_purged.append(slug)\n\n if len(snapshots_purged) == 1:\n _LOGGER.info(\"Purged 1 snapshot; %s\", snapshots_purged[0])\n elif len(snapshots_purged) > 1:\n _LOGGER.info(\n \"Purged %s snapshots; %s\",\n len(snapshots_purged),\n tuple(snapshots_purged),\n )\n\n if len(snapshots_purged) > 0:\n self._hass.bus.async_fire(\n f\"{DOMAIN}.purged_snapshots\", {\"snapshots\": snapshots_purged}\n )\n\n # update sensor after purge.\n if self.update_sensor_callback:\n self.update_sensor_callback()\n else:\n _LOGGER.debug(\"No snapshots required purging.\")","def cli(ctx):\n stopped = click.style(\"Stopped\", fg=\"red\")\n removed = click.style(\"Removed\", fg=\"blue\")\n for container in ctx.docker.get_containers():\n name = container.hostname\n node_name = ''.join([i for i in name if not i.isdigit()])\n image_name = container.dictionary['Config']['Image']\n if node_name in TO_KILL:\n container.stop(timeout=0)\n else:\n container.stop(timeout=5)\n # container.execute(\"poweroff\", \"root\", \"/\", False)\n # container.wait()\n ctx.log(\"Container %s --> %s\" % (name, stopped))\n container.remove(v=False, link=False, force=True)\n ctx.log(\"Container %s --> %s\" % (name, removed))\n ctx.state['containers'].remove(container.short_id)\n ctx.state.fast_dump()\n # remove untagged image\n if not image_name.startswith(ctx.prefix):\n ctx.docker.remove_image(image_name, force=True)\n ctx.docker.remove_network()","def delete_snapshot(session, snapshot, network):\n # type: (Session, Text, Text) -> None\n url_tail = \"/{}/{}/{}/{}\".format(\n CoordConstsV2.RSC_NETWORKS, network, CoordConstsV2.RSC_SNAPSHOTS, snapshot\n )\n return _delete(session, url_tail)","def delete_cluster(self):","def execute(self):\n\n c = self.config\n regions = dict((x.name, x) for x in boto.ec2.regions(\n aws_access_key_id=c['access_key'],\n aws_secret_access_key=c['secret_access_key']))\n connect = regions[c['region']].connect(\n aws_access_key_id=c['access_key'],\n aws_secret_access_key=c['secret_access_key'])\n volume = connect.get_all_volumes([c['volume_id']])[0]\n volume.create_snapshot(c['volume_id'])\n snapshots = {}\n for x in connect.get_all_snapshots():\n if x.volume_id == c['volume_id']:\n snapshots.update({x.id: x.start_time})\n snapshots = sorted(snapshots.items(), key=lambda (k, v): (v, k), reverse=True)\n for i in range(int(c['keep']), len(snapshots)):\n connect.delete_snapshot(snapshots[i][0])","def delete(self, arguments):\n name = arguments['<name>']\n\n instance_name = arguments['<instance>']\n instance_name = self.activate(instance_name)\n\n vmrun = VMrun(self.vmx, user=self.user, password=self.password)\n if vmrun.deleteSnapshot(name) is None:\n puts_err(colored.red(\"Cannot delete name\"))\n else:\n puts_err(colored.green(\"Snapshot {} deleted\".format(name)))","def s3_delete_data(self):\n\n self.k.delete()","def delete_volume_snapshots(\n self,\n references=None, # type: List[models.ReferenceType]\n authorization=None, # type: str\n x_request_id=None, # type: str\n ids=None, # type: List[str]\n names=None, # type: List[str]\n async_req=False, # type: bool\n _return_http_data_only=False, # type: bool\n _preload_content=True, # type: bool\n _request_timeout=None, # type: Optional[int]\n ):\n # type: (...) -> None\n kwargs = dict(\n authorization=authorization,\n x_request_id=x_request_id,\n ids=ids,\n names=names,\n async_req=async_req,\n _return_http_data_only=_return_http_data_only,\n _preload_content=_preload_content,\n _request_timeout=_request_timeout,\n )\n kwargs = {k: v for k, v in kwargs.items() if v is not None}\n endpoint = self._volume_snapshots_api.api20_volume_snapshots_delete_with_http_info\n _process_references(references, ['ids', 'names'], kwargs)\n return self._call_api(endpoint, kwargs)","def delete(**_):\n\n volume_id = utils.get_external_resource_id_or_raise(\n 'delete EBS volume', ctx.instance)\n\n if _delete_external_volume():\n return\n\n ctx.logger.debug('Deleting EBS volume: {0}'.format(volume_id))\n\n if not _delete_volume(volume_id):\n return ctx.operation.retry(\n message='Failed to delete volume {0}.'\n .format(volume_id))\n\n utils.unassign_runtime_property_from_resource(\n constants.ZONE, ctx.instance)\n\n utils.unassign_runtime_property_from_resource(\n constants.EXTERNAL_RESOURCE_ID, ctx.instance)\n\n ctx.logger.info(\n 'Deleted EBS volume: {0}.'\n .format(volume_id))","def test_delete_db_cluster_snapshot_no_wait(self):\n _create_db_cluster(self.hook)\n _create_db_cluster_snapshot(self.hook)\n\n cluster_snapshot_operator = RdsDeleteDbSnapshotOperator(\n task_id=\"test_delete_db_cluster_snapshot_no_wait\",\n db_type=\"cluster\",\n db_snapshot_identifier=DB_CLUSTER_SNAPSHOT,\n aws_conn_id=AWS_CONN,\n dag=self.dag,\n wait_for_completion=False,\n )\n _patch_hook_get_connection(cluster_snapshot_operator.hook)\n with patch.object(cluster_snapshot_operator.hook, \"wait_for_db_cluster_snapshot_state\") as mock_wait:\n cluster_snapshot_operator.execute(None)\n mock_wait.assert_not_called()\n\n with pytest.raises(self.hook.conn.exceptions.ClientError):\n self.hook.conn.describe_db_cluster_snapshots(DBClusterSnapshotIdentifier=DB_CLUSTER_SNAPSHOT)","def delete(self, volume_id):\n self.client().volumes.delete(volume_id)","def test_csi_volumesnapshot_restore_existing_backup(set_random_backupstore, # NOQA\n client, # NOQA\n core_api, # NOQA\n volume_name, # NOQA\n csi_pv, # NOQA\n pvc, # NOQA\n pod_make, # NOQA\n volumesnapshotclass, # NOQA\n volumesnapshotcontent,\n volumesnapshot, # NOQA\n volsnapshotclass_delete_policy, # NOQA\n backup_is_deleted): # NOQA\n csisnapclass = \\\n volumesnapshotclass(name=\"snapshotclass\",\n deletepolicy=volsnapshotclass_delete_policy)\n\n pod_name, pv_name, pvc_name, md5sum = \\\n prepare_pod_with_data_in_mb(client, core_api,\n csi_pv, pvc, pod_make,\n volume_name,\n data_path=\"/data/test\")\n\n volume = client.by_id_volume(volume_name)\n snap = create_snapshot(client, volume_name)\n volume.snapshotBackup(name=snap.name)\n wait_for_backup_completion(client, volume_name, snap.name)\n bv, b = find_backup(client, volume_name, snap.name)\n\n csivolsnap_name = volume_name + \"-volumesnapshot\"\n csivolsnap_namespace = \"default\"\n\n volsnapcontent = \\\n volumesnapshotcontent(\"volsnapcontent\",\n csisnapclass[\"metadata\"][\"name\"],\n \"Delete\",\n \"bs://\" + volume_name + \"/\" + b.name,\n csivolsnap_name,\n csivolsnap_namespace)\n\n csivolsnap = volumesnapshot(csivolsnap_name,\n csivolsnap_namespace,\n csisnapclass[\"metadata\"][\"name\"],\n \"volumeSnapshotContentName\",\n volsnapcontent[\"metadata\"][\"name\"])\n\n restore_pvc_name = pvc[\"metadata\"][\"name\"] + \"-restore\"\n restore_pvc_size = pvc[\"spec\"][\"resources\"][\"requests\"][\"storage\"]\n\n restore_csi_volume_snapshot(core_api,\n client,\n csivolsnap,\n restore_pvc_name,\n restore_pvc_size)\n\n restore_pod = pod_make()\n restore_pod_name = restore_pod[\"metadata\"][\"name\"]\n restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]\n\n create_and_wait_pod(core_api, restore_pod)\n restore_md5sum = \\\n get_pod_data_md5sum(core_api, restore_pod_name, path=\"/data/test\")\n\n assert restore_md5sum == md5sum\n\n # Delete volumeSnapshot test\n delete_volumesnapshot(csivolsnap[\"metadata\"][\"name\"], \"default\")\n\n if backup_is_deleted is False:\n find_backup(client, volume_name, b[\"snapshotName\"])\n else:\n wait_for_backup_delete(client, volume_name, b[\"name\"])","def clear_instances(cls, args, config):\n instance_list = config.get_all_instances()\n if len(instance_list) > 0:\n for i in instance_list:\n print i\n config.delete_instance(i)\n print \"instance {0} deleted\".format(i.id)\n else:\n print \"No instance found\"","def purge_volume(self, volume_path, data_isolated=False):\n\n trash = os.path.join(self.volume_prefix, \"_deleting\")\n trashed_volume = os.path.join(trash, volume_path.volume_id)\n\n try:\n self.fs.stat(trashed_volume)\n except cephfs.ObjectNotFound:\n log.warning(\"Trying to purge volume '{0}' but it's already been purged\".format(\n trashed_volume))\n return\n\n def rmtree(root_path):\n log.debug(\"rmtree {0}\".format(root_path))\n dir_handle = self.fs.opendir(root_path)\n d = self.fs.readdir(dir_handle)\n while d:\n if d.d_name not in [\".\", \"..\"]:\n # Do not use os.path.join because it is sensitive\n # to string encoding, we just pass through dnames\n # as byte arrays\n d_full = \"{0}/{1}\".format(root_path, d.d_name)\n if d.is_dir():\n rmtree(d_full)\n else:\n self.fs.unlink(d_full)\n\n d = self.fs.readdir(dir_handle)\n self.fs.closedir(dir_handle)\n\n self.fs.rmdir(root_path)\n\n rmtree(trashed_volume)\n\n if data_isolated:\n pool_name = \"{0}{1}\".format(self.POOL_PREFIX, volume_path.volume_id)\n osd_map = self._rados_command(\"osd dump\", {})\n pool_id = self._get_pool_id(osd_map, pool_name)\n mds_map = self._rados_command(\"mds dump\", {})\n if pool_id in mds_map['data_pools']:\n self._rados_command(\"mds remove_data_pool\", {\n 'pool': pool_name\n })\n self._rados_command(\"osd pool delete\",\n {\n \"pool\": pool_name,\n \"pool2\": pool_name,\n \"sure\": \"--yes-i-really-really-mean-it\"\n })","def delete_all(self):\n return self.context.delete(\"/ckks/all\", None,\n \"CKKS:: failed deleting all the CKKS data\"\n )","def delete_snapshot(self, pool, project, share, snapshot):\n svc = self.snapshot_path % (pool, project, share, snapshot)\n ret = self.rclient.delete(svc)\n if ret.status != restclient.Status.NO_CONTENT:\n exception_msg = (_('Error deleting '\n 'snapshot: %(snapshot)s on '\n 'share: %(share)s to '\n 'pool: %(pool)s '\n 'project: %(project)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'snapshot': snapshot,\n 'share': share,\n 'pool': pool,\n 'project': project,\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n LOG.error(exception_msg)\n raise exception.ShareBackendException(msg=exception_msg)","def delete_cloud_objects(chunk):\n container_name, cloud_objs = chunk\n conn = swiftclient.Connection(authurl=CUMULUS[\"AUTH_URL\"],\n user=CUMULUS[\"USERNAME\"],\n key=CUMULUS[\"API_KEY\"],\n snet=CUMULUS[\"SERVICENET\"],\n auth_version=CUMULUS[\"AUTH_VERSION\"],\n tenant_name=CUMULUS[\"AUTH_TENANT_NAME\"])\n filter(None, cloud_objs)\n deleted = []\n for cloud_obj in cloud_objs:\n conn.delete_object(container=container_name,\n obj=cloud_obj)\n deleted.append(cloud_obj)\n return deleted","def test_aws_service_api_volume_attachment_delete(self):\n pass","def generate_osd_list(ceph_cluster: Ceph):\n client = ceph_cluster.get_ceph_object(\"installer\")\n ceph_osds = ceph_cluster.get_ceph_objects(\"osd\")\n osd_nodes = set()\n disk_list = set()\n for osd in ceph_osds:\n osd_nodes.add(osd.node.vmshortname)\n osd_node_list = list(osd_nodes)\n log.info(osd_node_list)\n for osn in osd_node_list:\n for osd in ceph_osds:\n if osd.node.vmshortname == osn:\n for i in osd.node.vm_node.volumes:\n disk_list.add(i)\n osd_disk_list = list(disk_list)\n log.info(osd_disk_list)\n log.info(len(osd_disk_list))\n dump_osd_data(client, osn, osd_disk_list)\n disk_list.clear()\n osd_disk_list.clear()","def cleanup(cloud, prefix):\n # Get cloud configuration\n configs = get_cloud_credentials(cloud)\n\n # Get nodes with prefix\n procs, nodes = [], _get_nodes(prefix, cloud, configs)\n\n # Start deleting nodes in parallel\n for node, _ in nodes:\n proc = mp.Process(\n target=delete_node,\n args=(\n node,\n cloud,\n configs,\n ),\n )\n proc.start()\n procs.append(proc)\n\n # Wait till all nodes gets cleaned\n [p.join() for p in procs]\n\n log.info(f\"Cleaned cluster with prefix '{prefix}' sucessfully\")\n return True","def terminate_preemptible_instances(self, context, instances):\n # NOTE(aloga): we should not delete them directly, but probably send\n # them a signal so that the user is able to save her work.\n elevated = context.elevated()\n for instance in instances:\n LOG.info(_LI(\"Deleting %(uuid)s\") % {\"uuid\": instance[\"uuid\"]})\n instance = self.compute_api.get(elevated,\n instance[\"uuid\"],\n want_objects=True)\n self.compute_api.delete(elevated, instance)","def check_vs_content_deleted(vs_content_name, created_objects):\r\n if keep_objects:\r\n return\r\n api_instance = client.CustomObjectsApi()\r\n val = 0\r\n while val < 12:\r\n try:\r\n api_response = api_instance.get_cluster_custom_object(\r\n group=\"snapshot.storage.k8s.io\",\r\n version=\"v1beta1\",\r\n plural=\"volumesnapshotcontents\",\r\n name=vs_content_name\r\n )\r\n LOGGER.debug(api_response)\r\n time.sleep(15)\r\n LOGGER.info(f\"Volume Snapshot Content Delete : Checking deletion {vs_content_name}\")\r\n val += 1\r\n except ApiException:\r\n LOGGER.info(f\"Volume Snapshot Content Delete : {vs_content_name} deletion confirmed\")\r\n return\r\n LOGGER.error(f\"Volume Snapshot Content Delete : {vs_content_name} is not deleted , asserting\")\r\n clean_with_created_objects(created_objects)\r\n assert False","def clean(all):\n docker_clean(all)","def delete_old():\n objs = (Snapshot\n .objects\n .filter(timestamp__lte=(datetime.now() - timedelta(days=35)))\n )\n objs.delete()","def test_amazon_s3_delete_all_keys(self):\n config = Config()\n metadata_bucket = config.config.get(\"metadata\", \"bucket\")\n data_bucket = config.config.get(\"data\", \"bucket\")\n metadata_provider = amazon.S3(config, metadata_bucket).connect()\n provider = amazon.S3(config, data_bucket).connect()\n for key, metadata in metadata_provider.list().items():\n metadata_provider.delete(key)\n for key, data in provider.list().items():\n provider.delete(key)\n metadata_provider.disconnect()\n provider.disconnect()","def terminateCluster():\n try:\n # delete cluster\n redshift.delete_cluster(\n ClusterIdentifier=DWH_CLUSTER_IDENTIFIER,\n SkipFinalClusterSnapshot=True\n )\n\n # clear up role\n iam.detach_role_policy(\n RoleName=DWH_IAM_ROLE_NAME,\n PolicyArn=\"arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess\"\n )\n iam.delete_role(RoleName=DWH_IAM_ROLE_NAME)\n except Exception as e:\n print(e)","def _delete_image_volume(self,\n context: context.RequestContext,\n cache_entry: dict) -> None:\n volume = objects.Volume.get_by_id(context, cache_entry['volume_id'])\n\n # Delete will evict the cache entry.\n self.volume_api.delete(context, volume)","def command_unmount_all(self):\n has_failed = False\n for system_id in self.environment.get_mounted_ids():\n try:\n system = SystemModel.create_by_id(system_id, self.environment)\n controller = SystemControllerModel(system, self.environment)\n controller.unmount()\n except SftpConfigException as e:\n sys.stderr.write('Cannot unmount %s: %s\\n\\n' % (system_id, str(e)))\n has_failed = True\n sys.exit(0 if not has_failed else 1)","def check_pvc_deleted(pvc_name, volume_name, created_objects):\r\n if keep_objects:\r\n return\r\n count = 12\r\n api_instance = client.CoreV1Api()\r\n while (count > 0):\r\n try:\r\n api_response = api_instance.read_namespaced_persistent_volume_claim(\r\n name=pvc_name, namespace=namespace_value, pretty=True)\r\n LOGGER.debug(str(api_response))\r\n count = count-1\r\n time.sleep(15)\r\n LOGGER.info(f'PVC Delete : Checking deletion for pvc {pvc_name}')\r\n except ApiException:\r\n LOGGER.info(f'PVC Delete : pvc {pvc_name} deleted')\r\n ff.delete_created_fileset(volume_name)\r\n return\r\n\r\n LOGGER.error(f'pvc {pvc_name} is not deleted')\r\n clean_with_created_objects(created_objects)\r\n assert False","def fusion_api_delete_storage_volume(self, name=None, uri=None, param='', api=None, headers=None):\n return self.volume.delete(name=name, uri=uri, param=param, api=api, headers=headers)","def RemoveOldSnapshots(desktop):\n # Compute the file prefix of a snapshot created one day ago.\n yesterday = datetime.datetime.now() - datetime.timedelta(1)\n old_snapshot = yesterday.strftime('ChromiumSnapshot%Y%m%d%H%M%S')\n # Collect snapshots at least as old as that one created a day ago.\n to_delete = []\n for snapshot in glob.iglob(os.path.join(desktop, 'ChromiumSnapshot*.png')):\n if os.path.basename(snapshot) < old_snapshot:\n to_delete.append(snapshot)\n # Delete the collected snapshots.\n for snapshot in to_delete:\n print 'Removing old snapshot: %s' % snapshot\n try:\n os.remove(snapshot)\n except OSError, e:\n print >> sys.stderr, e"],"string":"[\n \"def snap_delete_all(mnode):\\n cmd = \\\"gluster snapshot delete all --mode=script\\\"\\n return g.run(mnode, cmd)\",\n \"def delete_volume_snapshot(volume_snapshots):\\n if type(volume_snapshots) is not list:\\n volumes = [volume_snapshots]\\n command = 'cinder snapshot-delete %s' % \\\\\\n \\\" \\\".join(snapshot['id'] for snapshot in volume_snapshots)\\n d = Popen(command.split(), stdout=STDOUT, stderr=STDERR).communicate()[0]\",\n \"def delete_all(k8s_ctx: str, dry_run: bool = False) -> List[str]:\\n commands1 = [f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=setup',\\n f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=blast']\\n commands2 = [f'kubectl --context={k8s_ctx} delete pvc --all --force=true',\\n f'kubectl --context={k8s_ctx} delete pv --all --force=true',\\n f'kubectl --context={k8s_ctx} delete volumesnapshots --all --ignore-not-found=true --force=true']\\n\\n def run_commands(commands: List[str], dry_run: bool) -> List[str]:\\n \\\"\\\"\\\" Run the commands in the argument list and return the names of the relevant k8s objects.\\n This function is specific to delete_all.\\n \\\"\\\"\\\"\\n result = []\\n for cmd in commands:\\n if dry_run:\\n logging.info(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n for line in p.stdout.decode().split('\\\\n'):\\n if line:\\n if line.startswith('No resources found'):\\n # nothing was deleted\\n break\\n fields = line.rstrip().split()\\n if len(fields) > 1:\\n result.append(fields[1])\\n else:\\n result.append(fields[0])\\n return result\\n\\n def delete_finalizers(k8s_ctx: str, dry_run: bool = False):\\n \\\"\\\"\\\" Delete finalizers to ensure PV and PVC get deleted\\n https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#finalizers\\n \\\"\\\"\\\"\\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\\n for storage_obj in run_commands([cmd], dry_run):\\n cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '\\n cmd += '{\\\"metadata\\\":{\\\"finalizers\\\":null}}'\\n logging.debug(cmd)\\n if dry_run:\\n logging.debug(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n logging.debug(p.stdout.decode().rstrip())\\n\\n def inspect_storage_objects_for_debugging(k8s_ctx: str, dry_run: bool = False):\\n \\\"\\\"\\\" Retrieve information about PV and PVC from kubectl and log it for debugging purposes. \\\"\\\"\\\"\\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\\n for storage_obj in run_commands([cmd], dry_run):\\n cmd = f'kubectl --context={k8s_ctx} describe {storage_obj}'\\n if dry_run:\\n logging.debug(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n for line in p.stdout.decode().split('\\\\n'):\\n if line.startswith(\\\"Status\\\") or line.startswith(\\\"Finalizers\\\"):\\n logging.debug(f'{storage_obj} {line}')\\n\\n inspect_storage_objects_for_debugging(k8s_ctx, dry_run)\\n # Delete the jobs first, wait, then delete the pvc and pv\\n deleted1 = run_commands(commands1, dry_run)\\n if not dry_run:\\n secs2sleep = int(os.getenv('ELB_PAUSE_AFTER_INIT_PV', str(ELB_PAUSE_AFTER_INIT_PV)))\\n time.sleep(secs2sleep)\\n delete_finalizers(k8s_ctx, dry_run)\\n inspect_storage_objects_for_debugging(k8s_ctx, dry_run)\\n deleted2 = run_commands(commands2, dry_run)\\n return deleted1 + deleted2\",\n \"def delete_volumes(volumes):\\n if type(volumes) is not list:\\n volumes = [volumes]\\n for volume in volumes:\\n command = 'cinder delete %s' % volume['id']\\n a = Popen(command.split(), stdout=STDOUT, stderr=STDERR).communicate()[0]\",\n \"def destroy_cluster(self, log_level=\\\"DEBUG\\\"):\\n super(AWSIPI, self).destroy_cluster(log_level)\\n\\n try:\\n # Retrieve cluster name and AWS region from metadata\\n cluster_name = self.ocp_deployment.metadata.get(\\\"clusterName\\\")\\n # Find and delete volumes\\n volume_pattern = f\\\"{cluster_name}*\\\"\\n logger.debug(f\\\"Finding volumes with pattern: {volume_pattern}\\\")\\n volumes = self.aws.get_volumes_by_name_pattern(volume_pattern)\\n logger.debug(f\\\"Found volumes: \\\\n {volumes}\\\")\\n for volume in volumes:\\n self.aws.detach_and_delete_volume(\\n self.aws.ec2_resource.Volume(volume['id'])\\n )\\n except Exception:\\n logger.error(traceback.format_exc())\",\n \"def delete(self):\\n for lv in self.logical_volumes:\\n self.delete_lv(lv_name=lv)\\n\\n super().delete()\",\n \"def detach_all_volumes(self):\\n nova_connection = self.source_connection.get_nova_connection(self.source_region_name)\\n loop = asyncio.get_event_loop()\\n try:\\n loop.run_until_complete(self.resource_manager.detach_all_volume(nova_connection))\\n except:\\n raise\",\n \"def database_volume_snapshot_delete(volume_snapshot_uuid):\\n db = database_get()\\n session = db.session()\\n query = session.query(model.VolumeSnapshot)\\n query.filter(model.VolumeSnapshot.uuid == volume_snapshot_uuid).delete()\\n session.commit()\",\n \"def cli(env, snapshot_id):\\n block_manager = SoftLayer.BlockStorageManager(env.client)\\n deleted = block_manager.delete_snapshot(snapshot_id)\\n\\n if deleted:\\n click.echo('Snapshot %s deleted' % snapshot_id)\",\n \"def delete_finalizers(k8s_ctx: str, dry_run: bool = False):\\n cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'\\n for storage_obj in run_commands([cmd], dry_run):\\n cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '\\n cmd += '{\\\"metadata\\\":{\\\"finalizers\\\":null}}'\\n logging.debug(cmd)\\n if dry_run:\\n logging.debug(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n logging.debug(p.stdout.decode().rstrip())\",\n \"def reap_snapshots(vcenter, logger):\\n all_users = vcenter.get_by_name(name=const.INF_VCENTER_USERS_DIR, vimtype=vim.Folder)\\n for username in all_users.childEntity:\\n vms = vcenter.get_by_name(name=username.name, vimtype=vim.Folder)\\n for vm in vms.childEntity:\\n if vm.snapshot:\\n vm_snaps = _get_snapshots(vm.snapshot.rootSnapshotList)\\n for snap in vm_snaps:\\n if is_expired(snap.name):\\n logger.info(\\\"deleteing snap {} of VM {} owned by {}\\\".format(snap, vm.name, username))\\n consume_task(snap.snapshot.RemoveSnapshot_Task(removeChildren=False))\",\n \"def resources_cleanup(namespace, image_uuids=None):\\n resources = [\\n constants.DEPLOYMENT,\\n constants.POD,\\n constants.VOLUME_REPLICATION_GROUP,\\n constants.VOLUME_REPLICATION,\\n constants.PVC,\\n constants.PV,\\n ]\\n log.info(\\\"Cleaning up leftover resources in managed clusters\\\")\\n for cluster in get_non_acm_cluster_config():\\n config.switch_ctx(cluster.MULTICLUSTER[\\\"multicluster_index\\\"])\\n for resource in resources:\\n sleep(10) # Wait 10 seconds before getting the list of items\\n log.info(f\\\"Cleaning up {resource} resources\\\")\\n ocp_obj = ocp.OCP(kind=resource, namespace=namespace)\\n item_list = ocp_obj.get()[\\\"items\\\"]\\n for item in item_list:\\n resource_name = item[\\\"metadata\\\"][\\\"name\\\"]\\n try:\\n if resource == constants.PV:\\n if item[\\\"spec\\\"][\\\"claimRef\\\"][\\\"namespace\\\"] != namespace:\\n continue\\n ocp_obj.delete(resource_name=resource_name)\\n ocp_obj.wait_for_delete(resource_name=resource_name)\\n else:\\n ocp_obj.delete(resource_name=resource_name, wait=False)\\n ocp_obj.patch(\\n resource_name=resource_name,\\n params='{\\\"metadata\\\": {\\\"finalizers\\\":null}}',\\n format_type=\\\"merge\\\",\\n )\\n ocp_obj.wait_for_delete(resource_name=resource_name)\\n\\n except CommandFailed as ex:\\n if \\\"NotFound\\\" in str(ex):\\n log.info(\\n f\\\"{resource} {resource_name} got deleted successfully\\\"\\n )\\n else:\\n raise ex\\n\\n for cluster in get_non_acm_cluster_config():\\n config.switch_ctx(cluster.MULTICLUSTER[\\\"multicluster_index\\\"])\\n for image_uuid in image_uuids:\\n delete_volume_in_backend(\\n img_uuid=image_uuid,\\n pool_name=constants.DEFAULT_CEPHBLOCKPOOL,\\n disable_mirroring=True,\\n )\",\n \"def tearDown(self):\\n\\n LOG.debug(\\\"\\\\n*** Starting cleanup...\\\")\\n client = self._get_client()\\n\\n # Get list of snapshots\\n #LOG.debug(\\\"- Getting list of snapshots\\\")\\n #resp, snapshots = self._execute_request(client, \\\"snapshots\\\", \\\"GET\\\", \\\"\\\")\\n #snapshots = json.loads(snapshots)\\n\\n # Delete all orphaned instances and snapshots\\n LOG.debug(\\\"- Deleting orphaned instances:\\\")\\n resp, content = self._execute_request(client, \\\"instances\\\", \\\"GET\\\", \\\"\\\")\\n content = json.loads(content)\\n\\n for each in content['instances']:\\n# LOG.debug(\\\"EACH: %s\\\" % each)\\n if each['name'] == INSTANCE_NAME:\\n #for snapshot in snapshots['snapshots']:\\n # # If any snapshots belong to an instance to be deleted, delete the snapshots too\\n # if snapshot['instanceId'] == each['id']:\\n # LOG.debug(\\\"Deleting snapshot: %s\\\" % snapshot['id'])\\n # resp, content = self._execute_request(client, \\\"snapshots/\\\" + snapshot['id'], \\\"DELETE\\\", \\\"\\\")\\n # LOG.debug(resp)\\n # LOG.debug(content)\\n LOG.debug(\\\"Deleting instance: %s\\\" % each['id'])\\n resp, content = self._execute_request(client, \\\"instances/\\\" + each['id'], \\\"DELETE\\\", \\\"\\\")\\n LOG.debug(resp)\\n LOG.debug(content)\",\n \"def delete_vs(vs_name, created_objects):\\r\\n if keep_objects:\\r\\n return\\r\\n custom_object_api_instance = client.CustomObjectsApi()\\r\\n try:\\r\\n custom_object_api_response = custom_object_api_instance.delete_namespaced_custom_object(\\r\\n group=\\\"snapshot.storage.k8s.io\\\",\\r\\n version=\\\"v1\\\",\\r\\n plural=\\\"volumesnapshots\\\",\\r\\n name=vs_name,\\r\\n namespace=namespace_value\\r\\n )\\r\\n LOGGER.debug(custom_object_api_response)\\r\\n LOGGER.info(f\\\"Volume Snapshot Delete : {vs_name} deleted\\\")\\r\\n created_objects[\\\"vs\\\"].remove(vs_name)\\r\\n except ApiException as e:\\r\\n LOGGER.error(f\\\"Exception when calling CustomObjectsApi->delete_cluster_custom_object: {e}\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def snap_delete_by_volumename(mnode, volname):\\n\\n cmd = \\\"gluster snapshot delete volume %s --mode=script\\\" % volname\\n return g.run(mnode, cmd)\",\n \"def test_aws_service_api_snapshot_delete(self):\\n pass\",\n \"def delete_snapshot(self, snapshot):\\n aname = \\\"cinder_v%s.delete_snapshot\\\" % self.version\\n with atomic.ActionTimer(self, aname):\\n self._get_client().volume_snapshots.delete(snapshot)\\n bench_utils.wait_for_status(\\n snapshot,\\n ready_statuses=[\\\"deleted\\\"],\\n check_deletion=True,\\n update_resource=self._update_resource,\\n timeout=CONF.openstack.cinder_volume_delete_timeout,\\n check_interval=(CONF.openstack\\n .cinder_volume_delete_poll_interval)\\n )\",\n \"def test_aws_service_api_volume_delete(self):\\n pass\",\n \"def destroy_snapshot(snapname, dataset='', recursive=True, zpool=None):\\n fullsnapname = \\\"%s%s@%s\\\" % (zpool, dataset, snapname)\\n print \\\"Destroying snapshot '%s'\\\" % fullsnapname\\n if recursive:\\n command = 'zfs destroy -r %s' % fullsnapname\\n else:\\n command = 'zfs destroy %s' % fullsnapname\\n #print \\\"Exec '%s'\\\" % command\\n assert command.find('@') != -1 # we are not destroying datasets, only snapshots\\n p = subprocess.Popen(command.split(' '))\\n p.wait()\\n if p.returncode != 0 and p.returncode != 1: # 1 = snapshot did not exist. We can stand that\\n raise Exception(\\\"Error executing '%s': %d\\\" % (command, p.returncode))\",\n \"def _DeleteAllFromDefaultNamespace(self):\\n run_cmd = [\\n 'delete', 'all', '--all', '-n', 'default'\\n ]\\n RunKubectlCommand(run_cmd)\\n\\n run_cmd = [\\n 'delete', 'pvc', '--all', '-n', 'default'\\n ]\\n RunKubectlCommand(run_cmd)\\n # There maybe a slight race if resources are cleaned up in the background\\n # where deleting the cluster immediately prevents the PVCs from being\\n # deleted.\\n logging.info('Sleeping for %s seconds to give resources time to delete.',\\n RESOURCE_DELETE_SLEEP_SECONDS)\\n time.sleep(RESOURCE_DELETE_SLEEP_SECONDS)\",\n \"def destroy_all(self):\\n self.log.info(\\\"Destroying the %s cluster\\\" % self.cluster_name)\\n for n in self.all_nodes:\\n n.destroy()\\n remove(self.save_file)\",\n \"def _delete_all_containers(self):\\n for container_ref in self.created_entities['container']:\\n self.barbicanclient.containers.delete(container_ref)\",\n \"def test_volume_snapshot_create_get_list_delete(self):\\n volume = self.create_volume()\\n self.addCleanup(self.delete_volume, volume['id'])\\n\\n s_name = data_utils.rand_name(self.__class__.__name__ + '-Snapshot')\\n # Create snapshot\\n snapshot = self.snapshots_client.create_snapshot(\\n volume_id=volume['id'],\\n display_name=s_name)['snapshot']\\n\\n def delete_snapshot(snapshot_id):\\n waiters.wait_for_volume_resource_status(self.snapshots_client,\\n snapshot_id,\\n 'available')\\n # Delete snapshot\\n self.snapshots_client.delete_snapshot(snapshot_id)\\n self.snapshots_client.wait_for_resource_deletion(snapshot_id)\\n\\n self.addCleanup(delete_snapshot, snapshot['id'])\\n self.assertEqual(volume['id'], snapshot['volumeId'])\\n # Get snapshot\\n fetched_snapshot = self.snapshots_client.show_snapshot(\\n snapshot['id'])['snapshot']\\n self.assertEqual(s_name, fetched_snapshot['displayName'])\\n self.assertEqual(volume['id'], fetched_snapshot['volumeId'])\\n # Fetch all snapshots\\n snapshots = self.snapshots_client.list_snapshots()['snapshots']\\n self.assertIn(snapshot['id'], map(lambda x: x['id'], snapshots))\",\n \"def delete_volume(self, volume):\\n nfs_share = volume.get('provider_location')\\n if nfs_share:\\n nms = self.share2nms[nfs_share]\\n vol, parent_folder = self._get_share_datasets(nfs_share)\\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\\n mount_path = self.remote_path(volume).strip(\\n '/%s' % self.VOLUME_FILE_NAME)\\n if mount_path in self._remotefsclient._read_mounts():\\n cinder.privsep.fs.umount(mount_path)\\n try:\\n props = nms.folder.get_child_props(folder, 'origin') or {}\\n nms.folder.destroy(folder, '-r')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Folder %s does not exist, it was '\\n 'already deleted.', folder)\\n return\\n raise\\n self._get_capacity_info(nfs_share)\\n origin = props.get('origin')\\n if origin and self._is_clone_snapshot_name(origin):\\n try:\\n nms.snapshot.destroy(origin, '')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Snapshot %s does not exist, it was '\\n 'already deleted.', origin)\\n return\\n raise\",\n \"def delete(config: Config, ami: str) -> None:\\n\\n ec2_client = boto3.client(\\\"ec2\\\", region_name=config.get(\\\"region\\\", None))\\n\\n response = describe(config, ami, show_snapshot_id=True)\\n\\n ec2_client.deregister_image(ImageId=ami)\\n\\n ec2_client.delete_snapshot(SnapshotId=response[0][\\\"SnapshotId\\\"])\",\n \"def snap_delete(mnode, snapname):\\n\\n cmd = \\\"gluster snapshot delete %s --mode=script\\\" % snapname\\n return g.run(mnode, cmd)\",\n \"def cleanup_detach_snapshot(ec2, aws_account_id, dry_run=True):\\n images = ec2.images.filter(Owners=[aws_account_id])\\n images = [image.id for image in images]\\n for snapshot in ec2.snapshots.filter(OwnerIds=[aws_account_id]):\\n r = re.match(r\\\".*for (ami-.*) from.*\\\", snapshot.description)\\n if r:\\n if r.groups()[0] not in images:\\n logger.info(\\\"Deleting %s\\\" % snapshot.snapshot_id)\\n if not dry_run:\\n snapshot.delete(DryRun=dry_run)\\n else:\\n logger.info(\\\" skipped as dry_run is true\\\")\",\n \"def cleanup():\\n cmd='docker rmi --force $(docker images -a -q)'\\n bash_command(\\\"Deleting all images\\\", cmd)\",\n \"def delete_old(self):\\n retention_time = Host().get_retention_time()\\n snapshots = self._list_snapshots()\\n\\n for snap in snapshots['Snapshots']:\\n snapshot_id = snap['SnapshotId']\\n start_time = snap['StartTime']\\n if start_time <= retention_time:\\n self.resource.delete_snapshot(\\n SnapshotId=snapshot_id,\\n DryRun=DRY_RUN\\n )\\n self.deleted_ids.append(snapshot_id)\\n\\n notify = Notifier()\\n notify.send(self.created_id, self.deleted_ids)\",\n \"def delete_metadata(self, snapshot, keys):\\n response_list = []\\n snapshot_id = base.getid(snapshot)\\n for k in keys:\\n resp, body = self._delete(\\\"/snapshots/%s/metadata/%s\\\" %\\n (snapshot_id, k))\\n response_list.append(resp)\\n\\n return common_base.ListWithMeta([], response_list)\",\n \"def purge_all(self, df, dry_run=True):\\n if not dry_run:\\n for image in df[\\\"image_name\\\"]:\\n logging.info(\\\"Deleting image: % s\\\" % image)\\n\\n delete_cmd = [\\n \\\"az\\\",\\n \\\"acr\\\",\\n \\\"repository\\\",\\n \\\"delete\\\",\\n \\\"-n\\\",\\n self.name,\\n \\\"--image\\\",\\n image,\\n \\\"--yes\\\",\\n ]\\n\\n result = run_cmd(delete_cmd)\\n\\n if result[\\\"returncode\\\"] != 0:\\n logging.error(result[\\\"err_msg\\\"])\\n raise AzureError(result[\\\"err_msg\\\"])\\n\\n logging.info(\\\"Image successfully deleted\\\")\",\n \"def destroy(self, log_level=''):\\n # Get all the additional volumes and detach,delete.\\n volumes = self.utils.get_volumes_with_tag(\\n {'cluster_name': config.ENV_DATA['cluster_name']}\\n )\\n self.flexy_instance.destroy()\\n self.utils.detach_and_delete_vols(volumes)\",\n \"def test_csi_volumesnapshot_basic(set_random_backupstore, # NOQA\\n volumesnapshotclass, # NOQA\\n volumesnapshot, # NOQA\\n client, # NOQA\\n core_api, # NOQA\\n volume_name, # NOQA\\n csi_pv, # NOQA\\n pvc, # NOQA\\n pod_make, # NOQA\\n volsnapshotclass_delete_policy, # NOQA\\n backup_is_deleted): # NOQA\\n\\n csisnapclass = \\\\\\n volumesnapshotclass(name=\\\"snapshotclass\\\",\\n deletepolicy=volsnapshotclass_delete_policy)\\n\\n pod_name, pv_name, pvc_name, md5sum = \\\\\\n prepare_pod_with_data_in_mb(client, core_api,\\n csi_pv, pvc, pod_make,\\n volume_name,\\n data_path=\\\"/data/test\\\")\\n\\n # Create volumeSnapshot test\\n csivolsnap = volumesnapshot(volume_name + \\\"-volumesnapshot\\\",\\n \\\"default\\\",\\n csisnapclass[\\\"metadata\\\"][\\\"name\\\"],\\n \\\"persistentVolumeClaimName\\\",\\n pvc_name)\\n\\n volume = client.by_id_volume(volume_name)\\n\\n for i in range(RETRY_COUNTS):\\n snapshots = volume.snapshotList()\\n if len(snapshots) == 2:\\n break\\n time.sleep(RETRY_INTERVAL)\\n\\n lh_snapshot = None\\n snapshots = volume.snapshotList()\\n for snapshot in snapshots:\\n if snapshot[\\\"name\\\"] == \\\"snapshot-\\\" + csivolsnap[\\\"metadata\\\"][\\\"uid\\\"]:\\n lh_snapshot = snapshot\\n assert lh_snapshot is not None\\n\\n wait_for_volumesnapshot_ready(csivolsnap[\\\"metadata\\\"][\\\"name\\\"],\\n csivolsnap[\\\"metadata\\\"][\\\"namespace\\\"])\\n\\n bv1, b = find_backup(client, volume_name, lh_snapshot[\\\"name\\\"])\\n\\n assert b[\\\"snapshotName\\\"] == lh_snapshot[\\\"name\\\"]\\n\\n restore_pvc_name = pvc[\\\"metadata\\\"][\\\"name\\\"] + \\\"-restore\\\"\\n restore_pvc_size = pvc[\\\"spec\\\"][\\\"resources\\\"][\\\"requests\\\"][\\\"storage\\\"]\\n\\n restore_csi_volume_snapshot(core_api,\\n client,\\n csivolsnap,\\n restore_pvc_name,\\n restore_pvc_size)\\n\\n restore_pod = pod_make()\\n restore_pod_name = restore_pod[\\\"metadata\\\"][\\\"name\\\"]\\n restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]\\n\\n create_and_wait_pod(core_api, restore_pod)\\n restore_md5sum = \\\\\\n get_pod_data_md5sum(core_api, restore_pod_name, path=\\\"/data/test\\\")\\n assert restore_md5sum == md5sum\\n\\n # Delete volumeSnapshot test\\n delete_volumesnapshot(csivolsnap[\\\"metadata\\\"][\\\"name\\\"], \\\"default\\\")\\n\\n if backup_is_deleted is False:\\n find_backup(client, volume_name, b[\\\"snapshotName\\\"])\\n else:\\n wait_for_backup_delete(client, volume_name, b[\\\"name\\\"])\",\n \"def delete_snapshot(self, snapshot_id):\\r\\n\\r\\n self.iscsi_svc.deleteObject(id=snapshot_id)\",\n \"def check_vs_deleted(vs_name, created_objects):\\r\\n if keep_objects:\\r\\n return\\r\\n api_instance = client.CustomObjectsApi()\\r\\n val = 0\\r\\n while val < 12:\\r\\n try:\\r\\n api_response = api_instance.get_namespaced_custom_object(\\r\\n group=\\\"snapshot.storage.k8s.io\\\",\\r\\n version=\\\"v1\\\",\\r\\n plural=\\\"volumesnapshots\\\",\\r\\n name=vs_name,\\r\\n namespace=namespace_value\\r\\n )\\r\\n LOGGER.debug(api_response)\\r\\n time.sleep(15)\\r\\n LOGGER.info(f\\\"Volume Snapshot Delete : Checking deletion for {vs_name}\\\")\\r\\n val += 1\\r\\n except ApiException:\\r\\n LOGGER.info(f\\\"Volume Snapshot Delete : {vs_name} deletion confirmed\\\")\\r\\n return\\r\\n LOGGER.error(f\\\"Volume Snapshot Delete : {vs_name} is not deleted , asserting\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def terminate_volumes(db, context, instance_id):\\n volume_api = volume.API()\\n for bdm in db.block_device_mapping_get_all_by_instance(context,\\n instance_id):\\n #LOG.debug(_(\\\"terminating bdm %s\\\") % bdm)\\n if bdm['volume_id'] and bdm['delete_on_termination']:\\n volume_api.delete(context, bdm['volume_id'])\\n db.block_device_mapping_destroy(context, bdm['id'])\",\n \"def _snapshot_destroy(self, dir_path, snapshot_name):\\n try:\\n self.fs.rmdir(self._snapshot_path(dir_path, snapshot_name))\\n except cephfs.ObjectNotFound:\\n log.warn(\\\"Snapshot was already gone: {0}\\\".format(snapshot_name))\",\n \"def DeleteContainers(self):\\n for container in itertools.chain(*list(self.containers.values())):\\n container.Delete()\",\n \"def vm_snapshot_remove_all(self, vm_moid):\\n result = DataResult()\\n try:\\n vm_mor = self.get_vm_mor(vm_moid)\\n task_mor = vm_mor.RemoveAllSnapshots()\\n result.task_key = task_mor._moId\\n except Exception as ex:\\n LOG.exception(ex)\\n result.status = False\\n result.message = \\\"Remove all snapshots for vm error: %s \\\" % str(ex)\\n return result\",\n \"def cleanup_infrastructure_storage(config, datacenter):\\n print \\\"Removing storage devices in datacenter %s...\\\" % datacenter.getName()\\n for device in datacenter.listStorageDevices():\\n device.delete()\",\n \"def delete_all_representations(model_admin, request, queryset):\\n Representation.objects.filter(image__in=queryset).delete()\",\n \"def nuke_all_ebs(older_than_seconds, logger):\\n\\n #### Nuke all volumes ####\\n response = EC2.describe_volumes()\\n time_delete = time.time() - older_than_seconds\\n\\n for volume in response['Volumes']:\\n\\n if volume['CreateTime'].timestamp() < time_delete:\\n for volumestate in volume['Attachments']:\\n if volumestate['State'] == 'detached' or \\\\\\n volumestate['State'] == 'busy':\\n\\n # Nuke all ebs volume\\n EC2.delete_volume(VolumeId=volume['VolumeId'])\\n logger.info(\\\"Nuke EBS Volume %s\\\", volume['VolumeId'])\\n\\n #### Nuke all snapshots ####\\n# response = EC2.describe_snapshots()\\n\\n#\\n# for snapshot in response['Snapshots']:\\n# print(snapshot)\\n# if snapshot['StartTime'].timestamp() < time_delete and \\\\\\n# snapshot['OwnerAlias'] == 'self':\\n#\\n# # Nuke all ebs volume\\n# EC2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])\\n\\n #### Nuke all ebs lifecycle manager ####\\n response = DLM.get_lifecycle_policies()\\n\\n for ebslifecycle in response['Policies']:\\n\\n detailedresponse = DLM.get_lifecycle_policy(PolicyId=ebslifecycle['PolicyId'])\\n\\n if detailedresponse['Policy']['DateCreated'].timestamp() < time_delete:\\n\\n # Nuke all ebs volume\\n DLM.delete_lifecycle_policy(PolicyId=detailedresponse['Policy']['PolicyId'])\\n logger.info(\\\"Nuke EBS Lifecycle Policy %s\\\", detailedresponse['Policy']['PolicyId'])\",\n \"def delete_all_images(self, index):\\n self.__accessed_image[:] = False\\n self.__check_delete_images()\",\n \"def delete_all_runtimes(self):\\n self.compute_handler.delete_all_runtimes()\",\n \"def verify_no_snapshot_reingestion(c: Composition) -> None:\\n c.run(\\\"testdrive\\\", \\\"wait-for-snapshot.td\\\", \\\"postgres-disable-select-permission.td\\\")\\n\\n restart_mz(c)\\n\\n c.run(\\n \\\"testdrive\\\",\\n \\\"delete-rows-t1.td\\\",\\n \\\"delete-rows-t2.td\\\",\\n \\\"alter-table.td\\\",\\n \\\"alter-mz.td\\\",\\n )\",\n \"def delete_vs_content(vs_content_name, created_objects):\\r\\n if keep_objects:\\r\\n return\\r\\n custom_object_api_instance = client.CustomObjectsApi()\\r\\n try:\\r\\n custom_object_api_response = custom_object_api_instance.delete_cluster_custom_object(\\r\\n group=\\\"snapshot.storage.k8s.io\\\",\\r\\n version=\\\"v1\\\",\\r\\n plural=\\\"volumesnapshotcontents\\\",\\r\\n name=vs_content_name\\r\\n )\\r\\n LOGGER.debug(custom_object_api_response)\\r\\n created_objects[\\\"vscontent\\\"].remove(vs_content_name)\\r\\n LOGGER.info(f\\\"Volume Snapshot Content Delete : {vs_content_name} deleted\\\")\\r\\n except ApiException as e:\\r\\n LOGGER.error(f\\\"Exception when calling CustomObjectsApi->delete_cluster_custom_object_0: {e}\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def delete(self):\\n for i in set(self.instances.values()):\\n i.delete()\\n shutil.rmtree(self.dirpath, True)\",\n \"def test_delete_snapshot(self):\\n ctxt = context.get_admin_context()\\n extra_specs = {}\\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\\n snapshot = {'id': '1', 'name': 'volume1',\\n 'display_name': '',\\n 'volume_type_id': type_ref['id'],\\n 'size': 10,\\n 'provider_id': 'snap10'}\\n self.driver.delete_snapshot(snapshot)\\n expected = {'name': 'snap10'}\\n self.assertDictMatch(expected, self.deleted)\",\n \"def detach(self, storages):\\n self.tracer.info(\\\"%s.attach method called\\\" % self.__class__.__name__)\\n\\n # init variables & arrays\\n all_pds = []\\n all_vgs = []\\n unmount_err = 0\\n\\n # reload global.ini\\n self._cfg.reload()\\n\\n # connect to Google API\\n conn = self.api_conn()\\n\\n # fetch the GCE zone for this host\\n zone = self.get_zone(conn, HOSTNAME)\\n\\n for storage in storages:\\n # fetch pd & dev variables for specified partition & usage\\n connectionData = self._getConnectionDataForLun(storage.get(\\\"partition\\\"), storage.get(\\\"usage_type\\\"))\\n try:\\n pd = connectionData[\\\"pd\\\"]\\n dev = connectionData[\\\"dev\\\"]\\n except:\\n raise Exception(\\\"pd or dev not set in global.ini\\\")\\n\\n # fetch the host which currently owns the disk & the file path\\n path = storage.get(\\\"path\\\")\\n\\n # try to unmount the file system twice\\n self._forcedUnmount(dev, path, 2)\\n\\n # if it's still mounted, try killing blocking processes and umount again\\n if os.path.ismount(path):\\n self._lsof_and_kill(path)\\n self._forcedUnmount(dev, path, 2)\\n\\n # if still mounted, raise exception. The taking over node will stonith this host\\n if os.path.ismount(path):\\n self.tracer.warning(\\\"A PID belonging to someone other than SIDADM is blocking the unmount. This node will be fenced\\\")\\n self._umount(path, lazy=True)\\n mount_err = 1\\n\\n # add to list of devices.\\n all_pds.append(pd)\\n\\n # check to see if the device is a VG. If so, add it to the list of VG's\\n all_vgs.append(self.get_vg(dev))\\n\\n # Stop each unique VG\\n all_vgs = list(set(all_vgs))\\n for vg in all_vgs:\\n Helper._runOsCommand(\\\"sudo /sbin/vgchange -an %s\\\" % vg, self.tracer)\\n self.tracer.info(\\\"stopping volume group %s\\\" % (vg))\\n\\n # for each unique disk detected, detach it using Google API's\\n all_pds = list(set(all_pds))\\n for pd_member in all_pds:\\n self.detach_pd(conn, HOSTNAME, pd_member)\\n\\n # if there was an error unmounting, self fence\\n if unmount_err == 1:\\n self.fence(conn, pdhost)\\n\\n # tell HANA we successfully detached\\n return 0\",\n \"def database_volume_delete(volume_uuid):\\n db = database_get()\\n session = db.session()\\n query = session.query(model.Volume)\\n query.filter(model.Volume.uuid == volume_uuid).delete()\\n session.commit()\",\n \"def _cleanup_deleted_os_disks(self):\\n try:\\n disks = self.disks.list_by_resource_group(\\n CONF.azure.resource_group)\\n except Exception as e:\\n LOG.warning(_LW(\\\"Unable to delete disks\\\"\\n \\\" in Azure because %(reason)s\\\"),\\n dict(reason=six.text_type(e)))\\n return\\n # blobs is and iterable obj, although it's empty.\\n if not disks:\\n LOG.info(_LI('No residual Disk in Azure'))\\n return\\n for i in disks:\\n if self._is_os_disk(i.name) and not i.owner_id:\\n try:\\n self.disks.delete(CONF.azure.resource_group, i.name)\\n except Exception as e:\\n LOG.warning(_LW(\\\"Unable to delete os disk %(disk)s\\\"\\n \\\"in Azure because %(reason)s\\\"),\\n dict(disk=i.name,\\n reason=six.text_type(e)))\\n else:\\n LOG.info(_LI(\\\"Delete residual os disk: %s in\\\"\\n \\\" Azure\\\"), i.name)\\n else:\\n LOG.info(_LI('Delete all residual disks in Azure'))\",\n \"def cleanup(cloud, prefix, timeout=600, interval=10):\\n global RECYCLE\\n\\n # Get nodes with prefix\\n procs, nodes = [], cloud.get_nodes_by_prefix(prefix)\\n if nodes:\\n log.info(f\\\"Nodes with prefix '{prefix}' are {', '.join(nodes)}\\\")\\n else:\\n log.error(f\\\"No nodes are available with prefix '{prefix}'\\\")\\n\\n # Start deleting nodes in parallel\\n for node in nodes:\\n proc = mp.Process(target=delete_node, args=(node, cloud, timeout, interval))\\n proc.start()\\n procs.append(proc)\\n\\n # Wait till all nodes gets cleaned\\n [p.join() for p in procs]\\n\\n # Get nodes woth prefix\\n procs, volumes = [], cloud.get_volumes_by_prefix(prefix)\\n if volumes:\\n log.info(f\\\"Volumes with prefix '{prefix}' are {', '.join(volumes)}\\\")\\n else:\\n log.error(f\\\"No volumes available with prefix '{prefix}'.\\\")\\n\\n # Start deleting volumes in parallel\\n for volume in volumes:\\n proc = mp.Process(target=delete_volume, args=(volume, cloud, timeout, interval))\\n proc.start()\\n procs.append(proc)\\n\\n # Wait till all volumes gets cleaned\\n [p.join() for p in procs]\\n\\n # Check if any resource deletion failed\\n stale = [r.name for r in RECYCLE if r.state]\\n if stale:\\n msg = f\\\"Failed to clean resources {', '.join(stale)}\\\"\\n log.error(msg)\\n raise OperationFailedError(msg)\\n\\n return True\",\n \"def destroy_all(self) -> None:\\n try:\\n containers = self.docker.containers.list(\\n all=True,\\n filters={\\n 'label': LABEL_TASK_ID,\\n },\\n )\\n\\n for container in containers:\\n container.remove(force=True)\\n\\n except requests.exceptions.ConnectionError:\\n raise ProviderError('Docker engine unavailable')\",\n \"def deleteShards():\\n os.popen('rm *_shard')\",\n \"def delete_snapshot(self, snapshot):\\n self._impl.delete_snapshot(snapshot)\",\n \"def list_volumes(self):\\n print '# Listing existing volumes'\\n self.compute.list_volumes()\",\n \"def run(connection, volume_id, interval='daily', max_snapshots=0, name=''):\\n try:\\n volumes = connection.get_all_volumes([volume_id])\\n except EC2ResponseError as error:\\n logging.error(kayvee.formatLog(\\\"ebs-snapshots\\\", \\\"error\\\", \\\"failed to connect to AWS\\\", {\\\"msg\\\": error.message}))\\n return\\n\\n for volume in volumes:\\n _ensure_snapshot(connection, volume, interval, name)\\n _remove_old_snapshots(connection, volume, max_snapshots)\",\n \"def delete_images(region, image_id_list):\\n conn = boto.ec2.connect_to_region(region)\\n for image_id in image_id_list:\\n sys.stderr.write('Deleting {}\\\\n'.format(image_id))\\n conn.deregister_image(image_id, delete_snapshot=True)\",\n \"def destroy(name, call=None):\\n if call == \\\"function\\\":\\n raise SaltCloudSystemExit(\\n \\\"The destroy action must be called with -d, --destroy, -a or --action.\\\"\\n )\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroying instance\\\",\\n \\\"salt/cloud/{}/destroying\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n datacenter_id = get_datacenter_id()\\n conn = get_conn()\\n node = get_node(conn, name)\\n attached_volumes = None\\n\\n delete_volumes = config.get_cloud_config_value(\\n \\\"delete_volumes\\\", get_configured_provider(), __opts__, search_global=False\\n )\\n # Get volumes before the server is deleted\\n attached_volumes = conn.get_attached_volumes(\\n datacenter_id=datacenter_id, server_id=node[\\\"id\\\"]\\n )\\n\\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\\\"id\\\"])\\n\\n # The server is deleted and now is safe to delete the volumes\\n if delete_volumes:\\n for vol in attached_volumes[\\\"items\\\"]:\\n log.debug(\\\"Deleting volume %s\\\", vol[\\\"id\\\"])\\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\\\"id\\\"])\\n log.debug(\\\"Deleted volume %s\\\", vol[\\\"id\\\"])\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroyed instance\\\",\\n \\\"salt/cloud/{}/destroyed\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n if __opts__.get(\\\"update_cachedir\\\", False) is True:\\n __utils__[\\\"cloud.delete_minion_cachedir\\\"](\\n name, _get_active_provider_name().split(\\\":\\\")[0], __opts__\\n )\\n\\n return True\",\n \"def vm_snapshotlist(args):\\n snapshot = args.snapshot\\n name = args.name\\n config = Kconfig(client=args.client, debug=args.debug, region=args.region, zone=args.zone, namespace=args.namespace)\\n k = config.k\\n common.pprint(\\\"Listing snapshots of %s...\\\" % name)\\n snapshots = k.snapshot(snapshot, name, listing=True)\\n if isinstance(snapshots, dict):\\n common.pprint(\\\"Vm %s not found\\\" % name, color='red')\\n return\\n else:\\n for snapshot in snapshots:\\n print(snapshot)\\n return\",\n \"def destroy(self):\\r\\n\\r\\n return self.driver.destroy_volume(volume=self)\",\n \"def delete_snapshot(SnapshotId=None):\\n pass\",\n \"def delete_snapshot(self, context, snapshot_id):\\n caller_context = context\\n context = context.elevated()\\n snapshot_ref = self.db.snapshot_get(context, snapshot_id)\\n project_id = snapshot_ref['project_id']\\n\\n LOG.info(_(\\\"snapshot %s: deleting\\\"), snapshot_ref['id'])\\n self._notify_about_snapshot_usage(\\n context, snapshot_ref, \\\"delete.start\\\")\\n\\n try:\\n LOG.debug(_(\\\"snapshot %s: deleting\\\"), snapshot_ref['id'])\\n\\n # Pass context so that drivers that want to use it, can,\\n # but it is not a requirement for all drivers.\\n snapshot_ref['context'] = caller_context\\n\\n self._delete_snapshot_cascaded(context, snapshot_id)\\n except exception.SnapshotIsBusy:\\n LOG.error(_(\\\"Cannot delete snapshot %s: snapshot is busy\\\"),\\n snapshot_ref['id'])\\n self.db.snapshot_update(context,\\n snapshot_ref['id'],\\n {'status': 'available'})\\n return True\\n except Exception:\\n with excutils.save_and_reraise_exception():\\n self.db.snapshot_update(context,\\n snapshot_ref['id'],\\n {'status': 'error_deleting'})\\n\\n # Get reservations\\n try:\\n if CONF.no_snapshot_gb_quota:\\n reserve_opts = {'snapshots': -1}\\n else:\\n reserve_opts = {\\n 'snapshots': -1,\\n 'gigabytes': -snapshot_ref['volume_size'],\\n }\\n volume_ref = self.db.volume_get(context, snapshot_ref['volume_id'])\\n QUOTAS.add_volume_type_opts(context,\\n reserve_opts,\\n volume_ref.get('volume_type_id'))\\n reservations = QUOTAS.reserve(context,\\n project_id=project_id,\\n **reserve_opts)\\n except Exception:\\n reservations = None\\n LOG.exception(_(\\\"Failed to update usages deleting snapshot\\\"))\\n self.db.volume_glance_metadata_delete_by_snapshot(context, snapshot_id)\\n self.db.snapshot_destroy(context, snapshot_id)\\n LOG.info(_(\\\"snapshot %s: deleted successfully\\\"), snapshot_ref['id'])\\n self._notify_about_snapshot_usage(context, snapshot_ref, \\\"delete.end\\\")\\n\\n # Commit the reservations\\n if reservations:\\n QUOTAS.commit(context, reservations, project_id=project_id)\\n return True\",\n \"def main(pods_fname):\\n \\n pods = ReadPodsToBeDeleted(pods_fname)\\n\\n print(\\\"To remove PODs: {0}\\\".format(len(pods)))\\n \\n for pod in pods:\\n cmd = \\\"kubectl delete pod \\\" + pod\\n rc = 0\\n for k in range(0, 12): # several attempts to make a pod\\n rc = subprocess.call(cmd, shell=True)\\n if rc == 0:\\n break\\n\\n if rc != 0:\\n print(\\\"Cannot delete pod {0}\\\".format(pod))\\n sys.exit(1)\",\n \"def delete(self):\\r\\n return self.connection.delete_volume(self.id)\",\n \"def cleanup_mounts(mounts):\\n if isinstance(mounts, str):\\n mounts = [mounts]\\n\\n g.log.info(\\\"Start cleanup mounts\\\")\\n all_mounts_procs = []\\n valid_mounts = []\\n for mount_obj in mounts:\\n g.log.info(\\\"Cleaning up data from %s:%s\\\", mount_obj.client_system,\\n mount_obj.mountpoint)\\n if (not mount_obj.mountpoint or\\n (os.path.realpath(os.path.abspath(mount_obj.mountpoint))\\n is '/')):\\n g.log.error(\\\"%s on %s is not a valid mount point\\\",\\n mount_obj.mountpoint, mount_obj.client_system)\\n continue\\n cmd = \\\"rm -rf %s/*\\\" % (mount_obj.mountpoint)\\n proc = g.run_async(mount_obj.client_system, cmd,\\n user=mount_obj.user)\\n all_mounts_procs.append(proc)\\n valid_mounts.append(mount_obj)\\n g.log.info(\\\"rm -rf on all clients is complete. Validating \\\"\\n \\\"deletion now...\\\")\\n\\n # Get cleanup status\\n _rc_rmdir = True\\n for i, proc in enumerate(all_mounts_procs):\\n ret, out, err = proc.async_communicate()\\n if ret != 0 or out or err:\\n g.log.error(\\\"Deleting files/dirs Failed on %s:%s\\\",\\n valid_mounts[i].client_system,\\n valid_mounts[i].mountpoint)\\n _rc_rmdir = False\\n else:\\n g.log.info(\\\"Deleting files/dirs is successful on %s:%s\\\",\\n valid_mounts[i].client_system,\\n valid_mounts[i].mountpoint)\\n if _rc_rmdir:\\n g.log.info(\\\"Successfully deleted files/dirs from all mounts\\\")\\n else:\\n g.log.error(\\\"Deleting files/dirs failed on some of the mounts\\\")\\n\\n # Check if mount points are empty\\n ignore_dirs_list = [\\\".trashcan\\\"]\\n ignore_dirs = \\\"\\\\|\\\".join(ignore_dirs_list)\\n all_mounts_procs = []\\n for mount_obj in mounts:\\n cmd = (\\\"find %s -mindepth 1 | grep -ve '%s'\\\" %\\n (mount_obj.mountpoint, ignore_dirs))\\n proc = g.run_async(mount_obj.client_system, cmd,\\n user=mount_obj.user)\\n all_mounts_procs.append(proc)\\n\\n # Get cleanup status\\n _rc_lookup = True\\n for i, proc in enumerate(all_mounts_procs):\\n ret, out, err = proc.async_communicate()\\n if ret == 0:\\n g.log.error(\\\"Mount %s on %s is still having entries:\\\\n%s\\\",\\n mounts[i].mountpoint, mounts[i].client_system, out)\\n _rc_lookup = False\\n else:\\n g.log.info(\\\"Mount %s on %s is cleaned up\\\\n%s\\\",\\n mounts[i].mountpoint, mounts[i].client_system, out)\\n if _rc_lookup:\\n g.log.info(\\\"All the mounts are successfully cleaned up\\\")\\n else:\\n g.log.error(\\\"Failed to cleanup all mounts\\\")\\n\\n # List mounts entries\\n g.log.info(\\\"Listing mounts entries:\\\")\\n list_all_files_and_dirs_mounts(mounts)\\n\\n return _rc_lookup\",\n \"def volume_delete_by_storage(context, storage_id):\\n _volume_get_query(context).filter_by(storage_id=storage_id).delete()\",\n \"def purge():\\n all_hashes = read_all()\\n used_hashes = read_used()\\n\\n for kind, hashes in used_hashes.items():\\n to_remove = all_hashes[kind].difference(hashes)\\n if kind == 'evs':\\n delete_from_directory_by_hashes(EV_DIRECTORY, to_remove)\\n elif kind == 'cache':\\n delete_from_directory_by_hashes(CACHE_DIRECTORY, to_remove)\\n elif kind == 'seeds':\\n delete_from_directory_by_hashes(SEED_DIRECTORY, to_remove)\\n\\n reset_used()\",\n \"def test_delete_volumes(self, volumes_count, volumes_steps,\\n create_volumes):\\n volume_names = list(generate_ids('volume', count=volumes_count))\\n create_volumes(volume_names)\",\n \"async def purge_snapshots(self):\\n now = datetime.now(timezone.utc)\\n\\n snapshots_purged = []\\n for slug, expires in self._snapshots_expiry.copy().items():\\n if expires < now:\\n if await self._purge_snapshot(slug):\\n snapshots_purged.append(slug)\\n\\n if len(snapshots_purged) == 1:\\n _LOGGER.info(\\\"Purged 1 snapshot; %s\\\", snapshots_purged[0])\\n elif len(snapshots_purged) > 1:\\n _LOGGER.info(\\n \\\"Purged %s snapshots; %s\\\",\\n len(snapshots_purged),\\n tuple(snapshots_purged),\\n )\\n\\n if len(snapshots_purged) > 0:\\n self._hass.bus.async_fire(\\n f\\\"{DOMAIN}.purged_snapshots\\\", {\\\"snapshots\\\": snapshots_purged}\\n )\\n\\n # update sensor after purge.\\n if self.update_sensor_callback:\\n self.update_sensor_callback()\\n else:\\n _LOGGER.debug(\\\"No snapshots required purging.\\\")\",\n \"def cli(ctx):\\n stopped = click.style(\\\"Stopped\\\", fg=\\\"red\\\")\\n removed = click.style(\\\"Removed\\\", fg=\\\"blue\\\")\\n for container in ctx.docker.get_containers():\\n name = container.hostname\\n node_name = ''.join([i for i in name if not i.isdigit()])\\n image_name = container.dictionary['Config']['Image']\\n if node_name in TO_KILL:\\n container.stop(timeout=0)\\n else:\\n container.stop(timeout=5)\\n # container.execute(\\\"poweroff\\\", \\\"root\\\", \\\"/\\\", False)\\n # container.wait()\\n ctx.log(\\\"Container %s --> %s\\\" % (name, stopped))\\n container.remove(v=False, link=False, force=True)\\n ctx.log(\\\"Container %s --> %s\\\" % (name, removed))\\n ctx.state['containers'].remove(container.short_id)\\n ctx.state.fast_dump()\\n # remove untagged image\\n if not image_name.startswith(ctx.prefix):\\n ctx.docker.remove_image(image_name, force=True)\\n ctx.docker.remove_network()\",\n \"def delete_snapshot(session, snapshot, network):\\n # type: (Session, Text, Text) -> None\\n url_tail = \\\"/{}/{}/{}/{}\\\".format(\\n CoordConstsV2.RSC_NETWORKS, network, CoordConstsV2.RSC_SNAPSHOTS, snapshot\\n )\\n return _delete(session, url_tail)\",\n \"def delete_cluster(self):\",\n \"def execute(self):\\n\\n c = self.config\\n regions = dict((x.name, x) for x in boto.ec2.regions(\\n aws_access_key_id=c['access_key'],\\n aws_secret_access_key=c['secret_access_key']))\\n connect = regions[c['region']].connect(\\n aws_access_key_id=c['access_key'],\\n aws_secret_access_key=c['secret_access_key'])\\n volume = connect.get_all_volumes([c['volume_id']])[0]\\n volume.create_snapshot(c['volume_id'])\\n snapshots = {}\\n for x in connect.get_all_snapshots():\\n if x.volume_id == c['volume_id']:\\n snapshots.update({x.id: x.start_time})\\n snapshots = sorted(snapshots.items(), key=lambda (k, v): (v, k), reverse=True)\\n for i in range(int(c['keep']), len(snapshots)):\\n connect.delete_snapshot(snapshots[i][0])\",\n \"def delete(self, arguments):\\n name = arguments['<name>']\\n\\n instance_name = arguments['<instance>']\\n instance_name = self.activate(instance_name)\\n\\n vmrun = VMrun(self.vmx, user=self.user, password=self.password)\\n if vmrun.deleteSnapshot(name) is None:\\n puts_err(colored.red(\\\"Cannot delete name\\\"))\\n else:\\n puts_err(colored.green(\\\"Snapshot {} deleted\\\".format(name)))\",\n \"def s3_delete_data(self):\\n\\n self.k.delete()\",\n \"def delete_volume_snapshots(\\n self,\\n references=None, # type: List[models.ReferenceType]\\n authorization=None, # type: str\\n x_request_id=None, # type: str\\n ids=None, # type: List[str]\\n names=None, # type: List[str]\\n async_req=False, # type: bool\\n _return_http_data_only=False, # type: bool\\n _preload_content=True, # type: bool\\n _request_timeout=None, # type: Optional[int]\\n ):\\n # type: (...) -> None\\n kwargs = dict(\\n authorization=authorization,\\n x_request_id=x_request_id,\\n ids=ids,\\n names=names,\\n async_req=async_req,\\n _return_http_data_only=_return_http_data_only,\\n _preload_content=_preload_content,\\n _request_timeout=_request_timeout,\\n )\\n kwargs = {k: v for k, v in kwargs.items() if v is not None}\\n endpoint = self._volume_snapshots_api.api20_volume_snapshots_delete_with_http_info\\n _process_references(references, ['ids', 'names'], kwargs)\\n return self._call_api(endpoint, kwargs)\",\n \"def delete(**_):\\n\\n volume_id = utils.get_external_resource_id_or_raise(\\n 'delete EBS volume', ctx.instance)\\n\\n if _delete_external_volume():\\n return\\n\\n ctx.logger.debug('Deleting EBS volume: {0}'.format(volume_id))\\n\\n if not _delete_volume(volume_id):\\n return ctx.operation.retry(\\n message='Failed to delete volume {0}.'\\n .format(volume_id))\\n\\n utils.unassign_runtime_property_from_resource(\\n constants.ZONE, ctx.instance)\\n\\n utils.unassign_runtime_property_from_resource(\\n constants.EXTERNAL_RESOURCE_ID, ctx.instance)\\n\\n ctx.logger.info(\\n 'Deleted EBS volume: {0}.'\\n .format(volume_id))\",\n \"def test_delete_db_cluster_snapshot_no_wait(self):\\n _create_db_cluster(self.hook)\\n _create_db_cluster_snapshot(self.hook)\\n\\n cluster_snapshot_operator = RdsDeleteDbSnapshotOperator(\\n task_id=\\\"test_delete_db_cluster_snapshot_no_wait\\\",\\n db_type=\\\"cluster\\\",\\n db_snapshot_identifier=DB_CLUSTER_SNAPSHOT,\\n aws_conn_id=AWS_CONN,\\n dag=self.dag,\\n wait_for_completion=False,\\n )\\n _patch_hook_get_connection(cluster_snapshot_operator.hook)\\n with patch.object(cluster_snapshot_operator.hook, \\\"wait_for_db_cluster_snapshot_state\\\") as mock_wait:\\n cluster_snapshot_operator.execute(None)\\n mock_wait.assert_not_called()\\n\\n with pytest.raises(self.hook.conn.exceptions.ClientError):\\n self.hook.conn.describe_db_cluster_snapshots(DBClusterSnapshotIdentifier=DB_CLUSTER_SNAPSHOT)\",\n \"def delete(self, volume_id):\\n self.client().volumes.delete(volume_id)\",\n \"def test_csi_volumesnapshot_restore_existing_backup(set_random_backupstore, # NOQA\\n client, # NOQA\\n core_api, # NOQA\\n volume_name, # NOQA\\n csi_pv, # NOQA\\n pvc, # NOQA\\n pod_make, # NOQA\\n volumesnapshotclass, # NOQA\\n volumesnapshotcontent,\\n volumesnapshot, # NOQA\\n volsnapshotclass_delete_policy, # NOQA\\n backup_is_deleted): # NOQA\\n csisnapclass = \\\\\\n volumesnapshotclass(name=\\\"snapshotclass\\\",\\n deletepolicy=volsnapshotclass_delete_policy)\\n\\n pod_name, pv_name, pvc_name, md5sum = \\\\\\n prepare_pod_with_data_in_mb(client, core_api,\\n csi_pv, pvc, pod_make,\\n volume_name,\\n data_path=\\\"/data/test\\\")\\n\\n volume = client.by_id_volume(volume_name)\\n snap = create_snapshot(client, volume_name)\\n volume.snapshotBackup(name=snap.name)\\n wait_for_backup_completion(client, volume_name, snap.name)\\n bv, b = find_backup(client, volume_name, snap.name)\\n\\n csivolsnap_name = volume_name + \\\"-volumesnapshot\\\"\\n csivolsnap_namespace = \\\"default\\\"\\n\\n volsnapcontent = \\\\\\n volumesnapshotcontent(\\\"volsnapcontent\\\",\\n csisnapclass[\\\"metadata\\\"][\\\"name\\\"],\\n \\\"Delete\\\",\\n \\\"bs://\\\" + volume_name + \\\"/\\\" + b.name,\\n csivolsnap_name,\\n csivolsnap_namespace)\\n\\n csivolsnap = volumesnapshot(csivolsnap_name,\\n csivolsnap_namespace,\\n csisnapclass[\\\"metadata\\\"][\\\"name\\\"],\\n \\\"volumeSnapshotContentName\\\",\\n volsnapcontent[\\\"metadata\\\"][\\\"name\\\"])\\n\\n restore_pvc_name = pvc[\\\"metadata\\\"][\\\"name\\\"] + \\\"-restore\\\"\\n restore_pvc_size = pvc[\\\"spec\\\"][\\\"resources\\\"][\\\"requests\\\"][\\\"storage\\\"]\\n\\n restore_csi_volume_snapshot(core_api,\\n client,\\n csivolsnap,\\n restore_pvc_name,\\n restore_pvc_size)\\n\\n restore_pod = pod_make()\\n restore_pod_name = restore_pod[\\\"metadata\\\"][\\\"name\\\"]\\n restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]\\n\\n create_and_wait_pod(core_api, restore_pod)\\n restore_md5sum = \\\\\\n get_pod_data_md5sum(core_api, restore_pod_name, path=\\\"/data/test\\\")\\n\\n assert restore_md5sum == md5sum\\n\\n # Delete volumeSnapshot test\\n delete_volumesnapshot(csivolsnap[\\\"metadata\\\"][\\\"name\\\"], \\\"default\\\")\\n\\n if backup_is_deleted is False:\\n find_backup(client, volume_name, b[\\\"snapshotName\\\"])\\n else:\\n wait_for_backup_delete(client, volume_name, b[\\\"name\\\"])\",\n \"def clear_instances(cls, args, config):\\n instance_list = config.get_all_instances()\\n if len(instance_list) > 0:\\n for i in instance_list:\\n print i\\n config.delete_instance(i)\\n print \\\"instance {0} deleted\\\".format(i.id)\\n else:\\n print \\\"No instance found\\\"\",\n \"def purge_volume(self, volume_path, data_isolated=False):\\n\\n trash = os.path.join(self.volume_prefix, \\\"_deleting\\\")\\n trashed_volume = os.path.join(trash, volume_path.volume_id)\\n\\n try:\\n self.fs.stat(trashed_volume)\\n except cephfs.ObjectNotFound:\\n log.warning(\\\"Trying to purge volume '{0}' but it's already been purged\\\".format(\\n trashed_volume))\\n return\\n\\n def rmtree(root_path):\\n log.debug(\\\"rmtree {0}\\\".format(root_path))\\n dir_handle = self.fs.opendir(root_path)\\n d = self.fs.readdir(dir_handle)\\n while d:\\n if d.d_name not in [\\\".\\\", \\\"..\\\"]:\\n # Do not use os.path.join because it is sensitive\\n # to string encoding, we just pass through dnames\\n # as byte arrays\\n d_full = \\\"{0}/{1}\\\".format(root_path, d.d_name)\\n if d.is_dir():\\n rmtree(d_full)\\n else:\\n self.fs.unlink(d_full)\\n\\n d = self.fs.readdir(dir_handle)\\n self.fs.closedir(dir_handle)\\n\\n self.fs.rmdir(root_path)\\n\\n rmtree(trashed_volume)\\n\\n if data_isolated:\\n pool_name = \\\"{0}{1}\\\".format(self.POOL_PREFIX, volume_path.volume_id)\\n osd_map = self._rados_command(\\\"osd dump\\\", {})\\n pool_id = self._get_pool_id(osd_map, pool_name)\\n mds_map = self._rados_command(\\\"mds dump\\\", {})\\n if pool_id in mds_map['data_pools']:\\n self._rados_command(\\\"mds remove_data_pool\\\", {\\n 'pool': pool_name\\n })\\n self._rados_command(\\\"osd pool delete\\\",\\n {\\n \\\"pool\\\": pool_name,\\n \\\"pool2\\\": pool_name,\\n \\\"sure\\\": \\\"--yes-i-really-really-mean-it\\\"\\n })\",\n \"def delete_all(self):\\n return self.context.delete(\\\"/ckks/all\\\", None,\\n \\\"CKKS:: failed deleting all the CKKS data\\\"\\n )\",\n \"def delete_snapshot(self, pool, project, share, snapshot):\\n svc = self.snapshot_path % (pool, project, share, snapshot)\\n ret = self.rclient.delete(svc)\\n if ret.status != restclient.Status.NO_CONTENT:\\n exception_msg = (_('Error deleting '\\n 'snapshot: %(snapshot)s on '\\n 'share: %(share)s to '\\n 'pool: %(pool)s '\\n 'project: %(project)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'snapshot': snapshot,\\n 'share': share,\\n 'pool': pool,\\n 'project': project,\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n LOG.error(exception_msg)\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def delete_cloud_objects(chunk):\\n container_name, cloud_objs = chunk\\n conn = swiftclient.Connection(authurl=CUMULUS[\\\"AUTH_URL\\\"],\\n user=CUMULUS[\\\"USERNAME\\\"],\\n key=CUMULUS[\\\"API_KEY\\\"],\\n snet=CUMULUS[\\\"SERVICENET\\\"],\\n auth_version=CUMULUS[\\\"AUTH_VERSION\\\"],\\n tenant_name=CUMULUS[\\\"AUTH_TENANT_NAME\\\"])\\n filter(None, cloud_objs)\\n deleted = []\\n for cloud_obj in cloud_objs:\\n conn.delete_object(container=container_name,\\n obj=cloud_obj)\\n deleted.append(cloud_obj)\\n return deleted\",\n \"def test_aws_service_api_volume_attachment_delete(self):\\n pass\",\n \"def generate_osd_list(ceph_cluster: Ceph):\\n client = ceph_cluster.get_ceph_object(\\\"installer\\\")\\n ceph_osds = ceph_cluster.get_ceph_objects(\\\"osd\\\")\\n osd_nodes = set()\\n disk_list = set()\\n for osd in ceph_osds:\\n osd_nodes.add(osd.node.vmshortname)\\n osd_node_list = list(osd_nodes)\\n log.info(osd_node_list)\\n for osn in osd_node_list:\\n for osd in ceph_osds:\\n if osd.node.vmshortname == osn:\\n for i in osd.node.vm_node.volumes:\\n disk_list.add(i)\\n osd_disk_list = list(disk_list)\\n log.info(osd_disk_list)\\n log.info(len(osd_disk_list))\\n dump_osd_data(client, osn, osd_disk_list)\\n disk_list.clear()\\n osd_disk_list.clear()\",\n \"def cleanup(cloud, prefix):\\n # Get cloud configuration\\n configs = get_cloud_credentials(cloud)\\n\\n # Get nodes with prefix\\n procs, nodes = [], _get_nodes(prefix, cloud, configs)\\n\\n # Start deleting nodes in parallel\\n for node, _ in nodes:\\n proc = mp.Process(\\n target=delete_node,\\n args=(\\n node,\\n cloud,\\n configs,\\n ),\\n )\\n proc.start()\\n procs.append(proc)\\n\\n # Wait till all nodes gets cleaned\\n [p.join() for p in procs]\\n\\n log.info(f\\\"Cleaned cluster with prefix '{prefix}' sucessfully\\\")\\n return True\",\n \"def terminate_preemptible_instances(self, context, instances):\\n # NOTE(aloga): we should not delete them directly, but probably send\\n # them a signal so that the user is able to save her work.\\n elevated = context.elevated()\\n for instance in instances:\\n LOG.info(_LI(\\\"Deleting %(uuid)s\\\") % {\\\"uuid\\\": instance[\\\"uuid\\\"]})\\n instance = self.compute_api.get(elevated,\\n instance[\\\"uuid\\\"],\\n want_objects=True)\\n self.compute_api.delete(elevated, instance)\",\n \"def check_vs_content_deleted(vs_content_name, created_objects):\\r\\n if keep_objects:\\r\\n return\\r\\n api_instance = client.CustomObjectsApi()\\r\\n val = 0\\r\\n while val < 12:\\r\\n try:\\r\\n api_response = api_instance.get_cluster_custom_object(\\r\\n group=\\\"snapshot.storage.k8s.io\\\",\\r\\n version=\\\"v1beta1\\\",\\r\\n plural=\\\"volumesnapshotcontents\\\",\\r\\n name=vs_content_name\\r\\n )\\r\\n LOGGER.debug(api_response)\\r\\n time.sleep(15)\\r\\n LOGGER.info(f\\\"Volume Snapshot Content Delete : Checking deletion {vs_content_name}\\\")\\r\\n val += 1\\r\\n except ApiException:\\r\\n LOGGER.info(f\\\"Volume Snapshot Content Delete : {vs_content_name} deletion confirmed\\\")\\r\\n return\\r\\n LOGGER.error(f\\\"Volume Snapshot Content Delete : {vs_content_name} is not deleted , asserting\\\")\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def clean(all):\\n docker_clean(all)\",\n \"def delete_old():\\n objs = (Snapshot\\n .objects\\n .filter(timestamp__lte=(datetime.now() - timedelta(days=35)))\\n )\\n objs.delete()\",\n \"def test_amazon_s3_delete_all_keys(self):\\n config = Config()\\n metadata_bucket = config.config.get(\\\"metadata\\\", \\\"bucket\\\")\\n data_bucket = config.config.get(\\\"data\\\", \\\"bucket\\\")\\n metadata_provider = amazon.S3(config, metadata_bucket).connect()\\n provider = amazon.S3(config, data_bucket).connect()\\n for key, metadata in metadata_provider.list().items():\\n metadata_provider.delete(key)\\n for key, data in provider.list().items():\\n provider.delete(key)\\n metadata_provider.disconnect()\\n provider.disconnect()\",\n \"def terminateCluster():\\n try:\\n # delete cluster\\n redshift.delete_cluster(\\n ClusterIdentifier=DWH_CLUSTER_IDENTIFIER,\\n SkipFinalClusterSnapshot=True\\n )\\n\\n # clear up role\\n iam.detach_role_policy(\\n RoleName=DWH_IAM_ROLE_NAME,\\n PolicyArn=\\\"arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess\\\"\\n )\\n iam.delete_role(RoleName=DWH_IAM_ROLE_NAME)\\n except Exception as e:\\n print(e)\",\n \"def _delete_image_volume(self,\\n context: context.RequestContext,\\n cache_entry: dict) -> None:\\n volume = objects.Volume.get_by_id(context, cache_entry['volume_id'])\\n\\n # Delete will evict the cache entry.\\n self.volume_api.delete(context, volume)\",\n \"def command_unmount_all(self):\\n has_failed = False\\n for system_id in self.environment.get_mounted_ids():\\n try:\\n system = SystemModel.create_by_id(system_id, self.environment)\\n controller = SystemControllerModel(system, self.environment)\\n controller.unmount()\\n except SftpConfigException as e:\\n sys.stderr.write('Cannot unmount %s: %s\\\\n\\\\n' % (system_id, str(e)))\\n has_failed = True\\n sys.exit(0 if not has_failed else 1)\",\n \"def check_pvc_deleted(pvc_name, volume_name, created_objects):\\r\\n if keep_objects:\\r\\n return\\r\\n count = 12\\r\\n api_instance = client.CoreV1Api()\\r\\n while (count > 0):\\r\\n try:\\r\\n api_response = api_instance.read_namespaced_persistent_volume_claim(\\r\\n name=pvc_name, namespace=namespace_value, pretty=True)\\r\\n LOGGER.debug(str(api_response))\\r\\n count = count-1\\r\\n time.sleep(15)\\r\\n LOGGER.info(f'PVC Delete : Checking deletion for pvc {pvc_name}')\\r\\n except ApiException:\\r\\n LOGGER.info(f'PVC Delete : pvc {pvc_name} deleted')\\r\\n ff.delete_created_fileset(volume_name)\\r\\n return\\r\\n\\r\\n LOGGER.error(f'pvc {pvc_name} is not deleted')\\r\\n clean_with_created_objects(created_objects)\\r\\n assert False\",\n \"def fusion_api_delete_storage_volume(self, name=None, uri=None, param='', api=None, headers=None):\\n return self.volume.delete(name=name, uri=uri, param=param, api=api, headers=headers)\",\n \"def RemoveOldSnapshots(desktop):\\n # Compute the file prefix of a snapshot created one day ago.\\n yesterday = datetime.datetime.now() - datetime.timedelta(1)\\n old_snapshot = yesterday.strftime('ChromiumSnapshot%Y%m%d%H%M%S')\\n # Collect snapshots at least as old as that one created a day ago.\\n to_delete = []\\n for snapshot in glob.iglob(os.path.join(desktop, 'ChromiumSnapshot*.png')):\\n if os.path.basename(snapshot) < old_snapshot:\\n to_delete.append(snapshot)\\n # Delete the collected snapshots.\\n for snapshot in to_delete:\\n print 'Removing old snapshot: %s' % snapshot\\n try:\\n os.remove(snapshot)\\n except OSError, e:\\n print >> sys.stderr, e\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72916466","0.694778","0.6632236","0.66130334","0.6478083","0.6477406","0.63046324","0.62845635","0.62041503","0.6171982","0.6118543","0.6096079","0.6044555","0.60432434","0.60415065","0.6008003","0.59782016","0.5899641","0.5896192","0.5867627","0.5867521","0.5862644","0.58396935","0.5822558","0.57977283","0.5758555","0.5743961","0.5716551","0.5702838","0.56999844","0.5691448","0.5688026","0.56654936","0.56599414","0.56562364","0.5634278","0.56188494","0.56141025","0.5597607","0.5587352","0.5587043","0.5574261","0.55684716","0.5564235","0.5558429","0.55319154","0.5525877","0.55150497","0.5512902","0.5474552","0.5468534","0.5459732","0.5451749","0.5444278","0.5434045","0.5413445","0.54043365","0.539897","0.53984284","0.5394626","0.5368577","0.5361564","0.5358509","0.53542596","0.53410673","0.5335741","0.53238344","0.5310289","0.5308566","0.52985287","0.52943414","0.52910286","0.5278716","0.5277344","0.52705306","0.525956","0.5258957","0.5235583","0.52354753","0.52335376","0.5223811","0.52090925","0.520742","0.52073586","0.51947004","0.51847124","0.5183401","0.51818943","0.5175917","0.5175354","0.5169096","0.51690835","0.51632106","0.5156471","0.51503974","0.5144475","0.5135907","0.51356196","0.5119718","0.5117868"],"string":"[\n \"0.72916466\",\n \"0.694778\",\n \"0.6632236\",\n \"0.66130334\",\n \"0.6478083\",\n \"0.6477406\",\n \"0.63046324\",\n \"0.62845635\",\n \"0.62041503\",\n \"0.6171982\",\n \"0.6118543\",\n \"0.6096079\",\n \"0.6044555\",\n \"0.60432434\",\n \"0.60415065\",\n \"0.6008003\",\n \"0.59782016\",\n \"0.5899641\",\n \"0.5896192\",\n \"0.5867627\",\n \"0.5867521\",\n \"0.5862644\",\n \"0.58396935\",\n \"0.5822558\",\n \"0.57977283\",\n \"0.5758555\",\n \"0.5743961\",\n \"0.5716551\",\n \"0.5702838\",\n \"0.56999844\",\n \"0.5691448\",\n \"0.5688026\",\n \"0.56654936\",\n \"0.56599414\",\n \"0.56562364\",\n \"0.5634278\",\n \"0.56188494\",\n \"0.56141025\",\n \"0.5597607\",\n \"0.5587352\",\n \"0.5587043\",\n \"0.5574261\",\n \"0.55684716\",\n \"0.5564235\",\n \"0.5558429\",\n \"0.55319154\",\n \"0.5525877\",\n \"0.55150497\",\n \"0.5512902\",\n \"0.5474552\",\n \"0.5468534\",\n \"0.5459732\",\n \"0.5451749\",\n \"0.5444278\",\n \"0.5434045\",\n \"0.5413445\",\n \"0.54043365\",\n \"0.539897\",\n \"0.53984284\",\n \"0.5394626\",\n \"0.5368577\",\n \"0.5361564\",\n \"0.5358509\",\n \"0.53542596\",\n \"0.53410673\",\n \"0.5335741\",\n \"0.53238344\",\n \"0.5310289\",\n \"0.5308566\",\n \"0.52985287\",\n \"0.52943414\",\n \"0.52910286\",\n \"0.5278716\",\n \"0.5277344\",\n \"0.52705306\",\n \"0.525956\",\n \"0.5258957\",\n \"0.5235583\",\n \"0.52354753\",\n \"0.52335376\",\n \"0.5223811\",\n \"0.52090925\",\n \"0.520742\",\n \"0.52073586\",\n \"0.51947004\",\n \"0.51847124\",\n \"0.5183401\",\n \"0.51818943\",\n \"0.5175917\",\n \"0.5175354\",\n \"0.5169096\",\n \"0.51690835\",\n \"0.51632106\",\n \"0.5156471\",\n \"0.51503974\",\n \"0.5144475\",\n \"0.5135907\",\n \"0.51356196\",\n \"0.5119718\",\n \"0.5117868\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8123454"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78697,"cells":{"query":{"kind":"string","value":"Return a list of kubernetes jobs"},"document":{"kind":"string","value":"def get_jobs(k8s_ctx: str, selector: Optional[str] = None, dry_run: bool = False) -> List[str]:\n cmd = 'kubectl --context={k8s_ctx} get jobs -o json'\n if selector is not None:\n cmd += f' -l {selector}'\n if dry_run:\n logging.info(cmd)\n return list()\n\n p = safe_exec(cmd)\n if not p.stdout:\n # a small JSON structure is always returned, even if there are no jobs\n raise RuntimeError('Unexpected lack of output for listing kubernetes jobs')\n out = json.loads(p.stdout.decode())\n return [i['metadata']['name'] for i in out['items']]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def list_jobs():\n\n name_to_job_details = redis_controller.get_name_to_job_details()\n return list(name_to_job_details.values())","def jobs():\n result = []\n out = subprocess.check_output([\"/bin/launchctl\", \"list\"]).decode()\n for row in out.splitlines()[1:]:\n result.append(Job(row))\n return result","def ListJobs(self, token=None):\n return aff4.FACTORY.Open(self.CRON_JOBS_PATH, token=token).ListChildren()","def get_jobs(self, age=1):\n jobs_for_reaper = []\n try: \n api_response = self.kube_v1_batch_client.list_namespaced_job(namespace=self.project, label_selector='job-origin=pman', include_uninitialized=True)\n for item in api_response.items:\n # Checking if job has finished running, either failed or succeeded\n if item.status.conditions and (item.status.failed or item.status.succeeded):\n # Using start_time because failed jobs have no completion_time\n start_time = item.status.start_time\n current_time = datetime.datetime.now(datetime.timezone.utc)\n diff = current_time-start_time\n # 86400 = number of seconds in a day. \"divmod\" returns quotient and remainder as tuple e.g (1, 5.74943)\n # means 1 day and 5.74943 sec have passed between current_time and start_time of the job\n diff_in_seconds = divmod(diff.total_seconds(), 86400)\n if diff_in_seconds[0] >= 1:\n jobs_for_reaper.append(item.metadata.name)\n \n except ApiException as e:\n print(\"Exception when calling BatchV1Api->list_namespaced_job: %s\\n\" % e)\n exit(1)\n return jobs_for_reaper","def list_jobs(arn=None, nextToken=None):\n pass","def get_jobs_list(self, response):\n pass","def get_jobs(self, label_selector, namespace):\n return self.batch_client.list_namespaced_job(namespace, label_selector=label_selector, watch=False)","def list_jobs(self):\n\n return dict(self._from_json(self.manage.run(override=\"list-jobs\")))","def list(self):\n return self.rpc.call(MsfRpcMethod.JobList)","def get(self):\n # TODO: auth\n return list(self.app.db.jobs.find())","def get_job_list(self):\n return self.job_list","def get_job_list(self):\n return self.job_list","async def get_jobs(): \n return mngr.getAllJobs()","def ListJobs(cls):\n return [key.parent().string_id() for key in cls.query().fetch(\n 100, keys_only=True)]","def jobs(self):\n return self.get_jobs()","def get_jobs(self):\n return list(self._jobs.values())","def _get_jobs():\n return _get_bigquery_service().jobs()","def jobs(self, tags=None, tags_intersect=None):\n return list(self.all_jobs(tags=tags, tags_intersect=tags_intersect))","def get_jobs(self, *, params: Optional[dict] = None) -> \"resource_types.Jobs\":\n\n return communicator.Jobs(self.__requester).fetch(parameters=params)","def get_job_list(self):\n job_list = []\n if mysql.job_list() == None:\n return job_list\n return mysql.job_list()","def listJobs():\n logger.debug('[FLASKWEB /jobs] Request for job listing')\n jobs = db.getJobs(numdays=2)\n for job in jobs:\n job['time'] = datetime.datetime.strptime(job['time'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\n if job['complete']:\n job['complete'] = datetime.datetime.strptime(job['complete'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\n\n # Garbage Collect Orpahened jobs\n compiles = db.getCompiles()\n for compile in compiles:\n if compile['submit']:\n compile['submit'] = datetime.datetime.strptime(compile['submit'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\n if compile['complete']:\n compile['complete'] = datetime.datetime.strptime(compile['complete'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\n # for c in compiles:\n # if c['uid'] not in compile_tasks.keys():\n # db.updateCompile(c['uid'], status='KILLED', done=True)\n # compiles = db.getCompiles()\n\n if request.headers['Accept'] == 'application/json':\n return jsonify(dict(LaunchJobs=jobs, CompilingJobs=compiles)), 200\n else:\n return render_template(\"jobs.html\", joblist=jobs, compilelist=compiles)","def jobs(self) -> List[Job]:\n return self._jobs.values()","def jobs(ctx, page):\n user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),\n ctx.obj.get('experiment'))\n page = page or 1\n try:\n response = PolyaxonClient().experiment.list_jobs(\n user, project_name, _experiment, page=page)\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\n Printer.print_error('Could not get jobs for experiment `{}`.'.format(_experiment))\n Printer.print_error('Error message `{}`.'.format(e))\n sys.exit(1)\n\n meta = get_meta_response(response)\n if meta:\n Printer.print_header('Jobs for experiment `{}`.'.format(_experiment))\n Printer.print_header('Navigation:')\n dict_tabulate(meta)\n else:\n Printer.print_header('No jobs found for experiment `{}`.'.format(_experiment))\n\n objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))\n for o in response['results']]\n objects = list_dicts_to_tabulate(objects)\n if objects:\n Printer.print_header(\"Jobs:\")\n objects.pop('experiment', None)\n dict_tabulate(objects, is_list_dict=True)","def list_jobs(user_data, cache):\n user = cache.ensure_user(user_data)\n\n jobs = []\n for job in cache.get_jobs(user):\n try:\n if job.project_id:\n job.project = cache.get_project(user, job.project_id)\n except IntermittentProjectIdError:\n continue\n\n jobs.append(job)\n\n return result_response(JobListResponseRPC(), {\"jobs\": jobs})","def get_all_jobs(self) -> List[DocumentReference]:\n return self.get_all_documents(Type._JOBS)","def submit_jobs(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:\n retval = list()\n if not path.exists():\n raise RuntimeError(f'Path with kubernetes jobs \"{path}\" does not exist')\n if path.is_dir():\n num_files = len(os.listdir(str(path)))\n if num_files == 0 and not dry_run:\n raise RuntimeError(f'Job directory {str(path)} is empty')\n elif num_files > K8S_MAX_JOBS_PER_DIR:\n files = os.listdir(str(path))\n for i, f in enumerate(sorted(files, key=lambda x: int(os.path.splitext(x)[0].split('_')[1]))):\n retval += submit_jobs_with_retries(k8s_ctx, pathlib.Path(os.path.join(path, f)), dry_run) # type: ignore\n perc_done = i / num_files * 100.\n if i % 50 == 0:\n logging.debug(f'Submitted job file # {i} of {num_files} {perc_done:.2f}% done')\n return retval\n\n cmd = f'kubectl --context={k8s_ctx} apply -f {path} -o json'\n if dry_run:\n logging.info(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n out = json.loads(p.stdout.decode())\n if 'items' in out:\n retval = [i['metadata']['name'] for i in out['items']]\n else:\n retval = [out['metadata']['name']]\n return retval","def get_jobs():\n \n rate_limit()\n command = [\"bjobs\", \"-o\", \"\\\"JOBID\", \"USER\", \"STAT\", \"QUEUE\", \"JOB_NAME\", \\\n \"delimiter=';'\\\"\"]\n command = \" \".join(command)\n jobs = subprocess.check_output(command, shell=True, stderr=open(os.devnull))\n \n # if there aren't any currently running or pending jobs, then the output\n if jobs == \"\":\n return set([])\n \n jobs = jobs.decode().strip().split(\"\\n\")\n \n current_jobs = set([])\n for line in jobs:\n if line.startswith(\"JOBID\"): # ignore the header line\n continue\n \n line = line.split(\";\")\n job_name = line[4]\n current_jobs.add(job_name)\n \n return current_jobs","def genJobList():\n nit=10\n reply=[]\n while len(reply)<10: #assume qstat fails if less that 10 jobs on cluster\n reply=chomp(os.popen('qstat|expand|tr -s \\' \\'|cut -d\\' \\' -f 1,2,5').readlines())\n nit+=1\n if nit>10: break\n return reply","def jobs(self):\n return self._jobs","def jobs(self):\n return self.properties.get('jobs',\n EntityCollection(self.context, SynchronizationJob,\n ResourcePath(\"jobs\", self.resource_path)))","def get_job_names(self):\n return []","def get_all_jobs():\n fq = get_failed_queue(connection=conn)\n job_data = {'queued_jobs': q.job_ids,\n 'failed_jobs': fq.job_ids}\n return jsonify(job_data), 200","def getJobs(**options):\n criteria = search.JobSearch.criteriaFromOptions(**options)\n jobSeq = Cuebot.getStub('job').GetJobs(\n job_pb2.JobGetJobsRequest(r=criteria), timeout=Cuebot.Timeout).jobs\n return [Job(j) for j in jobSeq.jobs]","def get_jobs(self, type = None):\n joblist = JobList()\n for jobs in self.sm.get_jobs(type = type):\n joblist.add_job(jobs['identifier'], jobs['phase'])\n return joblist.tostring()","def get_jobs(bmc, only_unfinished):\n jobs = bmc.list_jobs(only_unfinished)\n return namedtuples_to_dicts(jobs)","def jobs(self):\n return JobCollection(client=self)","def list_jobs(exproot, **kwargs):\n for jobname, args, results in load_all(exproot):\n print jobname, args, results","def get_jobs(dumpruninfo):\n if \"jobs\" not in dumpruninfo:\n return []\n return dumpruninfo[\"jobs\"].keys()","def jobs(self):\n raise NotImplementedError()","def get_job_list():\n\tdirlist = os.listdir(\".\")\n\tjoblist = [x for x in dirlist if \"job.sh\" in x and x in job_dict]\n\ttmplist = [x for x in dirlist if \"job.sh\" in x and x not in job_dict]\n\tdef compare_function(s: str):\n\t\treturn job_dict[s].order\n\tjoblist.sort(key=compare_function)\n\tjoblist.extend(tmplist)\n\treturn joblist","def job_info(self):\n def _sortkey(x):\n return x['job_name']\n\n resp = self._cmd(uri = '/jenkins_jobs')\n jobs = resp.get('jobs', [])\n return sorted(jobs, key=_sortkey)","def get_running_jobs(api_instance):\n namespace = \"default\"\n try:\n api_response = api_instance.list_namespaced_job(namespace)\n except ApiException as e:\n logger.exception(\"Exception while receiving running Jobs{}\".format(e))\n return api_response","def get_pr_jobs():\n res = requests.get(\n uri + \"/view/Pull%20Requests/api/json\",\n headers={\"accept\": \"application/json\"},\n auth=requests.auth.HTTPBasicAuth(user, password),\n verify=verify,\n )\n if res.status_code != 200:\n raise RuntimeError(\"Received non 200 status code from jenkins\")\n data = res.json()\n for job in data[\"jobs\"]:\n yield job","def list(self):\n self.background_scheduler.print_jobs()","def get_registered_jobs(self):\n with self.__lock:\n return list(self.__registered_jobs)","def get_jobs(self, expression):\n return list(parse_job_list(expression, context=self.cc))","def jobs(tileset, stage, token=None, indent=None):\n mapbox_api = _get_api()\n mapbox_token = _get_token(token)\n url = \"{0}/tilesets/v1/{1}/jobs?access_token={2}\".format(\n mapbox_api, tileset, mapbox_token\n )\n if stage:\n url = \"{0}/tilesets/v1/{1}/jobs?stage={2}&access_token={3}\".format(\n mapbox_api, tileset, stage, mapbox_token\n )\n\n r = requests.get(url)\n\n click.echo(json.dumps(r.json(), indent=indent))","def GetJobs(self, bulk=False):\n query = []\n _AppendIf(query, bulk, (\"bulk\", 1))\n\n if bulk:\n return self._SendRequest(HTTP_GET,\n \"/%s/jobs\" % GANETI_RAPI_VERSION,\n query, None)\n else:\n return [int(j[\"id\"])\n for j in self._SendRequest(HTTP_GET,\n \"/%s/jobs\" % GANETI_RAPI_VERSION,\n None, None)]","def list_labeling_jobs(CreationTimeAfter=None, CreationTimeBefore=None, LastModifiedTimeAfter=None, LastModifiedTimeBefore=None, MaxResults=None, NextToken=None, NameContains=None, SortBy=None, SortOrder=None, StatusEquals=None):\n pass","def all_jobs():\n\n jobs = Job.get_all()\n\n oneoffs = OneOff.get_all()\n\n job = JobView(None, jobs, oneoffs, False, Job.count() > 0)\n\n add_trello_task_links_to_g()\n\n return render_template(\"jobs.template.html\", page_title=\"Jobs\", job_info=job)","async def jobs(request):\n\n job_list = await get_jobs(request)\n return template('jobs.html',\n jobs=job_list)","def job_names(self):\n resp = self._cmd(uri = '/jenkins_jobs')\n names = []\n for item in resp.get('jobs'):\n names.append(item.get('job_name'))\n return sorted(names)","def list(self):\n\n for job_name in self.upstart.get_all_jobs():\n yield self.get_service(job_name)","def get_jobs(self, offset=0, length=-1):\n job_ids = self.get_job_ids(offset, length)\n jobs = []\n for job_id in job_ids:\n try:\n jobs.append(self.connection.get_job(job_id))\n except NoSuchJobError:\n pass\n return jobs","def list(self, jobguid=\"\", executionparams=None):","def get_protection_jobs(cohesity_client, skip_jobs=False):\n protection_job_list = cohesity_client.protection_jobs.get_protection_jobs()\n active_job_list = []\n for job in protection_job_list:\n # Jobs which are deleted are ignored.\n if job.is_deleted:\n continue\n # Skip jobs which are paused or in-active(failover ready).\n if skip_jobs and (job.is_paused or job.is_active != None):\n continue\n active_job_list.append(job)\n exported_res_dict[\"Protection Jobs\"].append(job.name)\n return active_job_list","def list():\n # Calling config file\n cf = config.ReadFile(config_file)\n user = cf[\"authentication\"][\"user\"]\n\n l = []\n for job in cron:\n l.append(job)\n return l","def getJobListFromDB(self):\n\t\tsql = \"SELECT jobname from hudson_jobs\"\n\t\tcsr = self.db.cursor()\n\t\tcsr.execute(sql)\n\t\tdata = [ x[0] for x in csr.fetchall() ]\n\t\treturn data","def createJobs():\n jobs_list = []\n for job in raw_jobs:\n cur_job = Job(int(job[0]), int(job[1]), int(job[2]))\n print(\"Created job: index:\", cur_job.number, \"Length:\", cur_job.length, \"Type\", cur_job.type, file=debug_file)\n jobs_list.append(cur_job)\n print(\"-----------------FINISHED CREATING JOB OBJECTS----------------------\\n\\n\", file=debug_file)\n return jobs_list","def search_jobs(self, bill_id: int = 0, limit: int = 0) -> List[Job]:\n pass","def get_jobs():\n jobs = [os.path.join(JOBS_DIR, job)\n for job in os.listdir(JOBS_DIR)\n if job != '.gitignore']\n return jobs","def list_pods(req, resp):\n namespace = req.params['namespace']\n return _get_all_pods(namespace)","def cmd_list(arguments):\r\n\r\n # get a producer\r\n producer = getProducer()\r\n\r\n # get the list of pending jobs\r\n jobs = producer.list()\r\n\r\n # print que list size and the entries\r\n print \"Number of jobs: %d\" % len(jobs)\r\n for j in range(len(jobs)):\r\n print \" job %06d - %s\" % (j, jobs[j])\r\n\r\n return 0","def get_jobs(self, jobstore=None):\n\n return self._scheduler.get_jobs(jobstore)","def job(job_name):\n ClientID = Job.get_client_id(job_name)\n return tasks_for_client_job(ClientID, job_name)","async def request_jobs_list(self, jobs_list_active_only: bool, *args, **kwargs) -> List[str]:\n # TODO: implement\n raise NotImplementedError('{} function \"request_jobs_list\" not implemented yet'.format(self.__class__.__name__))","def list_service(request):\n builder = http.ResponseBuilder()\n master_addr = request.GET.get('master',None)\n if not master_addr:\n return builder.error('master is required').build_json()\n\n client = wrapper.Galaxy(master_addr,settings.GALAXY_CLIENT_BIN)\n status,jobs = client.list_jobs()\n LOG.info(status)\n if not status:\n return builder.error('fail to list jobs').build_json()\n ret = []\n for job in jobs:\n ret.append(job.__dict__)\n return builder.ok(data=ret).build_json()","async def get_jobs(jobId: int) -> str: \n return mngr.getJob(str(jobId))","def get_waiting_jobs(self):\n return []","def list(self, jobguid=\"\", executionparams=dict()):","def getClientJobsInformation(client):\n # getSlaveForDispatch()\n #jobs = mongo.db.jobs.find({'owner': client, 'is_active': True})\n jobs = mongo.db.jobs.find({'is_active': True})\n\n # result = i.title()\n # if any([s.get('status')=='on progress' for s in tasks]):\n # result = 'On Progress'\n # return result\n\n result = [{\n 'name': j.get('name'),\n 'datetime': j.get('datetime'),\n 'status': getJobStatus(j),\n 'priority': j.get('priority'),\n 'progress': sum([t.get('progress') for t in mongo.db.tasks.find({'job': j.get('_id')})]) /\n (mongo.db.tasks.find({'job': j.get('_id')}).count() or -1),\n 'id': str(j.get('_id')),\n 'tasks_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True}).count(),\n 'failed_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True, 'status': 'failed'}).count(),\n 'completed_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True, 'status': 'completed'}).count(),\n 'active_task': 'Frame 43',\n } for j in jobs]\n return result or {}","def clean_jobs():\n\n # Delete all job related resources.\n redis_controller.delete_pending_jobs_queue()\n redis_controller.delete_killed_jobs_queue()\n name_to_node_details = redis_controller.get_name_to_node_details()\n for _, node_details in name_to_node_details.items():\n node_hostname = node_details[\"hostname\"]\n for container_name in node_details[\"containers\"]:\n requests.delete(\n url=f\"http://{node_hostname}:{node_details['api_server']['port']}/containers/{container_name}\",\n )\n return {}","def list_compilation_jobs(NextToken=None, MaxResults=None, CreationTimeAfter=None, CreationTimeBefore=None, LastModifiedTimeAfter=None, LastModifiedTimeBefore=None, NameContains=None, StatusEquals=None, SortBy=None, SortOrder=None):\n pass","def get_current_jobs(ssh):\n stdin, stdout, stderr = ssh.exec_command('qstat')\n\n running_jobs = []\n for line in stdout.readlines():\n if '.awonmgr2' in line:\n jobid = line.split('.awonmgr2')[0]\n running_jobs.append(jobid)\n \n return running_jobs","def get_jobs(state=\"all\"):\n if state.lower() == \"all\":\n query = {\"type\": \"op\", \"cmd\": \"<show><jobs><all></all></jobs></show>\"}\n elif state.lower() == \"pending\":\n query = {\"type\": \"op\", \"cmd\": \"<show><jobs><pending></pending></jobs></show>\"}\n elif state.lower() == \"processed\":\n query = {\n \"type\": \"op\",\n \"cmd\": \"<show><jobs><processed></processed></jobs></show>\",\n }\n else:\n raise CommandExecutionError(\n \"The state parameter must be all, pending, or processed.\"\n )\n\n return __proxy__[\"panos.call\"](query)","def list_job_runs(\n self,\n ) -> Callable[[cloud_deploy.ListJobRunsRequest], cloud_deploy.ListJobRunsResponse]:\n # Generate a \"stub function\" on-the-fly which will actually make\n # the request.\n # gRPC handles serialization and deserialization, so we just need\n # to pass in the functions for each.\n if \"list_job_runs\" not in self._stubs:\n self._stubs[\"list_job_runs\"] = self.grpc_channel.unary_unary(\n \"/google.cloud.deploy.v1.CloudDeploy/ListJobRuns\",\n request_serializer=cloud_deploy.ListJobRunsRequest.serialize,\n response_deserializer=cloud_deploy.ListJobRunsResponse.deserialize,\n )\n return self._stubs[\"list_job_runs\"]","def list_runtimes(self, docker_image_name='all'):\n logger.debug('Listing runtimes')\n logger.debug('Note that k8s job backend does not manage runtimes')\n return []","def submit(self, jobs):\n assert isinstance(jobs, list), 'Jobs must be type list'\n assert len(jobs) > 0, 'One or more jobs required'\n\n data = {'jobs': jobs}\n for j in data['jobs']:\n # generate a random UUID if absent\n if 'uuid' not in j:\n j['uuid'] = str(uuid1())\n\n # default missing fields\n j.update(dict(self._default_job_settings.items() + j.items()))\n\n self._job_schema.validate(jobs)\n\n try:\n self._api_post(self._scheduler_endpoint, data)\n return [j['uuid'] for j in data['jobs']]\n except HTTPError as e:\n raise JobClientError(e.message)","def get_vm_list(self):\n\t\treturn Job(SDK.PrlSrv_GetVmList(self.handle)[0])","def get_completed_incore_jobs(self):\n self.completed_incore_jobs = list()\n for label, job_names in self.running_jobs.items():\n for job_name in job_names:\n i = get_i_from_job_name(job_name)\n if i is None:\n job_type = '_'.join(job_name.split('_')[:-1]) # Consider job types such as 'directed_scan'.\n job = self.job_dict[label][job_type][job_name]\n elif 'conformer' in job_name:\n job = self.job_dict[label]['conformers'][i]\n elif 'tsg' in job_name:\n job = self.job_dict[label]['tsg'][i]\n else:\n raise ValueError(f'Did not recognize job {job_name} of species {label}.')\n if job.execution_type == 'incore' and job.job_status[0] == 'done':\n self.completed_incore_jobs.append(job.job_id)","def jobs(self):\n return JobManager(session=self._session)","def list_pilot_compute(self):\n return self.pilot_job_service","def get_all_jobs(self):\n all_jobs = self.job_set.all().order_by(\"-time_last_updated\", \"project__name\", \"-id\")\n # for job in all_jobs:\n # job.check_exists()\n\n # get the list of jobs listed in the database as running and update them.\n dbrunning = all_jobs.filter(state__in=['in queue', 'started'])\n for runningjob in dbrunning: runningjob.update();\n\n # get the updated list \n all_jobs = self.job_set.all().order_by(\"-time_last_updated\", \"project__name\", \"-id\")\n\n return all_jobs","def monitor_jobs(v1_api, jobs_to_monitor, namespace=\"default\"):\n w = watch.Watch()\n num_succeeded = 0\n num_failed = 0\n for e in w.stream(v1_api.list_namespaced_pod, namespace):\n pod = e[\"object\"]\n event_type = e[\"type\"]\n if pod.spec.containers:\n for c in pod.spec.containers:\n if c.name in jobs_to_monitor:\n logging.info(\"Job %s signalled event %s, POD Phase: %s\", c.name,\n event_type, pod.status.phase)\n if pod.status.phase == \"Succeeded\":\n num_succeeded += 1\n jobs_to_monitor.pop(c.name)\n elif pod.status.phase == \"Failed\":\n num_failed += 1\n jobs_to_monitor.pop(c.name)\n logging.info(\"Waiting for %d jobs to finish\", len(jobs_to_monitor))\n if len(jobs_to_monitor) <= 0:\n break\n return num_succeeded, num_failed","def get_executions(self, task_id, include_hostname=None):\n if include_hostname or config[\"retry_host_sensitive\"].get(bool):\n lbl_sel = f\"taclib_task_name={task_id},luigi_host={socket.gethostname()}\"\n else:\n lbl_sel = f\"taclib_task_name={task_id}\"\n res = self._c_batch.list_namespaced_job(self.namespace, label_selector=lbl_sel)\n jobs = sorted(res.items, key=lambda x: x.metadata.labels[\"luigi_retries\"])\n\n return jobs","def active_jobs(self):\n \n active_jobs = []\n for job in self._jobs:\n if job.active:\n job.backend.status( job )\n active_jobs.append( job )\n\n self._active_jobs = active_jobs[:]\n\n return active_jobs","def jobs(\n ctx: typer.Context,\n op_id: str = typer.Argument(\n ...,\n autocompletion=completion_op_id,\n callback=check_for_op_id,\n help=\"A valid op-id. e.g. get_markets_prices\",\n ),\n param_string: Optional[str] = typer.Option(\n None,\n \"--param-string\",\n \"-p\",\n help=\"Optional. Full or partial parameters as a json encoded dictionary string. \"\n \"Keys must be valid parameters for selected op_id.\",\n ),\n default_params: bool = typer.Option(\n False,\n \"-d\",\n \"--default-params\",\n help=\"Include all parameters that are required, or have default values. \"\n \"Missing values will be 'NOTSET'.\",\n ),\n callback_path: Optional[Path] = typer.Option(\n None,\n \"-c\",\n \"--callbacks\",\n help=\"Optional. Path to custom callbacks to be used. \",\n ),\n file_name: str = typer.Option(\n \"created-jobs/${esi_job_op_id}-${esi_job_uid}\",\n \"-n\",\n \"--file-name\",\n help=(\n \"File name for the new job, must be unique if multiple jobs. \"\n \"Can include directories, \"\n \"and the file type suffix will be added based on --format-id.\"\n ),\n ),\n data_path: Optional[Path] = typer.Option(\n None,\n \"--data-file\",\n \"-i\",\n help=(\n \"Optional. Path to json, csv, or yaml file with full or partial parameters. \"\n \"Must result in a list of dicts.\"\n ),\n ),\n format_id: FormatChoices = typer.Option(\n FormatChoices.json,\n \"-f\",\n \"--format-id\",\n show_choices=True,\n help=\"Output file format.\",\n ),\n path_out: Path = typer.Argument(\n \"./tmp\",\n help=\"Parent path for saving the new jobs, will be prepended to --file-name.\",\n ),\n):\n operation_manifest: OperationManifest = ctx.obj[\"operation_manifest\"]\n # path_out = optional_object(path_out, Path, \".\")\n if path_out.is_file:\n typer.BadParameter(\"path_out must not be a file.\")\n file_data: Optional[List[Dict]] = get_params_from_file(data_path)\n parameters: Dict = decode_param_string(param_string)\n if callback_path is None:\n callback_collection = default_callback_collection()\n else:\n callback_collection = load_callbacks(callback_path)\n jobs_: List[EsiJob] = []\n try:\n op_info = operation_manifest.op_info(op_id)\n if not file_data:\n job = op_info.create_job(\n parameters,\n callback_collection,\n include_default_params=default_params,\n # only_required_default_params=False,\n # allow_notset=False,\n )\n jobs_.append(job)\n else:\n for params in file_data:\n params.update(parameters)\n job = op_info.create_job(\n params,\n callback_collection,\n include_default_params=default_params,\n # only_required_default_params=False,\n # allow_notset=False,\n )\n jobs_.append(job)\n except Exception as ex:\n raise typer.BadParameter(\n f\"Exception creating job. {ex.__class__.__name__}: {ex}\"\n )\n for job in jobs_:\n file_path = resolve_job_file_path(job, file_name, path_out)\n try:\n save_path = job.serialize_file(file_path, format_id)\n except Exception as ex:\n raise typer.BadParameter(\n f\"Error saving job to {save_path}. {ex.__class__.__name__}, {ex}\"\n )\n logger.info(\"Saved job %s at %s\", job.uid, file_path)\n typer.echo(f\"{len(jobs_)} jobs saved to {path_out}\")\n report_finished_task(ctx)","def jobs(self):\n \n def get_jobs(job_ids):\n return defer.DeferredList([Job.safe_fetch(job_id, self.connection) for job_id in job_ids], consumeErrors=True)\n \n def compact(deferred_list):\n ret = []\n for job in deferred_list:\n if isinstance(job, Job):\n ret.append(job)\n else:\n self.remove(job.job_id)\n return ret\n \n d = self.job_ids\n d.addCallback(get_jobs)\n d.addCallback(compact)\n return d","def get_list_of_containers_from_pod(namespace, pod_name, k8s_cli):\n cmd = \"{} get pod {} -o jsonpath=\\\"{{.spec.containers[*].name}}\\\" -n {}\".format(k8s_cli, pod_name, namespace)\n return_code, out = run_shell_command(cmd)\n if return_code:\n logger.warning(\"Failed to get containers from pod: %s\", out)\n return None\n return out.split()","def submit_jobs_with_retries(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:\n return submit_jobs(k8s_ctx, path, dry_run)","def query(self, jobs):\n assert isinstance(jobs, list), 'Jobs must be type list'\n assert len(jobs) > 0, 'One or more jobs required'\n\n req = list()\n if len(jobs) > 1:\n for r in self._batch_request(jobs):\n req.append(\n ''.join([self._scheduler_endpoint, '?', '&'.join(r)]))\n else:\n req = \"{}?job={}\".format(\n self._scheduler_endpoint, jobs[0])\n\n try:\n ret = list()\n for resp in self._api_get(req):\n ret.extend(resp.json())\n return ret\n except HTTPError as e:\n raise JobClientError(e.message)","def all_jobs(self, tags: List[str] = None, tags_intersect: List[str] = None) -> Iterator[Iterable]:\n return self._all_pages(self.jobs_page, tags=tags, tags_intersect=tags_intersect)","def all_jobs_for_client(ClientID):\n\n client = Client.get(ClientID)\n\n jobs = Job.get_all_for_client(ClientID)\n\n oneoffs = OneOff.get_from_client_id_between_dates(ClientID)\n\n invoices = MonthlyInvoice.get_from_client_id_between_dates(ClientID)\n\n job = JobView(client, jobs, oneoffs, False, Job.get_count_for_client(ClientID) > 0)\n\n add_trello_task_links_to_g()\n\n return render_template(\"jobs.template.html\", page_title=\"Jobs\", job_info=job, invoices=invoices)","def get_all_jobs_data(project_name, redis_connection):\n\n job_ids = JobDataRedis._fetch_project_job_ids(\n project_name, redis_connection)\n return JobDataRedis.all_jobs_by_list_of_job_ids(job_ids, redis_connection)","def job_records():\n os_name = platform.system()\n\n # Build a list of job records.\n jobs = []\n for row in subprocess.check_output('atq', text=True, encoding='latin-1').split('\\n'):\n if row:\n job_id, attribs = row.split('\\t')\n if os_name == 'Linux':\n timestamp_str, status_code, username = attribs.rsplit(' ', 2)\n elif os_name == 'Darwin':\n timestamp_str = attribs\n else:\n raise OSError(\"Unsupported platform '{}'\".format(os_name))\n full_command = job_full_command(job_id) # includes any env settings\n jobs.append({\n 'id': job_id,\n 'timestamp': parse_datetime(timestamp_str),\n 'full_command': full_command,\n 'command': full_command.split('\\n')[-3] # \"last\" line only\n })\n\n return sorted(jobs, key=lambda job: (job['timestamp'], int(job['id'])))","def get_job_builds(self, job_id, started=None, finished=None,\n success=None, skipped=None, order='asc', limit=100):\n pass","def queue_all_instances(self):\n if not self.is_job:\n return []\n\n tasks_list = []\n for job_instance in self.instances:\n tasks_list.append(job_instance.queue())\n\n self.status = 'QUEUED'\n return tasks_list","def get_executed_jobs(self):\n with self.__lock:\n return list(self.__executed_jobs)","def do_list(cs, args):\n opts = {}\n opts['all_projects'] = args.all_projects\n opts['marker'] = args.marker\n opts['limit'] = args.limit\n opts['sort_key'] = args.sort_key\n opts['sort_dir'] = args.sort_dir\n opts['image'] = args.image\n opts['name'] = args.name\n opts['project_id'] = args.project_id\n opts['user_id'] = args.user_id\n opts['host'] = args.host\n opts['task_state'] = args.task_state\n opts['memory'] = args.memory\n opts['auto_remove'] = args.auto_remove\n opts['status'] = args.status\n opts = zun_utils.remove_null_parms(**opts)\n containers = cs.containers.list(**opts)\n zun_utils.list_containers(containers)","def jobs(self):\n return JobManager(self)"],"string":"[\n \"def list_jobs():\\n\\n name_to_job_details = redis_controller.get_name_to_job_details()\\n return list(name_to_job_details.values())\",\n \"def jobs():\\n result = []\\n out = subprocess.check_output([\\\"/bin/launchctl\\\", \\\"list\\\"]).decode()\\n for row in out.splitlines()[1:]:\\n result.append(Job(row))\\n return result\",\n \"def ListJobs(self, token=None):\\n return aff4.FACTORY.Open(self.CRON_JOBS_PATH, token=token).ListChildren()\",\n \"def get_jobs(self, age=1):\\n jobs_for_reaper = []\\n try: \\n api_response = self.kube_v1_batch_client.list_namespaced_job(namespace=self.project, label_selector='job-origin=pman', include_uninitialized=True)\\n for item in api_response.items:\\n # Checking if job has finished running, either failed or succeeded\\n if item.status.conditions and (item.status.failed or item.status.succeeded):\\n # Using start_time because failed jobs have no completion_time\\n start_time = item.status.start_time\\n current_time = datetime.datetime.now(datetime.timezone.utc)\\n diff = current_time-start_time\\n # 86400 = number of seconds in a day. \\\"divmod\\\" returns quotient and remainder as tuple e.g (1, 5.74943)\\n # means 1 day and 5.74943 sec have passed between current_time and start_time of the job\\n diff_in_seconds = divmod(diff.total_seconds(), 86400)\\n if diff_in_seconds[0] >= 1:\\n jobs_for_reaper.append(item.metadata.name)\\n \\n except ApiException as e:\\n print(\\\"Exception when calling BatchV1Api->list_namespaced_job: %s\\\\n\\\" % e)\\n exit(1)\\n return jobs_for_reaper\",\n \"def list_jobs(arn=None, nextToken=None):\\n pass\",\n \"def get_jobs_list(self, response):\\n pass\",\n \"def get_jobs(self, label_selector, namespace):\\n return self.batch_client.list_namespaced_job(namespace, label_selector=label_selector, watch=False)\",\n \"def list_jobs(self):\\n\\n return dict(self._from_json(self.manage.run(override=\\\"list-jobs\\\")))\",\n \"def list(self):\\n return self.rpc.call(MsfRpcMethod.JobList)\",\n \"def get(self):\\n # TODO: auth\\n return list(self.app.db.jobs.find())\",\n \"def get_job_list(self):\\n return self.job_list\",\n \"def get_job_list(self):\\n return self.job_list\",\n \"async def get_jobs(): \\n return mngr.getAllJobs()\",\n \"def ListJobs(cls):\\n return [key.parent().string_id() for key in cls.query().fetch(\\n 100, keys_only=True)]\",\n \"def jobs(self):\\n return self.get_jobs()\",\n \"def get_jobs(self):\\n return list(self._jobs.values())\",\n \"def _get_jobs():\\n return _get_bigquery_service().jobs()\",\n \"def jobs(self, tags=None, tags_intersect=None):\\n return list(self.all_jobs(tags=tags, tags_intersect=tags_intersect))\",\n \"def get_jobs(self, *, params: Optional[dict] = None) -> \\\"resource_types.Jobs\\\":\\n\\n return communicator.Jobs(self.__requester).fetch(parameters=params)\",\n \"def get_job_list(self):\\n job_list = []\\n if mysql.job_list() == None:\\n return job_list\\n return mysql.job_list()\",\n \"def listJobs():\\n logger.debug('[FLASKWEB /jobs] Request for job listing')\\n jobs = db.getJobs(numdays=2)\\n for job in jobs:\\n job['time'] = datetime.datetime.strptime(job['time'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\\n if job['complete']:\\n job['complete'] = datetime.datetime.strptime(job['complete'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\\n\\n # Garbage Collect Orpahened jobs\\n compiles = db.getCompiles()\\n for compile in compiles:\\n if compile['submit']:\\n compile['submit'] = datetime.datetime.strptime(compile['submit'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\\n if compile['complete']:\\n compile['complete'] = datetime.datetime.strptime(compile['complete'], db.TS_FMT).replace(tzinfo=db.timezone('UTC')).isoformat()\\n # for c in compiles:\\n # if c['uid'] not in compile_tasks.keys():\\n # db.updateCompile(c['uid'], status='KILLED', done=True)\\n # compiles = db.getCompiles()\\n\\n if request.headers['Accept'] == 'application/json':\\n return jsonify(dict(LaunchJobs=jobs, CompilingJobs=compiles)), 200\\n else:\\n return render_template(\\\"jobs.html\\\", joblist=jobs, compilelist=compiles)\",\n \"def jobs(self) -> List[Job]:\\n return self._jobs.values()\",\n \"def jobs(ctx, page):\\n user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),\\n ctx.obj.get('experiment'))\\n page = page or 1\\n try:\\n response = PolyaxonClient().experiment.list_jobs(\\n user, project_name, _experiment, page=page)\\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\\n Printer.print_error('Could not get jobs for experiment `{}`.'.format(_experiment))\\n Printer.print_error('Error message `{}`.'.format(e))\\n sys.exit(1)\\n\\n meta = get_meta_response(response)\\n if meta:\\n Printer.print_header('Jobs for experiment `{}`.'.format(_experiment))\\n Printer.print_header('Navigation:')\\n dict_tabulate(meta)\\n else:\\n Printer.print_header('No jobs found for experiment `{}`.'.format(_experiment))\\n\\n objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))\\n for o in response['results']]\\n objects = list_dicts_to_tabulate(objects)\\n if objects:\\n Printer.print_header(\\\"Jobs:\\\")\\n objects.pop('experiment', None)\\n dict_tabulate(objects, is_list_dict=True)\",\n \"def list_jobs(user_data, cache):\\n user = cache.ensure_user(user_data)\\n\\n jobs = []\\n for job in cache.get_jobs(user):\\n try:\\n if job.project_id:\\n job.project = cache.get_project(user, job.project_id)\\n except IntermittentProjectIdError:\\n continue\\n\\n jobs.append(job)\\n\\n return result_response(JobListResponseRPC(), {\\\"jobs\\\": jobs})\",\n \"def get_all_jobs(self) -> List[DocumentReference]:\\n return self.get_all_documents(Type._JOBS)\",\n \"def submit_jobs(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:\\n retval = list()\\n if not path.exists():\\n raise RuntimeError(f'Path with kubernetes jobs \\\"{path}\\\" does not exist')\\n if path.is_dir():\\n num_files = len(os.listdir(str(path)))\\n if num_files == 0 and not dry_run:\\n raise RuntimeError(f'Job directory {str(path)} is empty')\\n elif num_files > K8S_MAX_JOBS_PER_DIR:\\n files = os.listdir(str(path))\\n for i, f in enumerate(sorted(files, key=lambda x: int(os.path.splitext(x)[0].split('_')[1]))):\\n retval += submit_jobs_with_retries(k8s_ctx, pathlib.Path(os.path.join(path, f)), dry_run) # type: ignore\\n perc_done = i / num_files * 100.\\n if i % 50 == 0:\\n logging.debug(f'Submitted job file # {i} of {num_files} {perc_done:.2f}% done')\\n return retval\\n\\n cmd = f'kubectl --context={k8s_ctx} apply -f {path} -o json'\\n if dry_run:\\n logging.info(cmd)\\n else:\\n p = safe_exec(cmd)\\n if p.stdout:\\n out = json.loads(p.stdout.decode())\\n if 'items' in out:\\n retval = [i['metadata']['name'] for i in out['items']]\\n else:\\n retval = [out['metadata']['name']]\\n return retval\",\n \"def get_jobs():\\n \\n rate_limit()\\n command = [\\\"bjobs\\\", \\\"-o\\\", \\\"\\\\\\\"JOBID\\\", \\\"USER\\\", \\\"STAT\\\", \\\"QUEUE\\\", \\\"JOB_NAME\\\", \\\\\\n \\\"delimiter=';'\\\\\\\"\\\"]\\n command = \\\" \\\".join(command)\\n jobs = subprocess.check_output(command, shell=True, stderr=open(os.devnull))\\n \\n # if there aren't any currently running or pending jobs, then the output\\n if jobs == \\\"\\\":\\n return set([])\\n \\n jobs = jobs.decode().strip().split(\\\"\\\\n\\\")\\n \\n current_jobs = set([])\\n for line in jobs:\\n if line.startswith(\\\"JOBID\\\"): # ignore the header line\\n continue\\n \\n line = line.split(\\\";\\\")\\n job_name = line[4]\\n current_jobs.add(job_name)\\n \\n return current_jobs\",\n \"def genJobList():\\n nit=10\\n reply=[]\\n while len(reply)<10: #assume qstat fails if less that 10 jobs on cluster\\n reply=chomp(os.popen('qstat|expand|tr -s \\\\' \\\\'|cut -d\\\\' \\\\' -f 1,2,5').readlines())\\n nit+=1\\n if nit>10: break\\n return reply\",\n \"def jobs(self):\\n return self._jobs\",\n \"def jobs(self):\\n return self.properties.get('jobs',\\n EntityCollection(self.context, SynchronizationJob,\\n ResourcePath(\\\"jobs\\\", self.resource_path)))\",\n \"def get_job_names(self):\\n return []\",\n \"def get_all_jobs():\\n fq = get_failed_queue(connection=conn)\\n job_data = {'queued_jobs': q.job_ids,\\n 'failed_jobs': fq.job_ids}\\n return jsonify(job_data), 200\",\n \"def getJobs(**options):\\n criteria = search.JobSearch.criteriaFromOptions(**options)\\n jobSeq = Cuebot.getStub('job').GetJobs(\\n job_pb2.JobGetJobsRequest(r=criteria), timeout=Cuebot.Timeout).jobs\\n return [Job(j) for j in jobSeq.jobs]\",\n \"def get_jobs(self, type = None):\\n joblist = JobList()\\n for jobs in self.sm.get_jobs(type = type):\\n joblist.add_job(jobs['identifier'], jobs['phase'])\\n return joblist.tostring()\",\n \"def get_jobs(bmc, only_unfinished):\\n jobs = bmc.list_jobs(only_unfinished)\\n return namedtuples_to_dicts(jobs)\",\n \"def jobs(self):\\n return JobCollection(client=self)\",\n \"def list_jobs(exproot, **kwargs):\\n for jobname, args, results in load_all(exproot):\\n print jobname, args, results\",\n \"def get_jobs(dumpruninfo):\\n if \\\"jobs\\\" not in dumpruninfo:\\n return []\\n return dumpruninfo[\\\"jobs\\\"].keys()\",\n \"def jobs(self):\\n raise NotImplementedError()\",\n \"def get_job_list():\\n\\tdirlist = os.listdir(\\\".\\\")\\n\\tjoblist = [x for x in dirlist if \\\"job.sh\\\" in x and x in job_dict]\\n\\ttmplist = [x for x in dirlist if \\\"job.sh\\\" in x and x not in job_dict]\\n\\tdef compare_function(s: str):\\n\\t\\treturn job_dict[s].order\\n\\tjoblist.sort(key=compare_function)\\n\\tjoblist.extend(tmplist)\\n\\treturn joblist\",\n \"def job_info(self):\\n def _sortkey(x):\\n return x['job_name']\\n\\n resp = self._cmd(uri = '/jenkins_jobs')\\n jobs = resp.get('jobs', [])\\n return sorted(jobs, key=_sortkey)\",\n \"def get_running_jobs(api_instance):\\n namespace = \\\"default\\\"\\n try:\\n api_response = api_instance.list_namespaced_job(namespace)\\n except ApiException as e:\\n logger.exception(\\\"Exception while receiving running Jobs{}\\\".format(e))\\n return api_response\",\n \"def get_pr_jobs():\\n res = requests.get(\\n uri + \\\"/view/Pull%20Requests/api/json\\\",\\n headers={\\\"accept\\\": \\\"application/json\\\"},\\n auth=requests.auth.HTTPBasicAuth(user, password),\\n verify=verify,\\n )\\n if res.status_code != 200:\\n raise RuntimeError(\\\"Received non 200 status code from jenkins\\\")\\n data = res.json()\\n for job in data[\\\"jobs\\\"]:\\n yield job\",\n \"def list(self):\\n self.background_scheduler.print_jobs()\",\n \"def get_registered_jobs(self):\\n with self.__lock:\\n return list(self.__registered_jobs)\",\n \"def get_jobs(self, expression):\\n return list(parse_job_list(expression, context=self.cc))\",\n \"def jobs(tileset, stage, token=None, indent=None):\\n mapbox_api = _get_api()\\n mapbox_token = _get_token(token)\\n url = \\\"{0}/tilesets/v1/{1}/jobs?access_token={2}\\\".format(\\n mapbox_api, tileset, mapbox_token\\n )\\n if stage:\\n url = \\\"{0}/tilesets/v1/{1}/jobs?stage={2}&access_token={3}\\\".format(\\n mapbox_api, tileset, stage, mapbox_token\\n )\\n\\n r = requests.get(url)\\n\\n click.echo(json.dumps(r.json(), indent=indent))\",\n \"def GetJobs(self, bulk=False):\\n query = []\\n _AppendIf(query, bulk, (\\\"bulk\\\", 1))\\n\\n if bulk:\\n return self._SendRequest(HTTP_GET,\\n \\\"/%s/jobs\\\" % GANETI_RAPI_VERSION,\\n query, None)\\n else:\\n return [int(j[\\\"id\\\"])\\n for j in self._SendRequest(HTTP_GET,\\n \\\"/%s/jobs\\\" % GANETI_RAPI_VERSION,\\n None, None)]\",\n \"def list_labeling_jobs(CreationTimeAfter=None, CreationTimeBefore=None, LastModifiedTimeAfter=None, LastModifiedTimeBefore=None, MaxResults=None, NextToken=None, NameContains=None, SortBy=None, SortOrder=None, StatusEquals=None):\\n pass\",\n \"def all_jobs():\\n\\n jobs = Job.get_all()\\n\\n oneoffs = OneOff.get_all()\\n\\n job = JobView(None, jobs, oneoffs, False, Job.count() > 0)\\n\\n add_trello_task_links_to_g()\\n\\n return render_template(\\\"jobs.template.html\\\", page_title=\\\"Jobs\\\", job_info=job)\",\n \"async def jobs(request):\\n\\n job_list = await get_jobs(request)\\n return template('jobs.html',\\n jobs=job_list)\",\n \"def job_names(self):\\n resp = self._cmd(uri = '/jenkins_jobs')\\n names = []\\n for item in resp.get('jobs'):\\n names.append(item.get('job_name'))\\n return sorted(names)\",\n \"def list(self):\\n\\n for job_name in self.upstart.get_all_jobs():\\n yield self.get_service(job_name)\",\n \"def get_jobs(self, offset=0, length=-1):\\n job_ids = self.get_job_ids(offset, length)\\n jobs = []\\n for job_id in job_ids:\\n try:\\n jobs.append(self.connection.get_job(job_id))\\n except NoSuchJobError:\\n pass\\n return jobs\",\n \"def list(self, jobguid=\\\"\\\", executionparams=None):\",\n \"def get_protection_jobs(cohesity_client, skip_jobs=False):\\n protection_job_list = cohesity_client.protection_jobs.get_protection_jobs()\\n active_job_list = []\\n for job in protection_job_list:\\n # Jobs which are deleted are ignored.\\n if job.is_deleted:\\n continue\\n # Skip jobs which are paused or in-active(failover ready).\\n if skip_jobs and (job.is_paused or job.is_active != None):\\n continue\\n active_job_list.append(job)\\n exported_res_dict[\\\"Protection Jobs\\\"].append(job.name)\\n return active_job_list\",\n \"def list():\\n # Calling config file\\n cf = config.ReadFile(config_file)\\n user = cf[\\\"authentication\\\"][\\\"user\\\"]\\n\\n l = []\\n for job in cron:\\n l.append(job)\\n return l\",\n \"def getJobListFromDB(self):\\n\\t\\tsql = \\\"SELECT jobname from hudson_jobs\\\"\\n\\t\\tcsr = self.db.cursor()\\n\\t\\tcsr.execute(sql)\\n\\t\\tdata = [ x[0] for x in csr.fetchall() ]\\n\\t\\treturn data\",\n \"def createJobs():\\n jobs_list = []\\n for job in raw_jobs:\\n cur_job = Job(int(job[0]), int(job[1]), int(job[2]))\\n print(\\\"Created job: index:\\\", cur_job.number, \\\"Length:\\\", cur_job.length, \\\"Type\\\", cur_job.type, file=debug_file)\\n jobs_list.append(cur_job)\\n print(\\\"-----------------FINISHED CREATING JOB OBJECTS----------------------\\\\n\\\\n\\\", file=debug_file)\\n return jobs_list\",\n \"def search_jobs(self, bill_id: int = 0, limit: int = 0) -> List[Job]:\\n pass\",\n \"def get_jobs():\\n jobs = [os.path.join(JOBS_DIR, job)\\n for job in os.listdir(JOBS_DIR)\\n if job != '.gitignore']\\n return jobs\",\n \"def list_pods(req, resp):\\n namespace = req.params['namespace']\\n return _get_all_pods(namespace)\",\n \"def cmd_list(arguments):\\r\\n\\r\\n # get a producer\\r\\n producer = getProducer()\\r\\n\\r\\n # get the list of pending jobs\\r\\n jobs = producer.list()\\r\\n\\r\\n # print que list size and the entries\\r\\n print \\\"Number of jobs: %d\\\" % len(jobs)\\r\\n for j in range(len(jobs)):\\r\\n print \\\" job %06d - %s\\\" % (j, jobs[j])\\r\\n\\r\\n return 0\",\n \"def get_jobs(self, jobstore=None):\\n\\n return self._scheduler.get_jobs(jobstore)\",\n \"def job(job_name):\\n ClientID = Job.get_client_id(job_name)\\n return tasks_for_client_job(ClientID, job_name)\",\n \"async def request_jobs_list(self, jobs_list_active_only: bool, *args, **kwargs) -> List[str]:\\n # TODO: implement\\n raise NotImplementedError('{} function \\\"request_jobs_list\\\" not implemented yet'.format(self.__class__.__name__))\",\n \"def list_service(request):\\n builder = http.ResponseBuilder()\\n master_addr = request.GET.get('master',None)\\n if not master_addr:\\n return builder.error('master is required').build_json()\\n\\n client = wrapper.Galaxy(master_addr,settings.GALAXY_CLIENT_BIN)\\n status,jobs = client.list_jobs()\\n LOG.info(status)\\n if not status:\\n return builder.error('fail to list jobs').build_json()\\n ret = []\\n for job in jobs:\\n ret.append(job.__dict__)\\n return builder.ok(data=ret).build_json()\",\n \"async def get_jobs(jobId: int) -> str: \\n return mngr.getJob(str(jobId))\",\n \"def get_waiting_jobs(self):\\n return []\",\n \"def list(self, jobguid=\\\"\\\", executionparams=dict()):\",\n \"def getClientJobsInformation(client):\\n # getSlaveForDispatch()\\n #jobs = mongo.db.jobs.find({'owner': client, 'is_active': True})\\n jobs = mongo.db.jobs.find({'is_active': True})\\n\\n # result = i.title()\\n # if any([s.get('status')=='on progress' for s in tasks]):\\n # result = 'On Progress'\\n # return result\\n\\n result = [{\\n 'name': j.get('name'),\\n 'datetime': j.get('datetime'),\\n 'status': getJobStatus(j),\\n 'priority': j.get('priority'),\\n 'progress': sum([t.get('progress') for t in mongo.db.tasks.find({'job': j.get('_id')})]) /\\n (mongo.db.tasks.find({'job': j.get('_id')}).count() or -1),\\n 'id': str(j.get('_id')),\\n 'tasks_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True}).count(),\\n 'failed_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True, 'status': 'failed'}).count(),\\n 'completed_count': mongo.db.tasks.find({'job': j.get('_id'), 'is_active': True, 'status': 'completed'}).count(),\\n 'active_task': 'Frame 43',\\n } for j in jobs]\\n return result or {}\",\n \"def clean_jobs():\\n\\n # Delete all job related resources.\\n redis_controller.delete_pending_jobs_queue()\\n redis_controller.delete_killed_jobs_queue()\\n name_to_node_details = redis_controller.get_name_to_node_details()\\n for _, node_details in name_to_node_details.items():\\n node_hostname = node_details[\\\"hostname\\\"]\\n for container_name in node_details[\\\"containers\\\"]:\\n requests.delete(\\n url=f\\\"http://{node_hostname}:{node_details['api_server']['port']}/containers/{container_name}\\\",\\n )\\n return {}\",\n \"def list_compilation_jobs(NextToken=None, MaxResults=None, CreationTimeAfter=None, CreationTimeBefore=None, LastModifiedTimeAfter=None, LastModifiedTimeBefore=None, NameContains=None, StatusEquals=None, SortBy=None, SortOrder=None):\\n pass\",\n \"def get_current_jobs(ssh):\\n stdin, stdout, stderr = ssh.exec_command('qstat')\\n\\n running_jobs = []\\n for line in stdout.readlines():\\n if '.awonmgr2' in line:\\n jobid = line.split('.awonmgr2')[0]\\n running_jobs.append(jobid)\\n \\n return running_jobs\",\n \"def get_jobs(state=\\\"all\\\"):\\n if state.lower() == \\\"all\\\":\\n query = {\\\"type\\\": \\\"op\\\", \\\"cmd\\\": \\\"<show><jobs><all></all></jobs></show>\\\"}\\n elif state.lower() == \\\"pending\\\":\\n query = {\\\"type\\\": \\\"op\\\", \\\"cmd\\\": \\\"<show><jobs><pending></pending></jobs></show>\\\"}\\n elif state.lower() == \\\"processed\\\":\\n query = {\\n \\\"type\\\": \\\"op\\\",\\n \\\"cmd\\\": \\\"<show><jobs><processed></processed></jobs></show>\\\",\\n }\\n else:\\n raise CommandExecutionError(\\n \\\"The state parameter must be all, pending, or processed.\\\"\\n )\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def list_job_runs(\\n self,\\n ) -> Callable[[cloud_deploy.ListJobRunsRequest], cloud_deploy.ListJobRunsResponse]:\\n # Generate a \\\"stub function\\\" on-the-fly which will actually make\\n # the request.\\n # gRPC handles serialization and deserialization, so we just need\\n # to pass in the functions for each.\\n if \\\"list_job_runs\\\" not in self._stubs:\\n self._stubs[\\\"list_job_runs\\\"] = self.grpc_channel.unary_unary(\\n \\\"/google.cloud.deploy.v1.CloudDeploy/ListJobRuns\\\",\\n request_serializer=cloud_deploy.ListJobRunsRequest.serialize,\\n response_deserializer=cloud_deploy.ListJobRunsResponse.deserialize,\\n )\\n return self._stubs[\\\"list_job_runs\\\"]\",\n \"def list_runtimes(self, docker_image_name='all'):\\n logger.debug('Listing runtimes')\\n logger.debug('Note that k8s job backend does not manage runtimes')\\n return []\",\n \"def submit(self, jobs):\\n assert isinstance(jobs, list), 'Jobs must be type list'\\n assert len(jobs) > 0, 'One or more jobs required'\\n\\n data = {'jobs': jobs}\\n for j in data['jobs']:\\n # generate a random UUID if absent\\n if 'uuid' not in j:\\n j['uuid'] = str(uuid1())\\n\\n # default missing fields\\n j.update(dict(self._default_job_settings.items() + j.items()))\\n\\n self._job_schema.validate(jobs)\\n\\n try:\\n self._api_post(self._scheduler_endpoint, data)\\n return [j['uuid'] for j in data['jobs']]\\n except HTTPError as e:\\n raise JobClientError(e.message)\",\n \"def get_vm_list(self):\\n\\t\\treturn Job(SDK.PrlSrv_GetVmList(self.handle)[0])\",\n \"def get_completed_incore_jobs(self):\\n self.completed_incore_jobs = list()\\n for label, job_names in self.running_jobs.items():\\n for job_name in job_names:\\n i = get_i_from_job_name(job_name)\\n if i is None:\\n job_type = '_'.join(job_name.split('_')[:-1]) # Consider job types such as 'directed_scan'.\\n job = self.job_dict[label][job_type][job_name]\\n elif 'conformer' in job_name:\\n job = self.job_dict[label]['conformers'][i]\\n elif 'tsg' in job_name:\\n job = self.job_dict[label]['tsg'][i]\\n else:\\n raise ValueError(f'Did not recognize job {job_name} of species {label}.')\\n if job.execution_type == 'incore' and job.job_status[0] == 'done':\\n self.completed_incore_jobs.append(job.job_id)\",\n \"def jobs(self):\\n return JobManager(session=self._session)\",\n \"def list_pilot_compute(self):\\n return self.pilot_job_service\",\n \"def get_all_jobs(self):\\n all_jobs = self.job_set.all().order_by(\\\"-time_last_updated\\\", \\\"project__name\\\", \\\"-id\\\")\\n # for job in all_jobs:\\n # job.check_exists()\\n\\n # get the list of jobs listed in the database as running and update them.\\n dbrunning = all_jobs.filter(state__in=['in queue', 'started'])\\n for runningjob in dbrunning: runningjob.update();\\n\\n # get the updated list \\n all_jobs = self.job_set.all().order_by(\\\"-time_last_updated\\\", \\\"project__name\\\", \\\"-id\\\")\\n\\n return all_jobs\",\n \"def monitor_jobs(v1_api, jobs_to_monitor, namespace=\\\"default\\\"):\\n w = watch.Watch()\\n num_succeeded = 0\\n num_failed = 0\\n for e in w.stream(v1_api.list_namespaced_pod, namespace):\\n pod = e[\\\"object\\\"]\\n event_type = e[\\\"type\\\"]\\n if pod.spec.containers:\\n for c in pod.spec.containers:\\n if c.name in jobs_to_monitor:\\n logging.info(\\\"Job %s signalled event %s, POD Phase: %s\\\", c.name,\\n event_type, pod.status.phase)\\n if pod.status.phase == \\\"Succeeded\\\":\\n num_succeeded += 1\\n jobs_to_monitor.pop(c.name)\\n elif pod.status.phase == \\\"Failed\\\":\\n num_failed += 1\\n jobs_to_monitor.pop(c.name)\\n logging.info(\\\"Waiting for %d jobs to finish\\\", len(jobs_to_monitor))\\n if len(jobs_to_monitor) <= 0:\\n break\\n return num_succeeded, num_failed\",\n \"def get_executions(self, task_id, include_hostname=None):\\n if include_hostname or config[\\\"retry_host_sensitive\\\"].get(bool):\\n lbl_sel = f\\\"taclib_task_name={task_id},luigi_host={socket.gethostname()}\\\"\\n else:\\n lbl_sel = f\\\"taclib_task_name={task_id}\\\"\\n res = self._c_batch.list_namespaced_job(self.namespace, label_selector=lbl_sel)\\n jobs = sorted(res.items, key=lambda x: x.metadata.labels[\\\"luigi_retries\\\"])\\n\\n return jobs\",\n \"def active_jobs(self):\\n \\n active_jobs = []\\n for job in self._jobs:\\n if job.active:\\n job.backend.status( job )\\n active_jobs.append( job )\\n\\n self._active_jobs = active_jobs[:]\\n\\n return active_jobs\",\n \"def jobs(\\n ctx: typer.Context,\\n op_id: str = typer.Argument(\\n ...,\\n autocompletion=completion_op_id,\\n callback=check_for_op_id,\\n help=\\\"A valid op-id. e.g. get_markets_prices\\\",\\n ),\\n param_string: Optional[str] = typer.Option(\\n None,\\n \\\"--param-string\\\",\\n \\\"-p\\\",\\n help=\\\"Optional. Full or partial parameters as a json encoded dictionary string. \\\"\\n \\\"Keys must be valid parameters for selected op_id.\\\",\\n ),\\n default_params: bool = typer.Option(\\n False,\\n \\\"-d\\\",\\n \\\"--default-params\\\",\\n help=\\\"Include all parameters that are required, or have default values. \\\"\\n \\\"Missing values will be 'NOTSET'.\\\",\\n ),\\n callback_path: Optional[Path] = typer.Option(\\n None,\\n \\\"-c\\\",\\n \\\"--callbacks\\\",\\n help=\\\"Optional. Path to custom callbacks to be used. \\\",\\n ),\\n file_name: str = typer.Option(\\n \\\"created-jobs/${esi_job_op_id}-${esi_job_uid}\\\",\\n \\\"-n\\\",\\n \\\"--file-name\\\",\\n help=(\\n \\\"File name for the new job, must be unique if multiple jobs. \\\"\\n \\\"Can include directories, \\\"\\n \\\"and the file type suffix will be added based on --format-id.\\\"\\n ),\\n ),\\n data_path: Optional[Path] = typer.Option(\\n None,\\n \\\"--data-file\\\",\\n \\\"-i\\\",\\n help=(\\n \\\"Optional. Path to json, csv, or yaml file with full or partial parameters. \\\"\\n \\\"Must result in a list of dicts.\\\"\\n ),\\n ),\\n format_id: FormatChoices = typer.Option(\\n FormatChoices.json,\\n \\\"-f\\\",\\n \\\"--format-id\\\",\\n show_choices=True,\\n help=\\\"Output file format.\\\",\\n ),\\n path_out: Path = typer.Argument(\\n \\\"./tmp\\\",\\n help=\\\"Parent path for saving the new jobs, will be prepended to --file-name.\\\",\\n ),\\n):\\n operation_manifest: OperationManifest = ctx.obj[\\\"operation_manifest\\\"]\\n # path_out = optional_object(path_out, Path, \\\".\\\")\\n if path_out.is_file:\\n typer.BadParameter(\\\"path_out must not be a file.\\\")\\n file_data: Optional[List[Dict]] = get_params_from_file(data_path)\\n parameters: Dict = decode_param_string(param_string)\\n if callback_path is None:\\n callback_collection = default_callback_collection()\\n else:\\n callback_collection = load_callbacks(callback_path)\\n jobs_: List[EsiJob] = []\\n try:\\n op_info = operation_manifest.op_info(op_id)\\n if not file_data:\\n job = op_info.create_job(\\n parameters,\\n callback_collection,\\n include_default_params=default_params,\\n # only_required_default_params=False,\\n # allow_notset=False,\\n )\\n jobs_.append(job)\\n else:\\n for params in file_data:\\n params.update(parameters)\\n job = op_info.create_job(\\n params,\\n callback_collection,\\n include_default_params=default_params,\\n # only_required_default_params=False,\\n # allow_notset=False,\\n )\\n jobs_.append(job)\\n except Exception as ex:\\n raise typer.BadParameter(\\n f\\\"Exception creating job. {ex.__class__.__name__}: {ex}\\\"\\n )\\n for job in jobs_:\\n file_path = resolve_job_file_path(job, file_name, path_out)\\n try:\\n save_path = job.serialize_file(file_path, format_id)\\n except Exception as ex:\\n raise typer.BadParameter(\\n f\\\"Error saving job to {save_path}. {ex.__class__.__name__}, {ex}\\\"\\n )\\n logger.info(\\\"Saved job %s at %s\\\", job.uid, file_path)\\n typer.echo(f\\\"{len(jobs_)} jobs saved to {path_out}\\\")\\n report_finished_task(ctx)\",\n \"def jobs(self):\\n \\n def get_jobs(job_ids):\\n return defer.DeferredList([Job.safe_fetch(job_id, self.connection) for job_id in job_ids], consumeErrors=True)\\n \\n def compact(deferred_list):\\n ret = []\\n for job in deferred_list:\\n if isinstance(job, Job):\\n ret.append(job)\\n else:\\n self.remove(job.job_id)\\n return ret\\n \\n d = self.job_ids\\n d.addCallback(get_jobs)\\n d.addCallback(compact)\\n return d\",\n \"def get_list_of_containers_from_pod(namespace, pod_name, k8s_cli):\\n cmd = \\\"{} get pod {} -o jsonpath=\\\\\\\"{{.spec.containers[*].name}}\\\\\\\" -n {}\\\".format(k8s_cli, pod_name, namespace)\\n return_code, out = run_shell_command(cmd)\\n if return_code:\\n logger.warning(\\\"Failed to get containers from pod: %s\\\", out)\\n return None\\n return out.split()\",\n \"def submit_jobs_with_retries(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:\\n return submit_jobs(k8s_ctx, path, dry_run)\",\n \"def query(self, jobs):\\n assert isinstance(jobs, list), 'Jobs must be type list'\\n assert len(jobs) > 0, 'One or more jobs required'\\n\\n req = list()\\n if len(jobs) > 1:\\n for r in self._batch_request(jobs):\\n req.append(\\n ''.join([self._scheduler_endpoint, '?', '&'.join(r)]))\\n else:\\n req = \\\"{}?job={}\\\".format(\\n self._scheduler_endpoint, jobs[0])\\n\\n try:\\n ret = list()\\n for resp in self._api_get(req):\\n ret.extend(resp.json())\\n return ret\\n except HTTPError as e:\\n raise JobClientError(e.message)\",\n \"def all_jobs(self, tags: List[str] = None, tags_intersect: List[str] = None) -> Iterator[Iterable]:\\n return self._all_pages(self.jobs_page, tags=tags, tags_intersect=tags_intersect)\",\n \"def all_jobs_for_client(ClientID):\\n\\n client = Client.get(ClientID)\\n\\n jobs = Job.get_all_for_client(ClientID)\\n\\n oneoffs = OneOff.get_from_client_id_between_dates(ClientID)\\n\\n invoices = MonthlyInvoice.get_from_client_id_between_dates(ClientID)\\n\\n job = JobView(client, jobs, oneoffs, False, Job.get_count_for_client(ClientID) > 0)\\n\\n add_trello_task_links_to_g()\\n\\n return render_template(\\\"jobs.template.html\\\", page_title=\\\"Jobs\\\", job_info=job, invoices=invoices)\",\n \"def get_all_jobs_data(project_name, redis_connection):\\n\\n job_ids = JobDataRedis._fetch_project_job_ids(\\n project_name, redis_connection)\\n return JobDataRedis.all_jobs_by_list_of_job_ids(job_ids, redis_connection)\",\n \"def job_records():\\n os_name = platform.system()\\n\\n # Build a list of job records.\\n jobs = []\\n for row in subprocess.check_output('atq', text=True, encoding='latin-1').split('\\\\n'):\\n if row:\\n job_id, attribs = row.split('\\\\t')\\n if os_name == 'Linux':\\n timestamp_str, status_code, username = attribs.rsplit(' ', 2)\\n elif os_name == 'Darwin':\\n timestamp_str = attribs\\n else:\\n raise OSError(\\\"Unsupported platform '{}'\\\".format(os_name))\\n full_command = job_full_command(job_id) # includes any env settings\\n jobs.append({\\n 'id': job_id,\\n 'timestamp': parse_datetime(timestamp_str),\\n 'full_command': full_command,\\n 'command': full_command.split('\\\\n')[-3] # \\\"last\\\" line only\\n })\\n\\n return sorted(jobs, key=lambda job: (job['timestamp'], int(job['id'])))\",\n \"def get_job_builds(self, job_id, started=None, finished=None,\\n success=None, skipped=None, order='asc', limit=100):\\n pass\",\n \"def queue_all_instances(self):\\n if not self.is_job:\\n return []\\n\\n tasks_list = []\\n for job_instance in self.instances:\\n tasks_list.append(job_instance.queue())\\n\\n self.status = 'QUEUED'\\n return tasks_list\",\n \"def get_executed_jobs(self):\\n with self.__lock:\\n return list(self.__executed_jobs)\",\n \"def do_list(cs, args):\\n opts = {}\\n opts['all_projects'] = args.all_projects\\n opts['marker'] = args.marker\\n opts['limit'] = args.limit\\n opts['sort_key'] = args.sort_key\\n opts['sort_dir'] = args.sort_dir\\n opts['image'] = args.image\\n opts['name'] = args.name\\n opts['project_id'] = args.project_id\\n opts['user_id'] = args.user_id\\n opts['host'] = args.host\\n opts['task_state'] = args.task_state\\n opts['memory'] = args.memory\\n opts['auto_remove'] = args.auto_remove\\n opts['status'] = args.status\\n opts = zun_utils.remove_null_parms(**opts)\\n containers = cs.containers.list(**opts)\\n zun_utils.list_containers(containers)\",\n \"def jobs(self):\\n return JobManager(self)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79306775","0.7741598","0.7518071","0.7471795","0.7458499","0.74025124","0.73712224","0.7338191","0.7267556","0.72309756","0.72155577","0.72155577","0.72001016","0.7166212","0.706977","0.70534074","0.7034029","0.7031616","0.70106757","0.69732976","0.69674444","0.68800116","0.68705875","0.685322","0.6832234","0.6776611","0.6764701","0.67306304","0.67234236","0.66809165","0.6639186","0.66185343","0.6600322","0.65996534","0.65982634","0.6596586","0.6555502","0.6543587","0.65236795","0.6522302","0.6507556","0.64851105","0.64849764","0.6416516","0.641441","0.64054096","0.6390786","0.6375262","0.6360733","0.6352377","0.6342829","0.6338134","0.63301545","0.6304914","0.6296144","0.62362206","0.6208444","0.6203488","0.6179613","0.6165479","0.6145793","0.6143827","0.6138413","0.61372954","0.6118602","0.61117536","0.6098186","0.6085331","0.6077063","0.6071077","0.6018582","0.60118574","0.6004619","0.5995315","0.5973394","0.5949728","0.5934357","0.5899843","0.5887015","0.5880422","0.587793","0.58767486","0.5875712","0.58725667","0.58723783","0.58692676","0.5867668","0.58347005","0.58329433","0.5831942","0.58262485","0.58226275","0.58162445","0.5812286","0.5802317","0.58011097","0.5800234","0.5796799","0.5789815","0.57850456"],"string":"[\n \"0.79306775\",\n \"0.7741598\",\n \"0.7518071\",\n \"0.7471795\",\n \"0.7458499\",\n \"0.74025124\",\n \"0.73712224\",\n \"0.7338191\",\n \"0.7267556\",\n \"0.72309756\",\n \"0.72155577\",\n \"0.72155577\",\n \"0.72001016\",\n \"0.7166212\",\n \"0.706977\",\n \"0.70534074\",\n \"0.7034029\",\n \"0.7031616\",\n \"0.70106757\",\n \"0.69732976\",\n \"0.69674444\",\n \"0.68800116\",\n \"0.68705875\",\n \"0.685322\",\n \"0.6832234\",\n \"0.6776611\",\n \"0.6764701\",\n \"0.67306304\",\n \"0.67234236\",\n \"0.66809165\",\n \"0.6639186\",\n \"0.66185343\",\n \"0.6600322\",\n \"0.65996534\",\n \"0.65982634\",\n \"0.6596586\",\n \"0.6555502\",\n \"0.6543587\",\n \"0.65236795\",\n \"0.6522302\",\n \"0.6507556\",\n \"0.64851105\",\n \"0.64849764\",\n \"0.6416516\",\n \"0.641441\",\n \"0.64054096\",\n \"0.6390786\",\n \"0.6375262\",\n \"0.6360733\",\n \"0.6352377\",\n \"0.6342829\",\n \"0.6338134\",\n \"0.63301545\",\n \"0.6304914\",\n \"0.6296144\",\n \"0.62362206\",\n \"0.6208444\",\n \"0.6203488\",\n \"0.6179613\",\n \"0.6165479\",\n \"0.6145793\",\n \"0.6143827\",\n \"0.6138413\",\n \"0.61372954\",\n \"0.6118602\",\n \"0.61117536\",\n \"0.6098186\",\n \"0.6085331\",\n \"0.6077063\",\n \"0.6071077\",\n \"0.6018582\",\n \"0.60118574\",\n \"0.6004619\",\n \"0.5995315\",\n \"0.5973394\",\n \"0.5949728\",\n \"0.5934357\",\n \"0.5899843\",\n \"0.5887015\",\n \"0.5880422\",\n \"0.587793\",\n \"0.58767486\",\n \"0.5875712\",\n \"0.58725667\",\n \"0.58723783\",\n \"0.58692676\",\n \"0.5867668\",\n \"0.58347005\",\n \"0.58329433\",\n \"0.5831942\",\n \"0.58262485\",\n \"0.58226275\",\n \"0.58162445\",\n \"0.5812286\",\n \"0.5802317\",\n \"0.58011097\",\n \"0.5800234\",\n \"0.5796799\",\n \"0.5789815\",\n \"0.57850456\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84486145"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78698,"cells":{"query":{"kind":"string","value":"Wait for the job to return successfully or raise a TimeoutError after specified number of attempts"},"document":{"kind":"string","value":"def _wait_for_job(k8s_ctx: str, job_file: pathlib.Path, attempts: int = 30, secs2wait: int = 60, dry_run: bool = False) -> None:\n\n for counter in range(attempts):\n if _job_succeeded(k8s_ctx, job_file, dry_run):\n break\n time.sleep(secs2wait)\n else:\n raise TimeoutError(f'{job_file} timed out')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def _wait_retry(self) -> None:\n # Sleep 2^tries + 0…tries*3 seconds between retries\n self.retry_task = asyncio.create_task(\n asyncio.sleep(2 ** min(9, self.tries) + random.randint(0, self.tries * 3))\n )\n await self.retry_task\n self.retry_task = None","def __wait_for_job_success(self, name, jobname, delay = 30, tries = 36, loop_sleep = 5):\n start = time.time()\n print(\"Waiting for %s seconds before starting polling.\" % delay)\n time.sleep(delay)\n try:\n uuid = run(\"drush psite-uuid %s --nocache\" % name, pty=True, combine_stderr=True)\n for loop in range(1, tries+1):\n end = time.time()\n print(\"\\n\" + time.strftime(\"%d/%m/%Y %H:%M:%S\"))\n print(\"Running psite-jobs for the %s time, it has been %d seconds so far.\" % (loop, end - start))\n # the below grep command requires terminal wider than 120 columns:\n job_line = run(\"drush psite-jobs %s | grep '%s' || :\" % (uuid, jobname), \n pty=True, combine_stderr=True)\n m = re.search('SUCCESS', job_line)\n if m != None:\n end = time.time()\n print(\"We waited %d seconds and then needed %d loops, with %d second wait. Total elapsed time: %d seconds.\"\n % (delay, loop, loop_sleep, end - start))\n return\n time.sleep(loop_sleep)\n\n except SystemExit as e:\n raise Exception(\"Error while waiting for job to finish.Err: %s\" % str(e))\n\n end = time.time()\n raise Exception(\"Site create didn't finish in time. Total elapsed time: %d seconds, max time %d seconds (%d + %d x %d).\"\n % (end - start, tries * loop_sleep + delay, delay, tries, loop_sleep))","def wait_for_completion(self, timeout=10):\n cur_status = self.runtime_status()\n while cur_status not in ['FAILED', 'KILLED', 'FINISHED']:\n time.sleep(0.2)\n timeout -= 0.2\n cur_status = self.runtime_status()\n if timeout < 0:\n break\n\n return timeout > 0","def wait_for_job(job):\n if job.state != 'RUNNING':\n job.begin()\n retry_count = 1000\n while retry_count > 0 and job.state != 'DONE':\n retry_count -= 1\n time.sleep(1)\n job.reload()\n assert not job.errors, job.errors\n return job","def _wait_for_completion(conn, promise, wait_timeout, msg):\n if not promise:\n return\n wait_timeout = time.time() + wait_timeout\n while wait_timeout > time.time():\n time.sleep(5)\n operation_result = conn.get_request(\n request_id=promise[\"requestId\"], status=True\n )\n\n if operation_result[\"metadata\"][\"status\"] == \"DONE\":\n return\n elif operation_result[\"metadata\"][\"status\"] == \"FAILED\":\n raise Exception(\n \"Request: {}, requestId: {} failed to complete:\\n{}\".format(\n msg,\n str(promise[\"requestId\"]),\n operation_result[\"metadata\"][\"message\"],\n )\n )\n\n raise Exception(\n 'Timed out waiting for asynchronous operation {} \"{}\" to complete.'.format(\n msg, str(promise[\"requestId\"])\n )\n )","def wait(self, msecs = sys.maxint):\n\t\tcall_sdk_function('PrlJob_Wait', self.handle, msecs)\n\t\terr_obj = None\n\t\ttry:\n\t\t\terr_obj = self.get_error()\n\t\texcept:\n\t\t\tpass\n\t\tsdk_check_result(self.get_ret_code(), err_obj)\n\t\treturn self.get_result()","def _retry_finish(self, finish_job_params, success):\n if success:\n if (\n \"job_output\" not in finish_job_params\n or finish_job_params[\"job_output\"] is None\n ):\n finish_job_params[\"job_output\"] = {}\n\n try:\n self.ee2.finish_job(finish_job_params)\n except Exception:\n _sleep(30)\n self.ee2.finish_job(finish_job_params)","def timeout(n):\n time.sleep(int(n))\n return 'ok', 200","def wait_for(func, expected_exceptions=(), retries=60):\n\n retries = int(retries)\n for retry in range(1, retries + 1):\n try:\n return_value = func()\n if return_value:\n break\n\n except expected_exceptions:\n if retry == retries:\n raise\n else:\n pass\n\n time.sleep(1)\n\n return return_value","def _wait_for_job_complete():\n retries = kwargs['retries']\n try:\n kwargs['retries'] = retries + 1\n if not kwargs['wait_for_job_called']:\n is_complete, result, rc, status, task = (\n self._is_job_finished(job_id))\n if is_complete is True:\n kwargs['wait_for_job_called'] = True\n kwargs['rc'], kwargs['status'] = rc, status\n kwargs['result'], kwargs['task'] = result, task\n else:\n kwargs['status'], kwargs['task'] = status, task\n except Exception as error:\n exception_message = 'Issue encountered waiting for job.'\n LOG.exception(exception_message)\n raise exception.VolumeBackendAPIException(\n data=exception_message) from error\n\n return kwargs","def wait_for_job(self, value):\n logger.info('Waiting for job %s' % self.job_name)\n\n if self.provider_options.dry_run == True:\n logger.info('Dry run: continuing')\n else:\n logger.info('Checking job status...')\n provider = provider_base.get_provider(self.provider_options)\n\n while True:\n tasks = provider.lookup_job_tasks('*', job_name_list=[self.job_name], max_jobs=1)\n logger.debug('Tasks: %s' % tasks)\n\n if not tasks:\n raise RuntimeError('Job not found: %s' % self.job_name)\n\n is_running = False\n status = None\n\n # Wait until all tasks succeed; abort if any task fails or is canceled\n for task in tasks:\n status = provider.get_task_field(task, 'job-status')\n\n if status == 'RUNNING':\n is_running = True\n elif status == 'CANCELED':\n raise RuntimeException('Job %s: CANCELED' % self.job_name)\n elif status == 'FAILURE':\n error = provider.get_task_field(task, 'error-message')\n raise RuntimeException('Job %s: FAILURE. Error message: %s' % (self.job_name, error))\n\n if is_running:\n time.sleep(self.poll_interval)\n else:\n break\n\n logger.info('Job %s: SUCCESS' % self.job_name)\n return 'Success'","def test_wait_for_predicate_timeout(self):\n predicate_mock = mock.MagicMock(side_effect=[True, True, True])\n with self.assertRaises(TimeoutError):\n train_utils.wait_for_predicate(predicate_mock, num_retries=3)","def waitUntilSuccess():","async def timeout(self, failed: bool = False) -> None:\n raise NotImplementedError()","def set_retry_timeout(self, retry_timeout):","def wait(self, timeout):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)","def wait_for_job_complete(self, job):\n res, tasks = None, None\n if job['status'].lower() == SUCCEEDED:\n try:\n res, tasks = job['result'], job['task']\n except KeyError:\n pass\n return 0, res, job['status'], tasks\n\n def _wait_for_job_complete():\n \"\"\"Called at an interval until the job is finished.\"\"\"\n retries = kwargs['retries']\n try:\n kwargs['retries'] = retries + 1\n if not kwargs['wait_for_job_called']:\n is_complete, result, rc, status, task = (\n self._is_job_finished(job_id))\n if is_complete is True:\n kwargs['wait_for_job_called'] = True\n kwargs['rc'], kwargs['status'] = rc, status\n kwargs['result'], kwargs['task'] = result, task\n else:\n kwargs['status'], kwargs['task'] = status, task\n except Exception as error:\n exception_message = 'Issue encountered waiting for job.'\n LOG.exception(exception_message)\n raise exception.VolumeBackendAPIException(\n data=exception_message) from error\n\n return kwargs\n\n job_id = job['jobId']\n kwargs = {'retries': 0, 'wait_for_job_called': False,\n 'rc': 0, 'result': None}\n\n while not kwargs['wait_for_job_called']:\n time.sleep(self.interval)\n kwargs = _wait_for_job_complete()\n if kwargs['retries'] > self.retries:\n LOG.error('_wait_for_job_complete failed after {cnt} '\n 'tries.'.format(cnt=kwargs['retries']))\n kwargs['rc'], kwargs['result'] = -1, kwargs['result']\n break\n\n LOG.debug('Return code is: {rc}. Result is {res}.'.format(\n rc=kwargs['rc'], res=kwargs['result']))\n return (kwargs['rc'], kwargs['result'],\n kwargs['status'], kwargs['task'])","def _wait_for(\n func: Callable,\n expected_result: Any = True,\n timeout: int = 10,\n print_error: bool = True,\n sleep_for: int = 1,\n **kwargs,\n) -> None:\n end = time() + timeout\n\n while time() <= end:\n try:\n retval = func(**kwargs)\n except Exception as err: # pylint: disable=broad-except\n if print_error:\n logger.error(err)\n else:\n if retval == expected_result:\n return None\n sleep(sleep_for)\n\n raise WaitForException(\n f\"func: {func}, didn't return {expected_result} within specified timeout: {timeout}\"\n )","def wait(self, timeout=600):\n s = datetime.datetime.now()\n status = json.loads(self.get())\n while status['status'] != 'COMPLETE':\n status = self.get()\n e = datetime.datetime.now()\n if (e - s).seconds > timeout:\n raise RuntimeError('timeout')\n return status","def _wait_until_job_starts_on_cluster(self) -> Optional[float]:\n status = None\n job_checking_retry_cnt = 0\n while job_checking_retry_cnt < MAX_JOB_CHECKING_RETRY:\n # Avoid the infinite loop, if any bug happens.\n job_checking_retry_cnt += 1\n try:\n cluster_status, _ = (\n backend_utils.refresh_cluster_status_handle(\n self.cluster_name,\n force_refresh_statuses=set(status_lib.ClusterStatus)))\n except Exception as e: # pylint: disable=broad-except\n # If any unexpected error happens, retry the job checking\n # loop.\n # TODO(zhwu): log the unexpected error to usage collection\n # for future debugging.\n logger.info(f'Unexpected exception: {e}\\nFailed to get the '\n 'refresh the cluster status. Retrying.')\n continue\n if cluster_status != status_lib.ClusterStatus.UP:\n # The cluster can be preempted before the job is\n # launched.\n # Break to let the retry launch kick in.\n logger.info('The cluster is preempted before the job '\n 'is submitted.')\n # TODO(zhwu): we should recover the preemption with the\n # recovery strategy instead of the current while loop.\n break\n\n try:\n status = spot_utils.get_job_status(self.backend,\n self.cluster_name)\n except Exception as e: # pylint: disable=broad-except\n # If any unexpected error happens, retry the job checking\n # loop.\n # Note: the CommandError is already handled in the\n # get_job_status, so it should not happen here.\n # TODO(zhwu): log the unexpected error to usage collection\n # for future debugging.\n logger.info(f'Unexpected exception: {e}\\nFailed to get the '\n 'job status. Retrying.')\n continue\n\n # Check the job status until it is not in initialized status\n if status is not None and status > job_lib.JobStatus.INIT:\n try:\n job_submitted_at = spot_utils.get_job_timestamp(\n self.backend, self.cluster_name, get_end_time=False)\n return job_submitted_at\n except Exception as e: # pylint: disable=broad-except\n # If we failed to get the job timestamp, we will retry\n # job checking loop.\n logger.info(f'Unexpected Exception: {e}\\nFailed to get '\n 'the job start timestamp. Retrying.')\n continue\n # Wait for the job to be started\n time.sleep(spot_utils.JOB_STARTED_STATUS_CHECK_GAP_SECONDS)\n return None","async def _job(self):\n await asyncio.sleep(self._timeout)\n await self._callback()","def wait_fluently(condition: Callable, timeout: TimeoutType, err_msg: str):\n if timeout is None:\n timeout = 0\n start_time = time.time()\n while True:\n res = condition()\n if res:\n return res\n if time.time() - start_time >= timeout:\n raise TimeoutException(err_msg)\n time.sleep(0.3)","def fusion_api_wait_for_task_to_complete(self, uri=None, api=None, headers=None, retries=5, sleep_time=5, param=''):\n task_attempts = 0\n for _ in range(0, retries):\n time.sleep(sleep_time)\n task_attempts += 1\n response = self.task.get(uri=uri, api=api, headers=headers, param=param)\n if response[\"percentComplete\"] == 100:\n break\n if task_attempts == retries:\n raise Exception(\n \"Task did not complete after %d tries.\" % retries)\n return response","def wait_until_done(self, job_id, config_id=1,\n wait_time=5, max_iters=50, init_wait_time=0):\n status = False\n i= 0\n time.sleep(init_wait_time)\n # Do until job finishes or max iters is reached.\n while status == False and i < max_iters:\n resp = self.check_status(job_id, config_id)\n logger.debug(\"Waiting for response \" + resp.content)\n job_status = json.loads(resp.content)['status']\n if job_status == 'done':\n logger.info(\"Previous, job done! \" + resp.content)\n status = True\n # If the job fails stop everything and raise exception.\n elif job_status == \"FAILED\":\n raise Exception(\n \"FATAL: Job {num} failed with a response of: {resp}\".format(\n num=job_id,\n resp=resp.content\n )\n )\n i += 1\n time.sleep(wait_time)\n # If we hit max iterations.\n if status == False:\n raise Exception(\n \"Task Load Timeout!\\nTry setting a longer wait time\"\n )\n # TODO: Maybe report some time stats once done.","def wait_until_job_completes(self):\n while True:\n jobflow = self.conn.describe_jobflow(self.jobid)\n if self.verbose_mode:\n print jobflow.state\n if (jobflow.state == 'COMPLETED' or jobflow.state == 'TERMINATED'\n or jobflow.state == 'FAILED'):\n break\n sleep(10)","async def wait_graceafully(aws, timeout=None):\n\n while True:\n done, pending = await asyncio.wait(aws, timeout=15)\n\n for t in done:\n if t.exception():\n print(\"exception:\", patch.task_get_name(t), t.exception())\n elif t.result():\n print(\"result:\", patch.task_get_name(t), t.result())\n\n if not pending:\n break\n\n for t in pending:\n t.cancel()\n\n aws = pending","def _poll_until_exception(self, fn, expected_exception, max_retries=20, retry_delay=3):\n\n for _ in range(max_retries):\n try:\n fn()\n if self.is_live:\n time.sleep(retry_delay)\n except expected_exception:\n return\n\n self.fail(\"expected exception {expected_exception} was not raised\")","def retry_wait_backoff(fn_check, fail_msg, max_wait=20):\n sleep_time = 0.1\n total_waited = 0.0\n while total_waited < max_wait:\n if fn_check():\n break\n log.info('{0}, retrying in {1:.2f}s'.format(fail_msg, sleep_time))\n total_waited += sleep_time\n time.sleep(sleep_time)\n sleep_time = min(sleep_time * 2, 5, max_wait - total_waited)\n else:\n raise TimeoutError('{0} after {1:.2f}s'.format(fail_msg, max_wait))","def retry_wait_backoff(fn_check, fail_msg, max_wait=20):\n sleep_time = 0.1\n total_waited = 0.0\n while total_waited < max_wait:\n if fn_check():\n break\n log.info('{0}, retrying in {1:.2f}s'.format(fail_msg, sleep_time))\n total_waited += sleep_time\n time.sleep(sleep_time)\n sleep_time = min(sleep_time * 2, 5, max_wait - total_waited)\n else:\n raise TimeoutError('{0} after {1:.2f}s'.format(fail_msg, max_wait))","def request_until_success(url, max_attempts=5, wait=5,\r\n fail_max=True):\r\n req = urllib.request.Request(url)\r\n success = False\r\n num_tries = 0\r\n while not success:\r\n try:\r\n num_tries += 1\r\n response = urllib.request.urlopen(req)\r\n success = response.getcode() == 200\r\n except urllib.request.HTTPError as e:\r\n logger.error('e')\r\n logger.error('Error url: {}'.format(e))\r\n if e.code == 500 and num_tries < max_attempts:\r\n logger.info('trying again soon')\r\n time.sleep(wait)\r\n else:\r\n logger.error(e.reason)\r\n raise e\r\n\r\n if not success:\r\n raise Error('Failed to make request')\r\n return json.loads(response.read().decode('utf-8'))","def WaitForJobCompletion(self, job_id, period=5, retries=-1):\n while retries != 0:\n job_result = self.GetJobStatus(job_id)\n\n if job_result and job_result[\"status\"] == JOB_STATUS_SUCCESS:\n return True\n elif not job_result or job_result[\"status\"] in JOB_STATUS_FINALIZED:\n return False\n\n if period:\n time.sleep(period)\n\n if retries > 0:\n retries -= 1\n\n return False","def retry(self):\n # XXX: check whether it is possible to distingish \n # between the error conditions and set meaningfull exitcode\n return False","def wait_until(condition, delay, max_attempts):\n attempt = 0\n while not condition() and attempt < max_attempts:\n attempt += 1\n time.sleep(delay)\n\n if attempt >= max_attempts:\n raise Exception(\"Condition is still False after {} attempts.\".format(max_attempts))","def test_retry_failed_jobs(sleep, client, job_retry_on_query):\n\n retry_notfound = google.api_core.retry.Retry(\n predicate=google.api_core.retry.if_exception_type(\n google.api_core.exceptions.NotFound\n )\n )\n retry_badrequest = google.api_core.retry.Retry(\n predicate=google.api_core.retry.if_exception_type(\n google.api_core.exceptions.BadRequest\n )\n )\n\n if job_retry_on_query is None:\n reason = \"rateLimitExceeded\"\n else:\n reason = \"notFound\"\n\n err = dict(reason=reason)\n responses = [\n dict(status=dict(state=\"DONE\", errors=[err], errorResult=err)),\n dict(status=dict(state=\"DONE\", errors=[err], errorResult=err)),\n dict(status=dict(state=\"DONE\", errors=[err], errorResult=err)),\n dict(status=dict(state=\"DONE\")),\n dict(rows=[{\"f\": [{\"v\": \"1\"}]}], totalRows=\"1\"),\n ]\n\n def api_request(method, path, query_params=None, data=None, **kw):\n response = responses.pop(0)\n if data:\n response[\"jobReference\"] = data[\"jobReference\"]\n else:\n response[\"jobReference\"] = dict(\n jobId=path.split(\"/\")[-1], projectId=\"PROJECT\"\n )\n return response\n\n conn = client._connection = make_connection()\n conn.api_request.side_effect = api_request\n\n if job_retry_on_query == \"Query\":\n job_retry = dict(job_retry=retry_notfound)\n elif job_retry_on_query == \"Both\":\n # This will be overridden in `result`\n job_retry = dict(job_retry=retry_badrequest)\n else:\n job_retry = {}\n job = client.query(\"select 1\", **job_retry)\n\n orig_job_id = job.job_id\n job_retry = (\n dict(job_retry=retry_notfound)\n if job_retry_on_query in (\"Result\", \"Both\")\n else {}\n )\n result = job.result(**job_retry)\n assert result.total_rows == 1\n assert not responses # We made all the calls we expected to.\n\n # The job adjusts it's job id based on the id of the last attempt.\n assert job.job_id != orig_job_id\n assert job.job_id == conn.mock_calls[3][2][\"data\"][\"jobReference\"][\"jobId\"]\n\n # We had to sleep three times\n assert len(sleep.mock_calls) == 3\n\n # Sleeps are random, however they're more than 0\n assert min(c[1][0] for c in sleep.mock_calls) > 0\n\n # They're at most 2 * (multiplier**(number of sleeps - 1)) * initial\n # The default multiplier is 2\n assert max(c[1][0] for c in sleep.mock_calls) <= 8\n\n # We can ask for the result again:\n responses = [\n dict(rows=[{\"f\": [{\"v\": \"1\"}]}], totalRows=\"1\"),\n ]\n orig_job_id = job.job_id\n result = job.result()\n assert result.total_rows == 1\n assert not responses # We made all the calls we expected to.\n\n # We wouldn't (and didn't) fail, because we're dealing with a successful job.\n # So the job id hasn't changed.\n assert job.job_id == orig_job_id","def _poll_until_no_exception(self, fn, expected_exception, max_retries=20, retry_delay=3):\n\n for i in range(max_retries):\n try:\n return fn()\n except expected_exception:\n if i == max_retries - 1:\n raise\n if self.is_live:\n time.sleep(retry_delay)","def _wait_for_snapshot(k8s_ctx: str, spec_file: pathlib.Path, attempts: int = 30, secs2wait: int = 20, dry_run: bool = False) -> None:\n for counter in range(attempts):\n if _snapshot_ready(k8s_ctx, spec_file, dry_run):\n break\n time.sleep(secs2wait)\n else:\n raise TimeoutError(f'{spec_file} timed out')","def test_job_failure(app):\n with worker(app):\n state = wait_for_results(app, length=100, sleep=0.2, maxwait=4)\n\n # Tasks have been delivered and executed.\n assert set(r.return_value for r in all_results(app)) == set(range(100))\n assert len(state.queue.messages) == 0\n\n # Consumer groups behaved properly.\n assert state.queue.info.groups == 1\n assert state.queue.groups[0].pending == 0\n\n # Nothing in the DLQ.\n assert len(state.dead.messages) == 0\n\n # Any scheduled tasks completed and removed.\n assert len(state.schedule) == 0","async def test_wait_for_activity_timeout(aiopg_connector):\n pg_app = app.App(connector=aiopg_connector)\n worker = worker_module.Worker(app=pg_app, timeout=2)\n worker.notify_event = asyncio.Event()\n task = asyncio.ensure_future(worker.single_worker(worker_id=0))\n try:\n await asyncio.sleep(0.2) # should be enough so that we're waiting\n\n worker.stop_requested = True\n\n with pytest.raises(asyncio.TimeoutError):\n await asyncio.wait_for(task, timeout=0.2)\n finally:\n worker.notify_event.set()","def wait_on_job(self, delay=10):\n while self.isJobRunning() == True:\n time.sleep(delay)\n return self.ofile_exists()","def wait_until_not_raised(condition, delay, max_attempts):\n def wrapped_condition():\n try:\n result = condition()\n except:\n return False, None\n\n return True, result\n\n attempt = 0\n while attempt < (max_attempts-1):\n attempt += 1\n success, result = wrapped_condition()\n if success:\n return result\n\n time.sleep(delay)\n\n # last attempt, let the exception raise\n return condition()","def wait_until_done(self, timeout=10.0):\r\n cfunc = lib_importer.windll.DAQmxWaitUntilTaskDone\r\n if cfunc.argtypes is None:\r\n with cfunc.arglock:\r\n if cfunc.argtypes is None:\r\n cfunc.argtypes = [lib_importer.task_handle, ctypes.c_double]\r\n\r\n error_code = cfunc(self._handle, timeout)\r\n check_for_error(error_code)","def retry(times):\n return repeat_with_success_at_least(times, 1)","async def handle_launch_timeout(self):\n await asyncio.sleep(poll_interval)\n time_interval = RemoteProvisionerBase.get_time_diff(self.start_time)\n\n if time_interval > self.launch_timeout:\n reason = f\"Waited too long ({self.launch_timeout}s) to get connection file\"\n timeout_message = f\"KernelID: '{self.kernel_id}' launch timeout due to: {reason}\"\n await self.kill()\n self.log_and_raise(TimeoutError(timeout_message))","def wait_for_url(url: str, timeout=120) -> None:\n for _ in range(timeout):\n try:\n requests.get(url)\n return\n except requests.exceptions.ConnectionError:\n sleep(1)\n raise TimeoutError(f\"No response from APP in {timeout} seconds\")","def check_completion(self):\n\n time.sleep(3)\n while self.status == 0:\n pass","def _check_job_completeness(self, jobs):\n for job in concurrent.futures.as_completed(jobs):\n if job.exception():\n raise (job.exception())","def wait(self):\n response = self._client.api.operations[self.id].wait.get()\n\n try:\n if response.json()['metadata']['status'] == 'Failure':\n raise exceptions.LXDAPIException(response)\n except KeyError:\n # Support for legacy LXD\n pass","def jobHealthy(self, count):\n job = self.tester.submission_result.job\n for idx in range(count - 1):\n if (job.health == 'healthy'):\n return True\n print(\"health check fail : %d\" % idx )\n time.sleep(1)\n job.refresh()\n self.assertEqual('healthy', job.health)\n return False","def retry_failed_downloader_jobs() -> None:\n failed_jobs = (\n DownloaderJob.failed_objects.filter(created_at__gt=utils.JOB_CREATED_AT_CUTOFF)\n .order_by(\"created_at\")\n .prefetch_related(\"original_files__samples\")\n )\n\n paginator = Paginator(failed_jobs, utils.PAGE_SIZE, \"created_at\")\n page = paginator.page()\n page_count = 0\n\n if len(page.object_list) <= 0:\n # No failed jobs, nothing to do!\n return\n\n queue_capacity = get_capacity_for_downloader_jobs()\n\n if queue_capacity <= 0:\n logger.info(\n \"Not handling failed (explicitly-marked-as-failure) downloader jobs \"\n \"because there is no capacity for them.\"\n )\n\n while queue_capacity > 0:\n logger.info(\n \"Handling page %d of failed (explicitly-marked-as-failure) downloader jobs!\", page_count\n )\n\n handle_downloader_jobs(page.object_list)\n\n if page.has_next():\n page = paginator.page(page.next_page_number())\n page_count = page_count + 1\n queue_capacity = get_capacity_for_downloader_jobs()\n else:\n break","def wait_for_success(chronos_url, interval=30):\n last_chance = 0\n print('Waiting for jobs...')\n while True:\n time.sleep(interval)\n job_status = None\n while not job_status:\n try:\n job_status = get_status(chronos_url)\n except ValueError:\n print(\"Invalid JSON received, retrying.\")\n print_str = time.strftime(\"%H:%M:%S\")\n all_str = \" - all: \" + ', '.join(sorted(job_status['all']))\n fresh_str = \" - fresh: \" + ', '.join(sorted(job_status['fresh']))\n fail_str = \" - failures: \" + ', '.join(sorted(job_status['failure']))\n run_str = \" - running: \" + ', '.join(sorted(job_status['running']))\n print(print_str + fail_str + run_str)\n # no running, failure, or pending jobs, head to next step\n if (len(job_status['running']) == 0 and len(job_status['fresh']) == 0 and\n len(job_status['failure']) == 0):\n print('Ready for the next Phase!')\n return True\n elif len(job_status['running']) == 0:\n # no running jobs, but some pending, give one last chance\n if last_chance < 10 * 60 / interval:\n print('No jobs running, but not all finished, checking...')\n last_chance = last_chance + 1\n continue\n else:\n print('Continuing: Some jobs are stuck (possibly because of failures)')\n return True\n # there are jobs still running\n else:\n last_chance = 0","def test_run_max_retries():\n responses = [httpretty.Response(body=\"Internal Server Error\", status=500),\n httpretty.Response(body=\"Internal Server Error\", status=500),\n httpretty.Response(body=\"Internal Server Error\", status=500)]\n httpretty.register_uri(httpretty.GET, URL, responses=responses)\n with mock.patch('httsleep.main.sleep'):\n httsleep = HttSleep(URL, {'status_code': 200}, max_retries=2)\n with pytest.raises(StopIteration):\n httsleep.run()","def wait_for_job(job) -> bool:\n job.refresh_from_db()\n is_done = False\n\n while not is_done:\n if job.end_time is None and job.success is None:\n print(f\"Polling {type(job).__name__}s. Currently waiting for job id: {job.id}\")\n sleep(20)\n job.refresh_from_db()\n elif job.retried and job.retried_job:\n job = job.retried_job\n elif job.success:\n return True\n else:\n print(f\"{type(job).__name__} {job.id} failed!\")\n return False\n\n return False","def retry(self, times):\n return Retry((requests.ConnectionError, requests.Timeout), times)","def wait_for_reply(timeout=3):\n i = 0\n reply = Networking.get_instance().client.get_server_reply()\n while not reply:\n reply = Networking.get_instance().client.get_server_reply()\n time.sleep(1)\n i += 1\n if i > timeout:\n raise TimeoutError\n return reply","def test_submit_jobs(self):\r\n\r\n submit_jobs([self.command], prefix=\"test_job\")\r\n # Try and wait ten times, could be made nicer with alarm()\r\n for i in range(10):\r\n if exists(self.tmp_result_file):\r\n observed_text = \"\".join(list(open(self.tmp_result_file)))\r\n self.assertEqual(observed_text, \"hello\\n\")\r\n return\r\n else:\r\n sleep(10)\r\n # if we get here we failed\r\n self.fail(\"The test job apparently never finished.\\n\"\r\n + \"check the jobs error log and check the queue status\\n.\")","def wait_to_complete(self, timeout: float = 5) -> None:\n if self.proc.poll() is not None: # type: ignore\n return\n\n start_time = time.time()\n\n while start_time + timeout > time.time() and self.proc.poll() is None: # type: ignore\n time.sleep(0.001)\n\n if self.proc.poll() is None: # type: ignore\n self.terminate(force=True)\n self.wait()\n self.exitstatus = \"Terminated!\" # type: ignore","def wait(self, timeout=0):\n if timeout:\n self._finished.wait(timeout=timeout)\n else:\n self._finished.wait()","def retry(self):\n return False","def wait_for(*args, **kwargs):\n if \"timeout_seconds\" not in kwargs:\n kwargs[\"timeout_seconds\"] = constants.ux.MAX_USER_WAIT_SECONDS\n return waiting.wait(*args, **kwargs)","def retry_until_timeout(\n exception: Type[Exception],\n item: Callable[..., Any],\n timeout: int,\n args: List[Any] = None,\n kwargs: Mapping[str, Any] = None,\n interval: float = 0.05,\n raise_on_timeout: bool = True,\n) -> Any:\n timeout_info = TimeoutExceptionInfo()\n end_time = timeout_info.started + timeout\n while True:\n try:\n res = item(*args or tuple(), **kwargs or {})\n except exception as exc:\n if time.time() < end_time:\n # no timeout yet\n time.sleep(interval)\n else:\n if raise_on_timeout:\n raise TimeoutException(\n \"Timeout waiting for {0}\"\n \" to return without {1}. {2}. {3}\".format(\n item.__name__,\n exception.__name__,\n timeout_info.msg(),\n str(exc),\n )\n )\n else:\n return None\n else:\n return res","def wait(self, timeout=None):\n assert False, \"Deriving class must implement\"","async def job_wait(self, uid):\n self._require_running()\n await self._get_job(uid).wait()","def wait(self):\r\n self.jobs.join()","def _retry_request(self, request, timeout=2, attempts=3):\n import googleapiclient\n\n try:\n return request.execute()\n except BrokenPipeError as ex:\n if attempts > 0:\n time.sleep(timeout)\n return self._retry_request(request, timeout * 2, attempts - 1)\n raise ex\n except googleapiclient.errors.HttpError as ex:\n log_verbose_traceback(ex)\n raise ex\n except Exception as ex:\n log_verbose_traceback(ex)\n raise ex","def until_true(condition, timeout, error_msg):\n timeout = timestr_to_secs(timeout)\n max_wait = time.time() + timeout\n while True:\n if condition():\n break\n if time.time() > max_wait:\n raise AssertionError(error_msg)\n time.sleep(0.1)","def WaitForExit(self, timeout: int = 1200) -> Dict[str, Any]:\n raise NotImplementedError()","def get_result(self, execution_id, num_retries=30, interval=1, verbose=False): # pylint: disable=too-many-locals\n if verbose:\n print(f\"Waiting for results. [Job Arn: {execution_id}]\")\n\n original_sigint_handler = signal.getsignal(signal.SIGINT)\n\n def _handle_sigint_during_get_result(*_): # pragma: no cover\n raise Exception(f\"Interrupted. The Arn of your submitted job is {execution_id}.\")\n\n def _calculate_measurement_probs(measurements):\n \"\"\"\n Calculate the measurement probabilities .\n\n Calculate the measurement probabilities based on the list of measurements for a job sent to a SV1 Braket\n simulator.\n\n Args:\n measurements (list): list of measurements\n\n Returns:\n measurementsProbabilities (dict): The measurements with their probabilities\n \"\"\"\n total_mes = len(measurements)\n unique_mes = [list(x) for x in {tuple(x) for x in measurements}]\n total_unique_mes = len(unique_mes)\n len_qubits = len(unique_mes[0])\n measurements_probabilities = {}\n for i in range(total_unique_mes):\n strqubits = ''\n for qubit_idx in range(len_qubits):\n strqubits += str(unique_mes[i][qubit_idx])\n prob = measurements.count(unique_mes[i]) / total_mes\n measurements_probabilities[strqubits] = prob\n\n return measurements_probabilities\n\n # The region_name is obtained from the task_arn itself\n region_name = re.split(':', execution_id)[3]\n client_braket = boto3.client(\n 'braket',\n region_name=region_name,\n aws_access_key_id=self._credentials['AWS_ACCESS_KEY_ID'],\n aws_secret_access_key=self._credentials['AWS_SECRET_KEY'],\n )\n\n try:\n signal.signal(signal.SIGINT, _handle_sigint_during_get_result)\n\n for _ in range(num_retries):\n quantum_task = client_braket.get_quantum_task(quantumTaskArn=execution_id)\n status = quantum_task['status']\n bucket = quantum_task['outputS3Bucket']\n directory = quantum_task['outputS3Directory']\n resultsojectname = f\"{directory}/results.json\"\n if status == 'COMPLETED':\n # Get the device type to obtian the correct measurement\n # structure\n devicetype_used = client_braket.get_device(deviceArn=quantum_task['deviceArn'])['deviceType']\n # Get the results from S3\n client_s3 = boto3.client(\n 's3',\n aws_access_key_id=self._credentials['AWS_ACCESS_KEY_ID'],\n aws_secret_access_key=self._credentials['AWS_SECRET_KEY'],\n )\n s3result = client_s3.get_object(Bucket=bucket, Key=resultsojectname)\n if verbose:\n print(f\"Results obtained. [Status: {status}]\")\n result_content = json.loads(s3result['Body'].read())\n\n if devicetype_used == 'QPU':\n return result_content['measurementProbabilities']\n if devicetype_used == 'SIMULATOR':\n return _calculate_measurement_probs(result_content['measurements'])\n if status == 'FAILED':\n raise Exception(\n f'Error while running the code: {status}. '\n f'The failure reason was: {quantum_task[\"failureReason\"]}.'\n )\n if status == 'CANCELLING':\n raise Exception(f\"The job received a CANCEL operation: {status}.\")\n time.sleep(interval)\n # NOTE: Be aware that AWS is billing if a lot of API calls are\n # executed, therefore the num_repetitions is set to a small\n # number by default.\n # For QPU devices the job is always queued and there are some\n # working hours available.\n # In addition the results and state is written in the\n # results.json file in the S3 Bucket and does not depend on the\n # status of the device\n\n finally:\n if original_sigint_handler is not None:\n signal.signal(signal.SIGINT, original_sigint_handler)\n\n raise RequestTimeoutError(\n f\"Timeout. The Arn of your submitted job is {execution_id} and the status of the job is {status}.\"\n )","def test_timeout(self):\n start = time.time()\n dr = EventualResult(Deferred(), None)\n self.assertRaises(TimeoutError, dr.wait, timeout=0.03)\n # be a little lenient for slow computers:\n self.assertTrue(abs(time.time() - start) < 0.05)","def wait_until(self, check, timeout=None):\n self._wait_in_process_loop(lambda: (check(),None),timeout=timeout)","def test_wait_tx_settled_timeout(self, is_transaction_settled_mock):\n with pytest.raises(TimeoutError):\n wait_tx_settled(\"some\", \"some\", timeout=0.5)","def retry_hung_downloader_jobs() -> None:\n potentially_hung_jobs = (\n DownloaderJob.hung_objects.filter(created_at__gt=utils.JOB_CREATED_AT_CUTOFF)\n .order_by(\"created_at\")\n .prefetch_related(\"original_files__samples\")\n )\n paginator = Paginator(potentially_hung_jobs, utils.PAGE_SIZE, \"created_at\")\n database_page = paginator.page()\n database_page_count = 0\n\n if len(database_page.object_list) <= 0:\n # No failed jobs, nothing to do!\n return\n\n queue_capacity = get_capacity_for_downloader_jobs()\n\n if queue_capacity <= 0:\n logger.info(\n \"Not handling hung (started-but-never-finished) downloader jobs \"\n \"because there is no capacity for them.\"\n )\n while queue_capacity > 0:\n hung_jobs = utils.check_hung_jobs(database_page.object_list)\n\n if hung_jobs:\n logger.info(\n \"Handling page %d of hung (started-but-never-finished) downloader jobs!\",\n database_page_count,\n jobs_count=len(hung_jobs),\n )\n handle_downloader_jobs(hung_jobs)\n\n if database_page.has_next():\n database_page = paginator.page(database_page.next_page_number())\n database_page_count += 1\n queue_capacity = get_capacity_for_downloader_jobs()\n else:\n break","def _wait_for(self, check_func, desc, result=False, timeout=200):\r\n if result:\r\n return Promise(check_func, desc, timeout=timeout).fulfill()\r\n else:\r\n return EmptyPromise(check_func, desc, timeout=timeout).fulfill()","def __await_helms_installation(self, job_id, expected_services_count):\n end_waiting = datetime.now().timestamp() + self.TIMEOUT_MIN * 60 * 1000\n curr_status = self.helm_results.get(job_id)\n while datetime.now().timestamp() <= end_waiting:\n curr_status = self.helm_results.get(job_id, {\"services\": []})\n if expected_services_count != len(curr_status[\"services\"]):\n time.sleep(1.)\n else:\n self.helm_results.pop(job_id)\n return curr_status\n self.helm_results.pop(job_id)\n return curr_status","def retry(callback, retries, sleep=0.5, catch=Exception, *args, **kwargs):\n r = 0\n while r < retries:\n r += 1\n try:\n return callback(*args, **kwargs)\n except catch as c:\n if r == retries:\n raise c\n else:\n time.sleep(r * sleep)","def _selenium_wait_for(fn):\n start_time = time.time()\n while True:\n try:\n return fn()\n except (AssertionError, WebDriverException) as e:\n if time.time() - start_time > 10:\n raise e\n time.sleep(0.5)","def wait_jobs_completed():\n\n logging.info(\"checking jobs\")\n time.sleep(30)\n while True:\n running_jobs = []\n for job in bq.list_jobs(state_filter='RUNNING', all_users=True):\n running_jobs.append(job)\n logging.info(\"running jobs {}\".format(len(running_jobs)))\n if not running_jobs:\n break\n time.sleep(30)","def robust_wait_for_clickable_element(driver, delay, selector):\n clickable = False\n attempts = 1\n try:\n driver.find_element_by_xpath(selector)\n except Exception as e:\n print(\" Selector not found: {}\".format(selector))\n else:\n while not clickable:\n try:\n # wait for job post link to load\n wait_for_clickable_element(driver, delay, selector)\n except Exception as e:\n print(\" {}\".format(e))\n attempts += 1\n if attempts % 100 == 0:\n driver.refresh()\n if attempts > 10**3: \n print(\" \\nrobust_wait_for_clickable_element failed \" \\\n \"after too many attempts\\n\")\n break\n pass\n else:\n clickable = True","def wait_for_container():\n for i in xrange(30):\n print(\"Waiting for service to come up\")\n try:\n requests.get(URL).raise_for_status()\n return True\n except Exception as e:\n print e\n sleep(1)\n\n return False","def track_job_to_completion(ip_address, headers, job_id):\n job_status_map = {\n \"2020\": \"Scheduled\",\n \"2030\": \"Queued\",\n \"2040\": \"Starting\",\n \"2050\": \"Running\",\n \"2060\": \"Completed\",\n \"2070\": \"Failed\",\n \"2090\": \"Warning\",\n \"2080\": \"New\",\n \"2100\": \"Aborted\",\n \"2101\": \"Paused\",\n \"2102\": \"Stopped\",\n \"2103\": \"Canceled\"\n }\n\n max_retries = 20\n sleep_interval = 60\n failed_job_status = [2070, 2090, 2100, 2101, 2102, 2103]\n job_url = 'https://%s/api/JobService/Jobs(%s)' % (ip_address, job_id)\n loop_ctr = 0\n job_incomplete = True\n print(\"Polling %s to completion ...\" % job_id)\n while loop_ctr < max_retries:\n loop_ctr += 1\n time.sleep(sleep_interval)\n job_resp = requests.get(job_url, headers=headers, verify=False)\n if job_resp.status_code == 200:\n job_status = str((job_resp.json())['LastRunStatus']['Id'])\n print(\"Iteration %s: Status of %s is %s\" % (loop_ctr, job_id, job_status_map[job_status]))\n if int(job_status) == 2060:\n job_incomplete = False\n print(\"Completed updating firmware successfully ... Exiting\")\n break\n elif int(job_status) in failed_job_status:\n job_incomplete = False\n print(\"Update job failed ... \")\n job_hist_url = str(job_url) + \"/ExecutionHistories\"\n job_hist_resp = requests.get(job_hist_url, headers=headers, verify=False)\n if job_hist_resp.status_code == 200:\n job_history_id = str((job_hist_resp.json())['value'][0]['Id'])\n job_hist_det_url = str(job_hist_url) + \"(\" + job_history_id + \")/ExecutionHistoryDetails\"\n job_hist_det_resp = requests.get(job_hist_det_url,\n headers=headers,\n verify=False)\n if job_hist_det_resp.status_code == 200:\n print(job_hist_det_resp.text)\n else:\n print(\"Unable to parse job execution history .. Exiting\")\n break\n else:\n print(\"Unable to poll status of %s - Iteration %s \" % (job_id, loop_ctr))\n if job_incomplete:\n print(\"Job %s incomplete after polling %s times...Check status\" % (job_id, max_retries))","def test_retry_run(self):\n pass","def test_later_failure_result(self):\n d = Deferred()\n dr = EventualResult(d, None)\n result_list = []\n done = append_in_thread(result_list, dr.wait, 100)\n time.sleep(0.1)\n d.errback(RuntimeError())\n done.wait(100)\n self.assertEqual(\n (result_list[0], result_list[1].__class__), (False, RuntimeError))","def aws_cmd ( cmd, args, num_retries = 20 ) :\n while True :\n try :\n return cmd( *args )\n except :\n num_retries -= 1\n if num_retries < 1 :\n raise\n time.sleep( 1 )","def wait_until_complete(self):\n self._log.debug(\"waiting for upload job %s to complete\", self._job_id)\n xpath = ManoProject.prefix_project(\"D,/rw-image-mgmt:upload-jobs/\" +\n \"rw-image-mgmt:job[rw-image-mgmt:id={}]\".\n format(quoted_key(str(self._job_id))),\n project=self._project,\n log=self._log)\n\n while True:\n query_iter = yield from self._dts.query_read(xpath)\n job_status_msg = None\n for fut_resp in query_iter:\n job_status_msg = (yield from fut_resp).result\n break\n\n if job_status_msg is None:\n raise UploadJobError(\"did not get a status response for job_id: %s\",\n self._job_id)\n\n if job_status_msg.status == \"COMPLETED\":\n msg = \"upload job %s completed successfully\" % self._job_id\n self._log.debug(msg)\n return\n\n elif job_status_msg.status == \"FAILED\":\n msg = \"upload job %s as not successful: %s\" % (self._job_id, job_status_msg.status)\n self._log.error(msg)\n raise UploadJobFailed(msg)\n\n elif job_status_msg.status == \"CANCELLED\":\n msg = \"upload job %s was cancelled\" % self._job_id\n self._log.error(msg)\n raise UploadJobCancelled(msg)\n\n yield from asyncio.sleep(.5, loop=self._loop)","def timeout_check_call(timeout, *args, **kwargs):\n resolution = 0.1\n pro = subprocess.Popen(*args, **kwargs)\n starttime = time.time()\n while pro.poll() is None:\n time.sleep(resolution)\n if time.time() - starttime > timeout:\n to = time.time() - starttime\n pro.terminate()\n time.sleep(resolution)\n if pro.poll() is None:\n pro.kill()\n raise TimeoutError('Timed out after {0:.1f} seconds'.format(to))\n if pro.returncode:\n raise subprocess.CalledProcessError(\n pro.returncode, kwargs['args'] if 'args' in kwargs else args[0])\n return 0","def wait(self, ms=None):\r\n util.raiseNotDefined()","def until_timeout(timeout, value=None):\n\n start = time.time()\n\n while True:\n if time.time() - start >= timeout:\n raise Exception(\"timed out before success!\")\n yield value","def wait_job_loading(self, elt, timeout=10):\n time_slept = 0\n wait = True\n while wait:\n time.sleep(1)\n time_slept += 1\n company_name = elt.text.splitlines()[0]\n try:\n employer_info_txt = self.driver.find_element_by_class_name(\n \"empInfo\").text.splitlines()[0]\n if (employer_info_txt.splitlines()[0]\n == company_name):\n wait = False\n except NoSuchElementException as err:\n logger.error(\"Element not found \", err)\n if time_slept > timeout:\n raise TimeoutError(\n \"job offer of {} was not loaded in 10 seconds\".format(\n company_name))","def _wait_on_condition(self, timeout):\n self.__condition.wait(timeout)","def wait_or_fail(self, evt, timeout=2.0, msg=''):\n res = evt.wait(timeout)\n if not res:\n self.fail(msg)","def retry(nattempts, exception=None):\n \n def tryIt(func):\n def wrapper(*args, **kwargs):\n attempts = 0\n while attempts < nattempts - 1:\n try:\n return func(*args, **kwargs)\n except (exception if exception is not None else Exception):\n attempts += 1\n return func(*args, **kwargs)\n return wrapper\n return tryIt","def test_disable_retry_failed_jobs(sleep, client, job_retry_on_query):\n err = dict(reason=\"rateLimitExceeded\")\n responses = [dict(status=dict(state=\"DONE\", errors=[err], errorResult=err))] * 3\n\n def api_request(method, path, query_params=None, data=None, **kw):\n response = responses.pop(0)\n response[\"jobReference\"] = data[\"jobReference\"]\n return response\n\n conn = client._connection = make_connection()\n conn.api_request.side_effect = api_request\n\n if job_retry_on_query == \"Query\":\n job_retry = dict(job_retry=None)\n else:\n job_retry = {}\n job = client.query(\"select 1\", **job_retry)\n\n orig_job_id = job.job_id\n job_retry = dict(job_retry=None) if job_retry_on_query == \"Result\" else {}\n with pytest.raises(google.api_core.exceptions.Forbidden):\n job.result(**job_retry)\n\n assert job.job_id == orig_job_id\n assert len(sleep.mock_calls) == 0","def do_wait(self):\n pass","def retry_on_exception(func, max_attempts=5, ignored_exceptions=(StaleElementReferenceException, InvalidElementStateException)):\r\n attempt = 0\r\n while attempt < max_attempts:\r\n try:\r\n return func()\r\n except ignored_exceptions:\r\n world.wait(1)\r\n attempt += 1\r\n\r\n assert_true(attempt < max_attempts, 'Ran out of attempts to execute {}'.format(func))","def test_handle_multiple_responses_throw_timeouterror():\n # GIVEN\n bboxes = [8.67066,49.41423,8.68177,49.4204]\n time = \"2010-01-01/2011-01-01/P1Y\"\n keys = [\"building\"]\n values = [\"\"]\n\n # WHEN\n client = ohsome.OhsomeClientParallel()\n response = client.elements.count.post(bboxes=bboxes, time=time, keys=keys, values=values, timeout=2)\n del client","def raise_timeout(self, *args, **kwargs):\n\n self.log.error(\"Task timeout encountered.\")\n raise TimeoutError","def wait(self, timeout):\n if not hasattr(self, '_value'):\n try:\n value = self.broker.pop_result(self, timeout=timeout)\n except KeyError:\n return False\n except TaskExpired as err:\n value = err\n self._value = value\n return hasattr(self, '_value')","def test_default_maximum_conflict(self):\n\n self.set_options(timeouts=True, timeout_maximum=1, timeout_default=10)\n task = self.create_task(self.context())\n with self.assertRaises(ErrorWhileTesting):\n task.execute()","def sleep(self, timeout):\n try:\n self._wait_in_process_loop(lambda: (False,None),timeout=timeout)\n except threadprop.TimeoutThreadError:\n pass","def _retry(*, task, signature_kwargs, retries):\n if retries < MAX_RETRIES:\n step = task.signature(**signature_kwargs)\n queue = step.options.get(\"queue\", task.queue)\n step.options[\"queue\"] = f\"{queue}-delay\"\n step.kwargs[\"retries\"] = retries + 1\n on_commit(step.apply_async)\n else:\n raise MaxRetriesExceededError","def retry(retries, task_f, check_f=bool, wait_f=None):\n for attempt in range(retries):\n ret = task_f()\n if check_f(ret):\n return ret\n if attempt < retries - 1 and wait_f is not None:\n wait_f(attempt)\n raise RetryException(\"Giving up after {} failed attempt(s)\".format(retries))"],"string":"[\n \"async def _wait_retry(self) -> None:\\n # Sleep 2^tries + 0…tries*3 seconds between retries\\n self.retry_task = asyncio.create_task(\\n asyncio.sleep(2 ** min(9, self.tries) + random.randint(0, self.tries * 3))\\n )\\n await self.retry_task\\n self.retry_task = None\",\n \"def __wait_for_job_success(self, name, jobname, delay = 30, tries = 36, loop_sleep = 5):\\n start = time.time()\\n print(\\\"Waiting for %s seconds before starting polling.\\\" % delay)\\n time.sleep(delay)\\n try:\\n uuid = run(\\\"drush psite-uuid %s --nocache\\\" % name, pty=True, combine_stderr=True)\\n for loop in range(1, tries+1):\\n end = time.time()\\n print(\\\"\\\\n\\\" + time.strftime(\\\"%d/%m/%Y %H:%M:%S\\\"))\\n print(\\\"Running psite-jobs for the %s time, it has been %d seconds so far.\\\" % (loop, end - start))\\n # the below grep command requires terminal wider than 120 columns:\\n job_line = run(\\\"drush psite-jobs %s | grep '%s' || :\\\" % (uuid, jobname), \\n pty=True, combine_stderr=True)\\n m = re.search('SUCCESS', job_line)\\n if m != None:\\n end = time.time()\\n print(\\\"We waited %d seconds and then needed %d loops, with %d second wait. Total elapsed time: %d seconds.\\\"\\n % (delay, loop, loop_sleep, end - start))\\n return\\n time.sleep(loop_sleep)\\n\\n except SystemExit as e:\\n raise Exception(\\\"Error while waiting for job to finish.Err: %s\\\" % str(e))\\n\\n end = time.time()\\n raise Exception(\\\"Site create didn't finish in time. Total elapsed time: %d seconds, max time %d seconds (%d + %d x %d).\\\"\\n % (end - start, tries * loop_sleep + delay, delay, tries, loop_sleep))\",\n \"def wait_for_completion(self, timeout=10):\\n cur_status = self.runtime_status()\\n while cur_status not in ['FAILED', 'KILLED', 'FINISHED']:\\n time.sleep(0.2)\\n timeout -= 0.2\\n cur_status = self.runtime_status()\\n if timeout < 0:\\n break\\n\\n return timeout > 0\",\n \"def wait_for_job(job):\\n if job.state != 'RUNNING':\\n job.begin()\\n retry_count = 1000\\n while retry_count > 0 and job.state != 'DONE':\\n retry_count -= 1\\n time.sleep(1)\\n job.reload()\\n assert not job.errors, job.errors\\n return job\",\n \"def _wait_for_completion(conn, promise, wait_timeout, msg):\\n if not promise:\\n return\\n wait_timeout = time.time() + wait_timeout\\n while wait_timeout > time.time():\\n time.sleep(5)\\n operation_result = conn.get_request(\\n request_id=promise[\\\"requestId\\\"], status=True\\n )\\n\\n if operation_result[\\\"metadata\\\"][\\\"status\\\"] == \\\"DONE\\\":\\n return\\n elif operation_result[\\\"metadata\\\"][\\\"status\\\"] == \\\"FAILED\\\":\\n raise Exception(\\n \\\"Request: {}, requestId: {} failed to complete:\\\\n{}\\\".format(\\n msg,\\n str(promise[\\\"requestId\\\"]),\\n operation_result[\\\"metadata\\\"][\\\"message\\\"],\\n )\\n )\\n\\n raise Exception(\\n 'Timed out waiting for asynchronous operation {} \\\"{}\\\" to complete.'.format(\\n msg, str(promise[\\\"requestId\\\"])\\n )\\n )\",\n \"def wait(self, msecs = sys.maxint):\\n\\t\\tcall_sdk_function('PrlJob_Wait', self.handle, msecs)\\n\\t\\terr_obj = None\\n\\t\\ttry:\\n\\t\\t\\terr_obj = self.get_error()\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\t\\tsdk_check_result(self.get_ret_code(), err_obj)\\n\\t\\treturn self.get_result()\",\n \"def _retry_finish(self, finish_job_params, success):\\n if success:\\n if (\\n \\\"job_output\\\" not in finish_job_params\\n or finish_job_params[\\\"job_output\\\"] is None\\n ):\\n finish_job_params[\\\"job_output\\\"] = {}\\n\\n try:\\n self.ee2.finish_job(finish_job_params)\\n except Exception:\\n _sleep(30)\\n self.ee2.finish_job(finish_job_params)\",\n \"def timeout(n):\\n time.sleep(int(n))\\n return 'ok', 200\",\n \"def wait_for(func, expected_exceptions=(), retries=60):\\n\\n retries = int(retries)\\n for retry in range(1, retries + 1):\\n try:\\n return_value = func()\\n if return_value:\\n break\\n\\n except expected_exceptions:\\n if retry == retries:\\n raise\\n else:\\n pass\\n\\n time.sleep(1)\\n\\n return return_value\",\n \"def _wait_for_job_complete():\\n retries = kwargs['retries']\\n try:\\n kwargs['retries'] = retries + 1\\n if not kwargs['wait_for_job_called']:\\n is_complete, result, rc, status, task = (\\n self._is_job_finished(job_id))\\n if is_complete is True:\\n kwargs['wait_for_job_called'] = True\\n kwargs['rc'], kwargs['status'] = rc, status\\n kwargs['result'], kwargs['task'] = result, task\\n else:\\n kwargs['status'], kwargs['task'] = status, task\\n except Exception as error:\\n exception_message = 'Issue encountered waiting for job.'\\n LOG.exception(exception_message)\\n raise exception.VolumeBackendAPIException(\\n data=exception_message) from error\\n\\n return kwargs\",\n \"def wait_for_job(self, value):\\n logger.info('Waiting for job %s' % self.job_name)\\n\\n if self.provider_options.dry_run == True:\\n logger.info('Dry run: continuing')\\n else:\\n logger.info('Checking job status...')\\n provider = provider_base.get_provider(self.provider_options)\\n\\n while True:\\n tasks = provider.lookup_job_tasks('*', job_name_list=[self.job_name], max_jobs=1)\\n logger.debug('Tasks: %s' % tasks)\\n\\n if not tasks:\\n raise RuntimeError('Job not found: %s' % self.job_name)\\n\\n is_running = False\\n status = None\\n\\n # Wait until all tasks succeed; abort if any task fails or is canceled\\n for task in tasks:\\n status = provider.get_task_field(task, 'job-status')\\n\\n if status == 'RUNNING':\\n is_running = True\\n elif status == 'CANCELED':\\n raise RuntimeException('Job %s: CANCELED' % self.job_name)\\n elif status == 'FAILURE':\\n error = provider.get_task_field(task, 'error-message')\\n raise RuntimeException('Job %s: FAILURE. Error message: %s' % (self.job_name, error))\\n\\n if is_running:\\n time.sleep(self.poll_interval)\\n else:\\n break\\n\\n logger.info('Job %s: SUCCESS' % self.job_name)\\n return 'Success'\",\n \"def test_wait_for_predicate_timeout(self):\\n predicate_mock = mock.MagicMock(side_effect=[True, True, True])\\n with self.assertRaises(TimeoutError):\\n train_utils.wait_for_predicate(predicate_mock, num_retries=3)\",\n \"def waitUntilSuccess():\",\n \"async def timeout(self, failed: bool = False) -> None:\\n raise NotImplementedError()\",\n \"def set_retry_timeout(self, retry_timeout):\",\n \"def wait(self, timeout):\\n raise NotImplementedError(\\n u\\\"%s: Method not implemented\\\", self.__class__.__name__)\",\n \"def wait_for_job_complete(self, job):\\n res, tasks = None, None\\n if job['status'].lower() == SUCCEEDED:\\n try:\\n res, tasks = job['result'], job['task']\\n except KeyError:\\n pass\\n return 0, res, job['status'], tasks\\n\\n def _wait_for_job_complete():\\n \\\"\\\"\\\"Called at an interval until the job is finished.\\\"\\\"\\\"\\n retries = kwargs['retries']\\n try:\\n kwargs['retries'] = retries + 1\\n if not kwargs['wait_for_job_called']:\\n is_complete, result, rc, status, task = (\\n self._is_job_finished(job_id))\\n if is_complete is True:\\n kwargs['wait_for_job_called'] = True\\n kwargs['rc'], kwargs['status'] = rc, status\\n kwargs['result'], kwargs['task'] = result, task\\n else:\\n kwargs['status'], kwargs['task'] = status, task\\n except Exception as error:\\n exception_message = 'Issue encountered waiting for job.'\\n LOG.exception(exception_message)\\n raise exception.VolumeBackendAPIException(\\n data=exception_message) from error\\n\\n return kwargs\\n\\n job_id = job['jobId']\\n kwargs = {'retries': 0, 'wait_for_job_called': False,\\n 'rc': 0, 'result': None}\\n\\n while not kwargs['wait_for_job_called']:\\n time.sleep(self.interval)\\n kwargs = _wait_for_job_complete()\\n if kwargs['retries'] > self.retries:\\n LOG.error('_wait_for_job_complete failed after {cnt} '\\n 'tries.'.format(cnt=kwargs['retries']))\\n kwargs['rc'], kwargs['result'] = -1, kwargs['result']\\n break\\n\\n LOG.debug('Return code is: {rc}. Result is {res}.'.format(\\n rc=kwargs['rc'], res=kwargs['result']))\\n return (kwargs['rc'], kwargs['result'],\\n kwargs['status'], kwargs['task'])\",\n \"def _wait_for(\\n func: Callable,\\n expected_result: Any = True,\\n timeout: int = 10,\\n print_error: bool = True,\\n sleep_for: int = 1,\\n **kwargs,\\n) -> None:\\n end = time() + timeout\\n\\n while time() <= end:\\n try:\\n retval = func(**kwargs)\\n except Exception as err: # pylint: disable=broad-except\\n if print_error:\\n logger.error(err)\\n else:\\n if retval == expected_result:\\n return None\\n sleep(sleep_for)\\n\\n raise WaitForException(\\n f\\\"func: {func}, didn't return {expected_result} within specified timeout: {timeout}\\\"\\n )\",\n \"def wait(self, timeout=600):\\n s = datetime.datetime.now()\\n status = json.loads(self.get())\\n while status['status'] != 'COMPLETE':\\n status = self.get()\\n e = datetime.datetime.now()\\n if (e - s).seconds > timeout:\\n raise RuntimeError('timeout')\\n return status\",\n \"def _wait_until_job_starts_on_cluster(self) -> Optional[float]:\\n status = None\\n job_checking_retry_cnt = 0\\n while job_checking_retry_cnt < MAX_JOB_CHECKING_RETRY:\\n # Avoid the infinite loop, if any bug happens.\\n job_checking_retry_cnt += 1\\n try:\\n cluster_status, _ = (\\n backend_utils.refresh_cluster_status_handle(\\n self.cluster_name,\\n force_refresh_statuses=set(status_lib.ClusterStatus)))\\n except Exception as e: # pylint: disable=broad-except\\n # If any unexpected error happens, retry the job checking\\n # loop.\\n # TODO(zhwu): log the unexpected error to usage collection\\n # for future debugging.\\n logger.info(f'Unexpected exception: {e}\\\\nFailed to get the '\\n 'refresh the cluster status. Retrying.')\\n continue\\n if cluster_status != status_lib.ClusterStatus.UP:\\n # The cluster can be preempted before the job is\\n # launched.\\n # Break to let the retry launch kick in.\\n logger.info('The cluster is preempted before the job '\\n 'is submitted.')\\n # TODO(zhwu): we should recover the preemption with the\\n # recovery strategy instead of the current while loop.\\n break\\n\\n try:\\n status = spot_utils.get_job_status(self.backend,\\n self.cluster_name)\\n except Exception as e: # pylint: disable=broad-except\\n # If any unexpected error happens, retry the job checking\\n # loop.\\n # Note: the CommandError is already handled in the\\n # get_job_status, so it should not happen here.\\n # TODO(zhwu): log the unexpected error to usage collection\\n # for future debugging.\\n logger.info(f'Unexpected exception: {e}\\\\nFailed to get the '\\n 'job status. Retrying.')\\n continue\\n\\n # Check the job status until it is not in initialized status\\n if status is not None and status > job_lib.JobStatus.INIT:\\n try:\\n job_submitted_at = spot_utils.get_job_timestamp(\\n self.backend, self.cluster_name, get_end_time=False)\\n return job_submitted_at\\n except Exception as e: # pylint: disable=broad-except\\n # If we failed to get the job timestamp, we will retry\\n # job checking loop.\\n logger.info(f'Unexpected Exception: {e}\\\\nFailed to get '\\n 'the job start timestamp. Retrying.')\\n continue\\n # Wait for the job to be started\\n time.sleep(spot_utils.JOB_STARTED_STATUS_CHECK_GAP_SECONDS)\\n return None\",\n \"async def _job(self):\\n await asyncio.sleep(self._timeout)\\n await self._callback()\",\n \"def wait_fluently(condition: Callable, timeout: TimeoutType, err_msg: str):\\n if timeout is None:\\n timeout = 0\\n start_time = time.time()\\n while True:\\n res = condition()\\n if res:\\n return res\\n if time.time() - start_time >= timeout:\\n raise TimeoutException(err_msg)\\n time.sleep(0.3)\",\n \"def fusion_api_wait_for_task_to_complete(self, uri=None, api=None, headers=None, retries=5, sleep_time=5, param=''):\\n task_attempts = 0\\n for _ in range(0, retries):\\n time.sleep(sleep_time)\\n task_attempts += 1\\n response = self.task.get(uri=uri, api=api, headers=headers, param=param)\\n if response[\\\"percentComplete\\\"] == 100:\\n break\\n if task_attempts == retries:\\n raise Exception(\\n \\\"Task did not complete after %d tries.\\\" % retries)\\n return response\",\n \"def wait_until_done(self, job_id, config_id=1,\\n wait_time=5, max_iters=50, init_wait_time=0):\\n status = False\\n i= 0\\n time.sleep(init_wait_time)\\n # Do until job finishes or max iters is reached.\\n while status == False and i < max_iters:\\n resp = self.check_status(job_id, config_id)\\n logger.debug(\\\"Waiting for response \\\" + resp.content)\\n job_status = json.loads(resp.content)['status']\\n if job_status == 'done':\\n logger.info(\\\"Previous, job done! \\\" + resp.content)\\n status = True\\n # If the job fails stop everything and raise exception.\\n elif job_status == \\\"FAILED\\\":\\n raise Exception(\\n \\\"FATAL: Job {num} failed with a response of: {resp}\\\".format(\\n num=job_id,\\n resp=resp.content\\n )\\n )\\n i += 1\\n time.sleep(wait_time)\\n # If we hit max iterations.\\n if status == False:\\n raise Exception(\\n \\\"Task Load Timeout!\\\\nTry setting a longer wait time\\\"\\n )\\n # TODO: Maybe report some time stats once done.\",\n \"def wait_until_job_completes(self):\\n while True:\\n jobflow = self.conn.describe_jobflow(self.jobid)\\n if self.verbose_mode:\\n print jobflow.state\\n if (jobflow.state == 'COMPLETED' or jobflow.state == 'TERMINATED'\\n or jobflow.state == 'FAILED'):\\n break\\n sleep(10)\",\n \"async def wait_graceafully(aws, timeout=None):\\n\\n while True:\\n done, pending = await asyncio.wait(aws, timeout=15)\\n\\n for t in done:\\n if t.exception():\\n print(\\\"exception:\\\", patch.task_get_name(t), t.exception())\\n elif t.result():\\n print(\\\"result:\\\", patch.task_get_name(t), t.result())\\n\\n if not pending:\\n break\\n\\n for t in pending:\\n t.cancel()\\n\\n aws = pending\",\n \"def _poll_until_exception(self, fn, expected_exception, max_retries=20, retry_delay=3):\\n\\n for _ in range(max_retries):\\n try:\\n fn()\\n if self.is_live:\\n time.sleep(retry_delay)\\n except expected_exception:\\n return\\n\\n self.fail(\\\"expected exception {expected_exception} was not raised\\\")\",\n \"def retry_wait_backoff(fn_check, fail_msg, max_wait=20):\\n sleep_time = 0.1\\n total_waited = 0.0\\n while total_waited < max_wait:\\n if fn_check():\\n break\\n log.info('{0}, retrying in {1:.2f}s'.format(fail_msg, sleep_time))\\n total_waited += sleep_time\\n time.sleep(sleep_time)\\n sleep_time = min(sleep_time * 2, 5, max_wait - total_waited)\\n else:\\n raise TimeoutError('{0} after {1:.2f}s'.format(fail_msg, max_wait))\",\n \"def retry_wait_backoff(fn_check, fail_msg, max_wait=20):\\n sleep_time = 0.1\\n total_waited = 0.0\\n while total_waited < max_wait:\\n if fn_check():\\n break\\n log.info('{0}, retrying in {1:.2f}s'.format(fail_msg, sleep_time))\\n total_waited += sleep_time\\n time.sleep(sleep_time)\\n sleep_time = min(sleep_time * 2, 5, max_wait - total_waited)\\n else:\\n raise TimeoutError('{0} after {1:.2f}s'.format(fail_msg, max_wait))\",\n \"def request_until_success(url, max_attempts=5, wait=5,\\r\\n fail_max=True):\\r\\n req = urllib.request.Request(url)\\r\\n success = False\\r\\n num_tries = 0\\r\\n while not success:\\r\\n try:\\r\\n num_tries += 1\\r\\n response = urllib.request.urlopen(req)\\r\\n success = response.getcode() == 200\\r\\n except urllib.request.HTTPError as e:\\r\\n logger.error('e')\\r\\n logger.error('Error url: {}'.format(e))\\r\\n if e.code == 500 and num_tries < max_attempts:\\r\\n logger.info('trying again soon')\\r\\n time.sleep(wait)\\r\\n else:\\r\\n logger.error(e.reason)\\r\\n raise e\\r\\n\\r\\n if not success:\\r\\n raise Error('Failed to make request')\\r\\n return json.loads(response.read().decode('utf-8'))\",\n \"def WaitForJobCompletion(self, job_id, period=5, retries=-1):\\n while retries != 0:\\n job_result = self.GetJobStatus(job_id)\\n\\n if job_result and job_result[\\\"status\\\"] == JOB_STATUS_SUCCESS:\\n return True\\n elif not job_result or job_result[\\\"status\\\"] in JOB_STATUS_FINALIZED:\\n return False\\n\\n if period:\\n time.sleep(period)\\n\\n if retries > 0:\\n retries -= 1\\n\\n return False\",\n \"def retry(self):\\n # XXX: check whether it is possible to distingish \\n # between the error conditions and set meaningfull exitcode\\n return False\",\n \"def wait_until(condition, delay, max_attempts):\\n attempt = 0\\n while not condition() and attempt < max_attempts:\\n attempt += 1\\n time.sleep(delay)\\n\\n if attempt >= max_attempts:\\n raise Exception(\\\"Condition is still False after {} attempts.\\\".format(max_attempts))\",\n \"def test_retry_failed_jobs(sleep, client, job_retry_on_query):\\n\\n retry_notfound = google.api_core.retry.Retry(\\n predicate=google.api_core.retry.if_exception_type(\\n google.api_core.exceptions.NotFound\\n )\\n )\\n retry_badrequest = google.api_core.retry.Retry(\\n predicate=google.api_core.retry.if_exception_type(\\n google.api_core.exceptions.BadRequest\\n )\\n )\\n\\n if job_retry_on_query is None:\\n reason = \\\"rateLimitExceeded\\\"\\n else:\\n reason = \\\"notFound\\\"\\n\\n err = dict(reason=reason)\\n responses = [\\n dict(status=dict(state=\\\"DONE\\\", errors=[err], errorResult=err)),\\n dict(status=dict(state=\\\"DONE\\\", errors=[err], errorResult=err)),\\n dict(status=dict(state=\\\"DONE\\\", errors=[err], errorResult=err)),\\n dict(status=dict(state=\\\"DONE\\\")),\\n dict(rows=[{\\\"f\\\": [{\\\"v\\\": \\\"1\\\"}]}], totalRows=\\\"1\\\"),\\n ]\\n\\n def api_request(method, path, query_params=None, data=None, **kw):\\n response = responses.pop(0)\\n if data:\\n response[\\\"jobReference\\\"] = data[\\\"jobReference\\\"]\\n else:\\n response[\\\"jobReference\\\"] = dict(\\n jobId=path.split(\\\"/\\\")[-1], projectId=\\\"PROJECT\\\"\\n )\\n return response\\n\\n conn = client._connection = make_connection()\\n conn.api_request.side_effect = api_request\\n\\n if job_retry_on_query == \\\"Query\\\":\\n job_retry = dict(job_retry=retry_notfound)\\n elif job_retry_on_query == \\\"Both\\\":\\n # This will be overridden in `result`\\n job_retry = dict(job_retry=retry_badrequest)\\n else:\\n job_retry = {}\\n job = client.query(\\\"select 1\\\", **job_retry)\\n\\n orig_job_id = job.job_id\\n job_retry = (\\n dict(job_retry=retry_notfound)\\n if job_retry_on_query in (\\\"Result\\\", \\\"Both\\\")\\n else {}\\n )\\n result = job.result(**job_retry)\\n assert result.total_rows == 1\\n assert not responses # We made all the calls we expected to.\\n\\n # The job adjusts it's job id based on the id of the last attempt.\\n assert job.job_id != orig_job_id\\n assert job.job_id == conn.mock_calls[3][2][\\\"data\\\"][\\\"jobReference\\\"][\\\"jobId\\\"]\\n\\n # We had to sleep three times\\n assert len(sleep.mock_calls) == 3\\n\\n # Sleeps are random, however they're more than 0\\n assert min(c[1][0] for c in sleep.mock_calls) > 0\\n\\n # They're at most 2 * (multiplier**(number of sleeps - 1)) * initial\\n # The default multiplier is 2\\n assert max(c[1][0] for c in sleep.mock_calls) <= 8\\n\\n # We can ask for the result again:\\n responses = [\\n dict(rows=[{\\\"f\\\": [{\\\"v\\\": \\\"1\\\"}]}], totalRows=\\\"1\\\"),\\n ]\\n orig_job_id = job.job_id\\n result = job.result()\\n assert result.total_rows == 1\\n assert not responses # We made all the calls we expected to.\\n\\n # We wouldn't (and didn't) fail, because we're dealing with a successful job.\\n # So the job id hasn't changed.\\n assert job.job_id == orig_job_id\",\n \"def _poll_until_no_exception(self, fn, expected_exception, max_retries=20, retry_delay=3):\\n\\n for i in range(max_retries):\\n try:\\n return fn()\\n except expected_exception:\\n if i == max_retries - 1:\\n raise\\n if self.is_live:\\n time.sleep(retry_delay)\",\n \"def _wait_for_snapshot(k8s_ctx: str, spec_file: pathlib.Path, attempts: int = 30, secs2wait: int = 20, dry_run: bool = False) -> None:\\n for counter in range(attempts):\\n if _snapshot_ready(k8s_ctx, spec_file, dry_run):\\n break\\n time.sleep(secs2wait)\\n else:\\n raise TimeoutError(f'{spec_file} timed out')\",\n \"def test_job_failure(app):\\n with worker(app):\\n state = wait_for_results(app, length=100, sleep=0.2, maxwait=4)\\n\\n # Tasks have been delivered and executed.\\n assert set(r.return_value for r in all_results(app)) == set(range(100))\\n assert len(state.queue.messages) == 0\\n\\n # Consumer groups behaved properly.\\n assert state.queue.info.groups == 1\\n assert state.queue.groups[0].pending == 0\\n\\n # Nothing in the DLQ.\\n assert len(state.dead.messages) == 0\\n\\n # Any scheduled tasks completed and removed.\\n assert len(state.schedule) == 0\",\n \"async def test_wait_for_activity_timeout(aiopg_connector):\\n pg_app = app.App(connector=aiopg_connector)\\n worker = worker_module.Worker(app=pg_app, timeout=2)\\n worker.notify_event = asyncio.Event()\\n task = asyncio.ensure_future(worker.single_worker(worker_id=0))\\n try:\\n await asyncio.sleep(0.2) # should be enough so that we're waiting\\n\\n worker.stop_requested = True\\n\\n with pytest.raises(asyncio.TimeoutError):\\n await asyncio.wait_for(task, timeout=0.2)\\n finally:\\n worker.notify_event.set()\",\n \"def wait_on_job(self, delay=10):\\n while self.isJobRunning() == True:\\n time.sleep(delay)\\n return self.ofile_exists()\",\n \"def wait_until_not_raised(condition, delay, max_attempts):\\n def wrapped_condition():\\n try:\\n result = condition()\\n except:\\n return False, None\\n\\n return True, result\\n\\n attempt = 0\\n while attempt < (max_attempts-1):\\n attempt += 1\\n success, result = wrapped_condition()\\n if success:\\n return result\\n\\n time.sleep(delay)\\n\\n # last attempt, let the exception raise\\n return condition()\",\n \"def wait_until_done(self, timeout=10.0):\\r\\n cfunc = lib_importer.windll.DAQmxWaitUntilTaskDone\\r\\n if cfunc.argtypes is None:\\r\\n with cfunc.arglock:\\r\\n if cfunc.argtypes is None:\\r\\n cfunc.argtypes = [lib_importer.task_handle, ctypes.c_double]\\r\\n\\r\\n error_code = cfunc(self._handle, timeout)\\r\\n check_for_error(error_code)\",\n \"def retry(times):\\n return repeat_with_success_at_least(times, 1)\",\n \"async def handle_launch_timeout(self):\\n await asyncio.sleep(poll_interval)\\n time_interval = RemoteProvisionerBase.get_time_diff(self.start_time)\\n\\n if time_interval > self.launch_timeout:\\n reason = f\\\"Waited too long ({self.launch_timeout}s) to get connection file\\\"\\n timeout_message = f\\\"KernelID: '{self.kernel_id}' launch timeout due to: {reason}\\\"\\n await self.kill()\\n self.log_and_raise(TimeoutError(timeout_message))\",\n \"def wait_for_url(url: str, timeout=120) -> None:\\n for _ in range(timeout):\\n try:\\n requests.get(url)\\n return\\n except requests.exceptions.ConnectionError:\\n sleep(1)\\n raise TimeoutError(f\\\"No response from APP in {timeout} seconds\\\")\",\n \"def check_completion(self):\\n\\n time.sleep(3)\\n while self.status == 0:\\n pass\",\n \"def _check_job_completeness(self, jobs):\\n for job in concurrent.futures.as_completed(jobs):\\n if job.exception():\\n raise (job.exception())\",\n \"def wait(self):\\n response = self._client.api.operations[self.id].wait.get()\\n\\n try:\\n if response.json()['metadata']['status'] == 'Failure':\\n raise exceptions.LXDAPIException(response)\\n except KeyError:\\n # Support for legacy LXD\\n pass\",\n \"def jobHealthy(self, count):\\n job = self.tester.submission_result.job\\n for idx in range(count - 1):\\n if (job.health == 'healthy'):\\n return True\\n print(\\\"health check fail : %d\\\" % idx )\\n time.sleep(1)\\n job.refresh()\\n self.assertEqual('healthy', job.health)\\n return False\",\n \"def retry_failed_downloader_jobs() -> None:\\n failed_jobs = (\\n DownloaderJob.failed_objects.filter(created_at__gt=utils.JOB_CREATED_AT_CUTOFF)\\n .order_by(\\\"created_at\\\")\\n .prefetch_related(\\\"original_files__samples\\\")\\n )\\n\\n paginator = Paginator(failed_jobs, utils.PAGE_SIZE, \\\"created_at\\\")\\n page = paginator.page()\\n page_count = 0\\n\\n if len(page.object_list) <= 0:\\n # No failed jobs, nothing to do!\\n return\\n\\n queue_capacity = get_capacity_for_downloader_jobs()\\n\\n if queue_capacity <= 0:\\n logger.info(\\n \\\"Not handling failed (explicitly-marked-as-failure) downloader jobs \\\"\\n \\\"because there is no capacity for them.\\\"\\n )\\n\\n while queue_capacity > 0:\\n logger.info(\\n \\\"Handling page %d of failed (explicitly-marked-as-failure) downloader jobs!\\\", page_count\\n )\\n\\n handle_downloader_jobs(page.object_list)\\n\\n if page.has_next():\\n page = paginator.page(page.next_page_number())\\n page_count = page_count + 1\\n queue_capacity = get_capacity_for_downloader_jobs()\\n else:\\n break\",\n \"def wait_for_success(chronos_url, interval=30):\\n last_chance = 0\\n print('Waiting for jobs...')\\n while True:\\n time.sleep(interval)\\n job_status = None\\n while not job_status:\\n try:\\n job_status = get_status(chronos_url)\\n except ValueError:\\n print(\\\"Invalid JSON received, retrying.\\\")\\n print_str = time.strftime(\\\"%H:%M:%S\\\")\\n all_str = \\\" - all: \\\" + ', '.join(sorted(job_status['all']))\\n fresh_str = \\\" - fresh: \\\" + ', '.join(sorted(job_status['fresh']))\\n fail_str = \\\" - failures: \\\" + ', '.join(sorted(job_status['failure']))\\n run_str = \\\" - running: \\\" + ', '.join(sorted(job_status['running']))\\n print(print_str + fail_str + run_str)\\n # no running, failure, or pending jobs, head to next step\\n if (len(job_status['running']) == 0 and len(job_status['fresh']) == 0 and\\n len(job_status['failure']) == 0):\\n print('Ready for the next Phase!')\\n return True\\n elif len(job_status['running']) == 0:\\n # no running jobs, but some pending, give one last chance\\n if last_chance < 10 * 60 / interval:\\n print('No jobs running, but not all finished, checking...')\\n last_chance = last_chance + 1\\n continue\\n else:\\n print('Continuing: Some jobs are stuck (possibly because of failures)')\\n return True\\n # there are jobs still running\\n else:\\n last_chance = 0\",\n \"def test_run_max_retries():\\n responses = [httpretty.Response(body=\\\"Internal Server Error\\\", status=500),\\n httpretty.Response(body=\\\"Internal Server Error\\\", status=500),\\n httpretty.Response(body=\\\"Internal Server Error\\\", status=500)]\\n httpretty.register_uri(httpretty.GET, URL, responses=responses)\\n with mock.patch('httsleep.main.sleep'):\\n httsleep = HttSleep(URL, {'status_code': 200}, max_retries=2)\\n with pytest.raises(StopIteration):\\n httsleep.run()\",\n \"def wait_for_job(job) -> bool:\\n job.refresh_from_db()\\n is_done = False\\n\\n while not is_done:\\n if job.end_time is None and job.success is None:\\n print(f\\\"Polling {type(job).__name__}s. Currently waiting for job id: {job.id}\\\")\\n sleep(20)\\n job.refresh_from_db()\\n elif job.retried and job.retried_job:\\n job = job.retried_job\\n elif job.success:\\n return True\\n else:\\n print(f\\\"{type(job).__name__} {job.id} failed!\\\")\\n return False\\n\\n return False\",\n \"def retry(self, times):\\n return Retry((requests.ConnectionError, requests.Timeout), times)\",\n \"def wait_for_reply(timeout=3):\\n i = 0\\n reply = Networking.get_instance().client.get_server_reply()\\n while not reply:\\n reply = Networking.get_instance().client.get_server_reply()\\n time.sleep(1)\\n i += 1\\n if i > timeout:\\n raise TimeoutError\\n return reply\",\n \"def test_submit_jobs(self):\\r\\n\\r\\n submit_jobs([self.command], prefix=\\\"test_job\\\")\\r\\n # Try and wait ten times, could be made nicer with alarm()\\r\\n for i in range(10):\\r\\n if exists(self.tmp_result_file):\\r\\n observed_text = \\\"\\\".join(list(open(self.tmp_result_file)))\\r\\n self.assertEqual(observed_text, \\\"hello\\\\n\\\")\\r\\n return\\r\\n else:\\r\\n sleep(10)\\r\\n # if we get here we failed\\r\\n self.fail(\\\"The test job apparently never finished.\\\\n\\\"\\r\\n + \\\"check the jobs error log and check the queue status\\\\n.\\\")\",\n \"def wait_to_complete(self, timeout: float = 5) -> None:\\n if self.proc.poll() is not None: # type: ignore\\n return\\n\\n start_time = time.time()\\n\\n while start_time + timeout > time.time() and self.proc.poll() is None: # type: ignore\\n time.sleep(0.001)\\n\\n if self.proc.poll() is None: # type: ignore\\n self.terminate(force=True)\\n self.wait()\\n self.exitstatus = \\\"Terminated!\\\" # type: ignore\",\n \"def wait(self, timeout=0):\\n if timeout:\\n self._finished.wait(timeout=timeout)\\n else:\\n self._finished.wait()\",\n \"def retry(self):\\n return False\",\n \"def wait_for(*args, **kwargs):\\n if \\\"timeout_seconds\\\" not in kwargs:\\n kwargs[\\\"timeout_seconds\\\"] = constants.ux.MAX_USER_WAIT_SECONDS\\n return waiting.wait(*args, **kwargs)\",\n \"def retry_until_timeout(\\n exception: Type[Exception],\\n item: Callable[..., Any],\\n timeout: int,\\n args: List[Any] = None,\\n kwargs: Mapping[str, Any] = None,\\n interval: float = 0.05,\\n raise_on_timeout: bool = True,\\n) -> Any:\\n timeout_info = TimeoutExceptionInfo()\\n end_time = timeout_info.started + timeout\\n while True:\\n try:\\n res = item(*args or tuple(), **kwargs or {})\\n except exception as exc:\\n if time.time() < end_time:\\n # no timeout yet\\n time.sleep(interval)\\n else:\\n if raise_on_timeout:\\n raise TimeoutException(\\n \\\"Timeout waiting for {0}\\\"\\n \\\" to return without {1}. {2}. {3}\\\".format(\\n item.__name__,\\n exception.__name__,\\n timeout_info.msg(),\\n str(exc),\\n )\\n )\\n else:\\n return None\\n else:\\n return res\",\n \"def wait(self, timeout=None):\\n assert False, \\\"Deriving class must implement\\\"\",\n \"async def job_wait(self, uid):\\n self._require_running()\\n await self._get_job(uid).wait()\",\n \"def wait(self):\\r\\n self.jobs.join()\",\n \"def _retry_request(self, request, timeout=2, attempts=3):\\n import googleapiclient\\n\\n try:\\n return request.execute()\\n except BrokenPipeError as ex:\\n if attempts > 0:\\n time.sleep(timeout)\\n return self._retry_request(request, timeout * 2, attempts - 1)\\n raise ex\\n except googleapiclient.errors.HttpError as ex:\\n log_verbose_traceback(ex)\\n raise ex\\n except Exception as ex:\\n log_verbose_traceback(ex)\\n raise ex\",\n \"def until_true(condition, timeout, error_msg):\\n timeout = timestr_to_secs(timeout)\\n max_wait = time.time() + timeout\\n while True:\\n if condition():\\n break\\n if time.time() > max_wait:\\n raise AssertionError(error_msg)\\n time.sleep(0.1)\",\n \"def WaitForExit(self, timeout: int = 1200) -> Dict[str, Any]:\\n raise NotImplementedError()\",\n \"def get_result(self, execution_id, num_retries=30, interval=1, verbose=False): # pylint: disable=too-many-locals\\n if verbose:\\n print(f\\\"Waiting for results. [Job Arn: {execution_id}]\\\")\\n\\n original_sigint_handler = signal.getsignal(signal.SIGINT)\\n\\n def _handle_sigint_during_get_result(*_): # pragma: no cover\\n raise Exception(f\\\"Interrupted. The Arn of your submitted job is {execution_id}.\\\")\\n\\n def _calculate_measurement_probs(measurements):\\n \\\"\\\"\\\"\\n Calculate the measurement probabilities .\\n\\n Calculate the measurement probabilities based on the list of measurements for a job sent to a SV1 Braket\\n simulator.\\n\\n Args:\\n measurements (list): list of measurements\\n\\n Returns:\\n measurementsProbabilities (dict): The measurements with their probabilities\\n \\\"\\\"\\\"\\n total_mes = len(measurements)\\n unique_mes = [list(x) for x in {tuple(x) for x in measurements}]\\n total_unique_mes = len(unique_mes)\\n len_qubits = len(unique_mes[0])\\n measurements_probabilities = {}\\n for i in range(total_unique_mes):\\n strqubits = ''\\n for qubit_idx in range(len_qubits):\\n strqubits += str(unique_mes[i][qubit_idx])\\n prob = measurements.count(unique_mes[i]) / total_mes\\n measurements_probabilities[strqubits] = prob\\n\\n return measurements_probabilities\\n\\n # The region_name is obtained from the task_arn itself\\n region_name = re.split(':', execution_id)[3]\\n client_braket = boto3.client(\\n 'braket',\\n region_name=region_name,\\n aws_access_key_id=self._credentials['AWS_ACCESS_KEY_ID'],\\n aws_secret_access_key=self._credentials['AWS_SECRET_KEY'],\\n )\\n\\n try:\\n signal.signal(signal.SIGINT, _handle_sigint_during_get_result)\\n\\n for _ in range(num_retries):\\n quantum_task = client_braket.get_quantum_task(quantumTaskArn=execution_id)\\n status = quantum_task['status']\\n bucket = quantum_task['outputS3Bucket']\\n directory = quantum_task['outputS3Directory']\\n resultsojectname = f\\\"{directory}/results.json\\\"\\n if status == 'COMPLETED':\\n # Get the device type to obtian the correct measurement\\n # structure\\n devicetype_used = client_braket.get_device(deviceArn=quantum_task['deviceArn'])['deviceType']\\n # Get the results from S3\\n client_s3 = boto3.client(\\n 's3',\\n aws_access_key_id=self._credentials['AWS_ACCESS_KEY_ID'],\\n aws_secret_access_key=self._credentials['AWS_SECRET_KEY'],\\n )\\n s3result = client_s3.get_object(Bucket=bucket, Key=resultsojectname)\\n if verbose:\\n print(f\\\"Results obtained. [Status: {status}]\\\")\\n result_content = json.loads(s3result['Body'].read())\\n\\n if devicetype_used == 'QPU':\\n return result_content['measurementProbabilities']\\n if devicetype_used == 'SIMULATOR':\\n return _calculate_measurement_probs(result_content['measurements'])\\n if status == 'FAILED':\\n raise Exception(\\n f'Error while running the code: {status}. '\\n f'The failure reason was: {quantum_task[\\\"failureReason\\\"]}.'\\n )\\n if status == 'CANCELLING':\\n raise Exception(f\\\"The job received a CANCEL operation: {status}.\\\")\\n time.sleep(interval)\\n # NOTE: Be aware that AWS is billing if a lot of API calls are\\n # executed, therefore the num_repetitions is set to a small\\n # number by default.\\n # For QPU devices the job is always queued and there are some\\n # working hours available.\\n # In addition the results and state is written in the\\n # results.json file in the S3 Bucket and does not depend on the\\n # status of the device\\n\\n finally:\\n if original_sigint_handler is not None:\\n signal.signal(signal.SIGINT, original_sigint_handler)\\n\\n raise RequestTimeoutError(\\n f\\\"Timeout. The Arn of your submitted job is {execution_id} and the status of the job is {status}.\\\"\\n )\",\n \"def test_timeout(self):\\n start = time.time()\\n dr = EventualResult(Deferred(), None)\\n self.assertRaises(TimeoutError, dr.wait, timeout=0.03)\\n # be a little lenient for slow computers:\\n self.assertTrue(abs(time.time() - start) < 0.05)\",\n \"def wait_until(self, check, timeout=None):\\n self._wait_in_process_loop(lambda: (check(),None),timeout=timeout)\",\n \"def test_wait_tx_settled_timeout(self, is_transaction_settled_mock):\\n with pytest.raises(TimeoutError):\\n wait_tx_settled(\\\"some\\\", \\\"some\\\", timeout=0.5)\",\n \"def retry_hung_downloader_jobs() -> None:\\n potentially_hung_jobs = (\\n DownloaderJob.hung_objects.filter(created_at__gt=utils.JOB_CREATED_AT_CUTOFF)\\n .order_by(\\\"created_at\\\")\\n .prefetch_related(\\\"original_files__samples\\\")\\n )\\n paginator = Paginator(potentially_hung_jobs, utils.PAGE_SIZE, \\\"created_at\\\")\\n database_page = paginator.page()\\n database_page_count = 0\\n\\n if len(database_page.object_list) <= 0:\\n # No failed jobs, nothing to do!\\n return\\n\\n queue_capacity = get_capacity_for_downloader_jobs()\\n\\n if queue_capacity <= 0:\\n logger.info(\\n \\\"Not handling hung (started-but-never-finished) downloader jobs \\\"\\n \\\"because there is no capacity for them.\\\"\\n )\\n while queue_capacity > 0:\\n hung_jobs = utils.check_hung_jobs(database_page.object_list)\\n\\n if hung_jobs:\\n logger.info(\\n \\\"Handling page %d of hung (started-but-never-finished) downloader jobs!\\\",\\n database_page_count,\\n jobs_count=len(hung_jobs),\\n )\\n handle_downloader_jobs(hung_jobs)\\n\\n if database_page.has_next():\\n database_page = paginator.page(database_page.next_page_number())\\n database_page_count += 1\\n queue_capacity = get_capacity_for_downloader_jobs()\\n else:\\n break\",\n \"def _wait_for(self, check_func, desc, result=False, timeout=200):\\r\\n if result:\\r\\n return Promise(check_func, desc, timeout=timeout).fulfill()\\r\\n else:\\r\\n return EmptyPromise(check_func, desc, timeout=timeout).fulfill()\",\n \"def __await_helms_installation(self, job_id, expected_services_count):\\n end_waiting = datetime.now().timestamp() + self.TIMEOUT_MIN * 60 * 1000\\n curr_status = self.helm_results.get(job_id)\\n while datetime.now().timestamp() <= end_waiting:\\n curr_status = self.helm_results.get(job_id, {\\\"services\\\": []})\\n if expected_services_count != len(curr_status[\\\"services\\\"]):\\n time.sleep(1.)\\n else:\\n self.helm_results.pop(job_id)\\n return curr_status\\n self.helm_results.pop(job_id)\\n return curr_status\",\n \"def retry(callback, retries, sleep=0.5, catch=Exception, *args, **kwargs):\\n r = 0\\n while r < retries:\\n r += 1\\n try:\\n return callback(*args, **kwargs)\\n except catch as c:\\n if r == retries:\\n raise c\\n else:\\n time.sleep(r * sleep)\",\n \"def _selenium_wait_for(fn):\\n start_time = time.time()\\n while True:\\n try:\\n return fn()\\n except (AssertionError, WebDriverException) as e:\\n if time.time() - start_time > 10:\\n raise e\\n time.sleep(0.5)\",\n \"def wait_jobs_completed():\\n\\n logging.info(\\\"checking jobs\\\")\\n time.sleep(30)\\n while True:\\n running_jobs = []\\n for job in bq.list_jobs(state_filter='RUNNING', all_users=True):\\n running_jobs.append(job)\\n logging.info(\\\"running jobs {}\\\".format(len(running_jobs)))\\n if not running_jobs:\\n break\\n time.sleep(30)\",\n \"def robust_wait_for_clickable_element(driver, delay, selector):\\n clickable = False\\n attempts = 1\\n try:\\n driver.find_element_by_xpath(selector)\\n except Exception as e:\\n print(\\\" Selector not found: {}\\\".format(selector))\\n else:\\n while not clickable:\\n try:\\n # wait for job post link to load\\n wait_for_clickable_element(driver, delay, selector)\\n except Exception as e:\\n print(\\\" {}\\\".format(e))\\n attempts += 1\\n if attempts % 100 == 0:\\n driver.refresh()\\n if attempts > 10**3: \\n print(\\\" \\\\nrobust_wait_for_clickable_element failed \\\" \\\\\\n \\\"after too many attempts\\\\n\\\")\\n break\\n pass\\n else:\\n clickable = True\",\n \"def wait_for_container():\\n for i in xrange(30):\\n print(\\\"Waiting for service to come up\\\")\\n try:\\n requests.get(URL).raise_for_status()\\n return True\\n except Exception as e:\\n print e\\n sleep(1)\\n\\n return False\",\n \"def track_job_to_completion(ip_address, headers, job_id):\\n job_status_map = {\\n \\\"2020\\\": \\\"Scheduled\\\",\\n \\\"2030\\\": \\\"Queued\\\",\\n \\\"2040\\\": \\\"Starting\\\",\\n \\\"2050\\\": \\\"Running\\\",\\n \\\"2060\\\": \\\"Completed\\\",\\n \\\"2070\\\": \\\"Failed\\\",\\n \\\"2090\\\": \\\"Warning\\\",\\n \\\"2080\\\": \\\"New\\\",\\n \\\"2100\\\": \\\"Aborted\\\",\\n \\\"2101\\\": \\\"Paused\\\",\\n \\\"2102\\\": \\\"Stopped\\\",\\n \\\"2103\\\": \\\"Canceled\\\"\\n }\\n\\n max_retries = 20\\n sleep_interval = 60\\n failed_job_status = [2070, 2090, 2100, 2101, 2102, 2103]\\n job_url = 'https://%s/api/JobService/Jobs(%s)' % (ip_address, job_id)\\n loop_ctr = 0\\n job_incomplete = True\\n print(\\\"Polling %s to completion ...\\\" % job_id)\\n while loop_ctr < max_retries:\\n loop_ctr += 1\\n time.sleep(sleep_interval)\\n job_resp = requests.get(job_url, headers=headers, verify=False)\\n if job_resp.status_code == 200:\\n job_status = str((job_resp.json())['LastRunStatus']['Id'])\\n print(\\\"Iteration %s: Status of %s is %s\\\" % (loop_ctr, job_id, job_status_map[job_status]))\\n if int(job_status) == 2060:\\n job_incomplete = False\\n print(\\\"Completed updating firmware successfully ... Exiting\\\")\\n break\\n elif int(job_status) in failed_job_status:\\n job_incomplete = False\\n print(\\\"Update job failed ... \\\")\\n job_hist_url = str(job_url) + \\\"/ExecutionHistories\\\"\\n job_hist_resp = requests.get(job_hist_url, headers=headers, verify=False)\\n if job_hist_resp.status_code == 200:\\n job_history_id = str((job_hist_resp.json())['value'][0]['Id'])\\n job_hist_det_url = str(job_hist_url) + \\\"(\\\" + job_history_id + \\\")/ExecutionHistoryDetails\\\"\\n job_hist_det_resp = requests.get(job_hist_det_url,\\n headers=headers,\\n verify=False)\\n if job_hist_det_resp.status_code == 200:\\n print(job_hist_det_resp.text)\\n else:\\n print(\\\"Unable to parse job execution history .. Exiting\\\")\\n break\\n else:\\n print(\\\"Unable to poll status of %s - Iteration %s \\\" % (job_id, loop_ctr))\\n if job_incomplete:\\n print(\\\"Job %s incomplete after polling %s times...Check status\\\" % (job_id, max_retries))\",\n \"def test_retry_run(self):\\n pass\",\n \"def test_later_failure_result(self):\\n d = Deferred()\\n dr = EventualResult(d, None)\\n result_list = []\\n done = append_in_thread(result_list, dr.wait, 100)\\n time.sleep(0.1)\\n d.errback(RuntimeError())\\n done.wait(100)\\n self.assertEqual(\\n (result_list[0], result_list[1].__class__), (False, RuntimeError))\",\n \"def aws_cmd ( cmd, args, num_retries = 20 ) :\\n while True :\\n try :\\n return cmd( *args )\\n except :\\n num_retries -= 1\\n if num_retries < 1 :\\n raise\\n time.sleep( 1 )\",\n \"def wait_until_complete(self):\\n self._log.debug(\\\"waiting for upload job %s to complete\\\", self._job_id)\\n xpath = ManoProject.prefix_project(\\\"D,/rw-image-mgmt:upload-jobs/\\\" +\\n \\\"rw-image-mgmt:job[rw-image-mgmt:id={}]\\\".\\n format(quoted_key(str(self._job_id))),\\n project=self._project,\\n log=self._log)\\n\\n while True:\\n query_iter = yield from self._dts.query_read(xpath)\\n job_status_msg = None\\n for fut_resp in query_iter:\\n job_status_msg = (yield from fut_resp).result\\n break\\n\\n if job_status_msg is None:\\n raise UploadJobError(\\\"did not get a status response for job_id: %s\\\",\\n self._job_id)\\n\\n if job_status_msg.status == \\\"COMPLETED\\\":\\n msg = \\\"upload job %s completed successfully\\\" % self._job_id\\n self._log.debug(msg)\\n return\\n\\n elif job_status_msg.status == \\\"FAILED\\\":\\n msg = \\\"upload job %s as not successful: %s\\\" % (self._job_id, job_status_msg.status)\\n self._log.error(msg)\\n raise UploadJobFailed(msg)\\n\\n elif job_status_msg.status == \\\"CANCELLED\\\":\\n msg = \\\"upload job %s was cancelled\\\" % self._job_id\\n self._log.error(msg)\\n raise UploadJobCancelled(msg)\\n\\n yield from asyncio.sleep(.5, loop=self._loop)\",\n \"def timeout_check_call(timeout, *args, **kwargs):\\n resolution = 0.1\\n pro = subprocess.Popen(*args, **kwargs)\\n starttime = time.time()\\n while pro.poll() is None:\\n time.sleep(resolution)\\n if time.time() - starttime > timeout:\\n to = time.time() - starttime\\n pro.terminate()\\n time.sleep(resolution)\\n if pro.poll() is None:\\n pro.kill()\\n raise TimeoutError('Timed out after {0:.1f} seconds'.format(to))\\n if pro.returncode:\\n raise subprocess.CalledProcessError(\\n pro.returncode, kwargs['args'] if 'args' in kwargs else args[0])\\n return 0\",\n \"def wait(self, ms=None):\\r\\n util.raiseNotDefined()\",\n \"def until_timeout(timeout, value=None):\\n\\n start = time.time()\\n\\n while True:\\n if time.time() - start >= timeout:\\n raise Exception(\\\"timed out before success!\\\")\\n yield value\",\n \"def wait_job_loading(self, elt, timeout=10):\\n time_slept = 0\\n wait = True\\n while wait:\\n time.sleep(1)\\n time_slept += 1\\n company_name = elt.text.splitlines()[0]\\n try:\\n employer_info_txt = self.driver.find_element_by_class_name(\\n \\\"empInfo\\\").text.splitlines()[0]\\n if (employer_info_txt.splitlines()[0]\\n == company_name):\\n wait = False\\n except NoSuchElementException as err:\\n logger.error(\\\"Element not found \\\", err)\\n if time_slept > timeout:\\n raise TimeoutError(\\n \\\"job offer of {} was not loaded in 10 seconds\\\".format(\\n company_name))\",\n \"def _wait_on_condition(self, timeout):\\n self.__condition.wait(timeout)\",\n \"def wait_or_fail(self, evt, timeout=2.0, msg=''):\\n res = evt.wait(timeout)\\n if not res:\\n self.fail(msg)\",\n \"def retry(nattempts, exception=None):\\n \\n def tryIt(func):\\n def wrapper(*args, **kwargs):\\n attempts = 0\\n while attempts < nattempts - 1:\\n try:\\n return func(*args, **kwargs)\\n except (exception if exception is not None else Exception):\\n attempts += 1\\n return func(*args, **kwargs)\\n return wrapper\\n return tryIt\",\n \"def test_disable_retry_failed_jobs(sleep, client, job_retry_on_query):\\n err = dict(reason=\\\"rateLimitExceeded\\\")\\n responses = [dict(status=dict(state=\\\"DONE\\\", errors=[err], errorResult=err))] * 3\\n\\n def api_request(method, path, query_params=None, data=None, **kw):\\n response = responses.pop(0)\\n response[\\\"jobReference\\\"] = data[\\\"jobReference\\\"]\\n return response\\n\\n conn = client._connection = make_connection()\\n conn.api_request.side_effect = api_request\\n\\n if job_retry_on_query == \\\"Query\\\":\\n job_retry = dict(job_retry=None)\\n else:\\n job_retry = {}\\n job = client.query(\\\"select 1\\\", **job_retry)\\n\\n orig_job_id = job.job_id\\n job_retry = dict(job_retry=None) if job_retry_on_query == \\\"Result\\\" else {}\\n with pytest.raises(google.api_core.exceptions.Forbidden):\\n job.result(**job_retry)\\n\\n assert job.job_id == orig_job_id\\n assert len(sleep.mock_calls) == 0\",\n \"def do_wait(self):\\n pass\",\n \"def retry_on_exception(func, max_attempts=5, ignored_exceptions=(StaleElementReferenceException, InvalidElementStateException)):\\r\\n attempt = 0\\r\\n while attempt < max_attempts:\\r\\n try:\\r\\n return func()\\r\\n except ignored_exceptions:\\r\\n world.wait(1)\\r\\n attempt += 1\\r\\n\\r\\n assert_true(attempt < max_attempts, 'Ran out of attempts to execute {}'.format(func))\",\n \"def test_handle_multiple_responses_throw_timeouterror():\\n # GIVEN\\n bboxes = [8.67066,49.41423,8.68177,49.4204]\\n time = \\\"2010-01-01/2011-01-01/P1Y\\\"\\n keys = [\\\"building\\\"]\\n values = [\\\"\\\"]\\n\\n # WHEN\\n client = ohsome.OhsomeClientParallel()\\n response = client.elements.count.post(bboxes=bboxes, time=time, keys=keys, values=values, timeout=2)\\n del client\",\n \"def raise_timeout(self, *args, **kwargs):\\n\\n self.log.error(\\\"Task timeout encountered.\\\")\\n raise TimeoutError\",\n \"def wait(self, timeout):\\n if not hasattr(self, '_value'):\\n try:\\n value = self.broker.pop_result(self, timeout=timeout)\\n except KeyError:\\n return False\\n except TaskExpired as err:\\n value = err\\n self._value = value\\n return hasattr(self, '_value')\",\n \"def test_default_maximum_conflict(self):\\n\\n self.set_options(timeouts=True, timeout_maximum=1, timeout_default=10)\\n task = self.create_task(self.context())\\n with self.assertRaises(ErrorWhileTesting):\\n task.execute()\",\n \"def sleep(self, timeout):\\n try:\\n self._wait_in_process_loop(lambda: (False,None),timeout=timeout)\\n except threadprop.TimeoutThreadError:\\n pass\",\n \"def _retry(*, task, signature_kwargs, retries):\\n if retries < MAX_RETRIES:\\n step = task.signature(**signature_kwargs)\\n queue = step.options.get(\\\"queue\\\", task.queue)\\n step.options[\\\"queue\\\"] = f\\\"{queue}-delay\\\"\\n step.kwargs[\\\"retries\\\"] = retries + 1\\n on_commit(step.apply_async)\\n else:\\n raise MaxRetriesExceededError\",\n \"def retry(retries, task_f, check_f=bool, wait_f=None):\\n for attempt in range(retries):\\n ret = task_f()\\n if check_f(ret):\\n return ret\\n if attempt < retries - 1 and wait_f is not None:\\n wait_f(attempt)\\n raise RetryException(\\\"Giving up after {} failed attempt(s)\\\".format(retries))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6805994","0.67427564","0.66825926","0.6454168","0.6368625","0.6354731","0.63537157","0.63452667","0.63171816","0.6291563","0.62773556","0.6274619","0.6184791","0.61747164","0.6170765","0.6160677","0.6152056","0.6144066","0.61388767","0.61302525","0.6112476","0.6081149","0.607","0.6051735","0.604029","0.60337853","0.6029674","0.60120696","0.60120696","0.6009754","0.5986483","0.5937645","0.5930558","0.5926005","0.5924905","0.59224415","0.59124154","0.5905921","0.5898826","0.58597124","0.58515126","0.58423406","0.5841324","0.58361393","0.58220744","0.58210623","0.5813407","0.5805428","0.5802682","0.5791009","0.57848555","0.5778545","0.57538646","0.5748494","0.573656","0.57356566","0.5709086","0.57055986","0.57016253","0.57011586","0.5683214","0.56828433","0.5676181","0.5673275","0.56713116","0.566775","0.5657689","0.56520206","0.5651824","0.56502855","0.56374484","0.563015","0.5628062","0.5627205","0.5625866","0.56245273","0.56233346","0.56091404","0.5607839","0.5594536","0.5590267","0.5588107","0.55809","0.55767745","0.55760473","0.5573404","0.5566542","0.55654436","0.5564986","0.5562373","0.5561523","0.5560079","0.55565417","0.5555214","0.5553577","0.5552761","0.55441326","0.5543488","0.5542599","0.5539805"],"string":"[\n \"0.6805994\",\n \"0.67427564\",\n \"0.66825926\",\n \"0.6454168\",\n \"0.6368625\",\n \"0.6354731\",\n \"0.63537157\",\n \"0.63452667\",\n \"0.63171816\",\n \"0.6291563\",\n \"0.62773556\",\n \"0.6274619\",\n \"0.6184791\",\n \"0.61747164\",\n \"0.6170765\",\n \"0.6160677\",\n \"0.6152056\",\n \"0.6144066\",\n \"0.61388767\",\n \"0.61302525\",\n \"0.6112476\",\n \"0.6081149\",\n \"0.607\",\n \"0.6051735\",\n \"0.604029\",\n \"0.60337853\",\n \"0.6029674\",\n \"0.60120696\",\n \"0.60120696\",\n \"0.6009754\",\n \"0.5986483\",\n \"0.5937645\",\n \"0.5930558\",\n \"0.5926005\",\n \"0.5924905\",\n \"0.59224415\",\n \"0.59124154\",\n \"0.5905921\",\n \"0.5898826\",\n \"0.58597124\",\n \"0.58515126\",\n \"0.58423406\",\n \"0.5841324\",\n \"0.58361393\",\n \"0.58220744\",\n \"0.58210623\",\n \"0.5813407\",\n \"0.5805428\",\n \"0.5802682\",\n \"0.5791009\",\n \"0.57848555\",\n \"0.5778545\",\n \"0.57538646\",\n \"0.5748494\",\n \"0.573656\",\n \"0.57356566\",\n \"0.5709086\",\n \"0.57055986\",\n \"0.57016253\",\n \"0.57011586\",\n \"0.5683214\",\n \"0.56828433\",\n \"0.5676181\",\n \"0.5673275\",\n \"0.56713116\",\n \"0.566775\",\n \"0.5657689\",\n \"0.56520206\",\n \"0.5651824\",\n \"0.56502855\",\n \"0.56374484\",\n \"0.563015\",\n \"0.5628062\",\n \"0.5627205\",\n \"0.5625866\",\n \"0.56245273\",\n \"0.56233346\",\n \"0.56091404\",\n \"0.5607839\",\n \"0.5594536\",\n \"0.5590267\",\n \"0.5588107\",\n \"0.55809\",\n \"0.55767745\",\n \"0.55760473\",\n \"0.5573404\",\n \"0.5566542\",\n \"0.55654436\",\n \"0.5564986\",\n \"0.5562373\",\n \"0.5561523\",\n \"0.5560079\",\n \"0.55565417\",\n \"0.5555214\",\n \"0.5553577\",\n \"0.5552761\",\n \"0.55441326\",\n \"0.5543488\",\n \"0.5542599\",\n \"0.5539805\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7734525"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78699,"cells":{"query":{"kind":"string","value":"Checks whether the job file passed in as an argument has succeeded or not. Returns true if the job succeeded, false otherwise. If the job failed, a RuntimeError is raised."},"document":{"kind":"string","value":"def _job_succeeded(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> bool:\n if not k8s_job_file.exists():\n raise FileNotFoundError(str(k8s_job_file))\n\n cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'\n\n if dry_run:\n logging.info(cmd)\n return True\n\n p = safe_exec(cmd)\n if not p.stdout:\n return False\n\n retval = 0\n if not p.stdout:\n return False\n\n json_output = json.loads(p.stdout.decode())\n if 'status' not in json_output:\n return False\n\n final_status = ''\n if 'conditions' in json_output['status'] and len(json_output['status']['conditions']) > 0:\n final_status = json_output['status']['conditions'][0]['type']\n\n if final_status == 'Complete' and 'succeeded' in json_output['status']:\n retval = json_output['status']['succeeded']\n elif final_status == 'Failed' and 'failed' in json_output['status']:\n n = int(json_output['status']['failed'])\n logging.error(f'Job {k8s_job_file} failed {n} time(s)')\n # EB-1236, EB-1243: This exception is not caught anywhere - either catch it in caller,\n # or throw UserReportError instead\n raise RuntimeError(f'Job {k8s_job_file} failed {n} time(s)')\n return int(retval) == 1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def isJobRunning ( self ):\n #cmd = \"qstat \" + str(self.jobid)\n \n #magicString='Unknown Job Id' ### magicString _might_ need to be changed if Torque version changes\n #(output, error) = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()\n\n if self.ofile_exists(): #output.find(magicString) >=0 or redhawkStatsRe.search(output):\n self.status = \"finished\"\n return False\n \n\n return True","def check_job_status(job):\n assert isinstance(job, PreprocessJob),\\\n 'job must be a PreprocessJob'\n\n if job.is_finished():\n return True\n\n return True\n \"\"\"\n ye_task = AsyncResult(job.task_id,\n app=preprocess_csv_file)\n\n if ye_task.state == 'SUCCESS':\n\n if ye_task.result['success']:\n\n preprocess_data = ContentFile(json.dumps(ye_task.result['data']))\n\n new_name = 'preprocess_%s.json' % get_alphanumeric_lowercase(8)\n job.metadata_file.save(new_name,\n preprocess_data)\n job.set_state_success()\n\n job.user_message = 'Task completed! Preprocess is available'\n job.save()\n\n else:\n # Didn't work so well\n job.set_state_failure(ye_task.result['message'])\n job.save()\n\n ye_task.forget()\n return True\n\n elif ye_task.state == STATE_FAILURE:\n job.set_state_failure('ye_task failed....')\n job.save()\n ye_task.forget()\n return True\n\n return False\n \"\"\"","def checkSuccess():\n try:\n relin = np.genfromtxt(\"{}reliability.in\".format(basedir), dtype=str)\n # Accurate argument order\n args = [str(\"\\'\"+probpath+\"\\'\"), str(\"\\'\"+obpath+\"\\'\"),\n str(\"\\'\"+outfile+\"\\'\"),\n fcsthr, str(\"\\'\"+variable+\"\\'\"),\n rthresh, sixhour, nbrhd, rbox_bounds[0],\n rbox_bounds[1], rbox_bounds[2], rbox_bounds[3]]\n success = True # Assume success initially\n # Ensure that each argument was placed into the proper line of the\n # reliability input file\n for ind, line in enumerate(relin):\n # If an argument doesn't line up with the rel in arg, set False\n print(str(args[ind]).replace('\\\\', ''), line)\n if (str(args[ind]).replace('\\\\', '') != line):\n success = False\n print(success)\n except:\n success = False\n return success","def checkSuccess():\n try:\n relin = np.genfromtxt(\"{}reliability.in\".format(basedir), dtype=str)\n # Accurate argument order\n args = [str(\"\\'\"+probpath+\"\\'\"), str(\"\\'\"+obpath+\"\\'\"),\n str(\"\\'\"+outfile+\"\\'\"),\n fcsthr, str(\"\\'\"+variable+\"\\'\"),\n rthresh, sixhour, nbrhd, rbox_bounds[0],\n rbox_bounds[1], rbox_bounds[2], rbox_bounds[3]]\n success = True # Assume success initially\n # Ensure that each argument was placed into the proper line of the\n # reliability input file\n for ind, line in enumerate(relin):\n # If an argument doesn't line up with the rel in arg, set False\n print(str(args[ind]).replace('\\\\', ''), line)\n if (str(args[ind]).replace('\\\\', '') != line):\n success = False\n print(success)\n except:\n success = False\n return success","def _ensure_successful_job(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> None:\n if not k8s_job_file.exists():\n raise FileNotFoundError(str(k8s_job_file))\n\n cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'\n\n if dry_run:\n logging.info(cmd)\n return\n\n p = safe_exec(cmd)\n status = json.loads(p.stdout.decode())['status']['succeeded']\n if int(status) != 1:\n raise RuntimeError(f'{k8s_job_file} failed: {p.stderr.decode()}')","def check_file(filename: str):\n if os.path.isfile(filename):\n return True\n else:\n raise FileExistsError","def job_exists(self, job):\n\n with open(os.devnull, 'w') as devnull:\n result = subprocess.call(self.cli + [PlatformJenkinsJavaCLI.GET_JOB, job.name], stdout=devnull)\n\n return result == 0","def read_success():\n success_file = os.path.join(os.path.dirname(__file__), 'success')\n return os.path.exists(success_file)","def _setJob_checkShot(shotPath):\n\tvalid = True\n\n\tjobPath = os.path.split(shotPath)[0]\n\t#jobDataDir = os.path.join(jobPath, os.environ['IC_METADATA'])\n\tshotDataDir = os.path.join(shotPath, os.environ['IC_METADATA'])\n\n\t# if not os.path.isdir(jobDataDir):\n\t# \tvalid = False\n\n\tif not os.path.isdir(shotDataDir):\n\t\tvalid = False\n\n\treturn valid","def is_valid_file(parser, arg):\n if not os.path.exists(arg):\n parser.error(\"The file %s does not exist!\" % arg)\n else:\n return arg","def succeeded(self):\n output = self.__call__()\n if output.succeeded:\n return output or True\n return False","def _has_error(self):\n # Public interface is given by get_status instead.\n # TODO: Cache result if reached execution with no error\n try:\n # If there is something in the error file:\n if path.getsize(path.join(self.run_dir, \"err.txt\")) > 0:\n return True\n except FileNotFoundError:\n pass\n try:\n with open(path.join(self.run_dir, \"out.txt\"), \"r\") as f:\n text = f.read()\n # TODO: Depending on the file size, the following might be better. Investigate this.\n # text = \"\".join(head(path.join(self.run_dir, \"out.txt\"), 300)+tail(path.join(self.run_dir, \"out.txt\"), 10))\n\n # TODO: The commented option is slower (even if compiled) than this one. Investigate.\n if \"(*error*)\" in text or re.search(\"Error reading .* parameters\", text) or re.search(\n \"MPI_ABORT was invoked\", text):\n # if re.search(\"\\(\\*error\\*\\)|Error reading .* parameters|MPI_ABORT was invoked\",text):\n return True\n else:\n return False\n except FileNotFoundError:\n return False","def _check_job_status(self):\n try:\n status = self.ee2.check_job_canceled({\"job_id\": self.job_id})\n except Exception as e:\n self.logger.error(\n f\"Warning: Job cancel check failed due to {e}. However, the job will continue to run.\"\n )\n return True\n if status.get(\"finished\", False):\n return False\n return True","def test_job_exists():\n with tempfile.TemporaryDirectory() as STATUS_DIR:\n Status.add_job(STATUS_DIR, 'generation', 'test1',\n job_attrs={'job_status': 'submitted'})\n exists = Status.job_exists(STATUS_DIR, 'test1')\n assert exists","def is_valid_file(parser, arg):\n\n if not os.path.isfile(arg):\n parser.error('The file {} does not exist!'.format(arg))\n else:\n return arg","def is_valid_file(parser, arg):\n if not os.path.isfile(arg):\n parser.error(\"The file %s does not seem to be a file at all! Exiting for safety reasons.\" %arg)\n sys.exit(1)\n else:\n if validate_input(arg):\n return True\n else:\n print \"Invalid JSON. Exiting\"\n sys.exit(1)","def check_file_exist(self):\n return False","def verify_one(self, job_id, file_path):\n status = self.check_file(file_path)\n with db.within_session(self.config, self.logger) as session:\n job = session.query(Job).filter(Job.id == job_id).one()\n if status:\n self.logger.info(\"Job {} for host {} is OK\"\n .format(job.id, job.host.name))\n job.status = JobStatus.VERIFIED\n else:\n self.logger.warning(\"Job {} for host {} is NOT OK\"\n .format(job_id, job.host.name))\n job.status = JobStatus.FAILED","def check_for_assemble_file(task_file):\n if not os.path.exists(task_file):\n print_failure_msg(\"{} file is missing\".format(task_file))\n exit(127)\n return True","def check_exist(filename, status):\n\n if (status == \"r\"):\n # check to see if it exists for reading\n # (i.e. must be present)\n if (not (os.path.exists(filename))):\n print(f\"Couldn't open input file: {filename}.\")\n return False\n else:\n # check to see if it exists for writing\n # (i.e. must not exist or clobber=yes)\n if (os.path.exists(filename)):\n if (status == \"w\"):\n return True\n else:\n return False\n\n return True","def is_valid_file(args):\n if args.file is not None:\n return True\n return False","def is_valid_file(parser, arg):\n arg = os.path.abspath(arg)\n if not os.path.exists(arg):\n parser.error(\"The file %s does not exist!\" % arg)\n else:\n return arg","def checkExist(self,fname,status):\n\n if (self.status == \"r\"):\n # Checks to see if it exists for reading\n # Which means it must be present\n\n if (not (os.path.exists(self.fname))):\n print(f\"Couldn't open input file: {self.fname}\")\n return False\n else:\n # Check to see if exists for reading\n # (i.e. must not exist)\n if (os.path.exists(self.fname)):\n print(f\"File {self.fname} already exists.\")\n return False\n\n return True","def checkExist(self,fname,status):\n\n if (self.status == \"r\"):\n # Checks to see if it exists for reading\n # Which means it must be present\n\n if (not (os.path.exists(self.fname))):\n print(f\"Couldn't open input file: {self.fname}\")\n return False\n else:\n # Check to see if exists for reading\n # (i.e. must not exist)\n if (os.path.exists(self.fname)):\n print(f\"File {self.fname} already exists.\")\n return False\n\n return True","def check(filepath: str) -> bool:\n\n logging.debug(filepath, extra=dict(status=\"checking\"))\n\n try:\n with open(filepath) as f:\n toml.load(f)\n except toml.TomlDecodeError as err:\n logging.error(filepath, extra=dict(status=err.msg))\n return False\n\n logging.info(filepath, extra=dict(status=\"ok\"))\n return True","def _is_valid_file(arg: str) -> str:\n if not os.path.exists(arg):\n raise FileNotFoundError(\"%s does not exist\" % arg)\n return arg","def verify_job(self, job_id):\n file_path = None\n self.logger.info(\"Started verify with job_id #{}\".format(job_id))\n with db.within_session(self.config, self.logger) as session:\n file_path, = session.query(\n Job.file_path\n ).filter(Job.id == job_id).one()\n return self.verify_one(job_id, file_path)","def job_exists(self, job_id):\n\n return True if self.get_status(job_id) else False","def preliminary_file_check(self):\n\n if self.has_error():\n return False\n\n if not self.filepath:\n self.add_error(\"A file was specified!\")\n return False\n\n if not isfile(self.filepath):\n self.add_error(\"The file was not found: %s\" % basename(self.filepath))\n return False\n\n if getsize(self.filepath) < 1:\n self.add_error(\"The file is empty (no bytes): %s\" % basename(self.filepath))\n return False\n\n if self.file_ext in ['xls', 'xlsx']:\n self.is_excel = True\n\n return True","def fileCheck(filename):\n if not os.path.isfile(filename):\n print('File: ' + filename + ' not found. Exiting...', file=sys.stderr)\n sys.exit(1)","def file_exist() -> bool:\n pass","def isfailure(self):\n\n return self.proc.returncode != 0","def validate_input_file(self):\r\n return os.path.isfile(self.input_file)","def _check_for_finished_job(self):\n raise NotImplementedError","def isFinished(self):\r\n try:\r\n output = Popen(\"qstat | grep \"+self.jobId, shell=True, stdout=PIPE, stderr=PIPE).communicate()[0]\r\n if self.jobId in output:\r\n if output.split()[4] == \"Eqw\":\r\n #If the job fails, print a warning, and wait a minute so the user can check why the job fails,\r\n #before resubmitting the job.\r\n logging.warning(\"job \" + output.split()[2] + \" failed to run, resubmitting in one minute\")\r\n time.sleep(60)\r\n output = Popen(\"qdel \"+self.jobId, shell=True, stdout=PIPE, stderr=PIPE).communicate()[0]\r\n self.submit()\r\n return False\r\n else:\r\n logging.info(\"job with ID: \" + self.jobId + \" is finished.\")\r\n return True\r\n \r\n except ValueError:\r\n logging.info(\"Error: waiting for not submitted job...\")","def wait_on_job(self, delay=10):\n while self.isJobRunning() == True:\n time.sleep(delay)\n return self.ofile_exists()","def check_exist(filename, status, clobber = globclob):\n\n if (status == \"r\"):\n # check to see if it exists for reading\n # (i.e. must be present)\n if (not (os.path.exists(filename))):\n print(f\"Couldn't open input file: {filename}.\")\n return False\n else:\n # check to see if it exists for writing\n # (i.e. must not exist or clobber=yes)\n if (os.path.exists(filename)):\n if (clobber):\n os.remove(filename)\n else:\n print(f\"File {filename} already exists and clobber = no\")\n return False\n\n return True","def _IsBuildSuccessful(build_data):\n if build_data.get('steps'):\n for item in build_data.get('steps'):\n # The 'results' attribute of each step consists of two elements,\n # results[0]: This represents the status of build step.\n # See: http://docs.buildbot.net/current/developer/results.html\n # results[1]: List of items, contains text if step fails, otherwise empty.\n if (item.get('name') == 'package_build' and\n item.get('isFinished') and\n item.get('results')[0] in OK):\n return True\n return False","def _check_file_exists(self, filename):\n if not os.path.exists(filename):\n print('\\n[-] ERROR: %s is not at the specified path! \\\n Please check the filepath and filename...' \n %filename)\n return False\n return True","def fileCheck(path, filestub, suffix ):\n fpath = str(\"%s/%s.%s\" % (path, filestub, suffix) )\n try:\n if (os.path.isfile(fpath) is True):\n return True\n\n except:\n print(\"Error when testing for file %s. Halting\" % fpath )\n sys.exit()\n\n return False","def check_file(path):\n if not os.path.exists(path):\n raise RuntimeError('path [%s] does not exist' % path)\n if not os.path.isfile(path):\n raise RuntimeError('path [%s] is no file' % path)\n if not os.access(path, os.R_OK):\n raise RuntimeError('file [%s] cannot be read' % path)\n if not os.path.getsize(path) > 0:\n raise RuntimeError('file [%s] is 0KB' % path)\n else:\n logging.debug('file [%s] checked successfully', path)","def FileCheck(fn):\n try:\n open(fn, \"r\")\n return 1\n except IOError:\n print(\"Error: File does not exist.\")\n return 0","def is_update_success():\n file_success = os.getcwd() + \"\\\\last_success.txt\"\n if os.path.exists(file_success):\n return True\n else:\n return False","def readjob(job):\n with open(job) as f:\n try:\n jobdefn = json.load(f)\n except ValueError as e:\n job_logger.error('Cannont load job json: %s', e)\n return False\n else:\n try:\n validate(instance=jobdefn, schema=jobschema)\n except Exception as e:\n logecho(str(e), level='error')\n return False\n else:\n return jobdefn","def check_job_exists( job_list, analysis_group_id, reprocess_config_id):\n for job in job_list:\n struct = JSONMessage.unserialize(job.input_message)\n\n if( int( struct.analysis_group_id ) == int( analysis_group_id ) and \\\n int( struct.reprocess_config_id ) == int( reprocess_config_id ) ):\n return 1\n return 0","def check_file_flag(file):\n return process_file_flag(file, None)","def exists(self, args):\n file_path = self.path(args)\n return os.path.isfile(file_path)","def check_status(self) -> bool:\n ct_status = self.status()\n if ct_status >> 3:\n raise RuntimeError(\n \"Uploading of data to the command table failed \"\n \"due to a JSON parsing error.\"\n )\n return ct_status == 1","def run_pylint(self, fname):\n if '.py' not in fname:\n return False\n if not op.isfile(fname):\n self.logging.info('------------------------------------------------------------------')\n self.logging.info(\"FILE {} DOES NOT EXIST.\".format(fname))\n self.logging.info('------------------------------------------------------------------')\n self.logging.info('\\n')\n return False\n self.logging.info(\"{}\\n\".format(fname))\n self.fname = fname\n if self.rcfile and op.isfile(self.rcfile):\n command_arg = [fname, '--rcfile', self.rcfile, '--score', 'no']\n else:\n command_arg = [fname, '--score', 'no']\n try:\n with redirect_stdout(PrintLogger(name=\"pylint\", log_level=\"INFO\")):\n if int(pylint.__version__[0]) < 2:\n self.results = Run(command_arg, exit=False) # pylint: disable=unexpected-keyword-arg\n else:\n # Use the default one\n self.results = Run(command_arg, do_exit=False) # pylint: disable=unexpected-keyword-arg\n return True\n except Exception as error: # pylint: disable=broad-except\n # We want to crash if ANYTHING goes wrong\n self.logging.warning('------------------------------------------------------------------')\n self.logging.warning(\"PYLINT CRASHED WHILE HANDLING {}\".format(fname))\n self.logging.warning(\"{}: {}\".format(type(error), error.args))\n self.logging.warning('------------------------------------------------------------------')\n self.logging.info('\\n')\n self.failed_files.append(fname)\n return False","def test_jobs_successful(self):\n\n workspace = storage_test_utils.create_workspace()\n file1 = storage_test_utils.create_file()\n data_dict = {\n 'version': '1.0',\n 'input_data': [{\n 'name': 'INPUT_IMAGE',\n 'file_id': file1.id\n }],\n 'output_data': [{\n 'name': 'output_file_pngs',\n 'workspace_id': workspace.id\n }]}\n\n secret_configuration = {\n 'version': '6',\n 'priority': 50,\n 'output_workspaces': {'default': storage_test_utils.create_workspace().name},\n 'settings': {\n 'DB_HOST': 'som.host.name',\n 'DB_PASS': 'secret_password'\n }\n }\n\n seed_job_type = job_test_utils.create_seed_job_type(configuration=secret_configuration)\n seed_job = job_test_utils.create_job(job_type=seed_job_type, status='RUNNING', input=data_dict)\n\n url = '/%s/jobs/%d/' % (self.api, seed_job.id)\n response = self.client.generic('GET', url)\n result = json.loads(response.content)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n self.assertEqual(result['configuration']['priority'],50)\n self.assertNotIn('DB_PASS', result['configuration']['settings'])","def scriptChecker(filename):\n if not os.path.exists(filename):\n print 'ERROR: %s does not exist' % filename\n import errno\n return errno.ENOENT\n\n # The script-checker program is called directly. If we call the code\n # from this python interpreter, any changes to an observing script will\n # not be noticed.\n #\n # This is due to the way python works: a second import statement of the\n # same module does nothing!\n import subprocess\n script = helpers.getCarmaBuildPath() + '/scripts/script-checker'\n cmd = [script, filename]\n ret = subprocess.call(cmd)\n if ret != 0:\n print 'ERROR: script-checker returned status code:', ret","def _validate_jobs(\n self,\n check_nlst_warn: bool = False\n ):\n counter = 0\n for job in self.jobs:\n counter += 1\n print(job.job_id)\n if counter == 0:\n ignore_restarts = False\n else:\n ignore_restarts = True\n\n check_input_files(\n hrldas_namelist=job.hrldas_namelist,\n hydro_namelist=job.hydro_namelist,\n sim_dir=os.getcwd(),\n ignore_restarts=ignore_restarts,\n check_nlst_warn=check_nlst_warn\n )","def fileCheck(filePath):\n if not os.path.isfile(filePath):\n return False\n return True","def file_ready(file_path):\n while not os.path.exists(file_path):\n time.sleep(1)\n if os.path.isfile(file_path):\n return True\n raise ValueError(\"%s isn't a file!\" % file_path)","def checkRunning(procname):\n return procdata.checkRunning(procname)","def _job_was_successful(self, status):\n success = True\n\n # https://cloud.google.com/life-sciences/docs/reference/rest/v2beta/Event\n for event in status[\"metadata\"][\"events\"]:\n\n logger.debug(event[\"description\"])\n\n # Does it always result in fail for other failure reasons?\n if \"failed\" in event:\n success = False\n action = event.get(\"failed\")\n logger.debug(\"{}: {}\".format(action[\"code\"], action[\"cause\"]))\n\n elif \"unexpectedExitStatus\" in event:\n action = event.get(\"unexpectedExitStatus\")\n\n if action[\"exitStatus\"] != 0:\n success = False\n\n # Provide reason for the failure (desc includes exit code)\n msg = \"%s\" % event[\"description\"]\n if \"stderr\" in action:\n msg += \": %s\" % action[\"stderr\"]\n logger.debug(msg)\n\n return success","def FileExists(file):\n return os.path.exists(file)","def succeed(self) -> bool:\n return self.errorCode is None or len(self.errorCode) < 1","def check_status(job):\n client = get_dropbox_client()\n\n try:\n return client.metadata(\n '/Video Automation Platform/jobs/{job}/{job}.png'.format(job=job))\n\n except ErrorResponse:\n return False","def file_exists(self):\n return os.path.exists(self._fileName)","def was_successful(self):\n return self._build_proto.status == common.SUCCESS","def check_slurm_job_submission(expected_name):\n cmd = ['scontrol', 'show', 'job']\n job_id = 0\n found_job = False\n while True:\n while True:\n try:\n out = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()[0]\n break\n except:\n sleep(1)\n out = out.split('\\n')\n if 'error' in out[0]:\n sleep(1)\n msg = 'Error checking job status for {0}'.format(expected_name)\n logging.warning(msg)\n continue\n for line in out:\n for word in line.split():\n if 'JobId' in word:\n index = word.find('=') + 1\n job_id = int(word[index:])\n # continue\n if 'Name' in word:\n index = word.find('=') + 1\n if word[index:] == expected_name:\n found_job = True\n\n if found_job and job_id != 0:\n return found_job, job_id\n sleep(1)\n return found_job, job_id","def check_input_file(self):\n\n # Mission critical parameters\n if self.jobname is None:\n sys.exit('Batch_emto.check_input_file: \\'jobname\\' has to be given!')\n\n if self.runtime is None:\n self.runtime = \"48:00:00\"\n if self.emtopath is None:\n self.emtopath = \"./\"\n if self.EMTOdir is None:\n self.EMTOdir = \"$HOME/EMTO5.8/\"\n if self.runKGRN is None:\n self.runKGRN = True\n if self.runKFCD is None:\n self.runKFCD = True\n return","def does_file_exist(self, fn):\n if True:\n print(f\"-=- {fn} found.\")\n return True\n else:\n print(f\"-!- {fn} not found. Try again\")\n return False","def file_exists(filename):\n return os.path.exists(filename)","def exists(self, prefix, args=()):\n file_path = self.path(prefix, args)\n return os.path.isfile(file_path)","def exist(self):\n return self.file_path.exists()","def should_notify(job):\n if job.result not in (Result.failed, Result.passed):\n return\n\n parent = Job.query.join(\n Source, Source.id == Job.source_id,\n ).filter(\n Source.patch_id == None, # NOQA\n Source.revision_sha != job.build.source.revision_sha,\n Job.project == job.project,\n Job.date_created < job.date_created,\n Job.status == Status.finished,\n Job.result.in_([Result.passed, Result.failed]),\n ).order_by(Job.date_created.desc()).first()\n\n # if theres no parent, this job must be at fault\n if parent is None:\n return job.result == Result.failed\n\n if job.result == Result.passed == parent.result:\n return False\n\n current_failures = get_test_failures(job)\n # if we dont have any testgroup failures, then we cannot identify the cause\n # so we must notify the individual\n if not current_failures:\n return True\n\n parent_failures = get_test_failures(parent)\n if parent_failures != current_failures:\n return True\n\n return False","def is_failed(file, validate=None, tmp_dir=None):\n stats = os.stat(file)\n if stats.st_size <= 68:\n if validate is None:\n return True\n try:\n if get_extracted_name(os.path.basename(file)) != os.path.basename(file):\n file = extract_file_if_necessary(file, tmp_dir)\n output = subprocess.check_output([validate, file])\n except subprocess.CalledProcessError:\n output = 'invalid'\n if output == 'invalid':\n return True\n return False","def batch_job_running(self, name):\n if name not in self.batch_jobs:\n raise ValueError(\"job {} doesn't exists\".format(name))\n return name in self.jobs","def test_wrong_job(self):\n job = MockJob()\n container_name = 'container_identifier'\n self._mock_open.return_value.__enter__.return_value.readline. \\\n return_value = container_name\n\n # return an error trying to read file with container name\n self._mock_open.return_value.__enter__.side_effect = [\n PermissionError,\n FileNotFoundError,\n ]\n\n self.assertNotEqual(job.pid, 0)\n # non-zero pid, no container name is found -> refer to ForkSpawner\n validation_result = self._container_spawner.validate(job)\n self._mock_open.assert_called()\n self._mock_fork.assert_called()\n self.assertEqual(validation_result,\n spawner.PROCESS_RUNNING)\n # same check, a different exception\n self.assertEqual(self._container_spawner.validate(job),\n spawner.PROCESS_RUNNING)","def file_exists(filename, verbose=False):\n try:\n os.stat(filename)\n return True\n except (OSError,):\n err = sys.exc_info()[1]\n if verbose:\n logging.error(str(err))\n return False","def _check_analyzed_job(self, job, container):\n self.log(u\"Checking the Job object generated from container\")\n\n self.log(u\"Checking that the Job is not None\")\n if job is None:\n self._failed(u\"Unable to create a Job from the container.\")\n return\n\n self.log(u\"Checking that the Job has at least one Task\")\n if len(job) == 0:\n self._failed(u\"Unable to create at least one Task from the container.\")\n return\n\n if self.rconf[RuntimeConfiguration.JOB_MAX_TASKS] > 0:\n self.log(u\"Checking that the Job does not have too many Tasks\")\n if len(job) > self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]:\n self._failed(u\"The Job has %d Tasks, more than the maximum allowed (%d).\" % (\n len(job),\n self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]\n ))\n return\n\n self.log(u\"Checking that each Task text file is well formed\")\n for task in job.tasks:\n self.log([u\"Checking Task text file '%s'\", task.text_file_path])\n text_file_bstring = container.read_entry(task.text_file_path)\n if (text_file_bstring is None) or (len(text_file_bstring) == 0):\n self._failed(u\"Text file '%s' is empty\" % task.text_file_path)\n return\n self._check_utf8_encoding(text_file_bstring)\n if not self.result.passed:\n self._failed(u\"Text file '%s' is not encoded in UTF-8\" % task.text_file_path)\n return\n self._check_not_empty(text_file_bstring)\n if not self.result.passed:\n self._failed(u\"Text file '%s' is empty\" % task.text_file_path)\n return\n self.log([u\"Checking Task text file '%s': passed\", task.text_file_path])\n self.log(u\"Checking each Task text file is well formed: passed\")","def check_job_status_by_id(job_id):\n print('=' * 40)\n print('check_status_by_job_id', job_id)\n print('=' * 40)\n\n it_worked = check_job_status(job)\n if it_worked:\n return ok_resp(job)\n\n user_msg = ('PreprocessJob still in process: %s') % (job_id)\n return err_resp(user_msg)","def successful(self) -> bool:\n pass","def file_exists(filename: str) -> bool:\n\n return os.path.exists(filename)","def CheckIfJobFinished(jobid, numseq, to_email, g_params): # {{{\n bsname = \"job_final_process\"\n path_result = os.path.join(g_params['path_static'], 'result')\n rstdir = os.path.join(path_result, jobid)\n gen_logfile = g_params['gen_logfile']\n gen_errfile = g_params['gen_errfile']\n name_server = g_params['name_server']\n g_params['jobid'] = jobid\n g_params['numseq'] = numseq\n g_params['to_email'] = to_email\n jsonfile = os.path.join(rstdir, f\"{bsname}.json\")\n myfunc.WriteFile(json.dumps(g_params, sort_keys=True), jsonfile, \"w\")\n binpath_script = os.path.join(g_params['webserver_root'], \"env\", \"bin\")\n\n finished_idx_file = \"%s/finished_seqindex.txt\"%(rstdir)\n failed_idx_file = \"%s/failed_seqindex.txt\"%(rstdir)\n py_scriptfile = os.path.join(binpath_script, f\"{bsname}.py\")\n finished_idx_list = []\n failed_idx_list = []\n if os.path.exists(finished_idx_file):\n finished_idx_list = list(set(myfunc.ReadIDList(finished_idx_file)))\n if os.path.exists(failed_idx_file):\n failed_idx_list = list(set(myfunc.ReadIDList(failed_idx_file)))\n\n lockname = f\"{bsname}.lock\"\n lock_file = os.path.join(g_params['path_result'], g_params['jobid'],\n lockname)\n\n num_processed = len(finished_idx_list)+len(failed_idx_list)\n if num_processed >= numseq: # finished\n if ('THRESHOLD_NUMSEQ_CHECK_IF_JOB_FINISH' in g_params\n and numseq <= g_params['THRESHOLD_NUMSEQ_CHECK_IF_JOB_FINISH']):\n cmd = [\"python\", py_scriptfile, \"-i\", jsonfile]\n (isSubmitSuccess, t_runtime) = webcom.RunCmd(cmd, gen_logfile, gen_errfile)\n elif not os.path.exists(lock_file):\n bash_scriptfile = f\"{rstdir}/{bsname},{name_server},{jobid}.sh\"\n code_str_list = []\n code_str_list.append(\"#!/bin/bash\")\n cmdline = f\"python {py_scriptfile} -i {jsonfile}\"\n code_str_list.append(cmdline)\n code = \"\\n\".join(code_str_list)\n myfunc.WriteFile(code, bash_scriptfile, mode=\"w\", isFlush=True)\n os.chmod(bash_scriptfile, 0o755)\n os.chdir(rstdir)\n cmd = ['sbatch', bash_scriptfile]\n cmdline = \" \".join(cmd)\n verbose = False\n if 'DEBUG' in g_params and g_params['DEBUG']:\n verbose = True\n webcom.loginfo(\"Run cmdline: %s\"%(cmdline), gen_logfile)\n (isSubmitSuccess, t_runtime) = webcom.RunCmd(cmd, gen_logfile, gen_errfile, verbose)\n if 'DEBUG' in g_params and g_params['DEBUG']:\n webcom.loginfo(\"isSubmitSuccess: %s\"%(str(isSubmitSuccess)), gen_logfile)","def check_file(self) -> bool:\n log.info(\"Checking if the database file exists.\")\n try:\n with open(self.host, 'r'):\n log.info(\"Database file exists. Checking it's integrity\")\n except FileNotFoundError:\n log.error(\"The database file doesn't exists.\")\n return False\n else:\n try:\n self.setup_tables()\n return True\n except Exception:\n log.critical(\"An exception was raised.\")\n raise","def is_valid_file(input_file):\n if not os.path.isfile(input_file):\n print('File \\'{}\\' not found.'.format(input_file))\n exit(1)\n return input_file","def file_exists(self):\n if os.path.isfile(self.file_name):\n return True\n else:\n return False","def file_exists(self):\r\n if os.path.exists(self.file_path):\r\n return True\r\n else:\r\n return False","def exists(cls, job_id: str, connection: Optional['Redis'] = None) -> bool:\n if not connection:\n connection = resolve_connection()\n job_key = cls.key_for(job_id)\n job_exists = connection.exists(job_key)\n return bool(job_exists)","def check_file_existence(self, filename):\n try:\n for sample in TimeoutingSampler(\n config.GAHOOKS_TIMEOUT, 1, self.machine.fs.exists,\n \"/tmp/%s\" % filename\n ):\n if sample:\n return True\n except APITimeout:\n return False","def _check_job_completeness(self, jobs):\n for job in concurrent.futures.as_completed(jobs):\n if job.exception():\n raise (job.exception())","def test_successful_job(self, _is_coalesced):\n successful_job = json.loads(BASE_JSON % (SUCCESS, 1433166610, 1, 1433166609))[0]\n self.assertEquals(self.query_api.get_job_status(successful_job), SUCCESS)","def fileExist(file):\r\n return os.path.exists(file) and os.path.isfile(file)","def checkjob(sid, jid):\n with slycat.web.server.remote.get_session(sid) as session:\n return session.checkjob(jid)","def file_is_missing(filename, allow_missing=True):\n\n if os.path.exists(filename):\n return False\n if not allow_missing:\n raise RuntimeError(f\"File {filename} does not exist\")\n print(f\"Warning: file {filename} does not exist\")\n return True","def file_exists(filename):\n return os.path.isfile(filename)","def check_wait_for_copy_complete(jobs):\n for j in jobs:\n stdout, stderr = j.communicate()\n\n if j.returncode != 0:\n output = stdout or stderr or ''\n error = 'COPY FAILED with {0}: {1}'.format(j.returncode, output.strip())\n raise RuntimeError(error)","def _is_job_finished(self, job_id):\n complete, rc, status, result, task = False, 0, None, None, None\n job = self.get_job_by_id(job_id)\n if job:\n status = job['status']\n try:\n result, task = job['result'], job['task']\n except KeyError:\n pass\n if status.lower() == SUCCEEDED:\n complete = True\n elif status.lower() in INCOMPLETE_LIST:\n complete = False\n else:\n rc, complete = -1, True\n return complete, result, rc, status, task","def service_mesh_job_check(container_name):\n complete = False\n log.info(\"Checking if %s is complete\", container_name)\n try:\n response = coreV1Api.list_namespaced_pod(namespace=namespace, watch=False)\n for item in response.items:\n # container_statuses can be None, which is non-iterable.\n if item.status.container_statuses is None:\n continue\n for container in item.status.container_statuses:\n if container.name == container_name and item.status.phase == \"Running\":\n name = read_name(item)\n log.info(\"Container Details %s \", container)\n log.info(\"Container Status %s \", container.state.terminated)\n\n if container.state.terminated:\n log.info(\"Container Terminated with reason %s \", container.state.terminated.reason)\n complete = True\n\n except ApiException as exc:\n log.error(\"Exception when calling read_namespaced_job_status: %s\\n\",\n exc)\n return complete","def check_if_file_exists(file: str) -> Union[str, None]:\n if not os.path.exists(file) and not os.path.exists(f'{file}_qforce'):\n sys.exit(f'ERROR: \"{file}\" does not exist.\\n')\n return file","def if_file_exist(file_name: str) -> bool:\n\n exists = os.path.exists(file_name)\n\n return exists","def verify(filename):\n verified = True\n errs = []\n\n if not os.path.exists(filename):\n verified = False\n errs.append('No such file: %s' % filename)\n \n errs = ['[!] ' + e for e in errs]\n\n if len(errs) > 0:\n print('\\n'.join(errs))\n\n return verified","def _check_job_status(self) -> str:\n self._assert_job_created()\n\n r = requests.post(\n f'https://{cc.ROUTE_PREFIX}.stratodem.com/jobs/status',\n headers=dict(\n Authorization=f'Bearer {get_api_token()}',\n ),\n json=dict(job_id=self._job_id)\n )\n\n if not r.status_code == 200:\n raise APIQueryFailedException('Failed to determine job status')\n\n r = r.json()\n\n if not r['success']:\n raise APIQueryFailedException(r)\n else:\n return r['message']","def check_sp_job(self,\n label: str,\n job: 'JobAdapter',\n ):\n if 'mrci' in self.sp_level.method and job.level is not None and 'mrci' not in job.level.method:\n # This is a CCSD job ran before MRCI. Spawn MRCI\n self.run_sp_job(label)\n elif job.job_status[1]['status'] == 'done':\n self.post_sp_actions(label,\n sp_path=os.path.join(job.local_path_to_output_file),\n level=job.level,\n )\n # Update restart dictionary and save the yaml restart file:\n self.save_restart_dict()\n if self.species_dict[label].number_of_atoms == 1:\n # save the geometry from the sp job for monoatomic species for which no opt/freq jobs will be spawned\n self.output[label]['paths']['geo'] = job.local_path_to_output_file\n else:\n self.troubleshoot_ess(label=label,\n job=job,\n level_of_theory=job.level,\n )","def codepipeline_success(job_id):\n try:\n codepipeline = boto3.client('codepipeline')\n codepipeline.put_job_success_result(jobId=job_id)\n LOGGER.info('===SUCCESS===')\n return True\n except ClientError as err:\n LOGGER.error(\"Failed to PutJobSuccessResult for CodePipeline!\\n%s\", err)\n return False","def file_exists(path):\n\n try:\n with open(path):\n return True\n except IOError:\n return False","def chronos_job_is_ready(context, job_name):\n chronos_tools.wait_for_job(context.chronos_client, context.jobs[job_name]['name'])"],"string":"[\n \"def isJobRunning ( self ):\\n #cmd = \\\"qstat \\\" + str(self.jobid)\\n \\n #magicString='Unknown Job Id' ### magicString _might_ need to be changed if Torque version changes\\n #(output, error) = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()\\n\\n if self.ofile_exists(): #output.find(magicString) >=0 or redhawkStatsRe.search(output):\\n self.status = \\\"finished\\\"\\n return False\\n \\n\\n return True\",\n \"def check_job_status(job):\\n assert isinstance(job, PreprocessJob),\\\\\\n 'job must be a PreprocessJob'\\n\\n if job.is_finished():\\n return True\\n\\n return True\\n \\\"\\\"\\\"\\n ye_task = AsyncResult(job.task_id,\\n app=preprocess_csv_file)\\n\\n if ye_task.state == 'SUCCESS':\\n\\n if ye_task.result['success']:\\n\\n preprocess_data = ContentFile(json.dumps(ye_task.result['data']))\\n\\n new_name = 'preprocess_%s.json' % get_alphanumeric_lowercase(8)\\n job.metadata_file.save(new_name,\\n preprocess_data)\\n job.set_state_success()\\n\\n job.user_message = 'Task completed! Preprocess is available'\\n job.save()\\n\\n else:\\n # Didn't work so well\\n job.set_state_failure(ye_task.result['message'])\\n job.save()\\n\\n ye_task.forget()\\n return True\\n\\n elif ye_task.state == STATE_FAILURE:\\n job.set_state_failure('ye_task failed....')\\n job.save()\\n ye_task.forget()\\n return True\\n\\n return False\\n \\\"\\\"\\\"\",\n \"def checkSuccess():\\n try:\\n relin = np.genfromtxt(\\\"{}reliability.in\\\".format(basedir), dtype=str)\\n # Accurate argument order\\n args = [str(\\\"\\\\'\\\"+probpath+\\\"\\\\'\\\"), str(\\\"\\\\'\\\"+obpath+\\\"\\\\'\\\"),\\n str(\\\"\\\\'\\\"+outfile+\\\"\\\\'\\\"),\\n fcsthr, str(\\\"\\\\'\\\"+variable+\\\"\\\\'\\\"),\\n rthresh, sixhour, nbrhd, rbox_bounds[0],\\n rbox_bounds[1], rbox_bounds[2], rbox_bounds[3]]\\n success = True # Assume success initially\\n # Ensure that each argument was placed into the proper line of the\\n # reliability input file\\n for ind, line in enumerate(relin):\\n # If an argument doesn't line up with the rel in arg, set False\\n print(str(args[ind]).replace('\\\\\\\\', ''), line)\\n if (str(args[ind]).replace('\\\\\\\\', '') != line):\\n success = False\\n print(success)\\n except:\\n success = False\\n return success\",\n \"def checkSuccess():\\n try:\\n relin = np.genfromtxt(\\\"{}reliability.in\\\".format(basedir), dtype=str)\\n # Accurate argument order\\n args = [str(\\\"\\\\'\\\"+probpath+\\\"\\\\'\\\"), str(\\\"\\\\'\\\"+obpath+\\\"\\\\'\\\"),\\n str(\\\"\\\\'\\\"+outfile+\\\"\\\\'\\\"),\\n fcsthr, str(\\\"\\\\'\\\"+variable+\\\"\\\\'\\\"),\\n rthresh, sixhour, nbrhd, rbox_bounds[0],\\n rbox_bounds[1], rbox_bounds[2], rbox_bounds[3]]\\n success = True # Assume success initially\\n # Ensure that each argument was placed into the proper line of the\\n # reliability input file\\n for ind, line in enumerate(relin):\\n # If an argument doesn't line up with the rel in arg, set False\\n print(str(args[ind]).replace('\\\\\\\\', ''), line)\\n if (str(args[ind]).replace('\\\\\\\\', '') != line):\\n success = False\\n print(success)\\n except:\\n success = False\\n return success\",\n \"def _ensure_successful_job(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> None:\\n if not k8s_job_file.exists():\\n raise FileNotFoundError(str(k8s_job_file))\\n\\n cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'\\n\\n if dry_run:\\n logging.info(cmd)\\n return\\n\\n p = safe_exec(cmd)\\n status = json.loads(p.stdout.decode())['status']['succeeded']\\n if int(status) != 1:\\n raise RuntimeError(f'{k8s_job_file} failed: {p.stderr.decode()}')\",\n \"def check_file(filename: str):\\n if os.path.isfile(filename):\\n return True\\n else:\\n raise FileExistsError\",\n \"def job_exists(self, job):\\n\\n with open(os.devnull, 'w') as devnull:\\n result = subprocess.call(self.cli + [PlatformJenkinsJavaCLI.GET_JOB, job.name], stdout=devnull)\\n\\n return result == 0\",\n \"def read_success():\\n success_file = os.path.join(os.path.dirname(__file__), 'success')\\n return os.path.exists(success_file)\",\n \"def _setJob_checkShot(shotPath):\\n\\tvalid = True\\n\\n\\tjobPath = os.path.split(shotPath)[0]\\n\\t#jobDataDir = os.path.join(jobPath, os.environ['IC_METADATA'])\\n\\tshotDataDir = os.path.join(shotPath, os.environ['IC_METADATA'])\\n\\n\\t# if not os.path.isdir(jobDataDir):\\n\\t# \\tvalid = False\\n\\n\\tif not os.path.isdir(shotDataDir):\\n\\t\\tvalid = False\\n\\n\\treturn valid\",\n \"def is_valid_file(parser, arg):\\n if not os.path.exists(arg):\\n parser.error(\\\"The file %s does not exist!\\\" % arg)\\n else:\\n return arg\",\n \"def succeeded(self):\\n output = self.__call__()\\n if output.succeeded:\\n return output or True\\n return False\",\n \"def _has_error(self):\\n # Public interface is given by get_status instead.\\n # TODO: Cache result if reached execution with no error\\n try:\\n # If there is something in the error file:\\n if path.getsize(path.join(self.run_dir, \\\"err.txt\\\")) > 0:\\n return True\\n except FileNotFoundError:\\n pass\\n try:\\n with open(path.join(self.run_dir, \\\"out.txt\\\"), \\\"r\\\") as f:\\n text = f.read()\\n # TODO: Depending on the file size, the following might be better. Investigate this.\\n # text = \\\"\\\".join(head(path.join(self.run_dir, \\\"out.txt\\\"), 300)+tail(path.join(self.run_dir, \\\"out.txt\\\"), 10))\\n\\n # TODO: The commented option is slower (even if compiled) than this one. Investigate.\\n if \\\"(*error*)\\\" in text or re.search(\\\"Error reading .* parameters\\\", text) or re.search(\\n \\\"MPI_ABORT was invoked\\\", text):\\n # if re.search(\\\"\\\\(\\\\*error\\\\*\\\\)|Error reading .* parameters|MPI_ABORT was invoked\\\",text):\\n return True\\n else:\\n return False\\n except FileNotFoundError:\\n return False\",\n \"def _check_job_status(self):\\n try:\\n status = self.ee2.check_job_canceled({\\\"job_id\\\": self.job_id})\\n except Exception as e:\\n self.logger.error(\\n f\\\"Warning: Job cancel check failed due to {e}. However, the job will continue to run.\\\"\\n )\\n return True\\n if status.get(\\\"finished\\\", False):\\n return False\\n return True\",\n \"def test_job_exists():\\n with tempfile.TemporaryDirectory() as STATUS_DIR:\\n Status.add_job(STATUS_DIR, 'generation', 'test1',\\n job_attrs={'job_status': 'submitted'})\\n exists = Status.job_exists(STATUS_DIR, 'test1')\\n assert exists\",\n \"def is_valid_file(parser, arg):\\n\\n if not os.path.isfile(arg):\\n parser.error('The file {} does not exist!'.format(arg))\\n else:\\n return arg\",\n \"def is_valid_file(parser, arg):\\n if not os.path.isfile(arg):\\n parser.error(\\\"The file %s does not seem to be a file at all! Exiting for safety reasons.\\\" %arg)\\n sys.exit(1)\\n else:\\n if validate_input(arg):\\n return True\\n else:\\n print \\\"Invalid JSON. Exiting\\\"\\n sys.exit(1)\",\n \"def check_file_exist(self):\\n return False\",\n \"def verify_one(self, job_id, file_path):\\n status = self.check_file(file_path)\\n with db.within_session(self.config, self.logger) as session:\\n job = session.query(Job).filter(Job.id == job_id).one()\\n if status:\\n self.logger.info(\\\"Job {} for host {} is OK\\\"\\n .format(job.id, job.host.name))\\n job.status = JobStatus.VERIFIED\\n else:\\n self.logger.warning(\\\"Job {} for host {} is NOT OK\\\"\\n .format(job_id, job.host.name))\\n job.status = JobStatus.FAILED\",\n \"def check_for_assemble_file(task_file):\\n if not os.path.exists(task_file):\\n print_failure_msg(\\\"{} file is missing\\\".format(task_file))\\n exit(127)\\n return True\",\n \"def check_exist(filename, status):\\n\\n if (status == \\\"r\\\"):\\n # check to see if it exists for reading\\n # (i.e. must be present)\\n if (not (os.path.exists(filename))):\\n print(f\\\"Couldn't open input file: {filename}.\\\")\\n return False\\n else:\\n # check to see if it exists for writing\\n # (i.e. must not exist or clobber=yes)\\n if (os.path.exists(filename)):\\n if (status == \\\"w\\\"):\\n return True\\n else:\\n return False\\n\\n return True\",\n \"def is_valid_file(args):\\n if args.file is not None:\\n return True\\n return False\",\n \"def is_valid_file(parser, arg):\\n arg = os.path.abspath(arg)\\n if not os.path.exists(arg):\\n parser.error(\\\"The file %s does not exist!\\\" % arg)\\n else:\\n return arg\",\n \"def checkExist(self,fname,status):\\n\\n if (self.status == \\\"r\\\"):\\n # Checks to see if it exists for reading\\n # Which means it must be present\\n\\n if (not (os.path.exists(self.fname))):\\n print(f\\\"Couldn't open input file: {self.fname}\\\")\\n return False\\n else:\\n # Check to see if exists for reading\\n # (i.e. must not exist)\\n if (os.path.exists(self.fname)):\\n print(f\\\"File {self.fname} already exists.\\\")\\n return False\\n\\n return True\",\n \"def checkExist(self,fname,status):\\n\\n if (self.status == \\\"r\\\"):\\n # Checks to see if it exists for reading\\n # Which means it must be present\\n\\n if (not (os.path.exists(self.fname))):\\n print(f\\\"Couldn't open input file: {self.fname}\\\")\\n return False\\n else:\\n # Check to see if exists for reading\\n # (i.e. must not exist)\\n if (os.path.exists(self.fname)):\\n print(f\\\"File {self.fname} already exists.\\\")\\n return False\\n\\n return True\",\n \"def check(filepath: str) -> bool:\\n\\n logging.debug(filepath, extra=dict(status=\\\"checking\\\"))\\n\\n try:\\n with open(filepath) as f:\\n toml.load(f)\\n except toml.TomlDecodeError as err:\\n logging.error(filepath, extra=dict(status=err.msg))\\n return False\\n\\n logging.info(filepath, extra=dict(status=\\\"ok\\\"))\\n return True\",\n \"def _is_valid_file(arg: str) -> str:\\n if not os.path.exists(arg):\\n raise FileNotFoundError(\\\"%s does not exist\\\" % arg)\\n return arg\",\n \"def verify_job(self, job_id):\\n file_path = None\\n self.logger.info(\\\"Started verify with job_id #{}\\\".format(job_id))\\n with db.within_session(self.config, self.logger) as session:\\n file_path, = session.query(\\n Job.file_path\\n ).filter(Job.id == job_id).one()\\n return self.verify_one(job_id, file_path)\",\n \"def job_exists(self, job_id):\\n\\n return True if self.get_status(job_id) else False\",\n \"def preliminary_file_check(self):\\n\\n if self.has_error():\\n return False\\n\\n if not self.filepath:\\n self.add_error(\\\"A file was specified!\\\")\\n return False\\n\\n if not isfile(self.filepath):\\n self.add_error(\\\"The file was not found: %s\\\" % basename(self.filepath))\\n return False\\n\\n if getsize(self.filepath) < 1:\\n self.add_error(\\\"The file is empty (no bytes): %s\\\" % basename(self.filepath))\\n return False\\n\\n if self.file_ext in ['xls', 'xlsx']:\\n self.is_excel = True\\n\\n return True\",\n \"def fileCheck(filename):\\n if not os.path.isfile(filename):\\n print('File: ' + filename + ' not found. Exiting...', file=sys.stderr)\\n sys.exit(1)\",\n \"def file_exist() -> bool:\\n pass\",\n \"def isfailure(self):\\n\\n return self.proc.returncode != 0\",\n \"def validate_input_file(self):\\r\\n return os.path.isfile(self.input_file)\",\n \"def _check_for_finished_job(self):\\n raise NotImplementedError\",\n \"def isFinished(self):\\r\\n try:\\r\\n output = Popen(\\\"qstat | grep \\\"+self.jobId, shell=True, stdout=PIPE, stderr=PIPE).communicate()[0]\\r\\n if self.jobId in output:\\r\\n if output.split()[4] == \\\"Eqw\\\":\\r\\n #If the job fails, print a warning, and wait a minute so the user can check why the job fails,\\r\\n #before resubmitting the job.\\r\\n logging.warning(\\\"job \\\" + output.split()[2] + \\\" failed to run, resubmitting in one minute\\\")\\r\\n time.sleep(60)\\r\\n output = Popen(\\\"qdel \\\"+self.jobId, shell=True, stdout=PIPE, stderr=PIPE).communicate()[0]\\r\\n self.submit()\\r\\n return False\\r\\n else:\\r\\n logging.info(\\\"job with ID: \\\" + self.jobId + \\\" is finished.\\\")\\r\\n return True\\r\\n \\r\\n except ValueError:\\r\\n logging.info(\\\"Error: waiting for not submitted job...\\\")\",\n \"def wait_on_job(self, delay=10):\\n while self.isJobRunning() == True:\\n time.sleep(delay)\\n return self.ofile_exists()\",\n \"def check_exist(filename, status, clobber = globclob):\\n\\n if (status == \\\"r\\\"):\\n # check to see if it exists for reading\\n # (i.e. must be present)\\n if (not (os.path.exists(filename))):\\n print(f\\\"Couldn't open input file: {filename}.\\\")\\n return False\\n else:\\n # check to see if it exists for writing\\n # (i.e. must not exist or clobber=yes)\\n if (os.path.exists(filename)):\\n if (clobber):\\n os.remove(filename)\\n else:\\n print(f\\\"File {filename} already exists and clobber = no\\\")\\n return False\\n\\n return True\",\n \"def _IsBuildSuccessful(build_data):\\n if build_data.get('steps'):\\n for item in build_data.get('steps'):\\n # The 'results' attribute of each step consists of two elements,\\n # results[0]: This represents the status of build step.\\n # See: http://docs.buildbot.net/current/developer/results.html\\n # results[1]: List of items, contains text if step fails, otherwise empty.\\n if (item.get('name') == 'package_build' and\\n item.get('isFinished') and\\n item.get('results')[0] in OK):\\n return True\\n return False\",\n \"def _check_file_exists(self, filename):\\n if not os.path.exists(filename):\\n print('\\\\n[-] ERROR: %s is not at the specified path! \\\\\\n Please check the filepath and filename...' \\n %filename)\\n return False\\n return True\",\n \"def fileCheck(path, filestub, suffix ):\\n fpath = str(\\\"%s/%s.%s\\\" % (path, filestub, suffix) )\\n try:\\n if (os.path.isfile(fpath) is True):\\n return True\\n\\n except:\\n print(\\\"Error when testing for file %s. Halting\\\" % fpath )\\n sys.exit()\\n\\n return False\",\n \"def check_file(path):\\n if not os.path.exists(path):\\n raise RuntimeError('path [%s] does not exist' % path)\\n if not os.path.isfile(path):\\n raise RuntimeError('path [%s] is no file' % path)\\n if not os.access(path, os.R_OK):\\n raise RuntimeError('file [%s] cannot be read' % path)\\n if not os.path.getsize(path) > 0:\\n raise RuntimeError('file [%s] is 0KB' % path)\\n else:\\n logging.debug('file [%s] checked successfully', path)\",\n \"def FileCheck(fn):\\n try:\\n open(fn, \\\"r\\\")\\n return 1\\n except IOError:\\n print(\\\"Error: File does not exist.\\\")\\n return 0\",\n \"def is_update_success():\\n file_success = os.getcwd() + \\\"\\\\\\\\last_success.txt\\\"\\n if os.path.exists(file_success):\\n return True\\n else:\\n return False\",\n \"def readjob(job):\\n with open(job) as f:\\n try:\\n jobdefn = json.load(f)\\n except ValueError as e:\\n job_logger.error('Cannont load job json: %s', e)\\n return False\\n else:\\n try:\\n validate(instance=jobdefn, schema=jobschema)\\n except Exception as e:\\n logecho(str(e), level='error')\\n return False\\n else:\\n return jobdefn\",\n \"def check_job_exists( job_list, analysis_group_id, reprocess_config_id):\\n for job in job_list:\\n struct = JSONMessage.unserialize(job.input_message)\\n\\n if( int( struct.analysis_group_id ) == int( analysis_group_id ) and \\\\\\n int( struct.reprocess_config_id ) == int( reprocess_config_id ) ):\\n return 1\\n return 0\",\n \"def check_file_flag(file):\\n return process_file_flag(file, None)\",\n \"def exists(self, args):\\n file_path = self.path(args)\\n return os.path.isfile(file_path)\",\n \"def check_status(self) -> bool:\\n ct_status = self.status()\\n if ct_status >> 3:\\n raise RuntimeError(\\n \\\"Uploading of data to the command table failed \\\"\\n \\\"due to a JSON parsing error.\\\"\\n )\\n return ct_status == 1\",\n \"def run_pylint(self, fname):\\n if '.py' not in fname:\\n return False\\n if not op.isfile(fname):\\n self.logging.info('------------------------------------------------------------------')\\n self.logging.info(\\\"FILE {} DOES NOT EXIST.\\\".format(fname))\\n self.logging.info('------------------------------------------------------------------')\\n self.logging.info('\\\\n')\\n return False\\n self.logging.info(\\\"{}\\\\n\\\".format(fname))\\n self.fname = fname\\n if self.rcfile and op.isfile(self.rcfile):\\n command_arg = [fname, '--rcfile', self.rcfile, '--score', 'no']\\n else:\\n command_arg = [fname, '--score', 'no']\\n try:\\n with redirect_stdout(PrintLogger(name=\\\"pylint\\\", log_level=\\\"INFO\\\")):\\n if int(pylint.__version__[0]) < 2:\\n self.results = Run(command_arg, exit=False) # pylint: disable=unexpected-keyword-arg\\n else:\\n # Use the default one\\n self.results = Run(command_arg, do_exit=False) # pylint: disable=unexpected-keyword-arg\\n return True\\n except Exception as error: # pylint: disable=broad-except\\n # We want to crash if ANYTHING goes wrong\\n self.logging.warning('------------------------------------------------------------------')\\n self.logging.warning(\\\"PYLINT CRASHED WHILE HANDLING {}\\\".format(fname))\\n self.logging.warning(\\\"{}: {}\\\".format(type(error), error.args))\\n self.logging.warning('------------------------------------------------------------------')\\n self.logging.info('\\\\n')\\n self.failed_files.append(fname)\\n return False\",\n \"def test_jobs_successful(self):\\n\\n workspace = storage_test_utils.create_workspace()\\n file1 = storage_test_utils.create_file()\\n data_dict = {\\n 'version': '1.0',\\n 'input_data': [{\\n 'name': 'INPUT_IMAGE',\\n 'file_id': file1.id\\n }],\\n 'output_data': [{\\n 'name': 'output_file_pngs',\\n 'workspace_id': workspace.id\\n }]}\\n\\n secret_configuration = {\\n 'version': '6',\\n 'priority': 50,\\n 'output_workspaces': {'default': storage_test_utils.create_workspace().name},\\n 'settings': {\\n 'DB_HOST': 'som.host.name',\\n 'DB_PASS': 'secret_password'\\n }\\n }\\n\\n seed_job_type = job_test_utils.create_seed_job_type(configuration=secret_configuration)\\n seed_job = job_test_utils.create_job(job_type=seed_job_type, status='RUNNING', input=data_dict)\\n\\n url = '/%s/jobs/%d/' % (self.api, seed_job.id)\\n response = self.client.generic('GET', url)\\n result = json.loads(response.content)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n self.assertEqual(result['configuration']['priority'],50)\\n self.assertNotIn('DB_PASS', result['configuration']['settings'])\",\n \"def scriptChecker(filename):\\n if not os.path.exists(filename):\\n print 'ERROR: %s does not exist' % filename\\n import errno\\n return errno.ENOENT\\n\\n # The script-checker program is called directly. If we call the code\\n # from this python interpreter, any changes to an observing script will\\n # not be noticed.\\n #\\n # This is due to the way python works: a second import statement of the\\n # same module does nothing!\\n import subprocess\\n script = helpers.getCarmaBuildPath() + '/scripts/script-checker'\\n cmd = [script, filename]\\n ret = subprocess.call(cmd)\\n if ret != 0:\\n print 'ERROR: script-checker returned status code:', ret\",\n \"def _validate_jobs(\\n self,\\n check_nlst_warn: bool = False\\n ):\\n counter = 0\\n for job in self.jobs:\\n counter += 1\\n print(job.job_id)\\n if counter == 0:\\n ignore_restarts = False\\n else:\\n ignore_restarts = True\\n\\n check_input_files(\\n hrldas_namelist=job.hrldas_namelist,\\n hydro_namelist=job.hydro_namelist,\\n sim_dir=os.getcwd(),\\n ignore_restarts=ignore_restarts,\\n check_nlst_warn=check_nlst_warn\\n )\",\n \"def fileCheck(filePath):\\n if not os.path.isfile(filePath):\\n return False\\n return True\",\n \"def file_ready(file_path):\\n while not os.path.exists(file_path):\\n time.sleep(1)\\n if os.path.isfile(file_path):\\n return True\\n raise ValueError(\\\"%s isn't a file!\\\" % file_path)\",\n \"def checkRunning(procname):\\n return procdata.checkRunning(procname)\",\n \"def _job_was_successful(self, status):\\n success = True\\n\\n # https://cloud.google.com/life-sciences/docs/reference/rest/v2beta/Event\\n for event in status[\\\"metadata\\\"][\\\"events\\\"]:\\n\\n logger.debug(event[\\\"description\\\"])\\n\\n # Does it always result in fail for other failure reasons?\\n if \\\"failed\\\" in event:\\n success = False\\n action = event.get(\\\"failed\\\")\\n logger.debug(\\\"{}: {}\\\".format(action[\\\"code\\\"], action[\\\"cause\\\"]))\\n\\n elif \\\"unexpectedExitStatus\\\" in event:\\n action = event.get(\\\"unexpectedExitStatus\\\")\\n\\n if action[\\\"exitStatus\\\"] != 0:\\n success = False\\n\\n # Provide reason for the failure (desc includes exit code)\\n msg = \\\"%s\\\" % event[\\\"description\\\"]\\n if \\\"stderr\\\" in action:\\n msg += \\\": %s\\\" % action[\\\"stderr\\\"]\\n logger.debug(msg)\\n\\n return success\",\n \"def FileExists(file):\\n return os.path.exists(file)\",\n \"def succeed(self) -> bool:\\n return self.errorCode is None or len(self.errorCode) < 1\",\n \"def check_status(job):\\n client = get_dropbox_client()\\n\\n try:\\n return client.metadata(\\n '/Video Automation Platform/jobs/{job}/{job}.png'.format(job=job))\\n\\n except ErrorResponse:\\n return False\",\n \"def file_exists(self):\\n return os.path.exists(self._fileName)\",\n \"def was_successful(self):\\n return self._build_proto.status == common.SUCCESS\",\n \"def check_slurm_job_submission(expected_name):\\n cmd = ['scontrol', 'show', 'job']\\n job_id = 0\\n found_job = False\\n while True:\\n while True:\\n try:\\n out = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()[0]\\n break\\n except:\\n sleep(1)\\n out = out.split('\\\\n')\\n if 'error' in out[0]:\\n sleep(1)\\n msg = 'Error checking job status for {0}'.format(expected_name)\\n logging.warning(msg)\\n continue\\n for line in out:\\n for word in line.split():\\n if 'JobId' in word:\\n index = word.find('=') + 1\\n job_id = int(word[index:])\\n # continue\\n if 'Name' in word:\\n index = word.find('=') + 1\\n if word[index:] == expected_name:\\n found_job = True\\n\\n if found_job and job_id != 0:\\n return found_job, job_id\\n sleep(1)\\n return found_job, job_id\",\n \"def check_input_file(self):\\n\\n # Mission critical parameters\\n if self.jobname is None:\\n sys.exit('Batch_emto.check_input_file: \\\\'jobname\\\\' has to be given!')\\n\\n if self.runtime is None:\\n self.runtime = \\\"48:00:00\\\"\\n if self.emtopath is None:\\n self.emtopath = \\\"./\\\"\\n if self.EMTOdir is None:\\n self.EMTOdir = \\\"$HOME/EMTO5.8/\\\"\\n if self.runKGRN is None:\\n self.runKGRN = True\\n if self.runKFCD is None:\\n self.runKFCD = True\\n return\",\n \"def does_file_exist(self, fn):\\n if True:\\n print(f\\\"-=- {fn} found.\\\")\\n return True\\n else:\\n print(f\\\"-!- {fn} not found. Try again\\\")\\n return False\",\n \"def file_exists(filename):\\n return os.path.exists(filename)\",\n \"def exists(self, prefix, args=()):\\n file_path = self.path(prefix, args)\\n return os.path.isfile(file_path)\",\n \"def exist(self):\\n return self.file_path.exists()\",\n \"def should_notify(job):\\n if job.result not in (Result.failed, Result.passed):\\n return\\n\\n parent = Job.query.join(\\n Source, Source.id == Job.source_id,\\n ).filter(\\n Source.patch_id == None, # NOQA\\n Source.revision_sha != job.build.source.revision_sha,\\n Job.project == job.project,\\n Job.date_created < job.date_created,\\n Job.status == Status.finished,\\n Job.result.in_([Result.passed, Result.failed]),\\n ).order_by(Job.date_created.desc()).first()\\n\\n # if theres no parent, this job must be at fault\\n if parent is None:\\n return job.result == Result.failed\\n\\n if job.result == Result.passed == parent.result:\\n return False\\n\\n current_failures = get_test_failures(job)\\n # if we dont have any testgroup failures, then we cannot identify the cause\\n # so we must notify the individual\\n if not current_failures:\\n return True\\n\\n parent_failures = get_test_failures(parent)\\n if parent_failures != current_failures:\\n return True\\n\\n return False\",\n \"def is_failed(file, validate=None, tmp_dir=None):\\n stats = os.stat(file)\\n if stats.st_size <= 68:\\n if validate is None:\\n return True\\n try:\\n if get_extracted_name(os.path.basename(file)) != os.path.basename(file):\\n file = extract_file_if_necessary(file, tmp_dir)\\n output = subprocess.check_output([validate, file])\\n except subprocess.CalledProcessError:\\n output = 'invalid'\\n if output == 'invalid':\\n return True\\n return False\",\n \"def batch_job_running(self, name):\\n if name not in self.batch_jobs:\\n raise ValueError(\\\"job {} doesn't exists\\\".format(name))\\n return name in self.jobs\",\n \"def test_wrong_job(self):\\n job = MockJob()\\n container_name = 'container_identifier'\\n self._mock_open.return_value.__enter__.return_value.readline. \\\\\\n return_value = container_name\\n\\n # return an error trying to read file with container name\\n self._mock_open.return_value.__enter__.side_effect = [\\n PermissionError,\\n FileNotFoundError,\\n ]\\n\\n self.assertNotEqual(job.pid, 0)\\n # non-zero pid, no container name is found -> refer to ForkSpawner\\n validation_result = self._container_spawner.validate(job)\\n self._mock_open.assert_called()\\n self._mock_fork.assert_called()\\n self.assertEqual(validation_result,\\n spawner.PROCESS_RUNNING)\\n # same check, a different exception\\n self.assertEqual(self._container_spawner.validate(job),\\n spawner.PROCESS_RUNNING)\",\n \"def file_exists(filename, verbose=False):\\n try:\\n os.stat(filename)\\n return True\\n except (OSError,):\\n err = sys.exc_info()[1]\\n if verbose:\\n logging.error(str(err))\\n return False\",\n \"def _check_analyzed_job(self, job, container):\\n self.log(u\\\"Checking the Job object generated from container\\\")\\n\\n self.log(u\\\"Checking that the Job is not None\\\")\\n if job is None:\\n self._failed(u\\\"Unable to create a Job from the container.\\\")\\n return\\n\\n self.log(u\\\"Checking that the Job has at least one Task\\\")\\n if len(job) == 0:\\n self._failed(u\\\"Unable to create at least one Task from the container.\\\")\\n return\\n\\n if self.rconf[RuntimeConfiguration.JOB_MAX_TASKS] > 0:\\n self.log(u\\\"Checking that the Job does not have too many Tasks\\\")\\n if len(job) > self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]:\\n self._failed(u\\\"The Job has %d Tasks, more than the maximum allowed (%d).\\\" % (\\n len(job),\\n self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]\\n ))\\n return\\n\\n self.log(u\\\"Checking that each Task text file is well formed\\\")\\n for task in job.tasks:\\n self.log([u\\\"Checking Task text file '%s'\\\", task.text_file_path])\\n text_file_bstring = container.read_entry(task.text_file_path)\\n if (text_file_bstring is None) or (len(text_file_bstring) == 0):\\n self._failed(u\\\"Text file '%s' is empty\\\" % task.text_file_path)\\n return\\n self._check_utf8_encoding(text_file_bstring)\\n if not self.result.passed:\\n self._failed(u\\\"Text file '%s' is not encoded in UTF-8\\\" % task.text_file_path)\\n return\\n self._check_not_empty(text_file_bstring)\\n if not self.result.passed:\\n self._failed(u\\\"Text file '%s' is empty\\\" % task.text_file_path)\\n return\\n self.log([u\\\"Checking Task text file '%s': passed\\\", task.text_file_path])\\n self.log(u\\\"Checking each Task text file is well formed: passed\\\")\",\n \"def check_job_status_by_id(job_id):\\n print('=' * 40)\\n print('check_status_by_job_id', job_id)\\n print('=' * 40)\\n\\n it_worked = check_job_status(job)\\n if it_worked:\\n return ok_resp(job)\\n\\n user_msg = ('PreprocessJob still in process: %s') % (job_id)\\n return err_resp(user_msg)\",\n \"def successful(self) -> bool:\\n pass\",\n \"def file_exists(filename: str) -> bool:\\n\\n return os.path.exists(filename)\",\n \"def CheckIfJobFinished(jobid, numseq, to_email, g_params): # {{{\\n bsname = \\\"job_final_process\\\"\\n path_result = os.path.join(g_params['path_static'], 'result')\\n rstdir = os.path.join(path_result, jobid)\\n gen_logfile = g_params['gen_logfile']\\n gen_errfile = g_params['gen_errfile']\\n name_server = g_params['name_server']\\n g_params['jobid'] = jobid\\n g_params['numseq'] = numseq\\n g_params['to_email'] = to_email\\n jsonfile = os.path.join(rstdir, f\\\"{bsname}.json\\\")\\n myfunc.WriteFile(json.dumps(g_params, sort_keys=True), jsonfile, \\\"w\\\")\\n binpath_script = os.path.join(g_params['webserver_root'], \\\"env\\\", \\\"bin\\\")\\n\\n finished_idx_file = \\\"%s/finished_seqindex.txt\\\"%(rstdir)\\n failed_idx_file = \\\"%s/failed_seqindex.txt\\\"%(rstdir)\\n py_scriptfile = os.path.join(binpath_script, f\\\"{bsname}.py\\\")\\n finished_idx_list = []\\n failed_idx_list = []\\n if os.path.exists(finished_idx_file):\\n finished_idx_list = list(set(myfunc.ReadIDList(finished_idx_file)))\\n if os.path.exists(failed_idx_file):\\n failed_idx_list = list(set(myfunc.ReadIDList(failed_idx_file)))\\n\\n lockname = f\\\"{bsname}.lock\\\"\\n lock_file = os.path.join(g_params['path_result'], g_params['jobid'],\\n lockname)\\n\\n num_processed = len(finished_idx_list)+len(failed_idx_list)\\n if num_processed >= numseq: # finished\\n if ('THRESHOLD_NUMSEQ_CHECK_IF_JOB_FINISH' in g_params\\n and numseq <= g_params['THRESHOLD_NUMSEQ_CHECK_IF_JOB_FINISH']):\\n cmd = [\\\"python\\\", py_scriptfile, \\\"-i\\\", jsonfile]\\n (isSubmitSuccess, t_runtime) = webcom.RunCmd(cmd, gen_logfile, gen_errfile)\\n elif not os.path.exists(lock_file):\\n bash_scriptfile = f\\\"{rstdir}/{bsname},{name_server},{jobid}.sh\\\"\\n code_str_list = []\\n code_str_list.append(\\\"#!/bin/bash\\\")\\n cmdline = f\\\"python {py_scriptfile} -i {jsonfile}\\\"\\n code_str_list.append(cmdline)\\n code = \\\"\\\\n\\\".join(code_str_list)\\n myfunc.WriteFile(code, bash_scriptfile, mode=\\\"w\\\", isFlush=True)\\n os.chmod(bash_scriptfile, 0o755)\\n os.chdir(rstdir)\\n cmd = ['sbatch', bash_scriptfile]\\n cmdline = \\\" \\\".join(cmd)\\n verbose = False\\n if 'DEBUG' in g_params and g_params['DEBUG']:\\n verbose = True\\n webcom.loginfo(\\\"Run cmdline: %s\\\"%(cmdline), gen_logfile)\\n (isSubmitSuccess, t_runtime) = webcom.RunCmd(cmd, gen_logfile, gen_errfile, verbose)\\n if 'DEBUG' in g_params and g_params['DEBUG']:\\n webcom.loginfo(\\\"isSubmitSuccess: %s\\\"%(str(isSubmitSuccess)), gen_logfile)\",\n \"def check_file(self) -> bool:\\n log.info(\\\"Checking if the database file exists.\\\")\\n try:\\n with open(self.host, 'r'):\\n log.info(\\\"Database file exists. Checking it's integrity\\\")\\n except FileNotFoundError:\\n log.error(\\\"The database file doesn't exists.\\\")\\n return False\\n else:\\n try:\\n self.setup_tables()\\n return True\\n except Exception:\\n log.critical(\\\"An exception was raised.\\\")\\n raise\",\n \"def is_valid_file(input_file):\\n if not os.path.isfile(input_file):\\n print('File \\\\'{}\\\\' not found.'.format(input_file))\\n exit(1)\\n return input_file\",\n \"def file_exists(self):\\n if os.path.isfile(self.file_name):\\n return True\\n else:\\n return False\",\n \"def file_exists(self):\\r\\n if os.path.exists(self.file_path):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def exists(cls, job_id: str, connection: Optional['Redis'] = None) -> bool:\\n if not connection:\\n connection = resolve_connection()\\n job_key = cls.key_for(job_id)\\n job_exists = connection.exists(job_key)\\n return bool(job_exists)\",\n \"def check_file_existence(self, filename):\\n try:\\n for sample in TimeoutingSampler(\\n config.GAHOOKS_TIMEOUT, 1, self.machine.fs.exists,\\n \\\"/tmp/%s\\\" % filename\\n ):\\n if sample:\\n return True\\n except APITimeout:\\n return False\",\n \"def _check_job_completeness(self, jobs):\\n for job in concurrent.futures.as_completed(jobs):\\n if job.exception():\\n raise (job.exception())\",\n \"def test_successful_job(self, _is_coalesced):\\n successful_job = json.loads(BASE_JSON % (SUCCESS, 1433166610, 1, 1433166609))[0]\\n self.assertEquals(self.query_api.get_job_status(successful_job), SUCCESS)\",\n \"def fileExist(file):\\r\\n return os.path.exists(file) and os.path.isfile(file)\",\n \"def checkjob(sid, jid):\\n with slycat.web.server.remote.get_session(sid) as session:\\n return session.checkjob(jid)\",\n \"def file_is_missing(filename, allow_missing=True):\\n\\n if os.path.exists(filename):\\n return False\\n if not allow_missing:\\n raise RuntimeError(f\\\"File {filename} does not exist\\\")\\n print(f\\\"Warning: file {filename} does not exist\\\")\\n return True\",\n \"def file_exists(filename):\\n return os.path.isfile(filename)\",\n \"def check_wait_for_copy_complete(jobs):\\n for j in jobs:\\n stdout, stderr = j.communicate()\\n\\n if j.returncode != 0:\\n output = stdout or stderr or ''\\n error = 'COPY FAILED with {0}: {1}'.format(j.returncode, output.strip())\\n raise RuntimeError(error)\",\n \"def _is_job_finished(self, job_id):\\n complete, rc, status, result, task = False, 0, None, None, None\\n job = self.get_job_by_id(job_id)\\n if job:\\n status = job['status']\\n try:\\n result, task = job['result'], job['task']\\n except KeyError:\\n pass\\n if status.lower() == SUCCEEDED:\\n complete = True\\n elif status.lower() in INCOMPLETE_LIST:\\n complete = False\\n else:\\n rc, complete = -1, True\\n return complete, result, rc, status, task\",\n \"def service_mesh_job_check(container_name):\\n complete = False\\n log.info(\\\"Checking if %s is complete\\\", container_name)\\n try:\\n response = coreV1Api.list_namespaced_pod(namespace=namespace, watch=False)\\n for item in response.items:\\n # container_statuses can be None, which is non-iterable.\\n if item.status.container_statuses is None:\\n continue\\n for container in item.status.container_statuses:\\n if container.name == container_name and item.status.phase == \\\"Running\\\":\\n name = read_name(item)\\n log.info(\\\"Container Details %s \\\", container)\\n log.info(\\\"Container Status %s \\\", container.state.terminated)\\n\\n if container.state.terminated:\\n log.info(\\\"Container Terminated with reason %s \\\", container.state.terminated.reason)\\n complete = True\\n\\n except ApiException as exc:\\n log.error(\\\"Exception when calling read_namespaced_job_status: %s\\\\n\\\",\\n exc)\\n return complete\",\n \"def check_if_file_exists(file: str) -> Union[str, None]:\\n if not os.path.exists(file) and not os.path.exists(f'{file}_qforce'):\\n sys.exit(f'ERROR: \\\"{file}\\\" does not exist.\\\\n')\\n return file\",\n \"def if_file_exist(file_name: str) -> bool:\\n\\n exists = os.path.exists(file_name)\\n\\n return exists\",\n \"def verify(filename):\\n verified = True\\n errs = []\\n\\n if not os.path.exists(filename):\\n verified = False\\n errs.append('No such file: %s' % filename)\\n \\n errs = ['[!] ' + e for e in errs]\\n\\n if len(errs) > 0:\\n print('\\\\n'.join(errs))\\n\\n return verified\",\n \"def _check_job_status(self) -> str:\\n self._assert_job_created()\\n\\n r = requests.post(\\n f'https://{cc.ROUTE_PREFIX}.stratodem.com/jobs/status',\\n headers=dict(\\n Authorization=f'Bearer {get_api_token()}',\\n ),\\n json=dict(job_id=self._job_id)\\n )\\n\\n if not r.status_code == 200:\\n raise APIQueryFailedException('Failed to determine job status')\\n\\n r = r.json()\\n\\n if not r['success']:\\n raise APIQueryFailedException(r)\\n else:\\n return r['message']\",\n \"def check_sp_job(self,\\n label: str,\\n job: 'JobAdapter',\\n ):\\n if 'mrci' in self.sp_level.method and job.level is not None and 'mrci' not in job.level.method:\\n # This is a CCSD job ran before MRCI. Spawn MRCI\\n self.run_sp_job(label)\\n elif job.job_status[1]['status'] == 'done':\\n self.post_sp_actions(label,\\n sp_path=os.path.join(job.local_path_to_output_file),\\n level=job.level,\\n )\\n # Update restart dictionary and save the yaml restart file:\\n self.save_restart_dict()\\n if self.species_dict[label].number_of_atoms == 1:\\n # save the geometry from the sp job for monoatomic species for which no opt/freq jobs will be spawned\\n self.output[label]['paths']['geo'] = job.local_path_to_output_file\\n else:\\n self.troubleshoot_ess(label=label,\\n job=job,\\n level_of_theory=job.level,\\n )\",\n \"def codepipeline_success(job_id):\\n try:\\n codepipeline = boto3.client('codepipeline')\\n codepipeline.put_job_success_result(jobId=job_id)\\n LOGGER.info('===SUCCESS===')\\n return True\\n except ClientError as err:\\n LOGGER.error(\\\"Failed to PutJobSuccessResult for CodePipeline!\\\\n%s\\\", err)\\n return False\",\n \"def file_exists(path):\\n\\n try:\\n with open(path):\\n return True\\n except IOError:\\n return False\",\n \"def chronos_job_is_ready(context, job_name):\\n chronos_tools.wait_for_job(context.chronos_client, context.jobs[job_name]['name'])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67143625","0.66477233","0.6379032","0.6379032","0.6247778","0.62245816","0.6209879","0.6126895","0.6095487","0.60941005","0.60333455","0.60249513","0.6003191","0.5996906","0.59792376","0.59495425","0.5948564","0.5945208","0.5917747","0.590241","0.58824754","0.5859382","0.5857888","0.5857888","0.5846791","0.58460015","0.5845127","0.58383536","0.5837853","0.58365023","0.58109605","0.58087","0.57994604","0.5795493","0.5795413","0.57950336","0.57921076","0.5779603","0.5734668","0.57239527","0.57223195","0.57153654","0.56805027","0.5664193","0.5660293","0.56428075","0.5628095","0.5609912","0.5597735","0.55936116","0.5578944","0.55755764","0.5570805","0.5569612","0.5565349","0.55592793","0.55558175","0.5548413","0.55454755","0.5541085","0.5536719","0.5535042","0.5528988","0.55260223","0.55199504","0.5518693","0.5518479","0.55146897","0.55121946","0.5510489","0.5494554","0.54829144","0.5474811","0.54675806","0.5455389","0.54527634","0.54511505","0.54434294","0.5433947","0.54326963","0.5427321","0.54221725","0.54188246","0.54128957","0.54111326","0.54092085","0.5408375","0.53994197","0.53907883","0.5389723","0.53895617","0.53890765","0.53883183","0.53803873","0.53777575","0.53769934","0.537696","0.5374685","0.5372213","0.53721374"],"string":"[\n \"0.67143625\",\n \"0.66477233\",\n \"0.6379032\",\n \"0.6379032\",\n \"0.6247778\",\n \"0.62245816\",\n \"0.6209879\",\n \"0.6126895\",\n \"0.6095487\",\n \"0.60941005\",\n \"0.60333455\",\n \"0.60249513\",\n \"0.6003191\",\n \"0.5996906\",\n \"0.59792376\",\n \"0.59495425\",\n \"0.5948564\",\n \"0.5945208\",\n \"0.5917747\",\n \"0.590241\",\n \"0.58824754\",\n \"0.5859382\",\n \"0.5857888\",\n \"0.5857888\",\n \"0.5846791\",\n \"0.58460015\",\n \"0.5845127\",\n \"0.58383536\",\n \"0.5837853\",\n \"0.58365023\",\n \"0.58109605\",\n \"0.58087\",\n \"0.57994604\",\n \"0.5795493\",\n \"0.5795413\",\n \"0.57950336\",\n \"0.57921076\",\n \"0.5779603\",\n \"0.5734668\",\n \"0.57239527\",\n \"0.57223195\",\n \"0.57153654\",\n \"0.56805027\",\n \"0.5664193\",\n \"0.5660293\",\n \"0.56428075\",\n \"0.5628095\",\n \"0.5609912\",\n \"0.5597735\",\n \"0.55936116\",\n \"0.5578944\",\n \"0.55755764\",\n \"0.5570805\",\n \"0.5569612\",\n \"0.5565349\",\n \"0.55592793\",\n \"0.55558175\",\n \"0.5548413\",\n \"0.55454755\",\n \"0.5541085\",\n \"0.5536719\",\n \"0.5535042\",\n \"0.5528988\",\n \"0.55260223\",\n \"0.55199504\",\n \"0.5518693\",\n \"0.5518479\",\n \"0.55146897\",\n \"0.55121946\",\n \"0.5510489\",\n \"0.5494554\",\n \"0.54829144\",\n \"0.5474811\",\n \"0.54675806\",\n \"0.5455389\",\n \"0.54527634\",\n \"0.54511505\",\n \"0.54434294\",\n \"0.5433947\",\n \"0.54326963\",\n \"0.5427321\",\n \"0.54221725\",\n \"0.54188246\",\n \"0.54128957\",\n \"0.54111326\",\n \"0.54092085\",\n \"0.5408375\",\n \"0.53994197\",\n \"0.53907883\",\n \"0.5389723\",\n \"0.53895617\",\n \"0.53890765\",\n \"0.53883183\",\n \"0.53803873\",\n \"0.53777575\",\n \"0.53769934\",\n \"0.537696\",\n \"0.5374685\",\n \"0.5372213\",\n \"0.53721374\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6971786"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":786,"numItemsPerPage":100,"numTotalItems":95772,"offset":78600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMxNTM5MywianRpIjoiMzk5MTY0MDItMmJhNC00N2I3LWI0ZGMtMzBkYWY2YjAzMDY0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMTg5OTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.sDPvjs_rbTnH2_SMqhf2HK4DrzxcX3FXTtsS8__CohFsVH1PMNiSvDrv5PBmroixu-2MhA3xR7NEx9wWGT19Cw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Function to create a discrete node split. | def get_discrete_node ( self, feature_matrix, target_array, feature_column, feature_value, node ):
# Get the unique values for the X poitns
unique_x_vals = self.discrete_value_maps [ feature_column ]
# Create the node with an empty child for each x value
node.updateTreeValues (
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_split(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n helper.make_attribute('split', op.parts),\n ])\n return node",
"def create_split(self) -> NoReturn:\... | [
"0.6879672",
"0.66267234",
"0.65676033",
"0.6179339",
"0.6152159",
"0.5976991",
"0.5958041",
"0.5940135",
"0.5805374",
"0.57914776",
"0.57853085",
"0.5728951",
"0.56534255",
"0.5645786",
"0.56177664",
"0.5589983",
"0.5586557",
"0.5562353",
"0.55578905",
"0.55205125",
"0.54881... | 0.5515158 | 20 |
Function to get the next split in the decision tree | def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):
# If only 1 y value, make a leaf node
if len ( set ( target_array ) ) == 1:
tree_split.updateTreeValues (
feature_column = None,
feature_value = None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nextSplit(self):\n pass",
"def split_next(self):\n # Consider the node with the highest loss reduction (a.k.a. gain)\n node = heappop(self.splittable_nodes)\n\n tic = time()\n (sample_indices_left,\n sample_indices_right,\n right_child_pos) = self.splitter.s... | [
"0.72422147",
"0.6587546",
"0.6098902",
"0.607232",
"0.60684705",
"0.60498345",
"0.6005773",
"0.59968233",
"0.59107053",
"0.5817029",
"0.5778859",
"0.5776043",
"0.5758599",
"0.5738114",
"0.5722309",
"0.5722309",
"0.5703586",
"0.56686014",
"0.5667164",
"0.5667024",
"0.5664685"... | 0.6345202 | 2 |
Function to fit the decision tree | def fit ( self, feature_matrix: np.ndarray, target_array: np.ndarray):
# Create the root node
self.root = TreeSplits()
# Get all possible values for discrete valued columns
# Necessary so each split can handle unique X values that
# were not in the training set.
self.dis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_decision_tree(model, x_train, y_train):\r\n model.fit(x_train, y_train)\r\n score = model.score(x_train, y_train)\r\n importance = model.feature_importances_\r\n return score, importance",
"def train_decision_tree():\n train_model(DecisionTreeRegressor(max_depth=3, random_state=42),\n ... | [
"0.77766097",
"0.7377799",
"0.729431",
"0.72421414",
"0.71106946",
"0.70728546",
"0.69706905",
"0.6933395",
"0.692453",
"0.68938357",
"0.6887726",
"0.6838739",
"0.6834463",
"0.6828714",
"0.6772153",
"0.6772153",
"0.6662862",
"0.6650102",
"0.65992475",
"0.6572775",
"0.6558867"... | 0.0 | -1 |
Function to get all the target values of leaves for a subtree. Used for postpruning | def collect_children ( node: TreeSplits ):
if node.nodes is None or len ( node.nodes ) == 0:
return node.children
# Recursively get all the children and concatenate them
return np.concatenate (
[
BaseTree.collect_children ( child_node )
fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def leaves(tree):\n if is_leaf(tree):\n return [label(tree)]\n else:\n return sum([leaves(b) for b in branches(tree)], [])",
"def get_leaves(tree):\n if tree.is_leaf:\n return [tree.indices]\n else:\n return get_leaves(tree.left_child) + get_leaves(tree.right_child)",
"d... | [
"0.64149165",
"0.6268147",
"0.6199293",
"0.60760117",
"0.5998846",
"0.5984824",
"0.592592",
"0.5859059",
"0.58194226",
"0.58169144",
"0.5734021",
"0.57295066",
"0.57267654",
"0.5701329",
"0.56755906",
"0.5645248",
"0.5631038",
"0.5622244",
"0.55899423",
"0.5583704",
"0.558262... | 0.0 | -1 |
Function gets the prediction by treating a subtree as a leaf. | def predict_from_all_children ( self, node: TreeSplits ):
# Collect the children
children_values = BaseTree.collect_children ( node )
# Aggregate the leaf values
return self.agg_function ( children_values )
# End predict_from_all_children | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _predict(self, treenode, X):\n if treenode.is_leaf:\n return treenode.leaf_score\n elif pd.isnull(X[1][treenode.feature]):\n if treenode.nan_direction == 0:\n return self._predict(treenode.left_child, X)\n else:\n return self._predict... | [
"0.73726535",
"0.7305055",
"0.72884184",
"0.68872315",
"0.6845775",
"0.6741382",
"0.67383456",
"0.67291856",
"0.67155856",
"0.664063",
"0.66377825",
"0.65606916",
"0.65345055",
"0.6481487",
"0.6466333",
"0.64396113",
"0.6425822",
"0.641785",
"0.64166534",
"0.6359143",
"0.6341... | 0.6237798 | 25 |
Function which makes predictions based on a subtree | def predict_node ( self, feature_matrix: np.ndarray, node: TreeSplits ):
# If leaf, return children target values
if node.children is not None and len ( node.children ):
return node.children
# If continuous, split appropriately, and make recursive call
if node.node_type == "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_example(x, tree):\r\n\r\n # INSERT YOUR CODE HERE. NOTE: THIS IS A RECURSIVE FUNCTION.\r\n \r\n for branching_value, subtree in tree.items():\r\n attr_index = branching_value[0]\r\n attr_value = branching_value[1]\r\n split_decision = branching_value[2]\r\n\r\n if s... | [
"0.7251586",
"0.7180416",
"0.7117868",
"0.7090114",
"0.7047164",
"0.7041305",
"0.7013195",
"0.69450426",
"0.6935808",
"0.6813366",
"0.68088096",
"0.68065083",
"0.6770708",
"0.6596798",
"0.6544427",
"0.6533072",
"0.65033436",
"0.6477702",
"0.6445264",
"0.6400186",
"0.6392303",... | 0.61561775 | 40 |
Function to make predictions over an X matrix | def predict ( self, feature_matrix: np.ndarray, node: TreeSplits = None ):
node = self.root if not node else node
if feature_matrix.ndim == 1:
# If just one row, predict
return self.agg_function ( self.predict_node ( feature_matrix = feature_matrix, node = node ) )
# If ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, X):",
"def predict(self, X):",
"def predict(self, X):\n ...",
"def predict(self, X):\n ...",
"def predict(self, X):\n ...",
"def predict(self, x):\n \n\n return predictions",
"def predict(self,X): \n return self._predict(X)",
"def predict(se... | [
"0.8184807",
"0.8184807",
"0.80694795",
"0.80694795",
"0.80694795",
"0.79561454",
"0.7893413",
"0.78499883",
"0.78499883",
"0.78499883",
"0.7741521",
"0.7699846",
"0.7668127",
"0.7650042",
"0.75861543",
"0.75762063",
"0.75502324",
"0.7527598",
"0.752281",
"0.7517701",
"0.7517... | 0.0 | -1 |
Function to test a subtree for pruning. | def tag_node_from_pruning ( self, tree, node, feature_matrix, target_array ):
# If is a leaf, return False
if node.nodes is None or len ( node.nodes ) == 0:
return False
# Score predictions from whole tree
predictions = tree.predict ( feature_matrix )
whole_tree_scor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prune( tree, impurity_crit, dataSet, treeSeq ):\n\n\t\tsaved = {}\n\n\t\ttotal_leaf_impurity, num_leaves = DecisionTree._fetch(tree, impurity_crit, dataSet, saved)\n\n\t\tnodes, sets, G = saved['node'], saved['set'], saved['G']\n\n\t\t# choose TreeNode such that g is minimum to prune\n\t\tmin_g_ind = np.argmi... | [
"0.6757538",
"0.65374196",
"0.6457873",
"0.6327665",
"0.6244245",
"0.6157366",
"0.61086893",
"0.60678625",
"0.60539806",
"0.5990413",
"0.59583294",
"0.5913224",
"0.5904743",
"0.5879302",
"0.58372855",
"0.5814479",
"0.5754499",
"0.5735543",
"0.56741375",
"0.56655",
"0.56423604... | 0.51750505 | 65 |
Function to prune a given node | def prune_node (self, tree: BaseTree, node: TreeSplits):
# Prune node, get if change
change_made = self.tag_node_from_pruning (
tree = tree, node = node, feature_matrix = self.X_validation, target_array = self.y_validation
)
# If change not made and it's not a leaf
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_prune(self, function_graph, node, reason):",
"def prune(self, node, exclude=None):\n for child in node.children:\n if exclude and exclude.id != child.id:\n self.prune(child, exclude)\n\n self.nodes[node.id] = None\n del self.nodes[node.id]",
"def prune_node... | [
"0.7823959",
"0.75583607",
"0.6794292",
"0.66370064",
"0.6618599",
"0.6538975",
"0.6535095",
"0.6478751",
"0.6396522",
"0.6379691",
"0.6367987",
"0.6344035",
"0.6319461",
"0.62772906",
"0.6246157",
"0.62271076",
"0.6200702",
"0.61402917",
"0.61102575",
"0.6105385",
"0.6104484... | 0.69929415 | 2 |
Function to prune a tree. | def prune_tree ( self ):
tree = copy.deepcopy ( self.tree )
change_made = True
# As long as changes are made, recursively prune from the root node.
while change_made:
change_made = self.prune_node ( tree, tree.root )
return tree
# End prune_tree() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prune_tree(self):\n tree = copy.deepcopy(self.tree)\n change_made = True\n # As long as changes are made, recursively prune from the root node.\n while change_made:\n change_made = self.prune_node(tree, tree.root)\n return tree",
"def prune(self, n_leaves):\n ... | [
"0.76428306",
"0.757985",
"0.74307483",
"0.7363779",
"0.73275864",
"0.732632",
"0.7228591",
"0.72047454",
"0.7031705",
"0.6908371",
"0.6862588",
"0.6833638",
"0.676064",
"0.67177105",
"0.67132443",
"0.6611636",
"0.6551961",
"0.65180445",
"0.65033764",
"0.64932555",
"0.6482528... | 0.77864975 | 0 |
Function to run classification experiment | def run_classification_experiment ( feature_matrix, target_array, colmap ):
np.random.seed ( 7062020 ) # Due date
# Split off validation set and cross-validation set
X_validation = feature_matrix [ : feature_matrix.shape [ 0 ] // 10 ]
X_cross_validation = feature_matrix [ feature_matrix.shape [ 0 ] //... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_classification_experiment(data_set_path, learner, positive_class_name, data_type=float):\n print(\"Running {0} Experiment with positive class = {1}\".format(data_set_path, positive_class_name))\n\n # Network structure.\n print(\"Number of Hidden Layers: {}\".format(len(learner.weights)-1))\n pr... | [
"0.7555303",
"0.71173567",
"0.70545274",
"0.70258445",
"0.69593644",
"0.6909916",
"0.6901521",
"0.6863415",
"0.68557537",
"0.6821653",
"0.67475575",
"0.67457944",
"0.6727784",
"0.67036206",
"0.67031395",
"0.67025673",
"0.67003846",
"0.669516",
"0.6651564",
"0.6640094",
"0.663... | 0.69589823 | 5 |
Function to run regression experiment | def run_regression_experiment ( feature_matrix, target_array, early_stopping_values ):
np.random.seed ( 7062020 ) # Due date
X_validation = feature_matrix [ : feature_matrix.shape [ 0 ] // 10 ]
X_cross_validation = feature_matrix [ feature_matrix.shape [ 0 ] // 10 : ]
y_validation = target_array [ : fea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_run_regressions(test_data, model):\n answer = model._Run_Regressions(\n test_data,\n 100,\n forecasts={\"arima\", \"holtwinters\", \"prophet\", \"arima_r\", \"sarima_r\"}\n )",
"def run():\n\n df = read_input() # the parameters\n df = add_time_period(df) # a feature\n ... | [
"0.7170951",
"0.7053031",
"0.6840249",
"0.6774338",
"0.6767782",
"0.67024475",
"0.66778004",
"0.6634623",
"0.65704435",
"0.6561046",
"0.6554445",
"0.64907575",
"0.6428488",
"0.64265656",
"0.6409631",
"0.64052933",
"0.6398685",
"0.6391104",
"0.6386898",
"0.6347162",
"0.6340198... | 0.0 | -1 |
Function obtains indices of length of rows in feature matrix X | def get_indices ( self, feature_matrix ):
# Shuffle if `self.shuffle` is true.
nrows = feature_matrix.shape [ 0 ]
return (
np.random.permutation (
np.arange ( nrows )
) # Shuffle the rows if `self.shuffle`
if self.shuffle
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feature_to_index(feature, dims):\n p = 0\n for j, k in enumerate(feature):\n print(\"j:\", \"k:\", k, \"dims\", dims[:j])\n p += int(np.prod(dims[:j])) * k\n return p",
"def get_num_features(self):\r\n \r\n return len(self[0]['x'])",
"def __len__(self):\n return ... | [
"0.68508416",
"0.6607199",
"0.6558984",
"0.62764865",
"0.61540145",
"0.6143088",
"0.61092424",
"0.6106243",
"0.6093235",
"0.6086436",
"0.60840034",
"0.60784405",
"0.6062819",
"0.604969",
"0.6011112",
"0.6004441",
"0.5983271",
"0.5979516",
"0.5979018",
"0.59567195",
"0.5944685... | 0.6091677 | 9 |
Given the split indices, function obtains one of the training splits | def _get_one_split ( split_indices, number_of_split ):
# Given the split indices, get the `number_of_split` element of the indices.
return ( np.delete ( np.concatenate ( split_indices ), split_indices [ number_of_split ] ), # Drops the test from the train
split_indices [ number_of_spli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices_of_split(self, split_name='train'):\n return self.indices_of('split', split_name)",
"def train_valid_index_split(all_index, train_size = None, valid_split = 0.3):\n\tall_index = np.arange(all_index) if isinstance(all_index, int) else np.array(all_index)\n\ttrain_size = len(all_index) if train_size... | [
"0.6946859",
"0.680867",
"0.6726826",
"0.66065216",
"0.62583315",
"0.6195574",
"0.6195574",
"0.61884665",
"0.618018",
"0.61747795",
"0.6159418",
"0.61322176",
"0.61260164",
"0.60440093",
"0.6012981",
"0.6004573",
"0.5996648",
"0.5986898",
"0.59850836",
"0.59788764",
"0.593213... | 0.80875164 | 1 |
Function splits the indices by the number of folds | def _get_indices_split ( indices, number_of_folds ):
# Split the indicies by the number of folds
return np.array_split ( indices, indices_or_sections = number_of_folds )
# End get_indices_split() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fold(nb_splits, dataset):\r\n index = np.arange(np.shape(dataset)[0])\r\n splits = np.split(index, nb_splits)\r\n\r\n index = []\r\n\r\n for n_fold in np.arange(nb_splits):\r\n index.append((splits[n_fold].tolist(),(np.concatenate([x for i,x in enumerate(splits) if i!=n_fold])).tolist()))\r\... | [
"0.78790355",
"0.7600039",
"0.71495384",
"0.7104353",
"0.6637206",
"0.6535842",
"0.6340548",
"0.6302971",
"0.6302251",
"0.62954754",
"0.62954754",
"0.62938744",
"0.6240823",
"0.62392235",
"0.6203992",
"0.6193665",
"0.6119545",
"0.61134005",
"0.60917705",
"0.6089957",
"0.60720... | 0.8309637 | 1 |
Function creates a generator of train/test splits from feature matrix X | def split ( self, feature_matrix: np.ndarray, target_array: np.ndarray = None ):
# Split the indices into `number_of_folds` subarray
indices = self.get_indices ( feature_matrix )
split_indices = KFoldCV._get_indices_split ( indices = indices, number_of_folds = self.number_of_folds )
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split(self,X,y=None):\n all_idx = pd.Series(np.arange(X.shape[0])) \n mbrg = int(X.shape[0]*self.embargo_pct)\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\n for i, j in test_starts:\n t0 = all_idx.index[i] # start of test set\n ... | [
"0.7445462",
"0.7317444",
"0.7171339",
"0.6934437",
"0.6873336",
"0.6599626",
"0.65487504",
"0.65389675",
"0.6490598",
"0.6489834",
"0.64814985",
"0.64605737",
"0.64358217",
"0.6416908",
"0.6387303",
"0.63864625",
"0.6376802",
"0.6374079",
"0.63144904",
"0.6305631",
"0.630481... | 0.6842673 | 5 |
Function adds new column called "split" | def add_split_col ( self, feature_array ):
feature_array = feature_array if not self.shuffle else np.random.permutation ( feature_array )
n = len ( feature_array )
k = int ( np.ceil ( n / self.number_of_folds ) )
return pd.DataFrame (
{ "index": feature_array, "split": np.til... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def FE_split_add_column(dft, col, splitter=',', action='add'):\r\n dft = copy.deepcopy(dft)\r\n new_col = col + '_split_apply'\r\n print('Creating column = %s using split_add feature engineering...' %new_col)\r\n if action in ['+','-','*','/','add','subtract','multiply','divide']:\r\n if action ... | [
"0.70793533",
"0.6979426",
"0.6646522",
"0.6312934",
"0.6276767",
"0.6180665",
"0.60511595",
"0.58757806",
"0.58685505",
"0.58671844",
"0.5830357",
"0.5812464",
"0.5775889",
"0.5757142",
"0.5717239",
"0.56658155",
"0.56388277",
"0.56223357",
"0.55786914",
"0.54897255",
"0.548... | 0.5971428 | 7 |
Function takes an array of classes, and creates train/test splits with proportional examples for each group. | def split ( self, target_array, feature_matrix = None ):
# Make sure y is an array
target_array = np.array ( target_array ) if isinstance ( target_array, list ) else target_array
# Groupby y and add integer indices.
df_with_split = (
pd.DataFrame ( { "y": target_array, "inde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def splitData(groupList, trainSize):\r\n from sklearn.model_selection import StratifiedShuffleSplit\r\n\r\n groupList[0]['text'] = cleanRealTexts(list(groupList[0]['text']))\r\n\r\n classLabels = np.array([])\r\n for i, group in enumerate(groupList):\r\n classLabels = np.append(classLabels, np.r... | [
"0.69671094",
"0.6935927",
"0.68803024",
"0.67468333",
"0.65711087",
"0.6552346",
"0.65297866",
"0.6526746",
"0.6494246",
"0.63984704",
"0.6372851",
"0.6314143",
"0.6303204",
"0.6303204",
"0.6286704",
"0.628164",
"0.6279098",
"0.6203552",
"0.61877185",
"0.6187187",
"0.6186407... | 0.0 | -1 |
Function creates a mapping of arguments to values to grid search over. | def create_param_grid ( param_grid: Dict ):
return (
dict ( zip ( param_grid.keys(), instance ) )
for instance in product ( * param_grid.values() )
) # End create_param_grid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_grid(parameters):\n grid = {}\n for c_name, c_type, c_vals in parameters:\n if c_type == \"choice\":\n grid[c_name] = c_vals\n elif c_type == \"fixed\":\n grid[c_name] = [c_vals]\n else:\n raise ValueError(\"GridSearch can only use categorical... | [
"0.6630265",
"0.6563484",
"0.60290205",
"0.59737265",
"0.59663725",
"0.5853442",
"0.5811071",
"0.57477045",
"0.570582",
"0.5683749",
"0.5681522",
"0.5669857",
"0.56621957",
"0.56388795",
"0.5599613",
"0.559585",
"0.5566635",
"0.5566635",
"0.55430984",
"0.5477576",
"0.5477576"... | 0.6079484 | 3 |
Function runs a model fit and a validation step. | def get_single_fitting_iteration ( self, feature_matrix: np.ndarray, target_array: np.ndarray, model ):
scores = []
if self.cv_object:
# Create train/test splits
for train, test in self.cv_object.split ( feature_matrix = feature_matrix, target_array = target_arr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _evaluate_during_fit(self, test_loader, epoch):",
"def _fit(self, x_train, y_train, x_valid, y_valid, regressor_callback=None):",
"def fit(epochs, model, loss_func, opt, train_dl, valid_dl):\n def train():\n \"\"\"Train model for one epoch.\"\"\"\n model.train()\n for batch_index, (... | [
"0.71327233",
"0.7107278",
"0.70992154",
"0.7027115",
"0.699485",
"0.6873614",
"0.68706995",
"0.683266",
"0.68170667",
"0.67857736",
"0.67634565",
"0.6738605",
"0.6716458",
"0.6715485",
"0.6705056",
"0.6692423",
"0.6687187",
"0.66685694",
"0.6666301",
"0.6655238",
"0.66347945... | 0.0 | -1 |
Function runs the grid search across the parameter grid. | def get_cv_scores ( self, feature_matrix: np.ndarray, target_array: np.ndarray ):
# Create the parameter grid
param_grid = list ( GridSearchCV.create_param_grid ( self.param_grid ) )
# Zip the grid to the results from a single fit
return zip (
param_grid,
[
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grid_search(self, params):\n train_X, train_y, dev_X, dev_y = self.extract_train_dev_data()\n clf = self.classifiers[0]\n pred_y = clf.grid_search(params, train_X, train_y, dev_X)\n logger.info(classification_report(dev_y, pred_y))",
"def FindGrid(self, p_float=..., p_float=..., p... | [
"0.73994136",
"0.724876",
"0.7212698",
"0.70302624",
"0.69863653",
"0.69728756",
"0.6971818",
"0.6971692",
"0.6942894",
"0.6706154",
"0.66942745",
"0.6680439",
"0.6678906",
"0.6663483",
"0.6650619",
"0.66011894",
"0.659441",
"0.65446216",
"0.6542018",
"0.65298516",
"0.6524632... | 0.0 | -1 |
Function to get classifier accuracy | def accuracy ( actuals, predictions ):
return np.mean ( actuals == predictions )
# End accuracy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def accuracy(self):",
"def accuracy(self):\r\n # Load tarined model using intent id.\r\n clf = joblib.load(filename=self.intention_id+'.pkl')\r\n # Compute accuracy for hole training data and return.\r\n return clf.score(X=self.training_data, y=self.target_data)",
"def accuracy(clf,... | [
"0.8496106",
"0.8096605",
"0.801635",
"0.8007906",
"0.8000073",
"0.79757977",
"0.7973719",
"0.78371614",
"0.7820705",
"0.77562433",
"0.77545613",
"0.77506614",
"0.7692017",
"0.7687957",
"0.76814085",
"0.7674037",
"0.7672642",
"0.7662792",
"0.76614755",
"0.7658593",
"0.7611567... | 0.7498263 | 31 |
Function to get MSE | def mean_squared_error ( actuals, predictions ):
return np.mean ( ( actuals - predictions ) ** 2 )
# End mean_squared_error() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_MSE(e):\n\n return 1/2*np.mean(e**2)",
"def calculate_mse(e):\r\n return 1/2*np.mean(e**2)",
"def calculate_mse(e):\n return 1/2*np.mean(e.dot(e))",
"def _mse(self):\n error = self._input * self._weights - self._label\n sum_ = 0.0\n for i in range(self._input.shape[0... | [
"0.8160725",
"0.78669804",
"0.7640311",
"0.75215",
"0.75183463",
"0.7489461",
"0.74785423",
"0.74559116",
"0.74378157",
"0.72474",
"0.70897496",
"0.70897496",
"0.7059256",
"0.7040443",
"0.7005932",
"0.69923854",
"0.69908667",
"0.69908667",
"0.6931149",
"0.6910345",
"0.6901799... | 0.0 | -1 |
Function to use crossvalidation to choose a value of k | def choose_k (
feature_matrix,
target_array,
model_call,
param_grid,
scoring_func = accuracy,
cv = KFoldStratifiedCV ( number_of_folds = 3 ),
):
grid_search_cv = GridSearchCV (
model_callable = model_call,
param_grid = param_grid,
scoring_func = scoring_func,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_validation(self, k=5):\n test_errors, train_errors = [], []\n\n # For leave out cross validation k = n\n if k == -1:\n k = len(data)\n\n for _ in range(k):\n shuffled_data = data.copy()\n\n # Do not shuffle data for leave one out cross validati... | [
"0.7224282",
"0.7093413",
"0.70916903",
"0.70881224",
"0.70334035",
"0.7002712",
"0.6994055",
"0.69897985",
"0.69870645",
"0.6966804",
"0.6940088",
"0.6907635",
"0.6839479",
"0.67935413",
"0.6744706",
"0.6740456",
"0.6682505",
"0.66799736",
"0.6622509",
"0.65909576",
"0.65484... | 0.676675 | 14 |
HTTP 404 custom handler. | def custom_404(request, exception=None):
return render(request, "404.html", {"exception": exception}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handler404(request, *args, **argv):\n response = render_to_response('404.html', {})\n response.status_code = 404\n return response",
"def handleStatus_404(self):\n log.err('HTTP Error 404')",
"def handler404(request):\n response = render_to_response('404.html', {})\n response.status_c... | [
"0.85132957",
"0.8353488",
"0.8330883",
"0.81509715",
"0.8048861",
"0.80313754",
"0.786501",
"0.77363306",
"0.7723717",
"0.7723717",
"0.76770884",
"0.7660519",
"0.76588506",
"0.76477534",
"0.76434803",
"0.76398075",
"0.7615034",
"0.7605221",
"0.75976616",
"0.75976616",
"0.759... | 0.75459987 | 33 |
HTTP 500 custom handler. | def custom_500(request, exception=None):
return render(request, "500.html", {"exception": exception}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handler500(request, *args, **argv):\n response = render_to_response('500.html', {})\n response.status_code = 500\n return response",
"def handler500(request):\n response = render_to_response('500.html', {}, RequestContext(request))\n response.status_code = 500\n return response",
"def han... | [
"0.86234283",
"0.8478117",
"0.82295",
"0.786497",
"0.7826512",
"0.7707343",
"0.7634453",
"0.7619125",
"0.75892836",
"0.75564367",
"0.7447762",
"0.73859936",
"0.7378208",
"0.73606354",
"0.7347734",
"0.7283436",
"0.72626084",
"0.725488",
"0.72149926",
"0.72052675",
"0.7164875",... | 0.77075195 | 5 |
>>> s = Solution() >>> s.numSpecial([[1,0,0],[0,0,1],[1,0,0]]) 1 | def numSpecial(self, mat: list[list[int]]) -> int:
ans = 0
col_cache = {}
for row in mat:
# print(row)
ones = []
for i, n in enumerate(row):
if n == 1:
ones.append(i)
# print(ones)
if len(ones) == 1:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nits(self):",
"def J (self, n):",
"def __len__(self):\n if self.solution is None:\n return 0\n elif isinstance(self.solution, list):\n return len(self.solution)\n else:\n return 1",
"def double_nums(num_list):",
"def __init__(self, nums):\n d... | [
"0.5634397",
"0.533418",
"0.52352107",
"0.5177232",
"0.50461686",
"0.50198936",
"0.50171566",
"0.5002507",
"0.49893063",
"0.49433863",
"0.49368918",
"0.49326292",
"0.49240553",
"0.4905042",
"0.48826474",
"0.485887",
"0.4855875",
"0.48495466",
"0.48342177",
"0.48332715",
"0.48... | 0.6581576 | 0 |
get frame process frame handle result of processing process output | def run(self):
last_mean = 0
st = time.time()
sframe = 0
while True:
if time.time()-1 > st:
st = time.time()
#print 'fps', self.frame_counter - sframe
sframe = self.frame_counter
self.frame_counter += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_frame(self, frame):\n\t\treturn frame",
"def process_frame():\n return \"OK\"",
"def process_results(process_object):\n (stdout, stderr)=process_object.communicate()\n return (process_object.returncode, stdout, stderr)",
"def _get_output(self):\n return self.__output",
"def _get_out... | [
"0.665789",
"0.65517163",
"0.607196",
"0.6038569",
"0.6038569",
"0.6038569",
"0.6038569",
"0.6038569",
"0.6038569",
"0.59761804",
"0.5886538",
"0.5737582",
"0.5724387",
"0.572208",
"0.572208",
"0.5645779",
"0.5604923",
"0.5576578",
"0.5565851",
"0.5554697",
"0.55533904",
"0... | 0.0 | -1 |
Retrieve experiment specific phoneme information | def get_experiment_phn_info():
phone_list = ['##', 'aa', 'ae', 'ao', 'aw', 'ax', 'ay', 'bb', 'br',
'ch', 'dd', 'dh', 'eh', 'er', 'ey', 'ff', 'gg', 'hh', 'ih',
'iy', 'jh', 'kk', 'll', 'mm', 'ng', 'nn', 'ow', 'oy', 'pp',
'rr', 'sh', 'sp', 'ss', 'th', 'tt', 'uh', '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getexperimentinfo(expid):\n rdata = {}\n rdata['expId'] = expid\n res = requests.get(scbd_server_address + '/experiments/get_details', json=rdata)\n if res.status_code == 200:\n outstr = ''\n for cres in res.json()['details']:\n outstr += cres[0] + ':' + cres[1] + '<br>'\n ... | [
"0.5790809",
"0.5501423",
"0.5499727",
"0.5498819",
"0.54900473",
"0.54471534",
"0.53917515",
"0.5380888",
"0.5365359",
"0.53366756",
"0.5317841",
"0.52648",
"0.5258462",
"0.52435106",
"0.5186929",
"0.5146196",
"0.5093818",
"0.50938",
"0.50878394",
"0.50823444",
"0.5073125",
... | 0.6426803 | 0 |
return a tuple containing all the experiment specific speaker related information | def get_experiment_speaker_info(db_root):
seen_speakers = ['VCTK-speaker-p225-female',
'VCTK-speaker-p226-male',
'VCTK-speaker-p227-male',
'VCTK-speaker-p228-female',
'VCTK-speaker-p229-female',
'VCTK-speaker-p230-female',
'VCTK-speaker-p231-female',
'VCTK-speaker-p232-male',
'VCTK-speaker-p233-female',
'V... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def speaker_list(self):\n return \", \".join(str(speaker.person) for speaker in self.speakers.all())",
"def extract_speaker_data(self, X, y):\r\n\r\n speaker_names = []\r\n global_idx = 0\r\n curr_speaker_num = -1\r\n old_speaker = ''\r\n\r\n # Crawl the base and all sub... | [
"0.6471933",
"0.6339277",
"0.63172996",
"0.629798",
"0.61967725",
"0.60992134",
"0.60636175",
"0.5926962",
"0.580786",
"0.575381",
"0.5750333",
"0.5709002",
"0.5697383",
"0.56863433",
"0.564128",
"0.55814594",
"0.5512268",
"0.54673225",
"0.54642814",
"0.5446318",
"0.5411513",... | 0.72033405 | 0 |
sort `regions` in a descending order self The object regions A list of region which is in tuple form `regions` in a descending order. | def reverse_sort_regions(self, regions):
return sorted(regions, key=lambda region: region[0], reverse=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def concatregions(in_regions):\n out_regions = []\n if len(in_regions) == 0: # if no regions, then return empty\n return np.asarray(out_regions)\n for strand in [0,1]:\n # sort by left position\n on_strand = in_regions[in_regions[:,0] == strand]\n if len(on_strand) <= 1: # if 0... | [
"0.5818421",
"0.5711712",
"0.55216634",
"0.54087275",
"0.537096",
"0.5370231",
"0.5354793",
"0.5290695",
"0.51466596",
"0.5135079",
"0.5049498",
"0.49889728",
"0.49651736",
"0.495241",
"0.49407768",
"0.49245477",
"0.4892419",
"0.48727",
"0.48430598",
"0.48423144",
"0.48328733... | 0.8506791 | 0 |
called after changes have been made to a view self The object view The view True if a replacement happened, False otherwise. | def on_modified(self, view):
v = sublime.active_window().active_view()
# fix the issue that breaks functionality for undo/soft_undo
historyCmd = v.command_history(1) # this is from the redo stack
if historyCmd[0] == PLUGIN_CMD:
return False
print(v.command_history... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replaceView(self, modeId, newView):\n oldView = None\n for view in self.__views:\n if view.modeId() == modeId:\n oldView = view\n break\n elif isinstance(view, _CompositeDataView):\n # recurse\n hooks = self.getHook... | [
"0.6698093",
"0.6566338",
"0.63016355",
"0.62604386",
"0.61732435",
"0.60758954",
"0.5874421",
"0.5849249",
"0.5848018",
"0.5837404",
"0.57142",
"0.5711947",
"0.5706732",
"0.56667256",
"0.56494045",
"0.562875",
"0.5618073",
"0.55706793",
"0.5516057",
"0.5492775",
"0.5480724",... | 0.5966791 | 6 |
get the syntax file name and the syntax name which is on the bottomright corner of ST self The object view The view The current syntax. | def get_current_syntax(self, view):
syntaxFile = view.settings().get('syntax')
if syntaxFile not in syntaxInfos:
syntaxInfos[syntaxFile] = {
'fileName' : os.path.splitext(os.path.basename(syntaxFile))[0],
'syntaxName' : self.find_syntax_name(syntaxFile),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_syntax_name(self, syntaxFile):\n\n content = sublime.load_resource(syntaxFile).strip()\n\n # .tmLanguage (XML)\n if content.startswith('<'):\n matches = self.nameXmlRegex.search(content)\n # .sublime-syntax (YAML)\n else:\n matches = self.nameYamlRe... | [
"0.60397613",
"0.59165514",
"0.5733196",
"0.57180023",
"0.57087535",
"0.5576404",
"0.5452801",
"0.5322473",
"0.5300614",
"0.5289165",
"0.5253225",
"0.52486515",
"0.5197351",
"0.5190645",
"0.5080132",
"0.5079527",
"0.50793636",
"0.4998947",
"0.4986166",
"0.49765286",
"0.494739... | 0.69336903 | 0 |
find the name section in the give syntax file path self The object syntaxFile The path of a syntax file The syntax name of `syntaxFile` or None. | def find_syntax_name(self, syntaxFile):
content = sublime.load_resource(syntaxFile).strip()
# .tmLanguage (XML)
if content.startswith('<'):
matches = self.nameXmlRegex.search(content)
# .sublime-syntax (YAML)
else:
matches = self.nameYamlRegex.search(con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getSyntaxBySourceFileName(self, name, formatConverterFunction):\n for regExp, xmlFileName in self._extensionToXmlFileName.items():\n if regExp.match(name):\n return self._getSyntaxByXmlFileName(xmlFileName, formatConverterFunction)\n else:\n raise KeyError(\"... | [
"0.62873906",
"0.6136943",
"0.5446002",
"0.5399976",
"0.53163207",
"0.5222896",
"0.52083194",
"0.5134081",
"0.5114007",
"0.5108348",
"0.50795096",
"0.5013631",
"0.5010836",
"0.5007915",
"0.49805075",
"0.49515027",
"0.49298373",
"0.49222234",
"0.49050725",
"0.48783788",
"0.487... | 0.7932906 | 0 |
set employee name and salary | def __init__(self,fname,lname,salary):
self.first_name = fname
self.last_name = lname
self.salary = salary | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_salaried(self,salary,name):\n id = self.find_employee_id(name)\n if id in self.clsf:\n self.emp_dict[id][5] = \"2\"\n print(\"{}{}\".format(name,\" was successfully changed to be a salaried employee\"))\n self.emp_dict[id][7] = salary\n self.classi... | [
"0.72247374",
"0.66080004",
"0.6537093",
"0.64817953",
"0.64773196",
"0.64633507",
"0.637234",
"0.6360494",
"0.6305041",
"0.6234114",
"0.6188405",
"0.6122401",
"0.59281445",
"0.5886777",
"0.57775176",
"0.5758939",
"0.5757083",
"0.5713785",
"0.571265",
"0.56920433",
"0.5691727... | 0.5555704 | 28 |
give $5000 raise as default or raise as per inout | def give_raise(self,amount=5000):
self.salary += amount | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def give_raise(self, increase = 5000):\n\t\tself.increase = increase \n\t\tself.salary += increase",
"def give_raise(self, amount=5000):\n\t\tself.annual_salary += amount",
"def give_raise(self, amount=5000):\n self.salary += amount",
"def apply_raise(self):\n self.pay = int(self.pay * self.rai... | [
"0.66732913",
"0.6612099",
"0.6555888",
"0.6327619",
"0.6268917",
"0.6259644",
"0.62239206",
"0.6026449",
"0.5994266",
"0.5977445",
"0.59706587",
"0.5913774",
"0.58989495",
"0.58105314",
"0.57626814",
"0.57234055",
"0.56761575",
"0.5651629",
"0.5606309",
"0.5548258",
"0.55305... | 0.6504534 | 3 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder | def update_3(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
: Snapshots inspected, 'pass'
test/test_accel_amplitude.py
test/test_accel_deccel_amplitude.py
test/test_acceldeccel.py
test/test_accelerate.py
test/test_accelerate_speed.py
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def syncfolder():",
"def register_artifacts(self, which_pass):\n\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_INDEX_TABLE, which_pass\n )\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_STORE, which_pas... | [
"0.5904011",
"0.58413935",
"0.57848144",
"0.56511885",
"0.56056577",
"0.56036234",
"0.55917174",
"0.5542068",
"0.5518935",
"0.5510767",
"0.5492488",
"0.5471138",
"0.54641044",
"0.5460884",
"0.54597145",
"0.5448846",
"0.5443123",
"0.5436103",
"0.5423372",
"0.5380155",
"0.53798... | 0.5158686 | 37 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder | def update_6(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
: Snapshots inspected, 'pass'
test/test_cocosz.py
test/test_delay.py
test/test_draw.py
test/test_liquid_16_x_16.py
test/test_move_corner_down.py
test/test_move_corner_up.py... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def syncfolder():",
"def register_artifacts(self, which_pass):\n\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_INDEX_TABLE, which_pass\n )\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_STORE, which_pas... | [
"0.59056723",
"0.58410805",
"0.57843566",
"0.5651954",
"0.56048363",
"0.5604114",
"0.5592725",
"0.5542086",
"0.5518854",
"0.5509179",
"0.5492142",
"0.54697585",
"0.54642814",
"0.54608977",
"0.545977",
"0.5447512",
"0.5442904",
"0.54362696",
"0.5422522",
"0.5379201",
"0.534108... | 0.5380971 | 19 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder | def update_9(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
test/test_action_non_interval.py
test/test_all_collisions.py : puede no ser representativo; agregado z para ver si cuadrado rinde
test/test_draw_resolution.py
test/test_interpreter_layer.py : weak ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def syncfolder():",
"def register_artifacts(self, which_pass):\n\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_INDEX_TABLE, which_pass\n )\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_STORE, which_pas... | [
"0.59056723",
"0.58410805",
"0.57843566",
"0.5651954",
"0.56048363",
"0.5604114",
"0.5592725",
"0.5542086",
"0.5518854",
"0.5509179",
"0.5492142",
"0.54697585",
"0.54642814",
"0.54608977",
"0.545977",
"0.5447512",
"0.5442904",
"0.54362696",
"0.5422522",
"0.5380971",
"0.537920... | 0.0 | -1 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder | def update_19(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
test/test_aspect_16_9_to_fullscreen.py
test/test_aspect_4_3_to_fullscreen.py
test/test_aspect_ratio_on_resize.py
test/test_coords.py
test/test_custom_on_resize.py
test/test_entry_m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def syncfolder():",
"def register_artifacts(self, which_pass):\n\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_INDEX_TABLE, which_pass\n )\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_STORE, which_pas... | [
"0.59038097",
"0.58405656",
"0.5784711",
"0.5651934",
"0.5604398",
"0.5604276",
"0.55919385",
"0.5542104",
"0.55189013",
"0.5510264",
"0.54917127",
"0.54698503",
"0.5464448",
"0.5460157",
"0.5460076",
"0.5447427",
"0.5442345",
"0.54360855",
"0.54222316",
"0.53805226",
"0.5378... | 0.0 | -1 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder | def update_21(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
test/test_label_changing.py
test/test_batch2.py
test/test_scalexy.py
test/test_shader_examples.py
"""
candidates = doers.scripts_names_from_text(text, end_mark=':')
checked_in, unknown... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def syncfolder():",
"def register_artifacts(self, which_pass):\n\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_INDEX_TABLE, which_pass\n )\n artifact_manager.register_temp_file(\n config.MIRROR_NODES_STORE, which_pas... | [
"0.5904011",
"0.58413935",
"0.57848144",
"0.56511885",
"0.56056577",
"0.56036234",
"0.55917174",
"0.5542068",
"0.5518935",
"0.5510767",
"0.5492488",
"0.5471138",
"0.54641044",
"0.5460884",
"0.54597145",
"0.5448846",
"0.5443123",
"0.5436103",
"0.5423372",
"0.5380155",
"0.53798... | 0.0 | -1 |
Enter testrun info 'fail' or 'error' for some tests | def update_22(db, filename_persist, snapshots_dir, snapshots_reference_dir):
data = {
# 'fail'
'test/test_pyglet_vb.py' : {
'st': 'fail', 'diag': 'incomplete grossini rendition at first frame'},
# 'error'
'test/test_text_movement.py' : {
'st': 'error',
'diag': 'posit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_start(self):\n self.fail(\"write a test\")",
"def test_case_01(self):\n if True:\n self.fail()",
"def failed( self, mesg ):\n self.tests_failed += 1\n print \"fail: \" + mesg.rstrip()",
"def _test_run_with_short_error_msg(self, task_class):\r\n task_entr... | [
"0.6509504",
"0.64223963",
"0.6414181",
"0.6359421",
"0.6322421",
"0.6320431",
"0.63138866",
"0.63009924",
"0.62677574",
"0.6245532",
"0.6233363",
"0.6229177",
"0.6223931",
"0.6205429",
"0.62039953",
"0.6189725",
"0.61890954",
"0.6184349",
"0.61788744",
"0.61643875",
"0.61274... | 0.0 | -1 |
This files 'pass', register them as such and move their snapshots to the reference snapshots folder (but the second script should be updated for better autotest) | def update_23(db, filename_persist, snapshots_dir, snapshots_reference_dir):
text = """
test/test_fadeto.py
test/test_draw_elbows2.py
"""
candidates = doers.scripts_names_from_text(text, end_mark=':')
checked_in, unknown, move_failed = hl.update_testrun__pass(db,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_6(db, filename_persist, snapshots_dir, snapshots_reference_dir):\n text = \"\"\"\n : Snapshots inspected, 'pass'\n\n test/test_cocosz.py\n test/test_delay.py\n test/test_draw.py\n test/test_liquid_16_x_16.py\n test/test_move_corner_down.py\n test/test_... | [
"0.6359054",
"0.62082005",
"0.61056006",
"0.59230334",
"0.5728174",
"0.5716799",
"0.56549895",
"0.5625936",
"0.5621173",
"0.5597403",
"0.5585399",
"0.5543149",
"0.5535106",
"0.55044854",
"0.54968536",
"0.54944915",
"0.5480739",
"0.5479904",
"0.5454584",
"0.54531294",
"0.54304... | 0.53809464 | 27 |
get_aws_iam returns a dict with id and secret | def test_get_aws_iam(mock_system):
config = voithos.lib.config.DEFAULT_CONFIG
config["license"] = "11111111111111111111-2222222222222222222222222222222222222222"
mock_system.get_file_contents.return_value = json.dumps(config)
iam = aws.get_aws_iam()
assert "id" in iam
assert "secret" in iam
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_aws_secret(role):\n global AWS_ID\n AWS_ID += 1\n request.data\n return jsonify({\n \"request_id\": f\"a-request-id-{AWS_ID}\",\n \"lease_id\": f\"aws/creds/{role}/a-lease-id-{AWS_ID}\",\n \"renewable\": True,\n \"lease_duration\": 3600,\n \"data\": {\n ... | [
"0.725023",
"0.6431359",
"0.6358747",
"0.6328489",
"0.63060457",
"0.6280029",
"0.6222176",
"0.61839336",
"0.61627704",
"0.61163086",
"0.609",
"0.60536736",
"0.6049167",
"0.6023562",
"0.6014561",
"0.6012974",
"0.587488",
"0.5873585",
"0.5872633",
"0.58578235",
"0.578888",
"0... | 0.7496777 | 0 |
Fit model with MCMC, starting from MAP as initial value, and plot results | def fit_model(model):
print "Fitting vars:"
print model.vars.describe()
import time
start_time = time.time()
model.map = mc.MAP(model.vars)
model.map.fit(method='fmin_powell', verbose=1)
model.mcmc = mc.MCMC(model.vars)
model.mcmc.use_step_method(mc.AdaptiveMetropolis, mode... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def robust_lin_reg(df, var_map, \n steps=2000, mcmc='metropolis',\n plot_trace=True, plot_vars=True):\n import pymc3 as pm\n import pandas as pd\n import matplotlib.pyplot as plt\n import numpy as np\n import theano \n \n # Get cols\n df = df[var_map.valu... | [
"0.64326185",
"0.6002663",
"0.59082",
"0.5907472",
"0.5891982",
"0.58877134",
"0.5886521",
"0.58731794",
"0.57898426",
"0.5746489",
"0.5707085",
"0.5540485",
"0.5530723",
"0.55105585",
"0.5510401",
"0.54991907",
"0.54921657",
"0.5474497",
"0.53770715",
"0.5369792",
"0.5352105... | 0.62368906 | 1 |
Return a string response to a request | def serve(self) -> str:
return self._render() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, request):\r\n data = {\r\n 'results': 'THIS IS THE PROTECTED STRING FROM SERVER',\r\n }\r\n return Response(data, status=status.HTTP_200_OK)",
"def return_response_string(self):\n response = \"{} {}\\r\\n\".format(self.protocol, self.code)\n str_headers... | [
"0.74981505",
"0.7350811",
"0.7167688",
"0.71017843",
"0.6830472",
"0.67458236",
"0.6614951",
"0.66047513",
"0.65713",
"0.6560834",
"0.64871925",
"0.64846617",
"0.64349794",
"0.6416181",
"0.6400384",
"0.63373923",
"0.6288346",
"0.6281628",
"0.6238544",
"0.6194683",
"0.6193233... | 0.0 | -1 |
Return a string rendering of this view | def _render(self) -> str:
html = self._template.render(self._transient_context)
self._transient_context = None
return html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self):\n return render_to_string(\n self.template_name, self.get_context_data(), request=self.request\n )",
"def __str__(self):\n t = Template(\n \"\"\"\n <h4>$title</h4>\n $imgs\n $footnotes\n <hr/>\"\"\")\n ... | [
"0.80261445",
"0.7637391",
"0.7607511",
"0.74145526",
"0.7372933",
"0.7351635",
"0.7343746",
"0.73345333",
"0.73166084",
"0.7243189",
"0.7200906",
"0.7183523",
"0.71555793",
"0.71239877",
"0.7080639",
"0.7080639",
"0.7080639",
"0.7080639",
"0.7080639",
"0.7080639",
"0.7047732... | 0.71599025 | 12 |
Return a transient context for use in rendering the view | def generate_context(self) -> Context:
self._transient_context = Context()
return self._transient_context | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_context(self):\n return self.context.generate()",
"def context():\n return dict()",
"def get_context(self):\n return {}",
"def context(self) -> CONTEXT:",
"def get_context(self):\n return {\"request\": self.request, \"format\": self.format_kwarg, \"view\": self}",
"def get... | [
"0.77184707",
"0.7593439",
"0.75010717",
"0.7317102",
"0.72651404",
"0.7169451",
"0.70651585",
"0.70517874",
"0.6991241",
"0.695222",
"0.695222",
"0.695222",
"0.695222",
"0.695222",
"0.695222",
"0.695222",
"0.6935061",
"0.6920173",
"0.69052017",
"0.69001997",
"0.6891732",
"... | 0.75156814 | 2 |
Configure wrapper to use SPI. | def use_spi():
_LIB.oled_click_use_spi() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SPIsetup(self):\n self.writecmd(0x01,0x10,0,self.data); #SPI/SETUP",
"def _init_config(self, width, height, spi=None, spiMosi= None, spiDC=None, spiCS=None, spiReset=None, spiClk=None):\n self._spi = spi\n self._spi_mosi = spiMosi\n self._spi_dc = spiDC\n self._spi_cs = spi... | [
"0.64581645",
"0.60692745",
"0.57994145",
"0.5797513",
"0.5785946",
"0.57624316",
"0.57624316",
"0.57624316",
"0.57624316",
"0.575913",
"0.5678284",
"0.5665971",
"0.56648326",
"0.56648326",
"0.56648326",
"0.563461",
"0.563461",
"0.5623664",
"0.5560134",
"0.55506355",
"0.54671... | 0.63154364 | 1 |
Configure wrapper to use I2C. | def use_i2c():
_LIB.oled_click_use_i2c() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, machine):\n super().__init__(machine)\n self.features['has_i2c'] = True",
"def __init__(self, machine):\n super().__init__(machine)\n self.features['has_i2c'] = True",
"def ensureI2C(i2c=None):\n if i2c is None:\n logger.info('Initializing I2C.')\n ... | [
"0.66162145",
"0.66162145",
"0.65949684",
"0.63167465",
"0.6111046",
"0.6078323",
"0.58250207",
"0.5788781",
"0.5767513",
"0.5689637",
"0.5681065",
"0.55661315",
"0.5519384",
"0.55006874",
"0.5482283",
"0.5454556",
"0.5420815",
"0.5417926",
"0.53746414",
"0.53718674",
"0.5340... | 0.7479867 | 0 |
Enable the OLED click. | def enable(mikrobus_index):
ret = _LIB.oled_click_enable(mikrobus_index)
if ret < 0:
raise Exception("oled click enable failed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _led_enable():\n # type: () -> None\n GPIO.output(LED_nOE, GPIO.LOW)",
"def turn_on(self):\n GPIO.output(self.gpio, True) # turn on light",
"def enable(self):\n self.switch.enable()\n self._enabled = True",
"def enable():\n ret = _LIB.led_matrix_click_enable()\n if ret <... | [
"0.7803562",
"0.71197575",
"0.71039397",
"0.69039017",
"0.67663074",
"0.6755123",
"0.6752181",
"0.6694265",
"0.6667028",
"0.6605703",
"0.6582292",
"0.6561643",
"0.6561643",
"0.6537502",
"0.65163743",
"0.64581394",
"0.6453925",
"0.64473325",
"0.6443345",
"0.64403516",
"0.64364... | 0.74189276 | 1 |
Write a pixel buffer on the Oled display. Each bit of the array represents the state of a pixel. The first 96 bytes represent the first page (96x8 pixels), the following 96 bytes represent the second page... | def raw_write(data):
buf = (ctypes.c_uint8 * 384)(*data)
ret = _LIB.oled_click_raw_write(buf)
if ret < 0:
raise Exception("oled click raw write failed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitmap(arr, dc):\n wiringPy.digital_write(pin_DC, dc)\n wiringPy.digital_write_serial_array(0, struct.pack('B'*len(arr), *arr))",
"def set_pixel(self, x, y, r, g, b, a):\n\t\t\n\t\ti = 4 * (y * self.width + x)\n\t\tself.buffer[i : i + 4] = array.array('f', struct.pack('ffff', r, g, b, a))",
"def _sav... | [
"0.6251184",
"0.6223932",
"0.61893326",
"0.60717803",
"0.6011565",
"0.600209",
"0.5915968",
"0.5871335",
"0.58328456",
"0.5809756",
"0.5783888",
"0.5709632",
"0.57080525",
"0.56664234",
"0.5656356",
"0.56479025",
"0.562347",
"0.55849427",
"0.557958",
"0.5566176",
"0.55603415"... | 0.52128667 | 46 |
Write some text on the Oled display. | def write_text(text):
ret = _LIB.oled_click_write_text(ctypes.c_char_p(text.encode('utf-8')))
if ret < 0:
raise Exception("oled click write text failed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_text(self, text):\n self.write_to_serial(':DISP:TEXT \\'' + text + '\\'')",
"def WriteText(self, text):\n print(text)",
"def printt(self, data):\r\n self.text_ctrl_output.AppendText(data)",
"def Print(self,text = \"\"):\n self.Bus.Write_String(self.Address,0x00, text)",
... | [
"0.8052281",
"0.73763824",
"0.71736574",
"0.70968753",
"0.7006892",
"0.6958783",
"0.6950346",
"0.69271636",
"0.6902415",
"0.6863863",
"0.68558705",
"0.6836492",
"0.683297",
"0.68294656",
"0.68263483",
"0.68179524",
"0.68005294",
"0.67513156",
"0.6740279",
"0.67395735",
"0.672... | 0.6721604 | 21 |
Convert a character into an array of 22 bytes. | def get_char(c):
data = (ctypes.c_uint8 * 22)()
ret = _LIB.oled_click_get_char(c, ctypes.byref(data))
if ret < 0:
raise Exception("oled click get char failed")
return [data[i] for i in range(22)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bytes_as_char_array(b):\n return \"{ \" + \", \".join(\"0x%02x\" % x for x in b) + \" }\"",
"def to_char_array(s):\n if type(s) != bytes:\n raise ValueError('Input to to_char_array function should be in bytes')\n char_array = []\n tokens = s.split(b' ')\n for token in tokens:\n c... | [
"0.6772518",
"0.64857394",
"0.6455129",
"0.6275554",
"0.6080935",
"0.6075504",
"0.6041937",
"0.6011441",
"0.6011441",
"0.60084045",
"0.5997307",
"0.59810466",
"0.59715194",
"0.59327745",
"0.5909544",
"0.5848634",
"0.58313006",
"0.58160806",
"0.5803004",
"0.5797645",
"0.578704... | 0.57538843 | 23 |
Disable the OLED click. | def disable():
ret = _LIB.oled_click_disable()
if ret < 0:
raise Exception("oled click disable failed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _led_disable():\n # type: () -> None\n GPIO.output(LED_nOE, GPIO.HIGH)",
"def disable():\n ret = _LIB.led_matrix_click_disable()\n if ret < 0:\n raise Exception(\"led matrix click disable failed\")",
"def turn_off(self):\n GPIO.output(self.gpio, False) # turn off light",
"def t... | [
"0.809518",
"0.7531012",
"0.7469522",
"0.72568923",
"0.7174813",
"0.71696955",
"0.71069515",
"0.71025395",
"0.70688444",
"0.70502096",
"0.704196",
"0.70280635",
"0.70278597",
"0.6998497",
"0.6984781",
"0.6962407",
"0.69579947",
"0.6957407",
"0.6956076",
"0.6949486",
"0.694127... | 0.8671251 | 0 |
Pump until there is no more input or output. Returns whether any data was moved. | def flush(self, debug=False):
result = False
for x in range(1000):
if self.pump(debug):
result = True
else:
break
else:
assert 0, "Too long"
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_until_stop(self):\n while self.commands[self.pointer] != END:\n # Get the cmd\n cmd = self.commands[self.pointer]\n opcode = cmd % 100\n modes = cmd // 100\n \n vals, locs, self.pointer = get_vals_and_locs(opcode, modes, self.pointer, self.co... | [
"0.5977106",
"0.57480776",
"0.56906104",
"0.5683975",
"0.5607149",
"0.558183",
"0.55323035",
"0.5428544",
"0.54132",
"0.5409012",
"0.5401055",
"0.5396786",
"0.53637314",
"0.535892",
"0.5358188",
"0.53309345",
"0.53243923",
"0.53135455",
"0.52789587",
"0.52524316",
"0.52387816... | 0.5209061 | 23 |
Move data back and forth. Returns whether any data was moved. | def pump(self, debug=False):
if self.debug or debug:
print '-- GLUG --'
sData = self.serverIO.getOutBuffer()
cData = self.clientIO.getOutBuffer()
self.clientIO._checkProducer()
self.serverIO._checkProducer()
if self.debug or debug:
print '.'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self) -> bool:\n pass",
"def move_down(self):\n if self.pointer < (len(self._contents)-1):\n logging.debug(\"moved down\")\n self.pointer += 1 \n self.refresh() \n return True\n else: \n return False",
"def has_moved(self)... | [
"0.6548814",
"0.59832346",
"0.59732103",
"0.58637434",
"0.5830981",
"0.5820136",
"0.57540244",
"0.5660683",
"0.56401706",
"0.56389946",
"0.5632333",
"0.56197184",
"0.5614149",
"0.56067765",
"0.5605793",
"0.55919355",
"0.55858994",
"0.55379903",
"0.5512463",
"0.5510148",
"0.54... | 0.0 | -1 |
Returns a list of valid words. Words are strings of lowercase letters. Depending on the size of the word list, this function may take a while to finish. | def loadWords():
print "Loading word list from file..."
# inFile: file
inFile = open(WORDLIST_FILENAME, 'r', 0)
# wordList: list of strings
wordList = []
for line in inFile:
wordList.append(line.strip().lower())
print " ", len(wordList), "words loaded."
return wordList | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_words(f: str, letters: List[str]) -> List[str]:\r\n forbidden_letters = [i for i in string.ascii_lowercase]\r\n for i in letters:\r\n try:\r\n forbidden_letters.remove(i)\r\n except:\r\n pass\r\n words_file = open(f)\r\n word_list = []\r\n letstr = \"\"\r\... | [
"0.7713766",
"0.717011",
"0.7087718",
"0.6993999",
"0.69623536",
"0.6962017",
"0.69448495",
"0.6917324",
"0.6899307",
"0.68871945",
"0.6885995",
"0.68723124",
"0.6845915",
"0.68409246",
"0.6833867",
"0.6833511",
"0.6822346",
"0.68203837",
"0.6806308",
"0.6800549",
"0.673057",... | 0.6601317 | 34 |
Returns a dictionary where the keys are elements of the sequence and the values are integer counts, for the number of times that an element is repeated in the sequence. | def getFrequencyDict(sequence):
# freqs: dictionary (element_type -> int)
freq = {}
for x in sequence:
freq[x] = freq.get(x,0) + 1
return freq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def counts(sequence):\n # initialize the countainer\n count = defaultdict(int)\n # iterates through sequence elements\n for item in sequence:\n # if element not in counts add 0\n # else add 1\n count[item] = count.get(item, 0) + 1\n return dict(count)",
"def count_elements(seq... | [
"0.88433635",
"0.8707861",
"0.8707861",
"0.8238257",
"0.81628364",
"0.78431886",
"0.7644035",
"0.762158",
"0.7452036",
"0.7337739",
"0.7311011",
"0.6998471",
"0.68835694",
"0.68639237",
"0.6829713",
"0.6818011",
"0.67900753",
"0.67836136",
"0.6756537",
"0.6749939",
"0.6742152... | 0.8210399 | 5 |
Returns the score for a word. Assumes the word is a valid word. The score for a word is the sum of the points for letters in the word, multiplied by the length of the word, PLUS 50 points if all n letters are used on the first turn. Letters are scored as in Scrabble; A is worth 1, B is worth 3, C is worth 3, D is worth... | def getWordScore(word, n):
score = 0
for letters in word:
if letters in SCRABBLE_LETTER_VALUES:
score += SCRABBLE_LETTER_VALUES[letters]
if len(word) == n:
return (score * len(word)) + 50
else:
return score * len(word) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getWordScore(word, n):\n score = 0\n for letter in word:\n score += SCRABBLE_LETTER_VALUES[letter]\n score *= len(word)\n if len(word) == n:\n score += 50\n return score",
"def get_word_score(word, n=7):\n score = 0\n\n for i in word:\n score += SCRABBLE_LETTER_VALUE... | [
"0.84181976",
"0.82934874",
"0.8220061",
"0.8052078",
"0.8041427",
"0.7843509",
"0.7650167",
"0.7636099",
"0.7610513",
"0.75861526",
"0.7409019",
"0.7204724",
"0.70169866",
"0.70130014",
"0.6928664",
"0.6779603",
"0.67548424",
"0.67543375",
"0.67239964",
"0.66737604",
"0.6667... | 0.8374879 | 1 |
Displays the letters currently in the hand. | def displayHand(hand):
for letter in hand.keys():
for j in range(hand[letter]):
print letter, # print all on the same line
print # print an empty line | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def displayHand(hand: d_si) -> None:\n for letter in hand.keys():\n for _ in range(hand[letter]):\n print(letter,end=\" \")\n print()",
"def displayHand(hand):\r\n for letter in hand.keys():\r\n for j in range(hand[letter]):\r\n print(letter,end=\" \") # print ... | [
"0.76924473",
"0.76908666",
"0.7630516",
"0.7603937",
"0.70320636",
"0.69698924",
"0.68899405",
"0.68821144",
"0.6802938",
"0.674929",
"0.6746151",
"0.67160624",
"0.6569305",
"0.6542722",
"0.6519904",
"0.6488587",
"0.648419",
"0.6351849",
"0.6351849",
"0.6351849",
"0.62965095... | 0.75768644 | 4 |
Returns a random hand containing n lowercase letters. At least n/3 the letters in the hand should be VOWELS. Hands are represented as dictionaries. The keys are letters and the values are the number of times the particular letter is repeated in that hand. | def dealHand(n):
hand={}
numVowels = n / 3
for i in range(numVowels):
x = VOWELS[random.randrange(0,len(VOWELS))]
hand[x] = hand.get(x, 0) + 1
for i in range(numVowels, n):
x = CONSONANTS[random.randrange(0,len(CONSONANTS))]
hand[x] = hand.get(x, 0) + 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deal_hand(n):\n hand = {}\n num_vowels = n // 3\n\n for i in range(num_vowels):\n x = VOWELS[random.randrange(0, len(VOWELS))]\n hand[x] = hand.get(x, 0) + 1\n\n for i in range(num_vowels, n):\n x = CONSONANTS[random.randrange(0, len(CONSONANTS))]\n hand[x] =... | [
"0.78006905",
"0.7678525",
"0.7669588",
"0.74499804",
"0.6461991",
"0.6153672",
"0.60777944",
"0.60667515",
"0.60564005",
"0.5998895",
"0.59673965",
"0.59573287",
"0.59163105",
"0.59163105",
"0.59163105",
"0.5879762",
"0.58750254",
"0.584636",
"0.5825631",
"0.58003813",
"0.57... | 0.76973146 | 1 |
Assumes that 'hand' has all the letters in word. In other words, this assumes that however many times a letter appears in 'word', 'hand' has at least as many of that letter in it. | def updateHand(hand, word):
tempHand = hand.copy()
for letters in word:
if letters in tempHand:
tempHand[letters] -= 1
return tempHand | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidWord(word, hand, wordList):\n myHand = hand.copy() \n for letter in word:\n if letter not in hand or myHand[letter] <= 0:\n return False\n else:\n myHand[letter] -= 1 \n if word not in wordList:\n return False\n else:\n return T... | [
"0.7523692",
"0.73815393",
"0.72896904",
"0.72852725",
"0.72229683",
"0.7206578",
"0.7138506",
"0.71194625",
"0.7096104",
"0.70616984",
"0.6982035",
"0.69689786",
"0.69662434",
"0.69557613",
"0.6898297",
"0.6891437",
"0.6696662",
"0.66834134",
"0.6676677",
"0.66196877",
"0.65... | 0.69068694 | 14 |
Returns True if word is in the wordList and is entirely composed of letters in the hand. Otherwise, returns False. Does not mutate hand or wordList. | def isValidWord(word, hand, wordList):
tempHand = hand.copy()
if len(word) > 0 and word in wordList:
for letter in word:
if letter not in tempHand or tempHand[letter] <= 0:
return False
else:
tempHand[letter] = tempHand.get(letter, 0) - 1
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidWord(word, hand, wordList):\r\n \r\n \r\n if type(word) != str:\r\n return False\r\n \r\n if word not in wordList:\r\n return False\r\n \r\n for letter in word:\r\n if letter not in hand:\r\n return False\r\n \r\n updatedHand = hand.copy()\r\n ... | [
"0.81876624",
"0.8107502",
"0.7984113",
"0.7944561",
"0.79433525",
"0.7854562",
"0.7823658",
"0.77725965",
"0.7753029",
"0.77365476",
"0.77109057",
"0.7666229",
"0.76648957",
"0.74651563",
"0.735434",
"0.730834",
"0.7299409",
"0.7229836",
"0.7229836",
"0.7229836",
"0.7094772"... | 0.7918604 | 5 |
Returns the length (number of letters) in the current hand. | def calculateHandlen(hand):
return sum(hand.itervalues()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_length(self):\r\n return len(self.hand)",
"def calculate_handlen(hand):\n handlen = len(hand)\n return handlen",
"def get_length(self):\r\n return len(self.deck)",
"def handsize(self):\n return self._handsize",
"def get_length(self):\n return len(self.cards)",
"d... | [
"0.8455392",
"0.7924513",
"0.75295866",
"0.73232204",
"0.7322879",
"0.7170316",
"0.71048033",
"0.70595866",
"0.70591575",
"0.703998",
"0.703998",
"0.70157504",
"0.70006496",
"0.6982251",
"0.6982251",
"0.69610137",
"0.69566923",
"0.69514513",
"0.69469476",
"0.6931802",
"0.6922... | 0.728664 | 5 |
Allow the user to play an arbitrary number of hands. 1) Asks the user to input 'n' or 'r' or 'e'. If the user inputs 'n', let the user play a new (random) hand. If the user inputs 'r', let the user play the last hand again. If the user inputs 'e', exit the game. If the user inputs anything else, tell them their input w... | def playGame(wordList):
hand = None
while True:
selection = raw_input("Enter n to deal a new hand, r to replay the last hand, or e to end game:")
if selection == 'n':
hand = dealHand(HAND_SIZE)
playHand(hand, wordList, HAND_SIZE)
print
eli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_game(word_list):\n # TO DO ...\n\n hand = deal_hand(HAND_SIZE) # random init\n\n while True:\n cmd = input('Enter n to deal a new hand, r to replay the last hand, or e to end game: ')\n\n if cmd == 'n':\n hand = deal_hand(HAND_SIZE)\n play_hand(hand.copy(), wo... | [
"0.77609646",
"0.76356065",
"0.7516967",
"0.75046504",
"0.7053985",
"0.69752824",
"0.6643235",
"0.6316062",
"0.6228966",
"0.61934215",
"0.61589503",
"0.6122529",
"0.6072859",
"0.60151553",
"0.6011535",
"0.6007752",
"0.6001467",
"0.5992759",
"0.5989423",
"0.5976205",
"0.596974... | 0.7623381 | 2 |
Generates a JWT token valid for 10 minutes using the private key. | def generate_jwt_token(private_pem: bytes, app_id: int) -> str:
private_key = jwcrypto.jwk.JWK.from_pem(private_pem)
payload = {"iss": app_id}
duration = datetime.timedelta(minutes=10)
return python_jwt.generate_jwt(payload, private_key, "RS256", duration) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_jwt_token(self):\n import jwt\n from datetime import datetime, timedelta\n from django.conf import settings\n\n dt = datetime.now() + timedelta(days=60)\n\n token = jwt.encode({\n 'id': self.pk,\n 'username': self.username,\n 'exp': ... | [
"0.7184967",
"0.7133718",
"0.6737407",
"0.67275083",
"0.6704615",
"0.65334314",
"0.6511841",
"0.64169765",
"0.64080316",
"0.6331098",
"0.62940425",
"0.62615675",
"0.6237678",
"0.621826",
"0.6174233",
"0.6108475",
"0.60688114",
"0.6027714",
"0.6024385",
"0.59928554",
"0.595844... | 0.7318258 | 0 |
Generates an installation access token using a JWT token and an installation id. An installation access token is valid for 1 hour. | def generate_installation_access_token(jwt_token: str, installation_id) -> str:
headers = {
"Authorization": f"Bearer {jwt_token}",
"Accept": "application/vnd.github.machine-man-preview+json",
"User-Agent": USER_AGENT,
}
url = f"https://api.github.com/app/installations/{installation_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_access_token():\n return do_build_access_token(tenant_id='intility_tenant_id')",
"def get_token(app_id, installation_id):\n token_url = f\"{API_BASE_URL}/app/installations/{installation_id}/access_tokens\"\n temp_state = str(uuid.uuid4())\n private_key = get_private_key()\n\n # Required ... | [
"0.6996901",
"0.6979113",
"0.6809183",
"0.67003566",
"0.6534887",
"0.6493192",
"0.6465398",
"0.6324435",
"0.6281636",
"0.62720484",
"0.6217066",
"0.62050366",
"0.61707485",
"0.6150757",
"0.61372226",
"0.60964096",
"0.6017347",
"0.6011306",
"0.592635",
"0.59209037",
"0.5904168... | 0.8433338 | 0 |
Reads a private PEM file from an S3 bucket. | def get_pem(bucket_name: str, bucket_key: str) -> bytes:
s3 = boto3.resource("s3")
s3.Bucket(bucket_name).download_file(bucket_key, "/tmp/key.pem")
with open("/tmp/key.pem", "rb") as f:
return f.read() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_s3_file(bucket, key):\r\n try:\r\n s_3 = boto3.client('s3')\r\n file = s_3.get_object(Bucket=bucket, Key=key)\r\n file_body = file['Body'].read().decode(\"utf-8\")\r\n return file_body\r\n\r\n except (FileNotFoundError, IndexError, SystemExit, OSError, IOError) as err:\r\... | [
"0.7351964",
"0.7110344",
"0.70346",
"0.6955667",
"0.69070524",
"0.6842378",
"0.6714841",
"0.6691865",
"0.6596183",
"0.6484976",
"0.6464774",
"0.62390226",
"0.62254405",
"0.62190664",
"0.62123066",
"0.6198812",
"0.616393",
"0.61633474",
"0.6101623",
"0.60783464",
"0.60682744"... | 0.74012285 | 0 |
Checks if the MAC (message authentication code) sent in the request is really from GitHub. | def authenticate_request(shared_secret: str, body: str, signature: str) -> bool:
if signature is None:
return False
sha_body = hmac.new(
shared_secret.encode("utf8"), body.encode("utf8"), hashlib.sha1
).hexdigest()
_, sha_github = signature.split("=")
return hmac.compare_digest(sha_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _identify_mac(self, request):\n params = parse_authz_header(request, None)\n if params is None:\n return None\n if params.get(\"scheme\") != \"MAC\":\n return None\n # Check that various parameters are as expected.\n token = params.get(\"id\")\n i... | [
"0.62339866",
"0.57387596",
"0.5716142",
"0.5713359",
"0.5712786",
"0.56901765",
"0.5681487",
"0.5649187",
"0.55427325",
"0.5540321",
"0.55339146",
"0.55098766",
"0.54962564",
"0.5493968",
"0.54877156",
"0.545417",
"0.5438969",
"0.54327047",
"0.54191214",
"0.5394371",
"0.5342... | 0.56696975 | 7 |
Sets the learning rate to the initial LR decayed by 0.2 every steep step | def pt_adjust_learning_rate(epoch, opt, optimizer):
# if epoch < 2:
# for param_group in optimizer.param_groups:
# param_group['lr'] = 1e-7
# return 0
# print(epoch)
# print(np.asarray(opt.pt_lr_decay_epochs))
steps = np.sum(epoch > np.asarray(opt.pt_lr_decay_epochs))
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_learning_rate(self):\n\n if (self.FLAGS.learning_rate_decay is \"exponential\"):\n self.learning_rate = tf.train.exponential_decay(\n self.FLAGS.learning_rate,\n self.global_step,\n self.... | [
"0.79089844",
"0.7856753",
"0.7856753",
"0.76767546",
"0.75567615",
"0.75240135",
"0.75000376",
"0.7454447",
"0.7426672",
"0.74171114",
"0.7404257",
"0.7401694",
"0.7386987",
"0.73657304",
"0.7329806",
"0.73260325",
"0.73156565",
"0.7304068",
"0.73000455",
"0.7264402",
"0.725... | 0.0 | -1 |
Sets the learning rate to the initial LR decayed by 10 every 30 epochs | def ft_adjust_learning_rate(optimizer, intial_lr, epoch, lr_steps):
decay = 0.3 ** (sum(epoch >= np.array(lr_steps)))
lr = intial_lr * decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adjust_learning_rate(init_lr, optimizer, epoch, n=100):\n init_lr = init_lr * (0.1 ** (epoch // n))\n print('learning rate : ', init_lr)\n for param_group in optimizer.param_groups:\n param_group['lr'] = init_lr",
"def adjust_learning_rate(start_lr, optimizer, epoch, total_epoch_num):\n #l... | [
"0.79140896",
"0.7908034",
"0.7850816",
"0.7776915",
"0.7735598",
"0.7732588",
"0.7723862",
"0.77235436",
"0.77208304",
"0.7710736",
"0.76948273",
"0.7675381",
"0.76670265",
"0.76670265",
"0.76670265",
"0.7657111",
"0.76431805",
"0.7640621",
"0.7639109",
"0.76275903",
"0.7625... | 0.7563326 | 36 |
Function to parse features from GeoDataFrame in such a manner that rasterio wants them | def getFeatures(gdf):
import json
features = [json.loads(gdf.to_json())['features'][0]['geometry']]
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0]['geometry']]",
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0]['geometry']]",
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0][... | [
"0.70252776",
"0.70252776",
"0.70252776",
"0.70073014",
"0.7006912",
"0.66584796",
"0.6582383",
"0.6436205",
"0.6337286",
"0.6247641",
"0.6246245",
"0.6210641",
"0.6190014",
"0.61856955",
"0.6074713",
"0.605977",
"0.60548824",
"0.60548824",
"0.6047158",
"0.6041518",
"0.602713... | 0.6990803 | 5 |
Converts node to a string | def __str__(self):
return str(self._key) + ", " + str(self._value[0]) + ", " + str(self._value[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodeToString(cls, node):\n return lxml.etree.tostring(node, method='html').decode()",
"def as_str(node):\n node_string = ' '.join(k for k, _ in node.leaves())\n return u' '.join(node_string.split())",
"def test_node_to_str(self):\n f = lws.node_to_str\n # normal\n ... | [
"0.8387049",
"0.82369703",
"0.75747645",
"0.7456867",
"0.7450837",
"0.73087424",
"0.70796245",
"0.70432127",
"0.70348823",
"0.69631356",
"0.69130164",
"0.68732697",
"0.6834229",
"0.6753791",
"0.674325",
"0.6713926",
"0.6698366",
"0.6690693",
"0.6684852",
"0.6667392",
"0.66580... | 0.0 | -1 |
Initializes the priority heap | def __init__(self, g):
self._data = []
self.graph = g
self.pqLocator = {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.min_heap = []\n self.max_heap = []\n self.size_max, self.size_min = 0, 0",
"def __init__(self):\n self.min_heap = []\n self.max_heap = []",
"def __init__(self):\n self.__max_heap = []\n self.__min_heap = []",
"def __init__(self):\n ... | [
"0.7895022",
"0.78730625",
"0.78242964",
"0.7812003",
"0.7795688",
"0.77610606",
"0.7727318",
"0.7712711",
"0.77093875",
"0.7683902",
"0.7657671",
"0.764797",
"0.76411146",
"0.76411146",
"0.76411146",
"0.76315606",
"0.76188815",
"0.75978863",
"0.75660425",
"0.756221",
"0.7523... | 0.0 | -1 |
Converts the priority heap to a string | def __str__(self):
return '\n\n'.join(str(item) for item in self._data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return str(self._heap)",
"def __str__(self) -> str:\n return 'HEAP ' + str(self.heap)",
"def __str__(self) -> str:\n return 'HEAP ' + str(self.heap)",
"def __str__(self):\n\n string = \"[\"\n for i in range(1, self.i , 1):\n try:\n ... | [
"0.7485955",
"0.7094816",
"0.7094816",
"0.67488325",
"0.6633048",
"0.62878686",
"0.6045484",
"0.59887344",
"0.5947995",
"0.5898321",
"0.5829193",
"0.57599413",
"0.5745034",
"0.5654975",
"0.56530416",
"0.5631066",
"0.5626237",
"0.56002146",
"0.55961776",
"0.55735004",
"0.55630... | 0.0 | -1 |
Finds if heap is empty | def empty(self):
return True if len(self) == 0 else False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty(heap):\n return size(heap) == 0",
"def is_empty(self):\n return self.heap_size <= 0",
"def is_empty(self):\n return len(self.__heap) == 0",
"def is_empty(self) -> bool:\n return self.heap.length() == 0",
"def is_empty(self) -> bool:\n return self.heap.length() == 0"... | [
"0.87432164",
"0.8080125",
"0.80508566",
"0.7974598",
"0.7974598",
"0.78623253",
"0.7857394",
"0.7734315",
"0.7480083",
"0.71097034",
"0.69872475",
"0.6981132",
"0.6887114",
"0.6812178",
"0.67947066",
"0.67928696",
"0.6768594",
"0.67281306",
"0.6711304",
"0.6684485",
"0.66307... | 0.0 | -1 |
Minimum value in the min heap | def top(self):
# if not empty
if not self.empty():
return self._data[0].get_value()[1].course
# if empty
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min(self):\n return self.heap[1]",
"def get_min(h: Heap) -> Node:\n prev, curr = _min(h)\n return curr",
"def find_min_in_max_heap(self):\n min_number = None\n last_parent = (self.size - 1) // 2\n first_leaf = last_parent + 1\n # Shortcut to find first_leaf:\n ... | [
"0.80066824",
"0.79924774",
"0.7953096",
"0.7922488",
"0.7861636",
"0.7807199",
"0.773033",
"0.7653231",
"0.7630557",
"0.7614359",
"0.76007307",
"0.74046606",
"0.7337545",
"0.72455674",
"0.7219387",
"0.72004133",
"0.71765816",
"0.7166307",
"0.7158743",
"0.7147012",
"0.7126886... | 0.0 | -1 |
Adds an element to the heap | def push(self, key, val):
# create new node and add to data
new_ele = Node(key, val)
self._data.append(new_ele)
# percolate number into correct place
self.percolate_up(len(self)-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, element):\n # add element to the heap\n self.heap.append(element)\n\n # get index of added element and parent of added element\n index = len(self.heap) - 1\n parentIndex = (index - 1) // 2\n\n # swap parents and childs while needed\n while index >= 1 a... | [
"0.83968014",
"0.8395562",
"0.83507353",
"0.80548006",
"0.7984432",
"0.7979835",
"0.7967062",
"0.7937237",
"0.79159236",
"0.7915377",
"0.789867",
"0.786664",
"0.7776185",
"0.7742011",
"0.7721637",
"0.7721637",
"0.7709229",
"0.76871336",
"0.7682712",
"0.7673222",
"0.76684994",... | 0.0 | -1 |
Removes minimum element of the heap | def pop(self):
# if not empty
if not self.empty():
# swap min element with last and pop from data
popped = self._data[0]
self.swap(0, len(self)-1) # swap elements
self._data.pop()
# move swapped node to correct place
self.percolate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_min(self):\n #The length is 1 because the heap list was initialized with 0\n if len(self.heap_list) == 1:\n return \"Empty heap.\"\n\n #Store the min value of the heap\n top = self.heap_list[1]\n\n #Move the last value of the heap to the top\n self.he... | [
"0.83863187",
"0.8268813",
"0.8243556",
"0.8172819",
"0.8009114",
"0.7942755",
"0.7838469",
"0.7836379",
"0.7799861",
"0.77351683",
"0.76470023",
"0.7637858",
"0.7591406",
"0.7585167",
"0.75569344",
"0.7526615",
"0.74768615",
"0.7413565",
"0.7364462",
"0.725336",
"0.7238196",... | 0.0 | -1 |
Finds the minimum child of the index | def max_child(self, index):
# left and right child
left = self._data[(index*2)+1] if (index*2)+1 < len(self) else None
right = self._data[(index*2)+2] if (index*2)+2 < len(self) else None
# if has both children
if left and right:
if left < right:
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min_child(self, index):\n if self.empty():\n return None\n if self._has_left(index):\n left = self._left(index)\n small_child = left\n if self._has_right(index):\n right = self._right(index)\n if self._data[right] < self._d... | [
"0.80425453",
"0.791862",
"0.7847695",
"0.7785256",
"0.75363547",
"0.7435741",
"0.7424413",
"0.73639077",
"0.71918046",
"0.71815383",
"0.70990807",
"0.7095202",
"0.70832723",
"0.70796996",
"0.70733607",
"0.7018999",
"0.6948961",
"0.69062304",
"0.68996906",
"0.6890181",
"0.686... | 0.67524004 | 26 |
Moves node at index up to correct position in it's branch | def percolate_up(self, index):
# reached root
if index == 0:
return
p_ind = (index-1)//2
# swap if parent is greater than current and continue percolating
if self._data[p_ind] > self._data[index]:
self.swap(p_ind, index)
self.percolate_up(p_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift_item_up(self, index):\n while index > 0:\n parent_index = index // 2\n if parent_index > 0 and self.heaplist[parent_index] < self.heaplist[index]:\n self.heaplist[parent_index], self.heaplist[index] = self.heaplist[index], self.heaplist[parent_index]\n ... | [
"0.7009742",
"0.67257226",
"0.67239445",
"0.6688178",
"0.65012705",
"0.64163274",
"0.64070076",
"0.6321453",
"0.62840545",
"0.6257231",
"0.6249017",
"0.6238124",
"0.620318",
"0.6138193",
"0.6126185",
"0.6125101",
"0.6112156",
"0.6093909",
"0.6091938",
"0.60718596",
"0.6055841... | 0.65998065 | 4 |
Moves node down to correct position in tree | def percolate_down(self, index):
child = self.max_child(index)
# swap if child is less than than current and continue percolating
if child and self._data[child] < self._data[index]:
self.swap(child, index)
self.percolate_down(child) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_to_node(self,node):\n path=self.get_path(self.current_node,node)\n self.move_to(path)",
"def move_down(self):\n\n next_sibling = self.get_next_sibling()\n if next_sibling!=None: \n self.move_to(next_sibling,'right')\n self.save()",
"def move_up(self):\... | [
"0.72382915",
"0.7134786",
"0.7060045",
"0.69184643",
"0.68837345",
"0.68561095",
"0.6826683",
"0.679074",
"0.6742192",
"0.664455",
"0.6588179",
"0.6588179",
"0.6588179",
"0.6588179",
"0.65466446",
"0.64491093",
"0.64305204",
"0.6385504",
"0.63706255",
"0.63670796",
"0.634902... | 0.0 | -1 |
Changes the key of the node at index | def change_priority(self, index, new_key):
# if index is within array
if index < len(self):
old_key = self._data[index].get_key()
self._data[index].set_key(new_key)
# if new key greater percolate down
if new_key > old_key:
self.percolate_d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_key(self, i, key):\n self.__keys[i] = key\n self.__swim(self.__qp[i])\n self.__sink(self.__qp[i])",
"def _key_generated(self, key, index):\n self.keys[self.get_address(key)] = key\n self.last_generated_index = index",
"def transfer_key_counter_clockwise(self, index... | [
"0.6950654",
"0.6736145",
"0.67204005",
"0.6658157",
"0.65645784",
"0.6562288",
"0.6557089",
"0.65253705",
"0.64411515",
"0.6421411",
"0.6420965",
"0.64163303",
"0.6392428",
"0.63772845",
"0.6363883",
"0.6359659",
"0.6347571",
"0.63453865",
"0.6337254",
"0.63109064",
"0.63013... | 0.6091664 | 38 |
Swapping item at index x and y | def swap(self, x, y):
self._data[x], self._data[y] = self._data[y], self._data[x] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swap(ix, jx, ax, ay):\n tempx, tempy = ax[ix], ay[ix]\n ax[ix] = ax[jx]\n ay[ix] = ay[jx]\n ax[jx] = tempx\n ay[jx] = tempy",
"def _swap(self, i, j):\n self._data[i], self._data[j] = self._data[j], self._data[i]",
"def _swap(self, i, j):\n self._data[i], self._data[j] = self._data[j], ... | [
"0.76685715",
"0.75711036",
"0.75711036",
"0.7535092",
"0.7397885",
"0.73663235",
"0.73580956",
"0.7349034",
"0.7334804",
"0.7314467",
"0.72962046",
"0.7253714",
"0.7218827",
"0.71823746",
"0.7175004",
"0.71747667",
"0.71580243",
"0.71521693",
"0.71480864",
"0.71342266",
"0.7... | 0.73140013 | 10 |
Add `self` to the current session and optionally commits | def save(self, commit=True):
db.session.add(self)
if commit:
db.session.commit()
logger.info(
'{} {} saved'.format(self.__class__.__name__, self.id))
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commit(self):\n db.session.add(self)\n db.session.commit()",
"def add(self):\n with managed_session() as session:\n session.add(self)\n session.flush()\n session.refresh(self)\n session.expunge(self)",
"def save(self):\r\n s = self.get... | [
"0.7331662",
"0.7142118",
"0.70269156",
"0.6803673",
"0.6794338",
"0.6794338",
"0.6736462",
"0.6722512",
"0.6670579",
"0.6655404",
"0.6650521",
"0.65264803",
"0.65223646",
"0.6519931",
"0.64977217",
"0.64977217",
"0.64977217",
"0.64977217",
"0.64977217",
"0.64977217",
"0.6497... | 0.6096156 | 40 |
Removes `self` to the current session and optionally commits | def delete(self, commit=True):
db.session.delete(self)
if commit:
db.session.commit()
logger.info(
'{} {} deleted'.format(self.__class__.__name__, self.id))
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self):\n with managed_session() as session:\n session.delete(self)",
"def remove(self):\n db.session.delete(self)\n db.session.commit()",
"def delete(self):\r\n s = self.get_session()\r\n s.delete(self)\r\n s.commit()",
"def remove_data(self):\n... | [
"0.72724396",
"0.7219021",
"0.7042429",
"0.6749172",
"0.66947454",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6635438",
"0.6613953",
"0.64947295",
"0.64789134",
"0.6435805",
"0.6435805",
"0.6383086",
"0.63283646"... | 0.57677335 | 66 |
Returns the maximum number of kubernetes jobs | def get_maximum_number_of_allowed_k8s_jobs(dry_run: bool = False) -> int:
retval = 5000
JSON_PATH = r"'{.spec.hard.count/jobs\.batch}'"
cmd = f'kubectl get resourcequota gke-resource-quotas -o=jsonpath={JSON_PATH}'
if not dry_run:
try:
p = safe_exec(cmd)
if p.stdout:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def jobserver_max_jobs():\n\n if _MakeJobServer._singleton is not None:\n return _MakeJobServer._singleton.num_jobs\n else:\n return 0",
"def maximum_number_of_workers(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"maximum_number_of_workers\")",
"def maximum_number_of_worke... | [
"0.78179955",
"0.75503117",
"0.7508189",
"0.73179954",
"0.7272363",
"0.7165923",
"0.7165923",
"0.7165923",
"0.7165923",
"0.7165923",
"0.70873964",
"0.69605875",
"0.6936822",
"0.6898711",
"0.6891758",
"0.6864941",
"0.6856878",
"0.68284523",
"0.6810833",
"0.6802255",
"0.6756869... | 0.8028468 | 0 |
Return a list of persistent volume ids for a kubernetes cluster. Kubeconfig file determines the cluster that will be contacted. | def get_persistent_volumes(k8s_ctx: str) -> List[str]:
cmd = f'kubectl --context={k8s_ctx} get pv -o json'
p = safe_exec(cmd)
try:
dvols = json.loads(p.stdout.decode())
except Exception as err:
raise RuntimeError('Error when parsing listing of Kubernetes persistent volumes ' + str(err))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_persistent_disks(k8s_ctx: str, dry_run: bool = False) -> List[str]:\n cmd = f'kubectl --context={k8s_ctx} get pv -o json'\n if dry_run:\n logging.info(cmd)\n else:\n p = safe_exec(cmd)\n if p.stdout:\n pds = json.loads(p.stdout.decode())\n return [i['spec... | [
"0.66107404",
"0.6445898",
"0.5872532",
"0.5834013",
"0.57105106",
"0.57075375",
"0.5590087",
"0.5556461",
"0.55296147",
"0.5528321",
"0.5513306",
"0.5472359",
"0.54522735",
"0.54383785",
"0.54374796",
"0.542925",
"0.53947073",
"0.53806466",
"0.5363869",
"0.5344736",
"0.53418... | 0.69992113 | 0 |
Return a list of persistent disks for a kubernetes cluster. Kubeconfig file determines the cluster that will be contacted. | def get_persistent_disks(k8s_ctx: str, dry_run: bool = False) -> List[str]:
cmd = f'kubectl --context={k8s_ctx} get pv -o json'
if dry_run:
logging.info(cmd)
else:
p = safe_exec(cmd)
if p.stdout:
pds = json.loads(p.stdout.decode())
return [i['spec']['csi']['vo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ceph_disk():\n disks = []\n for srv in get_srv_list():\n cfg = get_srv_config(srv)\n for key in ['osd_data', 'osd_journal', 'mds_data', 'mon_data']:\n mnt_point = cfg[key]\n disk = get_disk_by_mountpoint(find_mount_point(mnt_point))\n if disk not in disk... | [
"0.69804466",
"0.65357673",
"0.62569875",
"0.6242567",
"0.6178439",
"0.6145541",
"0.61331636",
"0.61212426",
"0.61172605",
"0.6103872",
"0.6091794",
"0.6074201",
"0.6053231",
"0.597123",
"0.5810261",
"0.57258034",
"0.5673861",
"0.56392694",
"0.5635887",
"0.55451983",
"0.55267... | 0.73454463 | 0 |
Retry kubernetes job submissions with the parameters specified in the decorator | def submit_jobs_with_retries(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:
return submit_jobs(k8s_ctx, path, dry_run) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retry_job(\n self,\n ) -> Callable[[cloud_deploy.RetryJobRequest], cloud_deploy.RetryJobResponse]:\n # Generate a \"stub function\" on-the-fly which will actually make\n # the request.\n # gRPC handles serialization and deserialization, so we just need\n # to pass in the f... | [
"0.69828594",
"0.6794983",
"0.6765454",
"0.66975325",
"0.6523476",
"0.6380863",
"0.63713455",
"0.6340863",
"0.6169279",
"0.61630946",
"0.6125724",
"0.6113218",
"0.6111197",
"0.60778093",
"0.60651016",
"0.6061368",
"0.6057735",
"0.60167474",
"0.60050476",
"0.5981546",
"0.59133... | 0.59404534 | 20 |
Submit kubernetes jobs using yaml files in the provided path. | def submit_jobs(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:
retval = list()
if not path.exists():
raise RuntimeError(f'Path with kubernetes jobs "{path}" does not exist')
if path.is_dir():
num_files = len(os.listdir(str(path)))
if num_files == 0 and not dry_run:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def submit_jobs_with_retries(k8s_ctx: str, path: pathlib.Path, dry_run=False) -> List[str]:\n return submit_jobs(k8s_ctx, path, dry_run)",
"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--file', '-f',\n type=argparse.FileType('r'),\n ... | [
"0.6221261",
"0.5811291",
"0.5430136",
"0.54265577",
"0.53359383",
"0.52959836",
"0.5294317",
"0.52891713",
"0.52890307",
"0.5270789",
"0.52489644",
"0.52117705",
"0.5200493",
"0.5173163",
"0.5100042",
"0.5079487",
"0.5079471",
"0.5078372",
"0.5067541",
"0.50371045",
"0.50299... | 0.72203076 | 0 |
Delete all kubernetes jobs, persistent volume claims, and persistent volumes. | def delete_all(k8s_ctx: str, dry_run: bool = False) -> List[str]:
commands1 = [f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=setup',
f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=blast']
commands2 = [f'kubectl --context={k8s_ctx} delete pvc -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_jobs(self):\n jobs = self.get_jobs(self.age)\n print('Jobs queued for delete: ', jobs)\n for job in jobs:\n try: \n body = k_client.V1DeleteOptions(propagation_policy='Background')\n self.kube_v1_batch_client.delete_namespaced_job(job, body=b... | [
"0.7011506",
"0.6865935",
"0.6693092",
"0.66884226",
"0.66858184",
"0.6641274",
"0.65057886",
"0.64343244",
"0.642385",
"0.6397125",
"0.63845754",
"0.6333038",
"0.6206506",
"0.61990374",
"0.6195",
"0.6106106",
"0.61037713",
"0.60304976",
"0.60248446",
"0.6022556",
"0.59941286... | 0.75015736 | 0 |
Run the commands in the argument list and return the names of the relevant k8s objects. This function is specific to delete_all. | def run_commands(commands: List[str], dry_run: bool) -> List[str]:
result = []
for cmd in commands:
if dry_run:
logging.info(cmd)
else:
p = safe_exec(cmd)
if p.stdout:
for line in p.stdout.decode().split('\n'):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_all(k8s_ctx: str, dry_run: bool = False) -> List[str]:\n commands1 = [f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=setup',\n f'kubectl --context={k8s_ctx} delete jobs --ignore-not-found=true -l app=blast']\n commands2 = [f'kubectl --context={k8s_ctx} dele... | [
"0.78953844",
"0.6110259",
"0.6092635",
"0.608586",
"0.6070033",
"0.60426444",
"0.59926337",
"0.5909514",
"0.58847016",
"0.5745861",
"0.5739375",
"0.5739248",
"0.573826",
"0.5714165",
"0.5710907",
"0.5709907",
"0.5706169",
"0.5691667",
"0.5688918",
"0.5684755",
"0.5675016",
... | 0.6005288 | 6 |
Delete finalizers to ensure PV and PVC get deleted | def delete_finalizers(k8s_ctx: str, dry_run: bool = False):
cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'
for storage_obj in run_commands([cmd], dry_run):
cmd = f'kubectl --context={k8s_ctx} patch {storage_obj} -p '
cmd += '{"metadata":{"finalizers":null}}'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finalizer():\n for resource_type in pods, pvcs, storageclasses, secrets:\n for resource in resource_type:\n resource.delete()\n resource.ocp.wait_for_delete(resource.name)\n if pools:\n # Delete only the RBD pool\n pools[0].delete()\n... | [
"0.78778726",
"0.68315476",
"0.639127",
"0.63186175",
"0.62764853",
"0.6226027",
"0.6223201",
"0.61615956",
"0.61301416",
"0.612153",
"0.6120431",
"0.6120431",
"0.6120431",
"0.6109426",
"0.6105209",
"0.60924125",
"0.60924125",
"0.60924125",
"0.6078456",
"0.6068378",
"0.606651... | 0.7561303 | 1 |
Retrieve information about PV and PVC from kubectl and log it for debugging purposes. | def inspect_storage_objects_for_debugging(k8s_ctx: str, dry_run: bool = False):
cmd = f'kubectl --context={k8s_ctx} get pv,pvc -o=NAME'
for storage_obj in run_commands([cmd], dry_run):
cmd = f'kubectl --context={k8s_ctx} describe {storage_obj}'
if dry_run:
logging... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_pv_by_pvc_name_description(namespace, k8s_cli, retries):\n pv_output = \"\"\n error_template = \"Namespace '{}': Failed to get {} resource: {{}}.\".format(namespace, \"PersistentVolumeClaim\")\n volumes_names = get_pv_names(k8s_cli, namespace, error_template)\n for volume in volumes_names:\... | [
"0.61853266",
"0.5792927",
"0.5758242",
"0.57081366",
"0.5688722",
"0.5639404",
"0.55854255",
"0.5542733",
"0.55318034",
"0.5493715",
"0.5396289",
"0.53871465",
"0.53501064",
"0.5298621",
"0.5275156",
"0.5263584",
"0.5230812",
"0.5208932",
"0.51616544",
"0.5160978",
"0.515081... | 0.6945199 | 0 |
Delete all volume snapshots associated with the kubernetes cluster | def delete_volume_snapshots(k8s_ctx: str, dry_run: bool = False):
# We are not using --force=true here to do a graceful deletion. Volume
# snapshot does not need to wait for any pod or job to be deleted and it
# is fine if deletion takes some time. --ignore-not-found defaults to true
# if --all is used.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snap_delete_all(mnode):\n cmd = \"gluster snapshot delete all --mode=script\"\n return g.run(mnode, cmd)",
"def delete_volume_snapshot(volume_snapshots):\n if type(volume_snapshots) is not list:\n volumes = [volume_snapshots]\n command = 'cinder snapshot-delete %s' % \\\n \" \... | [
"0.72916466",
"0.694778",
"0.6632236",
"0.66130334",
"0.6478083",
"0.6477406",
"0.63046324",
"0.62845635",
"0.62041503",
"0.6171982",
"0.6118543",
"0.6096079",
"0.6044555",
"0.60432434",
"0.60415065",
"0.6008003",
"0.59782016",
"0.5899641",
"0.5896192",
"0.5867627",
"0.586752... | 0.8123454 | 0 |
Return a list of kubernetes jobs | def get_jobs(k8s_ctx: str, selector: Optional[str] = None, dry_run: bool = False) -> List[str]:
cmd = 'kubectl --context={k8s_ctx} get jobs -o json'
if selector is not None:
cmd += f' -l {selector}'
if dry_run:
logging.info(cmd)
return list()
p = safe_exec(cmd)
if not p.stdo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_jobs():\n\n name_to_job_details = redis_controller.get_name_to_job_details()\n return list(name_to_job_details.values())",
"def jobs():\n result = []\n out = subprocess.check_output([\"/bin/launchctl\", \"list\"]).decode()\n for row in out.splitlines()[1:]:\n result.append(Job(row)... | [
"0.79306775",
"0.7741598",
"0.7518071",
"0.7471795",
"0.7458499",
"0.74025124",
"0.73712224",
"0.7338191",
"0.7267556",
"0.72309756",
"0.72155577",
"0.72155577",
"0.72001016",
"0.7166212",
"0.706977",
"0.70534074",
"0.7034029",
"0.7031616",
"0.70106757",
"0.69732976",
"0.6967... | 0.84486145 | 0 |
Wait for the job to return successfully or raise a TimeoutError after specified number of attempts | def _wait_for_job(k8s_ctx: str, job_file: pathlib.Path, attempts: int = 30, secs2wait: int = 60, dry_run: bool = False) -> None:
for counter in range(attempts):
if _job_succeeded(k8s_ctx, job_file, dry_run):
break
time.sleep(secs2wait)
else:
raise TimeoutError(f'{job_file} t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _wait_retry(self) -> None:\n # Sleep 2^tries + 0…tries*3 seconds between retries\n self.retry_task = asyncio.create_task(\n asyncio.sleep(2 ** min(9, self.tries) + random.randint(0, self.tries * 3))\n )\n await self.retry_task\n self.retry_task = None",
"de... | [
"0.6805994",
"0.67427564",
"0.66825926",
"0.6454168",
"0.6368625",
"0.6354731",
"0.63537157",
"0.63452667",
"0.63171816",
"0.6291563",
"0.62773556",
"0.6274619",
"0.6184791",
"0.61747164",
"0.6170765",
"0.6160677",
"0.6152056",
"0.6144066",
"0.61388767",
"0.61302525",
"0.6112... | 0.7734525 | 0 |
Checks whether the job file passed in as an argument has succeeded or not. Returns true if the job succeeded, false otherwise. If the job failed, a RuntimeError is raised. | def _job_succeeded(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> bool:
if not k8s_job_file.exists():
raise FileNotFoundError(str(k8s_job_file))
cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'
if dry_run:
logging.info(cmd)
return True
p ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isJobRunning ( self ):\n #cmd = \"qstat \" + str(self.jobid)\n \n #magicString='Unknown Job Id' ### magicString _might_ need to be changed if Torque version changes\n #(output, error) = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()\... | [
"0.67143625",
"0.66477233",
"0.6379032",
"0.6379032",
"0.6247778",
"0.62245816",
"0.6209879",
"0.6126895",
"0.6095487",
"0.60941005",
"0.60333455",
"0.60249513",
"0.6003191",
"0.5996906",
"0.59792376",
"0.59495425",
"0.5948564",
"0.5945208",
"0.5917747",
"0.590241",
"0.588247... | 0.6971786 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.