id stringlengths 20 20 | title stringclasses 1
value | text stringlengths 8 768k |
|---|---|---|
ffd426500f8cfc77b53a | def __init__(self, spec, loadingContext):
super(ReanaPipelineTool, self).__init__(spec, loadingContext) | |
ffd433264ae27cb1edc5 | def train(self,
path_to_saved: str = None,
epochs: typing.Optional[int] = None,
log_frequency: typing.Optional[int] = None) -> None:
self.start_time_training = time.time()
if epochs:
self.epochs = epochs
if log_frequency:
self.... | |
ffd4605f5c8ba0e23361 | def img_augmentation(rgb, d):
if len(d.shape) == 2:
d = tf.expand_dims(d, -1)
flip_case = tf.random.uniform(shape=(), maxval=4, dtype=tf.int32)
# if case == 0, does not flip the image
# Flip horizontally
if flip_case == 1:
rgb = tf.image.flip_left_right(rgb)
d = tf.image.fli... | |
ffd47d07d6ecc3ec60a5 | def type_name(self):
return self.args[1] if len(self.args) > 1 else None | |
ffd48cf4a54c1ae7d88d | def get_file_data(self):
return self.__data | |
ffd48e80cc41a2d0d0e1 | def write_lexicon_pickle(self, data):
self.write_to_pickle(self.lexicon_pickle_file, data) | |
ffd4c62c7f2bce1fda18 | def plot_learners(self,
source_pattern :Union[str,int] = ".*",
learner_pattern:Union[str,int] = ".*",
span:int = None,
start:Union[int,float]=0.05,
end:Union[int,float] = 1.,
err_every:Union[int,float]=.05,
err_type:str=None,
complete_sims:bool = True,
... | |
ffd4fb4ab487a0d93e5e | def _py_while_stmt(test, body, get_state, set_state, init_vars, opts):
del opts, get_state, set_state
if __debug__:
checker = _PythonLoopChecker()
loop_vars = init_vars
while test(*loop_vars):
if __debug__:
checker.before_iteration()
loop_vars = body(*loop_vars)
if __debug__:
ch... | |
ffd534814b86bf0d915e | def playerStandings():
connection, db_cursor = connect()
query = "SELECT * FROM v_playerstandings;"
db_cursor.execute(query)
standings = db_cursor.fetchall()
connection.commit()
connection.close()
return standings | |
ffd566db161b6552d76f | def read_gcs_file(gcs_client: storage.Client, gsurl: str) -> str:
blob = storage.Blob.from_string(gsurl)
return blob.download_as_bytes(client=gcs_client).decode('UTF-8') | |
ffd5737fcca2a902535d | def __iter__(self):
for item in self._internal_collection:
yield item | |
ffd5795139100f74e7f1 | def UCfiles_to_taxtable(derepfile, otus97, otus95, otus90, otus85, otus80, otus75, otus55, otus35, otus15, taxtable):
ucfiles = [ {"file": otus95, 'label_high': 'otu97', 'label_low': 'otu95'},
{"file": otus90, 'label_high': 'otu95', 'label_low': 'otu90'},
{"file": otus85, 'label_... | |
ffd57ff158270e66af45 | def iservice_get_by_name(self, name): | |
ffd5a311c52690aa9c09 | def get_all_tables():
tree = get_lxml_tree_from_url(SMB_LEVEL_URL)
for elem in tree.cssselect("#mw-pages a"):
url = f"{BASE_URL}{elem.get('href')}"
print(f"Crawling data for `{url}`")
if "Minus" not in url:
subtree = get_lxml_tree_from_url(url)
yield {
... | |
ffd5a381f06668e36221 | def open(self):
try:
self.device = manager.connect(
host=self.hostname,
port=self.port,
username=self.username,
password=self.password,
key_filename=self.key_file,
timeout=self.timeout,
de... | |
ffd5c34f69d6d6b20725 | def IsRunning(self) -> bool:
return self._isok | |
ffd5c7be52ab13ea2ada | def metric_info(self, pos_rank_sum, user_len_list, pos_len_list):
neg_len_list = user_len_list - pos_len_list
# check positive and negative samples
any_without_pos = np.any(pos_len_list == 0)
any_without_neg = np.any(neg_len_list == 0)
non_zero_idx = np.full(len(user_len_list), T... | |
ffd5e2370feb9a1a9d9f | def recommend_home(user_id=None, n=10):
if user_id is not None:
max_city = get_max_city(user_id)
highest_scored = sorted(BUSINESSES[max_city], key=lambda x: x['stars'], reverse=True)[:10]
return highest_scored
all_businesses = get_all_businesses()
all_businesses = list... | |
ffd5e66d84f931fca692 | def song(self):
return self.__c_instance.song() | |
ffd67166ab75edd29eea | def edit_contact_status(request):
status = True if request.POST['status'] == 'true' else False
status = UserProfileService.edit_contact_status(request.user, status)
return JsonResponse({'status': status}) | |
ffd67e4c666c3f5b7e11 | def damaged(self, attack) -> None:
self.set_hp(self.get_hp() - attack) | |
ffd67f0664b8b8a8f512 | def get_key(
self, obj: Any, format: PyFormat
) -> Union[type, Tuple[type, ...]]:
return self.cls | |
ffd686056ed6b1770d7e | def f1(recall, precision):
return 2*precision*recall/(precision + recall) | |
ffd6af62d1f8ece223a3 | def save_logs(idx,message,sent):
with open("modem.logs", "a") as myfile:
myfile.write("[LOG %d][%s] %s\n"%(idx,sent, message))
if sent:
conn.incr("_"+str(idx)+"_sent_sms")
conn.rpush("sent_message_"+str(idx), message)
else:
conn.incr("_"+str(idx)+"_failed_sms")
conn.... | |
ffd6dece645bab486c9a | def longestCommonSubsequence(self, s: str, t: str) -> int:
if not s or not t:
return 0
m, n = len(s), len(t)
dp = [[0 for _ in range(n+1)] for _ in range(m+1)]
for i in range(1, m+1):
for j in range(1, n+1):
if s[i-1] == t[j-1]:
... | |
ffd6f0b2b90b02f437e4 | def authenticate(self, username=None, password=None):
try:
user = get_user_model().objects.get(email=username)
if user.check_password(password):
return user
except get_user_model().DoesNotExist:
return None | |
ffd6f22156cc6bee917a | def isvalidattr(ident):
# Smoke test - if it's not string, then it's not identifier, but we don't
# want to just silence exception. It's better to fail fast.
if not isinstance(ident, str):
raise TypeError('expected str, but got {!r}'.format(type(ident)))
# Resulting AST of ... | |
ffd728c0656484a57095 | def low_pass_filter(file_name):
file_content = load_wave(file_name)
frame_rate = file_content[0]
audio_data = file_content[1]
audio_data_copy = audio_data
for i in range(1,len(audio_data)-1):
for j in range(1):
# creating the averages:
first_avg = int((1/3)*(a... | |
ffd72d4d8b623343c52b | def action_document(self, nick, data=''):
self.simple_search(nick, data, dclib.DCBot.SEARCH_TYPE_DOCUMENT) | |
ffd73a3a49ed918e85dd | def retrieve_data(database, Year, Months, feq=None):
dict_df = {}
dict_df_cloud = {}
dict_df_tempc = {}
date_A = str(Year) + "-" + str('{:02d}'.format(Months[0])) + "-01"
if 12 == Months[-1]:
date_B = str(Year + 1) + "-01-01"
else:
date_B = str(Year) + "-" + str('{:02d}'.format(M... | |
ffd75f060df1d36e8206 | async def server_info(self, ctx):
embed = Embed(
title="Now Online!",
description="The server is now online",
colour=ctx.author.colour,
timestamp=datetime.utcnow()
)
fields = [
("Owner", f"Eren Yeager", True),
("Members", f"... | |
ffd77b227bf569559803 | def download_file(file_url, file_dest_path, silent=False):
with open(file_dest_path, "wb") as f:
maybe_print(not silent, "Downloading {}".format(file_dest_path))
response = requests.get(file_url, stream=True)
total_length = response.headers.get('content-length')
if total_length is N... | |
ffd7978586ac299ce092 | def on_disconnect(self, controller): | |
ffd7989d07bec0d436d0 | def enable(self):
self._enabled = True | |
ffd79a8c3b1c2b1acd71 | def WriteFooter(self):
return | |
ffd7ac8d2a1af30f96cc | def test_reshape_arr_1d_type(arr):
## Testing input types
with pytest.raises(TypeError):
gen_utils.reshape_arr_1d(arr) | |
ffd7bee7e6621795ffeb | def test_bad_input(self):
# Upper bound
self.assertEqual(chroma.Color((10, -3, 0.5), 'RGB').rgb, chroma.Color((1, 0, 0.5), 'RGB').rgb)
self.assertEqual(chroma.Color((300, -3, 50), 'RGB256').rgb256, chroma.Color((255, 0, 50), 'RGB256').rgb256)
self.assertEqual(chroma.Color((400, -3, 10), ... | |
ffd7c715b1122d7aabf0 | def _from_catalog(self):
if self.dbconn.version < 90300:
return
for trig in self.fetch():
trig.enabled = self.enable_modes[trig.enabled]
self[trig.key()] = trig | |
ffd7ffa7d30cd6ecb499 | def _flatten_index(shp):
return np.arange(np.prod(shp), dtype=np.intp).reshape(shp) | |
ffd815ebd6e257ba918a | def opposite(x):
return -1*x | |
ffd82b4cc65e0a0db9fe | def check_faces(image, to_find, known_faces, path):
unknown_image = face_recognition.load_image_file(image)
try:
unknown_face_encoding = face_recognition.face_encodings(unknown_image)
except IndexError:
return 0
for encoding in unknown_face_encoding:
try:
results = fa... | |
ffd83818e9f06112bdcf | def _write(self):
if self._send_buffer:
print("Sending database to", self.addr)
try:
# Should be ready to write
sent = self.sock.send(self._send_buffer)
except BlockingIOError:
# Resource temporarily unavailable (errno EWOULDBLO... | |
ffd83f9f971871a9aa5c | def __getitem__(self, k):
if(k in self.keys()):
for keys in dict.keys(self):
if(k in keys):
return dict.__getitem__(self,keys)
else:
raise KeyError(str(k)) | |
ffd867c5436498c255f1 | def save(self):
makeCheckpoint({
"epoch" : self.epoch,
"model" : self.model.state_dict(),
"highestPrecision" : self.highestPrecision,
"optimizer" : self.optimizer.state_dict()
}, self.isBest, self.ckpLoc + MOTION_CKP_FILE, self.ckpLoc + MOTION_BEST_FILE)
return | |
ffd8a39e98eef3229c1b | def framesList(mainFolder):
folder = os.listdir(mainFolder)
images = []
for image in folder:
curImg = cv2.imread(f'{mainFolder}/{image}')
# curImg = cv2.resize(curImg, (0, 0), None, 0.2, 0.2)
images.append(curImg)
return images | |
ffd8b19ea6e4622b452e | def has_inventory_sources(self):
return parse(self._data.get('has_inventory_sources')) | |
ffd8b1b1a441fac94ab3 | def update(self):
# "Pull" information of interest
v = self._model.get_value()
res = v / self._divisor
print("%.2f div %.2f is %.2f" % (v, self._divisor, res)) | |
ffd8c304b8982e37540a | def __get_language(self, article):
return BeautifulSoup(article, 'xml').article['lang'] | |
ffd8d8139651a3a648e6 | def get_global_gradient(self, dnn):
grad = torch.Tensor(0)
if self.all_layers_shapes == {}:
for i,layer in enumerate(dnn):
self.all_layers_shapes[i] = layer.shape
for i, layer in enumerate(dnn):
g = self.get_layer_gradient(layer)
g... | |
ffd8f1e221ef5affb137 | def sentiment(text,polarity):
raw_text = TextBlob(text)
final_result = raw_text.sentiment
if polarity == 'True':
click.secho('Your text was: {}'.format(text),fg='green')
click.secho('Sentiment - Polarity: {}'.format(final_result.polarity),fg='green')
elif polarity == 'False':
click.secho('Your text was: {}'.f... | |
ffd90199ee06b002694b | def spark_conf(self, spark_conf):
self._spark_conf = spark_conf | |
ffd923a4b4791c6edf54 | def filter ( self, object ):
for rule in self.rules:
if rule.enabled and (not rule.is_true( object )):
return False
return True | |
ffd93157bc228e04e392 | def plotAudio(self):
pylab.plot(self.audio.flatten())
pylab.show() | |
ffd931bb156f64a52b69 | def stdout():
return contextlib.redirect_stdout(io.StringIO()) | |
ffd944f7267fef229940 | def invert_image(self, im):
return -im | |
ffd95a157541e39c9e39 | def calcQuad4():
density = 2500.0
vp = 5000.0
vs = 3000.0
dt = 0.25
N0 = 0.5
N1 = 0.5
vel1X = 0.5*(N0+N1)*(N0*(1.3+1.5-1.1) + N1*(1.1+1.2-1.0)) / (2.0*dt)
vel1Y = 0.5*(N0+N1)*(N0*(2.1+2.4-1.8) + N1*(2.0+1.6-2.4)) / (2.0*dt)
normal1 = [-1.0, 0.0]
vel2X = 0.5*(N0+N1)*(N0*(1.9+2.4... | |
ffd9ad9fe001714394c1 | def get_relative_location(anno_dict):
location = "NA"
if float(anno_dict["feat_ovl_peak"]) == 1:
location = "PeakInsideFeature"
elif float(anno_dict["peak_ovl_feat"]) == 1:
location = "FeatureInsidePeak"
elif float(anno_dict["feat_ovl_peak"]) == 0: #no overlap
#If feature (gene) is on the - strand
if ... | |
ffd9bd6bbc9b7e60d0ff | def team_players_selected():
with open("data/teams_cleaned.json", "r") as f:
teams = json.load(f)
team_players_selected = {}
for team in teams:
team_players_selected[team["name"]] = 0
return team_players_selected | |
ffd9cb612cf1068e72b6 | def state(self):
return self.value | |
ffd9ce6eeefa4ba0607d | def sqrt(number):
epcilon = 1e-15 # 1*(10**-15)
x = number
while((x - number/x) > epcilon):
x = (x + number/x)*0.5
return x | |
ffd9dcf1f4d66fc57a4e | def create_project(self, project: Project) -> Project: | |
ffd9e0d1276a8334c8e0 | def algebra_generators(self):
return [self.x(i) for i in range(1, self._n+1)]+[self.t(i) for i in range(1, self._n)]+[self.e(p) for p in self._P] | |
ffd9fcbb40cad60125cf | def test_delete(self):
d = {
u'action': u'delete',
u'node': {
u'key': u'/testkey',
"modifiedIndex": 3,
"createdIndex": 2
}
}
self._mock_api(200, d)
res = self.client.delete('/testKey')
self.assert... | |
ffda0dec9cbbf25436e5 | def assert_keys_in_dict(allowable_keys, d):
for k in d:
if k not in allowable_keys:
return False, k
return True, None | |
ffda2d077603e41fad54 | def __init__(self, port):
self.port = port | |
ffda43238203c9a74229 | def parse_review_aspects_for_business(print_count=20):
complete_file_path = os.path.join(os.getcwd(), "../../Data", constants.REVIEW_SENTIMENT_FILE_NAME)
business_reviews_list = []
business_aspects_dict = {}
business_filtered_aspects_dict = {}
prev_business_id = None
business_id_count = 0
wi... | |
ffda4a0c0dd72803074f | def test_attr_set_name_set_cmd(mocker):
mocker.patch.object(device_attrs, 'name', 'old1')
mocker.patch('qtoggleserver.conf.settings.core.device_name.set_cmd', 'dummy set cmd')
spy_run_set_cmd = mocker.patch('qtoggleserver.core.device.attrs.run_set_cmd')
device_attrs.attr_set_name('new1')
assert dev... | |
ffda4e24fa680b5b4cab | def train(self, texts, labels):
preprocessed_texts = preprocess_texts(texts)
# <<<<<< BOW & TFIDF START>>>>>>>>>>>>
# self.vocabulary = self._non_rare_vocabulary(preprocessed_texts)
# # BAG OF WORDS
# # features = self._bag_of_words(preprocessed_texts, self.vocabulary)
... | |
ffda66a903bfa8def3ec | def storage_type_get_by_name(context, name):
return IMPL.storage_type_get_by_name(context, name) | |
ffda798ad323e8429119 | def _message_bits_limit(self):
return self._raw_bits_limit() - 11*3 | |
ffda84cfe143f52be909 | def get_business(business_id):
business_path = BUSINESS_PATH + business_id
return request(API_HOST, business_path) | |
ffdaa7345cc2b06dd1a0 | def SCHEMA(self):
pass | |
ffdabd9914adbbd43fc9 | def reverseUniqueIndex(index):
index = asarray(index)
rev = zeros(1+index.max(),dtype=index.dtype) - 1
rev[index] = arange(index.size,dtype=rev.dtype)
return rev | |
ffdad641096258992409 | def submit(self):
return self._submit | |
ffdae0a417f6f4ca1872 | def create_or_update_attachment(self, review_request, review_request_draft,
flags):
logger.info('Posting review request %s to bug %d.' %
(review_request.id, self.bug_id))
rr_url = get_obj_url(review_request)
diff_url = get_diff_url(review... | |
ffdb2c499b1deec4cea3 | def DrawButton(self):
self.UpdateToScreen(self.normalColor)
self.Update() | |
ffdb37be8692a242ce88 | def renderString(self, ctx=None):
io = StringIO()
writer = io.write
def finisher(result):
return io.getvalue()
ctx = PageContext(parent=ctx, tag=self)
self.rememberStuff(ctx)
doc = self.docFactory.load(ctx)
ctx = WovenContext(ctx, tags.invisible[doc... | |
ffdb515b5128453ba406 | def move_forward(self):
self.obs_x -= 20 | |
ffdb980b57340b99ef2e | def compl_tup(t):
return tuple(-x for x in t) | |
ffdbcc947e1c24ffa31e | def jacobian(self, x, rev=False):
return 0 | |
ffdbd830de122b2ae630 | def inverse(f, delta = 1/128.): | |
ffdbe32dd21ca9c0b9e9 | def ForwardEuler(f, U0, T, N):
import numpy as np
t = np.zeros(N+1)
u = np.zeros(N+1) # u[n] is the solution at time t[n]
u[0] = U0
t[0] = 0
dt = T/N
for n in range(N):
t[n+1] = t[n] + dt
u[n+1] = u[n] + dt*f(u[n], t[n])
return u, t | |
ffdbe593dd3935bf41fb | def network_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
return pulumi.get(self, "network_tags") | |
ffdbe9dd6b4e1c188cd7 | def setup_observers(self):
_object_cache.setup_observers(self._vtk_obj,
'ModifiedEvent',
self.update_traits) | |
ffdbf89f36b17902f8b6 | def test_create_iam_trust_point(self):
pass | |
ffdbf927dbcdbf7de0c7 | def get(cls, project_id, model_id, dataset_id):
if model_id is None:
raise ValueError("model_id must be specified")
if dataset_id is None:
raise ValueError("dataset_id must be specified")
scores = cls.list(project_id, model_id=model_id, dataset_id=dataset_id)
if n... | |
ffdc0f91eff01f003df4 | def preprocess(text):
lemmatizer = WordNetLemmatizer()
text = re.sub(r"won\'t", "will not", text) # decontracting the words
text = re.sub(r"can\'t", "can not", text)
text = re.sub(r"n\'t", " not", text)
text = re.sub(r"\'re", " are", text)
text = re.sub(r"\'s", " is", text)
text = r... | |
ffdc132e7ade1fc9200c | def swap(lyst, x, y):
lyst[x], lyst[y] = lyst[y], lyst[x] | |
ffdc2046dae8d362b1d1 | def stop(self):
return _qbee_swig.qbee_framer_sptr_stop(self) | |
ffdc21af9c070f00e298 | def rand_clusters(k,n,r,a,b,c,d):
clusters = []
for _ in range(k):
x = a + (b-a)*random()
y = c + (d-c)*random()
clusters.extend(rand_cluster(n,(x,y),r))
return clusters | |
ffdc2d36f594f9779d30 | def checkBoard():
#TODO | |
ffdc456b13cdf84d1321 | def temperature_oversample(self):
return _BME680_SAMPLERATES[self.osrs_p] | |
ffdc6c30e7b93ed159ff | def _get_cell_neigh(struct,
cell_radius,
single_atom_idx):
if "cell-list" not in struct.properties:
cell_list(struct)
cl = struct.properties["cell-list"]
atom_cell = cl[single_atom_idx]
### Obtain copy of atom_cell
atom_cell = atom... | |
ffdc7678c01d09772363 | def functions_matrix(self, w, mu, sigma, proportional, unknown):
matrix_size = 0
vars_idx = []
belongings_row = []
parameters = [w, mu, sigma]
for par_idx in unknown :
matrix_size+= len(parameters[par_idx])
vars_idx.append([i for i in r... | |
ffdc944f896f54a3471c | def test_site(MultiFileWindX_cls, ds_name='windspeed_100m'):
extract_site(MultiFileWindX_cls, ds_name)
MultiFileWindX_cls.close() | |
ffdca07b007ea4b36c5a | def squash(X):
return np.squeeze(np.asarray(X)) | |
ffdcb103005953099926 | def analyze(textReply):
client = language.LanguageServiceClient()
content = textReply
document = types.Document(
content=content,
type=PLAIN_TEXT)
annotations = client.analyze_sentiment(document=document)
# Print the results
print_result(annotations)
# idea | |
ffdcd93f5f9d33e42adf | def graph(self): | |
ffdcd96c5e5e7e492c58 | def computeQValueFromValues(self, state, action):
"*** YOUR CODE HERE ***"
successors = self.mdp.getTransitionStatesAndProbs(state, action)
Q_value = 0.0
for (nextState, prob) in successors:
tmp_next_state_value = self.values[nextState]
tmp_reward = self.mdp.get... | |
ffdceca8e0e08607406a | def get_update_submitter_emails(ipr):
messages = []
email_to_iprs = {}
email_to_name = {}
for related in ipr.updates:
name, email = get_pseudo_submitter(related.target)
email_to_name[email] = name
if email in email_to_iprs:
email_to_iprs[email].append(related.target)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.