Datasets:

anton-l

/

python_sample_10k

like 0

userchaitu/userchaitu

46eabeb496e15ffe3658e58869793a34857b831a

76a44425755ffc9fea9f4f2a80ad693e7dce294d

/testfiles/conftest.py

059e5ae0a4adaaf1cf2d33200343301228cca70d

no_license

https://github.com/userchaitu/userchaitu

f870691a7d2d108a6d6529a8f076b44e3d1d3acf

913ae1a68f51a68ae3407c86aabee6166d235222

refs/heads/master

import pytest from selenium import webdriver @pytest.fixture(scope='class') def test_setup(request): options = webdriver.ChromeOptions() options.add_argument("--start-maximized") driver = webdriver.Chrome(executable_path="C:\\Users\\user\\eclipse\\chromedriver_win32\\chromedriver.exe", options=options) driver.get("https://rahulshettyacademy.com/angularpractice/") request.cls.driver = driver yield driver.close()

UTF-8

Python

py

conftest.py

DiyanKalaydzhiev23/fundamentals---python

1fc42c7c2341b461d9f4c94009031efa7161e6b1

e0b48bcc55dafe59f0032a6fea2c8da770d849af

/RegEx- exsercise/Extract Eamils.py

c58fb62da2e382e26a6ae106ca0524859434bb07

permissive

https://github.com/DiyanKalaydzhiev23/fundamentals---python

a80bc9308aad87902e3fcd4e61cdd4e2c47853df

7fa032d9a3270648ffa383bb00dad8e51613189d

refs/heads/main

import re valid_emails = [] pattern = r"(^|(?<=\s))[a-zA-Z0-9]+[\._-]?[a-zA-Z0-9]+@[a-z]+-?[a-z]+(\.[a-z]+)+" [valid_emails.append(el.group()) for el in re.finditer(pattern, input())] [print(email) for email in valid_emails]

UTF-8

Python

py

Extract Eamils.py

YourboyTizzyT/HW_codecraft_2018

784c22dff30b18272b709df8eb1293e53d676818

7a535152b364e04afae85edc03417be01a2345dd

/ecs/predictor.py

40a4fff4f66175cb17cc30b14e85a7a0692f259d

no_license

https://github.com/YourboyTizzyT/HW_codecraft_2018

31c19e13c0bceddd262f3248ee4bb3ea3eac91e6

39afef08421eb27b696f14eb2b82be44f3d50311

refs/heads/master

# -*- coding: utf-8 -*- import datetime,time,knapsack,math class PhyInfo: def __init__(self, cpu, mem, sto): self.cpu = cpu self.mem = mem self.sto = sto class VMInfo: def __init__(self): self.CPU = [] self.MEM = [] self.ID = [] def add_VM(self,VMlist): self.ID.append(VMlist[0]) self.MEM.append(int(int(VMlist[2])/1024)) self.CPU.append(int(VMlist[1])) def sort(self): self.ID=list(reversed(self.ID)) self.MEM=list(reversed(self.MEM)) self.CPU=list(reversed(self.CPU)) def exponential_smoothing(l,a,b): avg=Math.avg(l) s,t = [0*i for i in range(len(l))],[0*i for i in range(len(l))] for i in range(1, len(s)): s[i] = a*l[i]+(1-a)*(s[i-1]+t[i-1]) if s[i]<0:s[i]=avg t[i] = b*(s[i]-s[i-1])+(1-b)*t[i-1] return s,t class Math: @staticmethod def avg(l): return float(sum(l))/len(l); @staticmethod def variance(l): s1=0; s2=0; for i in l: s1+=i**2; s2+=i; return math.sqrt(float(s1)/len(l)-(float(s2)/len(l))**2); def noise(l): l1=[]#第i周 l1=Denoising(l) return l1 def Denoising(l): print Math.avg(l),Math.variance(l) max_l=Math.avg(l)+3*Math.variance(l) avg_l=Math.avg(l) while max(l)>max_l: l[l.index(max(l))]=max_l return l def moving_windows(lists,length=7,step=1): l=[] begin=0 while begin<len(lists)-length+1: l.append(sum(lists[begin:begin+length])) begin+=step return l def try_alpha(l,t1):#t1预测天数 train=l[0:int(-1*t1+1)] test=l[-1] a_list=[i*0.1+0.1 for i in range(9)] b_list=[i*0.1+0.1 for i in range(9)] error,errors=[],[] for a in a_list: for b in b_list: s,t = exponential_smoothing(train,a,b) error.append((s[-1]+t[-1]*t1-test)**2) errors.append(error) error=[] mins=[] mins_index=[] for i in errors: mins.append(min(i)) mins_index.append(i.index(min(i))) return a_list[mins.index(min(mins))],b_list[mins_index[mins.index(min(mins))]] def predict_vm(ecs_lines, input_lines): # Do your work from here# result = [] if ecs_lines is None: print 'ecs information is none' return result if input_lines is None: print 'input file information is none' return result #读取input文件信息 values=input_lines[0].split(" ") phyInfo=PhyInfo(int(values[0]),int(values[1]),int(values[2])) VM_num=int(input_lines[2]) VM=VMInfo() for i in range(3,3+VM_num): VM.add_VM(input_lines[i].split(" ")) VM.sort() DIM=input_lines[3+VM_num+1][0:-1] predict_daySpan=(str2time(input_lines[3+VM_num+4])-str2time(input_lines[3+VM_num+3][0:-1])).days #读取traindata train_begin_time=str2time(ecs_lines[0].split("\t")[-1][0:-1]) train_end_time=str2time(ecs_lines[-1].split("\t")[-1][0:-1]) train_daySpan=(str2time(ecs_lines[-1].split("\t")[-1][0:-1])-str2time(ecs_lines[0].split("\t")[-1][0:-1])).days+1 sequence=[] start=train_begin_time ecs=ecs_lines ecs_list=[] predict=[] alpha = 0.60 beta= 0.2 for i in range(len(VM.ID)): sequence=[j*0 for j in range(train_daySpan)] for item in ecs: if item.split("\t")[1]==VM.ID[i]: sequence[(str2time(item.split("\t")[-1][0:10])-start).days]+=1 else: ecs_list.append(item) sequence=noise(sequence) sequence=moving_windows(sequence,predict_daySpan,1) #alpha,beta=try_alpha(sequence,predict_daySpan) s,t = exponential_smoothing(sequence,alpha,beta) predict.append(int(max(round(s[-1]+t[-1]*predict_daySpan,0),0))) ecs=ecs_list ecs_list=[] result=0 print "predict:",predict to_kp=knapsack_list(predict,VM) kp,reuse=knapsack.read_input(to_kp,phyInfo.cpu,phyInfo.mem,DIM) #if reuse[0]*1.0/PhyInfo.cpu if ((reuse[0]<0.2*phyInfo.cpu) or (reuse[1]<0.2*phyInfo.mem)) and (len(kp[-1])<=5): for i in kp[-1]: predict[VM.ID.index(i)]-=1 kp.pop() else: #给最后一个物理机添加虚拟机 for i in range(len(VM.CPU)): x=predict[i]//7+1 while(reuse[0]>=VM.CPU[i] and reuse[1]>=VM.MEM[i]): x-=1 if x==0: break reuse[0]-=VM.CPU[i] reuse[1]-=VM.MEM[i] kp[-1].append(VM.ID[i]) predict[i]+=1 result=result_writer1(predict,VM) result+=result_writer2(kp) return result def knapsack_list(num_list,vminfo): cpu,mem,vmid=[],[],[] for i in range(len(num_list)): if num_list[i]!=0: for j in range(num_list[i]): cpu.append(vminfo.CPU[i]),mem.append(vminfo.MEM[i]),vmid.append(vminfo.ID[i]) return [cpu,mem,vmid] def result_writer1(num_list,vminfo): out=[] out.append(str(sum(num_list))) for i in range(len(num_list)): out.append(vminfo.ID[i]+' '+str(num_list[i])) return out def result_writer2(lists): out=[] out.append('\n'+str(len(lists))) n=0 for i in lists: n+=1 lines=str(n)+' ' dic = {} for j in i: if i.count(j)>=1: dic[j] = i.count(j) for k in dic.items(): lines+=k[0]+' '+str(k[1])+' ' out.append(lines.strip()) del lines return out def str2time(inputStr): return datetime.datetime.strptime(inputStr[0:10],"%Y-%m-%d")

UTF-8

Python

py

predictor.py

Nejel/coursera-python-specialization-repository

79ceea2f14095a03bf7222e312cb0e175154c2e6

eb2b4f8db686ec8987830d6135a4d75408fc5a5b

/3-access-web-data/parse2.py

b41d8b722a5c76853d8135132bd206bdf6fcf8d8

no_license

https://github.com/Nejel/coursera-python-specialization-repository

5f4e3bb667e898a3f381e4ff3c19e2a93fb7fb50

c264f59cb7bf55126ba80f0ca4251e4d56376270

refs/heads/master

# To run this, you can install BeautifulSoup # https://pypi.python.org/pypi/beautifulsoup4 # Or download the file # http://www.py4e.com/code3/bs4.zip # and unzip it in the same directory as this file import urllib.request, urllib.parse, urllib.error from bs4 import BeautifulSoup sum = 0 import ssl import re pagecount = 0 tagcount = 0 html2 = () currenttag = () sampleurl = 'http://py4e-data.dr-chuck.net/comments_42.xml' mainurl = 'http://py4e-data.dr-chuck.net/comments_109327.xml' # Ignore SSL certificate errors ctx = ssl.create_default_context() ctx.check_hostname = False ctx.verify_mode = ssl.CERT_NONE #url = ('http://py4e-data.dr-chuck.net/known_by_Harris.html') url = mainurl #html = urllib.request.urlopen(url).read() # Retrieve all of the anchor tags #while pagecount < 7 : html = urllib.request.urlopen(url, context=ctx).read() soup = BeautifulSoup(html, 'html.parser') tags = soup('count') for tag in tags: if tagcount < 7777: #print(tag.get('href', None)) print(tag.string) sum += int(tag.string) tagcount += 1 #print(tagcount) ''' elif tagcount == 17: print(tag.get('href', None)) currenttag = (tag.string) print(currenttag) #answer = re.findall('>(.)</a>', currenttag, flags = 0) #print(answer) url = (tag.get('href', None)) break ''' # pagecount += 1 # tagcount = 0 # continue #else: print(currenttag) print(sum)

UTF-8

Python

py

parse2.py

avneetkaur1103/workbook

ddff17f668c4f2293f8f99d2f53df8a55f92d365

3142275793b5ca407bcb658ece39a617d1e75e30

/Algorithms/Greedy/job_sequencing.py

92f5825beaf501d7616e7583407622dd73539a0f

no_license

https://github.com/avneetkaur1103/workbook

d35da2d58fe4e213a38303d4d21ede2973ad3f2d

61b32387784a19ac2c4d758e8dcbdbe2d2e870e5

refs/heads/master

