Unnamed: 0
int64 0
2.93k
| code
stringlengths 101
62.2k
| docs
stringlengths 51
10.7k
| doc_len
int64 4
1.74k
| words
int64 4
4.82k
| lang
stringclasses 1
value | prompt
stringlengths 320
71.2k
|
|---|---|---|---|---|---|---|
0 | def rolling(self, *args, **kwargs) -> RollingGroupby:
from pandas.core.window import RollingGroupby
return RollingGroupby(
self._selected_obj,
*args,
_grouper=self.grouper,
_as_index=self.as_index,
**kwargs,
)
|
Return a rolling grouper, providing rolling functionality per group.
| 9 | 18 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def rolling(self, *args, **kwargs) -> RollingGroupby:
from pandas.core.window import RollingGroupby
return RollingGroupby(
self._selected_obj,
*args,
_grouper=self.grouper,
_as_index=self.as_index,
**kwargs,
)
```
###Assistant :
Return a rolling grouper, providing rolling functionality per group.
|
1 | def expected_degree_graph(w, seed=None, selfloops=True):
r
n = len(w)
G = nx.empty_graph(n)
# If there are no nodes are no edges in the graph, return the empty graph.
if n == 0 or max(w) == 0:
return G
rho = 1 / sum(w)
# Sort the weights in decreasing order. The original order of the
# weights dictates the order of the (integer) node labels, so we
# need to remember the permutation applied in the sorting.
order = sorted(enumerate(w), key=itemgetter(1), reverse=True)
mapping = {c: u for c, (u, v) in enumerate(order)}
seq = [v for u, v in order]
last = n
if not selfloops:
last -= 1
for u in range(last):
v = u
if not selfloops:
v += 1
factor = seq[u] * rho
p = min(seq[v] * factor, 1)
while v < n and p > 0:
if p != 1:
r = seed.random()
v += math.floor(math.log(r, 1 - p))
if v < n:
q = min(seq[v] * factor, 1)
if seed.random() < q / p:
G.add_edge(mapping[u], mapping[v])
v += 1
p = q
return G
| Returns a random graph with given expected degrees.
Given a sequence of expected degrees $W=(w_0,w_1,\ldots,w_{n-1})$
of length $n$ this algorithm assigns an edge between node $u$ and
node $v$ with probability
.. math::
p_{uv} = \frac{w_u w_v}{\sum_k w_k} .
Parameters
----------
w : list
The list of expected degrees.
selfloops: bool (default=True)
Set to False to remove the possibility of self-loop edges.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
Returns
-------
Graph
Examples
--------
>>> z = [10 for i in range(100)]
>>> G = nx.expected_degree_graph(z)
Notes
-----
The nodes have integer labels corresponding to index of expected degrees
input sequence.
The complexity of this algorithm is $\mathcal{O}(n+m)$ where $n$ is the
number of nodes and $m$ is the expected number of edges.
The model in [1]_ includes the possibility of self-loop edges.
Set selfloops=False to produce a graph without self loops.
For finite graphs this model doesn't produce exactly the given
expected degree sequence. Instead the expected degrees are as
follows.
For the case without self loops (selfloops=False),
.. math::
E[deg(u)] = \sum_{v \ne u} p_{uv}
= w_u \left( 1 - \frac{w_u}{\sum_k w_k} \right) .
NetworkX uses the standard convention that a self-loop edge counts 2
in the degree of a node, so with self loops (selfloops=True),
.. math::
E[deg(u)] = \sum_{v \ne u} p_{uv} + 2 p_{uu}
= w_u \left( 1 + \frac{w_u}{\sum_k w_k} \right) .
References
----------
.. [1] Fan Chung and L. Lu, Connected components in random graphs with
given expected degree sequences, Ann. Combinatorics, 6,
pp. 125-145, 2002.
.. [2] Joel Miller and Aric Hagberg,
Efficient generation of networks with given expected degrees,
in Algorithms and Models for the Web-Graph (WAW 2011),
Alan Frieze, Paul Horn, and Paweł Prałat (Eds), LNCS 6732,
pp. 115-126, 2011.
| 298 | 179 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def expected_degree_graph(w, seed=None, selfloops=True):
r
n = len(w)
G = nx.empty_graph(n)
# If there are no nodes are no edges in the graph, return the empty graph.
if n == 0 or max(w) == 0:
return G
rho = 1 / sum(w)
# Sort the weights in decreasing order. The original order of the
# weights dictates the order of the (integer) node labels, so we
# need to remember the permutation applied in the sorting.
order = sorted(enumerate(w), key=itemgetter(1), reverse=True)
mapping = {c: u for c, (u, v) in enumerate(order)}
seq = [v for u, v in order]
last = n
if not selfloops:
last -= 1
for u in range(last):
v = u
if not selfloops:
v += 1
factor = seq[u] * rho
p = min(seq[v] * factor, 1)
while v < n and p > 0:
if p != 1:
r = seed.random()
v += math.floor(math.log(r, 1 - p))
if v < n:
q = min(seq[v] * factor, 1)
if seed.random() < q / p:
G.add_edge(mapping[u], mapping[v])
v += 1
p = q
return G
```
###Assistant : Returns a random graph with given expected degrees.
Given a sequence of expected degrees $W=(w_0,w_1,\ldots,w_{n-1})$
of length $n$ this algorithm assigns an edge between node $u$ and
node $v$ with probability
.. math::
p_{uv} = \frac{w_u w_v}{\sum_k w_k} .
Parameters
----------
w : list
The list of expected degrees.
selfloops: bool (default=True)
Set to False to remove the possibility of self-loop edges.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
Returns
-------
Graph
Examples
--------
>>> z = [10 for i in range(100)]
>>> G = nx.expected_degree_graph(z)
Notes
-----
The nodes have integer labels corresponding to index of expected degrees
input sequence.
The complexity of this algorithm is $\mathcal{O}(n+m)$ where $n$ is the
number of nodes and $m$ is the expected number of edges.
The model in [1]_ includes the possibility of self-loop edges.
Set selfloops=False to produce a graph without self loops.
For finite graphs this model doesn't produce exactly the given
expected degree sequence. Instead the expected degrees are as
follows.
For the case without self loops (selfloops=False),
.. math::
E[deg(u)] = \sum_{v \ne u} p_{uv}
= w_u \left( 1 - \frac{w_u}{\sum_k w_k} \right) .
NetworkX uses the standard convention that a self-loop edge counts 2
in the degree of a node, so with self loops (selfloops=True),
.. math::
E[deg(u)] = \sum_{v \ne u} p_{uv} + 2 p_{uu}
= w_u \left( 1 + \frac{w_u}{\sum_k w_k} \right) .
References
----------
.. [1] Fan Chung and L. Lu, Connected components in random graphs with
given expected degree sequences, Ann. Combinatorics, 6,
pp. 125-145, 2002.
.. [2] Joel Miller and Aric Hagberg,
Efficient generation of networks with given expected degrees,
in Algorithms and Models for the Web-Graph (WAW 2011),
Alan Frieze, Paul Horn, and Paweł Prałat (Eds), LNCS 6732,
pp. 115-126, 2011.
|
2 | def save(self, path):
os.makedirs(path, exist_ok=True)
with open(os.path.join(path, "metrics.json"), "w") as fp:
json.dump(self.metrics, fp)
artifacts_metadata = {
artifact_name: {
"uri": artifact.uri,
"class_name": _get_fully_qualified_class_name(artifact),
}
for artifact_name, artifact in self.artifacts.items()
}
with open(os.path.join(path, "artifacts_metadata.json"), "w") as fp:
json.dump(artifacts_metadata, fp)
artifacts_dir = os.path.join(path, "artifacts")
os.mkdir(artifacts_dir)
for artifact_name, artifact in self.artifacts.items():
artifact._save(os.path.join(artifacts_dir, artifact_name))
| Write the evaluation results to the specified local filesystem path | 10 | 49 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def save(self, path):
os.makedirs(path, exist_ok=True)
with open(os.path.join(path, "metrics.json"), "w") as fp:
json.dump(self.metrics, fp)
artifacts_metadata = {
artifact_name: {
"uri": artifact.uri,
"class_name": _get_fully_qualified_class_name(artifact),
}
for artifact_name, artifact in self.artifacts.items()
}
with open(os.path.join(path, "artifacts_metadata.json"), "w") as fp:
json.dump(artifacts_metadata, fp)
artifacts_dir = os.path.join(path, "artifacts")
os.mkdir(artifacts_dir)
for artifact_name, artifact in self.artifacts.items():
artifact._save(os.path.join(artifacts_dir, artifact_name))
```
###Assistant : Write the evaluation results to the specified local filesystem path
|
3 | def test_build_group_generic_issue_attachment(self):
event = self.store_event(
data={"message": "Hello world", "level": "error"}, project_id=self.project.id
)
event = event.for_group(event.groups[0])
occurrence = self.build_occurrence(level="info")
occurrence.save(project_id=self.project.id)
event.occurrence = occurrence
event.group.type = GroupType.PROFILE_BLOCKED_THREAD
attachments = SlackIssuesMessageBuilder(group=event.group, event=event).build()
assert attachments["title"] == occurrence.issue_title
assert attachments["text"] == occurrence.evidence_display[0].value
assert attachments["fallback"] == f"[{self.project.slug}] {occurrence.issue_title}"
assert attachments["color"] == "#2788CE" # blue for info level
| Test that a generic issue type's Slack alert contains the expected values | 12 | 51 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_build_group_generic_issue_attachment(self):
event = self.store_event(
data={"message": "Hello world", "level": "error"}, project_id=self.project.id
)
event = event.for_group(event.groups[0])
occurrence = self.build_occurrence(level="info")
occurrence.save(project_id=self.project.id)
event.occurrence = occurrence
event.group.type = GroupType.PROFILE_BLOCKED_THREAD
attachments = SlackIssuesMessageBuilder(group=event.group, event=event).build()
assert attachments["title"] == occurrence.issue_title
assert attachments["text"] == occurrence.evidence_display[0].value
assert attachments["fallback"] == f"[{self.project.slug}] {occurrence.issue_title}"
assert attachments["color"] == "#2788CE" # blue for info level
```
###Assistant : Test that a generic issue type's Slack alert contains the expected values
|
4 | def apply(self, func, mask=None) -> 'ImageProcessor':
img = orig_img = self._img
img = func(img).astype(orig_img.dtype)
if img.ndim != 4:
raise Exception('func used in ImageProcessor.apply changed format of image')
if mask is not None:
mask = self._check_normalize_mask(mask)
img = ne.evaluate('orig_img*(1-mask) + img*mask').astype(orig_img.dtype)
self._img = img
return self
|
apply your own function on internal image
image has NHWC format. Do not change format, but dims can be changed.
func callable (img) -> img
example:
.apply( lambda img: img-[102,127,63] )
| 31 | 45 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def apply(self, func, mask=None) -> 'ImageProcessor':
img = orig_img = self._img
img = func(img).astype(orig_img.dtype)
if img.ndim != 4:
raise Exception('func used in ImageProcessor.apply changed format of image')
if mask is not None:
mask = self._check_normalize_mask(mask)
img = ne.evaluate('orig_img*(1-mask) + img*mask').astype(orig_img.dtype)
self._img = img
return self
```
###Assistant :
apply your own function on internal image
image has NHWC format. Do not change format, but dims can be changed.
func callable (img) -> img
example:
.apply( lambda img: img-[102,127,63] )
|
5 | def predict(self, x):
# start the timer
self.timer.start()
v_, _ = self.eval_out() # evaluate the ratings and the associated probabilities
vp = self.sess.run(v_, feed_dict={self.vu: x})
# stop the timer
self.timer.stop()
log.info("Done inference, time %f2" % self.timer.interval)
return vp
| Returns the inferred ratings. This method is similar to recommend_k_items() with the
exceptions that it returns all the inferred ratings
Basic mechanics:
The method samples new ratings from the learned joint distribution, together with
their probabilities. The input x must have the same number of columns as the one used
for training the model, i.e. the same number of items, but it can have an arbitrary number
of rows (users).
Args:
x (numpy.ndarray, int32): Input user/affinity matrix. Note that this can be a single vector, i.e.
the ratings of a single user.
Returns:
numpy.ndarray, float:
- A matrix with the inferred ratings.
- The elapsed time for predediction.
| 108 | 38 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def predict(self, x):
# start the timer
self.timer.start()
v_, _ = self.eval_out() # evaluate the ratings and the associated probabilities
vp = self.sess.run(v_, feed_dict={self.vu: x})
# stop the timer
self.timer.stop()
log.info("Done inference, time %f2" % self.timer.interval)
return vp
```
###Assistant : Returns the inferred ratings. This method is similar to recommend_k_items() with the
exceptions that it returns all the inferred ratings
Basic mechanics:
The method samples new ratings from the learned joint distribution, together with
their probabilities. The input x must have the same number of columns as the one used
for training the model, i.e. the same number of items, but it can have an arbitrary number
of rows (users).
Args:
x (numpy.ndarray, int32): Input user/affinity matrix. Note that this can be a single vector, i.e.
the ratings of a single user.
Returns:
numpy.ndarray, float:
- A matrix with the inferred ratings.
- The elapsed time for predediction.
|
6 | def raw_decode(self, s, idx=0):
try:
obj, end = self.scan_once(s, idx)
except StopIteration as err:
raise JSONDecodeError("Expecting value", s, err.value) from None
return obj, end
| Decode a JSON document from ``s`` (a ``str`` beginning with
a JSON document) and return a 2-tuple of the Python
representation and the index in ``s`` where the document ended.
This can be used to decode a JSON document from a string that may
have extraneous data at the end.
| 50 | 24 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def raw_decode(self, s, idx=0):
try:
obj, end = self.scan_once(s, idx)
except StopIteration as err:
raise JSONDecodeError("Expecting value", s, err.value) from None
return obj, end
```
###Assistant : Decode a JSON document from ``s`` (a ``str`` beginning with
a JSON document) and return a 2-tuple of the Python
representation and the index in ``s`` where the document ended.
This can be used to decode a JSON document from a string that may
have extraneous data at the end.
|
7 | def has_bridges(G, root=None):
try:
next(bridges(G))
except StopIteration:
return False
else:
return True
@not_implemented_for("multigraph")
@not_implemented_for("directed") | Decide whether a graph has any bridges.
A *bridge* in a graph is an edge whose removal causes the number of
connected components of the graph to increase.
Parameters
----------
G : undirected graph
root : node (optional)
A node in the graph `G`. If specified, only the bridges in the
connected component containing this node will be considered.
Returns
-------
bool
Whether the graph (or the connected component containing `root`)
has any bridges.
Raises
------
NodeNotFound
If `root` is not in the graph `G`.
NetworkXNotImplemented
If `G` is a directed graph.
Examples
--------
The barbell graph with parameter zero has a single bridge::
>>> G = nx.barbell_graph(10, 0)
>>> nx.has_bridges(G)
True
On the other hand, the cycle graph has no bridges::
>>> G = nx.cycle_graph(5)
>>> nx.has_bridges(G)
False
Notes
-----
This implementation uses the :func:`networkx.bridges` function, so
it shares its worst-case time complexity, $O(m + n)$, ignoring
polylogarithmic factors, where $n$ is the number of nodes in the
graph and $m$ is the number of edges.
| 167 | 14 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def has_bridges(G, root=None):
try:
next(bridges(G))
except StopIteration:
return False
else:
return True
@not_implemented_for("multigraph")
@not_implemented_for("directed")
```
###Assistant : Decide whether a graph has any bridges.
A *bridge* in a graph is an edge whose removal causes the number of
connected components of the graph to increase.
Parameters
----------
G : undirected graph
root : node (optional)
A node in the graph `G`. If specified, only the bridges in the
connected component containing this node will be considered.
Returns
-------
bool
Whether the graph (or the connected component containing `root`)
has any bridges.
Raises
------
NodeNotFound
If `root` is not in the graph `G`.
NetworkXNotImplemented
If `G` is a directed graph.
Examples
--------
The barbell graph with parameter zero has a single bridge::
>>> G = nx.barbell_graph(10, 0)
>>> nx.has_bridges(G)
True
On the other hand, the cycle graph has no bridges::
>>> G = nx.cycle_graph(5)
>>> nx.has_bridges(G)
False
Notes
-----
This implementation uses the :func:`networkx.bridges` function, so
it shares its worst-case time complexity, $O(m + n)$, ignoring
polylogarithmic factors, where $n$ is the number of nodes in the
graph and $m$ is the number of edges.
|
8 | def wheel_metadata(source, dist_info_dir):
# type: (ZipFile, str) -> Message
path = f"{dist_info_dir}/WHEEL"
# Zip file path separators must be /
wheel_contents = read_wheel_metadata_file(source, path)
try:
wheel_text = wheel_contents.decode()
except UnicodeDecodeError as e:
raise UnsupportedWheel(f"error decoding {path!r}: {e!r}")
# FeedParser (used by Parser) does not raise any exceptions. The returned
# message may have .defects populated, but for backwards-compatibility we
# currently ignore them.
return Parser().parsestr(wheel_text)
| Return the WHEEL metadata of an extracted wheel, if possible.
Otherwise, raise UnsupportedWheel.
| 13 | 65 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def wheel_metadata(source, dist_info_dir):
# type: (ZipFile, str) -> Message
path = f"{dist_info_dir}/WHEEL"
# Zip file path separators must be /
wheel_contents = read_wheel_metadata_file(source, path)
try:
wheel_text = wheel_contents.decode()
except UnicodeDecodeError as e:
raise UnsupportedWheel(f"error decoding {path!r}: {e!r}")
# FeedParser (used by Parser) does not raise any exceptions. The returned
# message may have .defects populated, but for backwards-compatibility we
# currently ignore them.
return Parser().parsestr(wheel_text)
```
###Assistant : Return the WHEEL metadata of an extracted wheel, if possible.
Otherwise, raise UnsupportedWheel.
|
9 | def remove_column(self, i, *args, **kwargs):
table = self.table.remove_column(i, *args, **kwargs)
name = self.table.column_names[i]
blocks = []
for tables in self.blocks:
blocks.append(
[
t.remove_column(t.column_names.index(name), *args, **kwargs) if name in t.column_names else t
for t in tables
]
)
return ConcatenationTable(table, blocks)
|
Create new Table with the indicated column removed.
Args:
i (:obj:`int`):
Index of column to remove.
Returns:
:class:`datasets.table.Table`:
New table without the column.
| 23 | 40 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def remove_column(self, i, *args, **kwargs):
table = self.table.remove_column(i, *args, **kwargs)
name = self.table.column_names[i]
blocks = []
for tables in self.blocks:
blocks.append(
[
t.remove_column(t.column_names.index(name), *args, **kwargs) if name in t.column_names else t
for t in tables
]
)
return ConcatenationTable(table, blocks)
```
###Assistant :
Create new Table with the indicated column removed.
Args:
i (:obj:`int`):
Index of column to remove.
Returns:
:class:`datasets.table.Table`:
New table without the column.
|
10 | def test_cable_cannot_terminate_to_a_wireless_interface(self):
wireless_interface = Interface(device=self.device1, name="W1", type=InterfaceTypeChoices.TYPE_80211A)
cable = Cable(a_terminations=[self.interface2], b_terminations=[wireless_interface])
with self.assertRaises(ValidationError):
cable.clean()
|
A cable cannot terminate to a wireless interface
| 8 | 14 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_cable_cannot_terminate_to_a_wireless_interface(self):
wireless_interface = Interface(device=self.device1, name="W1", type=InterfaceTypeChoices.TYPE_80211A)
cable = Cable(a_terminations=[self.interface2], b_terminations=[wireless_interface])
with self.assertRaises(ValidationError):
cable.clean()
```
###Assistant :
A cable cannot terminate to a wireless interface
|
11 | def get_test_db_clone_settings(self, suffix):
# When this function is called, the test database has been created
# already and its name has been copied to settings_dict['NAME'] so
# we don't need to call _get_test_db_name.
orig_settings_dict = self.connection.settings_dict
return {
**orig_settings_dict,
"NAME": "{}_{}".format(orig_settings_dict["NAME"], suffix),
}
|
Return a modified connection settings dict for the n-th clone of a DB.
| 13 | 43 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_test_db_clone_settings(self, suffix):
# When this function is called, the test database has been created
# already and its name has been copied to settings_dict['NAME'] so
# we don't need to call _get_test_db_name.
orig_settings_dict = self.connection.settings_dict
return {
**orig_settings_dict,
"NAME": "{}_{}".format(orig_settings_dict["NAME"], suffix),
}
```
###Assistant :
Return a modified connection settings dict for the n-th clone of a DB.
|
12 | def open(self, host='', port=IMAP4_PORT, timeout=None):
self.host = host
self.port = port
self.sock = self._create_socket(timeout)
self.file = self.sock.makefile('rb')
| Setup connection to remote server on "host:port"
(default: localhost:standard IMAP4 port).
This connection will be used by the routines:
read, readline, send, shutdown.
| 23 | 17 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def open(self, host='', port=IMAP4_PORT, timeout=None):
self.host = host
self.port = port
self.sock = self._create_socket(timeout)
self.file = self.sock.makefile('rb')
```
###Assistant : Setup connection to remote server on "host:port"
(default: localhost:standard IMAP4 port).
This connection will be used by the routines:
read, readline, send, shutdown.
|
13 | def synchronized_output_end_sequence(self) -> str:
if self.synchronised_output:
return TERMINAL_MODES_ANSI_SEQUENCES[Mode.SynchronizedOutput]["end_sync"]
return ""
|
Returns the ANSI sequence that we should send to the terminal to tell it that
it should stop buffering the content we're about to send.
If the terminal doesn't seem to support synchronised updates the string will be empty.
Returns:
str: the "synchronised output stop" ANSI sequence. It will be ab empty string
if the terminal emulator doesn't seem to support the "synchronised updates" mode.
| 65 | 10 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def synchronized_output_end_sequence(self) -> str:
if self.synchronised_output:
return TERMINAL_MODES_ANSI_SEQUENCES[Mode.SynchronizedOutput]["end_sync"]
return ""
```
###Assistant :
Returns the ANSI sequence that we should send to the terminal to tell it that
it should stop buffering the content we're about to send.
If the terminal doesn't seem to support synchronised updates the string will be empty.
Returns:
str: the "synchronised output stop" ANSI sequence. It will be ab empty string
if the terminal emulator doesn't seem to support the "synchronised updates" mode.
|
14 | def _band_penalty_coefficients(self, fc, q, gain, filter_frs):
ref_frs = biquad.digital_coeffs(self.frequency, 192e3, *biquad.peaking(fc, q, gain, fs=192e3))
est_sums = np.sum(filter_frs, axis=1)
ref_sums = np.sum(ref_frs, axis=1)
penalties = np.zeros((len(fc),))
mask = np.squeeze(ref_sums) != 0.0
penalties[mask] = est_sums[mask] / ref_sums[mask]
return 10 * (1 - np.expand_dims(penalties, 1))
| Calculates penalty coefficients for filters if their transition bands extend beyond Nyquist frequency
The calculation is based on ratio of frequency response integrals between 44.1 kHz and 192 kHz
Args:
fc: Filter center frequencies, 1-D array
q: Filter qualities, 1-D array
gain: Filter gains, 1-D array
filter_frs: Filter frequency responses, 2-D array, one fr per row
Returns:
Column array of penalty coefficients, one per filter
| 65 | 42 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _band_penalty_coefficients(self, fc, q, gain, filter_frs):
ref_frs = biquad.digital_coeffs(self.frequency, 192e3, *biquad.peaking(fc, q, gain, fs=192e3))
est_sums = np.sum(filter_frs, axis=1)
ref_sums = np.sum(ref_frs, axis=1)
penalties = np.zeros((len(fc),))
mask = np.squeeze(ref_sums) != 0.0
penalties[mask] = est_sums[mask] / ref_sums[mask]
return 10 * (1 - np.expand_dims(penalties, 1))
```
###Assistant : Calculates penalty coefficients for filters if their transition bands extend beyond Nyquist frequency
The calculation is based on ratio of frequency response integrals between 44.1 kHz and 192 kHz
Args:
fc: Filter center frequencies, 1-D array
q: Filter qualities, 1-D array
gain: Filter gains, 1-D array
filter_frs: Filter frequency responses, 2-D array, one fr per row
Returns:
Column array of penalty coefficients, one per filter
|
15 | def test_predict_on_toy_problem(global_random_seed):
clf1 = LogisticRegression(random_state=global_random_seed)
clf2 = RandomForestClassifier(n_estimators=10, random_state=global_random_seed)
clf3 = GaussianNB()
X = np.array(
[[-1.1, -1.5], [-1.2, -1.4], [-3.4, -2.2], [1.1, 1.2], [2.1, 1.4], [3.1, 2.3]]
)
y = np.array([1, 1, 1, 2, 2, 2])
assert_array_equal(clf1.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
assert_array_equal(clf2.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
assert_array_equal(clf3.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
eclf = VotingClassifier(
estimators=[("lr", clf1), ("rf", clf2), ("gnb", clf3)],
voting="hard",
weights=[1, 1, 1],
)
assert_array_equal(eclf.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
eclf = VotingClassifier(
estimators=[("lr", clf1), ("rf", clf2), ("gnb", clf3)],
voting="soft",
weights=[1, 1, 1],
)
assert_array_equal(eclf.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
| Manually check predicted class labels for toy dataset. | 8 | 104 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_predict_on_toy_problem(global_random_seed):
clf1 = LogisticRegression(random_state=global_random_seed)
clf2 = RandomForestClassifier(n_estimators=10, random_state=global_random_seed)
clf3 = GaussianNB()
X = np.array(
[[-1.1, -1.5], [-1.2, -1.4], [-3.4, -2.2], [1.1, 1.2], [2.1, 1.4], [3.1, 2.3]]
)
y = np.array([1, 1, 1, 2, 2, 2])
assert_array_equal(clf1.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
assert_array_equal(clf2.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
assert_array_equal(clf3.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
eclf = VotingClassifier(
estimators=[("lr", clf1), ("rf", clf2), ("gnb", clf3)],
voting="hard",
weights=[1, 1, 1],
)
assert_array_equal(eclf.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
eclf = VotingClassifier(
estimators=[("lr", clf1), ("rf", clf2), ("gnb", clf3)],
voting="soft",
weights=[1, 1, 1],
)
assert_array_equal(eclf.fit(X, y).predict(X), [1, 1, 1, 2, 2, 2])
```
###Assistant : Manually check predicted class labels for toy dataset.
|
16 | def fit_transform(self, X, y=None):
self._validate_params()
return self._transform(X, fitting=True)
| Learn a list of feature name -> indices mappings and transform X.
Like fit(X) followed by transform(X), but does not require
materializing X in memory.
Parameters
----------
X : Mapping or iterable over Mappings
Dict(s) or Mapping(s) from feature names (arbitrary Python
objects) to feature values (strings or convertible to dtype).
.. versionchanged:: 0.24
Accepts multiple string values for one categorical feature.
y : (ignored)
Ignored parameter.
Returns
-------
Xa : {array, sparse matrix}
Feature vectors; always 2-d.
| 78 | 8 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def fit_transform(self, X, y=None):
self._validate_params()
return self._transform(X, fitting=True)
```
###Assistant : Learn a list of feature name -> indices mappings and transform X.
Like fit(X) followed by transform(X), but does not require
materializing X in memory.
Parameters
----------
X : Mapping or iterable over Mappings
Dict(s) or Mapping(s) from feature names (arbitrary Python
objects) to feature values (strings or convertible to dtype).
.. versionchanged:: 0.24
Accepts multiple string values for one categorical feature.
y : (ignored)
Ignored parameter.
Returns
-------
Xa : {array, sparse matrix}
Feature vectors; always 2-d.
|
17 | def _on_feature_permission_requested(self, url, feature):
page = self._widget.page()
grant_permission = functools.partial(
page.setFeaturePermission, url, feature,
QWebEnginePage.PermissionPolicy.PermissionGrantedByUser)
deny_permission = functools.partial(
page.setFeaturePermission, url, feature,
QWebEnginePage.PermissionPolicy.PermissionDeniedByUser)
permission_str = debug.qenum_key(QWebEnginePage, feature)
if not url.isValid():
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-85116
is_qtbug = (qtutils.version_check('5.15.0',
compiled=False,
exact=True) and
self._tab.is_private and
feature == QWebEnginePage.Feature.Notifications)
logger = log.webview.debug if is_qtbug else log.webview.warning
logger("Ignoring feature permission {} for invalid URL {}".format(
permission_str, url))
deny_permission()
return
if feature not in self._options:
log.webview.error("Unhandled feature permission {}".format(
permission_str))
deny_permission()
return
if (
feature in [QWebEnginePage.Feature.DesktopVideoCapture,
QWebEnginePage.Feature.DesktopAudioVideoCapture] and
qtutils.version_check('5.13', compiled=False) and
not qtutils.version_check('5.13.2', compiled=False)
):
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-78016
log.webview.warning("Ignoring desktop sharing request due to "
"crashes in Qt < 5.13.2")
deny_permission()
return
question = shared.feature_permission(
url=url.adjusted(QUrl.UrlFormattingOption.RemovePath),
option=self._options[feature], msg=self._messages[feature],
yes_action=grant_permission, no_action=deny_permission,
abort_on=[self._tab.abort_questions])
if question is not None:
page.featurePermissionRequestCanceled.connect(
functools.partial(self._on_feature_permission_cancelled,
question, url, feature))
| Ask the user for approval for geolocation/media/etc.. | 7 | 125 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _on_feature_permission_requested(self, url, feature):
page = self._widget.page()
grant_permission = functools.partial(
page.setFeaturePermission, url, feature,
QWebEnginePage.PermissionPolicy.PermissionGrantedByUser)
deny_permission = functools.partial(
page.setFeaturePermission, url, feature,
QWebEnginePage.PermissionPolicy.PermissionDeniedByUser)
permission_str = debug.qenum_key(QWebEnginePage, feature)
if not url.isValid():
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-85116
is_qtbug = (qtutils.version_check('5.15.0',
compiled=False,
exact=True) and
self._tab.is_private and
feature == QWebEnginePage.Feature.Notifications)
logger = log.webview.debug if is_qtbug else log.webview.warning
logger("Ignoring feature permission {} for invalid URL {}".format(
permission_str, url))
deny_permission()
return
if feature not in self._options:
log.webview.error("Unhandled feature permission {}".format(
permission_str))
deny_permission()
return
if (
feature in [QWebEnginePage.Feature.DesktopVideoCapture,
QWebEnginePage.Feature.DesktopAudioVideoCapture] and
qtutils.version_check('5.13', compiled=False) and
not qtutils.version_check('5.13.2', compiled=False)
):
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-78016
log.webview.warning("Ignoring desktop sharing request due to "
"crashes in Qt < 5.13.2")
deny_permission()
return
question = shared.feature_permission(
url=url.adjusted(QUrl.UrlFormattingOption.RemovePath),
option=self._options[feature], msg=self._messages[feature],
yes_action=grant_permission, no_action=deny_permission,
abort_on=[self._tab.abort_questions])
if question is not None:
page.featurePermissionRequestCanceled.connect(
functools.partial(self._on_feature_permission_cancelled,
question, url, feature))
```
###Assistant : Ask the user for approval for geolocation/media/etc..
|
18 | def add_find_python(self):
start = 402
for ver in self.versions:
install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
machine_reg = "python.machine." + ver
user_reg = "python.user." + ver
machine_prop = "PYTHON.MACHINE." + ver
user_prop = "PYTHON.USER." + ver
machine_action = "PythonFromMachine" + ver
user_action = "PythonFromUser" + ver
exe_action = "PythonExe" + ver
target_dir_prop = "TARGETDIR" + ver
exe_prop = "PYTHON" + ver
if msilib.Win64:
# type: msidbLocatorTypeRawValue + msidbLocatorType64bit
Type = 2+16
else:
Type = 2
add_data(self.db, "RegLocator",
[(machine_reg, 2, install_path, None, Type),
(user_reg, 1, install_path, None, Type)])
add_data(self.db, "AppSearch",
[(machine_prop, machine_reg),
(user_prop, user_reg)])
add_data(self.db, "CustomAction",
[(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
(user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
(exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
])
add_data(self.db, "InstallExecuteSequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "InstallUISequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "Condition",
[("Python" + ver, 0, "NOT TARGETDIR" + ver)])
start += 4
assert start < 500
| Adds code to the installer to compute the location of Python.
Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
registry for each version of Python.
Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
else from PYTHON.MACHINE.X.Y.
Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe | 45 | 167 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def add_find_python(self):
start = 402
for ver in self.versions:
install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
machine_reg = "python.machine." + ver
user_reg = "python.user." + ver
machine_prop = "PYTHON.MACHINE." + ver
user_prop = "PYTHON.USER." + ver
machine_action = "PythonFromMachine" + ver
user_action = "PythonFromUser" + ver
exe_action = "PythonExe" + ver
target_dir_prop = "TARGETDIR" + ver
exe_prop = "PYTHON" + ver
if msilib.Win64:
# type: msidbLocatorTypeRawValue + msidbLocatorType64bit
Type = 2+16
else:
Type = 2
add_data(self.db, "RegLocator",
[(machine_reg, 2, install_path, None, Type),
(user_reg, 1, install_path, None, Type)])
add_data(self.db, "AppSearch",
[(machine_prop, machine_reg),
(user_prop, user_reg)])
add_data(self.db, "CustomAction",
[(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
(user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
(exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
])
add_data(self.db, "InstallExecuteSequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "InstallUISequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "Condition",
[("Python" + ver, 0, "NOT TARGETDIR" + ver)])
start += 4
assert start < 500
```
###Assistant : Adds code to the installer to compute the location of Python.
Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
registry for each version of Python.
Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
else from PYTHON.MACHINE.X.Y.
Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe
|
19 | def write_exports(self, exports):
rf = self.get_distinfo_file(EXPORTS_FILENAME)
with open(rf, 'w') as f:
write_exports(exports, f)
|
Write a dictionary of exports to a file in .ini format.
:param exports: A dictionary of exports, mapping an export category to
a list of :class:`ExportEntry` instances describing the
individual export entries.
| 32 | 13 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def write_exports(self, exports):
rf = self.get_distinfo_file(EXPORTS_FILENAME)
with open(rf, 'w') as f:
write_exports(exports, f)
```
###Assistant :
Write a dictionary of exports to a file in .ini format.
:param exports: A dictionary of exports, mapping an export category to
a list of :class:`ExportEntry` instances describing the
individual export entries.
|
20 | def _get_action_handler_with_module_context(self, connection, templar):
module_collection, separator, module_name = self._task.action.rpartition(".")
module_prefix = module_name.split('_')[0]
if module_collection:
# For network modules, which look for one action plugin per platform, look for the
# action plugin in the same collection as the module by prefixing the action plugin
# with the same collection.
network_action = "{0}.{1}".format(module_collection, module_prefix)
else:
network_action = module_prefix
collections = self._task.collections
# Check if the module has specified an action handler
module = self._shared_loader_obj.module_loader.find_plugin_with_context(
self._task.action, collection_list=collections
)
if not module.resolved or not module.action_plugin:
module = None
if module is not None:
handler_name = module.action_plugin
# let action plugin override module, fallback to 'normal' action plugin otherwise
elif self._shared_loader_obj.action_loader.has_plugin(self._task.action, collection_list=collections):
handler_name = self._task.action
elif all((module_prefix in C.NETWORK_GROUP_MODULES, self._shared_loader_obj.action_loader.has_plugin(network_action, collection_list=collections))):
handler_name = network_action
display.vvvv("Using network group action {handler} for {action}".format(handler=handler_name,
action=self._task.action),
host=self._play_context.remote_addr)
else:
# use ansible.legacy.normal to allow (historic) local action_plugins/ override without collections search
handler_name = 'ansible.legacy.normal'
collections = None # until then, we don't want the task's collection list to be consulted; use the builtin
handler = self._shared_loader_obj.action_loader.get(
handler_name,
task=self._task,
connection=connection,
play_context=self._play_context,
loader=self._loader,
templar=templar,
shared_loader_obj=self._shared_loader_obj,
collection_list=collections
)
if not handler:
raise AnsibleError("the handler '%s' was not found" % handler_name)
return handler, module
|
Returns the correct action plugin to handle the requestion task action and the module context
| 15 | 191 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _get_action_handler_with_module_context(self, connection, templar):
module_collection, separator, module_name = self._task.action.rpartition(".")
module_prefix = module_name.split('_')[0]
if module_collection:
# For network modules, which look for one action plugin per platform, look for the
# action plugin in the same collection as the module by prefixing the action plugin
# with the same collection.
network_action = "{0}.{1}".format(module_collection, module_prefix)
else:
network_action = module_prefix
collections = self._task.collections
# Check if the module has specified an action handler
module = self._shared_loader_obj.module_loader.find_plugin_with_context(
self._task.action, collection_list=collections
)
if not module.resolved or not module.action_plugin:
module = None
if module is not None:
handler_name = module.action_plugin
# let action plugin override module, fallback to 'normal' action plugin otherwise
elif self._shared_loader_obj.action_loader.has_plugin(self._task.action, collection_list=collections):
handler_name = self._task.action
elif all((module_prefix in C.NETWORK_GROUP_MODULES, self._shared_loader_obj.action_loader.has_plugin(network_action, collection_list=collections))):
handler_name = network_action
display.vvvv("Using network group action {handler} for {action}".format(handler=handler_name,
action=self._task.action),
host=self._play_context.remote_addr)
else:
# use ansible.legacy.normal to allow (historic) local action_plugins/ override without collections search
handler_name = 'ansible.legacy.normal'
collections = None # until then, we don't want the task's collection list to be consulted; use the builtin
handler = self._shared_loader_obj.action_loader.get(
handler_name,
task=self._task,
connection=connection,
play_context=self._play_context,
loader=self._loader,
templar=templar,
shared_loader_obj=self._shared_loader_obj,
collection_list=collections
)
if not handler:
raise AnsibleError("the handler '%s' was not found" % handler_name)
return handler, module
```
###Assistant :
Returns the correct action plugin to handle the requestion task action and the module context
|
21 | def forward(self, y_hat, y, length):
mask = sequence_mask(sequence_length=length, max_len=y.size(1)).unsqueeze(2)
y_norm = sample_wise_min_max(y, mask)
y_hat_norm = sample_wise_min_max(y_hat, mask)
ssim_loss = self.loss_func((y_norm * mask).unsqueeze(1), (y_hat_norm * mask).unsqueeze(1))
if ssim_loss.item() > 1.0:
print(f" > SSIM loss is out-of-range {ssim_loss.item()}, setting it 1.0")
ssim_loss == 1.0
if ssim_loss.item() < 0.0:
print(f" > SSIM loss is out-of-range {ssim_loss.item()}, setting it 0.0")
ssim_loss == 0.0
return ssim_loss
|
Args:
y_hat (tensor): model prediction values.
y (tensor): target values.
length (tensor): length of each sample in a batch for masking.
Shapes:
y_hat: B x T X D
y: B x T x D
length: B
Returns:
loss: An average loss value in range [0, 1] masked by the length.
| 50 | 61 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def forward(self, y_hat, y, length):
mask = sequence_mask(sequence_length=length, max_len=y.size(1)).unsqueeze(2)
y_norm = sample_wise_min_max(y, mask)
y_hat_norm = sample_wise_min_max(y_hat, mask)
ssim_loss = self.loss_func((y_norm * mask).unsqueeze(1), (y_hat_norm * mask).unsqueeze(1))
if ssim_loss.item() > 1.0:
print(f" > SSIM loss is out-of-range {ssim_loss.item()}, setting it 1.0")
ssim_loss == 1.0
if ssim_loss.item() < 0.0:
print(f" > SSIM loss is out-of-range {ssim_loss.item()}, setting it 0.0")
ssim_loss == 0.0
return ssim_loss
```
###Assistant :
Args:
y_hat (tensor): model prediction values.
y (tensor): target values.
length (tensor): length of each sample in a batch for masking.
Shapes:
y_hat: B x T X D
y: B x T x D
length: B
Returns:
loss: An average loss value in range [0, 1] masked by the length.
|
22 | def get_commands():
commands = {name: 'django.core' for name in find_commands(__path__[0])}
if not settings.configured:
return commands
for app_config in reversed(apps.get_app_configs()):
path = os.path.join(app_config.path, 'management')
commands.update({name: app_config.name for name in find_commands(path)})
return commands
|
Return a dictionary mapping command names to their callback applications.
Look for a management.commands package in django.core, and in each
installed application -- if a commands package exists, register all
commands in that package.
Core commands are always included. If a settings module has been
specified, also include user-defined commands.
The dictionary is in the format {command_name: app_name}. Key-value
pairs from this dictionary can then be used in calls to
load_command_class(app_name, command_name)
If a specific version of a command must be loaded (e.g., with the
startapp command), the instantiated module can be placed in the
dictionary in place of the application name.
The dictionary is cached on the first call and reused on subsequent
calls.
| 115 | 31 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_commands():
commands = {name: 'django.core' for name in find_commands(__path__[0])}
if not settings.configured:
return commands
for app_config in reversed(apps.get_app_configs()):
path = os.path.join(app_config.path, 'management')
commands.update({name: app_config.name for name in find_commands(path)})
return commands
```
###Assistant :
Return a dictionary mapping command names to their callback applications.
Look for a management.commands package in django.core, and in each
installed application -- if a commands package exists, register all
commands in that package.
Core commands are always included. If a settings module has been
specified, also include user-defined commands.
The dictionary is in the format {command_name: app_name}. Key-value
pairs from this dictionary can then be used in calls to
load_command_class(app_name, command_name)
If a specific version of a command must be loaded (e.g., with the
startapp command), the instantiated module can be placed in the
dictionary in place of the application name.
The dictionary is cached on the first call and reused on subsequent
calls.
|
23 | def getphraselist(self):
plist = []
while self.pos < len(self.field):
if self.field[self.pos] in self.FWS:
self.pos += 1
elif self.field[self.pos] == '"':
plist.append(self.getquote())
elif self.field[self.pos] == '(':
self.commentlist.append(self.getcomment())
elif self.field[self.pos] in self.phraseends:
break
else:
plist.append(self.getatom(self.phraseends))
return plist
| Parse a sequence of RFC 2822 phrases.
A phrase is a sequence of words, which are in turn either RFC 2822
atoms or quoted-strings. Phrases are canonicalized by squeezing all
runs of continuous whitespace into one space.
| 37 | 35 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def getphraselist(self):
plist = []
while self.pos < len(self.field):
if self.field[self.pos] in self.FWS:
self.pos += 1
elif self.field[self.pos] == '"':
plist.append(self.getquote())
elif self.field[self.pos] == '(':
self.commentlist.append(self.getcomment())
elif self.field[self.pos] in self.phraseends:
break
else:
plist.append(self.getatom(self.phraseends))
return plist
```
###Assistant : Parse a sequence of RFC 2822 phrases.
A phrase is a sequence of words, which are in turn either RFC 2822
atoms or quoted-strings. Phrases are canonicalized by squeezing all
runs of continuous whitespace into one space.
|
24 | def set_location(self, location):
# This puts the rectangle into figure-relative coordinates.
if isinstance(location, str):
_api.check_in_list(self._locstrings, location=location)
self._pos = 1. if location in ('top', 'right') else 0.
elif isinstance(location, numbers.Real):
self._pos = location
else:
raise ValueError(
f"location must be {self._locstrings[0]!r}, "
f"{self._locstrings[1]!r}, or a float, not {location!r}")
self._loc = location
if self._orientation == 'x':
# An x-secondary axes is like an inset axes from x = 0 to x = 1 and
# from y = pos to y = pos + eps, in the parent's transAxes coords.
bounds = [0, self._pos, 1., 1e-10]
else: # 'y'
bounds = [self._pos, 0, 1e-10, 1]
# this locator lets the axes move in the parent axes coordinates.
# so it never needs to know where the parent is explicitly in
# figure coordinates.
# it gets called in ax.apply_aspect() (of all places)
self.set_axes_locator(
_TransformedBoundsLocator(bounds, self._parent.transAxes))
|
Set the vertical or horizontal location of the axes in
parent-normalized coordinates.
Parameters
----------
location : {'top', 'bottom', 'left', 'right'} or float
The position to put the secondary axis. Strings can be 'top' or
'bottom' for orientation='x' and 'right' or 'left' for
orientation='y'. A float indicates the relative position on the
parent axes to put the new axes, 0.0 being the bottom (or left)
and 1.0 being the top (or right).
| 71 | 142 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def set_location(self, location):
# This puts the rectangle into figure-relative coordinates.
if isinstance(location, str):
_api.check_in_list(self._locstrings, location=location)
self._pos = 1. if location in ('top', 'right') else 0.
elif isinstance(location, numbers.Real):
self._pos = location
else:
raise ValueError(
f"location must be {self._locstrings[0]!r}, "
f"{self._locstrings[1]!r}, or a float, not {location!r}")
self._loc = location
if self._orientation == 'x':
# An x-secondary axes is like an inset axes from x = 0 to x = 1 and
# from y = pos to y = pos + eps, in the parent's transAxes coords.
bounds = [0, self._pos, 1., 1e-10]
else: # 'y'
bounds = [self._pos, 0, 1e-10, 1]
# this locator lets the axes move in the parent axes coordinates.
# so it never needs to know where the parent is explicitly in
# figure coordinates.
# it gets called in ax.apply_aspect() (of all places)
self.set_axes_locator(
_TransformedBoundsLocator(bounds, self._parent.transAxes))
```
###Assistant :
Set the vertical or horizontal location of the axes in
parent-normalized coordinates.
Parameters
----------
location : {'top', 'bottom', 'left', 'right'} or float
The position to put the secondary axis. Strings can be 'top' or
'bottom' for orientation='x' and 'right' or 'left' for
orientation='y'. A float indicates the relative position on the
parent axes to put the new axes, 0.0 being the bottom (or left)
and 1.0 being the top (or right).
|
25 | def length(self):
if self._length_cache is None:
if len(self.call_queue):
self.drain_call_queue()
else:
self._length_cache, self._width_cache = _get_index_and_columns.remote(
self.oid
)
if isinstance(self._length_cache, ObjectIDType):
self._length_cache = ray.get(self._length_cache)
return self._length_cache
|
Get the length of the object wrapped by this partition.
Returns
-------
int
The length of the object.
| 18 | 24 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def length(self):
if self._length_cache is None:
if len(self.call_queue):
self.drain_call_queue()
else:
self._length_cache, self._width_cache = _get_index_and_columns.remote(
self.oid
)
if isinstance(self._length_cache, ObjectIDType):
self._length_cache = ray.get(self._length_cache)
return self._length_cache
```
###Assistant :
Get the length of the object wrapped by this partition.
Returns
-------
int
The length of the object.
|
26 | def dmp_l2_norm_squared(f, u, K):
if not u:
return dup_l2_norm_squared(f, K)
v = u - 1
return sum([ dmp_l2_norm_squared(c, v, K) for c in f ])
|
Returns squared l2 norm of a polynomial in ``K[X]``.
Examples
========
>>> from sympy.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_l2_norm_squared(2*x*y - x - 3)
14
| 30 | 25 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def dmp_l2_norm_squared(f, u, K):
if not u:
return dup_l2_norm_squared(f, K)
v = u - 1
return sum([ dmp_l2_norm_squared(c, v, K) for c in f ])
```
###Assistant :
Returns squared l2 norm of a polynomial in ``K[X]``.
Examples
========
>>> from sympy.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_l2_norm_squared(2*x*y - x - 3)
14
|
27 | def cloud_filter(args, targets): # type: (IntegrationConfig, t.Tuple[IntegrationTarget, ...]) -> t.List[str]
if args.metadata.cloud_config is not None:
return [] # cloud filter already performed prior to delegation
exclude = [] # type: t.List[str]
for provider in get_cloud_providers(args, targets):
provider.filter(targets, exclude)
return exclude
| Return a list of target names to exclude based on the given targets. | 13 | 40 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def cloud_filter(args, targets): # type: (IntegrationConfig, t.Tuple[IntegrationTarget, ...]) -> t.List[str]
if args.metadata.cloud_config is not None:
return [] # cloud filter already performed prior to delegation
exclude = [] # type: t.List[str]
for provider in get_cloud_providers(args, targets):
provider.filter(targets, exclude)
return exclude
```
###Assistant : Return a list of target names to exclude based on the given targets.
|
28 | def test_upgrade_available_none():
chk_upgrade_out = (
"Last metadata expiration check: 22:5:48 ago on Mon Dec 6 19:26:36 EST 2021."
)
dnf_call = MagicMock(return_value={"retcode": 100, "stdout": chk_upgrade_out})
version_mock = MagicMock(return_value="6.6-2")
with patch("pathlib.Path.is_file", return_value=True):
with patch.dict(
aixpkg.__salt__,
{"cmd.run_all": dnf_call, "config.get": MagicMock(return_value=False)},
), patch.object(aixpkg, "version", version_mock):
result = aixpkg.upgrade_available("info")
assert dnf_call.call_count == 1
libpath_env = {"LIBPATH": "/opt/freeware/lib:/usr/lib"}
dnf_call.assert_any_call(
"/opt/freeware/bin/dnf check-update info",
env=libpath_env,
ignore_retcode=True,
python_shell=False,
)
assert not result
|
test upgrade available where a valid upgrade is not available
| 10 | 64 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_upgrade_available_none():
chk_upgrade_out = (
"Last metadata expiration check: 22:5:48 ago on Mon Dec 6 19:26:36 EST 2021."
)
dnf_call = MagicMock(return_value={"retcode": 100, "stdout": chk_upgrade_out})
version_mock = MagicMock(return_value="6.6-2")
with patch("pathlib.Path.is_file", return_value=True):
with patch.dict(
aixpkg.__salt__,
{"cmd.run_all": dnf_call, "config.get": MagicMock(return_value=False)},
), patch.object(aixpkg, "version", version_mock):
result = aixpkg.upgrade_available("info")
assert dnf_call.call_count == 1
libpath_env = {"LIBPATH": "/opt/freeware/lib:/usr/lib"}
dnf_call.assert_any_call(
"/opt/freeware/bin/dnf check-update info",
env=libpath_env,
ignore_retcode=True,
python_shell=False,
)
assert not result
```
###Assistant :
test upgrade available where a valid upgrade is not available
|
29 | def test_too_many_boosted_releases_do_not_boost_anymore(self):
release_2 = Release.get_or_create(self.project, "2.0")
release_3 = Release.get_or_create(self.project, "3.0")
for release_id in (self.release.id, release_2.id):
self.redis_client.set(f"ds::p:{self.project.id}:r:{release_id}", 1, 60 * 60 * 24)
self.redis_client.hset(
f"ds::p:{self.project.id}:boosted_releases",
release_id,
time(),
)
with self.options(
{
"dynamic-sampling:boost-latest-release": True,
}
):
self.make_release_transaction(
release_version=release_3.version,
environment_name=self.environment1.name,
project_id=self.project.id,
checksum="b" * 32,
timestamp=self.timestamp,
)
assert self.redis_client.hgetall(f"ds::p:{self.project.id}:boosted_releases") == {
str(self.release.id): str(time()),
str(release_2.id): str(time()),
}
assert self.redis_client.get(f"ds::p:{self.project.id}:r:{release_3.id}") is None
|
This test tests the case when we have already too many boosted releases, in this case we want to skip the
boosting of anymore releases
| 25 | 56 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_too_many_boosted_releases_do_not_boost_anymore(self):
release_2 = Release.get_or_create(self.project, "2.0")
release_3 = Release.get_or_create(self.project, "3.0")
for release_id in (self.release.id, release_2.id):
self.redis_client.set(f"ds::p:{self.project.id}:r:{release_id}", 1, 60 * 60 * 24)
self.redis_client.hset(
f"ds::p:{self.project.id}:boosted_releases",
release_id,
time(),
)
with self.options(
{
"dynamic-sampling:boost-latest-release": True,
}
):
self.make_release_transaction(
release_version=release_3.version,
environment_name=self.environment1.name,
project_id=self.project.id,
checksum="b" * 32,
timestamp=self.timestamp,
)
assert self.redis_client.hgetall(f"ds::p:{self.project.id}:boosted_releases") == {
str(self.release.id): str(time()),
str(release_2.id): str(time()),
}
assert self.redis_client.get(f"ds::p:{self.project.id}:r:{release_3.id}") is None
```
###Assistant :
This test tests the case when we have already too many boosted releases, in this case we want to skip the
boosting of anymore releases
|
30 | def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
import numpy as np
import scipy as sp
import scipy.sparse.linalg # call as sp.sparse.linalg
if len(G) == 0:
return {}, {}
A = nx.adjacency_matrix(G, nodelist=list(G), dtype=float)
if nstart is None:
u, s, vt = sp.sparse.linalg.svds(A, k=1, maxiter=max_iter, tol=tol)
else:
nstart = np.array(list(nstart.values()))
u, s, vt = sp.sparse.linalg.svds(A, k=1, v0=nstart, maxiter=max_iter, tol=tol)
a = vt.flatten().real
h = A @ a
if normalized:
h = h / h.sum()
a = a / a.sum()
hubs = dict(zip(G, map(float, h)))
authorities = dict(zip(G, map(float, a)))
return hubs, authorities
| Returns HITS hubs and authorities values for nodes.
The HITS algorithm computes two numbers for a node.
Authorities estimates the node value based on the incoming links.
Hubs estimates the node value based on outgoing links.
Parameters
----------
G : graph
A NetworkX graph
max_iter : integer, optional
Maximum number of iterations in power method.
tol : float, optional
Error tolerance used to check convergence in power method iteration.
nstart : dictionary, optional
Starting value of each node for power method iteration.
normalized : bool (default=True)
Normalize results by the sum of all of the values.
Returns
-------
(hubs,authorities) : two-tuple of dictionaries
Two dictionaries keyed by node containing the hub and authority
values.
Raises
------
PowerIterationFailedConvergence
If the algorithm fails to converge to the specified tolerance
within the specified number of iterations of the power iteration
method.
Examples
--------
>>> G = nx.path_graph(4)
>>> h, a = nx.hits(G)
Notes
-----
The eigenvector calculation is done by the power iteration method
and has no guarantee of convergence. The iteration will stop
after max_iter iterations or an error tolerance of
number_of_nodes(G)*tol has been reached.
The HITS algorithm was designed for directed graphs but this
algorithm does not check if the input graph is directed and will
execute on undirected graphs.
References
----------
.. [1] A. Langville and C. Meyer,
"A survey of eigenvector methods of web information retrieval."
http://citeseer.ist.psu.edu/713792.html
.. [2] Jon Kleinberg,
Authoritative sources in a hyperlinked environment
Journal of the ACM 46 (5): 604-32, 1999.
doi:10.1145/324133.324140.
http://www.cs.cornell.edu/home/kleinber/auth.pdf.
| 248 | 90 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
import numpy as np
import scipy as sp
import scipy.sparse.linalg # call as sp.sparse.linalg
if len(G) == 0:
return {}, {}
A = nx.adjacency_matrix(G, nodelist=list(G), dtype=float)
if nstart is None:
u, s, vt = sp.sparse.linalg.svds(A, k=1, maxiter=max_iter, tol=tol)
else:
nstart = np.array(list(nstart.values()))
u, s, vt = sp.sparse.linalg.svds(A, k=1, v0=nstart, maxiter=max_iter, tol=tol)
a = vt.flatten().real
h = A @ a
if normalized:
h = h / h.sum()
a = a / a.sum()
hubs = dict(zip(G, map(float, h)))
authorities = dict(zip(G, map(float, a)))
return hubs, authorities
```
###Assistant : Returns HITS hubs and authorities values for nodes.
The HITS algorithm computes two numbers for a node.
Authorities estimates the node value based on the incoming links.
Hubs estimates the node value based on outgoing links.
Parameters
----------
G : graph
A NetworkX graph
max_iter : integer, optional
Maximum number of iterations in power method.
tol : float, optional
Error tolerance used to check convergence in power method iteration.
nstart : dictionary, optional
Starting value of each node for power method iteration.
normalized : bool (default=True)
Normalize results by the sum of all of the values.
Returns
-------
(hubs,authorities) : two-tuple of dictionaries
Two dictionaries keyed by node containing the hub and authority
values.
Raises
------
PowerIterationFailedConvergence
If the algorithm fails to converge to the specified tolerance
within the specified number of iterations of the power iteration
method.
Examples
--------
>>> G = nx.path_graph(4)
>>> h, a = nx.hits(G)
Notes
-----
The eigenvector calculation is done by the power iteration method
and has no guarantee of convergence. The iteration will stop
after max_iter iterations or an error tolerance of
number_of_nodes(G)*tol has been reached.
The HITS algorithm was designed for directed graphs but this
algorithm does not check if the input graph is directed and will
execute on undirected graphs.
References
----------
.. [1] A. Langville and C. Meyer,
"A survey of eigenvector methods of web information retrieval."
http://citeseer.ist.psu.edu/713792.html
.. [2] Jon Kleinberg,
Authoritative sources in a hyperlinked environment
Journal of the ACM 46 (5): 604-32, 1999.
doi:10.1145/324133.324140.
http://www.cs.cornell.edu/home/kleinber/auth.pdf.
|
31 | def test_connection(self) -> Tuple[bool, str]:
try:
conn = self.get_conn()
conn.pwd
return True, "Connection successfully tested"
except Exception as e:
return False, str(e)
| Test the FTP connection by calling path with directory | 9 | 22 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_connection(self) -> Tuple[bool, str]:
try:
conn = self.get_conn()
conn.pwd
return True, "Connection successfully tested"
except Exception as e:
return False, str(e)
```
###Assistant : Test the FTP connection by calling path with directory
|
32 | def call_price(self, other_args):
parser = argparse.ArgumentParser(
add_help=False,
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
prog="price",
description=,
)
parser.add_argument(
"-s",
"--symbol",
required="-h" not in other_args,
type=str,
dest="symbol",
help="Symbol of coin to load data for, ~100 symbols are available",
)
if other_args and "-" not in other_args[0][0]:
other_args.insert(0, "-s")
ns_parser = self.parse_known_args_and_warn(parser, other_args)
if ns_parser:
if ns_parser.symbol in pyth_model.ASSETS.keys():
console.print(
"[param]If it takes too long, you can use 'Ctrl + C' to cancel.\n[/param]"
)
pyth_view.display_price(ns_parser.symbol)
else:
console.print("[red]The symbol selected does not exist.[/red]\n")
| Process price commandDisplay price and interval of confidence in real-time. [Source: Pyth] | 12 | 74 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def call_price(self, other_args):
parser = argparse.ArgumentParser(
add_help=False,
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
prog="price",
description=,
)
parser.add_argument(
"-s",
"--symbol",
required="-h" not in other_args,
type=str,
dest="symbol",
help="Symbol of coin to load data for, ~100 symbols are available",
)
if other_args and "-" not in other_args[0][0]:
other_args.insert(0, "-s")
ns_parser = self.parse_known_args_and_warn(parser, other_args)
if ns_parser:
if ns_parser.symbol in pyth_model.ASSETS.keys():
console.print(
"[param]If it takes too long, you can use 'Ctrl + C' to cancel.\n[/param]"
)
pyth_view.display_price(ns_parser.symbol)
else:
console.print("[red]The symbol selected does not exist.[/red]\n")
```
###Assistant : Process price commandDisplay price and interval of confidence in real-time. [Source: Pyth]
|
33 | def _single_map_nested(args):
function, data_struct, types, rank, disable_tqdm, desc = args
# Singleton first to spare some computation
if not isinstance(data_struct, dict) and not isinstance(data_struct, types):
return function(data_struct)
# Reduce logging to keep things readable in multiprocessing with tqdm
if rank is not None and logging.get_verbosity() < logging.WARNING:
logging.set_verbosity_warning()
# Print at least one thing to fix tqdm in notebooks in multiprocessing
# see https://github.com/tqdm/tqdm/issues/485#issuecomment-473338308
if rank is not None and not disable_tqdm and any("notebook" in tqdm_cls.__name__ for tqdm_cls in tqdm.__mro__):
print(" ", end="", flush=True)
# Loop over single examples or batches and write to buffer/file if examples are to be updated
pbar_iterable = data_struct.items() if isinstance(data_struct, dict) else data_struct
pbar_desc = (desc + " " if desc is not None else "") + "#" + str(rank) if rank is not None else desc
pbar = utils.tqdm(pbar_iterable, disable=disable_tqdm, position=rank, unit="obj", desc=pbar_desc)
if isinstance(data_struct, dict):
return {k: _single_map_nested((function, v, types, None, True, None)) for k, v in pbar}
else:
mapped = [_single_map_nested((function, v, types, None, True, None)) for v in pbar]
if isinstance(data_struct, list):
return mapped
elif isinstance(data_struct, tuple):
return tuple(mapped)
else:
return np.array(mapped)
| Apply a function recursively to each element of a nested data struct. | 12 | 182 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _single_map_nested(args):
function, data_struct, types, rank, disable_tqdm, desc = args
# Singleton first to spare some computation
if not isinstance(data_struct, dict) and not isinstance(data_struct, types):
return function(data_struct)
# Reduce logging to keep things readable in multiprocessing with tqdm
if rank is not None and logging.get_verbosity() < logging.WARNING:
logging.set_verbosity_warning()
# Print at least one thing to fix tqdm in notebooks in multiprocessing
# see https://github.com/tqdm/tqdm/issues/485#issuecomment-473338308
if rank is not None and not disable_tqdm and any("notebook" in tqdm_cls.__name__ for tqdm_cls in tqdm.__mro__):
print(" ", end="", flush=True)
# Loop over single examples or batches and write to buffer/file if examples are to be updated
pbar_iterable = data_struct.items() if isinstance(data_struct, dict) else data_struct
pbar_desc = (desc + " " if desc is not None else "") + "#" + str(rank) if rank is not None else desc
pbar = utils.tqdm(pbar_iterable, disable=disable_tqdm, position=rank, unit="obj", desc=pbar_desc)
if isinstance(data_struct, dict):
return {k: _single_map_nested((function, v, types, None, True, None)) for k, v in pbar}
else:
mapped = [_single_map_nested((function, v, types, None, True, None)) for v in pbar]
if isinstance(data_struct, list):
return mapped
elif isinstance(data_struct, tuple):
return tuple(mapped)
else:
return np.array(mapped)
```
###Assistant : Apply a function recursively to each element of a nested data struct.
|
34 | def test_unified(self):
self.write_settings("settings_to_diff.py", sdict={"FOO": '"bar"'})
args = ["diffsettings", "--settings=settings_to_diff", "--output=unified"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "+ FOO = 'bar'")
self.assertOutput(out, "- SECRET_KEY = ''")
self.assertOutput(out, "+ SECRET_KEY = 'django_tests_secret_key'")
self.assertNotInOutput(out, " APPEND_SLASH = True")
| --output=unified emits settings diff in unified mode. | 7 | 35 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_unified(self):
self.write_settings("settings_to_diff.py", sdict={"FOO": '"bar"'})
args = ["diffsettings", "--settings=settings_to_diff", "--output=unified"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "+ FOO = 'bar'")
self.assertOutput(out, "- SECRET_KEY = ''")
self.assertOutput(out, "+ SECRET_KEY = 'django_tests_secret_key'")
self.assertNotInOutput(out, " APPEND_SLASH = True")
```
###Assistant : --output=unified emits settings diff in unified mode.
|
35 | def runtime_env(self):
return RuntimeEnv.deserialize(self._get_runtime_env_string())
| Get the runtime env of the current job/worker.
If this API is called in driver or ray client, returns the job level runtime
env.
If this API is called in workers/actors, returns the worker level runtime env.
Returns:
A new ray.runtime_env.RuntimeEnv instance.
To merge from the current runtime env in some specific cases, you can get the
current runtime env by this API and modify it by yourself.
Example:
>>> # Inherit current runtime env, except `env_vars`
>>> Actor.options( # doctest: +SKIP
... runtime_env=ray.get_runtime_context().runtime_env.update(
... {"env_vars": {"A": "a", "B": "b"}})
... ) # doctest: +SKIP
| 95 | 4 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def runtime_env(self):
return RuntimeEnv.deserialize(self._get_runtime_env_string())
```
###Assistant : Get the runtime env of the current job/worker.
If this API is called in driver or ray client, returns the job level runtime
env.
If this API is called in workers/actors, returns the worker level runtime env.
Returns:
A new ray.runtime_env.RuntimeEnv instance.
To merge from the current runtime env in some specific cases, you can get the
current runtime env by this API and modify it by yourself.
Example:
>>> # Inherit current runtime env, except `env_vars`
>>> Actor.options( # doctest: +SKIP
... runtime_env=ray.get_runtime_context().runtime_env.update(
... {"env_vars": {"A": "a", "B": "b"}})
... ) # doctest: +SKIP
|
36 | def sleeper(self, duration):
s = time()
yield
time_to_sleep = duration - (time() - s)
if time_to_sleep > 0:
self.wait(time_to_sleep)
|
Do something and then wait for a given duration minus the time it took doing something
| 16 | 19 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def sleeper(self, duration):
s = time()
yield
time_to_sleep = duration - (time() - s)
if time_to_sleep > 0:
self.wait(time_to_sleep)
```
###Assistant :
Do something and then wait for a given duration minus the time it took doing something
|
37 | def test_BoundaryNorm():
boundaries = [0, 1.1, 2.2]
vals = [-1, 0, 1, 2, 2.2, 4]
# Without interpolation
expected = [-1, 0, 0, 1, 2, 2]
ncolors = len(boundaries) - 1
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# ncolors != len(boundaries) - 1 triggers interpolation
expected = [-1, 0, 0, 2, 3, 3]
ncolors = len(boundaries)
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# with a single region and interpolation
expected = [-1, 1, 1, 1, 3, 3]
bn = mcolors.BoundaryNorm([0, 2.2], ncolors)
assert_array_equal(bn(vals), expected)
# more boundaries for a third color
boundaries = [0, 1, 2, 3]
vals = [-1, 0.1, 1.1, 2.2, 4]
ncolors = 5
expected = [-1, 0, 2, 4, 5]
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# a scalar as input should not trigger an error and should return a scalar
boundaries = [0, 1, 2]
vals = [-1, 0.1, 1.1, 2.2]
bn = mcolors.BoundaryNorm(boundaries, 2)
expected = [-1, 0, 1, 2]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# same with interp
bn = mcolors.BoundaryNorm(boundaries, 3)
expected = [-1, 0, 2, 3]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# Clipping
bn = mcolors.BoundaryNorm(boundaries, 3, clip=True)
expected = [0, 0, 2, 2]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# Masked arrays
boundaries = [0, 1.1, 2.2]
vals = np.ma.masked_invalid([-1., np.NaN, 0, 1.4, 9])
# Without interpolation
ncolors = len(boundaries) - 1
bn = mcolors.BoundaryNorm(boundaries, ncolors)
expected = np.ma.masked_array([-1, -99, 0, 1, 2], mask=[0, 1, 0, 0, 0])
assert_array_equal(bn(vals), expected)
# With interpolation
bn = mcolors.BoundaryNorm(boundaries, len(boundaries))
expected = np.ma.masked_array([-1, -99, 0, 2, 3], mask=[0, 1, 0, 0, 0])
assert_array_equal(bn(vals), expected)
# Non-trivial masked arrays
vals = np.ma.masked_invalid([np.Inf, np.NaN])
assert np.all(bn(vals).mask)
vals = np.ma.masked_invalid([np.Inf])
assert np.all(bn(vals).mask)
# Incompatible extend and clip
with pytest.raises(ValueError, match="not compatible"):
mcolors.BoundaryNorm(np.arange(4), 5, extend='both', clip=True)
# Too small ncolors argument
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 2)
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 3, extend='min')
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 4, extend='both')
# Testing extend keyword, with interpolation (large cmap)
bounds = [1, 2, 3]
cmap = mpl.colormaps['viridis']
mynorm = mcolors.BoundaryNorm(bounds, cmap.N, extend='both')
refnorm = mcolors.BoundaryNorm([0] + bounds + [4], cmap.N)
x = np.random.randn(100) * 10 + 2
ref = refnorm(x)
ref[ref == 0] = -1
ref[ref == cmap.N - 1] = cmap.N
assert_array_equal(mynorm(x), ref)
# Without interpolation
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_over('black')
cmref.set_under('white')
cmshould = mcolors.ListedColormap(['white', 'blue', 'red', 'black'])
assert mcolors.same_color(cmref.get_over(), 'black')
assert mcolors.same_color(cmref.get_under(), 'white')
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='both')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
assert mynorm(bounds[0] - 0.1) == -1 # under
assert mynorm(bounds[0] + 0.1) == 1 # first bin -> second color
assert mynorm(bounds[-1] - 0.1) == cmshould.N - 2 # next-to-last color
assert mynorm(bounds[-1] + 0.1) == cmshould.N # over
x = [-1, 1.2, 2.3, 9.6]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2, 3]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
# Just min
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_under('white')
cmshould = mcolors.ListedColormap(['white', 'blue', 'red'])
assert mcolors.same_color(cmref.get_under(), 'white')
assert cmref.N == 2
assert cmshould.N == 3
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='min')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
x = [-1, 1.2, 2.3]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
# Just max
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_over('black')
cmshould = mcolors.ListedColormap(['blue', 'red', 'black'])
assert mcolors.same_color(cmref.get_over(), 'black')
assert cmref.N == 2
assert cmshould.N == 3
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='max')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
x = [1.2, 2.3, 4]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
|
GitHub issue #1258: interpolation was failing with numpy
1.7 pre-release.
| 10 | 623 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_BoundaryNorm():
boundaries = [0, 1.1, 2.2]
vals = [-1, 0, 1, 2, 2.2, 4]
# Without interpolation
expected = [-1, 0, 0, 1, 2, 2]
ncolors = len(boundaries) - 1
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# ncolors != len(boundaries) - 1 triggers interpolation
expected = [-1, 0, 0, 2, 3, 3]
ncolors = len(boundaries)
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# with a single region and interpolation
expected = [-1, 1, 1, 1, 3, 3]
bn = mcolors.BoundaryNorm([0, 2.2], ncolors)
assert_array_equal(bn(vals), expected)
# more boundaries for a third color
boundaries = [0, 1, 2, 3]
vals = [-1, 0.1, 1.1, 2.2, 4]
ncolors = 5
expected = [-1, 0, 2, 4, 5]
bn = mcolors.BoundaryNorm(boundaries, ncolors)
assert_array_equal(bn(vals), expected)
# a scalar as input should not trigger an error and should return a scalar
boundaries = [0, 1, 2]
vals = [-1, 0.1, 1.1, 2.2]
bn = mcolors.BoundaryNorm(boundaries, 2)
expected = [-1, 0, 1, 2]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# same with interp
bn = mcolors.BoundaryNorm(boundaries, 3)
expected = [-1, 0, 2, 3]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# Clipping
bn = mcolors.BoundaryNorm(boundaries, 3, clip=True)
expected = [0, 0, 2, 2]
for v, ex in zip(vals, expected):
ret = bn(v)
assert isinstance(ret, int)
assert_array_equal(ret, ex)
assert_array_equal(bn([v]), ex)
# Masked arrays
boundaries = [0, 1.1, 2.2]
vals = np.ma.masked_invalid([-1., np.NaN, 0, 1.4, 9])
# Without interpolation
ncolors = len(boundaries) - 1
bn = mcolors.BoundaryNorm(boundaries, ncolors)
expected = np.ma.masked_array([-1, -99, 0, 1, 2], mask=[0, 1, 0, 0, 0])
assert_array_equal(bn(vals), expected)
# With interpolation
bn = mcolors.BoundaryNorm(boundaries, len(boundaries))
expected = np.ma.masked_array([-1, -99, 0, 2, 3], mask=[0, 1, 0, 0, 0])
assert_array_equal(bn(vals), expected)
# Non-trivial masked arrays
vals = np.ma.masked_invalid([np.Inf, np.NaN])
assert np.all(bn(vals).mask)
vals = np.ma.masked_invalid([np.Inf])
assert np.all(bn(vals).mask)
# Incompatible extend and clip
with pytest.raises(ValueError, match="not compatible"):
mcolors.BoundaryNorm(np.arange(4), 5, extend='both', clip=True)
# Too small ncolors argument
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 2)
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 3, extend='min')
with pytest.raises(ValueError, match="ncolors must equal or exceed"):
mcolors.BoundaryNorm(np.arange(4), 4, extend='both')
# Testing extend keyword, with interpolation (large cmap)
bounds = [1, 2, 3]
cmap = mpl.colormaps['viridis']
mynorm = mcolors.BoundaryNorm(bounds, cmap.N, extend='both')
refnorm = mcolors.BoundaryNorm([0] + bounds + [4], cmap.N)
x = np.random.randn(100) * 10 + 2
ref = refnorm(x)
ref[ref == 0] = -1
ref[ref == cmap.N - 1] = cmap.N
assert_array_equal(mynorm(x), ref)
# Without interpolation
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_over('black')
cmref.set_under('white')
cmshould = mcolors.ListedColormap(['white', 'blue', 'red', 'black'])
assert mcolors.same_color(cmref.get_over(), 'black')
assert mcolors.same_color(cmref.get_under(), 'white')
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='both')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
assert mynorm(bounds[0] - 0.1) == -1 # under
assert mynorm(bounds[0] + 0.1) == 1 # first bin -> second color
assert mynorm(bounds[-1] - 0.1) == cmshould.N - 2 # next-to-last color
assert mynorm(bounds[-1] + 0.1) == cmshould.N # over
x = [-1, 1.2, 2.3, 9.6]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2, 3]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
# Just min
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_under('white')
cmshould = mcolors.ListedColormap(['white', 'blue', 'red'])
assert mcolors.same_color(cmref.get_under(), 'white')
assert cmref.N == 2
assert cmshould.N == 3
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='min')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
x = [-1, 1.2, 2.3]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
# Just max
cmref = mcolors.ListedColormap(['blue', 'red'])
cmref.set_over('black')
cmshould = mcolors.ListedColormap(['blue', 'red', 'black'])
assert mcolors.same_color(cmref.get_over(), 'black')
assert cmref.N == 2
assert cmshould.N == 3
refnorm = mcolors.BoundaryNorm(bounds, cmref.N)
mynorm = mcolors.BoundaryNorm(bounds, cmshould.N, extend='max')
assert mynorm.vmin == refnorm.vmin
assert mynorm.vmax == refnorm.vmax
x = [1.2, 2.3, 4]
assert_array_equal(cmshould(mynorm(x)), cmshould([0, 1, 2]))
x = np.random.randn(100) * 10 + 2
assert_array_equal(cmshould(mynorm(x)), cmref(refnorm(x)))
```
###Assistant :
GitHub issue #1258: interpolation was failing with numpy
1.7 pre-release.
|
38 | def _join_by_index(self, other_modin_frames, how, sort, ignore_index):
if how == "outer":
raise NotImplementedError("outer join is not supported in HDK engine")
lhs = self._maybe_materialize_rowid()
reset_index_names = False
for rhs in other_modin_frames:
rhs = rhs._maybe_materialize_rowid()
if len(lhs._index_cols) != len(rhs._index_cols):
raise NotImplementedError(
"join by indexes with different sizes is not supported"
)
reset_index_names = reset_index_names or lhs._index_cols != rhs._index_cols
condition = lhs._build_equi_join_condition(
rhs, lhs._index_cols, rhs._index_cols
)
exprs = lhs._index_exprs()
new_columns = lhs.columns.to_list()
for col in lhs.columns:
exprs[col] = lhs.ref(col)
for col in rhs.columns:
# Handle duplicating column names here. When user specifies
# suffixes to make a join, actual renaming is done in front-end.
new_col_name = col
rename_idx = 0
while new_col_name in exprs:
new_col_name = f"{col}{rename_idx}"
rename_idx += 1
exprs[new_col_name] = rhs.ref(col)
new_columns.append(new_col_name)
op = JoinNode(
lhs,
rhs,
how=how,
exprs=exprs,
condition=condition,
)
new_columns = Index.__new__(
Index, data=new_columns, dtype=self.columns.dtype
)
lhs = lhs.__constructor__(
dtypes=lhs._dtypes_for_exprs(exprs),
columns=new_columns,
index_cols=lhs._index_cols,
op=op,
force_execution_mode=self._force_execution_mode,
)
if sort:
lhs = lhs.sort_rows(
lhs._index_cols,
ascending=True,
ignore_index=False,
na_position="last",
)
if reset_index_names:
lhs = lhs._reset_index_names()
if ignore_index:
new_columns = Index.__new__(RangeIndex, data=range(len(lhs.columns)))
lhs = lhs._set_columns(new_columns)
return lhs
|
Perform equi-join operation for multiple frames by index columns.
Parameters
----------
other_modin_frames : list of HdkOnNativeDataframe
Frames to join with.
how : str
A type of join.
sort : bool
Sort the result by join keys.
ignore_index : bool
If True then reset column index for the resulting frame.
Returns
-------
HdkOnNativeDataframe
The new frame.
| 55 | 171 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _join_by_index(self, other_modin_frames, how, sort, ignore_index):
if how == "outer":
raise NotImplementedError("outer join is not supported in HDK engine")
lhs = self._maybe_materialize_rowid()
reset_index_names = False
for rhs in other_modin_frames:
rhs = rhs._maybe_materialize_rowid()
if len(lhs._index_cols) != len(rhs._index_cols):
raise NotImplementedError(
"join by indexes with different sizes is not supported"
)
reset_index_names = reset_index_names or lhs._index_cols != rhs._index_cols
condition = lhs._build_equi_join_condition(
rhs, lhs._index_cols, rhs._index_cols
)
exprs = lhs._index_exprs()
new_columns = lhs.columns.to_list()
for col in lhs.columns:
exprs[col] = lhs.ref(col)
for col in rhs.columns:
# Handle duplicating column names here. When user specifies
# suffixes to make a join, actual renaming is done in front-end.
new_col_name = col
rename_idx = 0
while new_col_name in exprs:
new_col_name = f"{col}{rename_idx}"
rename_idx += 1
exprs[new_col_name] = rhs.ref(col)
new_columns.append(new_col_name)
op = JoinNode(
lhs,
rhs,
how=how,
exprs=exprs,
condition=condition,
)
new_columns = Index.__new__(
Index, data=new_columns, dtype=self.columns.dtype
)
lhs = lhs.__constructor__(
dtypes=lhs._dtypes_for_exprs(exprs),
columns=new_columns,
index_cols=lhs._index_cols,
op=op,
force_execution_mode=self._force_execution_mode,
)
if sort:
lhs = lhs.sort_rows(
lhs._index_cols,
ascending=True,
ignore_index=False,
na_position="last",
)
if reset_index_names:
lhs = lhs._reset_index_names()
if ignore_index:
new_columns = Index.__new__(RangeIndex, data=range(len(lhs.columns)))
lhs = lhs._set_columns(new_columns)
return lhs
```
###Assistant :
Perform equi-join operation for multiple frames by index columns.
Parameters
----------
other_modin_frames : list of HdkOnNativeDataframe
Frames to join with.
how : str
A type of join.
sort : bool
Sort the result by join keys.
ignore_index : bool
If True then reset column index for the resulting frame.
Returns
-------
HdkOnNativeDataframe
The new frame.
|
39 | def _object2proto(self) -> RunFunctionOrConstructorAction_PB:
return RunFunctionOrConstructorAction_PB(
path=self.path,
args=[serialize(x, to_bytes=True) for x in self.args],
kwargs={k: serialize(v, to_bytes=True) for k, v in self.kwargs.items()},
id_at_location=serialize(self.id_at_location),
address=serialize(self.address),
msg_id=serialize(self.id),
)
| Returns a protobuf serialization of self.
As a requirement of all objects which inherit from Serializable,
this method transforms the current object into the corresponding
Protobuf object so that it can be further serialized.
:return: returns a protobuf object
:rtype: RunFunctionOrConstructorAction_PB
.. note::
This method is purely an internal method. Please use serialize(object) or one of
the other public serialization methods if you wish to serialize an
object.
| 68 | 25 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _object2proto(self) -> RunFunctionOrConstructorAction_PB:
return RunFunctionOrConstructorAction_PB(
path=self.path,
args=[serialize(x, to_bytes=True) for x in self.args],
kwargs={k: serialize(v, to_bytes=True) for k, v in self.kwargs.items()},
id_at_location=serialize(self.id_at_location),
address=serialize(self.address),
msg_id=serialize(self.id),
)
```
###Assistant : Returns a protobuf serialization of self.
As a requirement of all objects which inherit from Serializable,
this method transforms the current object into the corresponding
Protobuf object so that it can be further serialized.
:return: returns a protobuf object
:rtype: RunFunctionOrConstructorAction_PB
.. note::
This method is purely an internal method. Please use serialize(object) or one of
the other public serialization methods if you wish to serialize an
object.
|
40 | def truncated_cube_graph(create_using=None):
description = [
"adjacencylist",
"Truncated Cube Graph",
24,
[
[2, 3, 5],
[12, 15],
[4, 5],
[7, 9],
[6],
[17, 19],
[8, 9],
[11, 13],
[10],
[18, 21],
[12, 13],
[15],
[14],
[22, 23],
[16],
[20, 24],
[18, 19],
[21],
[20],
[24],
[22],
[23],
[24],
[],
],
]
G = make_small_undirected_graph(description, create_using)
return G
|
Returns the skeleton of the truncated cube.
The truncated cube is an Archimedean solid with 14 regular
faces (6 octagonal and 8 triangular), 36 edges and 24 nodes [1]_.
The truncated cube is created by truncating (cutting off) the tips
of the cube one third of the way into each edge [2]_.
Parameters
----------
create_using : NetworkX graph constructor, optional (default=nx.Graph)
Graph type to create. If graph instance, then cleared before populated.
Returns
-------
G : networkx Graph
Skeleton of the truncated cube
References
----------
.. [1] https://en.wikipedia.org/wiki/Truncated_cube
.. [2] https://www.coolmath.com/reference/polyhedra-truncated-cube
| 91 | 56 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def truncated_cube_graph(create_using=None):
description = [
"adjacencylist",
"Truncated Cube Graph",
24,
[
[2, 3, 5],
[12, 15],
[4, 5],
[7, 9],
[6],
[17, 19],
[8, 9],
[11, 13],
[10],
[18, 21],
[12, 13],
[15],
[14],
[22, 23],
[16],
[20, 24],
[18, 19],
[21],
[20],
[24],
[22],
[23],
[24],
[],
],
]
G = make_small_undirected_graph(description, create_using)
return G
```
###Assistant :
Returns the skeleton of the truncated cube.
The truncated cube is an Archimedean solid with 14 regular
faces (6 octagonal and 8 triangular), 36 edges and 24 nodes [1]_.
The truncated cube is created by truncating (cutting off) the tips
of the cube one third of the way into each edge [2]_.
Parameters
----------
create_using : NetworkX graph constructor, optional (default=nx.Graph)
Graph type to create. If graph instance, then cleared before populated.
Returns
-------
G : networkx Graph
Skeleton of the truncated cube
References
----------
.. [1] https://en.wikipedia.org/wiki/Truncated_cube
.. [2] https://www.coolmath.com/reference/polyhedra-truncated-cube
|
41 | def get_admin_urls_for_registration(self):
urls = ()
for instance in self.modeladmin_instances:
urls += instance.get_admin_urls_for_registration()
return urls
|
Utilised by Wagtail's 'register_admin_urls' hook to register urls for
used by any associated ModelAdmin instances
| 15 | 14 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_admin_urls_for_registration(self):
urls = ()
for instance in self.modeladmin_instances:
urls += instance.get_admin_urls_for_registration()
return urls
```
###Assistant :
Utilised by Wagtail's 'register_admin_urls' hook to register urls for
used by any associated ModelAdmin instances
|
42 | def setName(self, name):
self.name = name
self.errmsg = "Expected " + self.name
if __diag__.enable_debug_on_named_expressions:
self.setDebug()
return self
|
Define name for this expression, makes debugging and exception messages clearer.
Example::
Word(nums).parseString("ABC") # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
Word(nums).setName("integer").parseString("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1)
| 34 | 17 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def setName(self, name):
self.name = name
self.errmsg = "Expected " + self.name
if __diag__.enable_debug_on_named_expressions:
self.setDebug()
return self
```
###Assistant :
Define name for this expression, makes debugging and exception messages clearer.
Example::
Word(nums).parseString("ABC") # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
Word(nums).setName("integer").parseString("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1)
|
43 | def get_func(cls, key, **kwargs):
if "agg_func" in kwargs:
return cls.inplace_applyier_builder(key, kwargs["agg_func"])
elif "func_dict" in kwargs:
return cls.inplace_applyier_builder(key, kwargs["func_dict"])
else:
return cls.inplace_applyier_builder(key)
|
Extract aggregation function from groupby arguments.
Parameters
----------
key : callable or str
Default aggregation function. If aggregation function is not specified
via groupby arguments, then `key` function is used.
**kwargs : dict
GroupBy arguments that may contain aggregation function.
Returns
-------
callable
Aggregation function.
Notes
-----
There are two ways of how groupby aggregation can be invoked:
1. Explicitly with query compiler method: `qc.groupby_sum()`.
2. By passing aggregation function as an argument: `qc.groupby_agg("sum")`.
Both are going to produce the same result, however in the first case actual aggregation
function can be extracted from the method name, while for the second only from the method arguments.
| 106 | 21 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_func(cls, key, **kwargs):
if "agg_func" in kwargs:
return cls.inplace_applyier_builder(key, kwargs["agg_func"])
elif "func_dict" in kwargs:
return cls.inplace_applyier_builder(key, kwargs["func_dict"])
else:
return cls.inplace_applyier_builder(key)
```
###Assistant :
Extract aggregation function from groupby arguments.
Parameters
----------
key : callable or str
Default aggregation function. If aggregation function is not specified
via groupby arguments, then `key` function is used.
**kwargs : dict
GroupBy arguments that may contain aggregation function.
Returns
-------
callable
Aggregation function.
Notes
-----
There are two ways of how groupby aggregation can be invoked:
1. Explicitly with query compiler method: `qc.groupby_sum()`.
2. By passing aggregation function as an argument: `qc.groupby_agg("sum")`.
Both are going to produce the same result, however in the first case actual aggregation
function can be extracted from the method name, while for the second only from the method arguments.
|
44 | def update_scheduler(self, metric):
self.worker_group.apply_all_operators(
lambda op: [sched.step(metric) for sched in op._schedulers]
)
| Calls ``scheduler.step(metric)`` on all registered schedulers.
This is useful for lr_schedulers such as ``ReduceLROnPlateau``.
| 14 | 12 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def update_scheduler(self, metric):
self.worker_group.apply_all_operators(
lambda op: [sched.step(metric) for sched in op._schedulers]
)
```
###Assistant : Calls ``scheduler.step(metric)`` on all registered schedulers.
This is useful for lr_schedulers such as ``ReduceLROnPlateau``.
|
45 | def paired_cosine_distances(X, Y):
X, Y = check_paired_arrays(X, Y)
return 0.5 * row_norms(normalize(X) - normalize(Y), squared=True)
PAIRED_DISTANCES = {
"cosine": paired_cosine_distances,
"euclidean": paired_euclidean_distances,
"l2": paired_euclidean_distances,
"l1": paired_manhattan_distances,
"manhattan": paired_manhattan_distances,
"cityblock": paired_manhattan_distances,
}
|
Compute the paired cosine distances between X and Y.
Read more in the :ref:`User Guide <metrics>`.
Parameters
----------
X : array-like of shape (n_samples, n_features)
An array where each row is a sample and each column is a feature.
Y : array-like of shape (n_samples, n_features)
An array where each row is a sample and each column is a feature.
Returns
-------
distances : ndarray of shape (n_samples,)
Returns the distances between the row vectors of `X`
and the row vectors of `Y`, where `distances[i]` is the
distance between `X[i]` and `Y[i]`.
Notes
-----
The cosine distance is equivalent to the half the squared
euclidean distance if each sample is normalized to unit norm.
| 114 | 31 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def paired_cosine_distances(X, Y):
X, Y = check_paired_arrays(X, Y)
return 0.5 * row_norms(normalize(X) - normalize(Y), squared=True)
PAIRED_DISTANCES = {
"cosine": paired_cosine_distances,
"euclidean": paired_euclidean_distances,
"l2": paired_euclidean_distances,
"l1": paired_manhattan_distances,
"manhattan": paired_manhattan_distances,
"cityblock": paired_manhattan_distances,
}
```
###Assistant :
Compute the paired cosine distances between X and Y.
Read more in the :ref:`User Guide <metrics>`.
Parameters
----------
X : array-like of shape (n_samples, n_features)
An array where each row is a sample and each column is a feature.
Y : array-like of shape (n_samples, n_features)
An array where each row is a sample and each column is a feature.
Returns
-------
distances : ndarray of shape (n_samples,)
Returns the distances between the row vectors of `X`
and the row vectors of `Y`, where `distances[i]` is the
distance between `X[i]` and `Y[i]`.
Notes
-----
The cosine distance is equivalent to the half the squared
euclidean distance if each sample is normalized to unit norm.
|
46 | def torchdynamo_smart_context_manager(self):
ctx_manager = contextlib.nullcontext()
if is_torchdynamo_available():
import torchdynamo
from torchdynamo.optimizations.training import aot_autograd_speedup_strategy
if self.args.torchdynamo == "eager":
ctx_manager = torchdynamo.optimize("eager")
elif self.args.torchdynamo == "nvfuser":
ctx_manager = torchdynamo.optimize(aot_autograd_speedup_strategy)
return ctx_manager
|
A helper wrapper that creates an appropriate context manager for `torchdynamo`.
| 11 | 29 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def torchdynamo_smart_context_manager(self):
ctx_manager = contextlib.nullcontext()
if is_torchdynamo_available():
import torchdynamo
from torchdynamo.optimizations.training import aot_autograd_speedup_strategy
if self.args.torchdynamo == "eager":
ctx_manager = torchdynamo.optimize("eager")
elif self.args.torchdynamo == "nvfuser":
ctx_manager = torchdynamo.optimize(aot_autograd_speedup_strategy)
return ctx_manager
```
###Assistant :
A helper wrapper that creates an appropriate context manager for `torchdynamo`.
|
47 | def check_aug_version(self) -> bool:
self.aug.set("/test/path/testing/arg", "aRgUMeNT")
try:
matches = self.aug.match(
"/test//*[self::arg=~regexp('argument', 'i')]")
except RuntimeError:
self.aug.remove("/test/path")
return False
self.aug.remove("/test/path")
return matches
| Checks that we have recent enough version of libaugeas.
If augeas version is recent enough, it will support case insensitive
regexp matching | 22 | 20 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def check_aug_version(self) -> bool:
self.aug.set("/test/path/testing/arg", "aRgUMeNT")
try:
matches = self.aug.match(
"/test//*[self::arg=~regexp('argument', 'i')]")
except RuntimeError:
self.aug.remove("/test/path")
return False
self.aug.remove("/test/path")
return matches
```
###Assistant : Checks that we have recent enough version of libaugeas.
If augeas version is recent enough, it will support case insensitive
regexp matching
|
48 | def resize_depth(depth, width, height):
depth = torch.squeeze(depth[0, :, :, :]).to("cpu")
depth_resized = cv2.resize(
depth.numpy(), (width, height), interpolation=cv2.INTER_CUBIC
)
return depth_resized
| Resize depth map and bring to CPU (numpy).
Args:
depth (tensor): depth
width (int): image width
height (int): image height
Returns:
array: processed depth
| 24 | 20 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def resize_depth(depth, width, height):
depth = torch.squeeze(depth[0, :, :, :]).to("cpu")
depth_resized = cv2.resize(
depth.numpy(), (width, height), interpolation=cv2.INTER_CUBIC
)
return depth_resized
```
###Assistant : Resize depth map and bring to CPU (numpy).
Args:
depth (tensor): depth
width (int): image width
height (int): image height
Returns:
array: processed depth
|
49 | def comp(z1, z2, tol=None):
r
if type(z2) is str:
if not pure_complex(z1, or_real=True):
raise ValueError('when z2 is a str z1 must be a Number')
return str(z1) == z2
if not z1:
z1, z2 = z2, z1
if not z1:
return True
if not tol:
a, b = z1, z2
if tol == '':
return str(a) == str(b)
if tol is None:
a, b = sympify(a), sympify(b)
if not all(i.is_number for i in (a, b)):
raise ValueError('expecting 2 numbers')
fa = a.atoms(Float)
fb = b.atoms(Float)
if not fa and not fb:
# no floats -- compare exactly
return a == b
# get a to be pure_complex
for _ in range(2):
ca = pure_complex(a, or_real=True)
if not ca:
if fa:
a = a.n(prec_to_dps(min([i._prec for i in fa])))
ca = pure_complex(a, or_real=True)
break
else:
fa, fb = fb, fa
a, b = b, a
cb = pure_complex(b)
if not cb and fb:
b = b.n(prec_to_dps(min([i._prec for i in fb])))
cb = pure_complex(b, or_real=True)
if ca and cb and (ca[1] or cb[1]):
return all(comp(i, j) for i, j in zip(ca, cb))
tol = 10**prec_to_dps(min(a._prec, getattr(b, '_prec', a._prec)))
return int(abs(a - b)*tol) <= 5
diff = abs(z1 - z2)
az1 = abs(z1)
if z2 and az1 > 1:
return diff/az1 <= tol
else:
return diff <= tol
| Return a bool indicating whether the error between z1 and z2
is $\le$ ``tol``.
Examples
========
If ``tol`` is ``None`` then ``True`` will be returned if
:math:`|z1 - z2|\times 10^p \le 5` where $p$ is minimum value of the
decimal precision of each value.
>>> from sympy import comp, pi
>>> pi4 = pi.n(4); pi4
3.142
>>> comp(_, 3.142)
True
>>> comp(pi4, 3.141)
False
>>> comp(pi4, 3.143)
False
A comparison of strings will be made
if ``z1`` is a Number and ``z2`` is a string or ``tol`` is ''.
>>> comp(pi4, 3.1415)
True
>>> comp(pi4, 3.1415, '')
False
When ``tol`` is provided and $z2$ is non-zero and
:math:`|z1| > 1` the error is normalized by :math:`|z1|`:
>>> abs(pi4 - 3.14)/pi4
0.000509791731426756
>>> comp(pi4, 3.14, .001) # difference less than 0.1%
True
>>> comp(pi4, 3.14, .0005) # difference less than 0.1%
False
When :math:`|z1| \le 1` the absolute error is used:
>>> 1/pi4
0.3183
>>> abs(1/pi4 - 0.3183)/(1/pi4)
3.07371499106316e-5
>>> abs(1/pi4 - 0.3183)
9.78393554684764e-6
>>> comp(1/pi4, 0.3183, 1e-5)
True
To see if the absolute error between ``z1`` and ``z2`` is less
than or equal to ``tol``, call this as ``comp(z1 - z2, 0, tol)``
or ``comp(z1 - z2, tol=tol)``:
>>> abs(pi4 - 3.14)
0.00160156249999988
>>> comp(pi4 - 3.14, 0, .002)
True
>>> comp(pi4 - 3.14, 0, .001)
False
| 217 | 213 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def comp(z1, z2, tol=None):
r
if type(z2) is str:
if not pure_complex(z1, or_real=True):
raise ValueError('when z2 is a str z1 must be a Number')
return str(z1) == z2
if not z1:
z1, z2 = z2, z1
if not z1:
return True
if not tol:
a, b = z1, z2
if tol == '':
return str(a) == str(b)
if tol is None:
a, b = sympify(a), sympify(b)
if not all(i.is_number for i in (a, b)):
raise ValueError('expecting 2 numbers')
fa = a.atoms(Float)
fb = b.atoms(Float)
if not fa and not fb:
# no floats -- compare exactly
return a == b
# get a to be pure_complex
for _ in range(2):
ca = pure_complex(a, or_real=True)
if not ca:
if fa:
a = a.n(prec_to_dps(min([i._prec for i in fa])))
ca = pure_complex(a, or_real=True)
break
else:
fa, fb = fb, fa
a, b = b, a
cb = pure_complex(b)
if not cb and fb:
b = b.n(prec_to_dps(min([i._prec for i in fb])))
cb = pure_complex(b, or_real=True)
if ca and cb and (ca[1] or cb[1]):
return all(comp(i, j) for i, j in zip(ca, cb))
tol = 10**prec_to_dps(min(a._prec, getattr(b, '_prec', a._prec)))
return int(abs(a - b)*tol) <= 5
diff = abs(z1 - z2)
az1 = abs(z1)
if z2 and az1 > 1:
return diff/az1 <= tol
else:
return diff <= tol
```
###Assistant : Return a bool indicating whether the error between z1 and z2
is $\le$ ``tol``.
Examples
========
If ``tol`` is ``None`` then ``True`` will be returned if
:math:`|z1 - z2|\times 10^p \le 5` where $p$ is minimum value of the
decimal precision of each value.
>>> from sympy import comp, pi
>>> pi4 = pi.n(4); pi4
3.142
>>> comp(_, 3.142)
True
>>> comp(pi4, 3.141)
False
>>> comp(pi4, 3.143)
False
A comparison of strings will be made
if ``z1`` is a Number and ``z2`` is a string or ``tol`` is ''.
>>> comp(pi4, 3.1415)
True
>>> comp(pi4, 3.1415, '')
False
When ``tol`` is provided and $z2$ is non-zero and
:math:`|z1| > 1` the error is normalized by :math:`|z1|`:
>>> abs(pi4 - 3.14)/pi4
0.000509791731426756
>>> comp(pi4, 3.14, .001) # difference less than 0.1%
True
>>> comp(pi4, 3.14, .0005) # difference less than 0.1%
False
When :math:`|z1| \le 1` the absolute error is used:
>>> 1/pi4
0.3183
>>> abs(1/pi4 - 0.3183)/(1/pi4)
3.07371499106316e-5
>>> abs(1/pi4 - 0.3183)
9.78393554684764e-6
>>> comp(1/pi4, 0.3183, 1e-5)
True
To see if the absolute error between ``z1`` and ``z2`` is less
than or equal to ``tol``, call this as ``comp(z1 - z2, 0, tol)``
or ``comp(z1 - z2, tol=tol)``:
>>> abs(pi4 - 3.14)
0.00160156249999988
>>> comp(pi4 - 3.14, 0, .002)
True
>>> comp(pi4 - 3.14, 0, .001)
False
|
50 | def _parse_img_level_ann(self, image_level_ann_file):
item_lists = defaultdict(list)
with self.file_client.get_local_path(
image_level_ann_file) as local_path:
with open(local_path, 'r') as f:
reader = csv.reader(f)
i = -1
for line in reader:
i += 1
if i == 0:
continue
else:
img_id = line[0]
label_id = line[1]
assert label_id in self.label_id_mapping
image_level_label = int(
self.label_id_mapping[label_id])
confidence = float(line[2])
item_lists[img_id].append(
dict(
image_level_label=image_level_label,
confidence=confidence))
return item_lists
| Parse image level annotations from csv style ann_file.
Args:
image_level_ann_file (str): CSV style image level annotation
file path.
Returns:
defaultdict[list[dict]]: Annotations where item of the defaultdict
indicates an image, each of which has (n) dicts.
Keys of dicts are:
- `image_level_label` (int): of shape 1.
- `confidence` (float): of shape 1.
| 51 | 58 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def _parse_img_level_ann(self, image_level_ann_file):
item_lists = defaultdict(list)
with self.file_client.get_local_path(
image_level_ann_file) as local_path:
with open(local_path, 'r') as f:
reader = csv.reader(f)
i = -1
for line in reader:
i += 1
if i == 0:
continue
else:
img_id = line[0]
label_id = line[1]
assert label_id in self.label_id_mapping
image_level_label = int(
self.label_id_mapping[label_id])
confidence = float(line[2])
item_lists[img_id].append(
dict(
image_level_label=image_level_label,
confidence=confidence))
return item_lists
```
###Assistant : Parse image level annotations from csv style ann_file.
Args:
image_level_ann_file (str): CSV style image level annotation
file path.
Returns:
defaultdict[list[dict]]: Annotations where item of the defaultdict
indicates an image, each of which has (n) dicts.
Keys of dicts are:
- `image_level_label` (int): of shape 1.
- `confidence` (float): of shape 1.
|
51 | def logical_and(self, a, b):
a = _convert_other(a, raiseit=True)
return a.logical_and(b, context=self)
| Applies the logical operation 'and' between each operand's digits.
The operands must be both logical numbers.
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('0'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('1'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('0'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('1'))
Decimal('1')
>>> ExtendedContext.logical_and(Decimal('1100'), Decimal('1010'))
Decimal('1000')
>>> ExtendedContext.logical_and(Decimal('1111'), Decimal('10'))
Decimal('10')
>>> ExtendedContext.logical_and(110, 1101)
Decimal('100')
>>> ExtendedContext.logical_and(Decimal(110), 1101)
Decimal('100')
>>> ExtendedContext.logical_and(110, Decimal(1101))
Decimal('100')
| 52 | 11 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def logical_and(self, a, b):
a = _convert_other(a, raiseit=True)
return a.logical_and(b, context=self)
```
###Assistant : Applies the logical operation 'and' between each operand's digits.
The operands must be both logical numbers.
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('0'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('1'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('0'))
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('1'))
Decimal('1')
>>> ExtendedContext.logical_and(Decimal('1100'), Decimal('1010'))
Decimal('1000')
>>> ExtendedContext.logical_and(Decimal('1111'), Decimal('10'))
Decimal('10')
>>> ExtendedContext.logical_and(110, 1101)
Decimal('100')
>>> ExtendedContext.logical_and(Decimal(110), 1101)
Decimal('100')
>>> ExtendedContext.logical_and(110, Decimal(1101))
Decimal('100')
|
52 | def decrement_part_small(self, part, ub):
if self.lpart >= ub - 1:
self.p1 += 1 # increment to keep track of usefulness of tests
return False
plen = len(part)
for j in range(plen - 1, -1, -1):
# Knuth's mod, (answer to problem 7.2.1.5.69)
if j == 0 and (part[0].v - 1)*(ub - self.lpart) < part[0].u:
self.k1 += 1
return False
if j == 0 and part[j].v > 1 or j > 0 and part[j].v > 0:
# found val to decrement
part[j].v -= 1
# Reset trailing parts back to maximum
for k in range(j + 1, plen):
part[k].v = part[k].u
# Have now decremented part, but are we doomed to
# failure when it is expanded? Check one oddball case
# that turns out to be surprisingly common - exactly
# enough room to expand the leading component, but no
# room for the second component, which has v=0.
if (plen > 1 and part[1].v == 0 and
(part[0].u - part[0].v) ==
((ub - self.lpart - 1) * part[0].v)):
self.k2 += 1
self.db_trace("Decrement fails test 3")
return False
return True
return False
| Decrements part (a subrange of pstack), if possible, returning
True iff the part was successfully decremented.
Parameters
==========
part
part to be decremented (topmost part on the stack)
ub
the maximum number of parts allowed in a partition
returned by the calling traversal.
Notes
=====
The goal of this modification of the ordinary decrement method
is to fail (meaning that the subtree rooted at this part is to
be skipped) when it can be proved that this part can only have
child partitions which are larger than allowed by ``ub``. If a
decision is made to fail, it must be accurate, otherwise the
enumeration will miss some partitions. But, it is OK not to
capture all the possible failures -- if a part is passed that
should not be, the resulting too-large partitions are filtered
by the enumeration one level up. However, as is usual in
constrained enumerations, failing early is advantageous.
The tests used by this method catch the most common cases,
although this implementation is by no means the last word on
this problem. The tests include:
1) ``lpart`` must be less than ``ub`` by at least 2. This is because
once a part has been decremented, the partition
will gain at least one child in the spread step.
2) If the leading component of the part is about to be
decremented, check for how many parts will be added in
order to use up the unallocated multiplicity in that
leading component, and fail if this number is greater than
allowed by ``ub``. (See code for the exact expression.) This
test is given in the answer to Knuth's problem 7.2.1.5.69.
3) If there is *exactly* enough room to expand the leading
component by the above test, check the next component (if
it exists) once decrementing has finished. If this has
``v == 0``, this next component will push the expansion over the
limit by 1, so fail.
| 319 | 182 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def decrement_part_small(self, part, ub):
if self.lpart >= ub - 1:
self.p1 += 1 # increment to keep track of usefulness of tests
return False
plen = len(part)
for j in range(plen - 1, -1, -1):
# Knuth's mod, (answer to problem 7.2.1.5.69)
if j == 0 and (part[0].v - 1)*(ub - self.lpart) < part[0].u:
self.k1 += 1
return False
if j == 0 and part[j].v > 1 or j > 0 and part[j].v > 0:
# found val to decrement
part[j].v -= 1
# Reset trailing parts back to maximum
for k in range(j + 1, plen):
part[k].v = part[k].u
# Have now decremented part, but are we doomed to
# failure when it is expanded? Check one oddball case
# that turns out to be surprisingly common - exactly
# enough room to expand the leading component, but no
# room for the second component, which has v=0.
if (plen > 1 and part[1].v == 0 and
(part[0].u - part[0].v) ==
((ub - self.lpart - 1) * part[0].v)):
self.k2 += 1
self.db_trace("Decrement fails test 3")
return False
return True
return False
```
###Assistant : Decrements part (a subrange of pstack), if possible, returning
True iff the part was successfully decremented.
Parameters
==========
part
part to be decremented (topmost part on the stack)
ub
the maximum number of parts allowed in a partition
returned by the calling traversal.
Notes
=====
The goal of this modification of the ordinary decrement method
is to fail (meaning that the subtree rooted at this part is to
be skipped) when it can be proved that this part can only have
child partitions which are larger than allowed by ``ub``. If a
decision is made to fail, it must be accurate, otherwise the
enumeration will miss some partitions. But, it is OK not to
capture all the possible failures -- if a part is passed that
should not be, the resulting too-large partitions are filtered
by the enumeration one level up. However, as is usual in
constrained enumerations, failing early is advantageous.
The tests used by this method catch the most common cases,
although this implementation is by no means the last word on
this problem. The tests include:
1) ``lpart`` must be less than ``ub`` by at least 2. This is because
once a part has been decremented, the partition
will gain at least one child in the spread step.
2) If the leading component of the part is about to be
decremented, check for how many parts will be added in
order to use up the unallocated multiplicity in that
leading component, and fail if this number is greater than
allowed by ``ub``. (See code for the exact expression.) This
test is given in the answer to Knuth's problem 7.2.1.5.69.
3) If there is *exactly* enough room to expand the leading
component by the above test, check the next component (if
it exists) once decrementing has finished. If this has
``v == 0``, this next component will push the expansion over the
limit by 1, so fail.
|
53 | def get_node_id(self) -> str:
node_id = self.worker.current_node_id
assert not node_id.is_nil()
return node_id.hex()
| Get current node ID for this worker or driver.
Node ID is the id of a node that your driver, task, or actor runs.
The ID will be in hex format.
Returns:
A node id in hex format for this worker or driver.
| 43 | 12 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_node_id(self) -> str:
node_id = self.worker.current_node_id
assert not node_id.is_nil()
return node_id.hex()
```
###Assistant : Get current node ID for this worker or driver.
Node ID is the id of a node that your driver, task, or actor runs.
The ID will be in hex format.
Returns:
A node id in hex format for this worker or driver.
|
54 | def list_option(*, info):
return _option(
info,
"List options",
lambda opt: (isinstance(info.config.get_obj(opt.name), list) and
not opt.no_autoconfig)
)
| A CompletionModel filled with settings whose values are lists. | 9 | 16 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def list_option(*, info):
return _option(
info,
"List options",
lambda opt: (isinstance(info.config.get_obj(opt.name), list) and
not opt.no_autoconfig)
)
```
###Assistant : A CompletionModel filled with settings whose values are lists.
|
55 | def get_instance_from_config_with_end_date(config, query):
start_date = "2021-03-04"
end_date = "2021-04-04"
conversion_window_days = 14
google_api = GoogleAds(credentials=config["credentials"], customer_id=config["customer_id"])
instance = CustomQuery(
api=google_api,
conversion_window_days=conversion_window_days,
start_date=start_date,
end_date=end_date,
time_zone="local",
custom_query_config={"query": query, "table_name": "whatever_table"},
)
return instance
@pytest.mark.parametrize(
"query, fields",
[
(
,
["campaign.id", "campaign.name", "campaign.status", "metrics.impressions"],
),
(
,
["campaign.accessible_bidding_strategy", "segments.ad_destination_type", "campaign.start_date", "campaign.end_date"],
),
(, []),
],
) |
SELecT
campaign.id,
campaign.name,
campaign.status,
metrics.impressions FROM campaign
wheRe campaign.status = 'PAUSED'
AND metrics.impressions > 100
order by campaign.status
SELECT
campaign.accessible_bidding_strategy,
segments.ad_destination_type,
campaign.start_date,
campaign.end_date
FROM campaign
selet aasdasd from aaa | 29 | 53 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def get_instance_from_config_with_end_date(config, query):
start_date = "2021-03-04"
end_date = "2021-04-04"
conversion_window_days = 14
google_api = GoogleAds(credentials=config["credentials"], customer_id=config["customer_id"])
instance = CustomQuery(
api=google_api,
conversion_window_days=conversion_window_days,
start_date=start_date,
end_date=end_date,
time_zone="local",
custom_query_config={"query": query, "table_name": "whatever_table"},
)
return instance
@pytest.mark.parametrize(
"query, fields",
[
(
,
["campaign.id", "campaign.name", "campaign.status", "metrics.impressions"],
),
(
,
["campaign.accessible_bidding_strategy", "segments.ad_destination_type", "campaign.start_date", "campaign.end_date"],
),
(, []),
],
)
```
###Assistant :
SELecT
campaign.id,
campaign.name,
campaign.status,
metrics.impressions FROM campaign
wheRe campaign.status = 'PAUSED'
AND metrics.impressions > 100
order by campaign.status
SELECT
campaign.accessible_bidding_strategy,
segments.ad_destination_type,
campaign.start_date,
campaign.end_date
FROM campaign
selet aasdasd from aaa
|
56 | def node_degree_xy(G, x="out", y="in", weight=None, nodes=None):
nodes = set(G) if nodes is None else set(nodes)
if G.is_directed():
direction = {"out": G.out_degree, "in": G.in_degree}
xdeg = direction[x]
ydeg = direction[y]
else:
xdeg = ydeg = G.degree
for u, degu in xdeg(nodes, weight=weight):
# use G.edges to treat multigraphs correctly
neighbors = (nbr for _, nbr in G.edges(u) if nbr in nodes)
for _, degv in ydeg(neighbors, weight=weight):
yield degu, degv
| Generate node degree-degree pairs for edges in G.
Parameters
----------
G: NetworkX graph
x: string ('in','out')
The degree type for source node (directed graphs only).
y: string ('in','out')
The degree type for target node (directed graphs only).
weight: string or None, optional (default=None)
The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.
nodes: list or iterable (optional)
Use only edges that are adjacency to specified nodes.
The default is all nodes.
Returns
-------
(x, y): 2-tuple
Generates 2-tuple of (degree, degree) values.
Examples
--------
>>> G = nx.DiGraph()
>>> G.add_edge(1, 2)
>>> list(nx.node_degree_xy(G, x="out", y="in"))
[(1, 1)]
>>> list(nx.node_degree_xy(G, x="in", y="out"))
[(0, 0)]
Notes
-----
For undirected graphs each edge is produced twice, once for each edge
representation (u, v) and (v, u), with the exception of self-loop edges
which only appear once.
| 157 | 69 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def node_degree_xy(G, x="out", y="in", weight=None, nodes=None):
nodes = set(G) if nodes is None else set(nodes)
if G.is_directed():
direction = {"out": G.out_degree, "in": G.in_degree}
xdeg = direction[x]
ydeg = direction[y]
else:
xdeg = ydeg = G.degree
for u, degu in xdeg(nodes, weight=weight):
# use G.edges to treat multigraphs correctly
neighbors = (nbr for _, nbr in G.edges(u) if nbr in nodes)
for _, degv in ydeg(neighbors, weight=weight):
yield degu, degv
```
###Assistant : Generate node degree-degree pairs for edges in G.
Parameters
----------
G: NetworkX graph
x: string ('in','out')
The degree type for source node (directed graphs only).
y: string ('in','out')
The degree type for target node (directed graphs only).
weight: string or None, optional (default=None)
The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.
nodes: list or iterable (optional)
Use only edges that are adjacency to specified nodes.
The default is all nodes.
Returns
-------
(x, y): 2-tuple
Generates 2-tuple of (degree, degree) values.
Examples
--------
>>> G = nx.DiGraph()
>>> G.add_edge(1, 2)
>>> list(nx.node_degree_xy(G, x="out", y="in"))
[(1, 1)]
>>> list(nx.node_degree_xy(G, x="in", y="out"))
[(0, 0)]
Notes
-----
For undirected graphs each edge is produced twice, once for each edge
representation (u, v) and (v, u), with the exception of self-loop edges
which only appear once.
|
57 | def validate(self, num_steps=None, profile=False, reduce_results=True, info=None):
worker_stats = self.worker_group.validate(
num_steps=num_steps, profile=profile, info=info
)
if reduce_results:
return self._process_stats(worker_stats)
else:
return worker_stats
| Evaluates the model on the validation data set.
Args:
num_steps (int): Number of batches to compute update steps on
per worker. This corresponds also to the number of times
``TrainingOperator.validate_batch`` is called per worker.
profile (bool): Returns time stats for the evaluation procedure.
reduce_results (bool): Whether to average all metrics across
all workers into one dict. If a metric is a non-numerical
value (or nested dictionaries), one value will be randomly
selected among the workers. If False, returns a list of dicts.
info (dict): Optional dictionary passed to the training
operator for `validate` and `validate_batch`.
Returns:
A dictionary of metrics for validation.
You can provide custom metrics by passing in a custom
``training_operator_cls``.
| 113 | 20 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def validate(self, num_steps=None, profile=False, reduce_results=True, info=None):
worker_stats = self.worker_group.validate(
num_steps=num_steps, profile=profile, info=info
)
if reduce_results:
return self._process_stats(worker_stats)
else:
return worker_stats
```
###Assistant : Evaluates the model on the validation data set.
Args:
num_steps (int): Number of batches to compute update steps on
per worker. This corresponds also to the number of times
``TrainingOperator.validate_batch`` is called per worker.
profile (bool): Returns time stats for the evaluation procedure.
reduce_results (bool): Whether to average all metrics across
all workers into one dict. If a metric is a non-numerical
value (or nested dictionaries), one value will be randomly
selected among the workers. If False, returns a list of dicts.
info (dict): Optional dictionary passed to the training
operator for `validate` and `validate_batch`.
Returns:
A dictionary of metrics for validation.
You can provide custom metrics by passing in a custom
``training_operator_cls``.
|
58 | def set_raw_scale(self, in_, scale):
self.__check_input(in_)
self.raw_scale[in_] = scale
|
Set the scale of raw features s.t. the input blob = input * scale.
While Python represents images in [0, 1], certain Caffe models
like CaffeNet and AlexNet represent images in [0, 255] so the raw_scale
of these models must be 255.
Parameters
----------
in_ : which input to assign this scale factor
scale : scale coefficient
| 57 | 8 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def set_raw_scale(self, in_, scale):
self.__check_input(in_)
self.raw_scale[in_] = scale
```
###Assistant :
Set the scale of raw features s.t. the input blob = input * scale.
While Python represents images in [0, 1], certain Caffe models
like CaffeNet and AlexNet represent images in [0, 255] so the raw_scale
of these models must be 255.
Parameters
----------
in_ : which input to assign this scale factor
scale : scale coefficient
|
59 | def test_add_rule_to_best_shard():
# If we start with an empty list, then add to first shard
shards: List[List[bazel_sharding.BazelRule]] = [list() for _ in range(4)]
optimum = 600
rule = bazel_sharding.BazelRule("mock", "medium")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[0][0] == rule
assert all(not shard for shard in shards[1:])
# Add to first shard below optimum
old_rule = bazel_sharding.BazelRule("mock", "medium")
shards: List[List[bazel_sharding.BazelRule]] = [[old_rule] for _ in range(4)]
shards[3] = []
optimum = old_rule.actual_timeout_s
rule = bazel_sharding.BazelRule("mock", "small")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[3][0] == rule
assert all(shard[-1] == old_rule for shard in shards[0:3])
# If all shards are above or equal optimum, add to the one with the smallest
# difference
old_rule = bazel_sharding.BazelRule("mock", "large")
shards: List[List[bazel_sharding.BazelRule]] = [[old_rule] for _ in range(4)]
optimum = old_rule.actual_timeout_s
old_rule_medium = bazel_sharding.BazelRule("mock", "medium")
shards[3][0] = old_rule_medium
rule = bazel_sharding.BazelRule("mock", "small")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[3][0] == old_rule_medium
assert shards[3][-1] == rule
assert all(shard[-1] == old_rule for shard in shards[0:3])
| Test that the best shard in optimal strategy is chosen correctly. | 11 | 151 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_add_rule_to_best_shard():
# If we start with an empty list, then add to first shard
shards: List[List[bazel_sharding.BazelRule]] = [list() for _ in range(4)]
optimum = 600
rule = bazel_sharding.BazelRule("mock", "medium")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[0][0] == rule
assert all(not shard for shard in shards[1:])
# Add to first shard below optimum
old_rule = bazel_sharding.BazelRule("mock", "medium")
shards: List[List[bazel_sharding.BazelRule]] = [[old_rule] for _ in range(4)]
shards[3] = []
optimum = old_rule.actual_timeout_s
rule = bazel_sharding.BazelRule("mock", "small")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[3][0] == rule
assert all(shard[-1] == old_rule for shard in shards[0:3])
# If all shards are above or equal optimum, add to the one with the smallest
# difference
old_rule = bazel_sharding.BazelRule("mock", "large")
shards: List[List[bazel_sharding.BazelRule]] = [[old_rule] for _ in range(4)]
optimum = old_rule.actual_timeout_s
old_rule_medium = bazel_sharding.BazelRule("mock", "medium")
shards[3][0] = old_rule_medium
rule = bazel_sharding.BazelRule("mock", "small")
bazel_sharding.add_rule_to_best_shard(rule, shards, optimum)
assert shards[3][0] == old_rule_medium
assert shards[3][-1] == rule
assert all(shard[-1] == old_rule for shard in shards[0:3])
```
###Assistant : Test that the best shard in optimal strategy is chosen correctly.
|
60 | def async_heartbeat(self) -> None:
self._computed_state = False
self._restart_timer()
self.async_write_ha_state()
| Mark the device as online, and restart the 25 hour timer.
This gets called when the heartbeat node beats, but also when the
parent sensor sends any events, as we can trust that to mean the device
is online. This mitigates the risk of false positives due to a single
missed heartbeat event.
| 53 | 9 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def async_heartbeat(self) -> None:
self._computed_state = False
self._restart_timer()
self.async_write_ha_state()
```
###Assistant : Mark the device as online, and restart the 25 hour timer.
This gets called when the heartbeat node beats, but also when the
parent sensor sends any events, as we can trust that to mean the device
is online. This mitigates the risk of false positives due to a single
missed heartbeat event.
|
61 | def test_assert_series_equal_interval_dtype_mismatch():
# https://github.com/pandas-dev/pandas/issues/32747
left = Series([pd.Interval(0, 1, "right")], dtype="interval")
right = left.astype(object)
msg =
tm.assert_series_equal(left, right, check_dtype=False)
with pytest.raises(AssertionError, match=msg):
tm.assert_series_equal(left, right, check_dtype=True)
| Attributes of Series are different
Attribute "dtype" are different
\\[left\\]: interval\\[int64, right\\]
\\[right\\]: object | 14 | 24 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_assert_series_equal_interval_dtype_mismatch():
# https://github.com/pandas-dev/pandas/issues/32747
left = Series([pd.Interval(0, 1, "right")], dtype="interval")
right = left.astype(object)
msg =
tm.assert_series_equal(left, right, check_dtype=False)
with pytest.raises(AssertionError, match=msg):
tm.assert_series_equal(left, right, check_dtype=True)
```
###Assistant : Attributes of Series are different
Attribute "dtype" are different
\\[left\\]: interval\\[int64, right\\]
\\[right\\]: object
|
62 | def rc_file_defaults():
# Deprecation warnings were already handled when creating rcParamsOrig, no
# need to reemit them here.
with _api.suppress_matplotlib_deprecation_warning():
from .style.core import STYLE_BLACKLIST
rcParams.update({k: rcParamsOrig[k] for k in rcParamsOrig
if k not in STYLE_BLACKLIST})
|
Restore the `.rcParams` from the original rc file loaded by Matplotlib.
Style-blacklisted `.rcParams` (defined in
``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
| 19 | 35 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def rc_file_defaults():
# Deprecation warnings were already handled when creating rcParamsOrig, no
# need to reemit them here.
with _api.suppress_matplotlib_deprecation_warning():
from .style.core import STYLE_BLACKLIST
rcParams.update({k: rcParamsOrig[k] for k in rcParamsOrig
if k not in STYLE_BLACKLIST})
```
###Assistant :
Restore the `.rcParams` from the original rc file loaded by Matplotlib.
Style-blacklisted `.rcParams` (defined in
``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
|
63 | def lexer(self) -> Optional[Lexer]:
if isinstance(self._lexer, Lexer):
return self._lexer
try:
return get_lexer_by_name(
self._lexer,
stripnl=False,
ensurenl=True,
tabsize=self.tab_size,
)
except ClassNotFound:
return None
| The lexer for this syntax, or None if no lexer was found.
Tries to find the lexer by name if a string was passed to the constructor.
| 27 | 21 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def lexer(self) -> Optional[Lexer]:
if isinstance(self._lexer, Lexer):
return self._lexer
try:
return get_lexer_by_name(
self._lexer,
stripnl=False,
ensurenl=True,
tabsize=self.tab_size,
)
except ClassNotFound:
return None
```
###Assistant : The lexer for this syntax, or None if no lexer was found.
Tries to find the lexer by name if a string was passed to the constructor.
|
64 | def test_numeric_repl(file, multiline_file):
file.replace(multiline_file, r"Etiam", 123)
assert "123" in multiline_file.read_text()
|
This test covers cases where the replacement string is numeric. The CLI
parser yaml-fies it into a numeric type. If not converted back to a string
type in file.replace, a TypeError occurs when the replace is attempted. See
https://github.com/saltstack/salt/issues/9097 for more information.
| 42 | 10 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_numeric_repl(file, multiline_file):
file.replace(multiline_file, r"Etiam", 123)
assert "123" in multiline_file.read_text()
```
###Assistant :
This test covers cases where the replacement string is numeric. The CLI
parser yaml-fies it into a numeric type. If not converted back to a string
type in file.replace, a TypeError occurs when the replace is attempted. See
https://github.com/saltstack/salt/issues/9097 for more information.
|
65 | def set_interpret_parameters(self, segments=16):
self.interpretation_segments = segments
return self
|
Calculates interpretation score of image subsections by splitting the image into subsections, then using a "leave one out" method to calculate the score of each subsection by whiting out the subsection and measuring the delta of the output value.
Parameters:
segments (int): Number of interpretation segments to split image into.
| 50 | 8 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def set_interpret_parameters(self, segments=16):
self.interpretation_segments = segments
return self
```
###Assistant :
Calculates interpretation score of image subsections by splitting the image into subsections, then using a "leave one out" method to calculate the score of each subsection by whiting out the subsection and measuring the delta of the output value.
Parameters:
segments (int): Number of interpretation segments to split image into.
|
66 | def can_native_upsert(self) -> bool:
return sqlite3.sqlite_version_info >= (3, 24, 0)
|
Do we support native UPSERTs? This requires SQLite3 3.24+, plus some
more work we haven't done yet to tell what was inserted vs updated.
| 24 | 10 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def can_native_upsert(self) -> bool:
return sqlite3.sqlite_version_info >= (3, 24, 0)
```
###Assistant :
Do we support native UPSERTs? This requires SQLite3 3.24+, plus some
more work we haven't done yet to tell what was inserted vs updated.
|
67 | async def get_actors(self) -> dict:
reply = await self._client.get_all_actor_info(timeout=DEFAULT_RPC_TIMEOUT)
result = {}
for message in reply.actor_table_data:
data = self._message_to_dict(message=message, fields_to_decode=["actor_id"])
data = filter_fields(data, ActorState)
result[data["actor_id"]] = data
return result
| List all actor information from the cluster.
Returns:
{actor_id -> actor_data_in_dict}
actor_data_in_dict's schema is in ActorState
| 16 | 29 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
async def get_actors(self) -> dict:
reply = await self._client.get_all_actor_info(timeout=DEFAULT_RPC_TIMEOUT)
result = {}
for message in reply.actor_table_data:
data = self._message_to_dict(message=message, fields_to_decode=["actor_id"])
data = filter_fields(data, ActorState)
result[data["actor_id"]] = data
return result
```
###Assistant : List all actor information from the cluster.
Returns:
{actor_id -> actor_data_in_dict}
actor_data_in_dict's schema is in ActorState
|
68 | def insert_predictor_answer(self, insert):
model_interface = self.session.model_interface
data_store = self.session.data_store
select_data_query = insert.get('select_data_query')
if isinstance(select_data_query, str) is False or len(select_data_query) == 0:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg="'select_data_query' should not be empty"
).send()
return
models = model_interface.get_models()
if insert['name'] in [x['name'] for x in models]:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg=f"predictor with name '{insert['name']}'' already exists"
).send()
return
kwargs = {}
if isinstance(insert.get('training_options'), str) \
and len(insert['training_options']) > 0:
try:
kwargs = json.loads(insert['training_options'])
except Exception:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg='training_options should be in valid JSON string'
).send()
return
integration = self.session.integration
if isinstance(integration, str) is False or len(integration) == 0:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg='select_data_query can be used only in query from database'
).send()
return
insert['select_data_query'] = insert['select_data_query'].replace(r"\'", "'")
ds_name = data_store.get_vacant_name(insert['name'])
ds = data_store.save_datasource(ds_name, integration, {'query': insert['select_data_query']})
insert['predict'] = [x.strip() for x in insert['predict'].split(',')]
ds_data = data_store.get_datasource(ds_name)
if ds_data is None:
raise Exception(f"DataSource '{ds_name}' does not exists")
ds_columns = [x['name'] for x in ds_data['columns']]
for col in insert['predict']:
if col not in ds_columns:
data_store.delete_datasource(ds_name)
raise Exception(f"Column '{col}' not exists")
try:
insert['predict'] = self._check_predict_columns(insert['predict'], ds_columns)
except Exception:
data_store.delete_datasource(ds_name)
raise
model_interface.learn(
insert['name'], ds, insert['predict'], ds_data['id'], kwargs=kwargs, delete_ds_on_fail=True
)
self.packet(OkPacket).send()
| Start learn new predictor.
Parameters:
- insert - dict with keys as columns of mindsb.predictors table.
| 16 | 181 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def insert_predictor_answer(self, insert):
model_interface = self.session.model_interface
data_store = self.session.data_store
select_data_query = insert.get('select_data_query')
if isinstance(select_data_query, str) is False or len(select_data_query) == 0:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg="'select_data_query' should not be empty"
).send()
return
models = model_interface.get_models()
if insert['name'] in [x['name'] for x in models]:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg=f"predictor with name '{insert['name']}'' already exists"
).send()
return
kwargs = {}
if isinstance(insert.get('training_options'), str) \
and len(insert['training_options']) > 0:
try:
kwargs = json.loads(insert['training_options'])
except Exception:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg='training_options should be in valid JSON string'
).send()
return
integration = self.session.integration
if isinstance(integration, str) is False or len(integration) == 0:
self.packet(
ErrPacket,
err_code=ERR.ER_WRONG_ARGUMENTS,
msg='select_data_query can be used only in query from database'
).send()
return
insert['select_data_query'] = insert['select_data_query'].replace(r"\'", "'")
ds_name = data_store.get_vacant_name(insert['name'])
ds = data_store.save_datasource(ds_name, integration, {'query': insert['select_data_query']})
insert['predict'] = [x.strip() for x in insert['predict'].split(',')]
ds_data = data_store.get_datasource(ds_name)
if ds_data is None:
raise Exception(f"DataSource '{ds_name}' does not exists")
ds_columns = [x['name'] for x in ds_data['columns']]
for col in insert['predict']:
if col not in ds_columns:
data_store.delete_datasource(ds_name)
raise Exception(f"Column '{col}' not exists")
try:
insert['predict'] = self._check_predict_columns(insert['predict'], ds_columns)
except Exception:
data_store.delete_datasource(ds_name)
raise
model_interface.learn(
insert['name'], ds, insert['predict'], ds_data['id'], kwargs=kwargs, delete_ds_on_fail=True
)
self.packet(OkPacket).send()
```
###Assistant : Start learn new predictor.
Parameters:
- insert - dict with keys as columns of mindsb.predictors table.
|
69 | def populate_historical_trade_data(self):
trade_data = self.__orderbook.pivot(
index="Date",
columns="Ticker",
values=[
"Type",
"Sector",
"Industry",
"Country",
"Price",
"Quantity",
"Fees",
"Premium",
"Investment",
"Side",
"Currency",
],
)
# Make historical prices columns a multi-index. This helps the merging.
self.portfolio_historical_prices.columns = pd.MultiIndex.from_product(
[["Close"], self.portfolio_historical_prices.columns]
)
# Merge with historical close prices (and fillna)
trade_data = pd.merge(
trade_data,
self.portfolio_historical_prices,
how="right",
left_index=True,
right_index=True,
).fillna(0)
# Accumulate quantity held by trade date
trade_data["Quantity"] = trade_data["Quantity"].cumsum()
trade_data["Investment"] = trade_data["Investment"].cumsum()
trade_data.loc[:, ("Investment", "Total")] = trade_data["Investment"][
self.tickers_list
].sum(axis=1)
self.historical_trade_data = trade_data
| Create a new dataframe to store historical prices by ticker | 10 | 78 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def populate_historical_trade_data(self):
trade_data = self.__orderbook.pivot(
index="Date",
columns="Ticker",
values=[
"Type",
"Sector",
"Industry",
"Country",
"Price",
"Quantity",
"Fees",
"Premium",
"Investment",
"Side",
"Currency",
],
)
# Make historical prices columns a multi-index. This helps the merging.
self.portfolio_historical_prices.columns = pd.MultiIndex.from_product(
[["Close"], self.portfolio_historical_prices.columns]
)
# Merge with historical close prices (and fillna)
trade_data = pd.merge(
trade_data,
self.portfolio_historical_prices,
how="right",
left_index=True,
right_index=True,
).fillna(0)
# Accumulate quantity held by trade date
trade_data["Quantity"] = trade_data["Quantity"].cumsum()
trade_data["Investment"] = trade_data["Investment"].cumsum()
trade_data.loc[:, ("Investment", "Total")] = trade_data["Investment"][
self.tickers_list
].sum(axis=1)
self.historical_trade_data = trade_data
```
###Assistant : Create a new dataframe to store historical prices by ticker
|
70 | def test_fetch_openml_equivalence_array_dataframe(monkeypatch, parser):
pytest.importorskip("pandas")
data_id = 61
_monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
bunch_as_frame_true = fetch_openml(
data_id=data_id,
as_frame=True,
cache=False,
parser=parser,
)
bunch_as_frame_false = fetch_openml(
data_id=data_id,
as_frame=False,
cache=False,
parser=parser,
)
assert_allclose(bunch_as_frame_false.data, bunch_as_frame_true.data)
assert_array_equal(bunch_as_frame_false.target, bunch_as_frame_true.target)
# Known failure of PyPy for OpenML. See the following issue:
# https://github.com/scikit-learn/scikit-learn/issues/18906
@fails_if_pypy
@pytest.mark.parametrize("parser", ["liac-arff", "pandas"]) | Check the equivalence of the dataset when using `as_frame=False` and
`as_frame=True`.
| 11 | 47 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def test_fetch_openml_equivalence_array_dataframe(monkeypatch, parser):
pytest.importorskip("pandas")
data_id = 61
_monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
bunch_as_frame_true = fetch_openml(
data_id=data_id,
as_frame=True,
cache=False,
parser=parser,
)
bunch_as_frame_false = fetch_openml(
data_id=data_id,
as_frame=False,
cache=False,
parser=parser,
)
assert_allclose(bunch_as_frame_false.data, bunch_as_frame_true.data)
assert_array_equal(bunch_as_frame_false.target, bunch_as_frame_true.target)
# Known failure of PyPy for OpenML. See the following issue:
# https://github.com/scikit-learn/scikit-learn/issues/18906
@fails_if_pypy
@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
```
###Assistant : Check the equivalence of the dataset when using `as_frame=False` and
`as_frame=True`.
|
71 | def wire_type(self):
if hasattr(self, '_m_wire_type'):
return self._m_wire_type
self._m_wire_type = KaitaiStream.resolve_enum(GoogleProtobuf.Pair.WireTypes, (self.key.value & 7))
return getattr(self, '_m_wire_type', None)
| "Wire type" is a part of the "key" that carries enough
information to parse value from the wire, i.e. read correct
amount of bytes, but there's not enough informaton to
interprete in unambiguously. For example, one can't clearly
distinguish 64-bit fixed-sized integers from 64-bit floats,
signed zigzag-encoded varints from regular unsigned varints,
arbitrary bytes from UTF-8 encoded strings, etc.
| 59 | 17 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def wire_type(self):
if hasattr(self, '_m_wire_type'):
return self._m_wire_type
self._m_wire_type = KaitaiStream.resolve_enum(GoogleProtobuf.Pair.WireTypes, (self.key.value & 7))
return getattr(self, '_m_wire_type', None)
```
###Assistant : "Wire type" is a part of the "key" that carries enough
information to parse value from the wire, i.e. read correct
amount of bytes, but there's not enough informaton to
interprete in unambiguously. For example, one can't clearly
distinguish 64-bit fixed-sized integers from 64-bit floats,
signed zigzag-encoded varints from regular unsigned varints,
arbitrary bytes from UTF-8 encoded strings, etc.
|
72 | def address(self): # pragma: no cover
warnings.warn(
"Client.address is deprecated, use Client.peername instead.",
DeprecationWarning,
stacklevel=2,
)
return self.peername
| *Deprecated:* An outdated alias for Client.peername. | 6 | 18 | Python |
###User : Below is a Python method which does a task. Create a documentation for the below code :
```Python
def address(self): # pragma: no cover
warnings.warn(
"Client.address is deprecated, use Client.peername instead.",
DeprecationWarning,
stacklevel=2,
)
return self.peername
```
###Assistant : *Deprecated:* An outdated alias for Client.peername.
|
End of preview. Expand
in Dataset Viewer.
Dataset Card for Dataset Name
This dataset card aims to be a base template for creating python docs from methods. This is formatted from semeru/code-code-galeras-code-completion-from-docstring-3k-deduped
Dataset Description
- Curated by: semeru/code-code-galeras-code-completion-from-docstring-3k-deduped
- Language(s) (NLP): Python
- License: [More Information Needed]
Dataset Sources [optional]
- Repository: semeru/code-code-galeras-code-completion-from-docstring-3k-deduped
Uses
(use however you like)
Dataset Structure
Code - Method Doc - Documentation for the method Lang - Language Prompt - Prompt field for training
- Downloads last month
- 0