common_id
stringlengths 1
5
| image
stringlengths 15
19
| code
stringlengths 26
239
|
|---|---|---|
877
|
Train/png/877.png
|
def build(self, **kw):
global MkdirBuilder
if self.builder is not MkdirBuilder:
SCons.Node.Node.build(self, **kw)
|
9058
|
Train/png/9058.png
|
def _is_suffix(self, t):
return t not in NOT_SUFFIX and (t.replace('.', '') in SUFFIXES or t.replace('.', '') in SUFFIXES_LOWER)
|
5173
|
Train/png/5173.png
|
def get_all_names(chebi_ids):
all_names = [get_names(chebi_id) for chebi_id in chebi_ids]
return [x for sublist in all_names for x in sublist]
|
1328
|
Train/png/1328.png
|
def get_applicable_values(self):
return [v for v in self._values if v.is_active and not v.is_all_results]
|
5405
|
Train/png/5405.png
|
def _replace_nan(a, val):
mask = isnull(a)
return where_method(val, mask, a), mask
|
6069
|
Train/png/6069.png
|
def shutdown(self):
self.stop = True
if self.stats:
self.stats.shutDownStats()
self.join()
|
8688
|
Train/png/8688.png
|
def angle(self, v):
return acos((self * v) / (self.length() * v.length()))
|
9946
|
Train/png/9946.png
|
def unregister_widget(self, widget_cls):
if widget_cls.__name__ in self.widgets:
del self.widgets[widget_cls().get_name()]
|
1446
|
Train/png/1446.png
|
def subscription(self):
return self.client.customer_subscriptions.with_parent_id(self.customer_id).get(self.subscription_id)
|
847
|
Train/png/847.png
|
def readFILTER(self):
filterId = self.readUI8()
filter = SWFFilterFactory.create(filterId)
filter.parse(self)
return filter
|
8255
|
Train/png/8255.png
|
def load(self):
self._list = self._source.load()
self._list_iter = itertools.cycle(self._list)
|
7941
|
Train/png/7941.png
|
def complete_db(self, text, line, begidx, endidx):
return [i for i in PsiturkNetworkShell.db_commands if
i.startswith(text)]
|
9505
|
Train/png/9505.png
|
def dmat(c, nocc):
"Form the density matrix from the first nocc orbitals of c"
return np.dot(c[:, :nocc], c[:, :nocc].T)
|
616
|
Train/png/616.png
|
def clear(self) -> None:
self.click()
for i in self.text:
self._parent.send_keyevents(Keys.DEL)
|
8939
|
Train/png/8939.png
|
def resize(self, height, width, **kwargs):
self.client.resize(self.container, height=height, width=width)
|
5116
|
Train/png/5116.png
|
def clip_to_seconds(m: Union[int, pd.Series]) -> Union[int, pd.Series]:
return m // pd.Timedelta(1, unit='s').value
|
6118
|
Train/png/6118.png
|
def accept(self, visitor):
func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
return func(self)
|
736
|
Train/png/736.png
|
def to_esc(self):
chunks = chunked(self.stream, 2)
return ''.join(r'\x' + ''.join(pair) for pair in chunks)
|
4810
|
Train/png/4810.png
|
def dimensions(self):
return ImageDimensions(self._info.file.width, self._info.file.height)
|
3953
|
Train/png/3953.png
|
def warn(self, message, *args, **kwargs):
self._log(logging.WARNING, message, *args, **kwargs)
|
7440
|
Train/png/7440.png
|
def redraw(self):
if self._multiscat is not None:
self._multiscat._update()
self.vispy_widget.canvas.update()
|
8742
|
Train/png/8742.png
|
def paint(self, iconic, painter, rect, mode, state, options):
for opt in options:
self._paint_icon(iconic, painter, rect, mode, state, opt)
|
351
|
Train/png/351.png
|
def chunks(l, n):
# http://stackoverflow.com/a/3226719
# ...not that this is hard to understand.
return [l[x:x+n] for x in range(0, len(l), n)]
|
8535
|
Train/png/8535.png
|
def queuedb_row_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
|
4321
|
Train/png/4321.png
|
def update(self):
self._json = self._request(
method='GET',
url=self.API
)._json
|
5795
|
Train/png/5795.png
|
def revert(self, strip=0, root=None):
reverted = copy.deepcopy(self)
reverted._reverse()
return reverted.apply(strip, root)
|
8863
|
Train/png/8863.png
|
def scan(self, ids=range(254)):
return [id for id in ids if self.ping(id)]
|
6980
|
Train/png/6980.png
|
def deserialize(self, apic_frame):
return Image(data=apic_frame.data, desc=apic_frame.desc,
type=apic_frame.type)
|
6130
|
Train/png/6130.png
|
def get_activations(self):
res = (self.added, self.removed)
self.added = set()
self.removed = set()
return res
|
9994
|
Train/png/9994.png
|
def x_plus(self, dx=None):
if dx is None:
self.x += self.dx
else:
self.x = self.x + dx
|
3093
|
Train/png/3093.png
|
def _rel_path(self, path, basepath=None):
basepath = basepath or self.src_dir
return path[len(basepath) + 1:]
|
7952
|
Train/png/7952.png
|
def metric_parts(metric):
operator, met = resolve_metric_as_tuple(metric)
return operator.name, met.name
|
4462
|
Train/png/4462.png
|
def copy(self):
c = matrix()
c.tt = self.tt.copy()
c.n = self.n.copy()
c.m = self.m.copy()
return c
|
4576
|
Train/png/4576.png
|
def hr_avg(self):
hr_data = self.hr_values()
return int(sum(hr_data) / len(hr_data))
|
1367
|
Train/png/1367.png
|
def prox_soft(X, step, thresh=0):
thresh_ = _step_gamma(step, thresh)
return np.sign(X)*prox_plus(np.abs(X) - thresh_, step)
|
2063
|
Train/png/2063.png
|
def is_(self, state):
translator = self._meta['translator']
state = translator.translate(state)
return self.actual_state == state
|
9561
|
Train/png/9561.png
|
def fopenat_rw(base_fd, path):
return os.fdopen(openat(base_fd, path, os.O_RDWR), 'rb+')
|
4560
|
Train/png/4560.png
|
def SegmentSum(a, ids, *args):
def func(idxs): return reduce(np.add, a[idxs])
return seg_map(func, a, ids),
|
6001
|
Train/png/6001.png
|
def radiance_to_bt(arr, wc_, a__, b__):
return a__ + b__ * (C2 * wc_ / (da.log(1 + (C1 * (wc_ ** 3) / arr))))
|
1630
|
Train/png/1630.png
|
def bytes_to_str(self, b):
"convert bytes array to raw string"
if PYTHON_MAJOR_VER == 3:
return b.decode(charset_map.get(self.charset, self.charset))
return b
|
4669
|
Train/png/4669.png
|
def parentItem(self, value):
self._parentItem = value
self._recursiveSetNodePath(self._constructNodePath())
|
6044
|
Train/png/6044.png
|
def all_dependencies(self, target):
for dep in target.closure(bfs=True, **self.target_closure_kwargs):
yield dep
|
2191
|
Train/png/2191.png
|
def apis(self):
value = self.attributes['apis']
if isinstance(value, six.string_types):
value = shlex.split(value)
return value
|
2418
|
Train/png/2418.png
|
def depth(self):
return len(self.path.rstrip(os.sep).split(os.sep))
|
5466
|
Train/png/5466.png
|
def count_rows_with_nans(X):
if X.ndim == 2:
return np.where(np.isnan(X).sum(axis=1) != 0, 1, 0).sum()
|
6099
|
Train/png/6099.png
|
def setto(self, s):
length = len(s)
self.b[self.j+1:self.j+1+length] = s
self.k = self.j + length
|
3911
|
Train/png/3911.png
|
def do(self):
"run it, you can get a good stitching of the complete URL."
return urlunparse((self.scheme, self.netloc, self.path, self.params, self.query, self.fragment))
|
7290
|
Train/png/7290.png
|
def close(self):
self.consumer.close()
self.publisher.close()
self._closed = True
|
2035
|
Train/png/2035.png
|
def _tag(element):
tag = element.tag
if tag[0] == "{":
uri, tag = tag[1:].split("}")
return tag
|
3652
|
Train/png/3652.png
|
def __updateDataItem(self):
uri = self.getUri()
self.__dataItem = self.__parseResponseServer(uri)
|
4254
|
Train/png/4254.png
|
def readXML(self):
data = self.readLongString()
root = xml.fromstring(data)
self.context.addObject(root)
return root
|
7183
|
Train/png/7183.png
|
def data(self, value):
self.loader.save_image(self.category, self.image, value)
|
2442
|
Train/png/2442.png
|
def visit_Name(self, node: AST, dfltChaining: bool = True) -> str:
return node.id
|
9867
|
Train/png/9867.png
|
def parse_package_json():
with open(locate_package_json()) as pjson:
data = json.loads(pjson.read())
return data
|
2443
|
Train/png/2443.png
|
def visit_Expr(self, node: AST, dfltChaining: bool = True) -> str:
return self.visit(node.value)
|
4716
|
Train/png/4716.png
|
def state(self):
ev = self._query_waiters.request(self.__do_query_state)
ev.wait(1.0)
return self._state
|
4451
|
Train/png/4451.png
|
def format_ffmpeg_filter(name, params):
return "%s=%s" % (name,
":".join("%s=%s" % (k, v) for k, v in params.items()))
|
3956
|
Train/png/3956.png
|
def _update_handler(self, handler_class, level):
handler = self._get_handler(handler_class)
handler.setLevel(level)
|
1172
|
Train/png/1172.png
|
def from_name(cls, name):
return Author(name=name, sha512=cls.hash_name(name))
|
8928
|
Train/png/8928.png
|
def _correlate(self):
a = self.algorithm(**self.algorithm_params)
self.correlation_result = a.run()
|
5129
|
Train/png/5129.png
|
def valid_modes(self):
default_mode = (self.mode,) if self.mode is not None else None
return getattr(self, '_valid_mode', default_mode)
|
7588
|
Train/png/7588.png
|
def popitem(self):
key, value = super(LFUCache, self).popitem()
return (key, value[1])
|
9081
|
Train/png/9081.png
|
def _empty_cache(self):
self._children, self._parents = None, None
self._rchildren, self._rparents = {}, {}
|
1867
|
Train/png/1867.png
|
def do_not_disturb(self, enabled):
self._set_setting(
{
CONST.SETTINGS_DO_NOT_DISTURB: str(enabled).lower()
})
|
5939
|
Train/png/5939.png
|
def fetchall(self):
result = self.query.result()
return [row.values() for row in result]
|
2805
|
Train/png/2805.png
|
def query(transport, query):
with CommandLineClient(transport) as client:
echo_event(client.query(query))
|
6244
|
Train/png/6244.png
|
def scale_to_control(x, axis_scale=350., min_v=-1.0, max_v=1.0):
x = x / axis_scale
x = min(max(x, min_v), max_v)
return x
|
9934
|
Train/png/9934.png
|
def _set_node_lists(self, new):
for edge in self.edges:
edge._nodes = self.nodes
|
7102
|
Train/png/7102.png
|
def prepare(self, f):
self.g = autograd.grad(f)
self.h = autograd.hessian(f)
|
7927
|
Train/png/7927.png
|
def close(self):
if self.fd:
os.close(self.fd)
self.fd = None
|
2669
|
Train/png/2669.png
|
def _read_next_line(self):
prev_line = self._line
self._line = self.stream.readline()
return prev_line
|
6075
|
Train/png/6075.png
|
def parse_cookies(self, req: Request, name: str, field: Field) -> typing.Any:
return core.get_value(req.cookies, name, field)
|
7325
|
Train/png/7325.png
|
def pull_stream(image):
return (json.loads(s) for s in _get_docker().pull(image, stream=True))
|
9677
|
Train/png/9677.png
|
def start(self):
self.status = 'pending'
self.thing.action_notify(self)
self.perform_action()
self.finish()
|
6403
|
Train/png/6403.png
|
def series2cat(df: DataFrame, *col_names):
"Categorifies the columns `col_names` in `df`."
for c in listify(col_names):
df[c] = df[c].astype('category').cat.as_ordered()
|
8025
|
Train/png/8025.png
|
def focus(self, cli, buffer_name):
assert isinstance(buffer_name, six.text_type)
self.focus_stack = [buffer_name]
|
1325
|
Train/png/1325.png
|
def match(pattern, data, **parse_kwargs):
return [m.value for m in parse(pattern, **parse_kwargs).find(data)]
|
2524
|
Train/png/2524.png
|
def _cleanup(path: str) -> None:
if os.path.isdir(path):
shutil.rmtree(path)
|
5240
|
Train/png/5240.png
|
def name(self):
return ffi.string(
lib.EnvGetDeftemplateName(self._env, self._tpl)).decode()
|
3774
|
Train/png/3774.png
|
def _query_gen(self):
return urlencode(self.__query__, safe=self.safe, querydelimiter=self.__querydelimiter__)
|
6854
|
Train/png/6854.png
|
def function_is_noop(function_node: ast.FunctionDef) -> bool:
return all(node_is_noop(n) for n in function_node.body)
|
9870
|
Train/png/9870.png
|
def mkdummy(name, **attrs):
return type(
name, (), dict(__repr__=(lambda self: "<%s>" % name), **attrs)
)()
|
3136
|
Train/png/3136.png
|
def get_many(self, ids):
return [self.instance(id, **fields)
for id, fields in zip(ids, self.api.mget(ids))]
|
6104
|
Train/png/6104.png
|
def close(self):
if self.device is not None and self.device.is_open:
self.device.flush()
self.device.close()
|
6205
|
Train/png/6205.png
|
def PyobjColumns(obj):
'Return columns for each public attribute on an object.'
return [ColumnAttr(k, type(getattr(obj, k))) for k in getPublicAttrs(obj)]
|
2672
|
Train/png/2672.png
|
def copy(self):
mapping = OrderedDict(self.mapping.items())
return self.__class__(self.key, self.value, mapping)
|
5068
|
Train/png/5068.png
|
def format_cell(cell, datetime_fmt=None):
if datetime_fmt and isinstance(cell, datetime):
return cell.strftime(datetime_fmt)
return cell
|
2518
|
Train/png/2518.png
|
def save_to_file(cn_topo, filename):
jstr = cn_topo.serialize()
with open(filename, 'w') as outfile:
outfile.write(jstr)
|
2648
|
Train/png/2648.png
|
def kindex(matrix, k):
ix = (np.arange(len(matrix)), matrix.argsort(axis=0)[k])
return ix
|
1179
|
Train/png/1179.png
|
def complete_opt_display(self, text, *_):
return [t + " " for t in DISPLAYS if t.startswith(text)]
|
4745
|
Train/png/4745.png
|
def setwinsize(self, rows, cols):
self._winsize = (rows, cols)
self.pty.set_size(cols, rows)
|
9240
|
Train/png/9240.png
|
def on_excepthandler(self, node): # ('type', 'name', 'body')
return (self.run(node.type), node.name, node.body)
|
4404
|
Train/png/4404.png
|
def hasannotationlayer(self, annotationtype=None, set=None):
l = self.layers(annotationtype, set)
return (len(l) > 0)
|
6768
|
Train/png/6768.png
|
def go_up(self):
vsb = self.scrollarea.verticalScrollBar()
vsb.setValue(int(vsb.value() - vsb.singleStep()))
|
3450
|
Train/png/3450.png
|
def size(self, value):
self._size = value
self._thumb = self._link_to_img()
|
4835
|
Train/png/4835.png
|
def curse(rest):
"Curse the day!"
if rest:
cursee = rest
else:
cursee = 'the day'
karma.Karma.store.change(cursee, -1)
return "/me curses %s!" % cursee
|
9116
|
Train/png/9116.png
|
def _fetch_items(self):
if self._items is None:
self._items = list(self.engine.items(self))
return self._items
|
2487
|
Train/png/2487.png
|
def gid(self, value):
self.bytearray[self._get_slicers(2)] = bytearray(c_int32(value or 0))
|
7074
|
Train/png/7074.png
|
def grow(self):
"Add another worker to the pool."
t = self.worker_factory(self)
t.start()
self._size += 1
|
4751
|
Train/png/4751.png
|
def get_prefix(self, el):
prefix = self.get_prefix_name(el)
return util.lower(prefix) if prefix is not None and not self.is_xml else prefix
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.