""" Given an array of jobs where every job has a deadline and associated profit if the job is finished before the deadline. It is also given that every job takes single unit of time, so the minimum possible deadline for any job is 1. How to maximize total profit if only one job can be scheduled at a time. """ import operator def schedule(arr, n_slots): arr = sorted(arr, key=operator.itemgetter(2), reverse=True) result = list() slots = [True] * n_slots for id, deadline, profit in arr: for i in range(deadline-1, -1, -1): if slots[i]: result.append((id, i+1, profit)) slots[i] = False break print('Result ', result) # Driver COde arr = [['a', 2, 100], # Job Array ['b', 1, 19], ['c', 2, 27], ['d', 1, 25], ['e', 3, 15]] print("Following is maximum profit sequence of jobs") schedule(arr, 3)

UTF-8

Python

py

job_sequencing.py

kopyshev/HackerRankCheckIO

fc9c7dca8f7ccc129950c69c1edfc274c9424e21

cabd82f851ac7096801e8bc22b17f8c7225356da

/Others/The_Devil_s_WiFi.py

bc45a643e1616adb65cd1bac910fe76e2c04fe89

no_license

https://github.com/kopyshev/HackerRankCheckIO

9f2f92b058d371a7b533a578b2dde7bdbf67726f

9b1829b3e078b1acfc331bcbac222f7f7f360a68

refs/heads/main

from decimal import Decimal, getcontext from math import factorial getcontext().prec = 1000 #need for sqrt() precision def devils_wifi(position, n = 800): # the Chudnovsky brothers' formula # Each new term of the formula gives an additional 14 digits of pi. # by default n = 80 pi = Decimal(0) k = 0 while n > k: pi += Decimal((-1)**k*factorial(6*k)*(13591409+545140134*k))/Decimal(factorial(k)**3*(factorial(3*k))*((640320)**3)**k) k += 1 pi *= Decimal(10005).sqrt()/4270934400 pi = pi**(-1) return str(pi).split(str(position))[0][-8:] print(devils_wifi(28638823)) assert devils_wifi(28638823) == "73115956", 'wrong password'

UTF-8

Python

py

The_Devil_s_WiFi.py

DanielPiqueras/Python

3d41404f4638f0cd15c0d21061b342a2ed27cc4c

dadd16a451e9ba5679ef06b8eea2a8d097d9269e

/Python/Ebiblio/ebiblio-master/ebiblio-api/Login/models.py

26a3f7b571c58930947924fed59ac6d578860f45

no_license

https://github.com/DanielPiqueras/Python

d12845389202cb1d86e68b47191681a76c3ab04f

c83bd0dcd5752ccb8cc6b0fa2485635af7718e41

refs/heads/master

Python

import re from django.contrib.auth.models import User from django.contrib.auth.tokens import PasswordResetTokenGenerator import six from django.utils.crypto import constant_time_compare from django.utils.http import base36_to_int from rest_framework import status, serializers from rest_framework.permissions import BasePermission, SAFE_METHODS # Permission classes class IsUserOwnerOrAdmin(BasePermission): def has_permission(self, request, view): if (view.action == 'list' or request.method == 'POST') and \ not request.user.is_staff: return False elif request.user.is_authenticated: return bool(request.user and request.user.is_authenticated) else: return False def check_object_permission(self, user, obj): return bool(user and user.is_authenticated and bool(user.is_staff or obj == user)) def has_object_permission(self, request, view, obj): return self.check_object_permission(request.user, obj) class IsOwnerOrAdmin(BasePermission): def has_permission(self, request, view): if (request.user.pk == view.kwargs['user_id']) or request.user.is_staff: return True else: return False class IsAdminOrReadListBookOnly(BasePermission): def has_permission(self, request, view): return bool( request.method in SAFE_METHODS or request.user and request.user.is_staff ) class IsAdminOrOnlyRent(BasePermission): def has_permission(self, request, view): if (request.method != 'POST' and request.method != 'PUT') and \ not request.user.is_staff: return False elif request.user.is_authenticated: return bool(request.user and request.user.is_authenticated) else: return False # Check if data is valid def check_is_empty(attrs): for attribute in attrs: if attrs[attribute] == 'Not found': raise serializers.ValidationError( 'The {data} has not been sent'.format(data=attribute)) if isinstance(attrs[attribute], str) is False: raise serializers.ValidationError( 'The {data} need to be string'.format(data=attribute), code=status.HTTP_409_CONFLICT) if len(attrs[attribute]) == 0: raise serializers.ValidationError( 'The {data} is empty'.format(data=attribute), code=status.HTTP_409_CONFLICT) if ' ' in attrs[attribute]: raise serializers.ValidationError( 'The {data} should not contain spaces'.format(data=attribute)) return True def check_email(email): if isinstance(email, str) is False: raise serializers.ValidationError('The email need to be string') if re.match(r'^[(a-z0-9\_\-\.)]+@[(a-z0-9\_\-\.)]+\.[(a-z)]{2,15}$', email.lower()): return True else: raise serializers.ValidationError('Not valid email') def check_is_in(param): response = { True: True, False: False, 'true': True, 'false': False, } if not isinstance(param, str) and not isinstance(param, bool): raise serializers.ValidationError('Only true or false in string') if isinstance(param, str): param = param.lower() if param not in response: raise serializers.ValidationError('Only true or false in string') return response[param] def check_if_is_valid_post(request): field = '' if request.data.get('email', '') != '': check_email(request.data['email']) if len(User.objects.filter(email=request.data['email'])) != 0: raise serializers.ValidationError( 'This email is being used by another user.') data_to_check = { 'username': request.data.get('username', 'Not found'), 'password': request.data.get('password', 'Not found'), 'repeat_password': request.data.get('repeat_password', 'Not found') } check_is_empty(data_to_check) check_is_staff = request.data.get('is_staff', False) is_staff = check_is_in(check_is_staff) if isinstance(request.data.get('first_name', ''), str): first_name = request.data.get('first_name', '') else: field += 'First name, ' if isinstance(request.data.get('last_name', ''), str): last_name = request.data.get('last_name', '') else: field += 'Last name' if request.data['password'] != request.data['repeat_password']: raise serializers.ValidationError( 'The two password need to be identical') if field != "": raise serializers.ValidationError( 'Invalid data for {fields}'.format(fields=field)) user = User.objects.create_user( username=request.data['username'], password=request.data['password'], ) user.is_staff = is_staff user.first_name = first_name user.email = request.data.get('email', user.email) user.last_name = last_name user.save() return user def check_if_is_valid_put(instance, request): field = "" if request.data.get('email', '') != '': check_email(request.data['email']) if len(User.objects.filter(email=request.data['email']).exclude(pk=instance.pk)) != 0: raise serializers.ValidationError( 'This email is being used by another user.') check_is_staff = request.data.get('is_staff', False) check_is_active = request.data.get('is_active', True) is_staff = check_is_in(check_is_staff) is_active = check_is_in(check_is_active) if request.data.get('first_name') is not None and isinstance( request.data.get('first_name', ''), str): instance.first_name = request.data.get('first_name', instance.first_name) else: field += 'First name, ' instance.email = request.data.get('email', instance.email) if request.data.get('last_name') is not None and isinstance( request.data.get('last_name', ''), str): instance.last_name = request.data.get('last_name', instance.last_name) else: field += 'Last name, ' if request.data.get('username') is not None: check_is_empty({'username': request.data.get('username', 'Not found')}) instance.username = request.data.get('username', instance.username) else: field += 'Username, ' if request.data.get('password', 'notFound') is None or request.data.get( 'repeat_password', 'notFound') is None: field += 'Password' if field != "": raise serializers.ValidationError( 'Invalid data for {fields}'.format(fields=field)) if request.data.get('password', '') != '' or request.data.get( 'repeat_password', '') != '': check_is_empty({'password': request.data.get('password', 'Not found'), 'repeat_password': request.data.get('repeat_password', 'Not found')}) if instance.check_password(request.data.get('old_password', '')) and \ request.data['password'] == request.data['repeat_password']: instance.set_password(request.data['password']) elif request.data['password'] != request.data['repeat_password']: raise serializers.ValidationError( 'The password need to be identical') else: raise serializers.ValidationError('Incorrect old passwords') instance.is_active = is_active instance.is_staff = is_staff instance.save() return instance class TokenGenerator(PasswordResetTokenGenerator): def _make_hash_value(self, user, timestamp): return (six.text_type(user.pk) + six.text_type(timestamp) + six.text_type(user.is_active)) def check_token(self, user, token): """ Check that a password reset token is correct for a given user. """ if not (user and token): return False # Parse the token try: ts_b36, _ = token.split("-") except ValueError: return False try: ts = base36_to_int(ts_b36) except ValueError: return False # Check that the timestamp/uid has not been tampered with if not constant_time_compare(self._make_token_with_timestamp(user, ts), token): return False if (self._num_days(self._today()) - ts) > 1: return False return True

UTF-8

Python

py

models.py

RIT-Space-Exploration/URC-Base-Station

c3807b2cea0c006c8f23feb4d20115c872241160

0130de5817f4f3b34cfb13b9ed01f2612c5d464e

/Software/backend/rover_base_station/migrations/0006_auto_20200105_1252.py

49d67d71f670509b4f85c5953d5dfa5733f65690

no_license

https://github.com/RIT-Space-Exploration/URC-Base-Station

e2a6c43c72de960cd1e0760a74daaf072b3c710b

8097e28b11ed7b941f37aa2b54b14c5e7fb0b04c

refs/heads/master

# Generated by Django 2.2.5 on 2020-01-05 17:52 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('rover_base_station', '0005_video'), ] operations = [ migrations.AlterField( model_name='video', name='img', field=models.FileField(upload_to='images'), ), ]

UTF-8

Python

py

0006_auto_20200105_1252.py

CodecoolKRK20173/erp-mvc-2-ccnoobs

1cea68952750766d54282d1c8ab55f81d7c5ef77

e69f9d63ad3601553f936845cf6d3d7d5081bdd2

/controller/inventory_controller.py

7d8ea2dc000b6afbee6219286675d91e5350628d

no_license

https://github.com/CodecoolKRK20173/erp-mvc-2-ccnoobs

d99a569e96907adb86692dfce82b61662aed698f

d97e0684f159a0c1d071d8abcb54fc652f30c0c7

refs/heads/master

# everything you'll need is imported: from view import terminal_view from model.inventory import inventory from controller import common def run(): """ Starts this module and displays its menu. * User can access default special features from here. * User can go back to main menu from here. Returns: None """ def run(): """ Starts this module and displays its menu. * User can access default special features from here. * User can go back to main menu from here. Returns: None """ table = inventory.get_inventory_table_from_file() title_list = ["ID", "NAME", "Manufacturer".upper(), "Year".upper(), "Durability".upper()] options = ["View records", "Add record", "Remove record", "Update record", "Which items have not exceeded their durability yet?", "What are the average durability times for each manufacturer?"] choice = None while choice != "0": choice = terminal_view.get_choice_inner_menu(options, "Inventory manager") if choice == "1": terminal_view.print_table(table, title_list) elif choice == "2": data_input_not_correct = True while data_input_not_correct: record = terminal_view.get_inputs(title_list[1::],"Please provide new item data") if record[2].isdigit() and record[3].isdigit(): table = inventory.add(table, record) data_input_not_correct = False else: terminal_view.print_error_message("Year and durability should be natural numbers!") elif choice == "3": id_to_delete_table = terminal_view.get_inputs(["ID"],"Item to delete") id_to_delete = id_to_delete_table[0] table = inventory.remove(table, id_to_delete) elif choice == "4": records = terminal_view.get_inputs(title_list,"Edit item") record_id = records[0] table = inventory.update(table, record_id, records) elif choice == "5": available_items = inventory.get_available_items(table) terminal_view.print_table(available_items, title_list) #terminal_view.print_result(available_items, "Available items") elif choice == "6": average_durability = inventory.get_average_durability_by_manufacturers(table) list_from_dict = average_durability.items() dict_headers = ["MANUFACTURER","DURABILITY"] terminal_view.print_table(list_from_dict, dict_headers) # terminal_view.print_result(average_durability, "Average durability by manufacturer") elif choice != "0": terminal_view.print_error_message("There is no such choice.")

