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 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))
def __init__(self):
self.link = Link()
self.h = self.link
