def update_entry_handler(request, context): log.info('put call got request: {0}'.format(request)) response = dict(success=False, message='') if isinstance(request, str) or isinstance(request, unicode): try: log.info('Got string request, converting to JSON.') request = json.loads(request) except ValueError: log.warning('got malformed JSON request: {0}'.format(request)) msg = get_error_message(BAD_REQUEST, 'Malformed JSON in request.') raise PutCallException(msg) if not validate_request_params(request): msg = get_error_message(BAD_REQUEST, 'Parameter mismatch: validation failed.') raise PutCallException(msg) try: # this time return JSON, not stringified response = request.update(dict(calles='PUT')) return response except PutCallException: log.info('Error on response') log.info('response was {0}'.format(response)) msg = get_error_message(BAD_REQUEST, response['message']) raise PutCallException(msg) except: log.error('exception in update: {0}'.format(request)) log.error(traceback.print_exc()) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in PUT call request !') raise PutCallException(msg)
def patch_handler(request, context): log.debug('got patch request: {0}'.format(request)) response = dict(success=False, message='') if isinstance(request, str) or isinstance(request, unicode): try: log.info('Got string request, converting to JSON.') request = json.loads(request) except ValueError: log.warning('got malformed JSON request: {0}'.format(request)) msg = get_error_message(BAD_REQUEST, 'Malformed JSON in request.') raise PatchCallException(msg) if not validate_request_params(request): log.warning('Request validation failed.') msg = get_error_message( BAD_REQUEST, 'Parameter mismatch: please see documentation.') raise PatchCallException(msg) try: response['message'] = json.dumps(request.update(dict(called='PATCH'))) return response except PatchCallException: log.info('Error response from VREG.') log.info('response was: {0}'.format(response)) msg = get_error_message(BAD_REQUEST, response['message']) raise PatchCallException(msg) except: log.error('exception in reset: {0}'.format(request)) log.error(traceback.print_exc()) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in patch request !') raise PatchCallException(msg)
def execute_handler(request_handler, evt, ctx, timeout): try: start_time = time.time() data = base64.b64decode(evt.decode()) event = json.loads(data) signal.alarm(int(timeout)) result = request_handler(event, ctx) except Exception as user_ex: end_time = time.time() exc_info = sys.exc_info() message = get_error_message(user_ex, exc_info[2], True) if isinstance(user_ex, MemoryError): message = "Out of Memory" elif isinstance(user_ex, TimeoutError): message = "Time out" return False, message, round(end_time - start_time, 2) else: end_time = time.time() signal.alarm(0) if not isinstance(result, (str, bytes)): try: return True, make_json(result), round(end_time - start_time, 2) except TypeError: return True, str(result), round(end_time - start_time, 2) return True, str(result), round(end_time - start_time, 2)
def update_nodes(graph, max_allowed_error): lines = read_csv("{0}/matching_error.csv".format(var.CERE_REPLAY_PATH)) for line in lines: #for region_name, error in matching.iteritems(): #find the node in the graph for n,d in graph.nodes(data=True): if line["Codelet Name"] == d['_name']: d['_invivo'] = float(line["Invivo"]) d['_invitro'] = float(line["Invitro"]) d['_tested'] = True if float(line["Error"]) <= max_allowed_error: d['_matching'] = True else: d['_valid'] = False d['_error'] = float(line["Error"]) if utils.is_invalid(d['_name']): d['_error_message'] = utils.get_error_message(d['_name']) invocations = read_csv("{0}/invocations_error.csv".format(var.CERE_REPLAY_PATH)) del d['_invocations'][:] for inv in invocations: if inv["Codelet Name"] == d['_name']: d['_invocations'].append({"Cluster":inv["Cluster"], "Invocation":inv["Invocation"], "Part":round(float(inv["Part"]), 2), "Invivo (cycles)":"{:e}".format(float(inv["Invivo"])), "Invitro (cycles)":"{:e}".format(float(inv["Invitro"])), "Error (%)":round(float(inv["Error"]), 2)}) d['_tested'] = True d['_to_test'] = False save_graph(graph) plot(graph)
def handle_exception(self, exc): if isinstance(exc, tuple(self.expected_exceptions.keys())): drf_exception_class = self.expected_exceptions[exc.__class__] drf_exception = drf_exception_class(get_error_message(exc)) return super().handle_exception(drf_exception) return super().handle_exception(exc)
def clean(self, value): try: captcha_response = captcha.submit( value.get('recaptcha_challenge_field'), value.get('recaptcha_response_field'), get_private_key(), '', # remote user's IP address. See footnotes. ) except Exception: # this is probably bad. error_message = get_error_message('recaptcha-not-reachable') raise ValidationError(error_message) if not captcha_response.is_valid: error_message = get_error_message(captcha_response.error_code) raise ValidationError(error_message) return value
def ru_morpher(imgpaths, width=500, height=600, num_frames=20, fps=10, \ out_frames=None, out_video=None, alpha=False, plot=False, obj=None, sessionid=None): """ Create a morph sequence from multiple images in imgpaths :param imgpaths: array or generator of image paths :param callback: callback function on each point """ oBack = {'status': 'ok', 'msg': ''} try: video = videoer.Video(out_video, fps, width, height) images_points_gen = load_valid_image_points(imgpaths, (height, width)) src_img, src_points = next(images_points_gen) iStep = 0 for dest_img, dest_points in images_points_gen: debugMsg("ru_morpher step {}".format(iStep)) morph(src_img, src_points, dest_img, dest_points, video, width, height, num_frames, fps, out_frames, out_video, alpha, plot, obj=obj, sessionid=sessionid, result_type="image") # Set the new source = old destination src_img, src_points = dest_img, dest_points iStep += 1 # Check if any faces could be found in the image if iStep == 0: # This means that the points could not be found on the image print('debug point #3 in: ru_morpher') # No points were found oBack['status'] = "error" oBack['msg'] = "Er kan geen gezicht gevonden worden in dit beeld" debugMsg(oBack['msg']) debugMsg("ru_morpher video.end") video.end() except: sMsg = get_error_message() DoError("ru_morpher: ") oBack['status'] = 'error' oBack['msg'] = sMsg finally: return oBack
def add_something_handler(request, context): log.info('POST call - got request: {0}'.format(request)) response = dict(success=False, message='') if isinstance(request, str) or isinstance(request, unicode): try: log.info('Got string request, converting to JSON.') request = json.loads(request) except ValueError: log.warning('got malformed JSON request: {0}'.format(request)) raise PostCallException('Malformed JSON in request.') # special no op call, if noop is the only key in the request, just return the context # and a short message if 'noop' in request and request.get('noop'): if not request.get('skiplog'): log.info('NoOp called !') log.info('Nothing else was called, just Ping-Pong.') response = dict(message='No Op call successful', context=context, success=True) return response if not validate_request_params(request): msg = get_error_message(BAD_REQUEST, 'Parameter mismatch: validation failed.') raise PostCallException(msg) try: response['message'] = json.loads(request.update(dict(called='POST'))) except PostCallException: log.info('Error returned.') log.info('response was: {0}'.format(response)) msg = get_error_message(BAD_REQUEST, response['message']) raise PostCallException(msg) except: log.error('exception in a post call: {0}'.format(request)) log.error(traceback.print_exc()) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in POST request !') raise PostCallException(msg) return response
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'astronomer_date_check': return 'Data zgonu powinna późniejsza niż data urodzenia.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'Istnieją obserwacje wykonane przez tego astronoma. Spróbuj zmienić te obserwacje lub je usunąć.' elif code == -1: return 'Astronom o tym samym imieniu już istnieje.' return get_error_message(code, message)
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'galaxy_group_right_ascension_check': return 'Rektasencja powinna być pomiędzy 0 a 24.' elif constraint == 'galaxy_group_declination_check': return 'Deklinacja powinna być pomiędzy -90 a 90.' elif constraint == 'galaxy_group_distance_check': return 'Dystans powinien być większy lub równy 0.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'W tej grupie istnieją galaktyki lub istnieją obserwacje tej grupy. Spróbuj usunąć lub zmienić je najpierw.' return get_error_message(code, message)
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'satellite_period_check': return 'Okres musi być większy lub równy 0.' elif constraint == 'satellite_inclination_check': return 'Inklinacja powinna być pomiędzy 0 a 180 stopni.' elif constraint == 'satellite_date_check': return 'Data zniszczenia musi być później niż data startu.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'Istnieją obserwacje tego satelity lub jest on w katalogu. Spróbuj usunąć lub zmienić obserwacje i usunąć obiekt z katalogów.' return get_error_message(code, message)
def handle_node_package(package_name: str, mode: str, metadata: Metadata): """ Installs a node/npm package handling metadata for the method #### Arguments package_name (str): The name of the node/npm package to be installed version (str): The version of the node/npm package to be installed mode (str): The method (installation/uninstallation) metadata (`Metadata`): Metadata for the method """ version_proc = Popen(mslex.split('npm --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) version, err = version_proc.communicate() version = version.decode().strip() if err: click.echo(click.style('npm Or node Is Not Installed. Exit Code [0011]', fg='bright_yellow')) utils.disp_error_msg(utils.get_error_message('0011', 'install', package_name, None, metadata, packet.json_name), metadata) utils.handle_exit('ERROR', None, metadata) if mode == 'install': proc = Popen(mslex.split(f'npm i {package_name} -g'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) write(f'npm v{version} :: Collecting {package_name}', 'bright_green', metadata) package_version = None for line in proc.stdout: line = line.decode() if 'node install.js' in line: write(f'npm v{version} :: Running `node install.js` for {package_name}', 'bright_green', metadata) if package_name in line and '@' in line and 'install' in line or ' postinstall' in line: package_version = line.split()[1] write(f'npm v{version} :: {package_version} Installing To <=> "{line.split()[3]}"', 'bright_green', metadata) if 'Success' in line and package_name in line or 'added' in line: write(f'npm v{version} :: Successfully Installed {package_version}', 'bright_green', metadata) if 'updated' in line: if package_version: write(f'npm v{version} :: Sucessfully Updated {package_version}', 'bright_green', metadata) else: write(f'npm v{version} :: Sucessfully Updated {package_name}', 'bright_green', metadata) else: proc = Popen(mslex.split(f'npm uninstall -g {package_name}'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'up to date' in line: write(f'npm v{version} :: Could Not Find Any Existing Installations Of {package_name}', 'bright_yellow', metadata) if 'removed' in line: number = line.split(' ')[1].strip() time = line.split(' ')[4].strip() write(f'npm v{version} :: Sucessfully Uninstalled {package_name} And {number} Other Dependencies in {time}', 'bright_green', metadata)
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'latitude_check': return 'Szerokość geograficzna powinna być pomiędzy -90 a 90 stopni.' elif constraint == 'longitude_check': return 'Długość geograficzna powinna być pomiędzy -180 a 180 stopni.' elif constraint == 'coordinates_present': return 'Podaj obie współrzędne.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'Istnieją obserwacje wykonane w tym obserwatorium. Spróbuj zmienić ich obserwatorium lub je usunąć.' elif code == -1: return 'Obserwatorium o tym samym kodzie IAU już istnieje.' return get_error_message(code, message)
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'meteor_shower_right_ascension_check': return 'Rektasencja powinna być pomiędzy 0 a 24.' elif constraint == 'meteor_shower_declination_check': return 'Deklinacja powinna być pomiędzy -90 a 90.' elif constraint == 'meteor_shower_velocity_check': return 'Prędkość powinna być większa lub równa 0.' elif constraint == 'meteor_shower_zhr_check': return 'ZHR powinno być większe lub równe 0.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'Istnieją obserwacje tego roju meteorów lub jest on w katalogu. Spróbuj usunąć lub zmienić obserwacje i usunąć obiekt z katalogów.' return get_error_message(code, message)
def delete_handler(request, context): log.info('delete_call - got request: {0}'.format(request)) response = dict(success=False, message='') if isinstance(request, str) or isinstance(request, unicode): try: log.info('Got string request, converting to JSON.') request = json.loads(request) except ValueError: log.warning('got malformed JSON request: {0}'.format(request)) msg = get_error_message(BAD_REQUEST, 'Malformed JSON in request.') raise DeleteCallException(msg) if not validate_request_params(request): msg = get_error_message(BAD_REQUEST, 'Parameter mismatch, validation failed.') raise DeleteCallException(msg) try: # do some stuff to delete an entry in the system here # maybe send AMQP message, do database work, etc ... response['message'] = 'delete call successful' return response except DeleteCallException: log.info('Error response') log.info('response was: {0}'.format(response)) msg = get_error_message(BAD_REQUEST, response['message']) raise DeleteCallException(msg) except: log.error('exception in delete call: {0}'.format(request)) log.error(traceback.print_exc()) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in delete call request !') raise DeleteCallException(msg)
def check_for_image_points(path): points = [] try: print("check_for_image_points 1") if os.path.isfile(path): img = cv2.imread(path) print("check_for_image_points 2: read image") points = locator.face_points(img) print("check_for_image_points 3: {}".format(len(points))) else: print("check_for_image_points - file does not exist: {}".format( path)) except: sMsg = get_error_message() DoError("check_for_image_points: ") return (len(points) > 0)
def execute_invoke(environ): try: # get_fc_logger().info(constant.LOG_TAIL_START_PREFIX_INVOKE + get_request_id()) # validate request if get_request_id() is None: return constant.STATUS_ERR, "request id is none" if environ[constant.HTTP_REQUEST_METHOD] != constant.METHOD_POST: return constant.STATUS_ERR, "http method should be post" if environ[constant.HTTP_PATH_INFO] != constant.INVOKE_PATH: return constant.STATUS_ERR, "path should be /invoke" evt, ctx, handler = parse_params(environ) # load user handler md5 = environ[constant.HTTP_FUNCTION_MD5] code_path = environ[constant.HTTP_FUNCTION_CODE_PATH] load_success, request_handler = load_handler(handler, md5, code_path) if not load_success: status, message = request_handler() process_mem_info = psutil.Process(os.getpid()).memory_info() return status, gen_return_dict(process_mem_info, message, 0) # limit memory process_mem_info = psutil.Process(os.getpid()).memory_info() limit_as = int( process_mem_info.vms) + int(ctx.function.memory_size) * 1024 * 1024 soft, hard = resource.getrlimit(resource.RLIMIT_AS) resource.setrlimit(resource.RLIMIT_AS, (limit_as, hard)) # execute handler execute_success, resp_msg, time_usage = execute_handler( request_handler, evt, ctx, environ[constant.HTTP_FUNCTION_TIMEOUT]) if not execute_success: ret_code = constant.STATUS_USER_ERR else: ret_code = constant.STATUS_OK return ret_code, gen_return_dict(process_mem_info, resp_msg, time_usage) except Exception as ex: exc_info = sys.exc_info() ret = get_error_message(ex, exc_info[2]) process_mem_info = psutil.Process(os.getpid()).memory_info() return constant.STATUS_ERR, gen_return_dict(process_mem_info, ret, 0) finally: pass
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'small_body_period_check': return 'Okres musi być większy lub równy 0.' elif constraint == 'small_body_eccentricity_check': return 'Ekscentryczność powinna być większa lub równa 0.' elif constraint == 'small_body_semi_major_axis_check': return 'Półoś wielka powinna być większa lub równa 0.' elif constraint == 'small_body_inclination_check': return 'Inklinacja powinna być pomiędzy 0 a 180 stopni.' elif constraint == 'small_body_mass_check': return 'Masa powinna być większa lub równa 0.' elif constraint == 'small_body_diameter_check': return 'Średnica powinna być większa lub równa 0.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'To małe ciało jest orbitowane lub istnieją obserwacje tego obiektu. Spróbuj usunąć lub zmienić je najpierw.' return get_error_message(code, message)
def get_error_message(self, code, message): if code == 3819: # ER_CHECK_CONSTRAINT_VIOLATED constraint = message.split("'")[1] if constraint == 'star_right_ascension_check': return 'Rektasencja powinna być pomiędzy 0 a 24.' elif constraint == 'star_declination_check': return 'Deklinacja powinna być pomiędzy -90 a 90.' elif constraint == 'star_distance_check': return 'Dystans powinien być większy lub równy 0.' elif constraint == 'star_parallax_check': return 'Paralaksa powinna być większa lub równa 0.' elif constraint == 'star_mass_check': return 'Masa powinna być większa lub równa 0.' elif constraint == 'star_radius_check': return 'Promień powinien być większy lub równy 0.' elif code == 1217: # ER_ROW_IS_REFERENCED return 'Ta gwiazda jest orbitowana przez inne ciało lub istnieją obserwacje tej gwiazdy. Spróbuj usunąć lub zmienić je najpierw.' return get_error_message(code, message)
def update_nodes(graph, max_allowed_error): lines = read_csv("{0}/matching_error.csv".format(var.CERE_REPLAY_PATH)) for line in lines: #for region_name, error in matching.iteritems(): #find the node in the graph for n, d in graph.nodes(data=True): if line["Codelet Name"] == d['_name']: d['_invivo'] = float(line["Invivo"]) d['_invitro'] = float(line["Invitro"]) d['_tested'] = True if float(line["Error"]) <= max_allowed_error: d['_matching'] = True else: d['_valid'] = False d['_error'] = float(line["Error"]) if utils.is_invalid(d['_name']): d['_error_message'] = utils.get_error_message(d['_name']) invocations = read_csv("{0}/invocations_error.csv".format( var.CERE_REPLAY_PATH)) del d['_invocations'][:] for inv in invocations: if inv["Codelet Name"] == d['_name']: d['_invocations'].append({ "Cluster": inv["Cluster"], "Invocation": inv["Invocation"], "Part": round(float(inv["Part"]), 2), "Invivo (cycles)": "{:e}".format(float(inv["Invivo"])), "Invitro (cycles)": "{:e}".format(float(inv["Invitro"])), "Error (%)": round(float(inv["Error"]), 2) }) d['_tested'] = True d['_to_test'] = False save_graph(graph) plot(graph)
def handle_vscode_extension(package_name: str, requested_version: str, mode: str, metadata: Metadata): """ Installs a visual studio code package handling metadata for the method #### Arguments package_name (str): The name of the visual studio code package to be installed version (str): The version of the visual studio code package to be installed mode (str): The method (installation/uninstallation) metadata (`Metadata`): Metadata for the method """ base_c = 'code' output = Popen(mslex.split('code --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) version, _ = output.communicate() version = version.decode() if output.returncode != 0: output = Popen(mslex.split('code-insiders --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) version, _ = output.communicate() version = version.decode() base_c = 'code-insiders' if output.returncode != 0: click.echo(click.style( 'Visual Studio Code Or vscode Is Not Installed. Exit Code [0111]', fg='bright_yellow')) utils.disp_error_msg(utils.get_error_message( '0111', 'install', package_name, None, metadata, package_name), metadata) utils.handle_exit('error', '', metadata) version = version.strip().split('\n')[0] if mode == 'install': add_str = f"@{requested_version}" if requested_version else "" command = f'{base_c} --install-extension {package_name}{add_str} --force' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) success = False for line in proc.stdout: line = line.decode() if 'Installing extensions' in line: if metadata.no_color: write( f'Code v{version} :: Installing {package_name}', 'white', metadata) else: write( f'Code v{version} :: Installing {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.RESET}', 'bright_green', metadata) if 'is already installed' in line: success = True if metadata.no_color: write( f'Code v{version} :: {package_name} Is Already Installed!', 'white', metadata) else: write( f'{Fore.LIGHTGREEN_EX}Code v{version} :: {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.LIGHTYELLOW_EX} Is Already Installed!', 'white', metadata) if 'was successfully installed' in line: if metadata.no_color: write( f'Code v{version} :: Successfully Installed {package_name}', 'white', metadata) success = True else: write( f'{Fore.LIGHTGREEN_EX}Code v{version} :: Successfully Installed {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.RESET}', 'bright_green', metadata) if not success: write( f'{Fore.LIGHTGREEN_EX}Code v{version} :: Successfully Installed {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.RESET}', 'bright_green', metadata) if mode == 'uninstall': add_str = f"@{requested_version}" if requested_version else "" command = f'{base_c} --uninstall-extension {package_name}{add_str} --force' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'Uninstalling' in line: if metadata.no_color: write(f'Code v{version} :: Uninstalling {package_name}', 'white', metadata) else: write( f'Code v{version} :: Uninstalling {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.RESET}', 'bright_green', metadata) if 'is not installed' in line: if metadata.no_color: write(f'Code v{version} :: {package_name} is not installed!', 'white', metadata) else: write(f'{Fore.LIGHTGREEN_EX}Code v{version} :: {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.LIGHTYELLOW_EX} is not installed!', 'white', metadata) if 'was successfully uninstalled' in line: if metadata.no_color: write(f'Code v{version} :: Successfully Uninstalled {package_name}', 'white', metadata) else: write(f'{Fore.LIGHTGREEN_EX}Code v{version} :: Successfully Uninstalled {Fore.LIGHTMAGENTA_EX}{package_name}{Fore.RESET}', 'bright_green', metadata)
def handle_python_package(package_name: str, version: str, mode: str, metadata: Metadata): """ Installs a python package handling metadata for the method #### Arguments package_name (str): The name of the python package to be installed version (str): The version of the python package to be installed mode (str): The method (installation/uninstallation) metadata (`Metadata`): Metadata for the method """ command = '' valid = Popen(mslex.split('pip --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE) _, err = valid.communicate() if err: click.echo(click.style( 'Python Is Not Installed. Exit Code [0011]', fg='red')) utils.disp_error_msg(utils.get_error_message( '0011', 'install', package_name, None, metadata, package_name), metadata) utils.handle_exit('ERROR', None, metadata) if mode == 'install': command = 'python -m pip install --upgrade --no-input' command += f' {package_name}' if version != 'latest': command += f'=={version}' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE) py_version = sys.version.split() for line in proc.stdout: line = line.decode('utf-8') if f'Collecting {package_name}' in line: write( f'Python v{py_version[0]} :: Collecting {package_name}', 'bright_green', metadata) if 'Downloading' in line and package_name in line: write( f'Python v{py_version[0]} :: Downloading {package_name}', 'bright_green', metadata) if 'Installing collected packages' in line and package_name in line: write( f'Python v{py_version[0]} :: Installing {package_name}', 'bright_green', metadata) if f'Requirement ' in line and package_name in line: write( f'Python v{py_version[0]} :: {package_name} Is Already Installed And On The Latest Version ==> {line.split()[-1]}', 'bright_yellow', metadata) break if 'Successfully installed' in line and package_name in line: ver = line.split('-')[1] write( f'Python v{py_version[0]} :: Successfully Installed {package_name} {ver}', 'bright_green', metadata) if 'You should consider upgrading via' in line: wants = utils.confirm( 'Would you like to upgrade your pip version?') if wants: write('Updating Pip Version', 'bright_green', metadata) Popen(mslex.split('python -m pip install --upgrade pip')) elif mode == 'uninstall': command = 'python -m pip uninstall --no-input --yes' command += f' {package_name}' if version: command += f'=={version}' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE) py_version = sys.version.split() for line in proc.stdout: line = line.decode('utf-8') if 'Uninstalling' in line and package_name in line: write( f'Python v{py_version[0]} :: Uninstalling {package_name}', 'bright_green', metadata) if 'Successfully uninstalled' in line and package_name in line: ver = line.split('-')[1] write( f'Python v{py_version[0]} :: Successfully Uninstalled {package_name} {ver}', 'bright_green', metadata) _, err = proc.communicate() if err: err = err.decode('utf-8') if f'WARNING: Skipping {package_name}' in err: write( f'Python v{py_version[0]} :: Could Not Find Any Installations Of {package_name}', 'bright_yellow', metadata)
def test_get_error_response(self): correct = '500--Error message' self.assertEqual( correct, get_error_message(INTERNAL_SERVER_ERROR, 'Error message'))
def test_get_error_message_additional_args(self): correct = '400--some message--more information' self.assertEqual( correct, get_error_message(BAD_REQUEST, 'some message', 'more information'))
def get_error_message(self, code, message): if code == 1062: # ER_DUP_ENTRY return 'Taka sama obserwacja już istnieje.' elif code == 1644: return 'Tylko jedna obserwacja obiektu może być odkryciem.' return get_error_message(code, message)
def get_error_message(self, code, message): if code == -1: return 'Katalog o tej samej nazwie już istnieje.' return get_error_message(code, message)
def get_stuff_handler(request, context): """ Main function to be called as lambda handler. The parameters are specified in the AWS mapping in AWS Gateway and are the sum of request parameters from specification and the parsed headers. special call available for test purpose: this returns a message with the context used in the call, logging can be skipped if "skiplog" is ste to True, so even the connection with Cloudwatch can be switched { "noop": True, "skiplog": False } :param request: JSON { "value1": "something", "value2": "something else", "value3": "foo" } :param context: request context from AWS lambda :raises: GetCallException :return: JSON """ if isinstance(request, str): try: log.info('Got string request, converting to JSON.') request = json.loads(request) except ValueError: log.warning('Malformed Json in request: {0}'.format(request)) msg = get_error_message(BAD_REQUEST, 'Malformed JSON in request.') raise GetCallException(msg) # special no op call, if noop is the only key in the request, just return the context # and a short message # this can be used in 'keep warm' calls to keep the lambda function from being "scaled down', 'hibernated', # whatever ... # this way the calls can be easily distinguished from 'real' requests if 'noop' in request and request.get('noop'): if not request.get('skiplog'): log.info('NoOp called !') log.info('context returned: {0}'.format(context)) response = dict(message='No Op call successful', context=context, success=True) return response log.debug('got request: {0}'.format(request)) response = dict(success=False, message='') if not validate_request_params(request): # we need to use exceptions here now, so we can match the # errorMessage in the context response for HTTP response types msg = get_error_message(BAD_REQUEST, 'Parameter mismatch: validation failed.') raise GetCallException(msg) try: client = GetStuffViaAMQPClient() response = client.call(request, routing_key=ROUTING_KEY) log.info('found stuff with ID: {0}'.format(request.get('stuff_id'))) if not response['success']: raise GetCallException() return response except AmqpRpcError: log.error( 'Error connecting to AMQP exchange: {0}'.format(AMQP_EXCHANGE)) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in request for GET call!') raise GetCallException(msg) except GetCallException: log.info('Error response from VREG.') log.info('response was: {0}'.format(response)) msg = get_error_message(BAD_REQUEST, response['message']) raise GetCallException(msg) except: log.error('unexpected exception in get call: {0}'.format(request)) log.error(traceback.print_exc()) msg = get_error_message(INTERNAL_SERVER_ERROR, 'Error in request for GET call!') raise GetCallException(msg)
def handle_sublime_extension(package_name: str, mode: str, metadata: Metadata): """ Installs a sublime text package handling metadata for the method #### Arguments package_name (str): The name of the sublime text package to be installed version (str): The version of the sublime text package to be installed mode (str): The method (installation/uninstallation) metadata (`Metadata`): Metadata for the method """ if mode != 'install': return if utils.find_existing_installation('sublime-text-3', 'Sublime Text 3'): location = PathManager.get_appdata_directory().replace('\electric', '') + \ '\Sublime Text 3' if os.path.isdir(location) and os.path.isfile(fr'{location}\Packages\User\Package Control.sublime-settings'): with open(fr'{location}\Packages\User\Package Control.sublime-settings', 'r') as f: lines = f.readlines() idx = 0 for line in lines: if '"Package Control",' in line.strip(): idx = lines.index(line) if ']' in lines[idx + 1].strip(): lines[idx] = " \"Package Control\"" with open(fr'{location}\Packages\User\Package Control.sublime-settings', 'w') as f: f.writelines(lines) with open(fr'{location}\Packages\User\Package Control.sublime-settings', 'r') as f: json = js.load(f) current_packages = json['installed_packages'] if package_name in current_packages: write(f'{package_name} Is Already Installed!', 'white', metadata) sys.exit() current_packages.append(package_name) updated_packages = current_packages del json['installed_packages'] json['installed_packages'] = updated_packages with open(fr'{location}\Packages\User\Package Control.sublime-settings', 'w+') as f: f.write(js.dumps(json, indent=4)) write( f'Successfully Added {package_name} to Sublime Text 3', 'white', metadata) else: if not os.path.isdir(location): os.mkdir(location) if not os.path.isdir(fr'{location}\Installed Packages'): os.mkdir(fr'{location}\Installed Packages') # Package Control Not Installed with Halo('Installing Package Control', text_color='cyan'): urlretrieve('https://packagecontrol.io/Package%20Control.sublime-package', fr'{location}\Installed Packages\Package Control.sublime-package') if not os.path.isdir(fr'{location}\Packages'): os.mkdir(fr'{location}\Packages') if not os.path.isdir(fr'{location}\Packages\User'): os.mkdir(fr'{location}\Packages\User') with open(fr'{location}\Packages\User\Package Control.sublime-settings', 'w+') as f: f.write( js.dumps({ "bootstrapped": True, "installed_packages": [ "Package Control" ]}, indent=4 ) ) handle_sublime_extension(package_name, mode, metadata) else: click.echo(click.style( 'Sublime Text 3 Is Not Installed. Exit Code [0112]', fg='bright_yellow')) utils.disp_error_msg(utils.get_error_message( '0112', 'install', package_name, None, metadata, package_name), metadata) utils.handle_exit('error', '', metadata)
def get_error_message(self, code, message): return get_error_message(code, message)
def handle_atom_package(package_name: str, mode: str, requested_version: str, metadata: Metadata): """ Installs an atom package handling metadata #### Arguments package_name (str): The name of the atom package to be installed version (str): The version of the atom package to be installed mode (str): The method (installation/uninstallation) metadata (`Metadata`): Metadata for the method """ if mode == 'install': proc = Popen('apm'.split(), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) proc.communicate() if proc.returncode != 0: click.echo(click.style('Atom Is Not Installed. Exit Code [0113]', fg='bright_yellow')) utils.disp_error_msg(utils.get_error_message('0113', 'install', package_name, None, metadata, package_name), metadata) utils.handle_exit('error', '', metadata) with Halo(f'apm :: Installing {package_name}', text_color='cyan') as h: add_str = f"@{requested_version}" if requested_version else "" command = f'apm install {package_name}' + add_str proc = Popen( command, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'failed' in line: h.fail( f' Failed to Install {package_name} to <=> {line.split()[3]}') if 'done' in line: h.stop() click.echo(click.style( f' Successfully Installed {package_name} to <=> {line.split()[3]}', 'bright_green')) if mode == 'uninstall': proc = Popen('apm'.split(), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) proc.communicate() if proc.returncode != 0: click.echo(click.style('Atom Is Not Installed. Exit Code [0113]', fg='bright_yellow')) utils.disp_error_msg(utils.get_error_message('0113', 'install', package_name, None, metadata, package_name), metadata) utils.handle_exit('error', '', metadata) with Halo(f'apm :: Uninstalling {package_name}', text_color='cyan') as h: add_str = f"@{requested_version}" if requested_version else "" command = f'apm deinstall {package_name}' + add_str proc = Popen( command, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'failed' in line: h.fail(f' Failed to Uninstall {package_name}') if 'done' in line: h.stop() click.echo(click.style( f' Successfully Uninstalled {package_name}', 'bright_green'))
def get_error_message(self, code, message): if code == 1217: # ER_ROW_IS_REFERENCED return 'W tej konstelacji znajdują się gwiazdy lub galaktyki. Spróbuj zmienić ich konstelację lub je usunąć.' elif code == -1: return 'Konstelacja z tym samym skrótem IAU już istnieje.' return get_error_message(code, message)