UTF-8

Python

py

inventory_controller.py

418sec/labml

dcd040889fbc48082cf75089e6c280259f594820

bf483551159fc3d8420943f9906f8254bd2cdefc

/labml/utils/cache.py

deb41493c167e9fb5ef5b2e720435182beddd486

permissive

https://github.com/418sec/labml

0d9474223f8646cb634853902943ebbbe9b32339

215264eff311ad91ca6fd1519f94833c2f9a7cd6

refs/heads/master

MIT

import json from typing import Callable, Any from labml import lab def cache(name: str, loader: Callable[[], Any], file_type: str = 'json') -> Any: cache_path = lab.get_data_path() / 'cache' if not cache_path.exists(): cache_path.mkdir(parents=True) path = cache_path / f'{name}.{file_type}' if path.exists(): with open(str(path), 'r') as f: if file_type == 'json': return json.load(f) else: raise ValueError(f'Unknown file type: {file_type}') else: value = loader() with open(str(path), 'w') as f: if file_type == 'json': json.dump(value, f) else: raise ValueError(f'Unknown file type: {file_type}') return value def cache_get(name: str, file_type: str = 'json') -> Any: cache_path = lab.get_data_path() / 'cache' if not cache_path.exists(): cache_path.mkdir(parents=True) path = cache_path / f'{name}.{file_type}' if path.exists(): with open(str(path), 'r') as f: if file_type == 'json': return json.load(f) else: raise ValueError(f'Unknown file type: {file_type}') else: return None

UTF-8

Python

py

cache.py

Sunil-Yaragoppa/pythonRepo

f4ca67c691b053298d6c8231fd75613af6fda977

a55769d8a62bbcc17a9a8b7ef6047e19bd6a6c10

/restaurant.py

a299f2def06b00324639007ae14666fc3d38d0e0

no_license

https://github.com/Sunil-Yaragoppa/pythonRepo

76ded75464794c092e43ed7602e402e7faa46eda

1240b8dd6a6c28ad6f8eeb9b61a921747a6da1dd

refs/heads/master

'''Restaurant: Make a class called Restaurant. The __init__() method for Restaurant should store two attributes: a restaurant_name and a cuisine_type. Make a method called describe_restaurant() that prints these two pieces of information, and a method called open_restaurant() that prints a message indicating that the restaurant is open. Make an instance called restaurant from your class. Print the two attributes individually, and then call both methods.''' '''Ice Cream Stand: An ice cream stand is a specific kind of restaurant. Write a class called IceCreamStand that inherits from the Restaurant class you wrote in Exercise 9-1 (page 166) or Exercise 9-4 (page 171). Either version of the class will work; just pick the one you like better. Add an attribute called flavors that stores a list of ice cream flavors. Write a method that displays these flavors. Create an instance of IceCreamStand, and call this method.''' class Restaurant(): def __init__(self , restaurant_name , cuisine_type): self.restaurant_name = restaurant_name self.cuisine_type = cuisine_type def describe_restaurant(self): print(self.restaurant_name.title()) print(self.cuisine_type.title()) def open_restaurant(self): print("The restaurant is open!") #restaurant = Restaurant('the grand budapest' , 'luxury') #restaurant.describe_restaurant() #restaurant.open_restaurant() class IceCreamStand(Restaurant): def __init__(self , restaurant_name , cuisine_type): super().__init__( restaurant_name , cuisine_type) self.flavours = ['strawberry' , 'chocolate' , 'pista' , 'butter scotch'] def show_flavours(self): print(self.flavours) restaurant = IceCreamStand('the grand budapest' , 'luxury') restaurant.show_flavours()

UTF-8

Python

py

restaurant.py

razaldahal/eduinfsys

df01b0d9193879a9f24f82d86c02e49aaa7b88cd

6ef1991d2704c5882a52fd3d6844e8b529d6c058

/book/serializers.py

09fbaef0ae4076d8447c8a027e4150bc878ba447

no_license

https://github.com/razaldahal/eduinfsys

2093e19bd9e205813be14799b6e3ee5c7ca574d3

41531d78237e80459bbf5afed356a7ad193c3086

refs/heads/master

from rest_framework import serializers from .models import * class bookSerializer(serializers.ModelSerializer): class Meta: model=book fields=('serial_no','name','author','publisher','edition')

UTF-8

Python

py

serializers.py

joshuaNewman10/ml

1e565ecde5c034d6becd1245dffed8281187d24e

72b1d8b44520d1757d379d8013eb3912b005bef3

/ml/common/helper/data_generator.py

07eb045d577675a429d50c7dfd8322c0053f25e1

no_license

https://github.com/joshuaNewman10/ml

14d8d5821bd952e77272b740cf05cef69ebee383

3ec43868004d421814f8e056205e77a2b8cb92dc

refs/heads/master

import json class DataGenerator: def __init__(self, training_data_file_path, validation_data_file_path, image_loader): self.training_data_file_path = training_data_file_path self.validation_data_file_path = validation_data_file_path self.image_loader = image_loader self.training_data = self.load_data(self.training_data_file_path) def get_validation_data(self): X = [] y = [] validation_data = self.load_data(self.validation_data_file_path) for datum in validation_data: X.append(self.image_loader.load(datum['X'])) y.append(datum['y']) return (X, y) def get_training_data(self, batch_size, num_batches): while True: training_data = self.load_data(self.training_data_file_path) for batch_num in range(num_batches): X = [] y = [] for i in range(batch_size): training_datum = next(training_data) X.append(self.image_loader.load(training_datum['X'])) y.append(training_datum['y']) yield (X, y) def load_data(self, data_path): with open(data_path) as f: data = map(json.loads, f) for datum in data: yield datum

UTF-8

Python

py

data_generator.py

mentoring-by-guido/hallo-web

5d7f69977d30e4daae5946eea71e1d9d3e7e6d23

c0d488dfe581d676d7bb193449c43e65ab57dba3

/app.py

ce6718e871e44dfffa524bf4977fc3cb66d9d7b5

no_license

https://github.com/mentoring-by-guido/hallo-web

983d5a4f72390c8a4d77367a9acf8cfb62ecbb66

1501da20c1fd70f4a8ab69c4b2ffed74f78e2a63

refs/heads/master

from flask import Flask from flask import request app = Flask(__name__) @app.route('/') def hello(): name = request.args.get('name', default = 'world', type = str) out = f'Hello, {name}!' return out @app.route('/sum') def sum(): x = request.args.get('x') y = request.args.get('y') sum = int(x) + int(y) return str(sum) @app.route('/square') def square(): x = request.args.get('x') square = int(x) * int(x) return str(square) @app.route('/sub') def substraction(): x = request.args.get('x') y = request.args.get('y') sub = int(x) - int(y) return str(sub) print("changes") if __name__ == '__main__': app.run(debug=True, host='0.0.0.0')

UTF-8

Python

py

app.py

kavindukk/RRT

9e2704dab4bae1fc2f56c42f138b8281f33459f0

d458001627291b4e70c2e1783e1c92885072dbda

/AS_.py

d767732520d608d1a7a584a98fa7ba003cae6965

no_license

https://github.com/kavindukk/RRT

eba0861e2f4228ee6a7930787786842574365d9b

aed1271c7b80d4866caf5f3f82e630e4855feb96

refs/heads/master

import sys import numpy as np class Node(): def __init__(self, name, index, h, graph): self.node_name = name self.node_index = index self.h = h self.g = 9999 self.f = self.g + self.h self.graph = graph self.previous_node = None A = Node('A', 0, 16, {'B':5, 'C':5}) B = Node('B', 1, 17, {'A':5, "C":4, 'D':3}) C = Node('C', 2, 13, {'A':5, 'B':4, 'D':7, 'E':7, 'H':8}) D = Node('D', 3, 16, {'B':3, 'C':7, 'H':11, 'K':16, 'L':13, 'M':14}) E = Node('E', 4, 16, {'C':7, 'H':5, 'F':4}) F = Node('F', 5, 20, {'E':4, 'G':9}) G = Node('G', 6, 12, {'F':9, 'N':12}) H = Node('H', 7, 11, {'C':8, 'D':11, 'E':5, 'I':3}) I = Node('I', 8, 10, {'H':3, 'J':4}) J = Node('J', 9, 8, {'I':4, 'N':3, 'P':8}) K = Node('K', 10, 4, {'D':16, 'L':5, 'N':7, 'P':4}) L = Node('L', 11, 7, {'D':13, 'K':5, 'M':9, 'O':4}) M = Node('M', 12, 10, {'D':14, 'L':9, 'O':5}) N = Node('N', 13, 7, {'G':12, 'J':3, 'K':7, 'P':7 }) O = Node('O', 14, 5, {'L':4, 'M':5}) P = Node('P', 15, 0, {'J':8, 'K':4, 'N':7}) nodes = [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] current_node = 'A' open_nodes = ['A'] closed_nodes = [] A.g = 0 A.f = A.g + A.h def A_star_step(): global A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P global current_node, open_nodes, closed_nodes for node in list(globals()[current_node].graph.keys()): # N = globals()[node] if node not in open_nodes and node not in closed_nodes : open_nodes.append(node) if node not in closed_nodes: if globals()[node].previous_node == None and not A: globals()[node].previous_node = current_node globals()[node].g = globals()[current_node].g + globals()[node].graph[current_node] globals()[node].f = globals()[node].g + globals()[node].h elif globals()[node].f > globals()[current_node].g + globals()[node].graph[current_node] + globals()[node].h: globals()[node].previous_node = current_node globals()[node].g = globals()[current_node].g + globals()[node].graph[current_node] globals()[node].f = globals()[node].g + globals()[node].h closed_nodes.append(open_nodes.pop(open_nodes.index(current_node))) acitve_f = [] for node in open_nodes: acitve_f.append( globals()[node].f) i = acitve_f.index(min(acitve_f)) current_node = open_nodes[i] while 'P' not in list(globals()[current_node].graph.keys()): # for i in range(4): A_star_step() print(current_node) print(open_nodes) print(closed_nodes) A_star_step() print(P.previous_node)

UTF-8

Python

py

AS_.py

DanielSeehausen/pseudo_smart_random_pairing

bfd1de852e55c1c3c5bcf57ce2c297b9d469462e

389dfef2204fd925cff51a3f39d626e86159fbe3

/db_interface.py

6670b5faf9d1a0bbeeef32af584f1fc2c7d48e53

no_license

https://github.com/DanielSeehausen/pseudo_smart_random_pairing

e18c8728d5903d069e9f94e053d5ea49e5b39d21

f51a043bb046dc96feb7d43d62c8aaa757ebc70a

refs/heads/master

