def add_clearance_graph(self): print("-----------------------------------------") horizontal_clearance = self.clearance_analysis.horizontal_clearance x_init = self.graph_zero[0] + self.line_extend y_init = self.graph_zero[1] for i in range(len(horizontal_clearance)): clearance_points = horizontal_clearance[i] x = x_init + i * self.dimension_analysis.section_distance * self.length_multiplier left = -self.dimension_analysis.domain_length right = self.dimension_analysis.domain_length if clearance_points[0]: left = clearance_points[0] if clearance_points[1]: right = clearance_points[1] clearance = right - left y_top = y_init + left * self.height_multiplier y_bottom = y_init + right * self.height_multiplier pen_red = QPen() red = Color.create_qcolor_from_rgb_tuple(Color.red) pen_red.setColor(red) pen_green = QPen() green = Color.create_qcolor_from_rgb_tuple(Color.green) pen_green.setColor(green) line = QGraphicsLineItem(x, y_top, x, y_bottom) if clearance < self.min_horizontal_clearance: line.setPen(pen_red) else: line.setPen(pen_green) self.addToGroup(line) pass
def __init__(self, url, start_episode, end_episode, session, gui=None, token=None): super().__init__(url, start_episode, end_episode, session, gui) self.token = token self.api_key = None self.ts_no = None self.server_id = None self.site_key = "6LfEtpwUAAAAABoJ_595sf-Hh0psstoatwZpLex1" self.server_name = "Mp4upload" self.nine_anime_url = "https://9anime.to" self.episodes_url = "https://9anime.to/ajax/film/servers/" + url.split( ".")[2].split("/")[0] if not token: try: with open("settings.json") as (json_file): data = json.load(json_file) self.api_key = data["api_key"] except: Color.printer( "ERROR", "Reading settings file failed! Continue without API key...", self.gui) self.api_key = ""
def __init__(self, window: Window, text: str, pos: Vector, size: Vector = Vector(150, 50), bg: Color = Color(200, 200, 200), fg: Color = Color(20, 20, 20), bg_over: Color = Color(220, 220, 220), fg_over: Color = Color(20, 20, 20), border_size: int = 0, font: Font = Font('sans-serif', 15, HIDPI_FACTOR)): super().__init__(window) self._click_handler = None self.text = text self.pos = pos self.size = size # Initial colours self.bg = bg self.fg = fg self.bg_over = bg_over self.fg_over = fg_over # Extra self.font = font self.border_size = border_size # Center self.center = (self.pos[0] + self.size[0] / 2, self.pos[1] + self.size[1] / 2) # Get corners self.bounds = BoundingBox(pos, pos + size)
def extract_download_urls(): global session, gui down_base = "https://9anime.to/ajax/episode/info?" Color.printer("INFO", "Extracting download URLs...", gui) for episode in episodes: if (episode.id is None): episode.download_url = None continue url = down_base + "ts=" + ts_no + "&id=" + episode.id + "&server=" + server_id target = session.get(url).json()["target"] episode.page_url = target download_url = Mp4UploadExtractor(target, session).extract_direct_url() # video_page = session.get(target).content # # string = video_page.decode("utf-8") # # www_base = re.search("false\|(.*)\|devicePixelRatio",string).group(1) # url_id = re.search("video\|(.*)\|282", string).group(1) # # download_url = "https://"+www_base+".mp4upload.com:282/d/"+url_id+"/video.mp4" episode.download_url = download_url
def get_token(url): global session, site_key, api_key, gui try: captcha_id = \ session.post("http://2captcha.com/in.php?key={}&method=userrecaptcha&googlekey={}&pageurl={}&invisible=1" .format(api_key, site_key, url)).text.split('|')[1] recaptcha_answer = session.get( "http://2captcha.com/res.php?key={}&action=get&id={}".format( api_key, captcha_id)).text while 'CAPCHA_NOT_READY' in recaptcha_answer: sleep(5) recaptcha_answer = session.get( "http://2captcha.com/res.php?key={}&action=get&id={}".format( api_key, captcha_id)).text recaptcha_answer = recaptcha_answer.split('|')[1] # print("[Recaptcha answer] : {",recaptcha_answer,"}") return recaptcha_answer except Exception: Color.printer("ERROR", 'Failed to solve ReCaptcha!', gui) return None
def __init__(self, window: Window): super().__init__(window) from constants import BUTTON_SIZE window_size = window.get_size() window_center = (window_size[0] / 2, window_size[1] / 2) dpi_factor = window.hidpi_factor button_size = (BUTTON_SIZE[0] * dpi_factor, BUTTON_SIZE[1] * dpi_factor) button_font = Font('sans-serif', 16, dpi_factor) self.bg_image = util.load_image('assets/background.png') back_btn = Button(window, '[ Back ]', Vector(window_center[0] - button_size[0] / 2, window_size[1] * 2 / 3), Vector(*button_size), Color(0, 102, 255), Color(255, 255, 255), Color(0, 80, 230), Color(255, 255, 255), font=button_font) back_btn.set_click_handler(self.back) self.children.append(back_btn)
def __extract_page_urls(self): Color.printer("INFO", "Extracting page URLs...", self.gui) page = self.session.get(self.url).content soup_html = BeautifulSoup(page, "html.parser") try: server = soup_html.findAll("div", attrs={"class": "server"})[0] epi_ranges = server.findAll("ul", attrs={"class": "episodes"}) for epi_range in epi_ranges: epi_tags = epi_range.findAll("a", href=True) for epi_tag in epi_tags: epi_number = int(epi_tag.text) if epi_number < self.start_episode or epi_number > self.end_episode: continue episode = Episode(str(epi_number), "Episode - " + str(epi_number)) episode.page_url = epi_tag["href"] self.episodes.append(episode) except Exception as ex: print(ex) return None return self.episodes
def analysis(img, target_color = (255, 255, 255)): """ Esse metodo verifica cada pixel da imagem em busca dos pixel da cor procurada. Toda vez que for encontrado um pixel da cor procurada se aplica o floodFill para se marca o caminho """ from random import randint #path_number = -1 path_number = 0 #color = 10 color = Color() path_list = [] for i in range(img.size[0]): for j in range(img.size[1]): if img.getpixel((i,j)) == target_color: path_number = path_number + 1 if (path_number / 2) == 0: a = color.corHSVAliatoria(randint(50,200)) else: a = color.corRGBAliatoria(randint(50,200)) #result = floodFill(img, (i,j), target_color, color) result = floodFill(img, (i,j), target_color, a) path_list.append(result) #color=color+5 #img.save() return (path_list,img)
def set_color_picker_value(self): color = self.color_temp r, g, b = Color.from_factor_to_rgb(color[0], color[1], color[2]) q_color = QColor(r, g, b) new_color = QColorDialog.getColor(q_color) button = self.ui.pushButton_colorPicker self.color_temp = Color.from_rgb_to_factor(new_color.red(), new_color.green(), new_color.blue()) button.setStyleSheet("background-color: rgb({},{},{})".format(new_color.red(), new_color.green(), new_color.blue()))
def _process_args(self): if self.args.no_color == True: Color.disable() if self.args.command == "lvm": self.__lvm() elif self.args.command == "backup": self.__backup()
def draw(self, windows): # pragma: no cover body = windows['body'] body.clear() line = 10 body.addstr(line - 2, 20, 'SPACE JAIL', Color.use('red')) body.addstr(line + self.current_option, 20, '#', Color.use('blue')) for option in self.options: body.addstr(line, 22, option.capitalize(), Color.use('white')) line += 1
def run(self): while True: func, arg, kargs = self.tasks.get() try: func(*arg, **kargs) except Exception as ex: Color.printer("ERROR", ex, self.gui) finally: self.tasks.task_done()
def print_inventory(self, window, inv): #pragma: no cover for i in range(0, len(inv)): name_x = 1 if i % 2 is 0 else 40 name_y = (i / 2) + 1 q_x = 20 if name_x is 1 else 61 q_y = name_y window.addstr(name_y, name_x, inv[i]['name'], Color.use('white')) window.addstr(q_y, q_x, str(inv[i]['quantity']), Color.use('white'))
def write_data(): global episodes, gui Color.printer("INFO", "Writing results to results.csv file...", gui) data_file = open("results.csv", "w") for episode in episodes: data_file.write(episode.episode + "," + episode.download_url + "\n") data_file.close()
def __download_episode(self, episode): if system() == "Windows": episode.title = self.__clean_file_name(episode.title) if episode.is_direct: if episode.download_url is None: Color.printer( "ERROR", "Download URL is not set for " + episode.episode + ", skipping...", self.gui) return Color.printer("INFO", "Downloading " + episode.episode + "...", self.gui) # print(self.is_titles) # print(episode.title) if self.is_titles: # print("with title") file_name = self.directory + episode.episode + " - " + episode.title + ".mp4" else: # print("without title") file_name = self.directory + episode.episode + ".mp4" with requests.get(episode.download_url, headers=episode.request_headers, stream=True, verify=False) as r: with open(file_name, 'wb') as f: shutil.copyfileobj(r.raw, f, length=16 * 1024 * 1024) Color.printer("INFO", episode.episode + " finished downloading...", self.gui) else: Color.printer( "INFO", "HLS link found. Using custom HLSDownloader to download...", self.gui) try: HLSDownloader(episode, self.directory, requests.session(), self.gui).download() except Exception as ex: trace = traceback.format_exc() print(trace) Color.printer( "ERROR", "Custom HLS Downloader failed! Using FFMPEG to download...", self.gui) FFMPEGDownloader(episode, self.directory, self.gui).download()
def __init__(self, window: Window): super().__init__(window) from constants import BUTTON_SIZE self.window_size = window.get_size() self.window_center = (self.window_size[0] / 2, self.window_size[1] / 2) dpi_factor = window.hidpi_factor button_size = (BUTTON_SIZE[0] * dpi_factor, BUTTON_SIZE[1] * dpi_factor) button_font = Font('sans-serif', 16, dpi_factor) self.bg_image = util.load_image('assets/background.png') self.bg_size = (self.bg_image.get_width(), self.bg_image.get_height()) self.bg_center = (self.bg_size[0] / 2, self.bg_size[1] / 2) self.logo = util.load_image('assets/logo.png') self.logo_size = (self.logo.get_width(), self.logo.get_height()) self.logo_center = (self.logo_size[0] / 2, self.logo_size[1] / 2) self.max_score = 0 self.last_active_level = None self.text_font = Font('monospace', 20, window.hidpi_factor) self.text_font_color = Color(255, 255, 255) # Template to create new button start_btn = Button(window, '[ Start ]', Vector(self.window_center[0] - button_size[0] / 2, self.window_center[1] - button_size[1]), Vector(*button_size), Color(0, 102, 255), Color(255, 255, 255), Color(0, 80, 230), Color(255, 255, 255), font=button_font) start_btn.set_click_handler(self.start) self.children.append(start_btn) help_btn = Button(window, '[ Help ]', Vector(self.window_center[0] - button_size[0] / 2, self.window_center[1] + button_size[1]), Vector(*button_size), Color(0, 102, 255), Color(255, 255, 255), Color(0, 80, 230), Color(255, 255, 255), font=button_font) help_btn.set_click_handler(self.help) self.children.append(help_btn)
def print_data(self): """ Prints out details on the final aligned supermatrix. """ # TODO: make the output of this more useful color = Color() print(color.blue + "Supermatrix attributes:") records = SeqIO.parse(self.file, "fasta") num_records = 0 total_missing = 0 for record in records: otu = record.description missing = 0 for letter in record.seq: if letter == '?': missing += 1 total_missing += 1 print(color.yellow + "OTU: " + color.red + otu + color.yellow + " % missing data = " + color.red + str(round(missing / float(len(record.seq)), 2))) num_records += 1 matrix_length = len(record.seq) print(color.blue + "Total number of OTUs = " + color.red + str(num_records)) print(color.blue + "Total length of matrix = " + color.red + str(matrix_length)) print(color.blue + "Taxon coverage density = " + color.red + str(self.get_coverage_density())) print(color.blue + "Total % missing data = " + color.red + str(round(total_missing / float(matrix_length * num_records), 2)) + color.done)
def __init__(self, gb, seq_keys, gb_dir, num_cores, minlength, maxlength, length_thres=0.5, threshold=0.75, evalue=(1.0/10**10)): """ Input: gb dictionary of SeqRecords, keys to all sequences, and an optional threshold for clustering. Output: a list of cluster files from UCLUST """ ClusterBuilder.__init__(self, seq_keys) self.seq_keys = seq_keys self.threshold = threshold color = Color() if not os.path.exists("uclusters"): os.makedirs("uclusters") # write sequences to fasta sequences = [] for seq_key in seq_keys: record = gb[seq_key] record.description = record.annotations["organism"] + " " + record.description if "sp." not in record.annotations["organism"]: sequences.append(record) file_name = "_sumac" f = open(file_name, "wb") SeqIO.write(sequences, f, 'fasta') f.close() with open("_sumac", "r") as f, open("_sumac_filtered", "w") as fout: for l in f: if ">" in l: l = l.replace(" ", "_") fout.write(l) # call UCLUST sort_sequences = ["usearch", "-sortbylength", "_sumac_filtered", "-fastaout", "_sumac_sorted", "-minseqlength", str(minlength), "-maxseqlength", str(maxlength)] uclust = ["usearch", "-cluster_fast", "_sumac_sorted", "-id", str(threshold), "-minsl", str(length_thres), "-strand", "both", "-threads", str(num_cores), "-clusters", "uclusters/", "-fulldp", "-evalue", str(evalue)] try: subprocess.check_call(sort_sequences) subprocess.check_call(uclust) except CalledProcessError as e: print(color.red + "UCLUST error: " + str(e) + color.done) print(color.red + "Trying SLINK instead..." + color.done) self.error = True return except OSError as e: print(color.red + "UCLUST is not installed correctly." + color.done) print(color.red + "OS error: " + str(e) + color.done) print(color.red + "Trying SLINK instead..." + color.done) self.error = True return finally: if os.path.exists("_sumac"): subprocess.check_call(["rm", "_sumac"]) if os.path.exists("_sumac_filtered"): subprocess.check_call(["rm", "_sumac_filtered"]) if os.path.exists("_sumac_sorted"): subprocess.check_call(["rm", "_sumac_sorted"]) cluster_files = [ f for f in listdir("uclusters/") if isfile(join("uclusters/", f)) ] for f in cluster_files: self.clusters.append(f)
def display_heading(self, window): # pragma: no cover window.clear() window.border('|', '|', '-', '-', curses.ACS_ULCORNER, curses.ACS_URCORNER, curses.ACS_LLCORNER, curses.ACS_LRCORNER) title = 'Level ' + str(self.current_level) window.addstr(1, 10, title, Color.use('yellow'))
def __init__(self, gb, seq_keys, length_threshold, gb_dir, num_cores): """ Takes as input a dictionary of SeqRecords gb and the keys to all sequences. length_threshold is the threshold of sequence length percent similarity to cluster taxa. For example if length_threshold = 0.25, and one sequence has length 100, the other sequence must have length 75 to 125. If the lengths are not similar enough the distance is set to 50 (which keeps them from being clustered). Generates a 2 dimensional list of distances. Distances are blastn e-values. """ lock = multiprocessing.Lock() manager = multiprocessing.Manager() already_compared = manager.list() dist_matrix = manager.list() row = [] for i in range(len(seq_keys)): row.append(99) for i in range(len(seq_keys)): dist_matrix.append(row) color = Color() print(color.blue + "Spawning " + color.red + str(num_cores) + color.blue + " processes to make distance matrix." + color.done) processes = [] for i in range(num_cores): p = multiprocessing.Process(target=self.distance_matrix_worker, args=(seq_keys, length_threshold, dist_matrix, already_compared, lock, i, gb_dir)) p.start() processes.append(p) for p in processes: p.join() sys.stdout.write("\n") sys.stdout.flush() self.distance_matrix = dist_matrix
def print_PD(self): """ Prints partial decisiveness. """ color = Color() print(color.blue + "Partial decisiveness (fraction of triples) = " + color.red + str(self.get_PD()) + color.done)
def calculate_PD_parallel(self, num_cores): """ Method to calculate the fraction of triples, a measure of partial decisiveness (PD). See: Sanderson, M.J., McMahon, M.M. & Steel, M., 2010. BMC evolutionary biology, 10. """ color = Color() lock = multiprocessing.Lock() manager = multiprocessing.Manager() #already_compared = manager.list() #dist_matrix = manager.list() otus_shared = manager.dict() otus_shared = otus decisive_triples = manager.Value('i', 0) total_triples = manager.Value('i', 0) total = self.binomial_coefficient(len(self.otus), 3) for i in range(num_cores): p = multiprocessing.Process(target=calculate_PD_worker, args=(lock, i, num_cores, decisive_triples, total_triples, total, otus_shared)) p.start() processes.append(p) for p in processes: p.join() self.otus = otus_shared sys.stdout.write("\r" + color.blue + "Calculating PD: " + color.red + "100.00% " + color.blue + "finished\n" + color.done) sys.stdout.flush() return round(decisive_triples / float(total_triples), 2)
def set_rect_fill(*args): if args[0] == 0: #surface color mode rect = args[1] color = args[2] qcolor = Color.create_qcolor_from_rgb_tuple_f(color) brush = QBrush(qcolor) rect.setBrush(brush)
def print_data(self): """ Prints the name of each DNA region, the number of taxa, the aligned length, missing data (%), and taxon coverage density """ # first get list of all taxa taxa = self.get_all_taxa() # print data for each region i = 1 color = Color() for alignment in self.files: records = list(SeqIO.parse(alignment, "fasta")) if self.user_provided: region_name = alignment else: descriptors = records[0].description.split(" ") region_name = " ".join(descriptors[5:]) print(color.blue + "Aligned cluster #: " + color.red + str(i) + color.done) print(color.yellow + "DNA region: " + color.red + region_name + color.done) print(color.yellow + "OTUs: " + color.red + str(len(records)) + color.done) print(color.yellow + "Aligned length: " + color.red + str(len(records[0].seq)) + color.done) print(color.yellow + "Missing data (%): " + color.red + str(round(100 - (100 * len(records) / float(len(taxa))), 1)) + color.done) print(color.yellow + "Taxon coverage density: " + color.red + str(round(len(records) / float(len(taxa)), 2)) + color.done) i += 1
def align_cluster(self, cluster_file): """ Worker fuction for align_clusters Inputs a FASTA file containing an unaligned sequence cluster. Uses MAFFT to align the cluster. """ mafft_cline = MafftCommandline(input=cluster_file) mafft_cline.set_parameter("--auto", True) mafft_cline.set_parameter("--adjustdirection", True) color = Color() print(color.red + str(mafft_cline) + color.done) sys.stdout.flush() if cluster_file.find("/") != -1: alignment_file = "alignments" + cluster_file[cluster_file.index("/" ):] else: alignment_file = "alignments/" + cluster_file try: stdout, stderr = mafft_cline() with open(alignment_file, "w") as handle: handle.write(stdout) except: print( color.red + "Error: alignment file not generated. Please check your MAFFT installation." + color.done) return alignment_file
def __init__(self, world: 'World', pos: Tuple[int, int], size: Tuple[int, int]): super().__init__(world) self.pos = pos self.size = size self.color = Color(80, 80, 80)
def print_data(self): color = Color() print(color.blue + "Name = " + color.red + self.name) print(color.blue + "Sequence = " + color.red + self.sequence) print(color.blue + "Accessions = " + color.red) print(self.accessions) print(color.blue + "Sequence_lengths = " + color.red) print(self.sequence_lengths)
def __extract_download_urls(self): down_base = "https://9anime.to/ajax/episode/info?" Color.printer("INFO", "Extracting download URLs...", self.gui) for episode in self.episodes: if (episode.id is None): episode.download_url = None continue url = down_base + "ts=" + self.ts_no + "&id=" + episode.id + "&server=" + self.server_id target = self.session.get(url).json()["target"] episode.page_url = target download_url = Mp4UploadExtractor( target, self.session).extract_direct_url() episode.download_url = download_url
def state(self): """ Exec state of this component. """ rect = self.root.find_element_by_css_selector('rect') style = Style(rect.get_attribute('style')) stroke = Color.from_string(style.stroke) # red stroke if (stroke == Color(255, 0, 0)): return 'INVALID' # green stroke if (stroke == Color(0, 255, 0)): return 'VALID' # blue stroke if (stroke == Color(0, 0, 255)): return 'RUNNING' return 'UNKNOWN'
def color(self): # pragma: no cover colors = { 'floor': 'red', 'wall': 'magenta', 'empty': 'black', 'corridor': 'blue', 'stairs_down': 'green', 'stairs_up': 'green' } return Color.use(colors[self.type])
def print_search_status(self, i, total): color = Color() sys.stdout.write('\r' + color.yellow + 'Ingroup sequences found: ' \ + color.red + str(len(self.ingroup_keys)) + color.yellow \ + ' Outgroup sequences found: ' + color.red \ + str(len(self.outgroup_keys)) + color.yellow \ + ' Percent searched: ' + color.red \ + str(round( 100 * float(i) / total , 1)) + color.done ) sys.stdout.flush()
def download(self): try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: # Legacy Python that doesn't verify HTTPS certificates by default pass else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context Color.printer("INFO", "Downloading started...", self.gui) pool = ThreadPool(self.threads, gui) pool.map(self.__download_episode, self.episodes) pool.wait_completion() Color.printer("INFO", "Downloading finished!", self.gui)
def __init__(self, window: Window, source: WindowHandler): super().__init__(window) self.source = source self.levels = self._init_levels() self.level = self.levels[0] self.player = Player(self) self.window = window self.text_font = Font('monospace', 16, window.hidpi_factor) self.text_font_color = Color(255, 255, 255)
def main(start_episode=-1, end_episode=-1, token=None): global episodes, download_9anime_url, episodes_url, api_key, gui start_episode = int(start_episode) end_episode = int(end_episode) if not token: with open("settings.json") as (json_file): data = json.load(json_file) api_key = data["api_key"] if not download_9anime_url: download_9anime_url = input("Anime URL : ") if start_episode == -1: start_episode = int(input("Enter Start Episode : ")) if end_episode == -1: end_episode = int(input("Enter End Episode : ")) episodes_url = episodes_url + download_9anime_url.split(".")[2].split( "/")[0] episodes = extract_page_urls(start_episode, end_episode, token) if episodes is None: return if title_url: set_titles(start_episode, end_episode) else: Color.printer( "INFO", "animefiller.com URL not provided to collect episode names...", gui) Color.printer("INFO", "Skipping collecting episode names...", gui) extract_download_urls() write_data()
def create_distance_pointer(self): self.distance_pointer = QGraphicsLineItem() pen = QPen() pen.setWidthF(1.0) pen.setStyle(Qt.DashDotLine) color = Color.create_qcolor_from_rgb_tuple_f((1,0,0)) pen.setColor(color) self.distance_pointer.setPen(pen) self.distance_pointer.setZValue(1.0) self.addToGroup(self.distance_pointer) self.distance_label = QGraphicsSimpleTextItem() self.distance_label.setZValue(1.0) self.addToGroup(self.distance_label)
def state(self): """ Exec state of this component. """ rect = self.root.find_element_by_css_selector('rect') style = Style(rect.get_attribute('style')) stroke = Color.from_string(style.stroke) #red stroke if(stroke == Color(255, 0, 0)): return 'INVALID' #green stroke if(stroke == Color(0, 255, 0)): return 'VALID' #blue stroke if(stroke == Color(0, 0, 255)): return 'RUNNING' return 'UNKNOWN'
def init_color_interpolation(self): color_start = Color.create_qcolor_from_rgb_tuple(Color.red) color_end = Color.create_qcolor_from_rgb_tuple(Color.green) self.color_interpolation = ColorInterpolation(color_start, color_end, self.vertical_clearance_min, self.vertical_clearance_max)
def set_color_picker(self, material): button = self.ui.pushButton_colorPicker color = material.get_surface_colour() self.color_temp = (color[0], color[1], color[2]) r, g, b = Color.from_factor_to_rgb(color[0], color[1], color[2]) button.setStyleSheet("background-color: rgb({},{},{})".format(r, g, b))