id stringlengths 20 20 | title stringclasses 1
value | text stringlengths 8 768k |
|---|---|---|
ffdcee826bfc91249019 | def __init__(self, url):
if url.startswith('http'):
pos = url.find("//")
url = url[pos + 2 : ]
pos = url.find('/')
url = url[pos : ]
self.url = url
self.translated_pages = {}
self.translator = MachineTranslator() | |
ffdd02abdc9dd8c715f7 | def delete(self, id_or_filename):
raise NotImplementedError | |
ffdd11e55ff73b110ad6 | def get_offsets(self):
# Compute id offsets.
offsets = []
offsets.append(0)
for i in range(len(self.all_pts)-1): # Skip last camera size, not needed.
offsets.append(self.all_pts[i].shape[1])
offsets = np.array(offsets)
offsets = np.cumsum(offsets)
return offsets | |
ffdd167573dba2a8102c | def parent_selection(self, population):
# 1) set most recent fitness values
self.set_biased_population_fitness(population)
# 2) select two candidate parents
# get random subset
parents = []
w1 = len(population["feasible"])
w2 = len(population["infeasible"])
... | |
ffdd4bd462142fed5ca0 | def get_counts(log, tenant_id): | |
ffdd8d593588285aca85 | def test_runInteraction_error(self):
db = sqlite3.connect(':memory:')
mock = create_autospec(db)
runner = BlockingRunner(mock)
def interaction(cursor):
raise Exception('foo')
def check(result):
mock.rollback.assert_called_once_with()
d = runne... | |
ffdd8e3d1ac8d056b815 | def DoubleIt(x):
return 2 * x | |
ffdd903e2be3ce7c44a9 | def _constrain_polymerase(self, the_gene,
basal_fraction = 0):
# check if it is not ExpressedGene no constraint should be defined
if not isinstance(the_gene, ExpressedGene):
return
rnap_footprint_size = 40 # [bp] see docstring of ```_cons... | |
ffdd948e4edf041262a1 | def cross_product(p0,p1,p2):
return (((p2[0]-p0[0])*(p1[1]-p0[1]))-((p1[0]-p0[0])*(p2[1]-p0[1]))) | |
ffdd9b24c22d5e08b4bc | def getDataFrameFromSourceSparkCode():
return filterDataFrameSparkCode() + aggDataFrameSparkCode() + splitColumnSparkCode() + '''
def getDataFrameFromSource(jsonData, hdfsHost="spark-master0", hdfsPort="9000",
rootFolder="/users", removedColsDict={}, maxRowCount=10000):
"... | |
ffdd9bf1bd8d41dcbb70 | def handle_edit_post(post_id):
post = Post.query.get_or_404(post_id)
post.title = request.form['title']
post.content = request.form['content']
db.session.add(post)
db.session.commit()
flash(f"Post '{post.title}' edited.")
return redirect(f"/users/{post.user_id}") | |
ffddc601c0609c790abb | def dependency_order(self) -> Iterator[WorkflowNode]:
prune = [key for (key, value) in self.nodes.items() if "key" not in value]
if prune:
graph = self.copy()
for nid in prune:
graph.remove_node(nid)
else:
graph = self
itr = iter(
... | |
ffddcd89e93876b1764b | def get_cheapest_edge(self):
data_list = self.get_sorted_data_list()
return data_list[0] | |
ffddd7b2d8854a60a988 | def search(request):
context = get_global_context(request)
return render(request, 'app/search.html', context) | |
ffddec000d91aeac3099 | def process_prev_equality(self):
self.process_prev_multiplication()
if self.prev_operator == "+" or self.prev_operator == "-":
self.operators.pop()
self.py_lines.append("y = stack.pop()")
self.py_lines.append(f"x = y {self.prev_operator} x")
self.update_pr... | |
ffddf5424c85a39c4615 | def add_item_elements(self, handler, item):
pass | |
ffde01574aac3ade9080 | def update_num_cust_groups(self, attr, old, new):
self.update_num_price_groups()
for i in range(new):
if i + 1 > len(self.cust_groups):
self.cust_groups.append(PriceGroup(name='Customer Group #{}'.format(i + 1), pg_type='Customer'))
self.cust_groups[i].name.on_ch... | |
ffde167dfb4c570d0528 | def print_info(self):
for level in self.levels:
level.print_info() | |
ffde17eb39612f4d05e8 | def outbound_csv(self):
# pylint: disable=unused-argument
print("outbound_csv started:" + datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
session = create_session()
db_session = session()
new_submissions = db_session.query(Submission).filter(Submission.csv_date_processed.is_(None))
# create csvs... | |
ffde184d8f5b86d5a02b | def group_norm_composite(x, scale, bias, epsilon, groups, data_layout):
# original GroupNorm op cannot support NHWC format
assert data_layout == 'NCHW'
N, C, H, W = x.shape
is_amp = False
from paddle.fluid.data_feeder import convert_dtype
dtype = convert_dtype(x.dtype)
# when inputs are fl... | |
ffde1e081adae25b8f72 | def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
assert logits.dim() == 1 # batch size 1 for now - could be updated for more but the code would be less clear
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability le... | |
ffde211ab1b06cec8002 | def replace_digraphs(word: str) -> str:
for digraph, replacement in REPLACEMENTS.items():
word = word.replace(digraph, replacement)
return word | |
ffde226e05b95793c872 | def run_batch_evaluation(model, session):
batch_count = 0.0
loss = 0.0
accuracy = 0.0
while True:
try:
batch_loss, batch_accuracy, batch_size, _ = model.eval(session)
loss += batch_loss
accuracy += batch_accuracy
batch_count += 1
except tf.... | |
ffde40070ad44dddae6d | def custom_openapi():
if app.openapi_schema:
return app.openapi_schema
openapi_schema = get_openapi(
title="The VICC Therapy Normalizer",
version=__version__,
openapi_version="3.0.3",
description="Normalize drugs and other therapy terms.",
routes=app.routes
)
... | |
ffde6245dba426590c06 | def on_deleted(self): | |
ffde92d131b8eb78b7ae | def csv_writer(cluster, csv_path_cpu):
csv_file = open(csv_path_cpu, "wb")
for node in cluster:
if hasattr(node, 'cpu_obj'):
node_data = node.cpu_obj.data_array
for row in node_data:
for item in row:
if item.replace(".", "", 1).isdigit():
... | |
ffdecd14fb07fd23576c | def init_ftp():
ftp = FTP()
ftp.connect("218.95.37.249", 4449, 10)
ftp.login("greatbit", "greatbit@jshb")
return ftp | |
ffdf070b2000e9c93269 | def add_software_versions(meta, args):
programs = {
"blastn": {"flag": "-version", "regex": r":\s*(\S+)$"},
"blobtools": {"regex": r"\s+v(\S+)$"},
"busco": {"regex": r"\s+(\S+)$"},
"diamond": {"regex": r"version\s*(\S+)$"},
"minimap2": {"regex": r"(\S+)"},
"mosdepth":... | |
ffdf0e126e1e855c285c | def pad_and_mask(X):
zeros = np.zeros(X.shape[1:])[np.newaxis]
X = np.vstack([zeros, X])
mask = np.zeros(X.shape)
mask[0] = True
return ma.array(X, mask=mask) | |
ffdf1b9f4fca26b010b0 | def buildTheta():
mylambda = 0.
initial_theta = np.zeros((X.shape[1],1)).reshape(-1)
Theta = np.zeros((10,X.shape[1]))
for i in xrange(10):
iclass = i if i else 10 #class "10" corresponds to handwritten zero
print "Optimizing for handwritten number %d..."%i
logic_Y = np.array([1 ... | |
ffdf309e92d4954d3a3e | def is_palindrome(text):
text = remove_punc(text)
return text.upper() == reverse(text).upper() | |
ffdf4aee16933c1861e8 | def getAlbumMinMaxIds(self):
min_album_query = "select min(id) as min from lychee_albums"
max_album_query = "select max(id) as max from lychee_albums"
try:
min = -1
max = -1
cur = self.db.cursor()
cur.execute(min_album_query)
rows = cu... | |
ffdf5a8fa28a5a3a82af | def match(self, s: str) -> bool: | |
ffdf63a63116166fc027 | def BandCopy(A, B, copymu, copyml):
cvodes.BandCopy(A.data, B.data, copymu, copyml) | |
ffdf93a1d04d71e3c732 | def vf_to_vv(self, vertices, simplices):
if self.dim > 1:
for s in simplices:
edges = itertools.combinations(s, self.dim)
for e in edges:
self.V[tuple(vertices[e[0]])].connect(
self.V[tuple(vertices[e[1]])])
else:
... | |
ffdf9f103223702c65e0 | def build(self):
# add placeholders
self.add_placeholders_op()
# create policy net
self.build_policy_network_op()
# add square loss
self.add_loss_op()
# add optmizer for the main networks
self.add_optimizer_op()
# add baseline
if self.config.use_baseline:
self.add_baselin... | |
ffdfde5f22252e8fef3b | def build_model_b(device: str) -> Model:
return RandomBaseline() | |
ffdfe38f695032302479 | def extract_content(html_soup):
text = ''
if html_soup.findAll('div', attrs = {"itemprop" : "articleBody"}) is not None:
temp_soup = html_soup.find('div', attrs = {"itemprop" : "articleBody"})
soup = temp_soup.findAll('p')
for s in soup:
text = text + ' ' + s.text
else:
... | |
ffdfec061b1c1efb9de5 | def get_pressure(self):
# voltage_pressure = self.pressure_sensor.getVoltage()
# new_value = (250 * voltage_pressure / 5) - 25
# self._pressure_samples.append(new_value)
# if not self.pressure_timer.hasPeriodPassed(self.pressure_timer_delay):
# return self._last_pressure_value
# # Calculate new running... | |
ffdfff2edb338d46fc1a | def test_display_delete(self):
pass | |
ffe0259c0bae90b6b6f4 | def placeOrders(self, bid, ask):
#if (not self.traded) and (self.weigth > 0) and bid and ask:
# quantity = floor(self.starting_cash * self.weigth / self.getCurrentMidPrice(bid, ask))
# self.placeMarketOrder(self.symbol, quantity, True, ignore_risk=False)
# self.traded = True
... | |
ffe0437db912917f97bf | def test_viewing_flights_after_being_added(self):
self.create_admin_user()
response2 = self.login_user('test@gmail.com', 'tesTing123')
access_token = json.loads(response2.data.decode())['auth_token']
add_flight = self.client.post(
'/api/v1/flights',
headers=dict(A... | |
ffe0490a79fd4aeb6278 | def send_find(self, contact, target, message_type):
msg_dict = {
'uuid': str(uuid4()),
'recipient': contact.public_key,
'sender': self.public_key,
'reply_port': self.reply_port,
'version': self.version,
'key': target,
}
seal... | |
ffe076f86e57b0af4164 | def _set_green_phase(env, action_number):
if action_number == 0:
env.trafficlight.setPhase("TL", PHASE_NSL_GREEN)
elif action_number == 1:
env.trafficlight.setPhase("TL", PHASE_WEL_GREEN)
elif action_number == 2:
env.trafficlight.setPhase("TL", PHASE_S_EL_GREEN)
elif action_numbe... | |
ffe091cf14f271707f95 | def create_recipe(self, payload={}, *args, **kwargs):
endpoint = "/products"
method = "POST"
return self.make_request(endpoint, json.dumps(payload), method) | |
ffe0bd6bd0e1606e323c | def is_installed(name): | |
ffe0bd7b756b56c177fe | def Version(self) -> _n_0_t_5: | |
ffe13bf20f71483b93ed | def __init__(self, board=None):
self.board = board | |
ffe18a5ffa53a9e47e0b | def queueIsEmpty() :
return clear.isSet() | |
ffe191bf7b6739c5b099 | def process(sess, net, im):
timer = Timer()
timer.tic()
# Detect all object classes and regress object bounds
scores, boxes = im_detect(sess, net, im)
timer.toc()
# print ('Detection took {:.3f}s for '
# '{:d} object proposals').format(timer.total_time, boxes.shape[0])
return score... | |
ffe196a4773095d5695a | def get_column_names(self):
return self.columns[1:] | |
ffe1c52d5095e2d92262 | def random_string(length=10):
return "".join( # nosec
random.choice(string.ascii_lowercase) for x in range(length)
) | |
ffe1f6891b79452d7610 | def __str__(self):
if self.size == 0:
return "Empty Stack"
output = []
for i in range(self.size):
output.append(str(self.data[i]))
return "{} Capacity: {}".format(output, str(self.capacity)) | |
ffe2069393ecaa32c97b | def __add_page_generation_options(self, menu):
category_name = _("Page Generation")
addopt = partial(menu.add_option, category_name)
homenote = NoteOption(_('Home page note'))
homenote.set_help( _("A note to be used on the home page"))
addopt( "homenote", homenote )
hom... | |
ffe21ad876cae1fa393a | def test_parametrizedClock(self):
clock = Clock()
s, e, f = self.make_reconnector()
s.clock = clock
s.startService()
self.assertEqual(len(clock.calls), 1) | |
ffe22ab956d4017605cc | def binom(n, k):
# http://blog.plover.com/math/choose.html
if k > n:
return 0
if k == 0:
return 1
result = 1
for denom in range(1, k + 1):
result *= n
result /= denom
n -= 1
return result | |
ffe2406580a927537fa0 | def getAction(self, gameState):
"*** YOUR CODE HERE ***"
if '--ghost' in sys.argv:
return random.choice(gameState.getLegalActions())
alpha = -float("inf")
beta = float("inf")
depth = 0
score, action = self.minMax(gameState, depth, alpha, beta, self.index)
... | |
ffe24abbbd3015477da4 | def build_code(self):
raise NotImplementedError('build_code is not implemented') | |
ffe24c0f33d5a5dd996b | def overlap_array(a,b):
y1=max(a[:,0],b[0])
x1=max(a[:,1],b[1])
y2=min(a[:,2],b[2])
x2=min(a[:,3],b[3])
w=x2-x1+1
h=y2-y1+1
inter = w * h
areaa = (a[:,2]-a[:,0]+1) * (a[:,3]-a[:,1]+1)
areab = (b[2]-b[0]+1) * (b[3]-b[1]+1)
o = inter / float(areaa+areab-inter)
o[w<0]=0
o[h<... | |
ffe24ca4285ec00c66b7 | def execute_sql(self, sql_str):
self.c.execute(sql_str)
return self.c.fetchall() | |
ffe26f14c806e0837068 | def verify(sig, msg, vk):
try:
result = libnacl.crypto_sign_open(sig + msg, vk)
except Exception as ex:
return False
return True if result else False | |
ffe273237a052263140b | def to_dict(self):
return {
'message': 'Resource %s with key %s is already locked.' %
(self.name, self.key),
'code': 'RESOURCE_LOCKED',
'details': {
'name': self.name,
'key': self.key
}
} | |
ffe27418f9b7f704a4ce | def response(self, prompt_from_human):
return "It is very interesting that you say: '" + prompt_from_human + "'" | |
ffe28be5a032640bc9e9 | def create(openstack_resource):
created_resource = openstack_resource.create()
ctx.instance.runtime_properties[RESOURCE_ID] = \
created_resource.id
ctx.instance.runtime_properties['private_key'] = \
created_resource.private_key
ctx.instance.runtime_properties['public_key'] = \
cr... | |
ffe29636241ba0361070 | def _model_(self, records):
# model = self.__model__(record)
# return model
raise NotImplementedError | |
ffe297487d38b43c6868 | def set_enabled(self, enabled):
self.enabled = enabled | |
ffe2aebecd1be6529109 | def add(self, metric):
self.metrics.append(create(metric)) | |
ffe2f8cd4586a759c5f4 | def plot_choropleth_map(
regions,
regionaldata_input,
regional_sigs=None,
fig=None,
ax=None,
vrange=[-1, 1],
vstep=0.2,
vmid=None,
cpal="RdBu_r",
badcol="dimgrey",
undercol="magenta",
overcol="yellow",
bar_orientation="horizontal",
bar_position=None,
extendcol... | |
ffe3024a9eba38d65cf3 | def __calcPeriodogram(self):
# Build frequency array if not present
if self.freq is None:
plow = max(0.5, 2*ediff1d(self.t).min()) # minimum meaningful period?
self.__buildFreq(plow=plow)
# Circular frequencies
omegas = 2.*pi * self.freq
err2 = self.error*self.error
w = (1. / sum(1... | |
ffe328d381f7d4fd0d55 | def _check_for_dispersable_models(self):
for i, model in enumerate(self.models):
try:
callable(model.rotational_harmonics_representation)
except AttributeError:
msg = "Cannot disperse models input {}. ".format(i)
msg += "It has no rotationa... | |
ffe3527bc802f56222aa | def setInterval( self, value ):
value = int( value )
server = getToolByName( self, 'MailServer', None )
if server and server.min_interval is not None:
if value < server.min_interval:
value = server.min_interval
self.mail_interval = value
# update ta... | |
ffe35590eae45816e774 | def testNoiseSpectralDensity(mcp):
# First, disable the motor so that the associated noise (hopefully) goes away
mcp['device'].motorEnable = False
desiredMeasurements = 10000
halfMeasurements = int(desiredMeasurements/2)
samplingFrequency = 4.68 # kHz
frequencies = np.arange(0, samplingFrequenc... | |
ffe36d5557c747bb19fe | def test_new_user_email_normalized(self):
email = 'dtruong3@YAHOO.COM'
user = get_user_model().objects.create_user(email, 'test123')
self.assertEqual(user.email, email.lower()) | |
ffe37c4848a0fb64a84f | def edit_post():
form = PostForm()
if form.validate_on_submit():
postform = Post(lab=form.lab.data,
position=form.position.data,
details=form.details.data,
requirements=form.requirements.data,
img_addr... | |
ffe38df5a6682be1bae7 | def add(self, txs):
with self.lock:
# here we store all addresses in transactions
# to set them used later
addresses = []
# first we add all transactions to cache
for txid in txs:
tx = txs[txid]
# find minimal from 3 tim... | |
ffe3b9f3b884b911b16e | def r_get(self, k):
return util.class_getvalue(self, k) | |
ffe3bc9c20045d4fc6c1 | def validate_precedence(operator1, operator2):
if precedences_dic[operator1] == precedences_dic[operator2] and precedences_dic[operator1] == 3.9:
return False
else:
return precedences_dic[operator1] >= precedences_dic[operator2] | |
ffe3bd9bbf81b87a4845 | def test_retrieve_tags(self):
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res... | |
ffe3fb6eb1aab2a204de | def test_aall_param_a1(self):
with self.assertRaises(TypeError):
result = arrayfunc.aall()
# Check that the exception raised corresponds to the native Python behaviour.
with self.assertRaises(TypeError):
result = all() | |
ffe3fed9b29c04a2e9b3 | def getPreviousBuild(): | |
ffe42e36d311384510d7 | async def shutdown_requests(self, app):
for task, request in dict(self.running_requests).items():
task.cancel() | |
ffe43ad82ddcdb4d78e8 | def _link_edges(self):
index_id_dict = {i: v.id for i, v in enumerate(self._vertices)}
id_index_dict = {v_id: v_index for v_index, v_id in
index_id_dict.items()}
# Fill in the vertices' `index` attribute
for v in self._vertices:
v.index = id_index_di... | |
ffe440ae134d167d6447 | def _find_string_start(self, template, start_index, end_index):
quote_regex = re.compile(r"""['"]""")
start_match = quote_regex.search(template, start_index, end_index)
if start_match is None:
return None
else:
return start_match.start() | |
ffe449b597f3c4c76dc7 | def dump_datetime(value):
if value is None:
return None
return [value.strftime("%Y-%m-%d"), value.strftime("%H:%M:%S")] | |
ffe4b600874cad9c5fb2 | def SUM(attribute):
if callable(attribute):
def aggfunc(obj, current_agg_value):
a, b = current_agg_value, attribute(obj)
if a is None:
return b
if b is None:
return a
return a + b
else:
def aggfunc(obj, current_agg_... | |
ffe4c1b0325fb700a410 | def get_pretty(string):
content_type = detect_content_type(string)
if content_type == CONTENT_TYPES['json']:
d = json.loads(string)
return json.dumps(d, indent=2)
else:
return string | |
ffe5005f90f3f4bbd241 | def DNA_to_RNA(input_DNA):
for letter in input_DNA:
if letter == "T":
RNA_seq = input_DNA.replace ("T", "U")
return RNA_seq | |
ffe50153a4ea19e3bf35 | def __str__(self):
attribs_str = ""
if self.border:
self.attribs['border'] = self.border
if self.style:
self.attribs['style'] = self.style
if self.width:
self.attribs['width'] = self.width
if self.cellspacing:
self.attribs['cellspac... | |
ffe507861f1addbc26a8 | def testParseOptions(self):
options = cli_test_lib.TestOptions()
output_module = MockOutputModule()
database_config.DatabaseArgumentsHelper.ParseOptions(options, output_module)
with self.assertRaises(errors.BadConfigObject):
database_config.DatabaseArgumentsHelper.ParseOptions(options, None)
... | |
ffe51d17c22db3682801 | def playback_queue_cleared(self):
header = {'namespace': 'AudioPlayer',
'name': 'PlaybackQueueCleared'}
self._connection.send_event(header) | |
ffe54b4f5bc8776d9083 | def get_timestamp_string():
n = datetime.datetime.now()
return "%04d-%02d-%02d--%02d-%02d-%02d" % (
n.year,
n.month,
n.day,
n.hour,
n.minute,
n.second) | |
ffe583d052a9f464fe55 | def printInfo(self):
print('Number of inputs =', self.n_inputs)
print('Number of outputs =', self.n_outputs)
print('Number of units =', self.n_units)
print('Number of layers =', self.n_layers)
print('Number of params =', self.n_params)
print('Data type =', dtype) | |
ffe59026985aea82450e | def activate_sampler():
try:
sdi_reply = sdi_collect(sdi_addy, sdi_cmd, sdi_bus)
sample_slot = int(sdi_reply[0])
except (Sdi12Error, ValueError):
sample_slot = -1
return sample_slot | |
ffe5a6edd3a0c5b5e653 | def test_load_extra_params(self, gbq_sql_dataset, load_args):
for key, value in load_args.items():
assert gbq_sql_dataset._load_args[key] == value | |
ffe5b29d587562f7f86e | def _update_outfile(self, buffer):
if self._outfile:
if self._prefix_state:
prefix = "\n%20s| " % self._state
buffer = buffer.replace('\n', prefix)
self._outfile.write(buffer)
self._outfile.flush() | |
ffe5ba54c47489a26b3f | def branch(self, possible_paths: List[Tuple[Node]],
relevant_reads: RelevantReads) -> List[HaplotypeSet]:
new_haplotype_sets = []
for haplotype_set in self.candidate_sets:
new_haplotype_sets.extend(
self.generate_new_hsets(haplotype_set, possible_paths,
... | |
ffe5ed10d868d33611e2 | def data_user(id):
"""Get user from db"""
user = User.query.get(id)
"""get all related posts to the users"""
posts = user.posts
return render_template('user.html', user=user, posts = posts) | |
ffe5f92f5db5e801ad2a | def attribute_string(cls, attributes, replace_xml_characters=True):
if not attributes:
return ""
if replace_xml_characters:
string = " " + " ".join([key + '="' + str(value).replace('"', '"') + '"' for key, value in
attributes.items()])
... | |
ffe6036993498addfd62 | def make_request(url, headers):
r = None
try:
r = requests.get(url, headers=headers)
except Exception as e:
raise e
return r | |
ffe60a8176309365d3b5 | def __init__(self, msg, path_to_item=None, valid_classes=None,
key_type=None):
self.path_to_item = path_to_item
self.valid_classes = valid_classes
self.key_type = key_type
full_msg = msg
if path_to_item:
full_msg = "{0} at {1}".format(msg, render_path... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.