示例#1
0
文件: SSP.py 项目: GJClaridge/380CT
 def dynamic(self):
     values = []
     valuescopy = []
     counter = 0
     start = time.clock()
     for i in self.S:
         #print("i",i)
         if values == []:
             values.append(i)
         else:
             valuescopy = copy.copy(values)
             #print ("length",len(valuescopy))
             while counter < len(valuescopy):
                 #print(len(valuescopy), " ", counter)
                 values.append(valuescopy[counter] + i)
                 if valuescopy[counter] + i == self.t:
                     print("Target value found using subset of ", self.S)
                     break
                 #print("values",values)
                 counter += 1
             values.append(i)
             counter = 0
     print(values)
     end = time.clock()
     print(end - start)
示例#2
0
 def time_solve(grid):
     start = time.clock()
     values = solve(grid)
     t = time.clock()-start
     ## Display puzzles that take long enough
     if showif is not None and t > showif:
         display(grid_values(grid))
         if values: display(values)
         print '(%.2f seconds)\n' % t
     return (t, solved(values))
示例#3
0
 def time_solve(grid):
     start = time.clock()
     values = solve(grid)
     t = time.clock() - start
     ## Display puzzles that take long enough
     if showif is not None and t > showif:
         display(grid_values(grid))
         if values: display(values)
         print '(%.2f seconds)\n' % t
     return (t, solved(values))
示例#4
0
    def _recompute_path(self, map, start, end):
        pf = PathFinder(map.successors, map.move_cost, map.move_cost)
        t = time.clock()
        pathlines = list(pf.compute_path(start, end))

        dt = time.clock() - t
        if pathlines == []:
            print "No path found" 
            return pathlines
        else:
            print "Found path (length %d)" % len(pathlines)
            return pathlines
	def __init__(self, session, data, val=None):
		Screen.__init__(self, session, data)

		self.setTitle(_("EMC Cover Selecter"))

		self["actions"] = HelpableActionMap(self, "EMCimdb",
		{
			"EMCEXIT":	self.exit,
			#"green":	self.keySave,
			#"cancel":	self.keyClose,
			"EMCOK":	self.ok,
		}, -1)

		(title, o_path) = data.pop()
		self.m_title = title
		self["m_info"] = Label(("%s") % self.m_title)
		self.o_path = o_path
		self.menulist = []
		self["menulist"] = imdblist([])
		self["poster"] = Pixmap()
		self["info"] = Label(_("Searching for %s") % self.m_title)
		self["menulist"].onSelectionChanged.append(self.showInfo)
		self.check = "false"
		self.path = "/tmp/tmp.jpg"
		self.cover_count = 0
		self.einzel_start_time = time.clock()
		self.einzel_elapsed = time.clock()
		self.einzel_end_time = time.clock()

		self.picload = ePicLoad()
		#self.picload_conn = self.picload.PictureData.connect(self.showCoverCallback)

		self["info"].setText((_("found") + " %s " + _("covers")) % (self.cover_count))
		if val is not None:
			if val == "0":
				self.searchCover(self.m_title)
			elif val == "2":
				self.searchcsfd(self.m_title)
			elif val == "3":
				self.searchcsfd(self.m_title)
				self.searchtvdb(self.m_title)
				self.searchCover(self.m_title)
		else:
			if config.EMC.imdb.singlesearch.value == "0":
				self.searchCover(self.m_title)
			elif config.EMC.imdb.singlesearch.value == "1":
				self.searchtvdb(self.m_title)
			elif config.EMC.imdb.singlesearch.value == "2":
				self.searchcsfd(self.m_title)
			elif config.EMC.imdb.singlesearch.value == "3":
				self.searchcsfd(self.m_title)
				self.searchtvdb(self.m_title)
				self.searchCover(self.m_title)
示例#6
0
文件: SSP.py 项目: GJClaridge/380CT
 def try_at_random(self):
     """ This randomly tries different subsets to see if there is any combination that solves the problem. """
     start = time.clock()
     candidate = []
     total = 0
     while total != self.t:
         candidate = sample(self.S, randint(0, self.n))
         total = sum(candidate)
         print("(Random) Trying: ", candidate, ", sum:", total)
         if total == self.t:
             print("Success!")
     end = time.clock()
     print(end - start)
示例#7
0
def get_performance_sort():
    """Get performance"""
    scores = {}
    trial = 1
    while trial <= 16:
        numbers = [random.randint(1,9) for i in range(2**trial)]
        now = time.clock()
        numbers.sort()
        done = time.clock()
        scores[trial] = (done-now)
        trial = trial + 1
    for i in scores:
        print("%d\t%f" %(2**i,scores[i]))
示例#8
0
def get_performance_sum():
    """Calculating """
    scores = {}
    trial = 1
    while trial <= 16:
        numbers = [random.randint(1,9) for i in range(2**trial)]
        now = time.clock()
        sum = 0
        for d in numbers:
            sum = sum + d
        done = time.clock()
        scores[trial] = (done-now)
        trial = trial + 1
    for i in scores:
        print("%d\t%f" %(2**i,scores[i]))
示例#9
0
    def progress(self, i, n):

        now = time.clock()

        if not self.last:
            self.last = now

        if now - self.last > self.freq:
            diff = now - self.start
            self.last = now

            i_rate = float(i) / diff
            self.rates.append(i_rate)

            if len(self.rates) > self.rates.maxlen / 2:
                rate = sum(self.rates) / len(self.rates)
                rate_type = 'a'
            else:
                rate = i_rate
                rate_type = 'i'

            msg = '{}: Compressed: {} Mb. Downloaded, Uncompressed: {:6.2f}  Mb, {:5.2f} Mb / s ({})'\
                .format(
                    self.message, int(int(n) / (1024 * 1024)),
                    round(float(i) / (1024. * 1024.), 2),
                    round(float(rate) / (1024 * 1024), 2), rate_type)
            self.printf(msg)
	def search_done(self):
		#if self.search_check == "2":
		self.check = "true"
		self.showInfo()
		self.einzel_end_time = time.clock()
		self.einzel_elapsed = (self.einzel_end_time - self.einzel_start_time)
		self["info"].setText(_("found %s covers in %.1f sec") % (self.cover_count, self.einzel_elapsed))
示例#11
0
文件: __init__.py 项目: kball/ambry
    def progress(self, i, n):

        import time
        now = time.clock()

        if not self.last:
            self.last = now

        if now - self.last > self.freq:
            diff = now - self.start
            self.last = now

            i_rate = float(i)/diff
            self.rates.append(i_rate)
            
            if len(self.rates) > self.rates.maxlen/2:
                rate = sum(self.rates) / len(self.rates)
                rate_type = 'a'
            else:
                rate = i_rate
                rate_type = 'i'

            self.printf("{}: Compressed: {} Mb. Downloaded, Uncompressed: {:6.2f}  Mb, {:5.2f} Mb / s ({})".format(
                 self.message,int(int(n)/(1024*1024)),
                 round(float(i)/(1024.*1024.),2), 
                 round(float(rate)/(1024*1024),2), rate_type))
	def showCovers(self, data, title):
		print "EMB iMDB: Cover Select - %s" % title
		#print data
		bild = re.findall('<img src="http://ia.media-imdb.com/images/(.*?)".*?<a href="/title/(.*?)/".*?">(.*?)</a>.*?\((.*?)\)', data, re.S)
		if bild:
			for each in bild:
				#print self.cover_count
				self.cover_count = self.cover_count + 1
				imdb_title = each[2]
				imdb_url = each[0]
				imdb_url = re.findall('(.*?)\.', imdb_url)
				extra_imdb_convert = "._V1_SX320.jpg"
				imdb_url = "http://ia.media-imdb.com/images/%s%s" % (imdb_url[0], extra_imdb_convert)

				self.menulist.append(showCoverlist(imdb_title, imdb_url, self.o_path, "imdb: "))
		else:
			self["info"].setText(_("Nothing found for %s") % title)
			print "EMC iMDB: keine infos gefunden - %s" % title

		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		self.search_check += 1

		#if not config.EMC.imdb.singlesearch.value == "3":
		self.check = "true"
		self.showInfo()
		self.einzel_end_time = time.clock()
		self.einzel_elapsed = (self.einzel_end_time - self.einzel_start_time)
		self["info"].setText(_("found %s covers in %.1f sec") % (self.cover_count, self.einzel_elapsed))
