common_id
stringlengths 1
5
| image
stringlengths 15
19
| code
stringlengths 26
239
|
|---|---|---|
4875
|
Train/png/4875.png
|
def get_fetch_response(self, raw):
p = Payload(raw)
p._body = p.body
return p
|
4403
|
Train/png/4403.png
|
def reverse_complement(self, is_RNA=None):
Sequence.reverseComplement(self, is_RNA)
self.seq_qual = self.seq_qual[::-1]
|
6946
|
Train/png/6946.png
|
def reset_game(self):
self.ms_game.reset_game()
self.update_grid()
self.time = 0
self.timer.start(1000)
|
8044
|
Train/png/8044.png
|
def finish(self):
self.update(self.maxval)
if self.signal_set:
signal.signal(signal.SIGWINCH, signal.SIG_DFL)
|
1374
|
Train/png/1374.png
|
def run(self, world: int) -> IO:
text, action = self._value
new_world = pure_print(world, text)
return action(world=new_world)
|
9454
|
Train/png/9454.png
|
def string_tag(name, value):
return name.encode('utf-8') + \
len(value).to_bytes(4, byteorder='big') + \
value.encode('utf-8')
|
4231
|
Train/png/4231.png
|
def clear(self):
if os.path.exists(self.path):
os.remove(self.path)
|
4983
|
Train/png/4983.png
|
def getdrawings():
infos = Info.query.all()
sketches = [json.loads(info.contents) for info in infos]
return jsonify(drawings=sketches)
|
3150
|
Train/png/3150.png
|
def _config_changed(self, data, stat):
self.config = json.loads(data)
if self.cb:
self.cb(self.config)
|
2794
|
Train/png/2794.png
|
def metarate(self, func, name='values'):
setattr(func, name, self.values)
return func
|
6799
|
Train/png/6799.png
|
def out_format(data, out, opts=None, **kwargs):
return try_printout(data, out, opts, **kwargs)
|
8205
|
Train/png/8205.png
|
def _long_from_raw(thehash):
hashnum = 0
for h in thehash:
hashnum <<= 8
hashnum |= ord(bytes([h]))
return hashnum
|
846
|
Train/png/846.png
|
def readSB(self, bits):
shift = 32 - bits
return int32(self.readbits(bits) << shift) >> shift
|
361
|
Train/png/361.png
|
def _tokenize(sentence):
_tokens = nltk.word_tokenize(sentence)
tokens = [stemmer.stem(tk) for tk in _tokens]
return tokens
|
2139
|
Train/png/2139.png
|
def read_lsm_positions(fh):
size = struct.unpack('<I', fh.read(4))[0]
return fh.read_array('<2f8', count=size)
|
934
|
Train/png/934.png
|
def result(self, res):
return self >> Parser(lambda _, index: Value.success(index, res))
|
9563
|
Train/png/9563.png
|
def get_year_start(day=None):
day = add_timezone(day or datetime.date.today())
return day.replace(month=1).replace(day=1)
|
372
|
Train/png/372.png
|
def tag(self, version='bump', message=''):
self.clone_from_github()
self.github_repo.tag(version, message=message)
|
3562
|
Train/png/3562.png
|
def monkey_restore():
for k, v in originals.items():
setattr(time_mod, k, v)
global epoch
epoch = None
|
764
|
Train/png/764.png
|
def _split_keys_v1(joined):
left, _, right = joined.partition('::')
return _decode_v1(left), _decode_v1(right)
|
6828
|
Train/png/6828.png
|
def _is_junction(arg):
return isinstance(arg, dict) and len(arg) == 1 and next(six.iterkeys(arg)) == 'junction'
|
10031
|
Train/png/10031.png
|
def get(*args, **kwargs):
from invenio.modules.communities.models import FeaturedCommunity
q = FeaturedCommunity.query
return q.count(), q.all()
|
8168
|
Train/png/8168.png
|
def max_pool(x, dim):
return tf.nn.max_pool(
x, ksize=[1, dim, dim, 1], strides=[1, dim, dim, 1],
padding='SAME')
|
9364
|
Train/png/9364.png
|
def _get_view_method(self, request):
if hasattr(self, 'action'):
return self.action if self.action else None
return request.method.lower()
|
3025
|
Train/png/3025.png
|
def get_all_chains(self):
return [self.get_chain(i) for i in range(len(self.leaves))]
|
7298
|
Train/png/7298.png
|
def AssignVar(self, value):
self.value = value
# Call OnAssignVar on options.
[option.OnAssignVar() for option in self.options]
|
7375
|
Train/png/7375.png
|
def filepath(self) -> str:
return os.path.join(self._dirpath, self.name + '.nc')
|
4823
|
Train/png/4823.png
|
def closeLog(self):
self._logPtr.close()
if self._namePtr:
self._namePtr.close()
self.log = 0
|
7712
|
Train/png/7712.png
|
def gen_xor(src1, src2, dst):
assert src1.size == src2.size
return ReilBuilder.build(ReilMnemonic.XOR, src1, src2, dst)
|
2000
|
Train/png/2000.png
|
def user(self, email: str) -> models.User:
return self.User.query.filter_by(email=email).first()
|
8038
|
Train/png/8038.png
|
def decompress(data):
with GzipFile(fileobj=io.BytesIO(data)) as f:
return f.read()
|
2197
|
Train/png/2197.png
|
def reset_all(self):
for item in self.inputs:
setattr(self, "_%s" % item, None)
self.stack = []
|
3980
|
Train/png/3980.png
|
def getfunc(obj, name=''):
if name:
obj = getattr(obj, name)
return getattr(obj, '__func__', obj)
|
129
|
Train/png/129.png
|
def linear(self, limits=None, k=5):
start, stop = limits or (self.minval, self.maxval)
return np.linspace(start, stop, k)
|
8777
|
Train/png/8777.png
|
def clear(self):
self._options = []
self._combo_menu.tk.delete(0, END)
self._selected.set("")
|
4126
|
Train/png/4126.png
|
def get(key, section='main'):
return nago.settings.get_option(option_name=key, section_name=section)
|
9883
|
Train/png/9883.png
|
def _fmt(self, string):
if '{' not in string:
string = '{}.' + string
return string.format(self.name)
|
4680
|
Train/png/4680.png
|
def channels(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('GET', '/channels', fields={'topic': topic})
|
1052
|
Train/png/1052.png
|
def request(schema):
def wrapper(func):
setattr(func, REQUEST, schema)
return func
return wrapper
|
3517
|
Train/png/3517.png
|
def post(self, endpoint: str, **kwargs) -> dict:
return self._request('POST', endpoint, **kwargs)
|
5063
|
Train/png/5063.png
|
def remove_callback(self, callback):
if callback in self._async_callbacks:
self._async_callbacks.remove(callback)
|
7090
|
Train/png/7090.png
|
def start(self):
self.startTime = time.time()
self.configure(text='{0:<d} s'.format(0))
self.update()
|
2141
|
Train/png/2141.png
|
def name(self):
try:
return TIFF.TAGS[self.code]
except KeyError:
return str(self.code)
|
3680
|
Train/png/3680.png
|
def write(self, string):
self._output += self._options.indentation_character * \
self._indentation + string + '\n'
|
2557
|
Train/png/2557.png
|
def read_mm_header(fd, byte_order, dtype, count):
return numpy.rec.fromfile(fd, MM_HEADER, 1, byteorder=byte_order)[0]
|
8778
|
Train/png/8778.png
|
def hide(self):
self.tk.withdraw()
self._visible = False
if self._modal:
self.tk.grab_release()
|
8532
|
Train/png/8532.png
|
def to_json(self, labels=None):
output = self.to_dict(labels)
return json.dumps(output, cls=DateTimeEncoder, ensure_ascii=False)
|
5690
|
Train/png/5690.png
|
def _process_status(self, status):
self._screen_id = status.get(ATTR_SCREEN_ID)
self.status_update_event.set()
|
9919
|
Train/png/9919.png
|
def labels(ontology, output, ols_base):
for label in get_labels(ontology=ontology, ols_base=ols_base):
click.echo(label, file=output)
|
572
|
Train/png/572.png
|
def nodes_to_object(self, node, object):
"Map all child nodes to one object's attributes"
for n in list(node):
self.node_to_object(n, object)
|
2406
|
Train/png/2406.png
|
def load_all(cls, vr, params=None):
ob_docs = vr.query(cls.base, params)
return [cls(vr, ob) for ob in ob_docs]
|
9910
|
Train/png/9910.png
|
def _warn_node(self, msg, *args, **kwargs):
if not msg.startswith('nonlocal image URI found:'):
_warn_node_old(self, msg, *args, **kwargs)
|
3352
|
Train/png/3352.png
|
def baseglob(pat, base):
return [f for f in glob(pat) if f.startswith(base)]
|
6015
|
Train/png/6015.png
|
def get_annotation(self, id_):
endpoint = "annotations/{id}".format(id=id_)
return self._make_request(endpoint)
|
5276
|
Train/png/5276.png
|
def add_user(self, username, password):
self.server.user_dict[username] = password
self.server.isAuth = True
|
522
|
Train/png/522.png
|
def atoms_iter(self):
for n, atom in self.graph.nodes.data("atom"):
yield n, atom
|
982
|
Train/png/982.png
|
def sorted(cls, items, orders):
return sorted(items, cmp=cls.multipleOrderComparison(orders))
|
4645
|
Train/png/4645.png
|
def query_keywords_empty(kind='1'):
return TabPost.select().where((TabPost.kind == kind) & (TabPost.keywords == ''))
|
4539
|
Train/png/4539.png
|
def RandomUniformInt(shape, minval, maxval, seed):
if seed:
np.random.seed(seed)
return np.random.randint(minval, maxval, size=shape),
|
7270
|
Train/png/7270.png
|
def get_field_type(info):
type_ = info.get_type()
cls = get_field_class(type_)
field = cls(info, type_, None)
field.setup()
return field.py_type
|
290
|
Train/png/290.png
|
def patchURL(self, url, headers, body):
return self._load_resource("PATCH", url, headers, body)
|
8126
|
Train/png/8126.png
|
def geometry(obj):
gf = vtk.vtkGeometryFilter()
gf.SetInputData(obj)
gf.Update()
return gf.GetOutput()
|
9146
|
Train/png/9146.png
|
def column_names(self):
return [name for (name, d) in self._columns.items()
if d.get('show', True)]
|
6380
|
Train/png/6380.png
|
def get_env(name):
"Return env var value if it's defined and not an empty string, or return Unknown"
res = os.environ.get(name, '')
return res if len(res) else "Unknown"
|
1190
|
Train/png/1190.png
|
def _typeseq_iter(s):
s = str(s)
while s:
t, s = _next_argsig(s)
yield t
|
3593
|
Train/png/3593.png
|
def deserializeEc(x, compress=True):
return _deserialize(x, ec1Element, compress, librelic.ec_read_bin_abi)
|
6308
|
Train/png/6308.png
|
def rollback(name, database=None, directory=None, verbose=None):
router = get_router(directory, database, verbose)
router.rollback(name)
|
6093
|
Train/png/6093.png
|
def log(message, type):
(sys.stdout if type == 'notice' else sys.stderr).write(message + "\n")
|
2611
|
Train/png/2611.png
|
def logout(self):
logger.debug('Logout')
method = self._anaconda_client_api.remove_authentication
return self._create_worker(method)
|
7395
|
Train/png/7395.png
|
def list():
entries = lambder.list_events()
for e in entries:
click.echo(str(e))
|
5536
|
Train/png/5536.png
|
def Stat(self, ext_attrs=None):
del ext_attrs # Unused.
return self.MakeStatResponse(self.fd, tsk_attribute=self.tsk_attribute)
|
5380
|
Train/png/5380.png
|
def save_replay(self):
res = self._client.send(save_replay=sc_pb.RequestSaveReplay())
return res.data
|
7128
|
Train/png/7128.png
|
def _generate_random_word(self, length):
return ''.join(random.choice(string.ascii_lowercase) for _ in range(length))
|
10068
|
Train/png/10068.png
|
def _atexit(self):
self.log.debug("Application._atexit")
if self._atexit_func:
self._atexit_func(self)
|
2471
|
Train/png/2471.png
|
def get_buffer(self):
buffer = []
for table in self.__tables:
buffer.extend(table.get_buffer())
return buffer
|
10022
|
Train/png/10022.png
|
def add_bind(self, sequence, cpt):
cpt_value = self.value(cpt)
sequence.parser_tree = parsing.Bind(cpt_value, sequence.parser_tree)
return True
|
588
|
Train/png/588.png
|
def as_dict(self):
d = {k: v for (k, v) in self.__dict__.items()}
return d
|
91
|
Train/png/91.png
|
def add_constraint(self, name, tpe, val):
self.constraint.append([name, tpe, val])
|
6639
|
Train/png/6639.png
|
def ToMicroseconds(self):
micros = _RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND)
return self.seconds * _MICROS_PER_SECOND + micros
|
1344
|
Train/png/1344.png
|
def sections(self) -> list:
self.config.read(self.filepath)
return self.config.sections()
|
4845
|
Train/png/4845.png
|
def set(self, data=None):
self.__data = data
self.__exception = None
self.__event.set()
|
5486
|
Train/png/5486.png
|
def _isclose(a: Any, b: Any, *, atol: Union[int, float]) -> bool:
return True if np.isclose([a], [b], atol=atol, rtol=0.0)[0] else False
|
8172
|
Train/png/8172.png
|
def put_object_async(self, path, **kwds):
return self.do_request_async(self.api_url + path, 'PUT', **kwds)
|
8668
|
Train/png/8668.png
|
def density_angle(rho0: Density, rho1: Density) -> bk.BKTensor:
return fubini_study_angle(rho0.vec, rho1.vec)
|
2712
|
Train/png/2712.png
|
def _dirdiffandcopy(self, dir1, dir2):
self._dowork(dir1, dir2, self._copy)
|
8996
|
Train/png/8996.png
|
def notify():
a = TpPd(pd=0x3)
b = MessageType(mesType=0x3e) # 00111110
c = NotificationIndicator()
packet = a / b / c
return packet
|
3520
|
Train/png/3520.png
|
def parse(filename):
with open(filename) as f:
parser = ASDLParser()
return parser.parse(f.read())
|
4177
|
Train/png/4177.png
|
def show_vpnservice(self, vpnservice, **_params):
return self.get(self.vpnservice_path % (vpnservice), params=_params)
|
5982
|
Train/png/5982.png
|
def UDiv(a: BitVec, b: BitVec) -> BitVec:
return _arithmetic_helper(a, b, z3.UDiv)
|
2494
|
Train/png/2494.png
|
def curve(self):
return HelicalCurve.pitch_and_radius(
self.major_pitch, self.major_radius,
handedness=self.major_handedness)
|
9176
|
Train/png/9176.png
|
def Dis(self):
return [self.di_power(i, power=1) for i in range(self.N)]
|
9337
|
Train/png/9337.png
|
def sha1sum_numpy(np_array):
import hashlib
return hashlib.sha1(np_array.view(np.uint8)).hexdigest()
|
6926
|
Train/png/6926.png
|
def pre(self, text):
if text:
self.escpos.text(text)
self.dirty = True
|
7089
|
Train/png/7089.png
|
def sub(self, quantity):
newvalue = self._value - quantity
self.set(newvalue.deg)
|
4235
|
Train/png/4235.png
|
def data_context(fn, mode="r"):
with open(data_context_name(fn), mode) as f:
return f.read()
|
5013
|
Train/png/5013.png
|
def Shift(self, term):
new = self.Copy()
new.xs = [x + term for x in self.xs]
return new
|
9680
|
Train/png/9680.png
|
def _form_returning(self):
qn = self.connection.ops.quote_name
return ' RETURNING %s' % qn(self.query.model._meta.pk.attname)
|
8951
|
Train/png/8951.png
|
def controller_event(self, channel, contr_nr, contr_val):
return self.midi_event(CONTROLLER, channel, contr_nr, contr_val)
|
8227
|
Train/png/8227.png
|
def load_iris():
dataset = datasets.load_iris()
return Dataset(load_iris.__doc__, dataset.data, dataset.target,
accuracy_score, stratify=True)
|
1488
|
Train/png/1488.png
|
def pop(h):
n = h.size() - 1
h.swap(0, n)
down(h, 0, n)
return h.pop()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.