import json def read_dict(db_name): try: #little ducktyping -- catches both file not found and file empty (incase it was erased) with open(db_name, 'r') as f: print("updating db...db_name") return json.load(f) except (FileNotFoundError, ValueError): print("creating db...") return init_pairing_dict(student_arr) def write_dict(db_name, data): with open(db_name, 'w+') as f: json.dump(data, f)

UTF-8

Python

py

db_interface.py

meatballhat/box-o-sand

11ee3f2a16a611f8ecd4ea1555e1cd10c25e5030

6546b3f8758823318385b36ad969e65a83fdccf1

/aoc2020/day03/solution.py

a23e7ad7381be2e82457e3f6753babea63e39821

permissive

https://github.com/meatballhat/box-o-sand

cfe4860e775a74e1130d24369de6d919641166c0

4d665d7c15ee2dff10ad71993492beea03cade56

refs/heads/main

MIT

Rust

import functools import sys import typing class Loc(typing.NamedTuple): x: int y: int def main() -> int: forest_frame = [list(line.strip()) for line in sys.stdin.readlines()] frame_width = len(forest_frame[0]) frame_height = len(forest_frame) all_trees_encountered = [] for slope in [ Loc(x=1, y=1), Loc(x=3, y=1), Loc(x=5, y=1), Loc(x=7, y=1), Loc(x=1, y=2), ]: loc = Loc(x=0, y=0) trees_encountered = 0 while loc.y <= (frame_height - 1): at_loc = forest_frame[loc.y][loc.x] if at_loc == "#": trees_encountered += 1 next_x = (loc.x + slope.x) % frame_width next_y = loc.y + slope.y next_loc = Loc(x=next_x, y=next_y) loc = next_loc print( f"(slope right={slope.x} down={slope.y}) trees encountered: {trees_encountered}" ) all_trees_encountered.append(trees_encountered) trees_encountered_product = functools.reduce( lambda x, y: x * y, all_trees_encountered ) print(f"trees encountered product: {trees_encountered_product}") return 0 if __name__ == "__main__": sys.exit(main())

UTF-8

Python

py

solution.py

jar3b/py-phias

3522b4fbf2286f0dd870e76f3dc39cad4086b90e

f5d6e591a9684db43ec6c97c5ab06613ee7e2ec6

/orchestra/db/__init__.py

b5f96c71e6dbda2f29266cb1d8c76bc4fd10709e

permissive

https://github.com/jar3b/py-phias

20ce00f5d27b0e6c78a239d2cd12f27c73d59715

41b370208a801c79b4b6204d2b115f1724d232bc

refs/heads/master

BSD-3-Clause

Python

from .db_filler import DbFiller

UTF-8

Python

py

__init__.py

JeremyJones/jpmctt

950e92e0692a51175b532aaa4907fb3dbe7dde07

f8945c9ddfb7aa3fed2aad2b2dc4685c2e93253c

/main.py

fe1ae8ec7d03988c287825f3717cb1d684f567d5

no_license

https://github.com/JeremyJones/jpmctt

de663389e733537d502e93475265203fa6cb983d

cca7bdbcf69489d025f5377ba134bdb1ee97a180

refs/heads/master

"""main.py -- tech test by Jeremy Jones Given text data representing the instructions sent by various clients to execute in the international market, create a report that shows: - Amount in USD settled incoming every day - Amount in USD settled outgoing every day - Ranking of entities based on incoming and outgoing amount Usage: python main.py < data.tsv """ from sys import stdin from models import Solution def main(): """Process the data provided on standard input and print reports of the results to standard output. """ sol = Solution() sol.add_data(stdin) print("=========================================================") print(sol.report_amount_settled_every_day()) print("=========================================================") print(sol.report_rank_entities('incoming')) print("=========================================================") print(sol.report_rank_entities('outgoing')) if __name__ == '__main__': main()

UTF-8

Python

py

main.py

vinifmor/bauh

1773de9d7645aeb8d76937503cc5416ffdce151b

22c1865e6768e0ffae2a32db8044c155e245b3d7

/bauh/gems/arch/proc_util.py

13bb59d496e3672824007bf754121b756defc4bf

permissive

https://github.com/vinifmor/bauh

d33ffbe40c18c8db9f8fe053a26846420cae30f9

d80b23a952808c883045759270776847fcd7c4ec

refs/heads/master

Zlib

Python

import multiprocessing import os import traceback from pwd import getpwnam from typing import Callable, Optional, TypeVar R = TypeVar('R') class CallAsUser: def __init__(self, target: Callable[[], R], user: str): self._target = target self._user = user def __call__(self, *args, **kwargs) -> R: try: os.setuid(getpwnam(self._user).pw_uid) return self._target() except Exception: traceback.print_exc() class WriteToFile: def __init__(self, file_path: str, content: str): self._file_path = file_path self._content = content def __call__(self, *args, **kwargs) -> bool: try: with open(self._file_path, 'w+') as f: f.write(self._content) return True except Exception: traceback.print_exc() return False def exec_as_user(target: Callable[[], R], user: Optional[str] = None) -> R: if user: with multiprocessing.Pool(1) as pool: return pool.apply(CallAsUser(target, user)) else: return target() def write_as_user(content: str, file_path: str, user: Optional[str] = None) -> bool: return exec_as_user(target=WriteToFile(file_path=file_path, content=content), user=user)

UTF-8

Python

py

proc_util.py

MaRDI4NFDI/docker-importer

bf08b8ea6d04689c6f51fe24e043b5677201beff

c0ba916d5f8951c1dfe41909855fb8e1326dfd23

/src/mardi_importer/zbmath/ZBMathConfigParser.py

9a1995d1123916fa029e2d8ef62b35f0e8d384b1

no_license

https://github.com/MaRDI4NFDI/docker-importer

8b4fd796b602d70a156a4291c330a18f5bc0fc2b

2b99f7eb236f1f5e8988b537c9238766bdaa2971

refs/heads/main

Python

from configparser import ConfigParser, NoOptionError import sys from mardi_importer.importer.Importer import AConfigParser class ZBMathConfigParser(AConfigParser): """Config parser for ZBMath data""" def __init__(self, config_path): """ Args: config_path (string): path to config file """ self.config_path = config_path self.config = ConfigParser() def parse_config(self): """ Overrides abstract method. This method reads a config file containing the config dfor handling ZBMath data. Returns: dict: dict of (config_key, value) pairs extracted from config file """ config_dict = {} self.config.read(self.config_path) if not "ZBMath" in self.config: sys.exit("Error: Config file does not contain section ZBMath") try: config_dict["out_dir"] = self.config["DEFAULT"]["output_directory"] except NoOptionError: sys.exit("Error: No output_directory in DEFAULT section of config") try: config_dict["tags"] = [ x.strip() for x in self.config["ZBMath"]["tags"].split(",") ] except NoOptionError: sys.exit("Error: No tags in ZBMath section of config.") for key in ["raw_dump_path", "processed_dump_path", "split_id"]: try: val = self.config["ZBMath"][key] if val == "None": config_dict[key] = None else: config_dict[key] = val except NoOptionError: sys.exit("Error: No " + key + " in ZBMath section of config.") for key in ["from_date", "until_date"]: try: val = self.config["ZBMath"][key] if val == "None": config_dict[key] = None else: config_dict[key] = val except NoOptionError: sys.exit("Error: No " + key + " in ZBMath section of config.") return config_dict

UTF-8

Python

py

ZBMathConfigParser.py

gxyd/competitive-programming

2de07d9e9f813dbd44ec2208b67fbbec310e7814

964475a2cac8640b21d6826123ef3cf7f78d3933

/journey-to-the-moon.py

928ffc6029bf4042e0ef256e197add0b37867f90

no_license

https://github.com/gxyd/competitive-programming

06183ac6fe17e2594cdad4bc05ded99500fa2416

7fc4b4569d21226fd51a85a1637e362339f9aed1

refs/heads/master

#!/usr/bin/python3 n, p = map(int, input().split()) X = [] for i in range(p): a, b = map(int, input().split()) X.append((a, b)) graph = dict([(i, set()) for i in range(n)]) for i, j in X: graph[i].add(j) graph[j].add(i) def dfs(graph, start): visited, stack = set(), [start] while stack: node = stack.pop() if node not in visited: visited.add(node) stack += list(graph[node] - visited) return visited components = [] k = set(graph.keys()) while k: node = k.pop() visited = dfs(graph, node) components.append(visited) k -= visited t = [len(i) for i in components] count = 0 l = 0 for j in range(len(t) - 1, 0, -1): l += t[j] count += t[j-1]*l print(count)

UTF-8

Python

py

journey-to-the-moon.py

thezakman/CTF-Heaven

1ec931a68014f43f01740a6bae8565707aad0dc3

6deafbf6257a5c30f084c3678712235c2c31a686

/Toolz/binwalk/src/binwalk/modules/entropy.py

4deeac525015f5c3e5672004e37ac0fd483435af

permissive

https://github.com/thezakman/CTF-Heaven

53fcb4a72afa821ad05d8cc3b309fb388f958163

4b52a2178922f1502ab00fa8fc156d35e1dc653f

refs/heads/master

Unlicense

Python