示例#13
0
文件: __init__.py 项目: kball/ambry
 def __init__(self, message='Download', printf = _print):
     import time
     from collections import deque
     self.start = time.clock()
     self.message = message
     self.rates = deque(maxlen=10)
     self.printf = printf
示例#14
0
	def search_done(self):
		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		self.check = "true"
		self.showInfo()
		self.einzel_end_time = time.clock()
		self.einzel_elapsed = (self.einzel_end_time - self.einzel_start_time)
		self["info"].setText((_("found") + " %s " + _("covers in") + " %.1f " + _("sec")) % (self.cover_count, self.einzel_elapsed))
	def search_done(self):
		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(image())
		self.check = "true"
		self.showInfo()
		self.einzel_end_time = time.clock()
		self.einzel_elapsed = (self.einzel_end_time - self.einzel_start_time)
		self["info"].setText((_("found") + " %s " + _("covers in") + " %.1f " + _("sec")) % (self.cover_count, self.einzel_elapsed))
示例#16
0
 def start(self):
     """Start the meaurement process.
     
     Arguments:
     - `self`:
     """
     self.start_time = time.time()
     self.start_clock = time.clock()
     pass
示例#17
0
 def stop(self):
     """Stop the measurement process.
     
     Arguments:
     - `self`:
     """
     self.stop_time = time.time()
     self.stop_clock = time.clock()
     pass
示例#18
0
 def start(self):
     """Start the meaurement process.
     
     Arguments:
     - `self`:
     """
     self.start_time = time.time()
     self.start_clock = time.clock()
     pass
示例#19
0
文件: SSP.py 项目: GJClaridge/380CT
 def exhaustive(self):
     start = time.clock()
     total = 0
     subsets = [[]]
     next = []
     for j in self.S:
         for i in subsets:
             next.append(i + [j])
         subsets += next
         next = []
     print(subsets)
     for i in subsets:
         total = sum(i)
         if total == self.t:
             print(i, " is subset of ", self.S, "that equals ", self.t)
             end = time.clock()
             print(end - start)
             break
示例#20
0
 def stop(self):
     """Stop the measurement process.
     
     Arguments:
     - `self`:
     """
     self.stop_time = time.time()
     self.stop_clock = time.clock()
     pass
示例#21
0
def main():
    # TODO HL-DONE: 1. Define start_time to measure total program runtime by
    # collecting start time
    start_time = time.clock()
    
    # TODO HL-DONE: 2. Define get_input_args() function to create & retrieve command
    # line arguments
    in_arg = get_input_args()
    
    # TODO HL-DONE: 3. Define get_pet_labels() function to create pet image labels by
    # creating a dictionary with key=filename and value=file label to be used
    # to check the accuracy of the classifier function
    answers_dic = get_pet_labels()

    # TODO HL-DONE: 4. Define classify_images() function to create the classifier 
    # labels with the classifier function uisng in_arg.arch, comparing the 
    # labels, and creating a dictionary of results (result_dic)
    result_dic = classify_images()
    
    # TODO HL-DONE: 5. Define adjust_results4_isadog() function to adjust the results
    # dictionary(result_dic) to determine if classifier correctly classified
    # images as 'a dog' or 'not a dog'. This demonstrates if the model can
    # correctly classify dog images as dogs (regardless of breed)
    adjust_results4_isadog()

    # TODO HL-DONE: 6. Define calculates_results_stats() function to calculate
    # results of run and puts statistics in a results statistics
    # dictionary (results_stats_dic)
    results_stats_dic = calculates_results_stats()

    # TODO HL-DONE: 7. Define print_results() function to print summary results, 
    # incorrect classifications of dogs and breeds if requested.
    print_results()

    # TODO HL-DONE: 1. Define end_time to measure total program runtime
    # by collecting end time
    end_time = time.clock()

    # TODO HL-DONE: 1. Define tot_time to computes overall runtime in
    # seconds & prints it in hh:mm:ss format
    tot_time = end_time - start_time
    print("\n** Total Elapsed Runtime:", tot_time)
	def showCovers_csfd(self, data, title):
		bild = re.findall('<img src=\"(//img.csfd.cz/files/images/film/posters/.*?)\".*?<h3 class="subject"><a href="(.*?)" class="film c.">(.*?)</a>.*?</li>', data, re.DOTALL | re.IGNORECASE)
		if bild:
			for each in bild:
				print "EMC csfd: Cover Select - %s" % title
				self.cover_count = self.cover_count + 1
				csfd_title = each[2]
				csfd_detail_url = "http://www.csfd.cz" + each[1]
				print "csfd_detail_url: %s" % csfd_detail_url
				csfd_url = "http:" + each[0]
				print "csfd_url: %s" % csfd_url
				self.menulist.append(showCoverlist(csfd_title, csfd_url, self.o_path, 'csfd: '))
				self.searchcsfd_detail(csfd_detail_url, csfd_title)
		else:
			title_s = re.findall('<title>(.*?)\|', data, re.S)
			if title_s:
				csfd_title = title_s[0]
				print "EMC iMDB csfd: Movie found - %s" % csfd_title
			else:
				csfd_title = title
			bild = re.findall('<img src="(//img.csfd.cz/files/images/film/posters/.*?)" alt="poster"', data, re.DOTALL | re.IGNORECASE)
			if bild:
				print "EMC iMDB csfd: Cover Select - %s" % title
				self.cover_count = self.cover_count + 1
				csfd_url = "http:" + bild[0].replace('\\','').strip()
				print "csfd_url: %s" % csfd_url
				self.menulist.append(showCoverlist(csfd_title, csfd_url, self.o_path, "csfd: "))
				bild = re.findall('<h3>Plak.*?ty</h3>(.*?)</table>', data, re.S)
				if bild:
					bild1 = re.findall('style=\"background-image\: url\(\'(.*?)\'\)\;', bild[0], re.DOTALL | re.IGNORECASE)
					if bild1:
						for each in bild1:
							print "EMC iMDB - csfd: Cover Select - %s" % title
							self.cover_count = self.cover_count + 1
							csfd_url = "http:" + each.replace('\\','').strip()
							print "csfd_url: %s" % csfd_url
							self.menulist.append(showCoverlist(csfd_title, csfd_url, self.o_path, "csfd: "))
					else:
						print "EMC iMDB csfd 3 : no else covers - %s" % title
				else:
					print "EMC iMDB csfd 2 : no else covers - %s" % title
			else:
				print "EMC iMDB csfd 1 : keine infos gefunden - %s" % title

		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		self.search_check += 1
		if not config.EMC.imdb.singlesearch.value == "3":		
			self.check = "true"
			self.showInfo()
			self.einzel_end_time = time.clock()
			self.einzel_elapsed = self.einzel_end_time - self.einzel_start_time
			self["info"].setText(("found %s covers in %.1f sec") % (self.cover_count, self.einzel_elapsed))
