common_id
stringlengths 1
5
| image
stringlengths 15
19
| code
stringlengths 26
239
|
|---|---|---|
7427
|
Train/png/7427.png
|
def tran_hash(self, a, b, c, n):
return (((TRAN[(a+n) & 255] ^ TRAN[b]*(n+n+1))+TRAN[(c) ^ TRAN[n]]) & 255)
|
1437
|
Train/png/1437.png
|
def watch_firings(self, flag):
lib.EnvSetDefruleWatchFirings(self._env, int(flag), self._rule)
|
7059
|
Train/png/7059.png
|
def T(self, ID, sign):
lon = self.terms[sign][ID]
ID = 'T_%s_%s' % (ID, sign)
return self.G(ID, 0, lon)
|
6930
|
Train/png/6930.png
|
def gtype(n):
t = type(n).__name__
return str(t) if t != 'Literal' else 'Literal, {}'.format(n.language)
|
7899
|
Train/png/7899.png
|
def open_browser(self):
webbrowser.open(
"http://{host}:{port}/".format(host=self.host, port=self.port))
|
9708
|
Train/png/9708.png
|
def _check_surrounded_by_space(self, tokens, i):
self._check_space(tokens, i, (_MUST, _MUST))
|
582
|
Train/png/582.png
|
def lock_account(self, minutes=30):
period = datetime.timedelta(minutes=minutes)
self.locked_until = datetime.datetime.utcnow() + period
|
5835
|
Train/png/5835.png
|
def _zlib_no_compress(data):
cobj = zlib.compressobj(0)
return b"".join([cobj.compress(data), cobj.flush()])
|
3715
|
Train/png/3715.png
|
def getStatus(self):
command = '$GS'
status = self.sendCommand(command)
return states[int(status[1])]
|
6091
|
Train/png/6091.png
|
def add_task(self, func, *args, **kargs):
self.tasks_queue.put((func, args, kargs))
|
712
|
Train/png/712.png
|
def enable_all_links():
for link in client.list_data_links(instance='simulator'):
client.enable_data_link(instance=link.instance, link=link.name)
|
4788
|
Train/png/4788.png
|
def cli(yamlfile, format, context):
print(JSONLDGenerator(yamlfile, format).serialize(context=context))
|
8330
|
Train/png/8330.png
|
def accel_zoom_in(self, *args):
for term in self.get_notebook().iter_terminals():
term.increase_font_size()
return True
|
9397
|
Train/png/9397.png
|
def color(self):
color = idc.GetColor(self.ea, idc.CIC_ITEM)
if color == 0xFFFFFFFF:
return None
return color
|
1337
|
Train/png/1337.png
|
def center_str(txt, font_name, font_size, offset=0):
return -(text_width(txt, font_name, font_size) / 2.0) + offset
|
9089
|
Train/png/9089.png
|
def popAsk(text, title="Lackey Decision"):
root = tk.Tk()
root.withdraw()
return tkMessageBox.askyesno(title, text)
|
8143
|
Train/png/8143.png
|
def delete(self, callback=None, errback=None):
return self._rest.delete(self.data['id'], callback=callback, errback=errback)
|
9233
|
Train/png/9233.png
|
def topics_in(self, d, topn=5):
return self.theta.features[d].top(topn)
|
8259
|
Train/png/8259.png
|
def pause(self):
self._mq.send("p", True, type=1)
self._paused = True
|
1728
|
Train/png/1728.png
|
def disable(self):
for arr in self:
if arr.psy.plotter:
arr.psy.plotter.disabled = True
|
2495
|
Train/png/2495.png
|
def major_rise_per_monomer(self):
return numpy.cos(numpy.deg2rad(self.curve.alpha)) * self.minor_rise_per_residue
|
8823
|
Train/png/8823.png
|
def labels(self):
return tuple(_Label(label.get('id'), label.get('color'), label.text) for label
in self.root.iter('label'))
|
2473
|
Train/png/2473.png
|
def stop_pages(self):
await self.bot.delete_message(self.message)
self.paginating = False
|
7398
|
Train/png/7398.png
|
def edit_form(self, obj):
form = super(OAISetModelView, self).edit_form(obj)
del form.spec
return form
|
9802
|
Train/png/9802.png
|
def compute(self, tdb, tdb2=0.0):
for position in self.generate(tdb, tdb2):
return position
|
5135
|
Train/png/5135.png
|
def get(path):
try:
import cPickle as pickle
except:
import pickle
with open(path, 'rb') as file:
return pickle.load(file)
|
7214
|
Train/png/7214.png
|
def detail(self, detail=None, ret_r=False):
if detail or ret_r:
self._detail = detail
return self
return self._detail
|
3308
|
Train/png/3308.png
|
def deepcopy(data):
try:
return pickle.loads(pickle.dumps(data))
except TypeError:
return copy.deepcopy(data)
|
1181
|
Train/png/1181.png
|
def complete_opt_allow_select_scan(self, text, *_):
return [t for t in ("true", "false", "yes", "no") if t.startswith(text.lower())]
|
2660
|
Train/png/2660.png
|
def deriv(self, mu):
p = self._clean(mu)
return 1 + 2 * self.alpha * p
|
7554
|
Train/png/7554.png
|
def getCheck(self, checkid):
check = PingdomCheck(self, {'id': checkid})
check.getDetails()
return check
|
1698
|
Train/png/1698.png
|
def iterchunks(data, chunksize):
offt = 0
while offt < len(data):
yield data[offt:offt+chunksize]
offt += chunksize
|
5069
|
Train/png/5069.png
|
def validate_name(ctx, param, value):
if not value:
value = os.path.basename(ctx.params['directory'].rstrip(os.path.sep))
return value
|
751
|
Train/png/751.png
|
def setEditor(self, name):
editor = get_stimulus_editor(name)
self.editor = editor
self._stim.setStimType(name)
|
2117
|
Train/png/2117.png
|
def get_count(self, request, notifications, mark_as_read=False):
return Response({'count': notifications.filter(is_read=False).count()})
|
4125
|
Train/png/4125.png
|
def save(self):
with open(self.filename, 'w') as f:
ujson.dump(self.config, f, indent=4)
|
5189
|
Train/png/5189.png
|
def raw_escape(pattern, unix=False):
pattern = util.norm_pattern(pattern, False, True)
return escape(pattern, unix)
|
8658
|
Train/png/8658.png
|
def cas2mach(Vcas, H):
Vtas = cas2tas(Vcas, H)
Mach = tas2mach(Vtas, H)
return Mach
|
4492
|
Train/png/4492.png
|
def configure(self, options, conf):
self.conf = conf
self.when = options.browser_closer_when
|
6146
|
Train/png/6146.png
|
def add_output_opt(self, opt, out):
self.add_opt(opt, out._dax_repr())
self._add_output(out)
|
3801
|
Train/png/3801.png
|
def prep_regex(patterns):
flags = 0 if Config.options.case_sensitive else re.I
return [re.compile(pattern, flags) for pattern in patterns]
|
7231
|
Train/png/7231.png
|
def files(self):
self._check_session()
status, data = self._rest.get_request('files')
return data
|
2140
|
Train/png/2140.png
|
def flags(self):
return set((name.lower() for name in sorted(TIFF.FILE_FLAGS)
if getattr(self, 'is_' + name)))
|
4732
|
Train/png/4732.png
|
def today(self, chamber):
"Return today's votes in a given chamber"
now = datetime.date.today()
return self.by_range(chamber, now, now)
|
4418
|
Train/png/4418.png
|
def flatten(self, obj):
return [self._serialize(f, obj) for f in self.fields]
|
2650
|
Train/png/2650.png
|
def hmean(x, weights=None):
w_arr, x_arr = _preprocess_inputs(x, weights)
return w_arr.sum(axis=0) / (w_arr/x_arr).sum(axis=0)
|
7683
|
Train/png/7683.png
|
def log(self, *args):
print("%s %s" % (str(self).ljust(8), " ".join([str(x) for x in args])))
|
9455
|
Train/png/9455.png
|
def create(message_type, priority=0):
message = protobuf.ProtocolMessage()
message.type = message_type
message.priority = priority
return message
|
1529
|
Train/png/1529.png
|
def fw_policy_create(self, data, fw_name=None, cache=False):
LOG.debug("FW Policy Debug")
self._fw_policy_create(fw_name, data, cache)
|
296
|
Train/png/296.png
|
def _onWhat(self, name, line, pos, absPosition):
self.__lastImport.what.append(ImportWhat(name, line, pos, absPosition))
|
5956
|
Train/png/5956.png
|
def PrintSeparatorLine(self):
self._output_writer.Write('-' * self._LINE_LENGTH)
self._output_writer.Write('\n')
|
1300
|
Train/png/1300.png
|
def upd_data(self, *args):
data = [self.munge(k, v) for k, v in self.iter_data()]
self.data = sorted(data, key=lambda d: d['key'])
|
2157
|
Train/png/2157.png
|
def make_tsv_row(values: List[Any]) -> str:
return "\t".join([tsv_escape(x) for x in values]) + "\n"
|
558
|
Train/png/558.png
|
def record_content_length(self):
untldict = py2dict(self)
untldict.pop('meta', None)
return len(str(untldict))
|
2879
|
Train/png/2879.png
|
def update(self, *args, **kwargs):
self._call_helper("Updating", self.real.update, *args, **kwargs)
|
3385
|
Train/png/3385.png
|
def rm_subsets(ctx, dataset, kwargs):
"removes the dataset's training-set and test-set folders if they exists"
kwargs = parse_kwargs(kwargs)
data(dataset, **ctx.obj).rm_subsets(**kwargs)
|
7675
|
Train/png/7675.png
|
def post_parse(self):
if self.cache and not self.cache_loaded:
self.cache_writer_cls(self.file_name, self.wavefront).write()
|
6599
|
Train/png/6599.png
|
def dropout(tensor, drop_prob, is_training):
if not is_training:
return tensor
return tf.nn.dropout(tensor, 1.0 - drop_prob)
|
6357
|
Train/png/6357.png
|
def pack(o, stream, **kwargs):
packer = Packer(**kwargs)
stream.write(packer.pack(o))
|
3904
|
Train/png/3904.png
|
def run_local(client):
webbrowser.open(client.get_auth_uri())
code = wait_for_redirect()
return client.get_token(code)
|
4113
|
Train/png/4113.png
|
def init(vcs):
path = os.path.join(vcs.private_dir(), 'locks')
if not os.path.exists(path):
os.mkdir(path)
|
3884
|
Train/png/3884.png
|
def md5hash(self):
digest = hashlib.md5(self.content).digest()
return b64_string(digest)
|
2825
|
Train/png/2825.png
|
def conv_variant(self, column, name, **kwargs):
return self.convert(str(column.type), column, name, **kwargs)
|
6047
|
Train/png/6047.png
|
def import_path(self):
return os.path.join(self.remote_root, self.pkg) if self.pkg else self.remote_root
|
2885
|
Train/png/2885.png
|
def parse(self, text):
token_stream = self.lexer.tokenize(text)
return self.expr(token_stream, next(token_stream))
|
4237
|
Train/png/4237.png
|
def db(self):
if self.database is NotImplemented:
self.database = Session
return self.database
|
3695
|
Train/png/3695.png
|
def server(port):
args = ['python', 'manage.py', 'runserver']
if port:
args.append(port)
run.main(args)
|
9635
|
Train/png/9635.png
|
def __coord_chroma(n, bins_per_octave=12, **_kwargs):
return np.linspace(0, (12.0 * n) / bins_per_octave, num=n+1, endpoint=True)
|
1283
|
Train/png/1283.png
|
def remove_element(self, e):
if e.label is not None:
self.elementdict.pop(e.label)
self.elementlist.remove(e)
|
1816
|
Train/png/1816.png
|
def _get_storage(self):
if self._json is None:
self._json = Storage.objects.get(**self._kwargs).json
|
6881
|
Train/png/6881.png
|
def to_dict(self):
users = dict(users=list())
for user in self:
users['users'].append(user.to_dict())
return users
|
2966
|
Train/png/2966.png
|
def byteswap(data, word_size=4):
return reduce(lambda x, y: x+''.join(reversed(y)), chunks(data, word_size), '')
|
3618
|
Train/png/3618.png
|
def can_edit(self, user):
return user.is_admin or not self.is_locked and self in user.admin_for
|
2338
|
Train/png/2338.png
|
def set_to_public(self, request, queryset):
queryset.update(is_public=True, modified=now())
|
7363
|
Train/png/7363.png
|
def call_fset(self, obj, value) -> None:
vars(obj)[self.name] = self.fset(obj, value)
|
3691
|
Train/png/3691.png
|
def __fade_out(self):
self.__timer.stop()
self.__vector = -self.__fade_speed
self.__timer.start()
|
2445
|
Train/png/2445.png
|
def visit_Attribute(self, node: AST, dfltChaining: bool = True) -> str:
return '.'.join((self.visit(node.value), node.attr))
|
4893
|
Train/png/4893.png
|
def append(self, point):
point = Point(point)
self._elements.append(point)
|
9774
|
Train/png/9774.png
|
def run(self, data_x):
output_vars = self.compute(*data_x)
return self._extract_costs(output_vars)
|
6696
|
Train/png/6696.png
|
def set_as_data(self, as_data):
self._as_data = as_data
self.asDataChanged.emit(as_data)
|
1504
|
Train/png/1504.png
|
def count(self, weighted=True):
return self._measures.weighted_n if weighted else self._measures.unweighted_n
|
7881
|
Train/png/7881.png
|
def already_coords(self, address):
m = re.search(self.COORD_MATCH, address)
return (m != None)
|
926
|
Train/png/926.png
|
def X_length(self, new_window_length):
self.parent.value('window_length', new_window_length)
self.parent.overview.update_position()
|
2054
|
Train/png/2054.png
|
def get_nanopub(url):
r = bel.utils.get_url(url, cache=False)
if r and r.json():
return r.json()
else:
return {}
|
7545
|
Train/png/7545.png
|
def assert_le(left, right, message=None, extra=None):
assert left <= right, _assert_fail_message(
message, left, right, ">", extra)
|
6956
|
Train/png/6956.png
|
def dump_children(self, f, indent=''):
for child in self.__order:
child.dump(f, indent+' ')
|
6659
|
Train/png/6659.png
|
def htmlDocDump(self, f):
ret = libxml2mod.htmlDocDump(f, self._o)
return ret
|
2307
|
Train/png/2307.png
|
def get_seed_sub(self, label):
sx, sy, sz = np.nonzero(self.seeds == label)
return sx, sy, sz
|
3667
|
Train/png/3667.png
|
def set_meta(self, name, format, *args):
return lib.zcert_set_meta(self._as_parameter_, name, format, *args)
|
9242
|
Train/png/9242.png
|
def safe_lshift(a, b):
if b > MAX_SHIFT:
raise RuntimeError(
"Invalid left shift, max left shift is {}".format(MAX_SHIFT))
return a << b
|
9940
|
Train/png/9940.png
|
def _edges_changed(self, object, name, undefined, event):
self._delete_edges(event.removed)
self._add_edges(event.added)
|
7491
|
Train/png/7491.png
|
def load_blind(self, item):
blind = Blind.from_config(self.pyvlx, item)
self.add(blind)
|
3619
|
Train/png/3619.png
|
def can_edit(self, user):
return self.class_.can_edit(user) and self.status != u'locked'
|
7962
|
Train/png/7962.png
|
def spotlight(self, query, **kwargs):
return self.__call_api_get('spotlight', query=query, kwargs=kwargs)
|
2215
|
Train/png/2215.png
|
def toStr(self):
s = [self.strLegend]
for l in self.lines:
s.append(l.toStr())
return self.lineSeparator.join(s)
|
9949
|
Train/png/9949.png
|
def recv_ping(self, id_=None):
if id_ is None:
self.reply('pong')
else:
self.reply('pong', id=id_)
|
6661
|
Train/png/6661.png
|
def debugDumpAttr(self, output, depth):
libxml2mod.xmlDebugDumpAttr(output, self._o, depth)
|
2364
|
Train/png/2364.png
|
def indent(self, levels, first_line=None):
self._indentation_levels.append(levels)
self._indent_first_line.append(first_line)
|
5146
|
Train/png/5146.png
|
def _case_stmt(self, stmt: Statement, sctx: SchemaContext) -> None:
self._handle_child(CaseNode(), stmt, sctx)
|
1231
|
Train/png/1231.png
|
def _exists(self, path):
if path.endswith('/'):
return True
return self.storage.exists(path)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.