def main(project_name_param_, assets_param, assets_out_of_scope): project_name = project_name_param_ project = Project(project_name) assets = assets_param project.set_assets(assets) project.save_project() scan_instance = Scan(project) scan_instance.save_scan() for asset in assets: asset_instance = Asset(scan_instance, asset) asset_subdomains = asset_instance.get_subdomains() asset_id = asset_instance.save_asset() for subdomain in asset_subdomains: subdomain_instance = Subdomain(asset_id, subdomain, assets_out_of_scope) subdomain_links = subdomain_instance.parse_links() subdomain_id = subdomain_instance.save_subdomain() for link in subdomain_links: if link in assets_out_of_scope: continue link_instance = Link(subdomain_id, link) link_instance.process_link() link_id = link_instance.save_link() forms = link_instance.forms for form_index in range(len(forms)): form = forms[form_index] form_instance = Form(link_id, form, form_index) form_instance.save_form()
def __init__(self, tcpSenderVersion, bufferSize, rcvWindow): tcpReceiverVersion = "Tahoe" print "================================================================\n" + " Running TCP " + tcpSenderVersion_ + " sender (and " + tcpReceiverVersion_ + " receiver).\n" try: self.senderEndpt = Endpoint(self, "sender", None, tcpSenderVersion, rcvWindow) self.receiverEndpt = EndPoint(self, "reciever", self.senderEndpt, tcpReceiverVersion, rcvWindow) self.senderEndpt.setRemoteTCPendpoint(setRemoteTCPendpoint) except (Exception): pass # Decide what to do later return self.router = Router(self, "router", bufferSize) self.link1 = Link(self, "link1", senderEndpt, router, 0.001, 0.001) self.link2 = Link(self, "link2", receiverEndpt, router, 0.01, 0.001) self.senderEndpt.setLink(link1) self.receiverEndpt.setLink(link2) self.router.addForwardingTableEntry(senderEndpt, link1) self.router.addForwardingTableEntry(receiverEndpt, link2)
def manage_afterAdd(self, item, container): """Intercept after favorite has beeing added. The tools are not reachable in '__init__' because 'self' is not yet wrapped at this time. That's why the after add hook has to be intercepted. """ # save unique id of favorite self.remote_uid = self._getUidByUrl() # do the usual stuff Link.manage_afterAdd(self, item, container)
def main(): startLink = Link.linkFromUrl("http://www.telenor.com") lf = LinkFinder() links = lf.findLinks(startLink) for l in links: print l
def addLink(self): tA = self.linkA tB = self.linkB if tA == -1 or tB == -1: print("ERROR: a link end not assigned") if tA != tB and not self.hasLink(tA, tB): self.links.append( Link(self, self.getThought(tA), self.getThought(tB), importance=self.linkImportance)) #print "Creating a link!" # set circle colour back to white TA = self.getThought(tA) TA.canvas.itemconfig(TA.smallCircleIndex, fill=toHex(self.cs.smallCircle)) # reset link assignments self.resetLinkData() self.lowerLinks()
def generate_array_links(array_nodes): array_links = [] for i in range(9): for j in range(i, 9): link = Link(array_nodes[i], array_nodes[j + 1]) array_links.append(link) return array_links
def setupDatabase(self): print 'First run, creating tables.' # Create table for crawled links query = '''CREATE TABLE CrawledLinks (CrawledLinkId_PK Integer PRIMARY KEY AUTOINCREMENT, domain TEXT NOT NULL, path TEXT, OriginLinkId int)''' cursor=self.connection.cursor() cursor.execute(query) self.connection.commit() # Create table for unvisited links query = '''CREATE TABLE UnvisitedLinks (UnvisitedLinks_PK INTEGER PRIMARY KEY AUTOINCREMENT, domain TEXT NOT NULL, path TEXT)''' cursor=self.connection.cursor() cursor.execute(query) self.connection.commit() firstLink = Link.linkFromUrl("http://www.telenor.com") self.insertLink(firstLink) print 'Tables created.'
def getLinkFromStringLink(self, originatingLink, stringLink): domain = "" path = "" newlink = urlparse(stringLink) # If the link does not contain a domain, we use the domain of the originating link if newlink.netloc == "": domain = originatingLink.domain else: domain = newlink.netloc path = newlink.path # Add arguments to path, if found if newlink.query != "": path = path + "?" + newlink.query # Anchors within same document and relative links are ignored if path.startswith("#"): return None elif path.startswith(".."): return None # Create a link object link = Link.linkFromDomainAndPath(domain, path) return link
def __iadd__ (self, widget): link = Link (None, RawHTML ("%s" %(len(self.images.child) +1))) self.images += widget self.pager += link self.pager[-1].props['class'] = 'pagenum' return self
def add_links(data, nodes): for i in range(len(nodes)): node = nodes[i] for j in range(len(node.subnodes)): subnode_num = node.subnodes[j] subnode = search_node(subnode_num, nodes) if subnode != None: Link(node.x, node.y, subnode.x, subnode.y)
def createLinksList(self): linkcounter = 1 self.createLinks() for (m, n) in self.links: a = Link(m, n, linkcounter) linkcounter += 1 self.linksList.append(a) return self.linksList
def addChild(parent, depth): if (depth < DEPTH): print "%s () [%s]" % ('\t' * depth, 'DC' + str(len(datacentres))) child = Datacentre('DC' + str(len(datacentres)), self.env, sizeStruct[depth], self.applications) datacentres[child.getName()] = child for childNbr in range(childStruct[depth]): addChild(child, depth + 1) else: child = Leaf(str(len(leafs)), self.env) # Change workload to LEAF# leafs[child.getName()] = child print "%s X [%s]" % ('\t' * depth, child.getName()) link = Link('LINK' + str(len(links)), self.env, Link.RESOURCE_TYPES['M'], 100, self.applications) links[link.getName()] = link link.addPeer(child) link.addPeer(parent) parent.addPeer(link) child.addPeer(link)
def readLinks(self): mp = GerMap() line = self.file.readline() while len(line): ftrs = line.split(',') latlonst1 = [ll.split('/') for ll in ftrs[14].split('|')] latlons = list() for ll in latlonst1: sl0 = float(ll[0]) sl1 = float(ll[1]) if len(ll[2]): sl2 = float(ll[2]) else: sl2 = 0 latlons.append((sl0, sl1, sl2)) rnode = Node(int(ftrs[1]), latlons[0][0], latlons[0][1], latlons[0][2]) nrnode = Node(int(ftrs[2]), latlons[-1][0], latlons[-1][1], latlons[-1][2]) link = Link(int(ftrs[0]), rnode, nrnode, float(ftrs[3])) # def setShape(self, lat, lon, elev = None): for i in range(1, len(latlons) - 1): link.setShape(latlons[i][0], latlons[i][1], latlons[i][2]) if len(ftrs[15]): dstcurt1 = [ll.split('/') for ll in ftrs[15].split('|')] dstcurs = list() for ll in dstcurt1: sl0 = float(ll[0]) sl1 = float(ll[1]) dstcurs.append((sl0, sl1)) # def setCurvature(self, dist, curvature): for d, c in dstcurs: link.setCurvature(d, c) if len(ftrs[16]) > 1: dstslpt1 = [ll.split('/') for ll in ftrs[16].split('|')] dstslps = list() for ll in dstslpt1: sl0 = float(ll[0]) sl1 = float(ll[1]) dstslps.append((sl0, sl1)) # def setSlope(self, dist, curvature): for d, s in dstslps: link.setSlope(d, s) mp.addLink(link) line = self.file.readline() # self.line = self.dir return mp
def moreOption_edit_object(listOfObjects, i, event): mpos = pygame.mouse.get_pos() x = mpos[0] y = mpos[1] menu_obiektow = OB(x, y, 200, 40, (150, 150, 150), (100, 200, 255), pygame.font.SysFont("Comic Sans", 30), ["Usuń obiekt", "Dodaj łącze", "Edytuj ustawienia"]) whiles = True clock = pygame.time.Clock() MyPlayer = 0 selected_option = -1 while whiles == True: mpos = pygame.mouse.get_pos() clock.tick(60) # selected_option = -1 if ((x + 220) >= mpos[0] >= x - 10 and (y + 150) >= mpos[1] >= y - 10): # if selected_option == -1 or selected_option == 1: event_list = pygame.event.get() selected_option = menu_obiektow.update_menu(event_list) menu_obiektow.draw_menu_on_screen(Screen) pygame.display.flip() for event in pg.event.get(): if event.type == pg.QUIT: pg.quit() sys.exit() if (selected_option == 0): ObjectCharacterPC.deleteObject(selected_option, i, listOfObjects) break elif (selected_option == 1): print("") elif (selected_option == 2): ObjectCharacterPC.changeSettings(selected_option, i, listOfObjects, Screen) elif selected_option == 1: # obługa dodawania łączy pomiędzy obiektami startLinkObject = listOfObjects[i] xd = 0 while xd == 0: for event in pg.event.get(): for object in listOfObjects: if event.type == pg.MOUSEBUTTONDOWN: if object.rect.collidepoint( event.pos ) and event.button == 1: # przesuwanie obiektem przy pomocy lewego przycisku myszy endLinkObject = object linkObject = Link(startLinkObject, endLinkObject, Screen, listOfObjects) lista_laczy.append(linkObject) whiles = False xd = 1 else: whiles = False return MyPlayer
class Host(): Host_name = "" A = 192 B = 168 C = random.randint(0, 255) D = random.randint(1, 254) a = random.randint(0, 255) b = random.randint(0, 255) c = random.randint(0, 255) d = random.randint(0, 255) e = random.randint(0, 255) f = random.randint(0, 255) frame = Frame() IP_ADDRESS = [A, B, C, D] MAC_ADDRESS = [a, b, c, d, e, f] link = Link("FE") toPort, fromPort = link.createLink() def __init__(self): pass def __init__(self, Host_Queue, state, name): self.Host_name = name self.state = state self.hostQueue = Host_Queue self.readQueue = Queue() self.Port0 = Port(hostQueue, "Blocked", 0, self.name, self.toPort) readThread = Thread(target=Read, args=(self.hostQueue, )) readThread.start() def __del__(self): self.Read.join() self.Write.join() self.HostThread.join() def Write(self, in_q): while True: if in_q.empty() == 0: pass data = in_q.get() def Read(self, out_q): while True: P.processFrame(message) def toHostPipe(self): return (self.toPort, 0) def Ping(self, IP_ADDRESS): self.HostThread.start() for i in range(4): createICMP_frame(IP_ADDRESS)
def find_articles(website): results = [] try: html = urllib2.urlopen(website).read() except Exception: print "403 Forbidden" return [] seeker_soup = BeautifulSoup(html) news_list = seeker_soup.findAll("a") # Extract all potential links for link in news_list: if link.get("href"): # Make sure it's not deformed link = Link(href = link["href"], website = website, img_src = grab_img_src(link), title = link.getText()) if link.is_news(): results.append(link) results = set(results) return results
def crawlURL(self, url, depth): """crawlURL spawns worker threads that will crawl a given url to a certain depth. Args: url(str): starting url to crawl depth(int): depth at which to stop crawling, MAX = 4 """ if depth > 4: depth = 4 if (depth is 0) and (self.urlsCrawled.count({"url": url}) is not 0): return #start time for stats of crawl start = time.time() #add url and depth to the queue queuedLink = Link(url, depth) self.q.put(queuedLink) sema = threading.Semaphore() sema2 = threading.Semaphore() cv = threading.Condition() barrier = threading.Barrier(self.NUM_THREADS) for i in range(self.NUM_THREADS): t = threading.Thread(target=self.workers, args=( i + 1, sema, sema2, cv, barrier, )) # t.setDaemon(True) # we are not setting the damenon flag t.start() self.running_threads.append(t) # joining threads (we need this if the daemon flag is false) for t in self.running_threads: t.join() crawlTime = round(time.time() - start, 3) print("Execution Time:", crawlTime) print("Crawled Count:", self.crawlCount) print("Error Count:", self.errors.find().count()) self.stats.insert({ "type": "crawl", "threadCount": self.NUM_THREADS, "crawlCount": self.crawlCount, "executionTime": crawlTime, "time": time.strftime("%I:%M:%S"), "date": time.strftime("%d/%m/%Y") }) return
def Render (self): # Add pager and arrows if there is more than 1 item if len(self.pager) > 1 and not self.controls: arrows = Box({'class':'arrows'}) arrows += Link (None, RawHTML("%s"%(_('left'))), {'class': "buttons prev"}) arrows += Link (None, RawHTML("%s"%(_('right'))), {'class': "buttons next"}) self.controls = Box({'class':'controls'}) self.controls += arrows self.controls += self.pager Box.__iadd__ (self, self.controls) # Render render = Box.Render (self) render.headers += HEADERS render.js += JS_INIT %({'id': self.id}) return render
def __iadd__ (self, widget): box = Box ({'class': 'carousel-thumbs'}) box += RawHTML ("%s" %(len(self.images.child) +1)) box += Box ({'class': 'carousel_thumbs-image'}, widget) link = Link (None, Box ({'class': 'carousel_thumbs-link'}, box)) self.images += widget self.pager += link self.pager[-1].props['class'] = 'pagenum' return self
def __init__ (self, results_num, page_num, items_per_page, total_pages, refreshable): Box.__init__ (self, {'class': 'paginator-footer'}) # Get the base URL url = refreshable.url while url[-1] in string.digits+'/': url = url[:-1] # Reckon the range extra = 0 if page_num + FOOTER_OPTIONS > total_pages: extra += abs (total_pages - (page_num + FOOTER_OPTIONS)) if page_num - FOOTER_OPTIONS < 0: extra += abs (page_num - (FOOTER_OPTIONS + 1)) chunk_raw = range(page_num - (FOOTER_OPTIONS + extra), page_num + FOOTER_OPTIONS + extra + 1) chunk = filter (lambda x: x >= 0 and x < total_pages, chunk_raw) # Render it if page_num != 0: url = '%s/%d' %(refreshable.url, page_num-1) link = Link (None, RawHTML (_("Previous")), {'class': 'paginator-footer-prev'}) link.bind ('click', refreshable.JS_to_refresh(url=url)) self += link indexes = Container() for p in chunk: if p == page_num: indexes += RawHTML ("%d"%(p+1)) else: url = '%s/%d' %(refreshable.url, p) link = Link (None, RawHTML ("%d"%(p+1)), {'class': 'paginator-footer-page'}) link.bind ('click', refreshable.JS_to_refresh(url=url)) indexes += link if chunk.index(p) < len(chunk)-1: indexes += RawHTML (", ") self += indexes if page_num < total_pages-1: url = '%s/%d' %(refreshable.url, page_num+1) link = Link (None, RawHTML (_("Next")), {'class': 'paginator-footer-next'}) link.bind ('click', refreshable.JS_to_refresh(url=url)) self += link
def testmod(): import doctest global testEntry, testCatalog, testToHtml, testArchiveToHtml urn = 'urn:x-internet-archive:bookserver:catalog' testCatalog = Catalog(title='Internet Archive OPDS', urn=urn) testLink = Link(url='http://archive.org/download/itemid.pdf', type='application/pdf', rel='http://opds-spec.org/acquisition/buying') catalogLink = Link(url='/providers/IA', type=Link.opds) testEntry = Entry( { 'urn': 'x-internet-archive:item:itemid', 'title': u'test item', 'updated': '2009-01-01T00:00:00Z', 'date': '1977-06-17T00:00:55Z', 'summary': '<p>Fantastic book.</p>', }, links=[testLink]) start = 0 numFound = 2 numRows = 1 urlBase = '/alpha/a/' testNavigation = Navigation.initWithBaseUrl(start, numRows, numFound, urlBase) testCatalog.addNavigation(testNavigation) osDescription = 'http://bookserver.archive.org/catalog/opensearch.xml' testSearch = OpenSearch(osDescription) testCatalog.addOpenSearch(testSearch) testCatalog.addEntry(testEntry) testToHtml = CatalogToHtml(testCatalog) testArchiveToHtml = ArchiveCatalogToHtml(testCatalog) doctest.testmod()
def addLlink(self, fromId, toId, linkId): """ add Link between two Points """ if fromId == toId: print "error: fromNode is same with toNode" return False if isExist(self.pAll[fromId].toIds, toId) > -1: print self.pAll[fromId].toIds print "error: exist links from " + str(fromId) + " to " + str(toId) return False # if isExist(self.pAll[toId].toIds,fromId)>-1: # continue link = Link() link.id = linkId link.fromNode = fromId link.toNode = toId self.pAll[fromId].links.append(Link) self.pAll[fromId].toIds.append(toId) self.pAll[toId].links.append(Link) #//No direction self.pAll[toId].toIds.append(fromId) return True
def addLlink(self,fromId,toId,linkId): """ add Link between two Points """ if fromId==toId: print "error: fromNode is same with toNode" return False if isExist(self.pAll[fromId].toIds,toId)>-1: print self.pAll[fromId].toIds print "error: exist links from "+str(fromId)+" to "+str(toId) return False # if isExist(self.pAll[toId].toIds,fromId)>-1: # continue link=Link() link.id=linkId link.fromNode=fromId link.toNode=toId self.pAll[fromId].links.append(Link) self.pAll[fromId].toIds.append(toId) self.pAll[toId].links.append(Link) #//No direction self.pAll[toId].toIds.append(fromId) return True
def expand(self): import stat from BlockDevice import BlockDevice from CharacterDevice import CharacterDevice from File import File from Link import Link from NamedPipe import NamedPipe from Socket import Socket subdirectories = [] import os children = os.listdir(self.fullname()) for name in children: if self._children.has_key(name): continue pathname = os.path.join(self.fullname(), name) # PORTABILITY: lstat is unix only mode = os.lstat(pathname)[stat.ST_MODE] if stat.S_ISDIR(mode): node = Directory(name, self) subdirectories.append(node) elif stat.S_ISREG(mode): node = File(name, self) elif stat.S_ISLNK(mode): node = Link(name, self) elif stat.S_ISSOCK(mode): node = Socket(name, self) elif stat.S_ISFIFO(mode): node = NamedPipe(name, self) elif stat.S_ISCHR(mode): node = CharacterDevice(name, self) elif stat.S_ISBLK(mode): node = BlockDevice(name, self) else: Firewall.hit("unknown file type: mode=%x" % mode) self._children[node.name] = node self._subdirectories = subdirectories return subdirectories
def link_gen(): if COOKIE_KEY in request.cookies and request.cookies[COOKIE_KEY] == COOKIE_VALUE: if request.method == 'POST': link = request.form['link'] real_file = request.form['real_file'] clicks = request.form['clicks'] timeout = request.form['timeout'] if link is None or real_file is None or clicks is None or timeout is None: abort(400) new_link = Link(real_file, clicks, timeout) global link_map link_map[link] = new_link redirect(request.url) files = os.listdir('files/') if '.gitkeep' in files: files.remove('.gitkeep') return render_template('link_gen.html', files=files) return redirect(url_for('login'))
def readFile(filePtr): tn = TemporalNetwork() for line in filePtr: n1_name = line.split(FRONT_SEP)[0] n2_name = line.split(BACK_SEP)[1].rstrip('\r\n') c1 = line.find(FRONT_SEP) + len(FRONT_SEP) c2 = line.find(BACK_SEP) cons = float(line[c1:c2]) # if cons > 1000: # cons = 10 # elif cons < 1: # cons = -cons # elif cons < 0: # cons = 0.001 node1 = Node(n1_name) node2 = Node(n2_name) link = Link(node1, node2, cons) tn.addLink(link) return tn
def getVisitedLinks(self, num): self.mutex.acquire() links = [] domain_index = 1 path_index = 2 try: query = 'SELECT * FROM CrawledLinks EXCEPT (SELECT * FROM UnvisitedLinks) LIMIT ?' arguments = (num,) cursor = self.connection.cursor() cursor.execute(query, arguments) allentries = cursor.fetchall() for row in allentries: domain = str(row[domain_index]) path = str(row[path_index]) link = Link.linkFromDomainAndPath(domain, path) links.append(link) except Exception, e: pass
def __init__(self, confURL): file = open(confURL, 'r').read() nodeLines = re.findall(r'NODE_.*', file) linkLines = re.findall(r'Innovation_.*', file) linksToAdd = [] nodesToAdd = [] for link in linkLines: innovation = int(re.findall(r'Innovation_(.*?), ', link)[0]) fromID = int(re.findall(r'from=(.*?) :', link)[0]) toID = int(re.findall(r'to=(.*?) ],', link)[0]) weight = float(re.findall(r'Weight: (.*?) --', link)[0]) linksToAdd += [Link(innovation, toID, fromID, weight)] for node in nodeLines: nodeID = int(re.findall(r'NODE_(.*?), ', node)[0]) nodeType = re.findall(r'Type: (.*?), ', node)[0] responseType = re.findall(r'Activation: (.*?), ', node)[0] response = float(re.findall(r'Response: (.*?), ', node)[0]) position = float(re.findall(r'y: (.*?), z:', node)[0]) nodesToAdd += [ Node(nodeID, nodeType, responseType, response, position) ] inputAmount = 0 for node in nodesToAdd: if node.nodeType == "input": inputAmount += 1 self.inputCount = inputAmount nodesToAdd.sort(key=operator.attrgetter('position')) self.nodes = nodesToAdd self.links = linksToAdd
def __init__(self): print "GenericANN: Constructor called" self.__layers = [] self.__links = [] self.__exec_order = [] print "GenericANN: Begin read from script" io = ann_io() __ann_data = io.read() self.__hard_wired = __ann_data.get_hard_wired() # TODO read training data print "GenericANN: ", len(__ann_data.get_layers()) random.seed() print "GenericANN: Initializing GenericANN" for ann_layer in __ann_data.get_layers(): layer = Layer(ann_layer) self.__layers.append(layer) print "GenericANN: Added layer:" print "------------------------" layer.printout() print "------------------------" for ann_link in __ann_data.get_links(): # Adding layers to links link = Link(ann_link, self.get_layers()) self.__links.append(link) # Adding links to layers for layer in self.get_layers(): if link.getPostLayer().get_name() == layer.get_name(): layer.add_link_in(link) elif link.getPreLayer().get_name() == layer.get_name(): layer.add_link_out(link) print "GenericANN: Adding link from: " + link.getPreLayer().get_name() + " to: " + \ link.getPostLayer().get_name() if (ann_link.get_link_learn_rule() == RULE.OJA): link.setLearningRule( OjaLearning(ann_link.get_link_learn_rate())) elif (ann_link.get_link_learn_rule() == RULE.GENERAL): link.setLearningRule( GeneralHebbLearning(ann_link.get_link_learn_rate(), ann_link.get_link_learn_param())) elif (ann_link.get_link_learn_rule() == RULE.CLASSICAL): link.setLearningRule( ClassicalHebbLearning(ann_link.get_link_learn_rate())) if not link.isHardwired(): link.connect() else: for layer in self.__layers: layer.set_learning(False) for link in self.__links: link.setLearningMode(False) self.__exec_order = __ann_data.get_exec_order()
def workers(self, id, sema, sema2, cv, barrier): """workers are threads spawned by crawlURL. These workers will crawl a starting link to a certain depth, then end. While crawling, it will add data about these webpages to a MongoDB database. Args: id(int): Thread identifier sema(threading.Semaphore): guards crawlCount and waitingThreads sema2(threading.Semaphore): guards dontCrawl cv(threading.Condition): allowed threads to wait and be notified barrier(threading.Barrier): creates a barrier for threads """ #make local connections for each thread client = pymongo.MongoClient() db = client.db words = db.db urlsCrawled = db.db2 errors = db.db3 done = False crawled = 0 if id is 1: self.waitingThreads = 0 self.crawlCount = 0 self.dontCrawl = {} barrier.wait() while not done: try: # If `False`, the program is not blocked, it will throw the Queue.Empty exception. link = self.q.get(True, .1) url = link.getURL() depth = link.getDepth() #print("STARTED crawling url ", url) #if the url has not been crawled #during this function call #then continue with crawl if not self.alreadyCrawled(url, sema2): #create our scraper object scraper = WebScraper(url) if not scraper.error: #print("No Scraper Error --- crawling url ", url) if depth > 0: #Put all links into a Python Set to remove duplicates links = set(scraper.crawlLinks()) #Add all links to queue for link in links: queuedLink = Link(link, depth - 1) self.q.put(queuedLink) #Notify other threads to check the queue again for links #if they are currently waiting. sema.acquire() self.waitingThreads = 0 cv.acquire() cv.notify_all() #print("Thread ", id, " NOTIFYING") cv.release() sema.release() #Insert url into urlsCrawled try: urlsCrawled.insert({"url": url, "count": 1}) inserted = True #If url has already been inserted, then just increment count except pymongo.errors.DuplicateKeyError: urlsCrawled.update_one({"url": url}, {"$inc": { "count": 1 }}) inserted = False #If inserted, then the url's text needs to be added too. if inserted: #Put all text into a Python Set to remove duplicate words text = set(scraper.crawlText()) for word in text: #Insert word into words try: words.insert({"word": word, "urls": [url]}) #if word has already been inserted, then update urls. except pymongo.errors.DuplicateKeyError: words.update_one({"word": word}, {'$push': { "urls": url }}) #print("FINISHED Crawling url ", url) crawled = crawled + 1 else: #Insert error errorMessage = scraper.getErrorMessage() self.insertError(url, errorMessage, errors) #if the queue is empty, then have the threads #wait. If all the threads but one are waiting, then #no more urls need to be crawled and the workers are done. except queue.Empty: sema.acquire() if self.waitingThreads < self.NUM_THREADS - 1: self.waitingThreads = self.waitingThreads + 1 #print("Thread ", id, " is waiting. Waiting Thread Count: ", self.waitingThreads) sema.release() with cv: cv.wait() #print("Thread ", id, " woken up.") else: sema.release() done = True cv.acquire() cv.notify_all() cv.release() print("Thread ", id, " crawled ", crawled, " webpages.") sema.acquire() self.crawlCount = self.crawlCount + crawled sema.release() return
def addLinkParams( self, end1, end2, color, label, labelColor, isHidden, breed, thickness, shape, tieMode, additionalParams, columnTypes, ): link = Link() rex_who = re.compile(r"\{\S*\s+(\d+)\}") rex_string = re.compile(r"\"(.*)\"") match = rex_who.search(end1) if match != None: link.end1 = int(match.group(1)) else: link.end1 = int(end1) match = rex_who.search(end2) if match != None: link.end2 = int(match.group(1)) else: link.end2 = int(end2) link.color = float(color) link.additionalParams = additionalParams link.columnTypes = columnTypes match = rex_string.search(label) if match != None: link.label = match.group(1) else: link.label = label link.labelColor = float(labelColor) link.isHidden = isHidden == "true" link.breed = breed link.thickness = float(thickness) match = rex_string.search(shape) if match != None: link.shape = match.group(1) else: link.shape = shape match = rex_string.search(tieMode) if match != None: link.tieMode = match.group(1) else: link.tieMode = tieMode self.addLink(link) return link
class TopHandler(Handler): def __init__(self): self.link = Link() self.h = self.link def setGUI(self, GUI): self.GUI = GUI self.link.setGUI(GUI) def setStatechart(self, statechart): self.statechart = statechart self.link.setStatechart(statechart) # FILE EVENTS def onNew(self): if self.statechart.isValid == 0: return # ignore event if self.canClose(): self.statechart.setCanvas(None) self.setStatechart(Statechart(self.GUI.getStatechartHandler())) self.statechart.setModified(0) def onOpen(self): if self.statechart.isValid == 0: return 0# ignore event filename = self.GUI.getStatechartFile() if filename != None: try: f = open(filename, "r") except: self.GUI.showError("Open","Cannot open " + filename) return 0 try: statechart = pickle.load(f) except: self.GUI.showError("Open","Cannot open file:\nFormat not recognized") return 0 if self.canClose(): self.statechart.setCanvas(None) self.setStatechart(statechart) self.statechart.setHandler(self.GUI.workspace) self.statechart.setCanvas(self.GUI.getCanvas()) self.statechart.setModified(0) return 1 def canClose(self): if self.statechart.getModified() == 1: name = self._getShortStatechartName() answer = self.GUI.askYesNoCancel("Warning",name + " has been modified. Save?") if answer == "yes": return self.onSave() elif answer == "no": return 1 else: #cancel return 0 else: return 1 def onSave(self): if self.statechart.isValid == 0: return 0 # ignore event if (self.statechart.getFilename() != ""): self.save() return 1 else: return self.onSaveAs() def onSaveAs(self): if self.statechart.isValid == 0: return 0 # ignore event filename = self.GUI.getStatechartFilename() if filename == "": return 0 self.statechart.setFilename(filename) self.save() return 1 def save(self): f = open(self.statechart.getFilename(),'w') self.statechart.deselect() self.statechart.setCanvas(None) self.statechart.setHandler(None) pickle.dump(self.statechart, f) f.close() self.statechart.setHandler(self.GUI.workspace) self.statechart.setCanvas(self.GUI.getCanvas()) self.statechart.setModified(0) def onExportToPostscript(self): if self.statechart.isValid == 0: return # ignore event filename = self.GUI.getPostscriptFilename() if filename != "": self.statechart.deselect() self.GUI.getCanvas().postscript(file=filename) def onExportToSVM(self): if self.statechart.isValid == 0: return # ignore event filename = self.GUI.getSVMFilename() if filename != "": self.statechart.exportToSVM(filename) def onQuit(self): if self.statechart.isValid == 0: return # ignore event if self.canClose(): self.GUI.destroy() # STATECHART MODIFIED def onStatechartModified(self, modified): name = self._getShortStatechartName() if modified: self.GUI.setRootTitle(name + " [modified] - Statechart Editor") self.GUI.enable("save") else: self.GUI.setRootTitle(name + " - Statechart Editor") self.GUI.disable("save") def _getShortStatechartName(self): name = self.statechart.getFilename() # full name if name == "": return "Untitled" else: return name.split('/')[-1] # only filename # STATECHART EDITION EVENTS def onEditInitCode(self): self.GUI.editInitCode(self.statechart) def onEditInteractCode(self): self.GUI.editInteractCode(self.statechart) def onEditFinalCode(self): self.GUI.editFinalCode(self.statechart) # The other event are forwarded to # the current handler 'h' # STATE/TRANSITION EDITION EVENTS def onAddState(self): self.h = self.h.onAddState() def onAddSeparator(self): self.h = self.h.onAddSeparator() def onAddTransition(self): self.h = self.h.onAddTransition() def onAddTransitionTo(self): self.h = self.h.onAddTransitionTo() def onDelete(self): self.h = self.h.onDelete() def onEditState(self): self.h = self.h.onEditState() def onEditTransition(self): self.h = self.h.onEditTransition() def onSetStateAsDefault(self): self.h = self.h.onSetStateAsDefault() # CANVAS EVENTS def onCanvasEnter(self, event): self.h = self.h.onCanvasEnter(event) def onCanvasLeave(self, event): self.h = self.h.onCanvasLeave(event) def onCanvasButton(self, event): self.h = self.h.onCanvasButton(event) def onCanvasDoubleButton(self, event): self.h = self.h.onCanvasDoubleButton(event) def onCanvasMotion(self, event): self.h = self.h.onCanvasMotion(event) def onCanvasShiftMotion(self, event): self.h = self.h.onCanvasShiftMotion(event) def onCanvasButtonMotion(self, event): self.h = self.h.onCanvasButtonMotion(event) def onCanvasShiftButtonMotion(self, event): self.h = self.h.onCanvasShiftButtonMotion(event) def onCanvasButtonRelease(self, event): self.h = self.h.onCanvasButtonRelease(event) # STATE EVENTS def onStateButton1(self, state, event): self.h = self.h.onStateButton1(state, event) def onStateButton3(self, state, event): self.h = self.h.onStateButton3(state, event) def onStateDoubleButton1(self, state, event): self.h = self.h.onStateDoubleButton1(state, event) def onStateDoubleButton3(self, state, event): self.h = self.h.onStateDoubleButton3(state, event) def onStateButtonMotion1(self, state, event): self.h = self.h.onStateButtonMotion1(state, event) def onStateButtonMotion3(self, state, event): self.h = self.h.onStateButtonMotion3(state, event) def onStateButtonRelease1(self, state, event): self.h = self.h.onStateButtonRelease1(state, event) def onStateButtonRelease3(self, state, event): self.h = self.h.onStateButtonRelease3(state, event) # STATE BORDER EVENTS def onStateBorderEnter(self, state, border, event): self.h = self.h.onStateBorderEnter(state, border, event) def onStateBorderLeave(self, state, border, event): self.h = self.h.onStateBorderLeave(state, border, event) def onStateBorderButton1(self, state, border, event): self.h = self.h.onStateBorderButton1(state, border, event) def onStateBorderButtonMotion1(self, state, border, event): self.h = self.h.onStateBorderButtonMotion1(state, border, event) def onStateBorderButtonRelease1(self, state, border, event): self.h = self.h.onStateBorderButtonRelease1(state, border, event) # SEPARATOR EVENTS def onSeparatorEnter(self, sep, state, event): self.h = self.h.onSeparatorEnter(sep, state, event) def onSeparatorLeave(self, sep, state, event): self.h = self.h.onSeparatorLeave(sep, state, event) def onSeparatorButton1(self, sep, state, event): self.h = self.h.onSeparatorButton1(sep, state, event) def onSeparatorButton3(self, sep, state, event): self.h = self.h.onSeparatorButton3(sep, state, event) def onSeparatorButtonMotion1(self, sep, state, event): self.h = self.h.onSeparatorButtonMotion1(sep, state, event) def onSeparatorButtonMotion3(self, sep, state, event): self.h = self.h.onSeparatorButtonMotion3(sep, state, event) def onSeparatorButtonRelease1(self, sep, state, event): self.h = self.h.onSeparatorButtonRelease1(sep, state, event) def onSeparatorButtonRelease3(self, sep, state, event): self.h = self.h.onSeparatorButtonRelease3(sep, state, event) # TRANSITION EVENTS def onTransitionArrowButton1(self, transition, event): self.h = self.h.onTransitionArrowButton1(transition, event) def onTransitionSrcButton1(self, transition, event): self.h = self.h.onTransitionSrcButton1(transition, event) def onTransitionDestButton1(self, transition, event): self.h = self.h.onTransitionDestButton1(transition, event) def onTransitionHandleButton1(self, transition, event): self.h = self.h.onTransitionHandleButton1(transition, event) def onTransitionDoubleButton1(self, transition, event): self.h = self.h.onTransitionDoubleButton1(transition, event) def onTransitionButton3(self, transition, event): self.h = self.h.onTransitionButton3(transition, event) def onTransitionSrcButtonMotion1(self, transition, event): self.h = self.h.onTransitionSrcButtonMotion1(transition, event) def onTransitionDestButtonMotion1(self, transition, event): self.h = self.h.onTransitionDestButtonMotion1(transition, event) def onTransitionHandleButtonMotion1(self, transition, event): self.h = self.h.onTransitionHandleButtonMotion1(transition, event) def onTransitionButtonRelease1(self, transition, event): self.h = self.h.onTransitionButtonRelease1(transition, event)
def initialize(): ''' Returns array of links, simulation step length in seconds and total simulation time. ''' dt = 0.05 # seconds total_time = 60 # seconds total_links = 240 dx = 5 # link length in meters stop_bar = 50 # link immediately after the stop bar l = 5 # car length in meters g_min = 4 # meters v_max = 20 # m/s a_max = 1.5 # acceleration in m/s^2 b_max = 2 # deceleration in m/s^2 stop_location = 1100 # link number tau = 2.05 # seconds links = [] for i in range(total_links): rho = 0 if i < stop_bar: rho = float(1.0 / (g_min + l)) v = 0 if i >= stop_bar: v = v_max v = 0 is_stop = False if stop_location == i: is_stop = True link = Link(i, dx, l, g_min, v_max=v_max, rho_init=rho, v_init=v, a_max=a_max, b_max=b_max, tau=tau, is_stop=is_stop) links.append(link) for i in range(total_links): if i == 0: ulink = None else: ulink = links[i - 1] if i == total_links - 1: dlink = None else: dlink = links[i + 1] links[i].update_acceleration(dt, ulink, dlink) return links, dt, total_time
def __init__(self, linkedNodes): self.links = [] self.value = 0 for node in linkedNodes: self.links.append(Link(1.0, node, self))
def __init__(self): self.link = Link() self.h = self.link
def get_protocol(url): if url.startswith('http://'): protocol = 'http' else: protocol = 'https' return protocol if __name__ == "__main__": parser = argparse.ArgumentParser(description="Runs an SEO analysis for a website") parser.add_argument("url", help="Markdown file to convert") parser.add_argument("-outfile", help="Output from the SEO analysis goes here") args = parser.parse_args() print 'Running SEO analysis on ' + args.url + '...' l = Link(args.url, 1) links = {} links[l.get_url()] = l domain = get_domain(l.get_url()) protocol = get_protocol(l.get_url()) processed = [] queue = Queue.Queue() queue.put(l) try: file_handle = None file_name = 'index.html' if args.outfile: file_name = args.outfile print 'Output will be saved to file ' + file_name file_handle = open(file_name, 'w')
from mpl_toolkits.mplot3d import Axes3D from mpl_toolkits.mplot3d.art3d import Poly3DCollection import mpl_toolkits.mplot3d.art3d as art3d """ Init robot structure """ UXA = Robot() UX = num.array([[1], [0], [0]]) UY = num.array([[0], [1], [0]]) UZ = num.array([[0], [0], [1]]) BODY = Link('BODY', 0, 3.5, None, 1) BODY.dh = num.array([0, 0, 0, 0]) BODY.rot = num.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]]) BODY.a = UZ UXA.add_link(BODY) RLEG_J0 = Link('RLEG_J0', 1, 0.5, 7, 2) RLEG_J0.dh = num.array([-0.057, 0, -0.042, 0]) RLEG_J0.rot = num.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]]) RLEG_J0.a = UZ UXA.add_link(RLEG_J0)
import sys a = open(sys.argv[1], "r") hdr = a.readline()[:-2].split('\t') print hdr t = False from Link import Link s = Link() data = [] for l in a.readlines(): l = l[:-2].split('\t') C = int(l[hdr.index('rxcmd')]) DATA = int(l[hdr.index('DataPort')], 0x10) if t and not C: # if len(data) and (len(data) != 1 or data[0][1]): s.handle_packet(data) data = [] ts = int(l[0]) if C: data.append((ts, DATA)) else: print "+%d [%02x] alt_int=%d ID=%d RxEvent=%d Vbus=%d LineState=%d%d" % ( ts, DATA, (DATA >> 7) & 1, (DATA >> 6) & 1, (DATA >> 4) & 3,
import sys a = open(sys.argv[1], "r") hdr = a.readline()[:-2].split('\t') print hdr t = False from Link import Link s = Link() data = [] for l in a.readlines(): l = l[:-2].split('\t') C = int(l[hdr.index('rxcmd')]) DATA = int(l[hdr.index('DataPort')], 0x10) if t and not C: # if len(data) and (len(data) != 1 or data[0][1]): s.handle_packet(data) data = [] ts = int(l[0]) if C: data.append((ts, DATA)) else: print "+%d [%02x] alt_int=%d ID=%d RxEvent=%d Vbus=%d LineState=%d%d" % (ts, DATA, (DATA>>7)&1, (DATA>>6)&1, (DATA>>4)&3, (DATA>>2)&3, (DATA>>1)&1, (DATA>>0)&1)
def __init__( self, nodes_fn, links_fn, lookup_kd_size=1, region_kd_size=1000, limit_bbox = None): if(limit_bbox!=None): (left_lon, top_lat, right_lon, bottom_lat) = limit_bbox #Save the filenames for future reference self.nodes_fn = nodes_fn self.links_fn = links_fn self.nodes = [] # A list of all Nodes self.nodes_by_id = {} # Maps integer node_ids to Node objects self.links = [] # A list of all Links # Maps (begin_node_id, end_node_id) to Link objects self.links_by_node_id = {} self.total_region_count = 0 self.isFlat = False self.region_kd_size = region_kd_size self.lookup_kd_size = lookup_kd_size # Read nodes file and create node objects with open(nodes_fn, "r") as f: csv_reader = csv.reader(f) csv_reader.next() # throw out header for line in csv_reader: # Unpack CSV line [begin_node_id, is_complete, # is_complete, _, # num_in_links, _, # num_out_links, osm_traffic_controller, # osm_traffic_controller, longitude, latitude, osm_changeset, # osm_changeset, birth_timestamp, # birth_timestamp, death_timestamp, # death_timestamp, region_id] = line [latitude, longitude] = map(float, [latitude, longitude]) # Add the node if it is within the bounds of the map if(limit_bbox==None or (latitude > bottom_lat and latitude < top_lat and longitude > left_lon and longitude < right_lon)): self.min_lat = min(self.min_lat, latitude) self.max_lat = max(self.max_lat, latitude) self.min_lon = min(self.min_lon, longitude) self.max_lon = max(self.max_lon, longitude) # build node object node = Node( int(begin_node_id), latitude, longitude, int(region_id)) # set additional node properties node.is_complete = bool(is_complete) node.osm_traffic_controller = osm_traffic_controller node.osm_changeset = int(osm_changeset) node.birth_timestamp = int(birth_timestamp) node.death_timestamp = int(death_timestamp) node.region_id = int(region_id) self.nodes.append(node) self.nodes_by_id[node.node_id] = node # read Links file and create links with open(links_fn, "r") as f: csv_reader = csv.reader(f) csv_reader.next() # throw out header for line in csv_reader: # unpack line [_, # link_id, begin_node_id, end_node_id, begin_angle, # begin_angle, end_angle, # end_angle, street_length, osm_name, # osm_name, osm_class, osm_way_id, # osm_way_id, _, # startX, _, # startY, _, # endX, _, # endY, osm_changeset, # osm_changeset, birth_timestamp, # birth_timestamp, death_timestamp] = line # convert strings to int ids [begin_node_id, end_node_id] = map( int, [begin_node_id, end_node_id]) # If the begin_node and end_node exist, create a Link between # them if(begin_node_id in self.nodes_by_id and end_node_id in self.nodes_by_id): begin_node = self.nodes_by_id[begin_node_id] end_node = self.nodes_by_id[end_node_id] # Create the Link object and set properties link = Link(begin_node_id, end_node_id, float(street_length)) link.origin_node = begin_node link.connecting_node = end_node # Add Link to forward and backward adjacency lists begin_node.forward_links.append(link) end_node.backward_links.append(link) # Save additional link properties link.osm_class = osm_class link.begin_angle = float(begin_angle) link.end_angle = float(end_angle) link.osm_name = osm_name link.osm_class = osm_class link.osm_way_id = int(osm_way_id) link.osm_changeset = int(osm_changeset) link.birth_timestamp = int(birth_timestamp) link.death_timestamp = int(death_timestamp) # Add Link to the list and the lookup table self.links.append(link) self.links_by_node_id[begin_node_id, end_node_id] = link for i in xrange(len(self.links)): self.links[i].link_id = i # Clean the graph by removing extra SCCs self.remove_extra_sccs() # Build the KD trees self.build_kd_trees()
class TopHandler(Handler): def __init__(self): self.link = Link() self.h = self.link def setGUI(self, GUI): self.GUI = GUI self.link.setGUI(GUI) def setStatechart(self, statechart): self.statechart = statechart self.link.setStatechart(statechart) # FILE EVENTS def onNew(self): if self.statechart.isValid == 0: return # ignore event if self.canClose(): self.statechart.setCanvas(None) self.setStatechart(Statechart(self.GUI.getStatechartHandler())) self.statechart.setModified(0) def onOpen(self): if self.statechart.isValid == 0: return 0 # ignore event filename = self.GUI.getStatechartFile() if filename != None: try: f = open(filename, "r") except: self.GUI.showError("Open", "Cannot open " + filename) return 0 try: statechart = pickle.load(f) except: self.GUI.showError("Open", "Cannot open file:\nFormat not recognized") return 0 if self.canClose(): self.statechart.setCanvas(None) self.setStatechart(statechart) self.statechart.setHandler(self.GUI.workspace) self.statechart.setCanvas(self.GUI.getCanvas()) self.statechart.setModified(0) return 1 def canClose(self): if self.statechart.getModified() == 1: name = self._getShortStatechartName() answer = self.GUI.askYesNoCancel( "Warning", name + " has been modified. Save?") if answer == "yes": return self.onSave() elif answer == "no": return 1 else: #cancel return 0 else: return 1 def onSave(self): if self.statechart.isValid == 0: return 0 # ignore event if (self.statechart.getFilename() != ""): self.save() return 1 else: return self.onSaveAs() def onSaveAs(self): if self.statechart.isValid == 0: return 0 # ignore event filename = self.GUI.getStatechartFilename() if filename == "": return 0 self.statechart.setFilename(filename) self.save() return 1 def save(self): f = open(self.statechart.getFilename(), 'w') self.statechart.deselect() self.statechart.setCanvas(None) self.statechart.setHandler(None) pickle.dump(self.statechart, f) f.close() self.statechart.setHandler(self.GUI.workspace) self.statechart.setCanvas(self.GUI.getCanvas()) self.statechart.setModified(0) def onExportToPostscript(self): if self.statechart.isValid == 0: return # ignore event filename = self.GUI.getPostscriptFilename() if filename != "": self.statechart.deselect() self.GUI.getCanvas().postscript(file=filename) def onExportToSVM(self): if self.statechart.isValid == 0: return # ignore event filename = self.GUI.getSVMFilename() if filename != "": self.statechart.exportToSVM(filename) def onQuit(self): if self.statechart.isValid == 0: return # ignore event if self.canClose(): self.GUI.destroy() # STATECHART MODIFIED def onStatechartModified(self, modified): name = self._getShortStatechartName() if modified: self.GUI.setRootTitle(name + " [modified] - Statechart Editor") self.GUI.enable("save") else: self.GUI.setRootTitle(name + " - Statechart Editor") self.GUI.disable("save") def _getShortStatechartName(self): name = self.statechart.getFilename() # full name if name == "": return "Untitled" else: return name.split('/')[-1] # only filename # STATECHART EDITION EVENTS def onEditInitCode(self): self.GUI.editInitCode(self.statechart) def onEditInteractCode(self): self.GUI.editInteractCode(self.statechart) def onEditFinalCode(self): self.GUI.editFinalCode(self.statechart) # The other event are forwarded to # the current handler 'h' # STATE/TRANSITION EDITION EVENTS def onAddState(self): self.h = self.h.onAddState() def onAddSeparator(self): self.h = self.h.onAddSeparator() def onAddTransition(self): self.h = self.h.onAddTransition() def onAddTransitionTo(self): self.h = self.h.onAddTransitionTo() def onDelete(self): self.h = self.h.onDelete() def onEditState(self): self.h = self.h.onEditState() def onEditTransition(self): self.h = self.h.onEditTransition() def onSetStateAsDefault(self): self.h = self.h.onSetStateAsDefault() # CANVAS EVENTS def onCanvasEnter(self, event): self.h = self.h.onCanvasEnter(event) def onCanvasLeave(self, event): self.h = self.h.onCanvasLeave(event) def onCanvasButton(self, event): self.h = self.h.onCanvasButton(event) def onCanvasDoubleButton(self, event): self.h = self.h.onCanvasDoubleButton(event) def onCanvasMotion(self, event): self.h = self.h.onCanvasMotion(event) def onCanvasShiftMotion(self, event): self.h = self.h.onCanvasShiftMotion(event) def onCanvasButtonMotion(self, event): self.h = self.h.onCanvasButtonMotion(event) def onCanvasShiftButtonMotion(self, event): self.h = self.h.onCanvasShiftButtonMotion(event) def onCanvasButtonRelease(self, event): self.h = self.h.onCanvasButtonRelease(event) # STATE EVENTS def onStateButton1(self, state, event): self.h = self.h.onStateButton1(state, event) def onStateButton3(self, state, event): self.h = self.h.onStateButton3(state, event) def onStateDoubleButton1(self, state, event): self.h = self.h.onStateDoubleButton1(state, event) def onStateDoubleButton3(self, state, event): self.h = self.h.onStateDoubleButton3(state, event) def onStateButtonMotion1(self, state, event): self.h = self.h.onStateButtonMotion1(state, event) def onStateButtonMotion3(self, state, event): self.h = self.h.onStateButtonMotion3(state, event) def onStateButtonRelease1(self, state, event): self.h = self.h.onStateButtonRelease1(state, event) def onStateButtonRelease3(self, state, event): self.h = self.h.onStateButtonRelease3(state, event) # STATE BORDER EVENTS def onStateBorderEnter(self, state, border, event): self.h = self.h.onStateBorderEnter(state, border, event) def onStateBorderLeave(self, state, border, event): self.h = self.h.onStateBorderLeave(state, border, event) def onStateBorderButton1(self, state, border, event): self.h = self.h.onStateBorderButton1(state, border, event) def onStateBorderButtonMotion1(self, state, border, event): self.h = self.h.onStateBorderButtonMotion1(state, border, event) def onStateBorderButtonRelease1(self, state, border, event): self.h = self.h.onStateBorderButtonRelease1(state, border, event) # SEPARATOR EVENTS def onSeparatorEnter(self, sep, state, event): self.h = self.h.onSeparatorEnter(sep, state, event) def onSeparatorLeave(self, sep, state, event): self.h = self.h.onSeparatorLeave(sep, state, event) def onSeparatorButton1(self, sep, state, event): self.h = self.h.onSeparatorButton1(sep, state, event) def onSeparatorButton3(self, sep, state, event): self.h = self.h.onSeparatorButton3(sep, state, event) def onSeparatorButtonMotion1(self, sep, state, event): self.h = self.h.onSeparatorButtonMotion1(sep, state, event) def onSeparatorButtonMotion3(self, sep, state, event): self.h = self.h.onSeparatorButtonMotion3(sep, state, event) def onSeparatorButtonRelease1(self, sep, state, event): self.h = self.h.onSeparatorButtonRelease1(sep, state, event) def onSeparatorButtonRelease3(self, sep, state, event): self.h = self.h.onSeparatorButtonRelease3(sep, state, event) # TRANSITION EVENTS def onTransitionArrowButton1(self, transition, event): self.h = self.h.onTransitionArrowButton1(transition, event) def onTransitionSrcButton1(self, transition, event): self.h = self.h.onTransitionSrcButton1(transition, event) def onTransitionDestButton1(self, transition, event): self.h = self.h.onTransitionDestButton1(transition, event) def onTransitionHandleButton1(self, transition, event): self.h = self.h.onTransitionHandleButton1(transition, event) def onTransitionDoubleButton1(self, transition, event): self.h = self.h.onTransitionDoubleButton1(transition, event) def onTransitionButton3(self, transition, event): self.h = self.h.onTransitionButton3(transition, event) def onTransitionSrcButtonMotion1(self, transition, event): self.h = self.h.onTransitionSrcButtonMotion1(transition, event) def onTransitionDestButtonMotion1(self, transition, event): self.h = self.h.onTransitionDestButtonMotion1(transition, event) def onTransitionHandleButtonMotion1(self, transition, event): self.h = self.h.onTransitionHandleButtonMotion1(transition, event) def onTransitionButtonRelease1(self, transition, event): self.h = self.h.onTransitionButtonRelease1(transition, event)
def __init__(self): print "GenericANN: Constructor called" self.__layers = [] self.__links = [] self.__exec_order = [] print "GenericANN: Begin read from script" io = ann_io() __ann_data = io.read() self.__hard_wired = __ann_data.get_hard_wired() # TODO read training data print "GenericANN: ", len(__ann_data.get_layers()) random.seed() print "GenericANN: Initializing GenericANN" for ann_layer in __ann_data.get_layers(): layer = Layer(ann_layer) self.__layers.append(layer) print "GenericANN: Added layer:" print "------------------------" layer.printout() print "------------------------" for ann_link in __ann_data.get_links(): # Adding layers to links link = Link(ann_link, self.get_layers()) self.__links.append(link) # Adding links to layers for layer in self.get_layers(): if link.getPostLayer().get_name() == layer.get_name(): layer.add_link_in(link) elif link.getPreLayer().get_name() == layer.get_name(): layer.add_link_out(link) print "GenericANN: Adding link from: " + link.getPreLayer().get_name() + " to: " + \ link.getPostLayer().get_name() if (ann_link.get_link_learn_rule() == RULE.OJA): link.setLearningRule(OjaLearning(ann_link.get_link_learn_rate())) elif (ann_link.get_link_learn_rule() == RULE.GENERAL): link.setLearningRule(GeneralHebbLearning(ann_link.get_link_learn_rate(), ann_link.get_link_learn_param())) elif (ann_link.get_link_learn_rule() == RULE.CLASSICAL): link.setLearningRule(ClassicalHebbLearning(ann_link.get_link_learn_rate())) if not link.isHardwired(): link.connect() else: for layer in self.__layers: layer.set_learning(False) for link in self.__links: link.setLearningMode(False) self.__exec_order = __ann_data.get_exec_order()
def readConfig(filePath): try: routerID = -1 #the router id for out daemon inputPorts = [] #the input ports we are listening to outputLinks = [] #the output connections we are sending to otherRouterIDs = [ ] #for keeping track of the router IDs we have to ensure no duplicates periodic_update_time = 30 #if not specified the periodic update time will default to 30 sec #open the file for reading file = open(filePath, 'r') text = file.readlines() file.close() #for each line in the file for (index, line) in enumerate(text): line = line.strip() #remove any leading whitespace if len(line) == 0: continue #empty line elif line.startswith('#'): continue #comment line elif line.startswith("router-id"): line = line.split( ' ' ) #brake apart the two parts of this line, the second is our router id! routerID = checkParameter( line[1], int, 0, 64001) #bound between 1 and 64000 inclusive otherRouterIDs.append( routerID ) #we don't want people using our ID withut some complaints elif line.startswith("input-ports"): line = line[line.find(' '):].split( ',') #split after the "input-ports" sub string for interface in line: #check each port input interface = checkParameter( interface, int, 1023, 64001) #bound between 1024 and 64000 inclusive if not (interface in inputPorts) and not (interface in [ output.port for output in outputLinks ]): #ensure its unique inputPorts.append(interface) else: raise ValueError( "Inferface socket port {} already in use".format( interface)) elif line.startswith("outputs"): line = line[line.find(' '):].split(',') #split after "outputs" for output in line: link = Link() #we need a containing link object output = output.split('-') #split the parts of each output output[0] = checkParameter(output[0], int, 1023, 64001) if not (output[0] in [ output.port for output in outputLinks ]) and not (output[0] in inputPorts): link.port = output[0] else: raise ValueError( "Inferface socket port {} already in use".format( output[0])) link.metric = checkParameter(output[1], int, -1, 15) #second is the metric output[2] = checkParameter(output[2], int, 0, 64001) if not (output[2] in otherRouterIDs): #final is unique router id otherRouterIDs.append(output[2]) link.routerID = output[2] else: raise ValueError( "Router ID {} is duplicated in the configuration file. Router IDs must be unique." .format(output[2])) outputLinks.append(link) #add the link port to the outputs elif line.startswith("periodic-update-time"): line = line[line.find(' '):] periodic_update_time = checkParameter(line, int, 4, 1800) else: #the line is starting with something unknown raise SyntaxError( "Syntax error in file \"{0}\", on line {1}".format( filePath, index + 1)) if routerID == -1 or len(outputLinks) == 0 or len(inputPorts) == 0: raise ValueError( "router-id, outputs and input-ports must all be specified in the file" ) return (routerID, inputPorts, outputLinks, periodic_update_time ) #return the information in the file except ( ValueError, TypeError ) as error: #if we have some value or type error we have a syntax error in the file raise SyntaxError( "Syntax error in file \"{0}\", on line {1}\nError: {2}".format( filePath, index + 1, error))