示例#23
0
	def __init__(self, session, data):
		Screen.__init__(self, session, data)

		self["actions"] = HelpableActionMap(self, "EMCimdb",
		{
			"EMCEXIT":	self.exit,
			#"green":	self.keySave,
			#"cancel":	self.keyClose,
			"EMCOK":	self.ok,
		}, -1)

		(title, o_path) = data.pop()
		self.title = title
		self.o_path = o_path
		self.menulist = []
		self["menulist"] = imdblist([])
		self["poster"] = Pixmap()
		self["info"] = Label(_("Searching for %s") % self.title)
		self["menulist"].onSelectionChanged.append(self.showInfo)
		self.check = "false"
		self.path = "/tmp/tmp.jpg"
		self.cover_count = 0
		self.einzel_start_time = time.clock()
		self.einzel_elapsed = time.clock()
		self.einzel_end_time = time.clock()

		self.picload = ePicLoad()
		#self.picload.PictureData.get().append(self.showCoverCallback)

		self["info"].setText((_("found") + " %s " + _("covers")) % (self.cover_count))
		if config.EMC.imdb.singlesearch.value == "0":
			self.searchCover(self.title)
		elif config.EMC.imdb.singlesearch.value == "1":
			self.searchtvdb(self.title)
		elif config.EMC.imdb.singlesearch.value == "2":
			self.searchcsfd(self.title)
		elif config.EMC.imdb.singlesearch.value == "3":
			self.searchcsfd(self.title)
			self.searchtvdb(self.title)
			self.searchCover(self.title)
	def display_download(self, movie_title, search_title, path):
		self.counter += 1
		self.counter_download = self.counter_download + 1
		self.end_time = time.clock()
		elapsed = (self.end_time - self.start_time) * 10
		self.count = _("%s: %s von %s") % (self.showSearchSiteName, self.counter, self.count_movies)
		self["info"].setText(self.count)
		self["m_info"].setText(movie_title)
		self["download"].setText(_("Download: %s") % str(self.counter_download))
		self.menulist.append(imdb_show(movie_title, path, str(elapsed), "", search_title))
		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		if self.count_movies == self.counter:
			self.check = "true"
			self.init_ende()
示例#25
0
	def display_download(self, movie_title, search_title, path):
		self.counter += 1
		self.counter_download = self.counter_download + 1
		search_title = getMovieNameWithoutPhrases(getMovieNameWithoutExt(search_title))
		self.end_time = time.clock()
		elapsed = (self.end_time - self.start_time) * 10
		self.count = ("%s: %s " + _("from") + " %s") % (self.showSearchSiteName, self.counter, self.count_movies)
		self["info"].setText(self.count)
		self["m_info"].setText(movie_title)
		self["download"].setText(_("Download: %s") % str(self.counter_download))
		self.menulist.append(imdb_show(movie_title, path, str(elapsed), "", search_title))
		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		if self.count_movies == self.counter:
			self.check = "true"
			self.init_ende()
示例#26
0
	def imdb(self):
		if self.running == "true":
			print "EMC iMDB: Search already Running."

		elif self.running == "false":
			print "EMC iMDB: Search started..."
			self["done_msg"].show()
			self.no_cover()
			self.running = "true"
			self.counter = 0
			self.counter2 = 0
			self.counter3 = 0
			self.counter_download = 0
			self.counter_exist = 0
			self.counter_no_poster = 0
			self.t_elapsed = 0
			self.menulist = []
			self.count_movies = len(self.m_list)
			self["exist"].setText(_("Exist: %s") % "0")
			self["no_poster"].setText(_("No Cover: %s") % "0")
			self["download"].setText(_("Download: %s") % "0")
			self["done_msg"].setText(_("Searching..."))
			self.counter_a = 0
			self.starttime = 0
			self.t_start_time = time.clock()
			self.s_supertime = time.time()
			self.cm_list = self.m_list[:]
			self.search_list = []
			self.exist_list = []
			self.check = "false"
			self["done_msg"].setText(_("Creating Search List.."))
			for each in sorted(self.cm_list):
				(title, path) = each
				path = re.sub(self.file_format + "$", '.jpg', path)
				if os.path.exists(path):
					self.counter2 += 1
					print "EMC iMDB: Cover vorhanden - %s" % title
					self.display_exist(title, path)
				else:
					elem2 = (title, path)
					self.search_list.append(elem2)

			#print "exist:", self.exist_list
			#print "search:", self.search_list
			self.imdb_start()
	def imdb(self):
		if self.running == "true":
			print "EMC iMDB: Search already Running."

		elif self.running == "false":
			print "EMC iMDB: Search started..."
			self["done_msg"].show()
			self.no_cover()
			self.running = "true"
			self.counter = 0
			self.counter2 = 0
			self.counter3 = 0
			self.counter_download = 0
			self.counter_exist = 0
			self.counter_no_poster = 0
			self.t_elapsed = 0
			self.menulist = []
			self.count_movies = len(self.m_list)
			self["exist"].setText(_("Exist: %s") % "0")
			self["no_poster"].setText(_("No Cover: %s") % "0")
			self["download"].setText(_("Download: %s") % "0")
			self["done_msg"].setText(_("Searching..."))
			self.counter_a = 0
			self.starttime = 0
			self.t_start_time = time.clock()
			self.s_supertime = time.time()
			self.cm_list = self.m_list[:]
			self.search_list = []
			self.exist_list = []
			self.check = "false"
			self["done_msg"].setText(_("Creating Search List.."))
			for each in sorted(self.cm_list):
				(title, path) = each
				path = re.sub(self.file_format + "$", '.jpg', path)
				if os.path.exists(path):
					self.counter2 += 1
					print "EMC iMDB: Cover vorhanden - %s" % title
					self.display_exist(title, path)
				else:
					elem2 = (title, path)
					self.search_list.append(elem2)

			#print "exist:", self.exist_list
			#print "search:", self.search_list
			self.imdb_start()
	def __init__(self, session, data):
		Screen.__init__(self, session, data)

		self["actions"] = HelpableActionMap(self, "EMCimdb",
		{
			"EMCEXIT":	self.exit,
			#"green":	self.keySave,
			#"cancel":	self.keyClose,
			"EMCOK":	self.ok,
		}, -1)

		(title, o_path) = data.pop()
		self.title = title
		self.o_path = o_path
		self.menulist = []
		self["menulist"] = imdblist([])
		self["poster"] = Pixmap()
		self["info"] = Label(_("Searching for %s") % self.title)
		self["menulist"].onSelectionChanged.append(self.showInfo)
		self.check = "false"
		self.path = "/tmp/tmp.jpg"
		self.cover_count = 0
		self.search_check = 0
		self.einzel_start_time = time.clock()
		
		self.picload = ePicLoad()
		#self.picload.PictureData.get().append(self.showCoverCallback)
		
		if config.EMC.imdb.singlesearch.value == "0":
			self.searchCover(self.title)
			#self.search_done()
		
		if config.EMC.imdb.singlesearch.value == "1":
			self.searchtvdb(self.title)
			#self.search_done()
		
		if config.EMC.imdb.singlesearch.value == "2":
			self.searchcsfd(self.title)
			#self.search_done()
		
		if config.EMC.imdb.singlesearch.value == "3":
			self.searchcsfd(self.title)
			self.searchtvdb(self.title)
			self.searchCover(self.title)
	def showCovers_tvdb(self, data, title):
		bild = re.findall('<poster>(.*?)</poster>', data)
		if bild:
			print "EMB iMDB: Cover Select - %s" % title
			self.cover_count = self.cover_count + 1
			print "http://www.thetvdb.com/banners/_cache/%s" % bild[0]
			tvdb_url = "http://www.thetvdb.com/banners/_cache/%s" % bild[0]
			print "bild:", tvdb_url
			self.menulist.append(showCoverlist(title, tvdb_url, self.o_path, "tvdb: "))
		else:
			#self["info"].setText(_("Nothing found for %s") % title)
			print "EMC iMDB tvdb: keine infos gefunden - %s" % title

		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(28)
		self.search_check += 1 
		if not config.EMC.imdb.singlesearch.value == "3":		
			self.check = "true"
			self.showInfo()
			self.einzel_end_time = time.clock()
			self.einzel_elapsed = (self.einzel_end_time - self.einzel_start_time)
			self["info"].setText(_("found %s covers in %.1f sec") % (self.cover_count, self.einzel_elapsed))
