_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q270900 | SecurityLevel | test | def SecurityLevel():
"""
Generates a filter chain for validating a security level.
"""
return (
f.Type(int) |
f.Min(1) |
f.Max(3) |
f.Optional(default=AddressGenerator.DEFAULT_SECURITY_LEVEL)
) | python | {
"resource": ""
} |
q270901 | ProposedTransaction.increment_legacy_tag | test | def increment_legacy_tag(self):
"""
Increments the transaction's legacy tag, used to fix insecure
bundle hashes when finalizing a bundle.
References:
- https://github.com/iotaledger/iota.lib.py/issues/84
"""
self._legacy_tag = (
Tag.from_trits(add_tr... | python | {
"resource": ""
} |
q270902 | ProposedBundle.tag | test | def tag(self):
# type: () -> Tag
"""
Determines the most relevant tag for the bundle.
"""
for txn in reversed(self): # type: ProposedTransaction
if txn.tag:
return txn.tag
return Tag(b'') | python | {
"resource": ""
} |
q270903 | ProposedBundle.add_transaction | test | def add_transaction(self, transaction):
# type: (ProposedTransaction) -> None
"""
Adds a transaction to the bundle.
If the transaction message is too long, it will be split
automatically into multiple transactions.
"""
if self.hash:
raise RuntimeError... | python | {
"resource": ""
} |
q270904 | ProposedBundle.finalize | test | def finalize(self):
# type: () -> None
"""
Finalizes the bundle, preparing it to be attached to the Tangle.
"""
if self.hash:
raise RuntimeError('Bundle is already finalized.')
if not self:
raise ValueError('Bundle has no transactions.')
... | python | {
"resource": ""
} |
q270905 | ProposedBundle.sign_inputs | test | def sign_inputs(self, key_generator):
# type: (KeyGenerator) -> None
"""
Sign inputs in a finalized bundle.
"""
if not self.hash:
raise RuntimeError('Cannot sign inputs until bundle is finalized.')
# Use a counter for the loop so that we can skip ahead as we ... | python | {
"resource": ""
} |
q270906 | ProposedBundle.sign_input_at | test | def sign_input_at(self, start_index, private_key):
# type: (int, PrivateKey) -> None
"""
Signs the input at the specified index.
:param start_index:
The index of the first input transaction.
If necessary, the resulting signature will be split across
... | python | {
"resource": ""
} |
q270907 | ProposedBundle._create_input_transactions | test | def _create_input_transactions(self, addy):
# type: (Address) -> None
"""
Creates transactions for the specified input address.
"""
self._transactions.append(ProposedTransaction(
address=addy,
tag=self.tag,
# Spend the entire address balance; ... | python | {
"resource": ""
} |
q270908 | convert_value_to_standard_unit | test | def convert_value_to_standard_unit(value, symbol='i'):
# type: (Text, Text) -> float
"""
Converts between any two standard units of iota.
:param value:
Value (affixed) to convert. For example: '1.618 Mi'.
:param symbol:
Unit symbol of iota to convert to. For example: 'Gi'.
:re... | python | {
"resource": ""
} |
q270909 | decompress_G1 | test | def decompress_G1(z: G1Compressed) -> G1Uncompressed:
"""
Recovers x and y coordinates from the compressed point.
"""
# b_flag == 1 indicates the infinity point
b_flag = (z % POW_2_383) // POW_2_382
if b_flag == 1:
return Z1
x = z % POW_2_381
# Try solving y coordinate from the ... | python | {
"resource": ""
} |
q270910 | prime_field_inv | test | def prime_field_inv(a: int, n: int) -> int:
"""
Extended euclidean algorithm to find modular inverses for integers
"""
if a == 0:
return 0
lm, hm = 1, 0
low, high = a % n, n
while low > 1:
r = high // low
nm, new = hm - lm * r, high - low * r
lm, low, hm, high... | python | {
"resource": ""
} |
q270911 | Lexicon.from_json_file | test | def from_json_file(cls, filename):
"""
Load a lexicon from a JSON file.
Args:
filename (str): The path to a JSON dump.
"""
with open(filename, 'r') as fp:
return cls(json.load(fp)) | python | {
"resource": ""
} |
q270912 | Lexicon.find_word_groups | test | def find_word_groups(self, text, category, proximity=2):
"""
Given a string and a category, finds and combines words into
groups based on their proximity.
Args:
text (str): Some text.
tokens (list): A list of regex strings.
Returns:
list. The... | python | {
"resource": ""
} |
q270913 | Lexicon.find_synonym | test | def find_synonym(self, word):
"""
Given a string and a dict of synonyms, returns the 'preferred'
word. Case insensitive.
Args:
word (str): A word.
Returns:
str: The preferred word, or the input word if not found.
Example:
>>> syn = {... | python | {
"resource": ""
} |
q270914 | Lexicon.expand_abbreviations | test | def expand_abbreviations(self, text):
"""
Parse a piece of text and replace any abbreviations with their full
word equivalents. Uses the lexicon.abbreviations dictionary to find
abbreviations.
Args:
text (str): The text to parse.
Returns:
str: Th... | python | {
"resource": ""
} |
q270915 | Lexicon.split_description | test | def split_description(self, text):
"""
Split a description into parts, each of which can be turned into
a single component.
"""
# Protect some special sequences.
t = re.sub(r'(\d) ?in\. ', r'\1 inch ', text) # Protect.
t = re.sub(r'(\d) ?ft\. ', r'\1 feet ', t) ... | python | {
"resource": ""
} |
q270916 | Lexicon.categories | test | def categories(self):
"""
Lists the categories in the lexicon, except the
optional categories.
Returns:
list: A list of strings of category names.
"""
keys = [k for k in self.__dict__.keys() if k not in SPECIAL]
return keys | python | {
"resource": ""
} |
q270917 | Decor.random | test | def random(cls, component):
"""
Returns a minimal Decor with a random colour.
"""
colour = random.sample([i for i in range(256)], 3)
return cls({'colour': colour, 'component': component, 'width': 1.0}) | python | {
"resource": ""
} |
q270918 | Decor.plot | test | def plot(self, fmt=None, fig=None, ax=None):
"""
Make a simple plot of the Decor.
Args:
fmt (str): A Python format string for the component summaries.
fig (Pyplot figure): A figure, optional. Use either fig or ax, not
both.
ax (Pyplot axis): A... | python | {
"resource": ""
} |
q270919 | Legend.builtin | test | def builtin(cls, name):
"""
Generate a default legend.
Args:
name (str): The name of the legend you want. Not case sensitive.
'nsdoe': Nova Scotia Dept. of Energy
'canstrat': Canstrat
'nagmdm__6_2': USGS N. Am. Geol. Map Data Model ... | python | {
"resource": ""
} |
q270920 | Legend.builtin_timescale | test | def builtin_timescale(cls, name):
"""
Generate a default timescale legend. No arguments.
Returns:
Legend: The timescale stored in `defaults.py`.
"""
names = {
'isc': TIMESCALE__ISC,
'usgs_isc': TIMESCALE__USGS_ISC,
'... | python | {
"resource": ""
} |
q270921 | Legend.random | test | def random(cls, components, width=False, colour=None):
"""
Generate a random legend for a given list of components.
Args:
components (list or Striplog): A list of components. If you pass
a Striplog, it will use the primary components. If you pass a
co... | python | {
"resource": ""
} |
q270922 | Legend.from_image | test | def from_image(cls, filename, components,
ignore=None,
col_offset=0.1,
row_offset=2):
"""
A slightly easier way to make legends from images.
Args:
filename (str)
components (list)
ignore (list): Colours... | python | {
"resource": ""
} |
q270923 | Legend.from_csv | test | def from_csv(cls, filename=None, text=None):
"""
Read CSV text and generate a Legend.
Args:
string (str): The CSV string.
In the first row, list the properties. Precede the properties of the
component with 'comp ' or 'component '. For example:
colour, widt... | python | {
"resource": ""
} |
q270924 | Legend.to_csv | test | def to_csv(self):
"""
Renders a legend as a CSV string.
No arguments.
Returns:
str: The legend as a CSV.
"""
# We can't delegate this to Decor because we need to know the superset
# of all Decor properties. There may be lots of blanks.
header... | python | {
"resource": ""
} |
q270925 | Legend.max_width | test | def max_width(self):
"""
The maximum width of all the Decors in the Legend. This is needed
to scale a Legend or Striplog when plotting with widths turned on.
"""
try:
maximum = max([row.width for row in self.__list if row.width is not None])
return maximum... | python | {
"resource": ""
} |
q270926 | Legend.get_decor | test | def get_decor(self, c, match_only=None):
"""
Get the decor for a component.
Args:
c (component): The component to look up.
match_only (list of str): The component attributes to include in the
comparison. Default: All of them.
Returns:
Dec... | python | {
"resource": ""
} |
q270927 | Legend.getattr | test | def getattr(self, c, attr, default=None, match_only=None):
"""
Get the attribute of a component.
Args:
c (component): The component to look up.
attr (str): The attribute to get.
default (str): What to return in the event of no match.
match_only (list ... | python | {
"resource": ""
} |
q270928 | Legend.get_component | test | def get_component(self, colour, tolerance=0, default=None):
"""
Get the component corresponding to a display colour. This is for
generating a Striplog object from a colour image of a striplog.
Args:
colour (str): The hex colour string to look up.
tolerance (float):... | python | {
"resource": ""
} |
q270929 | Legend.plot | test | def plot(self, fmt=None):
"""
Make a simple plot of the legend.
Simply calls Decor.plot() on all of its members.
TODO: Build a more attractive plot.
"""
for d in self.__list:
d.plot(fmt=fmt)
return None | python | {
"resource": ""
} |
q270930 | Component.from_text | test | def from_text(cls, text, lexicon, required=None, first_only=True):
"""
Generate a Component from a text string, using a Lexicon.
Args:
text (str): The text string to parse.
lexicon (Lexicon): The dictionary to use for the
categories and lexemes.
... | python | {
"resource": ""
} |
q270931 | Component.summary | test | def summary(self, fmt=None, initial=True, default=''):
"""
Given a format string, return a summary description of a component.
Args:
component (dict): A component dictionary.
fmt (str): Describes the format with a string. If no format is
given, you will j... | python | {
"resource": ""
} |
q270932 | Rock | test | def Rock(*args, **kwargs):
"""
Graceful deprecation for old class name.
"""
with warnings.catch_warnings():
warnings.simplefilter("always")
w = "The 'Rock' class was renamed 'Component'. "
w += "Please update your code."
warnings.warn(w, DeprecationWarning, stacklevel=2)... | python | {
"resource": ""
} |
q270933 | _process_row | test | def _process_row(text, columns):
"""
Processes a single row from the file.
"""
if not text:
return
# Construct the column dictionary that maps each field to
# its start, its length, and its read and write functions.
coldict = {k: {'start': s,
'len': l,
... | python | {
"resource": ""
} |
q270934 | parse_canstrat | test | def parse_canstrat(text):
"""
Read all the rows and return a dict of the results.
"""
result = {}
for row in text.split('\n'):
if not row:
continue
if len(row) < 8: # Not a real record.
continue
# Read the metadata for this row/
row_header =... | python | {
"resource": ""
} |
q270935 | Striplog.__strict | test | def __strict(self):
"""
Private method. Checks if striplog is monotonically increasing in
depth.
Returns:
Bool.
"""
def conc(a, b):
return a + b
# Check boundaries, b
b = np.array(reduce(conc, [[i.top.z, i.base.z] for i in self]))... | python | {
"resource": ""
} |
q270936 | Striplog.unique | test | def unique(self):
"""
Property. Summarize a Striplog with some statistics.
Returns:
List. A list of (Component, total thickness thickness) tuples.
"""
all_rx = set([iv.primary for iv in self])
table = {r: 0 for r in all_rx}
for iv in self:
... | python | {
"resource": ""
} |
q270937 | Striplog.__intervals_from_tops | test | def __intervals_from_tops(self,
tops,
values,
basis,
components,
field=None,
ignore_nan=True):
"""
Private method. Take a se... | python | {
"resource": ""
} |
q270938 | Striplog._clean_longitudinal_data | test | def _clean_longitudinal_data(cls, data, null=None):
"""
Private function. Make sure we have what we need to make a striplog.
"""
# Rename 'depth' or 'MD'
if ('top' not in data.keys()):
data['top'] = data.pop('depth', data.pop('MD', None))
# Sort everything
... | python | {
"resource": ""
} |
q270939 | Striplog.from_petrel | test | def from_petrel(cls, filename,
stop=None,
points=False,
null=None,
function=None,
include=None,
exclude=None,
remap=None,
ignore=None):
"""
Mak... | python | {
"resource": ""
} |
q270940 | Striplog._build_list_of_Intervals | test | def _build_list_of_Intervals(cls,
data_dict,
stop=None,
points=False,
include=None,
exclude=None,
ignore=None,
... | python | {
"resource": ""
} |
q270941 | Striplog.from_csv | test | def from_csv(cls, filename=None,
text=None,
dlm=',',
lexicon=None,
points=False,
include=None,
exclude=None,
remap=None,
function=None,
null=None,
ign... | python | {
"resource": ""
} |
q270942 | Striplog.from_image | test | def from_image(cls, filename, start, stop, legend,
source="Image",
col_offset=0.1,
row_offset=2,
tolerance=0):
"""
Read an image and generate Striplog.
Args:
filename (str): An image file, preferably high-re... | python | {
"resource": ""
} |
q270943 | Striplog.from_log | test | def from_log(cls, log,
cutoff=None,
components=None,
legend=None,
legend_field=None,
field=None,
right=False,
basis=None,
source='Log'):
"""
Turn a 1D array into a stri... | python | {
"resource": ""
} |
q270944 | Striplog.from_las3 | test | def from_las3(cls, string, lexicon=None,
source="LAS",
dlm=',',
abbreviations=False):
"""
Turn LAS3 'lithology' section into a Striplog.
Args:
string (str): A section from an LAS3 file.
lexicon (Lexicon): The language... | python | {
"resource": ""
} |
q270945 | Striplog.from_canstrat | test | def from_canstrat(cls, filename, source='canstrat'):
"""
Eat a Canstrat DAT file and make a striplog.
"""
with open(filename) as f:
dat = f.read()
data = parse_canstrat(dat)
list_of_Intervals = []
for d in data[7]: # 7 is the 'card type' for litholo... | python | {
"resource": ""
} |
q270946 | Striplog.copy | test | def copy(self):
"""Returns a shallow copy."""
return Striplog([i.copy() for i in self],
order=self.order,
source=self.source) | python | {
"resource": ""
} |
q270947 | Striplog.to_csv | test | def to_csv(self,
filename=None,
as_text=True,
use_descriptions=False,
dlm=",",
header=True):
"""
Returns a CSV string built from the summaries of the Intervals.
Args:
use_descriptions (bool): Whether to use d... | python | {
"resource": ""
} |
q270948 | Striplog.to_las3 | test | def to_las3(self, use_descriptions=False, dlm=",", source="Striplog"):
"""
Returns an LAS 3.0 section string.
Args:
use_descriptions (bool): Whether to use descriptions instead
of summaries, if available.
dlm (str): The delimiter.
source (str)... | python | {
"resource": ""
} |
q270949 | Striplog.plot_axis | test | def plot_axis(self,
ax,
legend,
ladder=False,
default_width=1,
match_only=None,
colour=None,
colour_function=None,
cmap=None,
default=None,
... | python | {
"resource": ""
} |
q270950 | Striplog.get_data | test | def get_data(self, field, function=None, default=None):
"""
Get data from the striplog.
"""
f = function or utils.null
data = []
for iv in self:
d = iv.data.get(field)
if d is None:
if default is not None:
d = de... | python | {
"resource": ""
} |
q270951 | Striplog.extract | test | def extract(self, log, basis, name, function=None):
"""
'Extract' a log into the components of a striplog.
Args:
log (array_like). A log or other 1D data.
basis (array_like). The depths or elevations of the log samples.
name (str). The name of the attribute t... | python | {
"resource": ""
} |
q270952 | Striplog.find | test | def find(self, search_term, index=False):
"""
Look for a regex expression in the descriptions of the striplog.
If there's no description, it looks in the summaries.
If you pass a Component, then it will search the components, not the
descriptions or summaries.
Case inse... | python | {
"resource": ""
} |
q270953 | Striplog.find_overlaps | test | def find_overlaps(self, index=False):
"""
Find overlaps in a striplog.
Args:
index (bool): If True, returns indices of intervals with
gaps after them.
Returns:
Striplog: A striplog of all the overlaps as intervals.
"""
return self.__f... | python | {
"resource": ""
} |
q270954 | Striplog.find_gaps | test | def find_gaps(self, index=False):
"""
Finds gaps in a striplog.
Args:
index (bool): If True, returns indices of intervals with
gaps after them.
Returns:
Striplog: A striplog of all the gaps. A sort of anti-striplog.
"""
return self.__... | python | {
"resource": ""
} |
q270955 | Striplog.prune | test | def prune(self, limit=None, n=None, percentile=None, keep_ends=False):
"""
Remove intervals below a certain limit thickness. In place.
Args:
limit (float): Anything thinner than this will be pruned.
n (int): The n thinnest beds will be pruned.
percentile (flo... | python | {
"resource": ""
} |
q270956 | Striplog.anneal | test | def anneal(self):
"""
Fill in empty intervals by growing from top and base.
Note that this operation happens in-place and destroys any information
about the ``Position`` (e.g. metadata associated with the top or base).
See GitHub issue #54.
"""
strip = self.copy(... | python | {
"resource": ""
} |
q270957 | Striplog.fill | test | def fill(self, component=None):
"""
Fill gaps with the component provided.
Example
t = s.fill(Component({'lithology': 'cheese'}))
"""
c = [component] if component is not None else []
# Make the intervals to go in the gaps.
gaps = self.find_gaps()
... | python | {
"resource": ""
} |
q270958 | Striplog.union | test | def union(self, other):
"""
Makes a striplog of all unions.
Args:
Striplog. The striplog instance to union with.
Returns:
Striplog. The result of the union.
"""
if not isinstance(other, self.__class__):
m = "You can only union striplo... | python | {
"resource": ""
} |
q270959 | Striplog.intersect | test | def intersect(self, other):
"""
Makes a striplog of all intersections.
Args:
Striplog. The striplog instance to intersect with.
Returns:
Striplog. The result of the intersection.
"""
if not isinstance(other, self.__class__):
m = "You ... | python | {
"resource": ""
} |
q270960 | Striplog.merge_overlaps | test | def merge_overlaps(self):
"""
Merges overlaps by merging overlapping Intervals.
The function takes no arguments and returns ``None``. It operates on
the striplog 'in place'
TODO: This function will not work if any interval overlaps more than
one other intervals at e... | python | {
"resource": ""
} |
q270961 | Striplog.hist | test | def hist(self,
lumping=None,
summary=False,
sort=True,
plot=True,
legend=None,
ax=None
):
"""
Plots a histogram and returns the data for it.
Args:
lumping (str): If given, the bins will be lum... | python | {
"resource": ""
} |
q270962 | Striplog.invert | test | def invert(self, copy=False):
"""
Inverts the striplog, changing its order and the order of its contents.
Operates in place by default.
Args:
copy (bool): Whether to operate in place or make a copy.
Returns:
None if operating in-place, or an inverted co... | python | {
"resource": ""
} |
q270963 | Striplog.crop | test | def crop(self, extent, copy=False):
"""
Crop to a new depth range.
Args:
extent (tuple): The new start and stop depth. Must be 'inside'
existing striplog.
copy (bool): Whether to operate in place or make a copy.
Returns:
Operates in p... | python | {
"resource": ""
} |
q270964 | Striplog.quality | test | def quality(self, tests, alias=None):
"""
Run a series of tests and return the corresponding results.
Based on curve testing for ``welly``.
Args:
tests (list): a list of functions.
Returns:
list. The results. Stick to booleans (True = pass) or ints.
... | python | {
"resource": ""
} |
q270965 | hex_to_name | test | def hex_to_name(hexx):
"""
Convert hex to a color name, using matplotlib's colour names.
Args:
hexx (str): A hexadecimal colour, starting with '#'.
Returns:
str: The name of the colour, or None if not found.
"""
for n, h in defaults.COLOURS.items():
if (len(n) > 1) and ... | python | {
"resource": ""
} |
q270966 | loglike_from_image | test | def loglike_from_image(filename, offset):
"""
Get a log-like stream of RGB values from an image.
Args:
filename (str): The filename of a PNG image.
offset (Number): If < 1, interpreted as proportion of way across
the image. If > 1, interpreted as pixels from left.
Returns:
... | python | {
"resource": ""
} |
q270967 | CustomFormatter.get_field | test | def get_field(self, field_name, args, kwargs):
"""
Return an underscore if the attribute is absent.
Not all components have the same attributes.
"""
try:
s = super(CustomFormatter, self)
return s.get_field(field_name, args, kwargs)
except KeyError:... | python | {
"resource": ""
} |
q270968 | Jobs.get_jobs | test | def get_jobs(self, prefix=None):
""" Lists all the jobs registered with Nomad.
https://www.nomadproject.io/docs/http/jobs.html
arguments:
- prefix :(str) optional, specifies a string to filter jobs on based on an prefix.
This is specified as a querys... | python | {
"resource": ""
} |
q270969 | Jobs.parse | test | def parse(self, hcl, canonicalize=False):
""" Parse a HCL Job file. Returns a dict with the JSON formatted job.
This API endpoint is only supported from Nomad version 0.8.3.
https://www.nomadproject.io/api/jobs.html#parse-job
returns: dict
raises:
... | python | {
"resource": ""
} |
q270970 | Acl.update_token | test | def update_token(self, id, token):
""" Update token.
https://www.nomadproject.io/api/acl-tokens.html
arguments:
- AccdesorID
- token
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- no... | python | {
"resource": ""
} |
q270971 | Allocations.get_allocations | test | def get_allocations(self, prefix=None):
""" Lists all the allocations.
https://www.nomadproject.io/docs/http/allocs.html
arguments:
- prefix :(str) optional, specifies a string to filter allocations on based on an prefix.
This is specified as a query... | python | {
"resource": ""
} |
q270972 | Deployment.fail_deployment | test | def fail_deployment(self, id):
""" This endpoint is used to mark a deployment as failed. This should be done to force the scheduler to stop
creating allocations as part of the deployment or to cause a rollback to a previous job version.
https://www.nomadproject.io/docs/http/deployments.h... | python | {
"resource": ""
} |
q270973 | Deployment.pause_deployment | test | def pause_deployment(self, id, pause):
""" This endpoint is used to pause or unpause a deployment.
This is done to pause a rolling upgrade or resume it.
https://www.nomadproject.io/docs/http/deployments.html
arguments:
- id
- pause, Specifies whet... | python | {
"resource": ""
} |
q270974 | Deployment.deployment_allocation_health | test | def deployment_allocation_health(self, id, healthy_allocations=list(), unhealthy_allocations=list()):
""" This endpoint is used to set the health of an allocation that is in the deployment manually. In some use
cases, automatic detection of allocation health may not be desired. As such those task gr... | python | {
"resource": ""
} |
q270975 | Node.drain_node | test | def drain_node(self, id, enable=False):
""" Toggle the drain mode of the node.
When enabled, no further allocations will be
assigned and existing allocations will be migrated.
https://www.nomadproject.io/docs/http/node.html
arguments:
- id (str uuid... | python | {
"resource": ""
} |
q270976 | Node.drain_node_with_spec | test | def drain_node_with_spec(self, id, drain_spec, mark_eligible=None):
""" This endpoint toggles the drain mode of the node. When draining is enabled,
no further allocations will be assigned to this node, and existing allocations
will be migrated to new nodes.
If an empty dicti... | python | {
"resource": ""
} |
q270977 | Node.eligible_node | test | def eligible_node(self, id, eligible=None, ineligible=None):
""" Toggle the eligibility of the node.
https://www.nomadproject.io/docs/http/node.html
arguments:
- id (str uuid): node id
- eligible (bool): Set to True to mark node eligible
- ineli... | python | {
"resource": ""
} |
q270978 | ls.list_files | test | def list_files(self, id=None, path="/"):
""" List files in an allocation directory.
https://www.nomadproject.io/docs/http/client-fs-ls.html
arguments:
- id
- path
returns: list
raises:
- nomad.api.exceptions.Bas... | python | {
"resource": ""
} |
q270979 | stream_file.stream | test | def stream(self, id, offset, origin, path="/"):
""" This endpoint streams the contents of a file in an allocation directory.
https://www.nomadproject.io/api/client.html#stream-file
arguments:
- id: (str) allocation_id required
- offset: (int) required
... | python | {
"resource": ""
} |
q270980 | stat.stat_file | test | def stat_file(self, id=None, path="/"):
""" Stat a file in an allocation directory.
https://www.nomadproject.io/docs/http/client-fs-stat.html
arguments:
- id
- path
returns: dict
raises:
- nomad.api.exceptions.BaseNomadEx... | python | {
"resource": ""
} |
q270981 | Agent.join_agent | test | def join_agent(self, addresses):
"""Initiate a join between the agent and target peers.
https://www.nomadproject.io/docs/http/agent-join.html
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadEx... | python | {
"resource": ""
} |
q270982 | Agent.update_servers | test | def update_servers(self, addresses):
"""Updates the list of known servers to the provided list.
Replaces all previous server addresses with the new list.
https://www.nomadproject.io/docs/http/agent-servers.html
returns: 200 status code
raises:
- noma... | python | {
"resource": ""
} |
q270983 | Agent.force_leave | test | def force_leave(self, node):
"""Force a failed gossip member into the left state.
https://www.nomadproject.io/docs/http/agent-force-leave.html
returns: 200 status code
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNo... | python | {
"resource": ""
} |
q270984 | Nodes.get_nodes | test | def get_nodes(self, prefix=None):
""" Lists all the client nodes registered with Nomad.
https://www.nomadproject.io/docs/http/nodes.html
arguments:
- prefix :(str) optional, specifies a string to filter nodes on based on an prefix.
This is specified ... | python | {
"resource": ""
} |
q270985 | Evaluations.get_evaluations | test | def get_evaluations(self, prefix=None):
""" Lists all the evaluations.
https://www.nomadproject.io/docs/http/evals.html
arguments:
- prefix :(str) optional, specifies a string to filter evaluations on based on an prefix.
This is specified as a querys... | python | {
"resource": ""
} |
q270986 | Namespaces.get_namespaces | test | def get_namespaces(self, prefix=None):
""" Lists all the namespaces registered with Nomad.
https://www.nomadproject.io/docs/enterprise/namespaces/index.html
arguments:
- prefix :(str) optional, specifies a string to filter namespaces on based on an prefix.
... | python | {
"resource": ""
} |
q270987 | Job.register_job | test | def register_job(self, id, job):
""" Registers a new job or updates an existing job
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.ap... | python | {
"resource": ""
} |
q270988 | Job.plan_job | test | def plan_job(self, id, job, diff=False, policy_override=False):
""" Invoke a dry-run of the scheduler for the job.
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
- job, dict
- diff, boolean
- policy_override, boolea... | python | {
"resource": ""
} |
q270989 | Job.dispatch_job | test | def dispatch_job(self, id, payload=None, meta=None):
""" Dispatches a new instance of a parameterized job.
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
- payload
- meta
returns: dict
raises:
... | python | {
"resource": ""
} |
q270990 | Job.revert_job | test | def revert_job(self, id, version, enforce_prior_version=None):
""" This endpoint reverts the job to an older version.
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
- version, Specifies the job version to revert to.
optional_argume... | python | {
"resource": ""
} |
q270991 | Job.stable_job | test | def stable_job(self, id, version, stable):
""" This endpoint sets the job's stability.
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
- version, Specifies the job version to revert to.
- stable, Specifies whether the job should b... | python | {
"resource": ""
} |
q270992 | Job.deregister_job | test | def deregister_job(self, id, purge=None):
""" Deregisters a job, and stops all allocations part of it.
https://www.nomadproject.io/docs/http/job.html
arguments:
- id
- purge (bool), optionally specifies whether the job should be
stopped and pu... | python | {
"resource": ""
} |
q270993 | Operator.get_configuration | test | def get_configuration(self, stale=False):
""" Query the status of a client node registered with Nomad.
https://www.nomadproject.io/docs/http/operator.html
returns: dict
optional arguments:
- stale, (defaults to False), Specifies if the cluster should respond w... | python | {
"resource": ""
} |
q270994 | Operator.delete_peer | test | def delete_peer(self, peer_address, stale=False):
""" Remove the Nomad server with given address from the Raft configuration.
The return code signifies success or failure.
https://www.nomadproject.io/docs/http/operator.html
arguments:
- peer_address, The addre... | python | {
"resource": ""
} |
q270995 | Deployments.get_deployments | test | def get_deployments(self, prefix=""):
""" This endpoint lists all deployments.
https://www.nomadproject.io/docs/http/deployments.html
optional_arguments:
- prefix, (default "") Specifies a string to filter deployments on based on an index prefix.
Th... | python | {
"resource": ""
} |
q270996 | PJFMutators._get_random | test | def _get_random(self, obj_type):
"""
Get a random mutator from a list of mutators
"""
return self.mutator[obj_type][random.randint(0, self.config.level)] | python | {
"resource": ""
} |
q270997 | PJFMutators.get_mutator | test | def get_mutator(self, obj, obj_type):
"""
Get a random mutator for the given type
"""
if obj_type == unicode:
obj_type = str
obj = str(obj)
return self._get_random(obj_type)(obj) | python | {
"resource": ""
} |
q270998 | PJFMutators.get_string_polyglot_attack | test | def get_string_polyglot_attack(self, obj):
"""
Return a polyglot attack containing the original object
"""
return self.polyglot_attacks[random.choice(self.config.techniques)] % obj | python | {
"resource": ""
} |
q270999 | PJFMutators.fuzz | test | def fuzz(self, obj):
"""
Perform the fuzzing
"""
buf = list(obj)
FuzzFactor = random.randrange(1, len(buf))
numwrites=random.randrange(math.ceil((float(len(buf)) / FuzzFactor)))+1
for j in range(numwrites):
self.random_action(buf)
return self.s... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.