id stringlengths 20 20 | title stringclasses 1
value | text stringlengths 8 768k |
|---|---|---|
002d49f1215fe1e00b25 | def create_or_update(cls, **kwargs):
school = kwargs.get('school')
if cls.objects.filter(school=school).exists():
kwargs.pop('school')
cls.objects.filter(school=school).update(**kwargs)
else:
cls.objects.create(**kwargs)
return cls.objects.get(school=s... | |
002d4ed897a27f4fe36e | def get_public_ip(self):
try:
url_page = 'http://ipecho.net/plain'
public_ip = None
f = urllib.request.urlopen(url_page)
data = f.read().decode("utf8")
f.close()
pattern = re.compile('\d+\.\d+\.\d+\.\d+')
result = pattern.searc... | |
002d5afbe28eaf920d09 | def observe(self, observation, gameState):
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
# The following code first tackles part one of this problem and checks ... | |
002d615ea84bb67387db | def stop(self):
self.send('STOP') | |
002d6e9fcfcc23b4c506 | def bold(msg):
return u'\033[1m%s\033[0m' % msg | |
002d81ba75d717aac2f3 | def prod_view(request, prod):
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
prod = form.cleaned_data['research']
return redirect('/' + prod + '/')
else:
form = SearchForm()
else:
form = SearchForm()
list_p... | |
002d9495e9d1a02b9dd0 | def virtual_machine_extension_images(self):
return self._virtual_machine_extension_images | |
002daba8549b1d3316a5 | def get_similarity(df):
count = CountVectorizer()
count_matrix = count.fit_transform(df["bag_of_words"])
cosine_sim = cosine_similarity(count_matrix, count_matrix)
return cosine_sim | |
002e04aa64d71442a92c | def expandUniformByCellsCount(self, count, renumberDivision=True):
x, y, z = self.nDivXYZ
self.expandX((self.width / float(x)) * count)
self.expandY((self.length / float(y)) * count)
self.expandZ((self.height / float(z)) * count)
if renumberDivision:
self.nDivXY... | |
002e6b05cbe328b88e64 | def __getitem__(self, i):
if isinstance(i,int):
if i<0 or i>=self.__len__():
raise IndexError()
return FaceDatasetExample(self, i)
elif isinstance(i,slice):
return FaceImagesSubset(self,range(i.start, i.stop, i.step))
... | |
002e6f63cc54bd7691c2 | def openfile(file_path):
with open(file_path, 'r') as line:
array = line.read().split("\n")
return array | |
002e96be49c145874aa9 | def set_usage_rights(self, **kwargs):
response = self._requester.request(
"PUT",
"users/{}/usage_rights".format(self.id),
_kwargs=combine_kwargs(**kwargs),
)
return UsageRights(self._requester, response.json()) | |
002ec735f9711d5d771d | def reload_lb(self, search=""):
if search == "":
# If there is nothing searched, just return all patients
query = "SELECT * FROM Doctors"
doctors = self.window.query(query)
else:
search = "%" + search + "%"
query = "SELECT * FROM Doctors WHERE ... | |
002ece85c2fdc75034c7 | def range_values(self):
start, end = [int(x) for x in self.input.split('-')]
return [x for x in self._all_values if start <= x <= end] | |
002f0cb31b5cb18987c2 | def deal_card():
cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
card = random.choice(cards)
return card | |
002f893268571bfadbcf | def preprocess_data(self):
print("Preprocessing train data from csv files ...", end=' ')
data = pd.read_csv(os.path.join(self.path, 'train.csv'))
structures = pd.read_csv(os.path.join(self.path, 'structures.csv'))
data = data_prep.merge_data_with_structures(data, structures)
d... | |
002fa48fab6d3cb0ff6a | def clean_password2(self):
password1 = self.cleaned_data.get('password1')
password2 = self.cleaned_data.get('password2')
if password1 and password2 and password1 != password2:
raise forms.ValidationError(
self.error_messages['password_mismatch'],
code=... | |
002fd50074104e8f9f95 | def visit_subclass(self, node, children):
return children[0] | |
002fecc06a2b46ee1a4a | def filter_get(self, name):
cookie_name = '_'.join(['cheeze',name,'filter'])
regex = self._cookie_get(cookie_name)
if regex == '':
regex = self.regex_default
return regex | |
003033502912c47d34ce | def xr_3d_factory(
arr: np.ndarray, start_date: Optional[datetime] = None, freq: Optional[str] = None
) -> xr.Dataset:
assert arr.ndim == 3, "Can work only with 3 dimentional arrays"
assert not np.isnan(arr).any(), "The input data can't contain NaNs"
assert arr.shape[2] == 3, "The 2nd axis has to have d... | |
003063a664250dddc6cf | def normal_at(self, point):
return (point - self.center).normalized() | |
0030735295f6f3a31944 | def isprime(num):
if num == 1:
return "No"
for count in range(2, int(num ** 0.5) + 1):
if num % count == 0:
return "No"
return "Yes" | |
003080a80b68c89d7e94 | def min_replicas(self) -> Optional[int]:
return pulumi.get(self, "min_replicas") | |
00308f70f0a3178fcdc3 | def run(data_settings_yml):
import os
import yaml
import CPAC
print("\nGenerating data configuration file..")
settings_dct = yaml.safe_load(open(data_settings_yml, 'r'))
if "awsCredentialsFile" not in settings_dct or \
not settings_dct["awsCredentialsFile"]:
settings_dct[... | |
00309f3d65195a80c65b | def vernam_cipher_decrypt(text:str, key:int):
decrypted_text = ""
for i in range(len(text)):
decrypted_text += chr(ord(text[i]) ^ (key * (i+1))%128)
return decrypted_text | |
00309fff6bff58d4b43f | def create_book_dataframe() -> pd.DataFrame:
book_stats = pd.DataFrame(columns = ("Language", "Author", "Title", "Length", "Unique"))
title_num = 1
for LANGUAGE_DIR in os.listdir(BOOK_DIR):
for AUTHOR_DIR in os.listdir(BOOK_DIR + "/" + LANGUAGE_DIR):
for book_title in os.listdir(BOOK_DIR... | |
0030a1d454f6c628ed70 | def is_legal_action(self, action):
# Check that cells are within board
if not self.validate_cell_coordinates(action):
return False
piece_row, piece_col = action[0][0], action[0][1]
target_row, target_col = action[1][0], action[1][1]
# Check that current cell has pie... | |
0030a3208c2d9f70506b | def adjust_for_ace(self):
self.values["Ace"] = 1
self.value = 0
for card in self.cards:
self.value += self.values[card.rank] | |
0030b2a0383a836fe763 | def get_all_colors():
all_colors = set(db.session.query(SupplyDetail.color).filter(SupplyDetail.color != None).all())
all_colors = sorted(list(all_colors))
return all_colors | |
0030bce104fdf9890a78 | def fov_deg(self):
self.capsule_ensure()
return _imager_lib.fov(self._capsule) | |
0030be44b402eab93b33 | def age(self, age):
self.__age = test_input(age) | |
0030ed229a0297d003ee | def __read_cards():
all_cards = dict() # Dictionaries let us have convenient mappings between cards and their images
for suit_file, suit in zip('HDSC', range(4)):
for value_file, value in zip(['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'],
... | |
0031242620229c2c0544 | def node_label(self, text):
return self.label_format.format(text) | |
0031356dcabad892fd2c | def deduped(items):
no_dupes = set(items)
lst = list(no_dupes)
result = sorted(lst)
print result | |
003162c8ede13d3ec811 | def health_core(device,
default_dir=None,
output=None,
keyword=['_core.'],
num_of_cores=False,
decode=False,
decode_timeout=300,
remote_device=None,
remote_path=None,
remote_vi... | |
0031733f8b9e439b9a61 | def model(self, input_shape, output_dim: int):
# Main acoustic input
input_data = Input(name='the_input', shape=input_shape)
# print("input shape", input_shape)
x = input_data
if self.cnn_config:
if self.cnn_config.kernel_2d is not None:
res... | |
0031760db3d3d5eef796 | def solve_puzzle(problem):
print('Solving puzzle.')
return problem.getSolutions() | |
00317eb1bce17e85e86c | def stash_help():
for name, doc in get_stash_functions():
print(f'▸ {name}')
print('\n'.join(line.strip() for line in doc.splitlines()))
print() | |
00318dfae5596581ddab | def getPortingCountries(self):
return self._request(self._base_url + "/Porting/Countries", "GET") | |
00319fa877e5ca861be5 | def create_histo(options):
return | |
0031c4b5954990c68b1b | def internal_fqdn(self) -> Optional[str]:
return pulumi.get(self, "internal_fqdn") | |
0031d9ff80b197df4f37 | def post(self, data, batch_size=DEFAULT_BATCH_SIZE):
uri = self.endpoint + "/batch"
batches = []
# create one batch for each set of batch_size rows in data
for i in xrange(0, len(data), batch_size):
resp = self.session.post(uri, json=data[i:i+batch_size])
Salesfor... | |
00321a64ed27ea7d9b60 | def _spec2melspec(self, spec):
mel_basis = librosa.filters.mel(self.fs, self.fftl, self.n_mels)
mel = np.dot(mel_basis, spec)
return mel | |
00321cc865827cb0fae0 | def search4letters(phrase: str, letters: str) -> set:
return set(letters).intersection(set(phrase)) | |
003223459e414749afad | def clean_link(self, url: str) -> str:
return self.CLEAN_REGEX.sub(lambda match: f"%{ord(match.group(0)):02x}", url) | |
0032290f00479020917d | def current_tags(self):
return _ofdm_allocator_swig.per_measure_decimator_current_tags(self) | |
00322a7a006a22ceb093 | def test_create_failed_status(self):
# set up mock with a CREATE_FAILED status
self.cloud_provider.cloud_formation_stacks.append(MockStack("stack-1", "CREATE_FAILED"))
# run the cloud provider terminate class
self._terminator.start()
# verify that the stack was deleted
... | |
003234d4c75c6e94ec5d | def add(node):
server = xmlrpclib.Server(URL)
token = server.login(LOGIN, PASSWORD)
logger.info('Adding {} to cobbler server {}'.format(node, URL))
system_id = server.new_system(token)
server.modify_system(system_id, 'name', node.name, token)
server.modify_system(system_id, 'hostname', node.nam... | |
00323afa6cae943e332f | def test_y1(self):
l = Line(0, 0)
self.assertEqual(l.y(0), 0)
self.assertEqual(l.y(-1e600), 0)
self.assertEqual(l.y(1e600), 0)
l = Line(1, 1)
self.assertEqual(l.y(2), 3)
self.assertEqual(l.y(-1e600), -1e600)
self.assertEqual(l.y(1e600), 1e600)
l ... | |
0032456adeb8366df8d5 | def is_float(self, value):
try:
float(value)
return True
except:
return False | |
00324b3c7228ae3be00b | def param(self, name):
try:
return self.params[name][0]
except KeyError:
return None | |
00329043e3781ba4434f | def get_cw(comp, Cw, D2, D1= 2.0):
D3= D1*D2; # D_opx/ol;
comp[0]= comp[0]+ comp[3]; # water content is identical in olivine and garnet
x= Cw/(comp[0]+ comp[1]*D3+ comp[2]*D1);
cw= {"ol":x, "cpx": D1*x, "opx": D3*x, "gt":x};
return cw | |
0032a5bcb7f3575b8e22 | def board(self):
return self.__board | |
0032b2496a0e4eccfe34 | def test1(self) -> None:
assert 1 == 0, "Test 1 has failed" | |
0032c24359242122a15a | def part1(filename: str) -> int:
data = parse(filename)
total = 0
for equation in data:
total += p1_eval(equation)
return total | |
0032fe63546870c8ebf6 | def tokenize_input(self):
self.current_token = self.next_token()
while self.current_token.value != None:
self.tokenized_text.append(self.current_token)
self.current_token = self.next_token() | |
00330b155f1e9eff64ec | def teardown_all(self):
vals = [f for f in self._fixtures.values()]
for fixture in vals:
with suppress(RuntimeError, StopIteration):
fixture.teardown()
del self[fixture.key] | |
00333f81e32090da3e8a | def compute_base_rates():
period_min_rate = 1./TGT_RATE_MIN
period_max_rate = 1./TGT_RATE_MAX
periods_min_rate = int(np.ceil(period_min_rate/UNIT_PERIOD))
periods_max_rate = np.clip(int(np.floor(period_max_rate/UNIT_PERIOD)), 1, None)
unit_periods = np.arange(periods_max_rate, periods_min_rate)[::-... | |
00334e811863509abe11 | def _handle_system_ordered_queue_owners_exhausted(self, message):
try:
# Record the exhausted queue information in our tracker.
current_set = self._current_exhausted_queue_owner_dict.get(message.queue_name, set())
self._current_exhausted_queue_owner_dict[mes... | |
00335be095b4ecb4d496 | def _add_feature (self, feature):
self._feature_values[feature] = {
HAS_FEATURE: set(), NOT_HAS_FEATURE: set(),
INAPPLICABLE_FEATURE: set()} | |
00336359cbc7d850884c | def test_deliver_order_with_shipped_delivered(self):
order_factory = _get_order_factory_with_items(3)
order_factory.order_items[0].status = "SHIPPED"
order_factory.order_items[1].status = "SHIPPED"
order_factory.order_items[2].status = "DELIVERED"
new_order_id = self._create_new... | |
00337c840a74b24f4f95 | def build_real_network(structure_list):
global m, dist_matrix, df_stations
adj_matrix = np.zeros((m, m))
for k in range(len(structure_list) - 1):
if structure_list[k] == 'END_OF_LINE':
pass
elif structure_list[k + 1] == 'END_OF_LINE':
pass
else:
i ... | |
00339dcc608203809fea | def add_answer(username, password, problem_id):
user = authenticate(username=username, password=password)
if user is None:
raise TypeError("Incorrect username and passowrd given")
else:
problem = Problem.objects.get(pk=problem_id)
user.get_profile().add_answer(problem)
return... | |
0033a44deb38d80df689 | def random_string(random_length = None):
choices = string.letters + ' '
text = []
if not random_length:
random_length = random.randint(1, 30)
for x in range(random_length):
text.append(random.choice(choices))
return "".join(text) | |
0033ab8d44354d950d8c | def get_sample(self):
sample = self.get_samples(1)
assert len(sample) == 1
return sample[0] #unwrap list that was returned | |
0033bd038c6e27ccbc96 | def generateXML(self,workingDir,bool,inputFiles,tabMapFileName):
top = Element('scaling_library', {'print_xml':'t'})
print (self.listedDict)
for XS in self.listedDict.keys():
for tabulation in self.listedDict.get('XS').keys():
topChild = SubElement(top, 'set')
if bool:
tabLis... | |
0033e64549176cfdbb62 | def serialize_numpy(self, buff, numpy):
try:
_x = self.world
length = len(_x)
if python3 or type(_x) == unicode:
_x = _x.encode('utf-8')
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
length = len(self.ids)
buff.write(_struct_I.pack(length))
... | |
0033eac1bb73f9b3ec46 | def test_save_public_key(self):
key = rsa.key.PublicKey(3727264081, 65537)
der = key.save_pkcs1('DER')
self.assertEqual(PUBLIC_DER, der) | |
0033efa43133a2d1a2d3 | def prob(self, word):
return WORDS[word] / sum(WORDS.values()) | |
0034011108faa69ed672 | def like_count(self):
return self.like_set.count() | |
0034103b2eeda446519b | def extractXYPosition(frame):
return frame[torso_j][1][0], frame[torso_j][1][1] | |
003456d687b2ee8e7c51 | def print_s(self, message, *args):
message = message + "%.1fs"%(self.eltime_s())
if self.has_thread_time:
message = message + " (thread: %.1fs)"%(self.thread_eltime_s())
print(message, *args) | |
00345c76af7ed64df9f6 | def get_required_disk_size(self, **kwargs):
return 0 | |
00347baffe1923d13550 | def choose_card(self):
choice = input("Which plate do you want to keep? ").upper()
if check_choice_validity(self, choice) == False:
self.choose_card()
if check_hand_for_card(self, self.players[0].pre_hand, choice) == False:
self.choose_card()
index = index_of_choi... | |
00348c1b1bc450636804 | def close(self):
if self.device:
self.remove_events()
self.device.close()
del self.device | |
0034951014a8dad41060 | def is_empty(cell: Cell):
return (cell.value or '').strip() == '' | |
0034a490520995f65d51 | def normalize_address(address):
if address.startswith('tel:'):
address = address[4:]
return normalize_msisdn(address) | |
0034ee1d2486304f4e34 | def von_mises(x,y,moment_z,moment_y,normal_force,I_zz,I_yy,area, tau_max):
z = sp.width_wingbox(x)/2
#-my/I according to the formula, makes sense because for a positive Mz the top skin will be in compression
moment_z_upperskin = -moment_z*(sp.height_wingbox(x)-abs(y))/I_zz
moment_z_lowerskin =... | |
00352a4563bc7dab00c4 | def _check_before_run(self):
if not osp.exists(self.dataset_dir):
raise RuntimeError("'{}' is not available".format(self.dataset_dir))
# if not osp.exists(self.train_dir):
# raise RuntimeError("'{}' is not available".format(self.train_dir))
if not osp.exists(self.query_di... | |
00354706ea7cf4eb2f44 | def _update_limits(self, load_fct):
if self.motor_parameter['i_N'] == 0.0:
self.motor_parameter['i_N'] = self.motor_parameter['u_N'] / self.motor_parameter['r_a']
if self.motor_parameter['torque_N'] == 0.0:
self.motor_parameter['torque_N'] = self.torque([0, self.motor_parameter['... | |
00358f0c2772aa5f2115 | def invrsUV(deltamn,etamn,fmn,I,J,M,N,Pmn,Hmn,tstepcoeffmn,marray):
#do not sum over n=0 (see Hack and Jakob 1992 equations 5.24-5.25)
deltamn[:,0]=0
etamn[:,0]=0
newUm1=invrs_leg((1j)*np.multiply(np.multiply(marray,deltamn),tstepcoeffmn), I,J, M, N, Pmn)
newUm2=invrs_leg(np.multiply(e... | |
00358f5f421293b2a801 | def format(self, record):
record.message = record.getMessage()
if self.usesTime():
record.asctime = self.formatTime(record, self.datefmt)
s = self.formatMessage(record)
return s | |
0035abf95cf159b7624e | def get_property(self, prop_name):
raise cmerror.CMError('No implemented') | |
0035c214d3ee29b06be5 | def pack(self, *args):
return pack(self.format, *args) | |
0035d543a65f593072da | def replace_locators(self, prefix=None):
RESOURCE_LOCATOR_ELEMS = ("a", "img", "script", "link") #elements that can have resource locator attribute (img or src)
page_soup = self.soup.select(", ".join(RESOURCE_LOCATOR_ELEMS))
for elem in page_soup:
#get elements src or elem if they ... | |
003618ab0f8b2be3b9ab | def get(**kwargs):
url = kwargs.get('url', None)
params = kwargs.get('params', None)
woeid = kwargs.get('woeid', None)
date = kwargs.get('date', None)
try:
if not params:
if not date:
endpoint = f"{url}/{woeid}"
response = requests.get(url=endpoin... | |
00365790f2662616a5d6 | async def reload(ctx):
reloading = await ctx.send("Reloading...")
bot.unload_extension("cogs.main")
bot.load_extension("cogs.main")
bot.unload_extension("cogs.fun")
bot.load_extension("cogs.fun")
bot.unload_extension("cogs.owner")
bot.load_extension("cogs.owner")
bot.unload_exten... | |
00365c0be4dd1b6d65dd | def run(self):
df = self.read_input()
if self._analysis_type == 'flow':
self.flow_process_data(df)
elif self._analysis_type == 'packet':
self.packet_process_data(df) | |
00367428bb9b1a25d9a0 | def multi_line(self): | |
0036756530b22988e003 | def get(self):
time_start = time.time()
args = common_args.parse_args()
return_data = ScoreServices.getScoreByScoredId(args)
time_end = time.time()
monitor(time_start, time_end, path, "get")
return return_data["data"], return_data["status"], {'message': return_data["messa... | |
00367aee14d5772f72b6 | def trial_started(self, tn, tc):
return False | |
00368abb04af29861493 | def plot_img_sample(X_train, Y_train):
W_grid = 4
L_grid = 4
_, axes = plt.subplots(L_grid, W_grid, figsize=(15, 15))
axes = axes.ravel()
n_training = len(X_train)
for i in np.arange(0, L_grid * W_grid):
index = np.random.randint(0, n_training)
axes[i].imshow(X_train[index].resha... | |
00368b9e77ce983129ef | def forward(self, embedded_word, fc_feats, conv_feats, p_conv_feats, pool_feats, p_pool_feats, pnt_mask,
state, proposal_frame_mask=None, with_sentinel=False):
batch_size = embedded_word.size(0)
prev_h = state[0][-1] # language LSTM previous output hidden state
if self.opts.glo... | |
00369476c9f367b2de96 | def preprocess(self):
f = open(self['INCAR'],'r+');
incar = f.read() # read the whole file
for key in self.params:
val = self.params[key]
search_str = r'%s(?P<ws1>[ \t]*)=(?P<ws2>[ \t]*)([.\w]*)' % (key)
matches = re.search(search_str, incar)
if m... | |
0036b4374fbfa65912db | def win_is_runnnig(self, url):
response = None
time.sleep(1)
try:
response = urllib.request.urlopen(url, timeout=5)
if str(response.getcode()).startswith("2"):
return True
else:
return False
except URLError:
... | |
0036dd748b73e4f738c8 | def test_alternative_names_columns(self, lat_column_name, lon_column_name):
df = df1.rename(columns={"lat": lat_column_name, "lon": lon_column_name})
st.map(df1)
c = json.loads(self.get_delta_from_queue().new_element.deck_gl_json_chart.json)
self.assertEqual(len(c.get("layers")[0].get("... | |
0036e3fc1d5db447ea43 | def dump(self) -> str:
# Standard Library
import textwrap
s = f"""
BEL Object dump:
version: {self.version}
assertion: {self.assertion.entire}
species: {self.ast.species}
ast: {self.ast.print_tree()}
"""
... | |
0036ededc0be44f3e556 | def testSaveSameEpisode(self):
self._tester.SavePhotos(self._cookie, [(self._existing_ep_id, self._photo_ids[:1])])
self._tester.SavePhotos(self._cookie, [(self._existing_ep_id, self._photo_ids[1:])]) | |
0036ff391d3c95275be7 | def my_print(self):
if self.__size == 0:
print("")
else:
for sym in range(0, self.position[1]):
print("")
for sym in range(0, self.__size):
for char in range(0, self.position[0]):
print(" ", end="")
f... | |
0037024b7e580ad011be | def relbind(self, dict, db):
result = BoundTuple()
e2 = result.eqs
a2 = result.assns
for ((a,b), (c,d)) in self.eqs.items():
if a is None:
try:
a = dict[b]
except KeyError:
raise NameError, `b`+": ambiguo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.