示例#30
0
 def wrapper(*args, **kwargs):
     t = time.clock()
     res = func(*args, **kwargs)
     print(func.__name__, time.clock()-t)
     return res
import time
from tree import Tree

import parallel_cell_enumeration as p_cell

import parallel_masterprob as p_ma
import pre_process as pre
import subprob as sub


# Generate data sets of different scales and then test different seeds. 
# export OMP_NUM_THREADS=2  (Environment Variable  OMP_NUM_THREADS sets the number of threads)

if __name__ == "__main__":

    start_all = time.clock()
   
    NUM_CORES = 64
    
    #Parallel
    pool = Pool(processes=NUM_CORES)
    pool = None
	
    # Different size of test data set M, K, N
    M_list = [1]  #[1, 4, 8, 16, 32] 
    K_list = [2]  #[2, 4, 6]
    N_list = [10]  #[4, 8, 12]  
            
    # Generate test data sets
    for i_1 in xrange(len(M_list)):
        for i_2 in xrange(len(K_list)):
	def imdb_start(self):
		self["done_msg"].setText(_("Searching.."))
		self.starttime = time.time()
		self.run10 = "false"
		for i in xrange(10):
			#if self.search_list:
			if not len(self.search_list) == 0:
				(title, path) = self.search_list.pop()
				self.start_time = time.clock()

				if config.EMC.imdb.search.value == "0":
					self.name = title.replace(' ','.').replace(':','.').replace('..','.')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('.',' ')
				
					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://www.imdbapi.com/?t=" + self.name.replace('ö','%F6')
						##replace('ö','%F6')
						print "EMC imdbapi.com:", url
						getPage(url, timeout = 10).addCallback(self.imdbapi, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "1":
					self.name = title.replace(' ','+').replace(':','+').replace('-','').replace('++','+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('+',' ')

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://api.themoviedb.org/2.1/Movie.search/de/xml/8789cfd3fbab7dccf1269c3d7d867aff/" + self.name
						print "EMC themoviedb.org:", url						
						getPage(url, timeout = 10).addCallback(self.themoviedb, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "2":
					self.name = title.replace(' ','+').replace(':','+').replace('-','').replace('++','+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('+',' ')

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://ofdbgw.home-of-root.de/search/%s" % self.name
						#url = "http://ofdbgw.home-of-root.de/search/" + self.name
						print "EMC ofdb.de:", url				
						getPage(url).addCallback(self.ofdb_search, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "3":
					self.name = title.replace(':', ' ').replace('-', ' ').replace('++', '+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = urllib.quote(self.name.replace('+', ' '))

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://www.csfd.cz/hledat/?q=%s" % search_title
						print "EMC csfd.cz:", url				
						getPage(url).addCallback(self.csfd_search, self.name, path).addErrback(self.errorLoad, self.name)

			else:
				print "EMC iMDB: MovieList is empty, search is DONE. - BREAK..."
				#self.e_supertime = time.time()
				#total_movie = self.counter3 + self.counter2 
				#total_time = self.e_supertime - self.s_supertime
				#avg = (total_time / total_movie)
				#self.done = _("%s Filme in %.1f sec gefunden. Avg. Speed: %.1f sec") % (total_movie, total_time, avg) 
				#self["done_msg"].setText(self.done)
				#self.running = "false"
				break
示例#33
0
    # record the time for each iteration
    time_iteration = []

    print "Start optimizing..."

    index = 0
    global num_node
    num_node = 0
    current_node = 0

    #Claim a tree
    tree = Tree()
    node = tree.add_node(current_node, theta_L, theta_U)
    num_node = num_node + 1

    start_all = time.clock()
    print x_all[-1]

    while index < MAXITER:
        start = time.clock()
        print "----------------------------iteration %d---------------------------" % index

        # Solve the subproblem
        objOpt, thetaOpt, lamOpt, muOpt = sub.solve_subproblem(
            y, xBar)  #(objOpt) upper bound

        thetaBar.append(thetaOpt)
        lamBar.append(lamOpt)
        muBar.append(muOpt)

        SUBD = np.amin([objOpt, SUBD])
import time
from tree import Tree

import parallel_cell_enumeration as p_cell

import parallel_masterprob as p_ma
import pre_process as pre
import subprob as sub


# Generate data sets of different scales and then test different seeds. 
# export OMP_NUM_THREADS=2  (Environment Variable  OMP_NUM_THREADS sets the number of threads)

if __name__ == "__main__":

    start_all = time.clock()
   
    NUM_CORES = 64
    
    #Parallel
    pool = Pool(processes=NUM_CORES)
    pool = None
	
    # Different size of test data set M, K, N
    M_list = [1]  #[1, 4, 8, 16, 32] 
    K_list = [3]  #[2, 4, 6]
    N_list = [2]  #[4, 8, 12]  
            
    # Generate test data sets
    for i_1 in xrange(len(M_list)):
        for i_2 in xrange(len(K_list)):
示例#35
0
t0 = timeit.default_timer()
factorial(10**5)
print('Elapsed time :', timeit.default_timer() - t0)

#method 3: using cprofile()
import cProfile


def factorial(n):
    num = 1
    while n >= 1:
        num = num * n
        n = n - 1
    return num


cProfile.run('factorial(10**5)')

#method 4: simple method
import time
start = time.clock()
s = 'geeks'
U = []
for c in s:
    U.append(c.upper())
print U
elapsed = time.clock()
e1 = elapsed - start
print "Time spent in function is: ", e1
示例#36
0
    def parseWebpage(self, data, type, title, url, cover_path, season,
                     episode):
        data = six.ensure_str(data)
        self.counting += 1
        self.start_time = time.clock()
        if type == "movie":
            list = []
            list = re.findall(
                '"poster_path":"\\\(.*?)".*?"original_title":"(.*?)"', data,
                re.S)
            if list:
                purl = "http://image.tmdb.org/t/p/%s%s" % (
                    config.movielist.imdb.preferred_coversize.value,
                    list[0][0])
                purl = six.ensure_binary(purl)
                self.counter_download += 1
                self.end_time = time.clock()
                elapsed = (self.end_time - self.start_time) * 1000
                self.menulist.append(
                    self.imdb_show(title, cover_path, '%.1f' % elapsed, "",
                                   title))
                if not fileExists(cover_path):
                    downloadPage(purl, cover_path)

                if config.movielist.imdb.savetotxtfile.value:
                    idx = []
                    idx = re.findall('"id":(.*?),', data, re.S)
                    if idx:
                        iurl = "http://api.themoviedb.org/3/movie/%s?api_key=8789cfd3fbab7dccf1269c3d7d867aff&language=de" % idx[
                            0]
                        iurl = six.ensure_binary(iurl)
                        getPage(iurl,
                                headers={
                                    'Content-Type':
                                    'application/x-www-form-urlencoded'
                                }).addCallback(self.getInfos, id, type,
                                               cover_path)
            else:
                self.counter_no_poster += 1
                self.menulist.append(
                    self.imdb_show(title, cover_path, _("N/A"), "", title))

        elif type == "serie":
            list = []
            list = re.findall('<seriesid>(.*?)</seriesid>', data, re.S)
            if list:
                x = config.movielist.imdb.thetvdb_standardcover.value
                purl = "https://www.thetvdb.com/banners/_cache/posters/%s-%s.jpg" % (
                    list[0], x)
                if x > 1 and not urlExist(purl):
                    x = 1
                    purl = "https://www.thetvdb.com/banners/_cache/posters/%s-%s.jpg" % (
                        list[0], x)
                self.counter_download += 1
                self.end_time = time.clock()
                elapsed = (self.end_time - self.start_time) * 1000
                self.menulist.append(
                    self.imdb_show(title, cover_path, '%.1f' % elapsed, "",
                                   title))
                if not fileExists(cover_path):
                    downloadPage(purl, cover_path)
                if config.movielist.imdb.savetotxtfile.value:
                    if season and episode:
                        iurl = "https://www.thetvdb.com/api/2AAF0562E31BCEEC/series/%s/default/%s/%s/de.xml" % (
                            list[0], str(int(season)), str(int(episode)))
                        iurl = six.ensure_binary(iurl)
                        getPage(iurl,
                                headers={
                                    'Content-Type':
                                    'application/x-www-form-urlencoded'
                                }).addCallback(self.getInfos, id, type,
                                               cover_path)
            else:
                self.counter_no_poster += 1
                self.menulist.append(
                    self.imdb_show(title, cover_path, _("N/A"), "", title))

        self.count = ("%s: %s " + _("from") + " %s") % (
            self.showSearchSiteName, self.counting, self.count_total)
        self["info"].setText(self.count)
        self["no_poster"].setText(
            _("No Cover: %s") % str(self.counter_no_poster))
        self["exist"].setText(_("Exist: %s") % str(self.counter_exist))
        self["download"].setText(
            _("Download: %s") % str(self.counter_download))
        self["menulist"].l.setList(self.menulist)
        self["menulist"].l.setItemHeight(self.itemHeight)
        self.check = True

        if self.counting == self.count_total:
            self.e_supertime = time.time()
            total_time = self.e_supertime - self.s_supertime
            avg = (total_time / self.count_total)
            self.done = ("%s " + _("movies in") + " %.1f " +
                         _("sec found. Avg. Speed:") + " %.1f " +
                         _("sec.")) % (self.count_total, total_time, avg)
            self["done_msg"].setText(self.done)
            self.running = False
            self.showInfo()
示例#37
0
def parallel_cell_numeration(coefficients,
                             nCuts,
                             dim,
                             threshold,
                             pool=None,
                             certain_hyperplane=0):
    '''  Get the thetaB_list of all the regions.
    coefficients: the coefficients of all hyperplanes.
    nCuts: the number of hyperplanes.
    Dim: the dimension of space.
    threshold: the tolerance of the distance from the point to hyperplane
    certain_hyperplane: assume the sign of this hyperplane does not change. '''

    #sub_NUM_CORES = 10
    #Parallel
    #sub_pool = Pool(processes=sub_NUM_CORES)

    thetaB_list = []
    #the structure to manage the process of all the function.
    #openset = Queue.Queue()
    openset = []
    closedset = []

    Initialized_region = initialize_region(coefficients, nCuts, dim, threshold)

    #openset.put(Initialized_region)
    openset.append(Initialized_region)
    print('\nfinding adjacent regions...')

    # non-parallel
    if pool == None:
        while len(openset) != 0:
            #get the region and delete it from the openset.
            region = openset.pop(0)
            closedset.append(region)

            #calculate the adjacency regions
            adj_regions = cal_adjacency_regions(coefficients, nCuts, dim,
                                                region, certain_hyperplane,
                                                threshold)  #, sub_pool)

            for region in adj_regions:
                #if region never appears.
                if region not in openset and region not in closedset:
                    openset.append(region)
    # parallel
    else:
        start = time.clock()
        while len(openset) != 0:
            closedset.extend(openset)
            results = [
                pool.apply_async(cal_adjacency_regions,
                                 args=(coefficients, nCuts, dim, region,
                                       certain_hyperplane, threshold, None,
                                       closedset)) for region in openset
            ]

            #set openset is empty
            openset = []
            #get the result
            for p in results:
                openset.extend(p.get())
            #get the unique list
            openset.sort()
            openset = list(openset
                           for openset, _ in itertools.groupby(openset))

        end = time.clock()
        time_adj_region = end - start
        print('\nFinish finding adjacent regions using: %0.2f' %
              (time_adj_region))

    #Reflection
    for region in closedset:
        thetaB_list.append(region)
        ref_thetaB = reflection(region)
        thetaB_list.append(ref_thetaB)

    #length = len(thetaB_list)
    return thetaB_list
	def parseWebpage(self, data, type, title, url, cover_path, season, episode):
		self.counting += 1
		self.start_time = time.clock()
		if type == "movie":
			list = []
			list = re.findall('original_title":"(.*?)".*?"poster_path":"(.*?)"', data, re.S)
			if list:
				purl = "http://image.tmdb.org/t/p/%s%s" % (config.EMC.imdb.themoviedb_coversize.value, list[0][1])
				self.counter_download += 1
				self.end_time = time.clock()
				elapsed = (self.end_time - self.start_time) * 10
				self.menulist.append(imdb_show(title, cover_path, str(elapsed), "", title))
				if not fileExists(cover_path):
					downloadPage(purl, cover_path).addErrback(self.dataError)
			else:
				self.counter_no_poster += 1
				self.menulist.append(imdb_show(title, cover_path, _("N/A"), "", title))

			# get description
			if config.EMC.imdb.savetotxtfile.value:
				idx = []
				idx = re.findall('"id":(.*?),', data, re.S)
				if idx:
					iurl = "http://api.themoviedb.org/3/movie/%s?api_key=8789cfd3fbab7dccf1269c3d7d867aff&language=de" % idx[0]
					getPage(iurl, headers={'Content-Type':'application/x-www-form-urlencoded'}).addCallback(self.getInfos, id, type, cover_path).addErrback(self.dataError)

		elif type == "serie":
			list = []
			list = re.findall('<seriesid>(.*?)</seriesid>', data, re.S)
			if list:
				purl = "http://www.thetvdb.com/banners/_cache/posters/%s-1.jpg" % list[0]
				#self.guilist.append(((cleanTitle, True, filename),))
				self.counter_download += 1
				self.end_time = time.clock()
				elapsed = (self.end_time - self.start_time) * 10
				self.menulist.append(imdb_show(title, cover_path, str(elapsed), "", title))
				if not fileExists(cover_path):
					downloadPage(purl, cover_path).addErrback(self.dataError)

				# get description
				if config.EMC.imdb.savetotxtfile.value:
					if season and episode:
						iurl = "http://www.thetvdb.com/api/2AAF0562E31BCEEC/series/%s/default/%s/%s/de.xml" % (list[0], str(int(season)), str(int(episode)))
						getPage(iurl, headers={'Content-Type':'application/x-www-form-urlencoded'}).addCallback(self.getInfos, id, type, cover_path).addErrback(self.dataError)
			else:
				self.counter_no_poster += 1
				self.menulist.append(imdb_show(title, cover_path, _("N/A"), "", title))

		self.count = ("%s: %s " + _("from") + " %s") % (self.showSearchSiteName, self.counting, self.count_total)
		self["info"].setText(self.count)
		self["no_poster"].setText(_("No Cover: %s") % str(self.counter_no_poster))
		self["exist"].setText(_("Exist: %s") % str(self.counter_exist))
		self["download"].setText(_("Download: %s") % str(self.counter_download))
		self["menulist"].l.setList(self.menulist)
		self["menulist"].l.setItemHeight(image())
		self.check = True

		if self.counting == self.count_total:
			self.e_supertime = time.time()
			total_time = self.e_supertime - self.s_supertime
			avg = (total_time / self.count_total)
			self.done = ("%s " + _("movies in") + " %.1f " + _("sec found. Avg. Speed:") + " %.1f " + _("sec.")) % (self.count_total, total_time, avg)
			self["done_msg"].setText(self.done)
			self.running = False
示例#39
0
 def __init__(self, message='Download', printf=print_):
     self.start = time.clock()
     self.message = message
     self.rates = deque(maxlen=10)
     self.printf = printf
示例#40
0
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Flatten())
    model.add(Dense(128, activation='tanh'))
    model.add(Dense(num_classes, activation='softmax'))
	# Compile model
    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model
# build the model
model = baseline_model()
model.summary()
model.get_config()
model.get_weights()
model.output_shape
#%%
import time
start_time = time.clock()
# Fit the model
hist1 = model.fit(trainX, trainY, validation_data=(testX, testY), nb_epoch=1000, batch_size=200, verbose=2)

end_time = time.clock()
pretraining_time = (end_time - start_time)
print ('Training took %f minutes' % (pretraining_time / 60.))
#%%
# Final evaluation of the model
loss, accuracy = model.evaluate(testX, testY)
print("\nLoss: %.2f, Accuracy: %.2f%%" % (loss, accuracy*100))
#%%
from sklearn.metrics import confusion_matrix
y_pred = model.predict_classes(testX)
print(y_pred)
p=model.predict_proba(testX) # to predict probability
def parallel_cell_numeration(coefficients,  nCuts,  dim,  threshold, pool = None,  certain_hyperplane = 0):
    '''  Get the thetaB_list of all the regions.
    coefficients: the coefficients of all hyperplanes.
    nCuts: the number of hyperplanes.
    Dim: the dimension of space.
    threshold: the tolerance of the distance from the point to hyperplane
    certain_hyperplane: assume the sign of this hyperplane does not change. '''
    
    #sub_NUM_CORES = 10
    #Parallel
    #sub_pool = Pool(processes=sub_NUM_CORES)
    
    thetaB_list = []
    #the structure to manage the process of all the function.
    #openset = Queue.Queue()
    openset = []
    closedset = []

    Initialized_region = initialize_region(coefficients,  nCuts,  dim,  threshold)
    
    #openset.put(Initialized_region)
    openset.append(Initialized_region)
    print ('\nfinding adjacent regions...') 
	
    # non-parallel
    if pool == None:
        while len(openset) != 0:
            #get the region and delete it from the openset.
            region = openset.pop(0) 
            closedset.append(region)

            #calculate the adjacency regions
            adj_regions = cal_adjacency_regions(coefficients,  nCuts,  dim,  region, certain_hyperplane,  threshold)#, sub_pool)

            for region in adj_regions:
                #if region never appears.
                if region not in openset and region not in closedset:
                    openset.append(region)
    # parallel
    else:
        start = time.clock()
        while len(openset) != 0:
            closedset.extend(openset)
            results = [pool.apply_async(cal_adjacency_regions,  args = (coefficients,  nCuts,  dim,  region, certain_hyperplane,  threshold,  None, closedset)) for region in openset]

            #set openset is empty
            openset = []
            #get the result
            for p in results:
                openset.extend(p.get())
            #get the unique list
            openset.sort()
            openset = list(openset  for openset,  _ in itertools.groupby(openset))
    
        end = time.clock()
        time_adj_region = end - start
        print ('\nFinish finding adjacent regions using: %0.2f'  %(time_adj_region))  

    #Reflection 
    for region in closedset:
        thetaB_list.append(region)
        ref_thetaB = reflection(region)
        thetaB_list.append(ref_thetaB)

    #length = len(thetaB_list)
    return thetaB_list
示例#42
0
 def __init__(self, radius, center, contour, area):
     self.radius = radius
     self.center = center
     self.contour = contour
     self.area = area
     self.timestamp = time.clock()
示例#43
0
from time import time
import time
from tree import Tree

import parallel_cell_enumeration as p_cell

import parallel_masterprob as p_ma
import pre_process as pre
import subprob as sub

# Generate data sets of different scales and then test different seeds.
# export OMP_NUM_THREADS=2  (Environment Variable  OMP_NUM_THREADS sets the number of threads)

if __name__ == "__main__":

    start_all = time.clock()

    NUM_CORES = 64

    #Parallel
    pool = Pool(processes=NUM_CORES)
    pool = None

    # Different size of test data set M, K, N
    M_list = [1]  #[1, 4, 8, 16, 32]
    K_list = [2]  #[2, 4, 6]
    N_list = [10]  #[4, 8, 12]

    # Generate test data sets
    for i_1 in xrange(len(M_list)):
        for i_2 in xrange(len(K_list)):
示例#44
0
if Confirm.upper() == 'Q' :
	exit()

elif Confirm.upper() == 'N' :
	break

elif Confirm.upper() == 'Y' :
    print("\nEntraînement de tapage de mot de passe ! Ecrivez-le, le plus rapidement possible.\n")
    print("           Commencement au 'GO' dans 4 secondes :")
    sleep(1)
    print(" 3... ")
    sleep(1)
    print(" 2... ")
    sleep(1)
    print(" 1... ")
    sleep(1)
                
    ChronoDeb = time.clock()
    VPass = input("\n GO ! : ")
    ChronoFin = time.clock()
    result = ChronoFin - ChronoDeb
            
elif VPass == SPass :
	print("\nVous avez correctement recopié votre création. Temps d'exécution : ", result)
      
else VPass != SPass :
	print("Votre création n'a pas été parfaitement recopiée. Temps d'exécution : ", result)


print("Fin")
示例#45
0
                   print ("%.1f"%percentage) + " %"
            if first:
                print "\n" 
        except TypeError:
            sum = numpy.sum(array)
            if sum != 0:
                array[:] /= sum

dir = "prepared_text//"
#dir = "full_text//"
ext = ".txt"
order = 16
transitions_file = "transition_hgwells_order_"+str(order)
calculate = True

names = ["pg1268"]
text_gen = markov_chain()

if calculate:
    import time
    start_time = time.clock()

    text_gen.calculate_transitions([dir+name+ext for name in names], order)

    print("--- %s seconds ---" % (time.clock() - start_time))
#    text_gen.save(dir + transitions_file + ".data")
#else:
#    text_gen.calculate_transitions([dir+name+ext for name in names], 0, False)
#    text_gen.load(dir + transitions_file + ".data")
    text_gen.generate_string(4000, show_string=False)
	def imdb(self):
		if self.running:
			print "EMC iMDB: Search already Running."

		elif not self.running:
			print "EMC iMDB: Search started..."
			self["done_msg"].show()
			self.no_cover()
			self.running = True
			self.counter_download = 0
			self.counter_exist = 0
			self.counter_no_poster = 0
			self.t_elapsed = 0
			self.menulist = []
			self.count_movies = len(self.m_list)
			self["exist"].setText(_("Exist: %s") % "0")
			self["no_poster"].setText(_("No Cover: %s") % "0")
			self["download"].setText(_("Download: %s") % "0")
			self["done_msg"].setText(_("Searching..."))
			self.starttime = 0
			self.t_start_time = time.clock()
			self.s_supertime = time.time()
			self.cm_list = self.m_list[:]
			self.search_list = []
			self.exist_list = []
			self.check = False
			self["done_msg"].setText(_("Creating Search List.."))
			self.counting = 0
			self.count_total = len(self.cm_list)
			urls = []
			for each in sorted(self.cm_list):
				(title, path) = each
				cover_path = re.sub(self.file_format + "$", '.jpg', path)
				if os.path.exists(cover_path):
					self.counter_exist += 1
					self.counting += 1
					self.menulist.append(imdb_show(title, cover_path, _("Exist"), "", title))
					self["m_info"].setText(title)
					self["no_poster"].setText(_("No Cover: %s") % str(self.counter_no_poster))
					self["exist"].setText(_("Exist: %s") % str(self.counter_exist))
					self["download"].setText(_("Download: %s") % str(self.counter_download))
					self["menulist"].l.setList(self.menulist)
					self["menulist"].l.setItemHeight(image())
					self.check = True
					print "EMC iMDB: Cover vorhanden - %s" % title
				else:
					filename = path
					title = getMovieNameWithoutPhrases(getMovieNameWithoutExt(title))
					if re.search('[Ss][0-9]+[Ee][0-9]+', title) is not None:
						season = None
						episode = None
						seasonEpisode = re.findall('.*?[Ss]([0-9]+)[Ee]([0-9]+)', title, re.S|re.I)
						if seasonEpisode:
							(season, episode) = seasonEpisode[0]
						name2 = re.sub('[Ss][0-9]+[Ee][0-9]+.*[a-zA-Z0-9_]+','', title, flags=re.S|re.I)
						url = 'http://thetvdb.com/api/GetSeries.php?seriesname=%s&language=de' % name2.replace(' ','%20')
						urls.append(("serie", title, url, cover_path, season, episode))
					else:
						url = 'http://api.themoviedb.org/3/search/movie?api_key=8789cfd3fbab7dccf1269c3d7d867aff&query=%s&language=de' % title.replace(' ','%20')
						urls.append(("movie", title, url, cover_path, None, None))

			if len(urls) != 0:
				ds = defer.DeferredSemaphore(tokens=2)
				downloads = [ds.run(self.download, url).addCallback(self.parseWebpage, type, title, url, cover_path, season, episode).addErrback(self.dataError) for type, title, url, cover_path, season, episode in urls]
				finished = defer.DeferredList(downloads).addErrback(self.dataError2)
			else:
				self["done_msg"].setText(_("No Movies found!"))
示例#47
0
	def imdb_start(self):
		self["done_msg"].setText(_("Searching.."))
		self.starttime = time.time()
		self.run10 = "false"
		for i in xrange(10):
			#if self.search_list:
			if not len(self.search_list) == 0:
				(title, path) = self.search_list.pop()
				title = getMovieNameWithoutPhrases(getMovieNameWithoutExt(title))

				self.start_time = time.clock()

				if config.EMC.imdb.search.value == "0":
					self.name = title.replace(' ','.').replace(':','.').replace('..','.')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('.',' ')

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://www.imdbapi.com/?t=" + self.name.replace('ö','%F6').replace(' ','%20').replace('.','%20')
						print "EMC imdbapi.com:", url
						getPage(url, timeout = 10).addCallback(self.imdbapi, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "1":
					self.name = title.replace(' ','+').replace(':','+').replace('-','').replace('++','+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('+',' ')

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://api.themoviedb.org/2.1/Movie.search/de/xml/8789cfd3fbab7dccf1269c3d7d867aff/" + self.name
						print "EMC themoviedb.org:", url
						getPage(url, timeout = 10).addCallback(self.themoviedb, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "2":
					self.name = title.replace(' ','+').replace(':','+').replace('-','').replace('++','+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = self.name.replace('+',' ')

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://ofdbgw.home-of-root.de/search/%s" % self.name
						#url = "http://ofdbgw.home-of-root.de/search/" + self.name
						print "EMC ofdb.de:", url				
						getPage(url).addCallback(self.ofdb_search, search_title, path).addErrback(self.errorLoad, search_title)

				if config.EMC.imdb.search.value == "3":
					self.name = title.replace(':', ' ').replace('-', ' ').replace('++', '+')
					path = re.sub(self.file_format + "$", '.jpg', path)
					search_title = urllib.quote(self.name.replace('+', ' '))

					if not os.path.exists(path):
						self.counter3 += 1
						url = "http://www.csfd.cz/hledat/?q=%s" % search_title
						print "EMC csfd.cz:", url				
						getPage(url).addCallback(self.csfd_search, self.name, path).addErrback(self.errorLoad, self.name)

			else:
				print "EMC iMDB: MovieList is empty, search is DONE. - BREAK..."
				#self.e_supertime = time.time()
				#total_movie = self.counter3 + self.counter2 
				#total_time = self.e_supertime - self.s_supertime
				#avg = (total_time / total_movie)
				#self.done = _("%s Filme in %.1f sec gefunden. Avg. Speed: %.1f sec") % (total_movie, total_time, avg) 
				#self["done_msg"].setText(self.done)
				#self.running = "false"
				break
示例#48
0
 def wrapper(*args, **kwargs):
     start = time.clock()
     response = func(*args, **kwargs)
     end = time.clock()
     print('time spend:', end - start)
     return response
示例#49
0
    def crawl(self):
        """ Starts crawling for this project """

        # Reset flag
        self._flag = 0

        # Clear the event flag
        # self.exitobj.clear()

        if os.name == 'nt':
            t1 = time.clock()
        else:
            t1 = time()

        # Set start time on config object
        self._configobj.starttime = t1

        if not self._configobj.urlserver:
            self.push(self._baseUrlObj, 'crawler')
        else:
            try:
                # Flush url server of any previous urls by
                # sending a flush command.
                send_url("flush", self._configobj.urlhost,
                         self._configobj.urlport)
                send_url(
                    'CRAWLER:' + str(self._baseUrlObj.priority) + '#' +
                    str(self._baseUrlObj.index), self._configobj.urlhost,
                    self._configobj.urlport)
            except:
                pass

        if self._configobj.fastmode:

            # Start harvestman controller thread
            import datamgr

            self._controller = datamgr.HarvestManController()
            self._controller.start()

            # Create the number of threads in the config file
            # Pre-launch the number of threads specified
            # in the config file.

            # Initialize thread dictionary
            self._basetracker.setDaemon(True)
            self._basetracker.start()

            while self._basetracker.get_status() != 0:
                sleep(0.1)

            for x in range(1, self._configobj.maxtrackers):

                # Back to equality among threads
                if x % 2 == 0:
                    t = crawler.HarvestManUrlFetcher(x, None)
                else:
                    t = crawler.HarvestManUrlCrawler(x, None)

                self.add_tracker(t)
                t.setDaemon(True)
                t.start()

            for t in self._trackers:

                if t.get_role() == 'fetcher':
                    self._numfetchers += 1
                elif t.get_role() == 'crawler':
                    self._numcrawlers += 1

            # bug: give the threads some time to start,
            # otherwise we exit immediately sometimes.
            sleep(2.0)

            self.mainloop()

            # Set flag to 1 to denote that downloading is finished.
            self._flag = 1

            self.stop_threads(noexit=True)
        else:
            self._basetracker.action()
示例#50
0
    def crawl(self):
        """ Starts crawling for this project """

        # Reset flag
        self._flag = 0

        # Clear the event flag
        # self.exitobj.clear()
        
        if os.name=='nt':
            t1=time.clock()
        else:
            t1=time()

        # Set start time on config object
        self._configobj.starttime = t1

        if not self._configobj.urlserver:
            self.push(self._baseUrlObj, 'crawler')
        else:
            try:
                # Flush url server of any previous urls by
                # sending a flush command.
                send_url("flush", self._configobj.urlhost, self._configobj.urlport)
                send_url('CRAWLER:' + str(self._baseUrlObj.priority) + '#' + str(self._baseUrlObj.index),
                         self._configobj.urlhost,
                         self._configobj.urlport)
            except:
                pass

        if self._configobj.fastmode:

            # Start harvestman controller thread
            import datamgr
            
            self._controller = datamgr.HarvestManController()
            self._controller.start()
            
            # Create the number of threads in the config file
            # Pre-launch the number of threads specified
            # in the config file.

            # Initialize thread dictionary
            self._basetracker.setDaemon(True)
            self._basetracker.start()

            while self._basetracker.get_status() != 0:
                sleep(0.1)

            for x in range(1, self._configobj.maxtrackers):

                # Back to equality among threads
                if x % 2==0:
                    t = crawler.HarvestManUrlFetcher(x, None)
                else:
                    t = crawler.HarvestManUrlCrawler(x, None)

                self.add_tracker(t)
                t.setDaemon(True)
                t.start()

            for t in self._trackers:

                if t.get_role() == 'fetcher':
                    self._numfetchers += 1
                elif t.get_role() == 'crawler':
                    self._numcrawlers += 1

            # bug: give the threads some time to start,
            # otherwise we exit immediately sometimes.
            sleep(2.0)

            self.mainloop()
            
            # Set flag to 1 to denote that downloading is finished.
            self._flag = 1
            
            self.stop_threads(noexit = True)
        else:
            self._basetracker.action()
示例#51
0
def upload_all():
    tick = time.clock()
    file = request.files['image']
    if not file:
        return jsonify({'error': 'No file was uploaded.'})

    if not allowed_file(file.filename):
        return jsonify({'error': 'Please upload a JPG or PNG.'})
    if request.form['request'] == "":
        return jsonify({'answer': "Please, ask a question!"})
    file_hash = hashlib.md5(file.read()).hexdigest()
    save_path = os.path.join(app.config['UPLOAD_FOLDER'], file_hash + '.jpg')
    file.seek(0)
    file.save(save_path)

    print("file:")
    print(save_path)

    question = request.form['request']
    
    lst = question.split()
    lst[0] = lst[0][0].upper() + lst[0][1:]

    question = " ".join(lst)
    
    result = np.squeeze(sentencePredictor.predict(question))
    

    maxval = 0
    idx = 0
    for i in range(len(result)):
        print(result[i])
        if result[i] > maxval:
            maxval = result[i]
            idx = i


    # handle image first
    print("question:")
    print(question)
    print( str(idx) + "th NETWORK")
    
    name = question[:question.find(" ")]
    print(name)
    if (name == 'name' or name == 'Name'):
        print("adding person")
        name = question[question.find(" ") + 1:]
        Image = cv2.imread(save_path)
        answer = recognizer.add(Image, name, file_hash + '.jpg')
        if answer != "success":
            print("could not save person " + name + ", because: " + answer)
        return jsonify({'answer': answer})

    # img captioning
    if idx == 0:

        answer = im2txt.feed_image(save_path)
        tock = time.clock()
        print(str(tock - tick) + "time used for iamge captioning")

        return jsonify({'answer': answer})

    
    # face
    if (idx == 3):
        try:
            print("path = " + save_path)
            answer = ""
            Image = cv2.imread(save_path)
            people = recognizer.recognize(Image)
            

            if len(people) == 0:
                answer = "I don't see anyone here!"
            elif (len(people) == 1):
                if people[0] == "I don't know :(":
                    answer = "I don't know :("
                else:
                    answer = "It is " + people[0]
            else:
                known_people = ""
                unknow_people = 0
                for person in people:
                    if person == "I don't know :(":
                        unknow_people += 1
                    else:
                        if known_people == "":
                            known_people = person
                        else:
                            known_people = known_people + ", " + person

                if known_people == "":
                    answer = "There are " + str(unknow_people) + " people. I don't know anyone here."
                else:
                    answer = "There are " + known_people
                    if unknow_people > 0:
                        answer = answer + ". There are " + str(unknow_people) + " people, which I don't know."
        except:
            tock = time.clock()
            print(str(tock - tick) + "time used for face")
            return jsonify({'answer': "I don't see anyone here!"})
        tock = time.clock()
        print(str(tock - tick) + "time used for face")
        return jsonify({'answer': answer})

    # emotion
    if (idx == 2):
        img = cv2.imread(save_path)
        faces = faceDetector.detect_Face(img)
        if len(faces) == 0:
            answer = "There are no people here!"
            return jsonify({'answer': answer})
        else:
            answer = []
        for face in faces:
            answer.append(emotionDetector.predict(img, face))
        tock = time.clock()
        print(str(tock - tick) + "time used for emotion")
        print(answer)
        return jsonify({'answer': ",".join(answer)})




    # question answering
    if idx == 1:

        feature = questionAnswering.img_handler(save_path)
        if feature is None:
            tock = time.clock()
            print(str(tock - tick) + "time used for qa")
            return jsonify({'error': 'Error reading image.'})

        # image + question
        img_ques_hash = hashlib.md5(file_hash + question).hexdigest()
        json = questionAnswering.get_answers(question, feature, save_path, img_ques_hash, VIZ_FOLDER)

        tock = time.clock()
        print(str(tock - tick) + "time used for qa")
        return jsonify(json)

    # text
    if idx == 4:
        json = textReader.read(save_path)
        
        print(type(json))
        if json == '':
            tock = time.clock()
            print(str(tock - tick) + "time used for text")
            return jsonify({'answer': "I don't see the text here!"})
        tock = time.clock()
        print(str(tock - tick) + "time used for text")
        return jsonify({'answer':json})

    else:
        tock = time.clock()
        print(str(tock - tick) + "time used for text")
        return jsonify({'answer':"Error text"})