def gen_flash_images(self): work_dir = self.config.get_str('gapy/work_dir') # Go through all the specified flashes to generate image and stimuli if needed for flash_path in self.config.get_py('runner/flash_devices'): traces.info('Building stimuli for flash ' + flash_path) flash_config = self.config.get(flash_path) if flash_config is None: raise errors.InputError('Invalid flash device: ' + flash_path) if flash_config.get('content/partitions') is not None: for name, partition in flash_config.get('content/partitions').get_items().items(): type_name = partition.get_str('type') if type_name is not None: if type_name == 'readfs': gen_readfs.main(config=self.config, partition_config=partition) elif type_name == 'lfs': gen_lfs.main(config=self.config, partition_config=partition) elif type_name == 'hostfs': work_dir = self.config.get_str('gapy/work_dir') for file in partition.get('files').get_dict(): shutil.copy(file, work_dir) else: raise errors.InputError('Invalid partition type: ' + type_name) if flash_config.get('content/image') is not None: gen_flash_image.main(config=self.config, flash_config=flash_config)
def _open_output(self, filename): try: self.output = open(filename, "w", encoding="utf-8") except ValueError: raise errors.InputError("Output file encoding is not supported.") except: raise errors.InputError("Output file couldn't be opened.")
def check_input(self, dataframe, lookup, classifier_type, topics, n_grams, features, text_column): if dataframe == None or lookup == None or classifier_type == None or topics == None or n_grams == None or features == None: raise errors.InputError("Please provide all necessary information") if not isinstance(text_column, str) or text_column not in dataframe.columns: raise errors.InputError("That column does not exist") return (dataframe, lookup, str(topics), classifier_type, str(n_grams), str(features), str(text_column))
def check_input(self, dataframe, lookup, topics, passes, min_probability, text_column): if dataframe == None or lookup == None or topics == None or passes == None or min_probability == None: raise errors.InputError("Please provide all necessary information") if not isinstance(text_column, str) or text_column not in dataframe.columns: raise errors.InputError("That column does not exist") return (dataframe, lookup, str(topics), str(passes), min_probability, str(text_column))
def get_boot_flash(self): flash_path = self.config.get_str("runner/boot/device") if flash_path is None: raise errors.InputError('The path to the flash device must be specified when booting from flash') flash_config = self.config.get(flash_path) if flash_config is None: raise errors.InputError('Invalid flash device specified for boot: ' + flash_path) return flash_config
def _parse_date(dt_str): if dt_str is None: return None try: d, m, y = [int(x) for x in dt_str.split('/')] if y < 2013: raise errors.InputError('Wrong year %s for param %s' % (y, dt_str)) return datetime.date(year=y, month=m, day=d) except ValueError, e: raise errors.InputError('Wrong date param %s: %s' % (dt_str, unicode(e)))
def main(): try: log.info("<--------------START----------------->") log.info("Get Address based on Latitude and Longitude.") location_res = getlocation() _places_list = [] city = location_res.get_cityname() state = location_res.get_statecode() if not city or not state: raise (errors.InputError().message, errors.InputError().expression) log.info( "Address extracted based on latitude and longitude => '%s,%s'" % (city, state)) origin = ('%s %s' % (city, state)) _places_list.append(origin) destination = ('%s %s' % (__destination_city__, __destination_state__)) log.info("Now get the distance between %s and %s" % (origin, destination)) dist_req = distance_request.DistanceRequest(origin, destination) dist_res = distance_response.DistanceResponse() distance.Distance(dist_req, dist_res) _distance = dist_res.get_distance() _duration = dist_res.get_duration() if not _distance or not _duration: raise errors.Error( "Could not get distance or duration for the given destination.", "%s,%s" % (_distance, _duration)) else: _places_list.append(destination) log.info(" Distance and duration between %s and %s is %s and %s" % (origin, destination, _distance, _duration)) weather_url = weather.get_weatherurl() output_format = weather.get_weatheroutputformat() log.info(_places_list) for place in _places_list: log.info("Invoke weather API for location %s" % (place.split(",")[0])) weather_req = weather_request.WeatherRequest() weather_req.set_url(weather_url) weather_req.set_city(place.rsplit(" ", maxsplit=1)[0]) weather_req.set_state(place.rsplit(" ", maxsplit=1)[1]) weather_req.set_format(output_format) weather_res = weather_response.WeatherResponse() weather.Weather(weather_req, weather_res) _weatherResponse(weather_res) log.info("<---------------END------------------>") except errors.Error as err: print("%s %s" % (err.message, err.expression))
def assertAimAxis(jnt=None, aim=None): '''Assert the given axis is the axis aiming at child nodes Attributes: jnt -- Joint in scene to check aim -- Character "x"|"y"|"z". Axis expected to aim at child ''' if not isinstance(jnt, pm.nt.Joint): raise errors.InputError('jnt', jnt, pm.nt.Joint) if aim.lower() not in ['x', 'y', 'z']: raise errors.InputError('aim', aim, '"x", "y" or "z"') aim = aim.lower() children = jnt.getChildren() if not children: raise errors.ObjectError(jnt, 'Child nodes', children) if len(children) > 1: raise errors.ObjectError(jnt, 'One child', children) # Place locator as child to jnt and zero it loc = pm.spaceLocator() pm.parent(loc, jnt) loc.setTranslation(0) loc.setRotation([0, 0, 0]) # Get magnitude of vector to child jnt_pos = pm.dt.Vector(pm.xform(jnt, q=1, ws=1, t=1)) chld_pos = pm.dt.Vector(pm.xform(children[0], q=1, ws=1, t=1)) vec = chld_pos - jnt_pos # Move it along expected axis if aim == 'x': loc.tx.set(vec.length()) if aim == 'y': loc.ty.set(vec.length()) if aim == 'z': loc.tz.set(vec.length()) loc_pos = pm.xform(loc, q=1, ws=1, t=1) # Remove locator from the scene pm.delete(loc) for l, p in zip(loc_pos, chld_pos): if round(l, 6) != round(p, 6): return False return True
def rest_post_json(baseURL, uri, thejson, user, password): proxies = { "http": None, "https": None, } appformat = 'application/json' headers = {'content-type': appformat, 'accept': appformat} restURI = baseURL + uri logging.info(restURI) try: r = requests.post(restURI, data=thejson, headers=headers, proxies=proxies, auth=(user, password), verify=False) # print "HTTP response code is: " + str(r.status_code) if r.status_code == 200: return json.dumps(r.json(), indent=2) else: raise errors.InputError(restURI, "HTTP status code: " + str(r.status_code)) except errors.InputError as err: logging.error("Exception raised: " + str(type(err))) logging.error(err.expression) logging.error(err.message) return
def __gen_debug_info(self, full_config, gvsoc_config): for binary in full_config.get('**/debug_binaries').get_dict(): if os.system('pulp-pc-info --file %s --all-file %s' % (binary.replace('.debugInfo', ''), binary)) != 0: raise errors.InputError( 'Error while generating debug symbols information, make sure the toolchain and the binaries are accessible ' )
def main(): arfns = args if not len(arfns): raise errors.InputError("No input archives provided! " \ "Here's your summary: NOTHING!") print "Making summary plot of %d files" % len(arfns) if options.numrows is None: numrows = int(np.ceil(len(arfns) / float(options.numcols))) else: numrows = options.numrows layout = (options.numcols, numrows) numpanels = np.prod(layout) arfs = get_archives(arfns, options.sortkeys) numfigs = int(np.ceil(len(arfns) / float(numpanels))) for fignum in range(numfigs): arfs_toplot = arfs[fignum * numpanels:(fignum + 1) * numpanels] fig = plt.figure(figsize=(8,11), FigureClass=SummaryFigure, arfs=arfs_toplot, scale_indep=options.scale_indep, \ show_template=options.show_template, \ centre_prof=options.centre_prof, layout=layout, \ infotext=options.info_text) fig.text(0.94, 0.02, "%d / %d" % (fignum + 1, numfigs), size='small') fig.connect_event_triggers() fig.plot() if options.savefn: if numfigs > 1: fn, ext = os.path.splitext(options.savefn) plt.savefig(fn + ("_page%d" % (fignum + 1)) + ext, papertype='a4') else: plt.savefig(options.savefn, papertype='a4') fig.canvas.mpl_connect('key_press_event', \ lambda ev: ev.key in ('q', 'Q') and plt.close(fig)) if options.interactive: plt.show()
def __get_platform_path(self): if self.platform_path is None: if self.platform_tool == 'vsim': plt_path_name = 'VSIM_PATH' plt_path = os.environ.get('VSIM_PATH') else: plt_path_name = 'XCSIM_PATH' plt_path = os.environ.get('XCSIM_PATH') platform_path_name = self.plt_config.get_str('path_envvar') if platform_path_name is not None: envvar = os.environ.get(platform_path_name) if envvar is not None: plt_path = envvar plt_path_name = plt_path_name if plt_path is None: if platform_path_name is None: raise errors.InputError( "No platform found, VSIM_PATH is not defined.") else: raise errors.InputError( "No platform found, neither %s nor VSIM_PATH is defined." % (platform_path_name)) if not os.path.exists(plt_path): raise errors.InputError("ERROR: %s=%s path does not exist" % (plt_path_name, plt_path)) self.platform_path = plt_path os.environ['PULP_PATH'] = plt_path os.environ['TB_PATH'] = plt_path os.environ['VSIM_PLATFORM'] = plt_path os.environ['VSIM_PLATFORM'] = plt_path if self.platform_tool == 'vsim': pass else: os.environ['XCSIM_PLATFORM'] = plt_path self.platform_path = plt_path return self.platform_path
def get_route_info_full(req): route_id = req.GET['route_id'] from_date = _parse_date(req.GET.get('from_date')) to_date = _parse_date(req.GET.get('to_date')) if from_date and to_date and from_date > to_date: raise errors.InputError('from_date %s cannot be after to_date %s' % (from_date, to_date)) filters = Filters(from_date=from_date, to_date=to_date) stats = _get_route_info_full(route_id, filters) stats.sort(key=_get_info_sort_key) return json_resp(stats)
def check_type(obj=None, attr=None, types=[]): ''' Check an objects type Attributes: obj -- Object to check attr -- Attribute that object is passed into. String types -- List of types that obj needs to be ''' for t in types: if isinstance(obj, t): return True raise errors.InputError(attr, type(obj), types)
class Combine: def __init__(self, dataframe, datediff=10): self.datediff= self.check_input(self, datediff) self.datediff = datediff self.dataframe = dataframe self.dataframe.show() self.split() self.combine() def self.check_input(self, datediff): if not isinstance(datediff, int) or datediff < 0: raise errors.InputError("The date differences cannot be smaller than 0") return datediff
def assertAimingAt(a=None, b=None, axis=None, log=False): '''Assert a aims at b along axis Attributes: a -- Object a. [pm.nt.Transform, pm.nt.Joint] b -- Object b. [pm.nt.Transform, pm.nt.Joint] axis -- axis aiming at b. 'x' 'y' or 'z' ''' general.check_type(a, 'a', [pm.nt.Transform, pm.nt.Joint]) general.check_type(b, 'b', [pm.nt.Transform, pm.nt.Joint]) general.check_type(axis, 'axis', [str]) if axis not in ['x', 'y', 'z']: raise errors.InputError(axis, 'axis', ['x', 'y', 'z']) pos_a = pm.dt.Vector(pm.xform(a, q=1, ws=1, rp=1)) pos_b = pm.dt.Vector(pm.xform(b, q=1, ws=1, rp=1)) vec = pos_b - pos_a if not vec.length() > 0: raise errors.ObjectError(a, 'Different position than b', 'Same position as b') loc = pm.spaceLocator() pm.parent(loc, a) loc.setTranslation(0) loc.setRotation([0, 0, 0]) if axis == 'x': loc.tx.set(vec.length()) elif axis == 'y': loc.ty.set(vec.length()) elif axis == 'z': loc.tz.set(vec.length()) pos_loc = pm.dt.Vector(pm.xform(loc, q=1, ws=1, rp=1)) pm.delete(loc) if log: str_1 = 'pos_a: ', pos_a str_2 = 'pos_b: ', pos_b str_3 = 'pos_loc: ', pos_loc general.logging.debug(str_1) general.logging.debug(str_2) general.logging.debug(str_3) return general.assertAlmostEquals(pos_loc, pos_b, 3)
def operationFunc(args, config=None): if config.get_str('root_dir') is None: return traces.info('Generating LittleFS image') cmd = 'mklfs -b 262144 -r 4 -p 4 -s 10485760 -c %s -i %s' % (config.get_str('root_dir'), args.output) traces.info('Generating LittleFS images with command:') traces.info(' ' + cmd) stdout = None if traces.verbose else subprocess.PIPE if subprocess.run(shlex.split(cmd), stdout=stdout).returncode != 0: raise errors.InputError('Failed to generate LittleFS image') if config is not None: config.set('enabled', True)
def new_user(self, name, mail, password, description=""): """ create a new user """ MAX_LEN_PASSWORD = 255 enc_password = conn.ccdCrypto.hashPassword(password) if len(enc_password) > MAX_LEN_PASSWORD: raise errors.InputError("Password exceeds limit of %d chars." % MAX_LEN_PASSWORD) validate_name(name) validate_mail(mail) validate_description(description) pld = dict(name=name, mail=mail, password=enc_password, description=description) resp_t = comm.sendpacket(self, op=conn.ccdlib.OP_NEWUSER, pld=pld) return resp_t[-1]
def profile_likelihood(self, pl_directory, size=0.3, num_per_row=3): """ compile any pdf, jpg and png files in directory into a latex pdf document :return: """ if isinstance(self.file_types, str): self.file_types = [self.file_types] files = self.search_recursive(pl_directory) if files is []: raise errors.InputError( '''Cannot locate pdf, jpg or png files in "{}". Please give the full path to where your model selection results are plotted. '''.format(pl_directory) ) doc = pylatex.Document(self.filename, documentclass='article') for k, v in files.items(): assert isinstance(v, list) if v is not None: with doc.create(pylatex.Figure( position='htbp!', width=pylatex.NoEscape(r'\linewidth'))) as fig: # [fig.add_image(i) for i in v] for i in range(len(v)): with doc.create(pylatex.SubFigure( width=pylatex.NoEscape(str(size) + r'\linewidth'))) as sub: sub.add_image(v[i]) sub.add_caption(os.path.split(v[i])[1]) if i is not 0 and i % num_per_row is 0: doc.append(pylatex.NoEscape(r'\break')) # sub.add_label(i) # # fig.add_caption(os.path.join(*Path(v[i]).parts[-3:-1])) doc.append(pylatex.NoEscape(r'\hfill')) fig.add_caption(os.path.split(k)[1]) doc.generate_pdf() LOG.info('PDF generated at "{}"'.format(doc.default_filepath))
def rest_post_xml(baseURL, uri, thexml, user, password): proxies = { "http": None, "https": None, } appformat = 'application/xml' headers = {'content-type': appformat, 'accept': appformat} restURI = baseURL + uri try: r = requests.post(restURI, data=thexml, headers=headers, proxies=proxies, auth=(user, password), verify=False) # print "HTTP response code is: " + str(r.status_code) if r.status_code == 200: response_xml = xml.dom.minidom.parseString(r.content) return response_xml.toprettyxml() else: raise errors.InputError(restURI, "HTTP status code: " + str(r.status_code)) except errors.InputError as err: print "Exception raised: " + str(type(err)) print err.expression print err.message return
def check_input(self, dataframe, lookup, topics, passes, decay, iterations, min_probability, text_column): if dataframe == None or lookup == None or topics == None or passes == None or min_probability == None: raise errors.InputError("Please provide all necessary information") if topics not in self.possible_topics: raise errors.InputError( "We do not have a topic with that number of topics") if passes not in self.possible_passes: raise errors.InputError( "We do not have a topic with that number of passes") if decay is not None and decay not in self.possible_decay: raise errors.InputError( "We do not have a topic with that decay rate") if iterations is not None and iterations not in self.possible_iterations: raise errors.InputError( "We do not have a topic with that iteration rate") if not isinstance(text_column, str) or text_column not in dataframe.columns: raise errors.InputError("That column does not exist") return (dataframe, lookup, str(topics), str(passes), str(decay), str(iterations), min_probability, str(text_column))
def conf(self): boot_mode = self.config.get_str("runner/boot/mode") if boot_mode is None: raise errors.InputError('The boot mode has to be specified') binary = self.config.get_str('runner/boot-loader') # If we boot from flash, store the boot binary information in the specified flash if boot_mode == 'flash': flash_config = self.get_boot_flash() flash_config.set('content/boot-loader', binary) work_dir = self.config.get_str('gapy/work_dir') # Go through all the specified flashes to generate image and stimuli if needed for flash_path in self.config.get_py('runner/flash_devices'): traces.info('Building stimuli for flash ' + flash_path) flash_config = self.config.get(flash_path) if flash_config is None: raise errors.InputError('Invalid flash device: ' + flash_path) gen_image = False flash_image = self.args.force # The flash can contain the boot binary and several partitions for FS if flash_config.get('content/boot-loader') is not None: gen_image = True if flash_config.get('content/partitions') is not None: for name, partition in flash_config.get( 'content/partitions').get_items().items(): gen_image = True type_name = partition.get_str('type') if type_name is None: raise errors.InputError('No partition type found') if type_name not in ['hostfs'] and ( (partition.get('files') is not None and len(partition.get('files').get_dict()) != 0) or (partition.get_str('root_dir'))): flash_image = True img_path = os.path.join( work_dir, flash_path.replace('/', '.') + '.' + name + '.img') partition.set('image', img_path) if gen_image: img_path = os.path.join(work_dir, flash_path.replace('/', '.') + '.img') flash_config.set('content/image', img_path) flash_config.set('content/flash', flash_image) stim_format = flash_config.get_str("models/%s/stimuli/format" % self.args.platform) if stim_format is not None: file_name = flash_config.get_str("models/%s/stimuli/file" % self.args.platform) if file_name is None: file_name = flash_path.replace('/', '.') + '.' + stim_format file_path = os.path.join(work_dir, file_name) flash_config.set("content/stimuli/format", stim_format) flash_config.set("content/stimuli/file", file_path)
def prepare_document(self, directory, subdirs=False, file_types='.png'): """ compile any pdf, jpg and png files in directory into a latex pdf document :return: """ if subdirs not in [True, False]: raise errors.InputError('subdirs argument should be either True or False') if isinstance(file_types, str): file_types = [file_types] if subdirs: files = self.search_recursive(directory) else: files = self.search() if files is []: raise errors.InputError( '''Cannot locate pdf, jpg or png files in "{}". Please give the full path to where your model selection results are plotted. '''.format(directory) ) doc = pylatex.Document(self.filename, documentclass='article') for k, v in files.items(): assert isinstance(v, list) if v is not None: with doc.create(pylatex.Section(os.path.join(*Path(k).parts[-1:]))): doc.append(k) doc.append(pylatex.NoEscape(r'\\*')) if len(v) == 1: with doc.create( pylatex.Figure( position='htbp!', width=pylatex.NoEscape(r'0.3\linewidth')) ) as fig: fig.add_image(v[0]) fig.add_caption(os.path.join(*Path(v[0]).parts[-2:])) # fig.add_label(v[0]) else: with doc.create(pylatex.Figure( position='htbp!', width=pylatex.NoEscape(r'\linewidth'), ) ) as fig: for i in range(len(v)): with doc.create( pylatex.SubFigure( width=pylatex.NoEscape(r'0.3\linewidth') ) ) as sub: sub.add_image(v[i]) # sub.add_caption('') if i % 3 == 0: doc.append(pylatex.NoEscape(r'\break')) # sub.add_label(i) fig.add_caption(os.path.join(*Path(v[i]).parts[-3:-1])) doc.append(pylatex.NoEscape(r'\hfill')) doc.generate_pdf() LOG.info('PDF generated at "{}"'.format(doc.default_filepath))
def _read_syscalls(self, filename): try: with open(filename, "r", encoding="utf-8") as file: self.syscalls_list = [line[:-1] for line in file] except: raise errors.InputError("Syscalls file couldn't be opened.")
def check_text_column(self, dataframe, text_column): if not isinstance(text_column, str) or text_column not in dataframe.columns: raise errors.InputError("That column does not exist") return text_column
def download_from_ccd(self, filename, dst, force): """ download file from ccd input: filename path of the file to download dst destination, where to store file at """ SYM_SHARED = "$shared" SYM_HOME = "$home" if not validate_filename(dst): raise errors.InputError(message='Invalid path %s' % dst) if self.project: proj_dir = './outdir/project_%d/' % self.project else: proj_dir = '/tmp/' logger.info('Using project dir %s', proj_dir) # source, aka file to upload path = filename.split("/") root = path[0] logger.info('Path: %s', path) # location where to download from if root == SYM_SHARED: logger.info('From shared dir') subpath = "/".join(path[1:]) name = os.path.join(SYM_SHARED, subpath) plg_id = "0" elif root == SYM_HOME: logger.info('From home dir') subpath = "/".join(path[1:]) name = os.path.join(SYM_HOME, subpath) plg_id = "0" else: logger.info('From plg dir') plg = self._findPlugin(root) if not plg: raise errors.InvalidServerPath(message=root) logger.info('Found Plugin: %s', plg) plg_id = plg.id name = "/".join(path[1:]) logger.info('Dwlnd src: %s', name) # get file pld = dict(fn=name) resp = comm.sendpacket(self, op=conn.ccdlib.OP_DOWNLOAD, plg=plg_id, pld=pld)[-1] try: string = resp["content"] blob = base64.decodestring(string) except KeyError: raise Exception("Invalid payload format!") # store file if not os.path.exists(proj_dir): os.makedirs(proj_dir) # dst = "/tmp/%s" % fn dst = os.path.join(proj_dir, dst) with open(dst, "w+b") as f: f.write(blob) print("File successfully download to %s" % dst)