# Calculates and optionally plots the entropy of input files. import os import math import zlib import binwalk.core.common from binwalk.core.compat import * from binwalk.core.module import Module, Option, Kwarg class Entropy(Module): XLABEL = 'Offset' YLABEL = 'Entropy' XUNITS = 'B' YUNITS = 'E' FILE_WIDTH = 1024 FILE_FORMAT = 'png' COLORS = ['g', 'r', 'c', 'm', 'y'] DEFAULT_BLOCK_SIZE = 1024 DEFAULT_DATA_POINTS = 2048 DEFAULT_TRIGGER_HIGH = .95 DEFAULT_TRIGGER_LOW = .85 TITLE = "Entropy" ORDER = 8 # TODO: Add --dpoints option to set the number of data points? CLI = [ Option(short='E', long='entropy', kwargs={'enabled': True}, description='Calculate file entropy'), Option(short='F', long='fast', kwargs={'use_zlib': True}, description='Use faster, but less detailed, entropy analysis'), Option(short='J', long='save', kwargs={'save_plot': True}, description='Save plot as a PNG'), Option(short='Q', long='nlegend', kwargs={'show_legend': False}, description='Omit the legend from the entropy plot graph'), Option(short='N', long='nplot', kwargs={'do_plot': False}, description='Do not generate an entropy plot graph'), Option(short='H', long='high', type=float, kwargs={'trigger_high': DEFAULT_TRIGGER_HIGH}, description='Set the rising edge entropy trigger threshold (default: %.2f)' % DEFAULT_TRIGGER_HIGH), Option(short='L', long='low', type=float, kwargs={'trigger_low': DEFAULT_TRIGGER_LOW}, description='Set the falling edge entropy trigger threshold (default: %.2f)' % DEFAULT_TRIGGER_LOW), ] KWARGS = [ Kwarg(name='enabled', default=False), Kwarg(name='save_plot', default=False), Kwarg(name='trigger_high', default=DEFAULT_TRIGGER_HIGH), Kwarg(name='trigger_low', default=DEFAULT_TRIGGER_LOW), Kwarg(name='use_zlib', default=False), Kwarg(name='display_results', default=True), Kwarg(name='do_plot', default=True), Kwarg(name='show_legend', default=True), Kwarg(name='block_size', default=0), ] # Run this module last so that it can process all other module's results # and overlay them on the entropy graph PRIORITY = 0 def init(self): self.HEADER[-1] = "ENTROPY" self.max_description_length = 0 self.file_markers = {} self.output_file = None if self.use_zlib: self.algorithm = self.gzip else: self.algorithm = self.shannon # Get a list of all other module's results to mark on the entropy graph for (module, obj) in iterator(self.modules): for result in obj.results: if result.plot and result.file and result.description: description = result.description.split(',')[0] if not has_key(self.file_markers, result.file.name): self.file_markers[result.file.name] = [] if len(description) > self.max_description_length: self.max_description_length = len(description) self.file_markers[result.file.name].append((result.offset, description)) # If other modules have been run and they produced results, don't spam # the terminal with entropy results if self.file_markers: self.display_results = False if not self.block_size: if self.config.block: self.block_size = self.config.block else: self.block_size = None def _entropy_sigterm_handler(self, *args): print ("Fuck it all.") def run(self): self._run() def _run(self): # Sanity check and warning if matplotlib isn't found if self.do_plot: try: # If we're saving the plot to a file, configure matplotlib # to use the Agg back-end. This does not require a X server, # allowing users to generate plot files on headless systems. if self.save_plot: import matplotlib as mpl mpl.use('Agg') import matplotlib.pyplot as plt except ImportError as e: binwalk.core.common.warning("Failed to import matplotlib module, visual entropy graphing will be disabled") self.do_plot = False for fp in iter(self.next_file, None): if self.display_results: self.header() self.calculate_file_entropy(fp) if self.display_results: self.footer() def calculate_file_entropy(self, fp): # Tracks the last displayed rising/falling edge (0 for falling, 1 for # rising, None if nothing has been printed yet) last_edge = None # Auto-reset the trigger; if True, an entropy above/below # self.trigger_high/self.trigger_low will be printed trigger_reset = True # Clear results from any previously analyzed files self.clear(results=True) # If -K was not specified, calculate the block size to create # DEFAULT_DATA_POINTS data points if self.block_size is None: block_size = fp.size / self.DEFAULT_DATA_POINTS # Round up to the nearest DEFAULT_BLOCK_SIZE (1024) block_size = int(block_size + ((self.DEFAULT_BLOCK_SIZE - block_size) % self.DEFAULT_BLOCK_SIZE)) else: block_size = self.block_size # Make sure block size is greater than 0 if block_size <= 0: block_size = self.DEFAULT_BLOCK_SIZE binwalk.core.common.debug("Entropy block size (%d data points): %d" % (self.DEFAULT_DATA_POINTS, block_size)) while True: file_offset = fp.tell() (data, dlen) = fp.read_block() if dlen < 1: break i = 0 while i < dlen: entropy = self.algorithm(data[i:i + block_size]) display = self.display_results description = "%f" % entropy if not self.config.verbose: if last_edge in [None, 0] and entropy > self.trigger_low: trigger_reset = True elif last_edge in [None, 1] and entropy < self.trigger_high: trigger_reset = True if trigger_reset and entropy >= self.trigger_high: description = "Rising entropy edge (%f)" % entropy display = self.display_results last_edge = 1 trigger_reset = False elif trigger_reset and entropy <= self.trigger_low: description = "Falling entropy edge (%f)" % entropy display = self.display_results last_edge = 0 trigger_reset = False else: display = False description = "%f" % entropy r = self.result(offset=(file_offset + i), file=fp, entropy=entropy, description=description, display=display) i += block_size if self.do_plot: self.plot_entropy(fp.name) def shannon(self, data): ''' Performs a Shannon entropy analysis on a given block of data. ''' entropy = 0 if data: length = len(data) seen = dict(((chr(x), 0) for x in range(0, 256))) for byte in data: seen[byte] += 1 for x in range(0, 256): p_x = float(seen[chr(x)]) / length if p_x > 0: entropy -= p_x * math.log(p_x, 2) return (entropy / 8) def gzip(self, data, truncate=True): ''' Performs an entropy analysis based on zlib compression ratio. This is faster than the shannon entropy analysis, but not as accurate. ''' # Entropy is a simple ratio of: <zlib compressed size> / <original # size> e = float(float(len(zlib.compress(str2bytes(data), 9))) / float(len(data))) if truncate and e > 1.0: e = 1.0 return e def plot_entropy(self, fname): try: import matplotlib.pyplot as plt except ImportError as e: return i = 0 x = [] y = [] plotted_colors = {} for r in self.results: x.append(r.offset) y.append(r.entropy) fig = plt.figure() # axisbg is depreciated, but older versions of matplotlib don't support facecolor. # This tries facecolor first, thus preventing the annoying depreciation warnings, # and falls back to axisbg if that fails. try: ax = fig.add_subplot(1, 1, 1, autoscale_on=True, facecolor='black') except AttributeError: ax = fig.add_subplot(1, 1, 1, autoscale_on=True, axisbg='black') ax.set_title(self.TITLE) ax.set_xlabel(self.XLABEL) ax.set_ylabel(self.YLABEL) ax.plot(x, y, 'y', lw=2) # Add a fake, invisible plot entry so that offsets at/near the # minimum x value (0) are actually visible on the plot. ax.plot(-(max(x)*.001), 1.1, lw=0) ax.plot(-(max(x)*.001), 0, lw=0) if self.show_legend and has_key(self.file_markers, fname): for (offset, description) in self.file_markers[fname]: # If this description has already been plotted at a different offset, we need to # use the same color for the marker, but set the description to None to prevent # duplicate entries in the graph legend. # # Else, get the next color and use it to mark descriptions of # this type. if has_key(plotted_colors, description): color = plotted_colors[description] description = None else: color = self.COLORS[i] plotted_colors[description] = color i += 1 if i >= len(self.COLORS): i = 0 ax.plot([offset, offset], [0, 1.1], '%s-' % color, lw=2, label=description) ax.legend(loc='lower right', shadow=True) if self.save_plot: self.output_file = os.path.join(os.getcwd(), os.path.basename(fname)) + '.png' fig.savefig(self.output_file) else: plt.show()

UTF-8

Python

py

entropy.py

UCL/scikit-surgeryfred

91144c003b68fb54829a2c2c9451fbc2bd2c7dda

4f5303dd2dcfc1ab60f3147ab68eb82d83d31696

/get_results.py

a0d07493d2ab9895cf8b97e0481b8415e4105e9c

permissive

https://github.com/UCL/scikit-surgeryfred

a599591ab0b84b38c5dc4c945fa534372a6b93bc

3e22fc8b9d0898502a5f8a6c8cc813dc62fc3fd5

refs/heads/master

NOASSERTION

Python

from sksurgeryfred.utilities.get_results import get_results get_results()

UTF-8

Python

py

get_results.py

tsushiy/competitive-programming-submissions

2e2c905ce277492c944d24130486d1f117fd71f4

16d159d6d3fe69d513717caad3e2c21320f93224

/AtCoder/ABC/ABC101-150/abc134/abc134d.py

b76a6ee76b6079dc4edbb121de2952045048c509

no_license

https://github.com/tsushiy/competitive-programming-submissions

d4f068a5157c0de0f1822367e0ca66dd978e43f9

9011d855d9252134179cc9cc8f328f6e0ca32407

refs/heads/master

