def test_factory_for_default(self): # make sure FACTORY works for the global default A = namedlist('A', 'x y', default=FACTORY(list)) a = A() self.assertEqual(a.x, []) self.assertEqual(a.y, []) a.x.append(4) self.assertEqual(a.x, [4]) a.y.append(4) self.assertEqual(a.y, [4]) b = A() self.assertEqual(b.x, []) self.assertEqual(b.y, []) # mix and match FACTORY and a non-callable mutable default A = namedlist('A', [('x', []), 'y'], default=FACTORY(list)) a = A() self.assertEqual(a.x, []) self.assertEqual(a.y, []) a.x.append(4) self.assertEqual(a.x, [4]) a.y.append(4) self.assertEqual(a.y, [4]) b = A() self.assertEqual(b.x, [4]) self.assertEqual(b.y, [])
def test_simple(self): Point = namedlist('Point', 'x y') p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20}) Point = namedlist('Point', 'x,y') p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20}) Point = namedlist('Point', 'x, y') p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20}) Point = namedlist('Point', ['x', 'y']) p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20}) self.assertEqual(Point(10, 11), Point(10, 11)) self.assertNotEqual(Point(10, 11), Point(10, 12)) self.assertEqual(vars(p), p._asdict()) # verify that vars() works
def test_identity_of_defaults(self): default = object() Point = namedlist('Point', [('x', default)]) # in 2.7 this should become assertIs self.assertTrue(Point().x is default) Point = namedlist('Point', 'x', default) # in 2.7 this should become assertIs self.assertTrue(Point().x is default)
def test_slots(self): Point = namedlist('Point', '') p = Point() # p.x = 3 raises AttributeError because of slots self.assertRaises(AttributeError, setattr, p, 'x', 3) Point = namedlist('Point', '', use_slots=True) p = Point() # p.x = 3 raises AttributeError because of slots self.assertRaises(AttributeError, setattr, p, 'x', 3)
def test_list(self): Point = namedlist('Point', ['x', 'y']) p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20}) Point = namedlist('Point', ('x', 'y')) p = Point(10, 20) self.assertEqual((p.x, p.y), (10, 20)) self.assertEqual(p._asdict(), {'x':10, 'y':20})
def test_default_and_specified_default(self): Point = namedlist('Point', ['x', ('y', 10), ('z', 20)], 100) self.assertEqual(Point(), Point(100, 10, 20)) self.assertEqual(Point(0), Point(0, 10, 20)) self.assertEqual(Point(0, 1), Point(0, 1, 20)) self.assertEqual(Point(0, 1, 2), Point(0, 1, 2)) # default doesn't just have to apply to the last field Point = namedlist('Point', [('x', 0), 'y', ('z', 20)], 100) self.assertEqual(Point(), Point(0, 100, 20))
def test_docstring(self): Point = namedlist('Point', '') self.assertEqual(Point.__doc__, 'Point()') Point = namedlist('Point', 'dx') self.assertEqual(Point.__doc__, 'Point(dx)') Point = namedlist('Point', 'x') self.assertEqual(Point.__doc__, 'Point(x)') Point = namedlist('Point', 'dx dy, dz') self.assertEqual(Point.__doc__, 'Point(dx, dy, dz)') Point = namedlist('Point', 'dx dy dz', default=10) self.assertEqual(Point.__doc__, 'Point(dx=10, dy=10, dz=10)') Point = namedlist('Point', 'dx, dy, dz', default=FACTORY(10)) self.assertEqual(Point.__doc__, 'Point(dx=FACTORY(10), dy=FACTORY(10), dz=FACTORY(10))') Point = namedlist('Point', ['dx', 'dy', ('dz', 11.0)], default=10) self.assertEqual(Point.__doc__, 'Point(dx=10, dy=10, dz=11.0)') Point = namedlist('Point', ['dx', 'dy', ('dz', 11.0)], default=FACTORY(list)) if _PY2: list_repr = "<type 'list'>" else: list_repr = "<class 'list'>" self.assertEqual(Point.__doc__, "Point(dx=FACTORY({0}), dy=FACTORY({0}), dz=11.0)".format(list_repr)) Point = namedlist('Point', ['dx', 'dy', ('dz', FACTORY(11.0))], default=[]) self.assertEqual(Point.__doc__, 'Point(dx=[], dy=[], dz=FACTORY(11.0))')
def test_complex_defaults(self): Point = namedlist('Point', ['x', ('y', 10), ('z', 20)], [1, 2, 3]) p = Point() self.assertEqual((p.x, p.y, p.z), ([1, 2, 3], 10, 20)) Point = namedlist('Point', [('x', [4, 5, 6]), ('y', 10), ('z', 20)]) p = Point() self.assertEqual((p.x, p.y, p.z), ([4, 5, 6], 10, 20))
def test_fields(self): Point = namedlist('Point', 'x y z') self.assertEqual(Point._fields, ('x', 'y', 'z')) self.assertIsInstance(Point._fields, tuple) Point = namedlist('Point', 'x y z', 100) self.assertEqual(Point._fields, ('x', 'y', 'z')) Point = namedlist('Point', [('x', 0), ('y', 0), ('z', 0)]) self.assertEqual(Point._fields, ('x', 'y', 'z')) Point = namedlist('Point', '') self.assertEqual(Point._fields, ()) self.assertIsInstance(Point._fields, tuple)
def test_type_has_same_name_as_field(self): Point = namedlist('Point', ['Point', ('y', 10), ('z', 20)], [1, 2, 3]) p = Point() self.assertEqual(len(p), 3) self.assertEqual(p.Point, [1, 2, 3]) Point = namedlist('Point', 'Point') p = Point(4) self.assertEqual(p.Point, 4) Point = namedlist('Point', 'x Point') p = Point(3, 4) self.assertEqual(p.Point, 4)
def test_replace_none(self): Point = namedlist('Point', 'x y z') a = Point(1, 2, 3) b = a._replace() self.assertIsNot(a, b) self.assertEqual((a.x, a.y, a.z), (1, 2, 3)) self.assertEqual((b.x, b.y, b.z), (1, 2, 3))
def test_update_other_self_kwarg(self): # make sure 'self' and 'other' work as kwargs Point = namedlist('Point', 'self other') a = Point(1, 0) a._update(self=10, other=20) self.assertEqual((a.self, a.other), (10, 20))
def test_default_list(self): Point = namedlist('Point', 'x y z'.split(), 100) self.assertEqual(Point(), Point(100, 100, 100)) self.assertEqual(Point(10), Point(10, 100, 100)) self.assertEqual(Point(10, 20), Point(10, 20, 100)) self.assertEqual(Point(10, 20, 30), Point(10, 20, 30)) self.assertEqual(Point()._asdict(), {'x':100, 'y':100, 'z':100})
def test_assert(self): test_list = namedlist('test_list', ['x', 'y']) test_list_instance = test_list(1, 2) with pytest.raises(KeyError) as e: change_namedlist(test_list_instance, {'z': 3}) assert 'Field with name z is not in list test_list(x=1, y=2)' in str( e.value)
def main(anno_file): Data = namedlist("Data", "Gene_stable_id refseq_ncrna hgnc_symbol description") results = OrderedDict() first = "" with open(anno_file, 'rt')as fin: first = fin.readline() for line in fin: line = line.strip("\n") csv_list = line.split("\t") ensembl_id = csv_list[0] ncrna = csv_list[1] symbol = csv_list[2] desc = csv_list[3] if ensembl_id in results: tmp = results[ensembl_id] if ncrna != "": tmp.refseq_ncrna += ncrna + ";" else: results[ensembl_id] = Data(Gene_stable_id=ensembl_id, refseq_ncrna=ncrna, hgnc_symbol=symbol, description=desc) with open(anno_file + ".pared.tsv", 'wt')as fout: fout.write("HGNC symbol\tGene stable ID\tRefSeq ncRNA ID\tdescription\n") for i in results: tmp = results[i] tab = "\t" tmp.refseq_ncrna = tmp.refseq_ncrna.rstrip(";") wf = tmp.hgnc_symbol + tab + tmp.Gene_stable_id +tab + tmp.refseq_ncrna + tab + tmp.description + "\n" fout.write(wf)
def test_mapping(self): # use a regular dict so testing with 2.6 is still possible # do not make any assumptions about field order Point = namedlist('Point', {'x': 0, 'y': 100}) p = Point() self.assertEqual(p.x, 0) self.assertEqual(p.y, 100)
def retrieveSearchData(rowID, DB, search_space): queryRecordList = [ "HostName", "FilePath", "FileName", "LastModified", "LastUpdate", "Size", "ExecFlag", "RowID", "EntryType", "FirstRun", "SHA1", "Search_Space" ] queryRecordFields = namedlist("queryRecordList", queryRecordList, default=None) # Grab all fields in the queryRecordList selectQuery = ','.join(queryRecordList) selectQuery = selectQuery.replace('Search_Space', search_space) # Execute the query entry = DB.Query("SELECT %s FROM Entries_FilePaths INNER JOIN Hosts \ ON Entries_FilePaths.HostID = Hosts.HostID WHERE RowID = '%s'" % (selectQuery, rowID))[0] # todo: There has to be a more pythonic way to do this record = queryRecordFields() tmpDict = dict(zip(queryRecordList, entry)) i = 0 for field in queryRecordList: record[i] = tmpDict[field] i += 1 return record
class Term(namedlist('Term', 'position label symbol content')): '''代数项对象''' __slots__ = () def __init__(self,position=None,label=None,symbol=None,content=None): self.position = position self.label = label self.symbol = symbol self.content = content @property def __str__(self): return 'Term: position=%s '\ 'label=$%s symbol=%s '\ 'content=%s ' % (self.position, self.label, self.symbol,self.content) def change_label(self,newlabel): self.label = newlabel def change_symbol(self): self.symbol *= -1 def change_position(self,newpositon): self.position = newpositon def change_content(self,newcontent): self.content = newcontent
def __init__(self, title='DummyTitle', headless=True): super().__init__(headless=headless) self.__Novel_Site_Data = namedlist('NovelSiteData', [('SiteLink', ''), ('fix', ''), ('suffix', ''), ('AdditionalLinks', []), ('AdditionalActionNeeded', False)]) self.__Domains_to_search = { 'Novel Updates': self.__Novel_Site_Data( SiteLink='https://www.novelupdates.com/series/', fix='-'), #nie jest na czasie z duza iloscia novelek 'Webnovel': self.__Novel_Site_Data( SiteLink='https://www.webnovel.com', AdditionalActionNeeded=True ), #trzeba wyszukiwac w search-bar tytul,wybierac pozycje i dopiero sprawdzac 'ReadLightNovel': self.__Novel_Site_Data(SiteLink='https://www.readlightnovel.org/', fix='-'), 'NovelFull': self.__Novel_Site_Data( SiteLink='https://novelfull.com/', fix='-', suffix='.html' ), #koncowka z .html chyba trzeba przeklikac na ostatnia strone,zeby znalezc numery tytulu 'ReadNovelFull': self.__Novel_Site_Data( SiteLink='https://readnovelfull.com/', fix='-', suffix='.html#tab-chapters-title' ), # '#tab-chapters-title' trzeba dodac do konca nazwy .html } self.__Formated_domain_titles = {} self.title = title self.results = []
def retrieve_genome_and_hash( filestem: str, suffix: str, ftpstem: str, outdir: Path, timeout: int, disable_tqdm: bool = False, ) -> namedlist: """Download genome contigs and MD5 hash data from NCBI. :param filestem: :param suffix: :param ftpstem: :param outdir: :param timeout: :param disable_tqdm: Boolean, show tqdm progress bar? """ DLStatus = namedlist("DLStatus", "url hashurl outfname outfhash skipped error") skipped = False # Flag - set True if we skip download for existing file error = None # Text of last-raised error # Construct remote URLs and output filenames url, hashurl = compile_url(filestem, suffix, ftpstem) outfname, outfhash = construct_output_paths(filestem, suffix, outdir) # Download the genome sequence and corresponding hash file try: download_url(url, outfname, timeout, disable_tqdm) download_url(hashurl, outfhash, timeout, disable_tqdm) except IOError: error = last_exception() return DLStatus(url, hashurl, outfname, outfhash, skipped, error)
def mutabletuple(typename, field_names, default=MtNoDefault): """Factory function that creates a class mutabletuple.""" # Create a namedlist mtuple = namedlist.namedlist(typename, field_names, default) # Set unique attribute to identify mutabletuple classes mtuple.MutableTupleUniqueIdentifier = None # Extend namedlist functionality (fields, defaults) = namedlist._fields_and_defaults(typename, field_names, default, rename=False) mtuple.__init__ = namedlist._make_fn('__init__', _mt_init, fields, defaults) mtuple.__repr__ = _mt_repr mtuple._asdict = _mt_asdict mtuple.iteritems = _mt_iteritems mtuple.merge = _mt_merge mtuple.orderedDict = _mt_orderedDict mtuple.__getstate__ = _mt_getstate mtuple.__setstate__ = _mt_setstate # Assign the class as a global under the same name # Required for pickle so the class seems declared at global level. globals()[typename] = mtuple return mtuple
def __init__(self, label, *n_assets): self.label = label n_asset = namedlist('N_Asset', ['n', 'asset']) self.c = \ [n_asset(n=x[0], asset=x[1]) if isinstance(x, (list, tuple)) else n_asset(n=1, asset=x) for x in n_assets]
def test_slice(self): Point = namedlist('Point', 'x y z color') values = [3, 5, -12, 'red'] p = Point(*values) self.assertEqual(values[0:-1], p[0:-1]) self.assertEqual(values[:3], p[:3]) self.assertEqual(values[4:1:-1], p[4:1:-1])
class SimpleNode(namedlist("_", ["word", "postag", "head", "deprel"])): @classmethod def from_line(cls, line): fields = line.split() return cls(*fields) def to_line(self, sep='\t'): return sep.join(six.text_type(i) for i in self)
def test_setitem(self): Point = namedlist('Point', 'a b') p = Point(1, 2) p[0] = 10 self.assertEqual(list(p), [10, 2]) p[1] = 20 self.assertEqual(list(p), [10, 20]) self.assertRaises(IndexError, p.__setitem__, 2, 3)
def test_replace_none(self): # make sure 'self' and 'other' work as kwargs Point = namedlist('Point', 'self other') a = Point(1, 2) b = a._replace(self=3, other=4) self.assertIsNot(a, b) self.assertEqual((a.self, a.other), (1, 2)) self.assertEqual((b.self, b.other), (3, 4))
def test_NO_DEFAULT(self): # NO_DEFAULT is only really useful with we're using a mapping # plus a default value. it's the only way to specify that # some of the fields use the default. Point = namedlist('Point', {'x':0, 'y':NO_DEFAULT}, default=5) p = Point() self.assertEqual(p.x, 0) self.assertEqual(p.y, 5)
def test_asdict_vars_ordered(self): Point = namedlist('Point', ['x', 'y']) p = Point(10, 20) # can't use unittest.skipIf in 2.6 if sys.version_info[0] <= 2 and sys.version_info[1] <= 6: self.assertIsInstance(p.__dict__, dict) else: self.assertIsInstance(p.__dict__, collections.OrderedDict)
def test_correct_change(self): test_list = namedlist('test_list', ['x', 'y']) test_list_instance = test_list(1, 2) assert test_list_instance.x == 1 assert test_list_instance.y == 2 test_list_instance2 = change_namedlist(test_list_instance, {'x': 3}) assert test_list_instance2.x == 3 assert test_list_instance2.y == 2
def test_update_other_named_list(self): Point = namedlist('Point', ['x', ('y', 10), ('z', 20)], 100) a = Point(10) b = Point(100, 200, 300) a._update(b) self.assertEqual((a.x, a.y, a.z), (100, 200, 300)) self.assertIsNot(a, b)
def __init__(self, weights): self.bridge = CvBridge() self.Data = namedlist('Data', ['pose', 'rgb', 'depth']) self.data = self.Data(pose=None, rgb=None, depth=None) self.is_start = True checkpoint = torch.load(weights, map_location="cpu") self.model = Model(**checkpoint['kwargs']) self.model.load_state_dict(checkpoint["model_state_dict"]) self.model.eval()
def makeCover(prelations, successors): """ prelations = {'activity': ['predecesor1', 'predecesor2'...} successors = {'activity': ['successor1', 'successor2'...} return a dictionary with the improper covers work_table_imp = {index: u(improper covers successors), w(improper covers predecessors)} """ # SConstruct improper cover work table MinRev = namedlist.namedlist("MinRev", ["u", "w"]) # [0 Identical successors, 1 Identical Predecessors) # Group by Identical Successors visited_suc = {} work_table_imp = {} i = 0 for act, columns in successors.items(): u = set() pred = frozenset(columns) if pred not in visited_suc: visited_suc[pred] = act u.add(act) for act2, columns2 in successors.items(): if columns2 == columns: u.add(act2) if u: work_table_imp[i] = MinRev(list(u), []) i += 1 # Group by Identical Predecessors visited_pred = {} i = 0 for act, columns in prelations.items(): u.clear() pred = frozenset(columns) if pred not in visited_pred: visited_pred[pred] = act u.add(act) for act2 in prelations: if pred == columns: u.add(act2) if u: if work_table_imp.has_key(i): work_table_imp[i].w = list(u) else: work_table_imp[i] = MinRev([], list(u)) i += 1 return work_table_imp
def make_defaults(self): """Make a namedtuple for extracting our wanted keys""" if not self.fields: return empty_defaults else: fields = [] end_fields = [] for field in self.fields: if isinstance(field, (tuple, list)): name, dflt = field if callable(dflt): dflt = dflt() end_fields.append((name, dflt)) else: fields.append(field) joined = fields + end_fields identifier = str(joined) if identifier not in cached_namedlists: cached_namedlists[identifier] = namedlist("Defaults", joined) return cached_namedlists[identifier]
from namedlist import namedlist empty_defaults = namedlist("Defaults", []) cached_namedlists = {} class dictobj(dict): fields = None def make_defaults(self): """Make a namedtuple for extracting our wanted keys""" if not self.fields: return empty_defaults else: fields = [] end_fields = [] for field in self.fields: if isinstance(field, (tuple, list)): name, dflt = field if callable(dflt): dflt = dflt() end_fields.append((name, dflt)) else: fields.append(field) joined = fields + end_fields identifier = str(joined) if identifier not in cached_namedlists: cached_namedlists[identifier] = namedlist("Defaults", joined) return cached_namedlists[identifier] def __init__(self, *args, **kwargs):
def sysloOptimal(prelations): """ Build a PERT graph using Syslo algorithm return p_graph pert.PertMultigraph() """ # Adaptation to avoid multiple end nodes successors = graph.reversed_prelation_table(prelations) end_act = graph.ending_activities(successors) #Kahn1962.check_cycles(successors) prela = successors.copy() Columns = namedlist.namedlist('Columns', ['pre', 'blocked', 'dummy', 'suc', 'start_node', 'end_node']) # [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node] # Blocked = (False or Activity with same precedents) #Step 0. grafo = {} alt = graph.successors2precedents(successors) grafo = graph.successors2precedents(syslo_table.syslo(prela, grafo, alt)) #Step 1. Save the new prelation table in a work table work_table = {} for act, pre in grafo.items(): if not act in prelations: work_table[act] = Columns(pre, False, True, None, None, None) else: work_table[act] = Columns(pre, False, False, None, None, None) #Step 2. Identify Dummy Activities And Identical Precedence Constraint of Diferent Activities visited_pred = {} for act, columns in work_table.items(): pred = frozenset(columns.pre) if pred not in visited_pred: visited_pred[pred] = act else: columns.blocked = visited_pred[pred] #Step 3. Creating nodes # (a) find start nodes node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging for act, columns in work_table.items(): if not columns.blocked: columns.start_node = node node += 1 if columns.blocked: columns.start_node = work_table[columns.blocked].start_node # Associate activities with their end nodes for suc, suc_columns in work_table.items(): if not suc_columns.blocked: if act in suc_columns.pre: columns.suc = suc break # (b) find end nodes graph_end_node = node # Reserve one node for graph end node += 1 for act, columns in work_table.items(): suc = columns.suc if suc: columns.end_node = work_table[suc].start_node else: # Create needed end nodes, avoiding multiple graph end nodes (adaptation) if act in end_act: columns.end_node = graph_end_node else: columns.end_node = node node += 1 # Step 4. Remove redundancy of dummy activities vis = [] for act, columns in work_table.items(): if columns.dummy == False: for q in work_table[act].pre: for w in work_table[act].pre: if q in work_table and w in work_table: if q != w and work_table[q].pre == work_table[w].pre and work_table[q].dummy==True and work_table[w].dummy==True: if w not in vis: del work_table[w] vis.append(q) #Step 5. Generate the graph pm_graph = pert.PertMultigraph() for act, columns in work_table.items(): _, _, dummy, _, start, end = columns pm_graph.add_arc((start, end), (act, dummy)) p_graph = pm_graph.to_directed_graph() return p_graph return p_graph
Grammatical agreement conversion for words in error reporting. :copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules from namedlist import namedlist import six # OBJECTS # ------- GrammaticalNumber = namedlist("GrammaticalNumber", "singular plural") # DATA # ---- GRAMMATICAL_NUMBERS = { '-s': GrammaticalNumber("", "s"), '-at': GrammaticalNumber("at", "ose"), '-y': GrammaticalNumber("y", "ies"), } SINGULAR = {k: v.singular for k, v in GRAMMATICAL_NUMBERS.items()} PLURAL = {k: v.plural for k, v in GRAMMATICAL_NUMBERS.items()}
def sysloPolynomial(prelations): # Adaptation to avoid multiple end nodes successors = graph.reversed_prelation_table(prelations) end_act = graph.ending_activities(successors) # Step 0. Construct work table with Immediate Predecessors Columns = namedlist.namedlist("Columns", ["pre", "blocked", "dummy", "suc", "start_node", "end_node"]) # [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node] # Blocked = (False or Activity with same precedents) # Step 1. Create the improper covers work_table_pol = makeCover(prelations, successors) # Step 2. Syslo Polynomial algorithm final = successors.copy() visited = [] for act, pred in prelations.items(): for v in pred: for u in pred: if u != v and successors[v] != successors[u] and act not in visited: # Find activity in the improper cover table for key, value in work_table_pol.items(): if act in value.w: w = value.w # Find each row that belongs to the predecessors of activity for key, value in work_table_pol.items(): if set(value.u).issubset(prelations[act]) and value.u: vertex = set(value.u).pop() # Compare successors of a row with the improper cover of the activity if successors[vertex] != w: for q in value.u: if final.has_key(q): final[q] = list( (set(final[q]) - set(w) | set([str(vertex) + separator + str(act)])) - set([act]) ) else: final[q] = list( set(successors[q]) - set(w) | set([str(vertex) + separator + str(act)]) ) final[str(vertex) + separator + str(act)] = [act] for l in w: visited.append(l) final = graph.successors2precedents(final) work_table = {} for act, pred in final.items(): work_table[act] = Columns(pred, False, False, None, None, None) if act not in prelations: work_table[act].dummy = True # Step 3. Identify Dummy Activities And Identical Precedence Constraint of Diferent Activities visited_pred = {} for act, columns in work_table.items(): pred = frozenset(columns.pre) if pred not in visited_pred: visited_pred[pred] = act else: columns.blocked = visited_pred[pred] # Step 4. Creating nodes # (a) find start nodes node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging for act, columns in work_table.items(): if not columns.blocked: columns.start_node = node node += 1 if columns.blocked: columns.start_node = work_table[columns.blocked].start_node # Associate activities with their end nodes for suc, suc_columns in work_table.items(): if not suc_columns.blocked: if act in suc_columns.pre: columns.suc = suc break # (b) find end nodes graph_end_node = node # Reserve one node for graph end node += 1 pm_graph = pert.PertMultigraph() for act, columns in work_table.items(): suc = columns.suc if suc: columns.end_node = work_table[suc].start_node else: # Create needed end nodes, avoiding multiple graph end nodes (adaptation) if act in end_act: columns.end_node = node else: columns.end_node = graph_end_node node += 1 # Generate the graph _, _, dummy, _, start, end = columns pm_graph.add_arc((start, end), (act, dummy)) p_graph = pm_graph.to_directed_graph() return p_graph
def reactivenamedlist(name, *args, **kwargs): nlist = namedlist.namedlist('_nl_' + name, *args, **kwargs) rnl = type(str(name), (ReactiveNamedListMixin, nlist,), {}) return rnl
import namedlist Family = namedlist.namedlist('Columns', ['u', 'w', 'est', 'no_est']) # [0 Activities, 1 Successors, 2 Estable, 3 Non-estable, # Activities = (Activities with same successors) def syslo(temp, pert_graph, alt): """ Steps to build a PERT graph with the minimal number of dummy activities through the Syslo improper cover table return p_graph dictionary """ # Step 0.1. Topological Sorting setfamily = [] for k in sorted(temp, key = lambda k: len(temp[k]), reverse = True): setfamily.append(k) for k, v in temp.items(): for k2, v2 in temp.items(): if k != k2 and set(v).issubset(set(v2)) and len(v) < len(v2): setfamily.remove(k) setfamily.insert(setfamily.index(k2), k) setfamily.remove(k2) setfamily.insert(setfamily.index(k), k2)
__author__ = 'osakaaa' """Utility module with types difinitions""" from namedlist import namedlist FUZZMODES = ["headers", "post-data", "url-data", "whole-request", "poc"] HTTP_METHODS = ["HEAD", "GET", "POST", "OPTIONS", "PUT", "DELETE", "TRACE", "CONNECT"] INPUT = ["wuzzer", "custom", "pcap"] """HTTP HEADER SPECIFICATION""" HEADER = namedlist("HEADER", "name delimiter value content default fuzz") """HTTP POST DATA SPECIFICATION""" DATA = namedlist("DATA", "name delimiter value content") """HTTP URL SPECIFICATION""" PATH = namedlist("PATH", "type delimiter name value content") """FIRST LINE OF HTTP REQUEST""" FIRSTLINER = namedlist("FIRSTLINER", "method url version") """TASK format""" HEADER_GEN_MAP = {"Connection": "connection", "Accept-Charset": "acceptcharset", "Accept-Language": "acceptlanguage", "Accept": "accept", "Accept-Encoding": "acceptencoding", "Content-Type": "contenttype", "Range": "range", "Authorization": "basic_auth", "Cookie": "cookie"} BYTE = 8 WORD = 16 DWORD = 32
:copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules import unittest from namedlist import namedlist from xldlib.chemical import formula # OBJECTS # ------- Formula = namedlist("Formula", "string strict conditions") Condition = namedlist("Condition", "formula mass") # ITEMS # ----- FORMULAS = [ Formula("C2", False, [ Condition("C2", 24.0), Condition("C4", 48.0), ]), Formula("Hex", False, [ Condition('O5 C6 H10', 162.05282347), Condition('O10 C12 H20', 324.10564694), ]), Formula("HexNAc", False, [
from conn_db import conn_DB from namedlist import namedlist from summarizer import summarize from comment_select import * import sys import argparse import datetime import math import nltk import re #TODO: reconsider period CommentInfo = namedlist('CommentInfo','cid,sentence,rating') SENT_TOKENIZER = nltk.data.load('tokenizers/punkt/english.pickle') PERCENT = 0.4 LEAST = 5 SHORTEST = 100 SENTIMENT = ['negative','positive'] def summary_update(db, cur, tid, period, portion): current = datetime.datetime.now() last = current - datetime.timedelta(hours=period) last = last.strftime("%Y-%m-%d %H:%M:%S") print last get_entities = "SELECT eid FROM entity where tid="+tid+" AND updated>'"+last+"';" print get_entities cur.execute(get_entities) entities = cur.fetchall() counter = 1
from xldlib.definitions import re from xldlib.resources.parameters import defaults from . import configurations as config __all__ = [ 'ProteolyticEnzyme' ] # OBJECTS # ------- Cleaved = namedlist("Cleaved", "peptide position remaining") class ProteolyticEnzyme(object): ''' Object definition for an item that mimics a proteolytic enzyme. The object is a wrapper around a compiled regex, which then provides convenience methods for cleaving a target sequence. ''' def __init__(self, enzyme=None): super(ProteolyticEnzyme, self).__init__() self.enzyme = self._enzymechecker(enzyme) self.cut_regex = re.compile(self.enzyme.cut_regex)
from xldlib.utils import decorators, logger from . import lineedit, spinbox # ERRORS # ------ ERROR = 'Invalid value entered, value must match {}' # OBJECTS # ------- Storage = namedlist("Storage", [ ("key", NO_DEFAULT), ("data", defaults.DEFAULTS)] ) class BaseStorage(views.ViewObject): '''Inheritable property definitions for connecting change state/saves''' @property def store(self): return self._store @property def data(self): return self.store.data @property
from datetime import date from PyQt4 import QtCore, QtGui from PyQt4.QtCore import SIGNAL import web_scraper from collections import namedtuple from namedlist import namedlist Subject = namedlist("Subject", ["active", "nr", "name", "req", "exam_type", "semester", "grade", "status", "credits", "note", "attempt", "date"]) # TODO: translate Subject.header = ["Count", "Nr", "Name", "Req", "Exam type", "Semester", "Grade", "Status", "Credits", "Note", "Attempt", "Date"] #Subject.visibility = [True, False, True, False, False, False, True, # False, True, False, False, False] class GradesModelProxy(QtGui.QSortFilterProxyModel): """This proxy offers column visibility toggling and filtering the data from GradesModel. """ def __init__(self, parent=None): QtGui.QSortFilterProxyModel.__init__(self, parent) self.col_visibility = [True, False, True, False, False, False, True, False, True, False, False, False] self.setDynamicSortFilter(True)
@sequence.serializable("SpectralFormatVersion") class Version(namedlist("Version", "name major minor revision " "distiller format defaults")): # PUBLIC def tostr(self): '''String representation of the version''' return "{0}.{1}.{2}, {3}".format(self.major, self.minor, self.revision, self.distiller) MgfDefaults = namedlist("MgfDefaults", "regexp start end skip") MzmlDefaults = namedlist("MzmlDefaults", "regexp") MzxmlDefaults = namedlist("MzxmlDefaults", "regexp") LinkDefaults = namedlist("LinkDefaults", "regexp") @serialization.register("SpectralFormat") class SpectralFormat(dicttools.EngineDict): '''Method definitions for spectral format objects''' # PUBLIC def matchfile(self, fileobj): '''Matches a given fileobj to a spectral database format''' fileformat = _fileformat(fileobj)
# load modules/submodules import atexit import os from namedlist import namedlist from PySide import QtCore from xldlib.general import mapping from xldlib.resources import paths # OBJECTS # ------- MinimumScore = namedlist("MinimumScore", "protein peptide") MaximumEV = namedlist("MaximumEV", "protein peptide") # PATHS # ----- DEFAULT_PATH = os.path.join(paths.DIRS['preferences'], 'defaults.json') # DATA # ---- DEFAULTS = mapping.Configurations(DEFAULT_PATH, [ # SYSTEM # ------ # Updates
from namedlist import namedlist A = namedlist("A", "x y") B = namedlist("B", "x y") C = namedlist("C", "i j") print(A(x=10, y=20) == A(x=10, y=20)) print(A(x=10, y=20) == B(x=10, y=20)) print(A(x=10, y=20) == C(i=10, j=20)) print(A(x=10, y=20) < A(x=20, y=10))
__all__ = [ 'TAXA' ] # OBJECTS # ------- Species = namedlist("Species", [ 'id', 'species', 'genus', ('family', None), ('order', None), ('class_', None), ('phylum', None), ('kingdom', None), ('domain', None), ]) # DATA # ---- TAXA = OrderedDict([ ('M. musculus', Species(id='10090', species='musculus', genus='Mus', family='Muridae',
:license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules from namedlist import namedlist __all__ = [ 'INPUT_TABLE_BAR', 'TABLE_BAR', 'TRANSITIONS_BAR' ] # OBJECTS # ------- Shortcut = namedlist("Shortcut", "key sequence description") # DATA # ---- #MENU = [ # Shortcut(key='Ctrl+F4', description='Close Application'), # Shortcut(key='Ctrl+s', description='Save Settings') #] # TABLE_BAR = [ Shortcut(key='A', sequence='Ctrl + A', description='Select All'), Shortcut(key='B',
:copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules import unittest from namedlist import namedlist from xldlib.chemical.proteins.configurations import protease from xldlib.definitions import re # OBJECTS # ------- Test = namedlist("Test", "sequence position") # ITEMS # ----- PROTEASES = [ ('Trypsin', ['K', 'R'], ['P'], protease.TERMINI['C']), ('Lys-C', ['K'], [], protease.TERMINI['C']), ('Lys-N', ['K'], [], protease.TERMINI['N']), ('Fake-TrypsinN', ['K', 'R'], ['P'], protease.TERMINI['N']), ] TESTS = [ Test("MKWVTF", [1, 1, 0, 0]), Test("PKLKPDPNTLCDEFK", [1, 1, 0, 2]),
import unittest from collections import namedtuple from namedlist import namedlist import numpy as np from xldlib.general.mapping import functions, serialize from xldlib.utils.io_ import high_level # OBJECTS # ------- JsonTest = namedlist("JsonTest", "input output") NamedList = namedlist("NamedList", "field") NamedTuple = namedtuple("NamedTuple", "field") class Unserializable(object): '''Unserializable object definition''' class NoSetter(dict): '''Dictionary object with an optionally blocked `__setitem__` method''' # BLOCKED # ------- blocked = False
else: from StringIO import StringIO else: from StringIO import StringIO import traceback # Third-party packages available on PyPi from namedlist import namedlist import numpy logger = logging.getLogger(__name__) __version__ = "0.7.7" HeaderItem = namedlist("HeaderItem", ["mnemonic", "unit", "value", "descr"]) Curve = namedlist("Curve", ["mnemonic", "unit", "value", "descr", "data"]) class LASDataError(Exception): '''Error during reading of numerical data from LAS file.''' pass class LASHeaderError(Exception): '''Error during reading of header data from LAS file.''' pass
host.interface) def find(self, dst_ip): try: return next(e for e in self.entries if dst_ip & e.mask == e.net) except StopIteration: raise KeyError('no matching entry for {}'.format(dst_ip)) def add(self, net, mask, gateway, interface): self.entries.append(Entry( IP(net), IP(mask), IP(gateway), interface)) def __getitem__(self, index): return self.entries[index] def __iter__(self): return iter(self.entries) def __repr__(self): s = '{:16} {:16} {:16} {:16}\n'.format( 'Network', 'Mask', 'Gateway', 'Interface') for net, mask, gateway, interface in self: s += '{:16} {:16} {:16} {:16}\n'.format( net, mask, gateway, interface.ip) return s Entry = namedlist('Entry', ['net', 'mask', 'gateway', 'interface'])
:copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules from namedlist import namedlist __all__ = [ 'SCAN_TITLES' ] # OBJECTS # ------- ScanTitle = namedlist("ScanTitle", "vendor format distiller regexp") # DATA # ---- # Each regex added needs to have a <num> and a <frac> # capture group. If the fraction is not specified, this # can capture a null group, but the num is crucial for # scan linking. Any other capture groups may be additionally defined. SCAN_TITLES = [ ScanTitle(vendor='thermo_finnigan', format='raw', distiller='DTA SuperCharge', regexp=r'(?P<frac>\w+)\.(?P<num>\d+)\.\d+\.\d{1,2}\.dta'),
- id - tag_names - text - answers Answer: - valid - fixed_position - text """ import json from namedlist import namedlist # Project = namedlist('Project', ['name', 'total_questions_per_exam', 'total_exams_to_generate', 'current_page', 'tags', 'questions']) Project = namedlist('Project', ['name', 'total_questions_per_exam', 'total_exams_to_generate', 'tags', 'questions']) Tag = namedlist('Tag', ['name', 'min_questions']) Question = namedlist('Question', ['id', 'tag_names', 'text', 'answers']) Answer = namedlist('Answer', ['valid', 'fixed_position', 'text']) def dump_project(proj, path): try: s = json.dumps(proj) with open(path, 'w') as fp: fp.write(s) except: print 'Error saving Project' def load_project(path):
# ----- VIEWS = paths.DIRS['views'] SPLASH_PATH = os.path.join(VIEWS, 'splash.json') CROSSLINK_DISCOVERER_PATH = os.path.join(VIEWS, 'discoverer.json') TRANSITION_PATH = os.path.join(VIEWS, 'transitions.json') FINGERPRINT_PATH = os.path.join(VIEWS, 'fingerprint.json') DIALOGS_PATH = os.path.join(VIEWS, 'dialogs.json') CONTEXTS_PATH = os.path.join(VIEWS, 'contexts.json') # OBJECTS # ------- Dimensions = namedlist("Dimensions", "w h") Frame = namedlist("Frame", "x y w h") XlDiscovererMode = namedlist("XlDiscovererMode", "icon title banner") Thresholds = namedlist("Thresholds", "upper lower") class ViewConfigurations(mapping.Configurations): '''Definitions which defines a view_edited signal back to edit''' def __init__(self, *args, **kwds): super(ViewConfigurations, self).__init__(*args, **kwds) self.edited = signals.Signal() self.edited.connect(self.modified) # PUBLIC
"""Stores data structures""" from enum import Enum from namedlist import namedlist class Split(Enum): """Enum containing information of how the window is split: horizontally or vertically. """ vert = 0 horz = 1 def swap(self): """Returns the opposite split. """ return Split((self.value + 1) % 2) Rect = namedlist('Rect', 'x, y, w, h') Size = namedlist('Size', 'w, h')
:license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules import unittest from namedlist import namedlist from PySide import QtCore, QtGui from xldlib.qt.resources import enums # OBJECTS # ------- Test = namedlist("Test", "instance key enum") # ITEMS # ----- ITEMS = [ Test(instance=enums.CONNECTION, key='Queued', enum=QtCore.Qt.QueuedConnection), Test(instance=enums.CURSOR, key='Arrow', enum=QtCore.Qt.ArrowCursor), Test(instance=enums.EDIT_TRIGGER, key='No', enum=QtGui.QAbstractItemView.NoEditTriggers),
from PySide import QtCore, QtGui from xldlib.definitions import ZIP from xldlib.general import mapping from xldlib.gui.views import widgets from xldlib.qt.objects import views from xldlib.qt import resources as qt from xldlib.resources.parameters import defaults from xldlib.utils import logger from . import base_canvas, legends, lines, plots # OBJECTS # ------- PeakIndexes = namedlist("PeakIndexes", "start end") # AXIS # ---- def tickStrings(values, scale, spacing, str_format = '{:.1e}'): return [str_format.format(i) for i in values] # VIEWBOX # ------- class CustomViewBox(pg.ViewBox):