def decmin_to_decdeg(pos, return_string=False): # print type(pos),pos try: if utils.is_sequence(pos): output = [] for p in pos: # print p, type(p) p = float(p) if p >= 0: output.append(np.floor(p / 100.) + (p % 100) / 60.) else: output.append(np.ceil(p / 100.) - (-p % 100) / 60.) else: pos = float(pos) if pos >= 0: output = np.floor(pos / 100.) + (pos % 100) / 60. else: output = np.ceil(pos / 100.) - (-pos % 100) / 60. if return_string: if utils.is_sequence(output): # print 'if-if' return map(unicode, output) else: # print 'if-else' return unicode(output) else: # print 'else' return output except: return pos
def data_type(obj): """Identify format of data object. Returns `str` or `None`""" # inspired by pyqtgraph.graphicsitems.PlotDataItem logger.debug(f"data_type {type(obj), repr(obj)}") if obj is None: return None if isinstance(obj, DictArray): return 'DictArray' if hasattr(obj, '__len__'): if isinstance(obj, np.ndarray): pass elif len(obj) == 0: return 'empty' if isinstance(obj, dict): first = obj[list(obj.keys())[0]] if utils.is_sequence(first): return 'dictOfLists' else: return 'dictOfValues' if utils.is_sequence(obj): # if (hasattr(obj, 'implements') and obj.implements('MetaArray')): # return 'MetaArray' if isinstance(obj, np.ndarray): if obj.ndim <= 1: if obj.dtype.names is None: return 'listOfValues' elif obj.dtype.names: return 'recarray' # elif obj.ndim == 2 and obj.dtype.names is None and obj.input[1] == 2: # return 'Nx2array' elif obj.ndim == 2: if obj.dtype.names is None: return 'ndarray' else: return 'recarray' else: raise Exception( 'array input must be (N points, N keys); got %s instead' % str(obj.shape)) first = obj[0] if isinstance(first, dict): return 'listOfDicts' elif utils.is_sequence(first): if isinstance(first, np.ndarray) and first.ndim == 0: return 'listOfValues' else: return 'listOfLists' else: return 'listOfValues' raise NotImplementedError(f"Unknown data_type, {repr(obj)}")
def p_listadecl(t): ''' listadecl : tipo listaids SEMI ''' if t[2]: logger.debug( "listadecl : tipo listaids SEMI Tipo de t[2] es {t}".format( t=type(t[2]))) if is_sequence(t[2]): l = [] for x in t[2]: logger.debug( "x en t[2] es de tipo {t} y tiene valor {v}".format( t=type(x), v=x)) var = DeclaracionNodo(get_decl_total(t[1], x), delete_brackets(x), en_declvariables=True, tam_nodo=numeros_bracket(x)) l.append(var) logger.debug("Listadecl es : {}".format(t[0])) t[0] = l else: t[0] = [ DeclaracionNodo(get_decl_total(t[1], t[2]), delete_brackets(t[2]), en_declvariables=True, tam_nodo=numeros_bracket(t[2])) ] else: logger.warning("listadecl: listaids vacia")
def __init__(self, email, password, roles=None): self.email = email.lower() # If only a string is passed for roles, convert it to a list containing # that string if roles and isinstance(roles, basestring): roles = [roles] # If a sequence is passed for roles (or if roles has been converted to # a sequence), fetch the corresponding database objects and make a list # of those. if roles and is_sequence(roles): role_list = [] for role in roles: role_list.appen(Role.query.filter_by(name=role).first()) self.roles = role_list # Otherwise, assign the default 'user' role. Create that role if it # doesn't exist. else: r = Role.query.filter_by(name='user').first() if not r: r = Role('user') db.session.add(r) db.session.commit() self.roles = [r] self.set_password(password)
def decdeg_to_decmin(pos, string_type=False, decimals=False): # TODO, add if else for negative position (longitude west of 0 degrees) if utils.is_sequence(pos): output = [] for p in pos: p = float(p) deg = np.floor(p) minut = p % deg * 60.0 if string_type: if decimals is not False: output.append('%%2.%sf' % decimals % (deg * 100.0 + minut)) else: output.append(unicode(deg * 100.0 + minut)) else: output.append(deg * 100.0 + minut) else: pos = float(pos) deg = np.floor(pos) minut = pos % deg * 60.0 if string_type: if decimals is not False: output = ('%%2.%sf' % decimals % (deg * 100.0 + minut)) else: output = (unicode(deg * 100.0 + minut)) else: output = (deg * 100.0 + minut) return output
def check_lists_in_dict(filter_dict, use_string=False): for key in filter_dict: if not utils.is_sequence(filter_dict[key]): if type(filter_dict[key]) == str and use_string: pass else: filter_dict[key] = [filter_dict[key]] return filter_dict
def brackets_necesarias(self): logger.debug("Calculando las brackets necesarias") if not is_sequence(self.tam_vec): logger.debug("No necesitamos ninguna") return 0 ret = len(self.tam_vec) logger.debug("{} pares necesarios".format(ret)) return ret
def esta_en_limites(self, posicion): logger.debug("Calculando si simbolo esta en limites") if not is_sequence(self.tam_vec): logger.debug("No esta en secuencia, retornamos True") return True ret = esta_en_limites(posicion, self.tam_vec) if ret: logger.debug("Esta en limites") else: logger.debug("No esta en limites") return ret
def register(cls): """ called by subclass to allow Input() constructor to find and return that subclass """ if cls is Input: return None if not cls.subtypes: l_logger.error("A location must define its types: {}".format(cls.name)) raise ValueError("{} has no 'types', unable to register".format(cls.name)) if not is_sequence(cls.subtypes): cls.subtypes = (cls.subtypes, ) for subtype in cls.subtypes: Input.types[subtype]= cls h_logger.info("Input: {} registered for {}".format(cls.__name__, cls.subtypes)) return True
def dump(self, indent=0, max_level=100, sp_per_level=4): spaces = ' ' * (indent * sp_per_level) print(spaces + self._print_clase_hoja()) spaces = ' ' * (indent * (sp_per_level + 1)) if indent < max_level: for val in self.hijos: if is_sequence(val): for v in val: if not isinstance(val, str): v.dump(indent + 1) else: print(spaces + val) else: if not isinstance(val, str): val.dump(indent + 1) else: print(spaces + val)
fetch_index = args.index aspera = args.aspera aspera_settings = args.aspera_settings if aspera or aspera_settings is not None: aspera = utils.set_aspera(aspera_settings) try: if utils.is_wgs_set(accession): if output_format is not None: sequenceGet.check_format(output_format) sequenceGet.download_wgs(dest_dir, accession, output_format) elif not utils.is_available(accession): sys.stderr.write('ERROR: Record does not exist or is not available for accession provided\n') sys.exit(1) elif utils.is_sequence(accession): if output_format is not None: sequenceGet.check_format(output_format) sequenceGet.download_sequence(dest_dir, accession, output_format, expanded) elif utils.is_analysis(accession): if output_format is not None: readGet.check_read_format(output_format) readGet.download_files(accession, output_format, dest_dir, fetch_index, fetch_meta, aspera) elif utils.is_run(accession) or utils.is_experiment(accession): if output_format is not None: readGet.check_read_format(output_format) readGet.download_files(accession, output_format, dest_dir, fetch_index, fetch_meta, aspera) elif utils.is_assembly(accession): if output_format is not None: assemblyGet.check_format(output_format) assemblyGet.download_assembly(dest_dir, accession, output_format, fetch_wgs, extract_wgs, expanded)
def detect_format(file): logger.debug(f"detect_format {file}") ff = {'data': None, 'file': None, 'header': None, 'dialect': None} try: samplelines = DataFileIO.readnlines(file, 3) except UnicodeDecodeError as e: ff['file'] = 'numpy' logger.debug(ff) return None, ff n_samplelines = len(samplelines) if n_samplelines in [0, 1]: if n_samplelines == 0 or samplelines[0].strip(' \t\n\r') == '': ff['file'] = 'empty' logger.debug(ff) return [], ff logger.debug(samplelines) if samplelines[0][0] in "[({": try: sample = ast.literal_eval(samplelines[0]) logger.debug('here') except SyntaxError: logger.debug('here') if samplelines[0][1] in "[({": sample = ast.literal_eval(samplelines[0][1:]) logger.debug(f'sample {sample}') else: # file.seek(0) sample = ast.literal_eval(file.read()) ff['file'] = 'multiLine' ff['data'] = data_type(sample) return sample, ff if n_samplelines == 1: ff['file'] = 'oneLine' else: ff['file'] = 'multiLine' if isinstance(sample, dict): ff['data'] = 'dict' itemsample = list(sample.values())[0] if utils.is_sequence(itemsample): ff['data'] += 'OfLists' elif n_samplelines == 1: ff['data'] += 'OfValues' else: ff['data'] = 'someDicts' elif utils.is_sequence(sample): ff['data'] = 'list' try: itemsample = sample[0] except IndexError: ff['data'] += 'OfEmpty' else: if isinstance(itemsample, dict): ff['data'] += 'OfDicts' elif utils.is_sequence(itemsample): ff['data'] += 'OfLists' else: ff['data'] = 'someLists' else: raise TypeError(type(sample), sample) else: samplestr = ''.join(samplelines) logger.debug(f'samplestr {samplestr}') try: ff['dialect'] = csv.Sniffer().sniff(samplestr) logger.debug(f"dialect {ff['dialect']}") except csv.Error: logger.debug(f'csv Error') if n_samplelines > 1: logger.debug(f"MORE THAN ONE LINE") sample_without_header = ''.join(samplelines[1:]) try: ff['dialect'] = csv.Sniffer().sniff( sample_without_header) except csv.Error: pass else: ff['header'] = samplelines[0] logger.debug('CHECK HEADER') if not ff['header']: try: hasheader = csv.Sniffer().has_header(samplestr) except csv.Error: logger.debug(f'DOES NOT HAVE HEADER') pass else: logger.debug(f'HAS HEADER {hasheader}') ff['header'] = samplelines[0] if hasheader else None if ff['file'] == 'oneLine': logger.debug((sample, ff)) return sample, ff logger.debug((None, ff)) return None, ff
def test_is_sequence(): assert utils.is_sequence((1, 2)) assert utils.is_sequence([1, 2]) assert not utils.is_sequence('12')
def fertilities(self, ferts): if not is_sequence(ferts): ferts = (ferts,) self.__fertilities = tuple(ferts)
if format not in allowed_formats: print ('Please select a valid format for this accession: ', allowed_formats) sys.exit(1) if __name__ == '__main__': parser = set_parser() args = parser.parse_args() accession = args.accession format = args.format dest_dir = args.dest try: if utils.is_wgs_set(accession): download_wgs(dest_dir, accession, format) elif utils.is_sequence(accession) or utils.is_coding(accession): if not utils.is_available(accession): print ('Record does not exist or is not available for accession provided') sys.exit(1) if format == utils.MASTER_FORMAT: print ('Invalid format. master format only available for WGS sets') sys.exit(1) download_sequence(dest_dir, accession, format) else: print ('Error: Invalid accession. A sequence or coding accession or a WGS set (prefix or master accession) must be provided') sys.exit(1) print ('Completed') except Exception: utils.print_error() sys.exit(1)
def operador(self): if is_sequence(self.hoja): return self.hoja[0] return self.hoja