def sort(self): # Showing text while image is loading and processing self.label_2.setText('Processing ...') # Opening dialog window to choose an image file # Giving name to the dialog window --> 'Choose Image to Open' # Specifying starting directory --> '.' # Showing only needed files to choose from --> '*.png *.jpg *.bmp' # noinspection PyCallByClass image_path = \ QtWidgets.QFileDialog.getOpenFileName(self, 'Choose Image to Open', '.', '*.xlsx') # Variable 'image_path' now is a tuple that consists of two elements # First one is a full path to the chosen image file # Second one is a string with possible extensions # Checkpoint print(type(image_path)) # <class 'tuple'> print(image_path[0]) # /home/my_name/Downloads/example.png print(image_path[1]) # *.png *.jpg *.bmp # Slicing only needed full path image_path = image_path[0] # /home/my_name/Downloads/example.png # Passing full path to loaded image into YOLO v3 algorithm sort(image_path, keywords_list)
def create_list(): v.deleted.clear() for i in v.all_alph: i.clear() file = open(r"CitiesHard.txt").read( ) # Открытие файла со списком городов на чтение new = file.split("\n") # Создание вектора всех городов s.sort(new) # Сортировка вектора
def parse_compose_file(my_path, yaml_file): global path path = os.path.basename(os.path.dirname(my_path)) services = yaml_file['services'] sorted_services = sorting.sort(services) parsed_services = [] for d in sorted_services: for name, service in d.items(): parsed_services.append(ServiceParser(name, service)) networks = yaml_file['networks'] for n in networks: if n == 'default': for k,v in networks[n].items(): if k == 'external': # add this network commands.append("docker network create {}".format(v['name'])) for s in parsed_services: s.docker_args['network'] = " --network={} ".format(v['name']) volumes = yaml_file['volumes'] for v in volumes: commands.append("docker volume create {}_{}".format(path, v)) for s in parsed_services: commands.append(s.write_run_command()) return commands
def list(self, request): '''Lists comments''' queryset = sorting.sort(request, self.model.objects.all()) objects = get_paginated(request, queryset) return Response(self.paginated_serializer(objects, context={'request': request}).data)
def news(self, request, pk=None): '''Retrieves a list of news items this user has created''' serializer = motsdits_serializers.PaginatedNewsSerializer queryset = sorting.sort(request, News.objects.filter(created_by=pk)) news = get_paginated(request, queryset) return Response(serializer(news, context={'request': request}).data)
def favourites(self, request, pk=None): '''Retrieves a list of motsdits this user has favourited''' serializer = motsdits_serializers.PaginatedMotDitSerializer queryset = sorting.sort(request, MotDit.objects.filter(favourites=pk)) motsdits = get_paginated(request, queryset) return Response(serializer(motsdits, context={'request': request}).data)
def photos(self, request, pk=None): '''Retrieves a list of photos related to this item''' serializer = motsdits_compact.PaginatedCompactPhotoSerializer queryset = sorting.sort(request, Photo.objects.filter(Q(motdit__what=pk) | Q(motdit__where=pk))) photos = get_paginated(request, queryset) return Response(serializer(photos, context={'request': request}).data)
def liked_stories(self, request, pk=None): '''Retrieves a list of motsdits this user has liked''' serializer = motsdits_serializers.PaginatedStorySerializer queryset = sorting.sort(request, Story.objects.filter(likes=pk)) stories = get_paginated(request, queryset) return Response(serializer(stories, context={'request': request}).data)
def followers(self, request, pk=None): '''Retrieves a list of motsdits this user has liked''' serializer = accounts_serializers.PaginatedUserSerializer queryset = sorting.sort(request, get_user_model().objects.filter(following=pk)) users = get_paginated(request, queryset) return Response(serializer(users, context={'request': request}).data)
def news(self, request, pk=None): '''Retrieves a list of news related to this item''' serializer = motsdits_compact.PaginatedCompactNewsSerializer queryset = sorting.sort(request, News.objects.filter(motdit=pk)) stories = get_paginated(request, queryset) return Response(serializer(stories, context={'request': request}).data)
def comments(self, request, pk=None): '''Retrieves a list of stories related to this item''' # @TODO: Add pagination serializer = motsdits_compact.PaginatedCompactCommentSerializer queryset = sorting.sort(request, Comment.objects.filter(news_item=pk)) comments = get_paginated(request, queryset) return Response(serializer(comments, context={'request': request}).data)
def related(self, request, pk=None): '''Recommend the motdit''' serializer = motsdits_serializers.PaginatedMotDitSerializer queryset = sorting.sort(request, MotDit.objects.filter(Q(what=pk) | Q(where=pk))) motsdits = get_paginated(request, queryset) return Response(serializer(motsdits, context={'request': request}).data)
def parse_compose_file(yaml_file): services = yaml_file['services'] sorted_services = sorting.sort(services) parsed_services = [] for d in sorted_services: for k, v in d.items(): parsed_services.append(parse_service(k, v)) commands = [] for s in parsed_services: commands.append(write_run_command(s)) return commands
def answers(self, request, pk=None): '''Allows users to post an answer to the question, either as a new motdit or as a motdit id''' # Load the relevant question question = Question.objects.get(pk=pk) # List all answers if request.method == 'GET': serializer = motsdits_compact.PaginatedCompactAnswerSerializer queryset = sorting.sort(request, Answer.objects.filter(question=question)) objects = get_paginated(request, queryset) return Response(serializer(objects, context={'request': request}).data) # Create a new answer elif request.method == 'POST': serializer = motsdits_compact.CompactAnswerSerializer # Either supply a discrete motdit ID if isinstance(request.DATA['motdit'], int): motdit = MotDit.objects.get(pk=request.DATA['motdit']) else: try: # Handle the response response = create_motdit(request, request.DATA['motdit']) motdit = MotDit.objects.get(pk=response.data['id']) except Exception as e: return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST) answer, created = Answer.objects.get_or_create( question=question, answer=motdit, created_by=request.user ) if created: signals.question_answered.send(request.user.__class__, created_by=request.user, question=question, answer=answer, motdit=motdit) status_code = status.HTTP_201_CREATED else: status_code = status.HTTP_200_OK return Response(serializer(answer, context={'request': request}).data, status=status_code)
def test_sort(ary): assert not is_sorted(ary) sorting.sort(ary) assert is_sorted(ary)
def index_kw(kw_file, out_file=OUT_FILE): SEPARATOR = "|" headers = {"Accept": "application/vnd.github.v3.text-match+json"} kws = format_kw(kw_file) sorted_kws = sort([kw[0] for kw in kws]) with open('/tmp/sorted.txt', 'w') as f: f.write('\n'.join(sorted_kws)) with open(out_file, 'a') as f: for pair in kws: time.sleep(60) fields = [] name = pair[0] corrected_name = correct_keys(pair[0]) print "Starting for %s which was corrected to %s" % (name, corrected_name) fields = [name] if name in sorted_kws: fields.append(str(len(sorted_kws) - sorted_kws.index(name) + 1)) else: fields.append('???') if name in SEARCH_KWS: terms = SEARCH_KWS[name] terms.insert(0, name) # Indeed indeed_count = aggregate_searchs(terms, fetch_indeed) fields.append(indeed_count) # SimplyHired simplyhired_count = aggregate_searchs(terms, fetch_simplyhired) fields.append(simplyhired_count) else: fields.append(fetch_indeed([corrected_name])) fields.append(fetch_simplyhired([corrected_name])) # StackOverflow fields.append(fetch_stackoverflow([name])) if pair[1]: # Github available, check github for stars etc. url = "https://api.github.com/repos/%s/%s" % pair[1:] x = requests.get(url, headers=headers) repo = json.loads(x.text) git_fields = ['network_count', 'stargazers_count', 'subscribers_count', 'html_url'] for field in git_fields: if field not in repo: break forks = repo['network_count'] fields.append(forks) stars = repo['stargazers_count'] fields.append(stars) watchers = repo['subscribers_count'] fields.append(watchers) url = repo['html_url'] fields.append(url) line = SEPARATOR.join([unicode(x) for x in fields]).encode('utf-8') print "Writing " + line f.write(line) f.write('\n')
def test_bubble2(self): bubble = sort() listamal = [0, 1, 77, 3, 77, 4, 77, 3, 2, 5] listabien = bubble.bubbleSort(listamal) self.assertEqual(listabien, [0, 1, 2, 3, 3, 4, 5, 77, 77, 77])
def test_bubble1(self): bubble = sort() listamal = [66, 71, 16, 21, 79, 9, 40, 60, 5] listabien = bubble.bubbleSort(listamal) self.assertEqual(listabien, [5, 9, 16, 21, 40, 60, 66, 71, 79])
f_algo = form.getvalue('algorithm') f_size = form.getvalue('problem_size') if not f_type: # Print HTML form til valg af problem type print htmlforms['problem_type'] elif not f_algo: if f_type in htmlforms: # Print HTML form til valg af algoritme print htmlforms[f_type] else: print 'Den valgte problemtype er ikke understøttet.' else: if f_type == 'sort': # Start HTML tabel print '<table><tr><td>Algoritme:</td><td>Tid:</td></tr>' for result in sorting.sort(f_algo, int(f_size)): # Udpak resultat name, time = result # Gør navnet lidt pænere name = name.replace('_', ' ').title() # Print HTML række print '<tr><td>%s:</td><td>%.4f</td></tr>' % (name, time) # S**t HTML tabel print '</table>' # Print HTML footer print '''</body></html>'''
from sorting import sort import random as rd l = [rd.randint(1, 10) for _ in range(10)] print(sort(l, 'merge'))
def testArray3(self): array3 = [5, 0, 15, 25, 21, 35, 40, 25, 6, 9] bubble3 = sort().BubbleSort(array3) self.assertEqual(array3, bubble3)
def testArray2(self): array2 = [0, 2, 23, 4, 2, 8, 1, 25, 6, 9] bubble2 = sort().BubbleSort(array2) self.assertEqual(array2, bubble2)
def main(year): # NBA season # URL page we will scrap url = "https://www.basketball-reference.com/leagues/NBA_{}_standings.html".format( year) # HTML from URL html = get(url) soup = BeautifulSoup(html.text, "html.parser") bstWins = Tree() bstLoss = Tree() bstWin_loss_pct = Tree() bstGb = Tree() bstPts_per_g = Tree() bstOpp_pts_per_g = Tree() bstSrs = Tree() teamsList = [] winList = [] lossList = [] win_loss_pctList = [] gbList = [] pts_per_gList = [] opp_pts_per_gList = [] srsList = [] # Scraps eastern conference table easternTable = soup.findAll('table', attrs={"id": "confs_standings_E"}) for tablerows in easternTable: tableBody = tablerows.find_all('tbody') for item in tableBody: href = item.find_all("a", href=True) wins = item.find_all('td', attrs={"data-stat": "wins"}) loss = item.find_all('td', attrs={"data-stat": "losses"}) win_loss_pct = item.find_all('td', attrs={"data-stat": "win_loss_pct"}) gb = item.find_all('td', attrs={"data-stat": "gb"}) pts_per_g = item.find_all('td', attrs={"data-stat": "pts_per_g"}) opp_pts_per_g = item.find_all('td', attrs={"data-stat": "opp_pts_per_g"}) srs = item.find_all('td', attrs={"data-stat": "srs"}) cont = 0 # Adds Eastern Conference Data to BST for name in href: teamName = name.text teamsList.append(teamName) winsItem = float(wins[cont].text) winList.append(winsItem) bstWins.insert(teamName, winsItem) lossItem = float(loss[cont].text) lossList.append(lossItem) bstLoss.insert(teamName, lossItem) win_loss_pctItem = float(win_loss_pct[cont].text) win_loss_pctList.append(win_loss_pctItem) bstWin_loss_pct.insert(teamName, win_loss_pctItem) gbItem = float(gb[cont].text.replace('—', '0')) gbList.append(gbItem) bstGb.insert(teamName, gbItem) pts_per_gItem = float(pts_per_g[cont].text) pts_per_gList.append(pts_per_gItem) bstPts_per_g.insert(teamName, pts_per_gItem) opp_pts_per_gItem = float(opp_pts_per_g[cont].text) opp_pts_per_gList.append(opp_pts_per_gItem) bstOpp_pts_per_g.insert(teamName, opp_pts_per_gItem) srsItem = float(srs[cont].text) srsList.append(srsItem) bstSrs.insert(teamName, srsItem) cont += 1 # Scraps Western conference table westernTable = soup.findAll('table', attrs={"id": "confs_standings_W"}) for tablerows in westernTable: tableBody = tablerows.find_all('tbody') for item in tableBody: href = item.find_all("a", href=True) wwins = item.find_all('td', attrs={"data-stat": "wins"}) wloss = item.find_all('td', attrs={"data-stat": "losses"}) wwin_loss_pct = item.find_all('td', attrs={"data-stat": "win_loss_pct"}) wgb = item.find_all('td', attrs={"data-stat": "gb"}) wpts_per_g = item.find_all('td', attrs={"data-stat": "pts_per_g"}) wopp_pts_per_g = item.find_all( 'td', attrs={"data-stat": "opp_pts_per_g"}) wsrs = item.find_all('td', attrs={"data-stat": "srs"}) wcont = 0 # Adds Western Conference Data to BST for name in href: teamName = name.text teamsList.append(teamName) winsItem = float(wwins[wcont].text) winList.append(winsItem) bstWins.insert(teamName, winsItem) lossItem = float(wloss[wcont].text) lossList.append(lossItem) bstLoss.insert(teamName, lossItem) win_loss_pctItem = float(wwin_loss_pct[wcont].text) win_loss_pctList.append(win_loss_pctItem) bstWin_loss_pct.insert(teamName, win_loss_pctItem) gbItem = float(wgb[wcont].text.replace('—', '0')) gbList.append(gbItem) bstGb.insert(teamName, gbItem) pts_per_gItem = float(wpts_per_g[wcont].text) pts_per_gList.append(pts_per_gItem) bstPts_per_g.insert(teamName, pts_per_gItem) opp_pts_per_gItem = float(wopp_pts_per_g[wcont].text) opp_pts_per_gList.append(opp_pts_per_gItem) bstOpp_pts_per_g.insert(teamName, opp_pts_per_gItem) srsItem = float(wsrs[wcont].text) srsList.append(srsItem) bstSrs.insert(teamName, srsItem) wcont += 1 #Builds list for mins and max minWins = bstWins.find_min() maxWins = bstWins.find_max() minLoss = bstLoss.find_min() maxLoss = bstLoss.find_max() minWin_loss_pct = bstWin_loss_pct.find_min() maxWin_loss_pct = bstWin_loss_pct.find_max() minGb = bstGb.find_min() maxGb = bstGb.find_max() minPts_per_g = bstPts_per_g.find_min() maxPts_per_g = bstPts_per_g.find_max() minOpp_pts_per_g = bstOpp_pts_per_g.find_min() maxOpp_pts_per_g = bstOpp_pts_per_g.find_max() minSrs = bstSrs.find_min() maxSrs = bstSrs.find_max() minsAndMax = [ minWins, maxWins, minLoss, maxLoss, minWin_loss_pct, maxWin_loss_pct, minGb, maxGb, minPts_per_g, maxPts_per_g, minOpp_pts_per_g, maxOpp_pts_per_g, minSrs, maxSrs ] # Builds data frame from Scrapped Data data = { 'Teams': teamsList, 'Wins': winList, 'Loss': lossList, 'Win-Loss Percentage': win_loss_pctList, 'Games Behind': gbList, 'Points Per Game': pts_per_gList, 'Opponent Points Per Game': opp_pts_per_gList, 'Simple Rating System': srsList } # ['wins', 'loss', 'win_loss_pct', 'gb', 'pts_per_g', 'opp_pts_per_g', 'srs'] df = DataFrame(data, columns=[ 'Teams', 'Wins', 'Loss', 'Win-Loss Percentage', 'Games Behind', 'Points Per Game', 'Opponent Points Per Game', 'Simple Rating System' ]) df.to_csv(r'data\dataframe_NBA.csv', index=False) # SORTING sortedTeamsList = sort("ALL", teamsList) sortedWinList = sort("ALL", winList) sortedWinLossPCT = sort("ALL", win_loss_pctList) # SEARCHING print(sortedWinLossPCT) return minsAndMax, year, df, data, sortedTeamsList, sortedWinList, sortedWinLossPCT
def testArray1(self): array1 = [36, 71, 16, 21, 73, 9, 0, 40, 66, 7] bubble1 = sort().BubbleSort(array1) self.assertEqual(array1, bubble1)
def test1_check_sort(self): res = list(sorting.sort([], [], [5])) ass = [5] self.assertEqual(res, ass)
def test2_check_sort(self): res = list(sorting.sort([1000], [2.2, 3], [-1])) ass = [-1, 2.2, 3, 1000] self.assertEqual(res, ass)
def test3_check_sort(self): res = list(sorting.sort([1], [1, 1], [1, 5])) ass = [1, 1, 1, 1, 5] self.assertEqual(res, ass)
def test4_check_sort(self): res = list(sorting.sort([5], [3, 5], [4, 5])) ass = [3, 4, 5, 5, 5] self.assertEqual(res, ass)
def test0_check_sort(self): res = list(sorting.sort([1], [2, 3], [4, 5])) ass = [1, 2, 3, 4, 5] self.assertEqual(res, ass)
for photos in photos_tuples: out.append(photos[0]) return out #datasets = os.listdir("data") datasets = ["e_shiny_selfies.txt"] for dataset in datasets: print("Started data set {}".format(dataset)) photos = file_io.read_input(dataset) vertical = list(filter(lambda item: item[1] == "V", photos)) horizontal = filter(lambda item: item[1] == "H", photos) horizontal = list(map(lambda item: ((item[0], ), ) + item[1:], horizontal)) averageH = pairing.findHAverage(horizontal) vertical = pairing.pair(vertical, averageH) photos = sorting.sort(vertical + horizontal) #score.check_nearby(photos) slides = convert_to_slides(photos) #random.shuffle(slides) print("Started write") file_io.write_output(dataset, slides) print("finished dataset " + dataset) print("done")
print(dfPosts) df_maintags.to_csv("Tags.csv") Tags = pd.read_csv("Tags.csv") Posts = pd.read_csv("Posts.csv") df_result = Tags.join(Posts) df_result = df_result.drop(columns=["Unnamed: 0"]) df_result = df_result.sort_values(by=["posts"]) ##########create folder and change directory################ try: os.makedirs(tagword) except: print("folder exist") os.chdir(tagword) ###################################################################### print(df_result) name = "#" + tagword + ".csv" df_result.to_csv(name, index=False) sort(name) delete_emptycols("sorted.csv") gen("sorted1.csv") os.chdir("..") path = os.path.join(tagword, "hashtags.txt") tagword = tagword + ".txt" upload(tagword, path)