n = int(input()) a = list(map(int, input().split())) c = [0 for i in range(n)] for i in range(n, n//2, -1): if a[i-1]: c[i-1] = 1 for i in range(n//2, 1, -1): t = i tt = 0 cnt = 1 while t<=n: tt += c[t-1] cnt += 1 t = i*cnt if (a[i-1]==1 and tt%2==0) or (a[i-1]==0 and tt%2==1): c[i-1] = 1 ttt = sum(c) if (ttt%2==0 and a[0]==1) or (ttt%2==1 and a[0]==0): c[0] = 1 ttt += 1 #print(c) ans = [] for i in range(n): if c[i]: ans.append(i+1) print(ttt) if ttt: print(*ans)

UTF-8

Python

py

abc134d.py

EEmery/anomaly-detection

55775fde7d9fdb14ba0632da6f0d39845322c27e

94a27c14e31aeac3fe16980240e19634837679a8

/Google Maps/google-maps-API.py

6050b04f953f7b1d95f20aa880c1f2d9a44d91d7

no_license

https://github.com/EEmery/anomaly-detection

73762045eb317f0dc565f1199b28c61ce8fe1756

3fbb098ea483c85a7f0bec46ca33c3b3b417dbbf

refs/heads/master

import googlemaps, requests, json from datetime import datetime # Reads the Google API key safely google_API_key_file = open('googleAPI-key.txt', 'r') google_API_key = google_API_key_file.read() google_API_key_file.close() # Set up the Google API gmaps = googlemaps.Client(key=google_API_key) # Makes a simple request geocode_result = gmaps.geocode('1600 Amphitheatre Parkway, Mountain View, CA') # Saves result response_file = open('response.json', 'w') response = json.dump(geocode_result, response_file) response_file.close()

UTF-8

Python

py

google-maps-API.py

certifiedloud/clido

6bd982bb2f2fb788311058fa5e49a6dec02e28a6

24f409902cb56e352f175100c154f1c31c29ab1a

/clido.py

af05f0cf4a45a318108f8ec59475719cd0eda4be

permissive

https://github.com/certifiedloud/clido

09a177de877c83057fd81419a302f2c035d071e5

eddccbf8b3443e4fb6869c20c22a040086b2989e

refs/heads/master

import argparse from tabulate import tabulate import sys from os.path import expanduser try: import digitalocean except ImportError: print("python-digitalocean is required. pip install it and try again") # Set the API token for authenticated interaction # TODO cycle through a list of tokens to avoid rate limiting config_file = expanduser('~') + '/.clido.cfg' f = open(config_file, 'r') api_token = f.readline().split('=')[1].strip() # Initialize the API do = digitalocean.Manager(token=api_token) # Use argparse to set all of the CLI options description = """ Interact with your DigitalOcean account through their API. When run without any arguments, you simply get a list of all the active droplets in the specified account """ parser = argparse.ArgumentParser(description=description) parser.add_argument('operand', help="specify one of the following: " "droplets, domains, images, sizes, regions, keys.") parser.add_argument('-c', '--create', action="store_true", help="create droplet. -c -n <name> -s <size>" "-i <image> -r <region>") parser.add_argument('-d', '--destroy', help="destroy <operand> by <id>") parser.add_argument('-n', '--name', help="name of droplet to create") parser.add_argument('-u', '--update-domain', action="store_true", help="update specifc domain with a record") parser.add_argument('-a', '--ip-address', help="Specify ip address for domain creation") parser.add_argument('-s', '--size', help="size-slug of droplet to create") parser.add_argument('-i', '--image', help="image-slug of droplet to create") parser.add_argument('-r', '--region', help="region-slug of droplet to create") parser.add_argument('-k', '--ssh-keys', default=[], nargs='+', type=int, help="list of ssh key id's to add to new droplets") parser.add_argument('-l', '--lookup', help="lookup details of <operand> by <id>") args = parser.parse_args() if args.operand == 'sizes': sizes = do.get_all_sizes() for size in sizes: print(size) elif args.operand == 'regions': # Print a detailed list of available regions regions = do.get_all_regions() for region in regions: print("{}({})".format(region, region.slug)) sys.exit(0) elif args.operand == 'keys': keys = do.get_all_sshkeys() for key in keys: print(key) elif args.operand == 'images': images = do.get_all_images() for image in images: print("{}({})".format(image, image.slug)) elif args.operand == 'droplets': # check if we want to destroy a droplet if args.destroy: try: droplet_to_destroy = do.get_droplet(args.destroy) droplet_to_destroy.destroy() sys.exit(0) except Exception as e: print("Unable to destroy droplet: {}".format(e)) sys.exit(1) droplets = do.get_all_droplets() for droplet in droplets: print(droplet) elif args.operand == 'domains': # check if we want to create a domain if args.create: if not args.name and not args.ip_address: parser.error("In order to create a domain you must specify both " "--name and --ip-address") sys.exit(1) else: try: domain = digitalocean.Domain(token=api_token, name=args.name, ip_address=args.ip_address).create() sys.exit(0) except Exception as e: print("Unable to create domain: {}".format(e)) sys.exit(1) # check if we want to destroy a domain if args.destroy: try: digitalocean.Domain(token=api_token, name=args.destroy).destroy() sys.exit(0) except Exception as e: print("Couldn't destroy domain: {}".format(e)) sys.exit(1) # Check if we want to update existing domain if args.update_domain: if not args.name: print("You must specify -n, which domain to update") sys.exit(1) # TODO finish domain record updating if args.lookup: domain = digitalocean.Domain(token=api_token, name=args.lookup) records = domain.get_records() record_list = [] for record in records: record_list.append({"Type": record.type, "Priority": record.priority, "Name": record.name, "Data": record.data, "ID": record.id}) print(tabulate(record_list, headers='keys', stralign='center')) sys.exit(0) # If nothing else, just print a list of domains domains = do.get_all_domains() for domain in domains: print(domain) else: print("{} is not a valid operand, please choose one of the following:" .format(args.operand)) print("droplets, domains, keys, regions, sizes, images.")

UTF-8

Python

py

clido.py

jiluhu/dirtysalt.github.io

c4fee36cd15e55edd0db56c00b1940a04bf57929

9099ed0407521ac40b88f3b92872307f66c57bf9

/codes/contest/leetcode/subsets-ii.py

673281f982e936ee7749215f53f3052e1bd2aa83

no_license

https://github.com/jiluhu/dirtysalt.github.io

0cea3f52d2c4adf2bbf5c23b74f4cb1070025816

c026f2969c784827fac702b34b07a9268b70b62a

refs/heads/master

#!/usr/bin/env python # coding:utf-8 # Copyright (C) dirlt class Solution(object): def subsetsWithDup(self, nums): """ :type nums: List[int] :rtype: List[List[int]] """ from collections import defaultdict d = defaultdict(int) for n in nums: d[n] += 1 keys = list(d.keys()) res = [[]] for k in keys: res2 = [] for v in range(0, d[k] + 1): for r in res: res2.append([k] * v + r) res = res2 return res

UTF-8

Python

py

subsets-ii.py

Torniojaws/vortech-backend

867a2b985540a16c03883cca0021ae1eeed7492b

5794c1dd7e8ec0ec279ea72c22ccd0cec2f8ead0

/migrations/versions/0894a7be87c8_added_videos_model.py

32163c7e934b9c99c475705c2ae477d3ebd20886

permissive

https://github.com/Torniojaws/vortech-backend

7c4365e232cab9dfe5abebd3a544f2e2bba49e91

62f8e8e904e379541193f0cbb91a8434b47f538f

refs/heads/master

MIT

Python

"""Added Videos model Revision ID: 0894a7be87c8 Revises: d255000b4aa6 Create Date: 2017-09-25 23:09:13.516907 """ from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = '0894a7be87c8' down_revision = 'd255000b4aa6' branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('VideoCategories', sa.Column('VideoCategoryID', sa.Integer(), nullable=False), sa.Column('Category', sa.String(length=200), nullable=False), sa.PrimaryKeyConstraint('VideoCategoryID') ) op.create_table('Videos', sa.Column('VideoID', sa.Integer(), nullable=False), sa.Column('Title', sa.String(length=200), nullable=False), sa.Column('URL', sa.Text(), nullable=False), sa.Column('Created', sa.DateTime(), nullable=True), sa.Column('Updated', sa.DateTime(), nullable=True), sa.PrimaryKeyConstraint('VideoID') ) op.create_table('VideosCategoriesMapping', sa.Column('VideosCategoriesMappingID', sa.Integer(), nullable=False), sa.Column('VideoID', sa.Integer(), nullable=False), sa.Column('VideoCategoryID', sa.Integer(), nullable=False), sa.ForeignKeyConstraint(['VideoCategoryID'], ['VideoCategories.VideoCategoryID'], ), sa.ForeignKeyConstraint(['VideoID'], ['Videos.VideoID'], ondelete='CASCADE'), sa.PrimaryKeyConstraint('VideosCategoriesMappingID') ) # ### end Alembic commands ### def downgrade(): # ### commands auto generated by Alembic - please adjust! ### op.drop_table('VideosCategoriesMapping') op.drop_table('Videos') op.drop_table('VideoCategories') # ### end Alembic commands ###

UTF-8

Python

py

0894a7be87c8_added_videos_model.py

Tanushree28/12-Python-Projects

20e66f99632fc2c8a1f88729484f5e0ccaf60328

b5d4d92c16dfc69f6d8235b9b22530c4b407f6df

/Madlib/madlibs.py

aeb1ffa0981454d62090f670f9fb55a4c1bdfd76

no_license

https://github.com/Tanushree28/12-Python-Projects

28277af8b4284af25ffb2e9848d250cf6b416778

60c2c2ef071ebb8d8d0203fe9f5a9b2b1cb0e7e0

refs/heads/master

#string concatenation(put strings together) #suppose we want to create string that says "subscribe to __" #youtuber = "Coder" #some string variable #a few ways to do this #print("subscribe to " + youtuber) #print("subscribe to {}".format(youtuber)) #in the curly braces the value of youtuber is placed #print(f"subscribe to {youtuber}") #app string adj = input("Adjective: ") verb1 = input("Verb: ") verb2 = input("Verb: ") famous_person = input("Famous Person: ") madlib = f"Computer programming is so {adj}! It makes me so excited all the times because I love to {verb1}. Stay hydrarted and {verb2} like you are {famous_person}!" print(madlib)

UTF-8

Python

py

madlibs.py

simtb/coding-puzzles

bfbc50a2c2a1eb41eb8848844092cb09f7eef1bd

942f0b081d2271978ffe20fbbfa8d687b57e5c02

/coding_problems/tests/test_flattening_a_linked_list.py

7ce85443a4032f39d868595c375e779acd65047d

no_license

https://github.com/simtb/coding-puzzles

99762322606bb505d82924d4d5843db1c04aafbd

9e1d53e35b2117240eb357d7930cdb8cfd891c8e

refs/heads/master

import unittest from problems.flattening_a_linked_list import Node, solution_1 class TestSolution1(unittest.TestCase): head = Node(5) head.bottom = Node(7) head.bottom.bottom = Node(8) head.bottom.bottom.bottom = Node(30) head.next = Node(10) head.next.bottom = Node(20) head.next.next = Node(19) head.next.next.bottom = Node(22) head.next.next.bottom.bottom = Node(50) head.next.next.next = Node(28) head.next.next.next.bottom = Node(35) head.next.next.next.bottom.bottom = Node(40) head.next.next.next.bottom.bottom.bottom = Node(45) def test_empty_string(self): test_head = None output = solution_1(test_head) self.assertEqual(output, None) def test_example(self): test_head = self.head output = solution_1(test_head) self.assertEqual(output.value, 5) self.assertEqual(output.next.value, 7) self.assertEqual(output.next.next.value, 8) self.assertEqual(output.next.next.next.value, 10) self.assertEqual(output.next.next.next.next.value, 19) self.assertEqual(output.next.next.next.next.next.value, 20) self.assertEqual(output.next.next.next.next.next.next.value, 22) self.assertEqual(output.next.next.next.next.next.next.next.value, 28) self.assertEqual(output.next.next.next.next.next.next.next.next.value, 30) self.assertEqual(output.next.next.next.next.next.next.next.next.next.value, 35) self.assertEqual(output.next.next.next.next.next.next.next.next.next.next.value, 40) self.assertEqual(output.next.next.next.next.next.next.next.next.next.next.next.value, 45) self.assertEqual(output.next.next.next.next.next.next.next.next.next.next.next.next.value, 50) self.assertEqual(output.next.next.next.next.next.next.next.next.next.next.next.next.next, None) if __name__ == "__main__": unittest.main()

UTF-8

Python

py

test_flattening_a_linked_list.py

uwaces/DAGit

8847ffa9875483ba49d448ac49a2082df91878ee

a2a0a918fb382174cc36d25adb214a429d478df5

/src/kirkpatrick/git_dag.py

216be89bb0de41d6dfc742b225593a11792c9cc2

no_license

https://github.com/uwaces/DAGit

d9305d7219a39c5430cb151cda4368aa7c5b6c9f

7f93cd376c6becdbe50530a9d6ad82d7c6cf06ff

refs/heads/master

import git class DAG: def __init__(self, root=None): self.adj_list = dict() self.root = root def __str__(self): ret = "==================================" ret += "\nDAG ADJACENCY LIST:\n" for x in self.adj_list.keys(): ret += str(x) + " maps to: [" for y in self.adj_list[x]: ret += str(y) + ", " ret += "] \n" ret += "==================================" return ret def add_root(self, elem): if elem not in self.adj_list.keys(): self.adj_list[elem] = set() self.root = elem def add_directed_edge(self, v1, v2): if v1 not in self.adj_list: self.adj_list[v1] = set() self.adj_list[v1].add(v2) if v2 not in self.adj_list: self.adj_list[v2] = set() def children(self, elem): return self.adj_list[elem] def biuld_git(self, filepath): """ make a new repo with git at the filepath make a branch for each child in the adj_list copy adj_list until adj_list copy is empty... remove children from adj_list copy (including the references in other nodes) for each child in copy - merge branches -- and overwrite merge conflict with new triangle """ pass # Use condition_fun to trace to bottom def find_leaf_where(self, condition_fun): if not condition_fun(self.root): return None cur = self.root while len(self.children(cur)) > 0: for v in self.children(cur): if condition_fun(v): cur = v break return cur

UTF-8

Python

py

git_dag.py

jdixosnd/jsonl-to-conll

4ae49bce35a1903ad621b2d2edaa8c3cb96f1f5c

178f33d92ac6a8ff1c67797183de070a69857f08

/jsonl_to_conll/convert.py

f7dfa2ab65a785592eb199ded0439996a9a940bc

permissive

https://github.com/jdixosnd/jsonl-to-conll

7be3819261180c0e335df31b0cc2d473492cb6a8

3a7c14b7f0cb362abe6b9ddd0ab93d59e12078da

refs/heads/master

Apache-2.0

import json def flatten(data): output_text = [] beg_index = 0 end_index = 0 text = data["text"] all_labels = sorted(data["labels"]) for ind in range(len(all_labels)): next_label = all_labels[ind] output_text += [(label_word, "O") for label_word in text[end_index:next_label[0]].strip().split()] label = next_label beg_index = label[0] end_index = label[1] label_text = text[beg_index:end_index] output_text += [(label_word, "B-" + label[2]) if not i else (label_word, "I-" + label[2]) for i, label_word in enumerate(label_text.split(" "))] output_text += [(label_word, "O") for label_word in text[end_index:].strip().split()] return output_text def flatten_all(datas): return [flatten(data) for data in datas]

UTF-8

Python

py

convert.py

awalshz/masterMemory

6ca7ccbd2e655ad0ebff17139719ae3cbf8fdc94

7c9bd321297a18f99ff069f47492fcb366e535bd

/Memoire.VersionFinal/Population_homogene/comportemental/choix_fenetre.py

76c5841036fd7a36f71aaee3387589647fbf0788

no_license

https://github.com/awalshz/masterMemory

180c84cb55033dd96d25c1aab0de5687ef099037

c524231c3cde000eb1c4fbfa8a12c3ba8db87f91

refs/heads/master

from stock_pel import stock_pel import pandas as pd import numpy as np import time from non_parametric_regression import Kernel # ============================================================================== # choisir fenetre de lissage pour le taux de cloture. # ============================================================================== print('Computing R2 for taux cloture') t0 = time.time() X = stock_pel.values[:, 0:2] encours = stock_pel.values[:, 2] clotures = stock_pel.values[:, 4] tx_cloture = clotures / encours # On fait une grille avec possibles choises de fenetres h. Chaque entree aura # le coeficient R2 pour le test_data. On choisi la fenetre que maximise le R2. grille = pd.DataFrame(index=range(1, 12), columns=[x / 200 for x in range(2, 11)]) RS = np.random.RandomState(13062013) model = Kernel(X=X, Y=tx_cloture, RS=RS) for h1 in grille.index: for h2 in grille.columns: print(f'Clotures: computing R2 for h=[{h1},{h2}]') grille[h2][h1] = model.R2(h=[h1, h2]) grille.to_csv('grille_clotures.csv') t1 = time.time() print(f'on a finit avec les clotures en {t1-t0:.2f} secondes \n') # ============================================================================== # choisir fenetre de lissage pour le taux de versement. # ============================================================================== print('Computing R2 for taux versement') stock_pel = stock_pel[stock_pel['age'] < 120] X = stock_pel.values[:, 0:2] encours = stock_pel.values[:, 2] versements = stock_pel.values[:, 3] tx_versement = versements / encours RS = np.random.RandomState(13062013) model = Kernel(X=X, Y=tx_versement, RS=RS) for h1 in grille.index: for h2 in grille.columns: print(f'Versements: computing R2 for h=[{h1},{h2}]') grille[h2][h1] = model.R2(h=[h1, h2]) grille.to_csv('grille_versements.csv') t2 = time.time() print(f'on a finit avec les versements en {t2-t1:.2f} secondes \n') # ============================================================================ # Comentaire : d'apres les grilles de lissage, on n'a pas aucune doute que le # meilleur choix de h1 ( la fentre de lissage pour la variable age ) est h1 = # 1 mois. Pour la ecart de taux, s'est pas tres claire, car les valeurs de R2 # sont tres proches et peut dependre du decoupage aleatoire choisi. Dans le # fichier choix_h2.py on fixe h1 = 1 et on calcule R2 pour plusieurs decoupages # aleatoires et plusieurs valeurs de h2

UTF-8

Python

py

choix_fenetre.py

folomeev1980/kwork_64

b46a17db47f9c08339cedb8681462181b3b89c05

f30653d6e808879f97d52dc1443d10783f4982e6

/RosMed3/doctorsCvs2.py

87585776049ed474f670547dd3408aa29aac3b02

no_license

https://github.com/folomeev1980/kwork_64

6786cbe76a36e90a293f016c5c07cb7af66c278b

47169fb64b5bde5436a39469b8bb3e88a0da360d

refs/heads/master

Python

import requests import csv from bs4 import BeautifulSoup from selenium import webdriver from bs4 import BeautifulSoup from random import randint from time import sleep from progress.bar import Bar from openpyxl import Workbook, load_workbook def lst(l): s = "" for i in l: s = s + i + "####" return (s) def create_csv(): header = tuple(["Словарная метка", "ФИО", "Организация, проводящая КИ", "Код врача", "День рождения врача"]) with open("dbs\\doctors.csv", "w", newline='', encoding='utf-8') as f: writer = csv.writer(f, delimiter=';') #writer.writerow(header) def get_html_(url): page = "" while page == '': try: headers = { 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.84 Safari/537.36'} page = requests.get(url, headers=headers) return page.text break except: print("Connection refused by the doctor server..") print("Let me sleep for 10 seconds") # print("ZZzzzz...") sleep(10) # print("Was a nice sleep, now let me continue...") continue def get_list_of_doctors(url): list_of_doctors = [] # print(url) if url != "": clinics = get_html_(url) soup = BeautifulSoup(clinics, "lxml") try: tds = soup.find("table", class_="ts1").findAll("tr", class_="hi_sys") for td in tds: temp = td.findAll("td") # print(temp) a = (temp[-2].text.strip().split("-")) b = (temp[-1].text.strip().split()[1][1:]) c = temp[2] c = str(c).split(">")[1] c = c.split("<")[0].strip() list_of_doctors.append([a[0], a[1], b, c]) # print(list_of_doctors) except Exception as e: # print(e, "except by list of doctors",url) list_of_doctors = [] return list_of_doctors else: return list_of_doctors def get_append_list_of_doctors(url): list_of_doctors = [] try: options = webdriver.ChromeOptions() options.add_argument('headless') options.add_argument('window-size=1920x935') driver = webdriver.Chrome('chromedriver.exe', options=options) driver.get(url) except Exception as e: driver.quit() k = 2 while True: try: # print("ok") page = "/html/body/form/table/tbody/tr/td/table/tbody/tr[3]/td/div[2]/table/tbody/tr[3]/td/div/table/tbody/tr[22]/td/table/tbody/tr/td[{}]/a".format( k) driver.find_element_by_xpath(page).click() html = driver.page_source # print(html) soup = BeautifulSoup(html, "lxml") tds = soup.find("table", class_="ts1").findAll("tr", class_="hi_sys") for td in tds: temp = td.findAll("td") c = temp[2] c = str(c).split(">")[1] c = c.split("<")[0].strip() a = (temp[-2].text.strip().split("-")) b = (temp[-1].text.strip().split()[1][1:]) list_of_doctors.append([a[0], a[1], b, c]) k = k + 1 # time.sleep(2) except Exception as e: # print("End pages",e) break # driver.quit() driver.quit() return list_of_doctors def get_info_for_each_page_(html): list_dics = [] soup = BeautifulSoup(html, "lxml") list_of_page = (soup.findAll("tr", class_="hi_sys poi")) # print(list_of_page) for st, page in enumerate(list_of_page): dic = {} list_some = [] try: doctor_link = "https://grls.rosminzdrav.ru/" + \ page.get("onclick").split("'")[1] doctors_list = get_list_of_doctors(doctor_link) except: doctors_list = [] try: page_data = page.findAll("td") for td in page_data: list_some.append(td.text.strip()) # print(list_some[6]) if int(list_some[6]) <= 20: list_some.append(doctors_list) else: list_some.append(doctors_list) # print(doctor_link) list_some[-1].extend(get_append_list_of_doctors(doctor_link)) # print(list_some) dic["code"] = list_some[1] dic["famaly"] = list_some[2] dic["name"] = list_some[3] dic["fathername"] = list_some[4] dic["numer_of_ki"] = list_some[6] dic["birthday"] = list_some[7] dic["doctors_list"] = list_some[8] # print(dic) list_dics.append(dic) except Exception as e: print(e, "Ошибка ") dic = {} list_dics.append(dic) return list_dics def writer_csv(data): for dic in data: for j in dic["doctors_list"]: with open("dbs\\doctors.csv", "a", newline='', encoding='utf-8') as f: writer = csv.writer(f, delimiter=';') a = "{} {} {}".format(dic["famaly"], dic["name"], dic["fathername"]) b = "{}_{}_{}".format(j[0], j[1], j[2]) c = j[-1] d = dic["code"] e = dic["birthday"] writer.writerow((b, a, c, d, e)) def cvs_doctors(): i = 1 k = 0 sum = 0 create_csv() while True: try: url = "https://grls.rosminzdrav.ru/ciexperts.aspx?F=&N=&P=&D=&ExpertID=&order=fio&orderType=desc&moduleId=2&pageSize=30&pageNum={}".format( i) html = get_html_(url) list_of_dics_one_page = get_info_for_each_page_(html) if len(list_of_dics_one_page) == 0: k = k + 1 sum = sum + len(list_of_dics_one_page) writer_csv(list_of_dics_one_page) i = i + 1 print(sum) if k > 5: break except Exception as e: if k > 5: break print(i, "Pages\n", sum, "Doctors") def excel_doctors(): book_new = Workbook() dic = {} sheet_new = book_new.active header = tuple(["ID_PI", "FIO", "Organization", "Email", "Phone", "VK", "Facebook", "Instagram", "Birthday", ]) sheet_new.append(header) with open('dbs\\doctors.csv', newline='', encoding='utf-8') as csv_file_clinics: csv_reader_clinics = csv.reader(csv_file_clinics, delimiter=';') for i in csv_reader_clinics: #print(lst(i[1:])) dic[lst(i[1:])]=None # try: # i=[i[3],i[1],i[2],"","","","","",i[4]] # # sheet_new.append(i) # except: # pass for k in dic: try: i=k.split("####")[0:-1] i = [i[2], i[0], i[1], "", "", "", "", "", i[3]] #print(i) sheet_new.append(i) except: pass # print(k.split("####")[0:]) #sheet_new.append() book_new.save("final_xls_tables\\PI.xlsx") if __name__ == "__main__": excel_doctors() # cvs_doctors()

UTF-8

Python

py

doctorsCvs2.py

freelancer1845/rsockets2-try

f61dbfc6276b7339ef1418511c0536b658402737

a56a8fce70036f2c40d9090077450a83b27173d1

/rsockets2/frames/frame_abc.py

91adb9d1943bfff3288bfd9d77bc53ff3c6df38d

permissive

https://github.com/freelancer1845/rsockets2-try

c68be4853d2d0b3bf05b32a235dcba01419029bf

25b8b38e00925c3feb6c6e790624a35bc8689619

refs/heads/master

from abc import ABC, abstractmethod class Frame_ABC(ABC): def __init__(self): super().__init__() self.stream_id = 0 @abstractmethod def to_bytes(self): raise NotImplementedError() @classmethod @abstractmethod def from_data(cls, stream_id: int, flags: int, full_data: bytes): raise NotImplementedError()

UTF-8

Python

py

frame_abc.py

ashutoshdhondkar/basic-python

c1af1a82e22a24f74463695b12511853b83bfb18

d960ed6ede1e863d931489cca70662ee0703d7f7

/regexValidEmails.py

000767b442f7a2572471a90733a17ee1b3c39ddf

no_license

https://github.com/ashutoshdhondkar/basic-python

4bd7e37969e3145a15d99f2116f640825e1c7a0a

61e6d733b02f27670319d598b67c8f266ad68d63

refs/heads/master

# program to find valid email addresses import re emails = ["john@example.com", "pythonl985ist@python.org", "??%4ly@email.com",'abx@11.com'] pattern = re.compile("^[a-zA-Z0-9.?]+@\w+\.\w+") for line in emails: match = re.search(pattern,line) if(match): print(match.group(0))

UTF-8

Python

py

regexValidEmails.py

Shunichi09/RNN_practice

0300d656abab99eb62cad736462b8ea0f60f5370

11e3e5cbdd6c21fca1eb593ec7e376eb922e7451

/5th/RNN_ch5_main.py

903f7212c1eb4e77364381aa3b9cdc716396061c

no_license

https://github.com/Shunichi09/RNN_practice

df175aaf54825b100babd406f5fd52a5b638af26

1ebb3005dfe5f8fc7480dfcf4679168a1322df01

refs/heads/master

import sys sys.path.append('..') from NN_ch5 import SimpleRnnlm, SGD # , RnnlmTrainer from common import ptb # dataset読み込む用 import pandas as pd import numpy as np import matplotlib.pyplot as plt def main(): # ハイパーパラメータの設定 batch_size = 10 wordvec_size = 100 # Embeddingの大きさ hidden_size = 100 # 隠れ層の大きさ time_size = 5 # Truncated BPTTの展開する時間サイズ，RNNのステップ数 lr = 0.1 # 学習率 max_epoch = 100 # 最大epoch # 学習データの読み込み（データセットを小さくする） corpus, word_to_id, id_to_word = ptb.load_data('train') corpus_size = 1000 corpus = corpus[:corpus_size] # コーパス小さくします vocab_size = int(max(corpus) + 1) xs = corpus[:-1] # 入力，最後までは見ない ts = corpus[1:] # 出力（教師ラベル），最初は飛ばす data_size = len(xs) print('corpus size: %d, vocabulary size: %d' % (corpus_size, vocab_size)) # 学習時に使用する変数 max_iters = data_size // (batch_size * time_size) # 現実的に繰り返せる回数（データの数），ランダムに使うわけではない！！，今回は99 time_idx = 0 total_loss = 0 loss_count = 0 ppl_list = [] # モデルの生成 model = SimpleRnnlm(vocab_size, wordvec_size, hidden_size) optimizer = SGD(lr) # ミニバッチの各サンプルの読み込み開始位置を計算 jump = (corpus_size - 1) // batch_size offsets = [i * jump for i in range(batch_size)] print('max_iters = {0}'.format(max_iters)) print('offsets = {0}'.format(offsets)) for epoch in range(max_epoch): for iter in range(max_iters): # ミニバッチの取得 batch_x = np.empty((batch_size, time_size), dtype='i') batch_t = np.empty((batch_size, time_size), dtype='i') for t in range(time_size): for i, offset in enumerate(offsets): batch_x[i, t] = xs[(offset + time_idx) % data_size] # batch_t[i, t] = ts[(offset + time_idx) % data_size] # 今回はbatchを作ってもバッチ×時間×1かも time_idx += 1 print(time_idx) if time_idx > 200: sys.exit() # print('batch_t.shape = {0}'.format(batch_t.shape)) # print('batch_x.shape = {0}'.format(batch_x.shape)) # 勾配を求め、パラメータを更新 loss = model.forward(batch_x, batch_t) model.backward() optimizer.update(model.params, model.grads) total_loss += loss loss_count += 1 # エポックごとにパープレキシティの評価 ppl = np.exp(total_loss / loss_count) print('| epoch %d | perplexity %.2f' % (epoch+1, ppl)) ppl_list.append(float(ppl)) total_loss, loss_count = 0, 0 # グラフの描画 x = np.arange(len(ppl_list)) plt.plot(x, ppl_list, label='train') plt.xlabel('epochs') plt.ylabel('perplexity') plt.show() if __name__ == '__main__': main()

UTF-8

Python

py

RNN_ch5_main.py

Olo23/eth2.0-specs

dc012af335e5e5af46efcdb7272e290361741472

56e0576622b74f77c4d22269b1db7376b1f06d23

/tests/generators/fork_choice/main.py

f09bbcc0aa12c41819c526669be33a5def526f26

permissive

https://github.com/Olo23/eth2.0-specs

c0653bfde91978dc9016caccde1151ddda52afbf

0d22e08a7ec2c40c68d9813503cc01b32fbbd138

refs/heads/master

from eth2spec.gen_helpers.gen_from_tests.gen import run_state_test_generators from eth2spec.phase0 import spec as spec_phase0 from eth2spec.altair import spec as spec_altair from eth2spec.test.context import PHASE0, ALTAIR specs = (spec_phase0, spec_altair) if __name__ == "__main__": phase_0_mods = {key: 'eth2spec.test.phase0.fork_choice.test_' + key for key in [ 'get_head', ]} # No additional Altair specific finality tests, yet. altair_mods = phase_0_mods all_mods = { PHASE0: phase_0_mods, ALTAIR: altair_mods, } run_state_test_generators(runner_name="fork_choice", specs=specs, all_mods=all_mods)

UTF-8

Python

py

main.py

KamilJerzyWojcik/PopularPythonPackages

371af43020fa1344aee4840381ef216c90498f2e

93798867df24c2d469dd97783ff5eadc2b459e9f

/NumPyApp/main2.py

2b658154368371153e3a7fd272109de7aff26deb

no_license

https://github.com/KamilJerzyWojcik/PopularPythonPackages

79f568cf44a868bb9d6e6276270a86a7119e86f9

72d52a2759ae25c11024c372a2850158c9b5eb01

refs/heads/master

import numpy as np first = np.array([1, 2, 3]) second = np.array([1, 2, 3]) print(first + second) print(first + 2) dimensions_inch = np.array([1, 2, 3]) dimensions_cm = dimensions_inch * 2.54

UTF-8

Python

py

main2.py

ningliang/bagger

e860517cda36c6c4001b26ed168497c42b376115

054c3f0cb8a5046ccbd70c2fb228a934161af440

/steve/app/flags.py

76d8bd688433a5866c218b5905ab2c56cac1bc9d

no_license

https://github.com/ningliang/bagger

16049d96dd65ac863073bf49992d0fcfe6cb602c

075f3463d6319996399a46971a4da8f054fbf900

refs/heads/master

"""Methods to make app-level global definition of flags easy. TODO(fedele): write example usage. """ __author__ = 'stephen.fedele@gmail.com (Stephen Fedele)' # Note: you probably can't import the prelude here, # as that would set up a cyclic dependency? # from cobra.steve.util.prelude import * import optparse import re class FlagParser(object): def __init__(self): self.parser = optparse.OptionParser() self.options = None self.args = None def _DoParse(self): self.options, self.args = self.parser.parse_args() def __getattr__(self, attr): if attr.startswith("Define"): raise AttributeError, "Use 'flags.%s' instead of 'FLAGS.%s'" % (attr, attr) return getattr(self.options, attr) def _Define(self, value_type, flag_name, default, description): # TODO(fedele): output a reasonable error message here assert re.match(r'^[-A-Za-z_]+$', flag_name) self.parser.add_option("--%s" % flag_name, dest=flag_name, default=default, help=description, type=value_type) def _DefineString(self, *args, **kwargs): self._Define("string", *args, **kwargs) def _DefineInteger(self, *args, **kwargs): self._Define("int", *args, **kwargs) def _DefineFloat(self, *args, **kwargs): self._Define("float", *args, **kwargs) def _DefineBoolean(self, flag_name, default, description): # TODO(fedele): output a reasonable error message here assert re.match(r'^[-A-Za-z_]+$', flag_name) true_name = "--%s" % flag_name false_name = "--no%s" % flag_name self.parser.add_option(true_name, action="store_true", dest=flag_name, help=description) self.parser.add_option(false_name, action="store_false", dest=flag_name, default=default) FLAGS = FlagParser() DefineBoolean = FLAGS._DefineBoolean DefineString = FLAGS._DefineString DefineInteger = FLAGS._DefineInteger DefineFloat = FLAGS._DefineFloat DoParse = FLAGS._DoParse

UTF-8

Python

py

flags.py

bizzyvinci/project-euler

4e1f0fb5aba72ec6e70a8ea092c00f9ff854f1f2

c3523f94789d6f6e301f66f06938bcdf718afb49

/014.py

0637ea87d2e21db5ef1d80e352055db7e4460767

no_license

https://github.com/bizzyvinci/project-euler

382427a43a4d70ef7c535f2c3896ad49eef550f0

1b52c872beb9fa564dd1975b6292063fc297031e

refs/heads/master

''' Longest Collatz sequence(conjecture) Problem: Which starting number, under one million, produces the longest chain? NOTE: Once the chain starts the terms are allowed to go above one million. ''' from math import floor # This code is efficient because it saves every n that is solved in a dictionary def count_chain(n): if n in values: return values[n] if n%2==0: values[n]=1+count_chain(n/2) else: values[n]=2+count_chain((3*n+1)/2) return values[n] limit = 1000000 longest_chain = 0 answer = -1 values = {1:1} for x in range(floor(limit/2), limit): if count_chain(x)>longest_chain: longest_chain=count_chain(x) answer=x print(answer)

UTF-8

Python

py

014.py

manuelcarrizo/rss-filter

8d9f47be986c1d410528f96349d71cdf92da7cf9

67754d244493cd1a31b2a489be3fa8941c74eecb

/filter.py

61e8405575260bd3ab44377de65f47c3053ff6ff

no_license

https://github.com/manuelcarrizo/rss-filter

5372a8cda94a10e00c199b5706c5283af8bfe4bc

14173668d13758be55e2c41d5578370324ba60e9

refs/heads/master

import sys import os import json from urllib import request from defusedxml import ElementTree def usage(): print("python %s CONFIG_FILE" % __file__) print("Filters URL or FILE xml file with an RSS feed to remove entries that don't match the filters on config.json") def input(source): if source is None: data = sys.stdin.read() elif os.path.exists(source) and os.path.isfile(source): with open(source) as f: data = f.read() else: with request.urlopen(source, timeout=10) as f: data = f.read().decode('utf-8') return data def filter_xml(data, config): et = ElementTree.fromstring(data) channel = et.find("channel") for item in channel.findall("item"): title = item.find("title").text some_matches = False for filters in config["filters"]: some_matches = all(map(lambda w: w in title, tuple(filters["keys"]))) if some_matches: #if filters.get("category", None): # elem = '<qbCategory>%s</qbCategory>' % filters["category"] # item.append((ElementTree.fromstring(elem))) break if not some_matches: channel.remove(item) print(ElementTree.tostring(et).decode('utf-8')) if __name__ == "__main__": if len(sys.argv) != 2: usage() exit(1) config = {} with open(sys.argv[1], "r") as config_file: config = json.load(config_file) source = config.get("source", None) data = input(source) filter_xml(data, config)

UTF-8

Python

py

filter.py

qianpeng-qp/pytest1

0ab5f3c7d1094641c2d3da60f09682f457dea345

1c4fc7a849df519615b3ae41b7578f1e9fb4fe0d

/src/json_1/number_write1.py

7a9ca0096a501fa32c855f0b21b29510ee118b8a

no_license

https://github.com/qianpeng-qp/pytest1

889b223542f22d6f2121bd12aa2ee770f9ef460d

6eb3007547ddeabed07b46cecaaffde9d8e32e64

refs/heads/master