code stringlengths 20 4.93k | docstring stringlengths 33 1.27k | source stringclasses 3
values |
|---|---|---|
def _embedding_dim(vocab_size):
if ((not vocab_size) or (vocab_size <= 0)):
raise ValueError(('Invalid vocab_size %g.' % vocab_size))
return int(round((6.0 * math.sqrt(math.sqrt(vocab_size))))) | Calculate a reasonable embedding size for a vocabulary.
Rule of thumb is 6 * 4th root of vocab_size.
Args:
vocab_size: Size of the input vocabulary.
Returns:
The embedding size to use.
Raises:
ValueError: if `vocab_size` is invalid. | codesearchnet |
def mlir_sparsify(input_data_str):
return wrap_converter.wrapped_experimental_mlir_sparsify(input_data_str) | Sparsify `input_data_str` to encode sparse tensor with proper format.
Args:
input_data_str: Input data in serialized form (e.g. a TFLITE model).
Returns:
Sparsified model in serialized form (e.g. a TFLITE model). | github-repos |
def _eager_run_fn(fn: PartFn, part: _T) -> AsyncIterable[_T]:
q = asyncio.Queue[_T | _FinishedT]()
async def call_fn():
async for c in fn(part):
q.put_nowait(c)
q.put_nowait(_Finished)
context.create_task(call_fn())
async def result_iter():
while (c := (await q.get(... | Executes fn on part in an asyncio.task.
Must be called called in an async context. It eagerly schedules a task on
the event loop to execute the whole of `fn` on the part. Results from the
AsyncIterable returned by `fn` can be retrieved via the AsyncIterable returned
by this method.
Args:
fn: the part function to exec... | github-repos |
def trading_dates(start, end, calendar='US'):
kw = dict(start=pd.Timestamp(start, tz='UTC').date(), end=pd.Timestamp(end, tz='UTC').date())
us_cal = getattr(sys.modules[__name__], f'{calendar}TradingCalendar')()
return pd.bdate_range(**kw).drop(us_cal.holidays(**kw)) | Trading dates for given exchange
Args:
start: start date
end: end date
calendar: exchange as string
Returns:
pd.DatetimeIndex: datetime index
Examples:
>>> bus_dates = ['2018-12-24', '2018-12-26', '2018-12-27']
>>> trd_dates = trading_dates(start='2018-12-23', end='2018-12-27')
>>> assert len(trd_dates) == len(bus_d... | juraj-google-style |
def unbroadcast_numpy_to(array, shape):
axis = create_unbroadcast_axis(shape, numpy.shape(array))
return numpy.reshape(numpy.sum(array, axis=axis), shape) | Reverse the broadcasting operation.
Args:
array: An array.
shape: A shape that could have been broadcasted to the shape of array.
Returns:
Array with dimensions summed to match `shape`. | juraj-google-style |
def post(fqdn, package, result, entry, bound, ekey, *argl, **argd):
global _atdepth_call, _cstack_call
_cstack_call.pop()
if (len(_cstack_call) == 0):
_atdepth_call = False
r = _post_call(_atdepth_call, package, fqdn, result, entry, bound, ekey, argl, argd)
return r | Adds logging for the post-call result of calling the method externally.
Args:
fqdn (str): fully-qualified domain name of the function being logged.
package (str): name of the package we are logging for. Usually the first
element of `fqdn.split('.')`.
result: returned from calling the method we are logging.
entry (dict... | codesearchnet |
def earliest_date(dates, full_date=False):
min_date = min(PartialDate.loads(date) for date in dates)
if not min_date.month and full_date:
min_date.month = 1
if not min_date.day and full_date:
min_date.day = 1
return min_date.dumps() | Return the earliest among the schema-compliant dates.
This is a convenience wrapper around :ref:`PartialDate`, which should be
used instead if more features are needed.
Args:
dates(list): List of dates from which oldest/earliest one will be returned
full_date(bool): Adds month and/or day as "01" if they are missing
R... | juraj-google-style |
def get_pattern_step_time(self, patternnumber, stepnumber):
_checkPatternNumber(patternnumber)
_checkStepNumber(stepnumber)
address = _calculateRegisterAddress('time', patternnumber, stepnumber)
return self.read_register(address, 0) | Get the step time.
Args:
* patternnumber (integer): 0-7
* stepnumber (integer): 0-7
Returns:
The step time (int??). | juraj-google-style |
def assemble(cls, header_json, metadata_json, content_json):
try:
header = json_decode(header_json)
except ValueError:
raise MessageError("header could not be decoded")
try:
metadata = json_decode(metadata_json)
except ValueError:
... | Creates a new message, assembled from JSON fragments.
Args:
header_json (``JSON``) :
metadata_json (``JSON``) :
content_json (``JSON``) :
Returns:
Message subclass
Raises:
MessageError | juraj-google-style |
def _remove_squeezable_dimensions(labels, predictions, weights=None, expected_rank_diff=0):
labels, predictions = confusion_matrix.remove_squeezable_dimensions(labels, predictions, expected_rank_diff=expected_rank_diff)
if weights is not None:
weights = ops.convert_to_tensor(weights)
labels_rank... | Internal version of _remove_squeezable_dimensions which handles weights.
Squeezes `predictions` and `labels` if their ranks differ from expected by
exactly 1.
Squeezes `weights` if its rank is 1 more than the new rank of `predictions`
This will use static shape if available. Otherwise, it will add graph
operations, w... | github-repos |
def fleet_id_to_slug(did):
try:
fleet_slug = IOTileFleetSlug(did)
except ValueError:
raise ArgumentError("Unable to recognize {} as a fleet id".format(did))
return str(fleet_slug) | Converts a fleet id into a correct fleet slug.
Args:
did (long) : A fleet id
did (string) : A device slug in the form of XXXX, XXXX-XXXX-XXXX, g--XXXX, g--XXXX-XXXX-XXXX
Returns:
str: The device slug in the g--XXXX-XXXX-XXX format
Raises:
ArgumentError: if the ID is not in the [1, 16**12] range, or if not a valid stri... | juraj-google-style |
def partitions_for_topic(self, topic):
if topic not in self._partitions:
return None
return set(self._partitions[topic].keys()) | Return set of all partitions for topic (whether available or not)
Arguments:
topic (str): topic to check for partitions
Returns:
set: {partition (int), ...} | juraj-google-style |
def _get_fields(mcs, bases, namespace):
fields = [(name, namespace.pop(name)) for (name, attribute) in list(namespace.items()) if isinstance(attribute, BaseField)]
for base in reversed(bases):
if hasattr(base, mcs._fields_storage_key):
fields = (list(getattr(base, mcs._fields_storage_key).it... | Create fields dictionary to be used in resource class namespace.
Pop all field objects from attributes dict (namespace) and store them
under _field_storage_key atrribute. Also collect all fields from base
classes in order that ensures fields can be overriden.
Args:
bases: all base classes of created serializer class
... | codesearchnet |
def _load_chunk(dat_path, cat_path, info_path):
dat_array = read_binary_matrix(dat_path)
dat_array = np.expand_dims(dat_array, (- 1))
cat_array = read_binary_matrix(cat_path)
info_array = read_binary_matrix(info_path)
info_array = np.copy(info_array)
info_array[(:, 2)] = (info_array[(:, 2)] / 2)... | Loads a data chunk as specified by the paths.
Args:
dat_path: Path to dat file of the chunk.
cat_path: Path to cat file of the chunk.
info_path: Path to info file of the chunk.
Returns:
Tuple with the dat, cat, info_arrays. | codesearchnet |
def plogdet(K):
r
egvals = eigvalsh(K)
return npsum(log(egvals[egvals > epsilon])) | r"""Log of the pseudo-determinant.
It assumes that ``K`` is a positive semi-definite matrix.
Args:
K (array_like): matrix.
Returns:
float: log of the pseudo-determinant. | juraj-google-style |
def make_fake_movie(nframes, mask_shape=(64, 64), mask_center=None, bg_intensity=0.1, mask_sigma=10, dt=0.02, rate=1.0, tau=1.0, sigma=0.001, seed=None):
gen = np.random.RandomState(seed)
n = gen.poisson((rate * dt), size=nframes)
gamma = np.exp(((- dt) / tau))
c = signal.lfilter(np.r_[1], np.r_[(1, (- ... | Generate 2D fake fluorescence movie
Arguments:
---------------------------------------------------------------------------
nframes: number of timebins to simulate
mask_shape: tuple (nrows, ncols), shape of a single movie frame
mask_center: tuple (x, y), pixel coords of cell center
bg_intensity: scalar,... | codesearchnet |
def single_slice_dim(self, shape):
if not isinstance(shape, (tuple, list)):
raise TypeError('`shape` must be a sequence (like tuple or list) instead of ' + type(shape).__name__)
if len(shape) != len(self.full_shape):
raise ValueError('Expected equal length, but received shape={} of length {} whi... | Returns the slice dim when the variable is partitioned only in one dim.
Args:
shape: Tuple or list of `int` indicating the shape of one specific
variable partition.
Returns:
`int` representing the dimension that the variable is partitioned in, or
`None` if the variable doesn't seem to be partitioned at all.
Raises:
... | github-repos |
def __setitem__(self, key: Union[str, int], value: Any) -> None:
if not hasattr(self, '_sym_parent'):
return
if base.treats_as_sealed(self):
raise base.WritePermissionError(self._error_message('Cannot modify field of a sealed Dict.'))
if not base.writtable_via_accessors(self):
raise ... | Set item in this Dict.
Args:
key: String key. (Please be noted that key path is not supported.)
value: Value to be inserted.
Raises:
WritePermissionError: when Dict cannot be modified by accessor or
is sealed.
KeyError: Key is not allowed according to the value spec.
ValueError: Value is not acceptable according to t... | github-repos |
def put(self, dash_id=0):
data = request.get_json()
updated = self._update_dash(dash_id, data)
return build_response(dict(data=updated, code=200)) | Update a dash meta and content, return updated dash content.
Args:
dash_id: dashboard id.
Returns:
A dict containing the updated content of that dashboard, not include the meta info. | codesearchnet |
def get_student_current_grades(self, username, course_ids=None):
if (course_ids is None):
enrollments_client = CourseEnrollments(self.requester, self.base_url)
enrollments = enrollments_client.get_student_enrollments()
course_ids = list(enrollments.get_enrolled_course_ids())
all_current_... | Returns a CurrentGradesByUser object with the user current grades.
Args:
username (str): an edx user's username
course_ids (list): a list of edX course ids.
Returns:
CurrentGradesByUser: object representing the student current grades | codesearchnet |
def _construct_location_to_filter_list(match_query):
location_to_filters = {}
for match_traversal in match_query.match_traversals:
for match_step in match_traversal:
current_filter = match_step.where_block
if (current_filter is not None):
current_location = match_... | Return a dict mapping location -> list of filters applied at that location.
Args:
match_query: MatchQuery object from which to extract location -> filters dict
Returns:
dict mapping each location in match_query to a list of
Filter objects applied at that location | codesearchnet |
def remove_all_servers(self):
for server_id in list(self._servers.keys()):
self.remove_server(server_id) | Remove all registered WBEM servers from the subscription manager. This
also unregisters listeners from these servers and removes all owned
indication subscriptions, owned indication filters, and owned listener
destinations.
Raises:
Exceptions raised by :class:`~pywbem.WBEMConnection`. | codesearchnet |
def humanize_time_delta(sec):
if (sec < 0):
logger.warn('humanize_time_delta() obtains negative seconds!')
return '{:.3g} seconds'.format(sec)
if (sec == 0):
return '0 second'
time = (datetime(2000, 1, 1) + timedelta(seconds=int(sec)))
units = ['day', 'hour', 'minute', 'second']
... | Humanize timedelta given in seconds
Args:
sec (float): time difference in seconds. Must be positive.
Returns:
str - time difference as a readable string
Example:
.. code-block:: python
print(humanize_time_delta(1)) # 1 second
print(humanize_time_delta(60 + 1)) ... | codesearchnet |
def delete_nsg_rule(access_token, subscription_id, resource_group, nsg_name, nsg_rule_name):
endpoint = ''.join([get_rm_endpoint(),
'/subscriptions/', subscription_id,
'/resourceGroups/', resource_group,
'/providers/Microsoft.Network/netwo... | Delete network security group rule.
Args:
access_token (str): A valid Azure authentication token.
subscription_id (str): Azure subscription id.
resource_group (str): Azure resource group name.
nsg_name (str): Name of the Network Security Group.
nsg_rule_name (str): Name of the NSG rule.
Returns:
HTTP response. | juraj-google-style |
def help_members(obj, use_other=False):
import utool as ut
attrnames = dir(obj)
attr_list = [getattr(obj, attrname) for attrname in attrnames]
attr_types = ut.lmap(ut.type_str, map(type, attr_list))
(unique_types, groupxs) = ut.group_indices(attr_types)
type_to_items = ut.dzip(unique_types, ut.a... | r"""
Inspects members of a class
Args:
obj (class or module):
CommandLine:
python -m utool.util_inspect help_members
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_inspect import * # NOQA
>>> import utool as ut
>>> obj = ut.DynStruct
>>> result = help_members(obj)
>>> print(result) | codesearchnet |
def is_supergroup(self, subgroup):
warnings.warn("This is not fully functional. Only trivial subsets are "
"tested right now. ")
return set(subgroup.symmetry_ops).issubset(self.symmetry_ops) | True if this group is a supergroup of the supplied group.
Args:
subgroup (SymmetryGroup): Subgroup to test.
Returns:
True if this group is a supergroup of the supplied group. | juraj-google-style |
def description(self, description):
self._data['description'] = description
request = self._base_request
request['description'] = description
return self._tc_requests.update(request, owner=self.owner) | Updates the security labels description.
Args:
description: | codesearchnet |
def _exec_procedure_func(self, func, tr_record):
func_name = func.__name__
procedure_name = func_name[1:] if func_name[0] == '_' else func_name
with self._log_test_stage(procedure_name):
try:
func(copy.deepcopy(tr_record))
except signals.TestAbortSignal:
raise
... | Executes a procedure function like on_pass, on_fail etc.
This function will alter the 'Result' of the test's record if
exceptions happened when executing the procedure function, but
prevents procedure functions from altering test records themselves
by only passing in a copy.
This will let signals.TestAbortAll through... | github-repos |
def solid_named(self, name):
check.str_param(name, 'name')
if (name not in self._solid_dict):
raise DagsterInvariantViolationError('Pipeline {pipeline_name} has no solid named {name}.'.format(pipeline_name=self.name, name=name))
return self._solid_dict[name] | Return the solid named "name". Throws if it does not exist.
Args:
name (str): Name of solid
Returns:
SolidDefinition: SolidDefinition with correct name. | codesearchnet |
def parse_objective_coefficient(entry):
for parameter in entry.kinetic_law_reaction_parameters:
pid, name, value, units = parameter
if (pid == 'OBJECTIVE_COEFFICIENT' or
name == 'OBJECTIVE_COEFFICIENT'):
return value
return None | Return objective value for reaction entry.
Detect objectives that are specified using the non-standardized
kinetic law parameters which are used by many pre-FBC SBML models. The
objective coefficient is returned for the given reaction, or None if
undefined.
Args:
entry: :class:`SBMLReactionEntry`. | juraj-google-style |
def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
converted_len = int(clip_len * frame_sample_rate)
end_idx = np.random.randint(converted_len, seg_len)
start_idx = end_idx - converted_len
indices = np.linspace(start_idx, end_idx, num=clip_len)
indices = np.clip(indices, start_idx, end_... | Sample a given number of frame indices from the video.
Args:
clip_len (`int`): Total number of frames to sample.
frame_sample_rate (`int`): Sample every n-th frame.
seg_len (`int`): Maximum allowed index of sample's last frame.
Returns:
indices (`List[int]`): List of sampled frame indices | github-repos |
def get_plugin(self, identifier, cls=None):
if (((cls is None) or (cls == 'provider')) and (identifier in self.available_providers)):
return self.available_providers[identifier]
elif (((cls is None) or (cls == 'checker')) and (identifier in self.available_checkers)):
return self.available_checke... | Return the plugin corresponding to the given identifier and type.
Args:
identifier (str): identifier of the plugin.
cls (str): one of checker / provider.
Returns:
Checker/Provider: plugin class. | codesearchnet |
def smoothing_cross_entropy_factored(a, b, labels, confidence):
num_splits = 16
vocab_size = shape_list(b)[0]
labels = approximate_split(labels, num_splits)
a = approximate_split(a, num_splits)
parts = []
for part in range(num_splits):
with tf.control_dependencies(parts[-1:]):
logits = tf.matmu... | Memory-efficient computation of smoothing cross-entropy.
Avoids realizing the entire logits matrix at once.
Args:
a: a Tensor with shape [batch, inner_dim]
b: a Tensor with shape [vocab_size, inner_dim]
labels: an integer Tensor with shape [batch]
confidence: a float
Returns:
A Tensor with shape [batch] | juraj-google-style |
def _finalize_func(string_handle):
iterator_resource = gen_dataset_ops.iterator_from_string_handle_v2(string_handle, **self._input_dataset._flat_structure)
with ops.control_dependencies([resource_variable_ops.destroy_resource_op(iterator_resource, ignore_lookup_error=True)]):
return array_ops.constant(0... | Destroys the iterator resource created.
Args:
string_handle: An iterator string handle created by _init_func
Returns:
Tensor constant 0 | github-repos |
def _add_scalar(self, scalar):
encoded = EncodedNumber.encode(self.public_key, scalar,
max_exponent=self.exponent)
return self._add_encoded(encoded) | Returns E(a + b), given self=E(a) and b.
Args:
scalar: an int or float b, to be added to `self`.
Returns:
EncryptedNumber: E(a + b), calculated by encrypting b and
taking the product of E(a) and E(b) modulo
:attr:`~PaillierPublicKey.n` ** 2.
Raises:
ValueError: if scalar is out of range or precision. | juraj-google-style |
def maybe_download_and_extract_dataset(self, data_url, dest_directory):
if not data_url:
return
if not gfile.Exists(dest_directory):
os.makedirs(dest_directory)
filename = data_url.split('/')[-1]
filepath = os.path.join(dest_directory, filename)
if not gfile.Exists(filepath):
... | Download and extract data set tar file.
If the data set we're using doesn't already exist, this function
downloads it from the TensorFlow.org website and unpacks it into a
directory.
If the data_url is none, don't download anything and expect the data
directory to contain the correct files already.
Args:
data_url: We... | github-repos |
def _prepare_feed_values(model, inputs, targets, sample_weights, mode):
strategy = model._distribution_strategy
inputs, targets, sample_weights = _get_input_from_iterator(inputs, model)
if backend.is_tpu_strategy(strategy):
if sample_weights is not None:
raise ValueError('TPUStrategy doe... | Prepare feed values to the model execution function.
Args:
model: Model to prepare feed values for.
inputs: List or dict of model inputs.
targets: Optional list of model targets.
sample_weights: Optional list of sample weight arrays.
mode: One of ModeKeys.TRAIN/ModeKeys.TEST/ModeKeys.PREDICT.
Returns:
Feed values for... | github-repos |
def _get_num_nvidia_gpus():
try:
return len(os.environ['CUDA_VISIBLE_DEVICES'].split(','))
except KeyError:
pass
try:
output = subprocess.check_output(['nvidia-smi', '--list-gpus'], encoding='utf-8')
return sum((l.startswith('GPU ') for l in output.strip().split('\n')))
e... | Gets the number of NVIDIA GPUs by using CUDA_VISIBLE_DEVICES and nvidia-smi.
Returns:
Number of GPUs available on the node
Raises:
RuntimeError if executing nvidia-smi failed | github-repos |
def _init_volume_service(self, version):
volume_cfg = self._load_config_section(CONFIG_VOLUME_SECTION)
self._token_volume = volume_cfg[CONFIG_TOKEN]
proto = volume_cfg[CONFIG_PROTOCOL]
host = volume_cfg[CONFIG_HOST]
self._volume = VolumeService(host, version)
self._volume.base_protocol = proto
... | Method to initialize the Volume Service from the config data
Args:
version (string): Version of Boss API to use.
Returns:
None
Raises:
(KeyError): if given invalid version. | codesearchnet |
def post_process_travis_macos(journal_filename):
travis_build_dir = os.environ.get('TRAVIS_BUILD_DIR', '')
with open(journal_filename, 'r') as file_obj:
content = file_obj.read()
processed = content.replace(travis_build_dir, '${TRAVIS_BUILD_DIR}')
with open(journal_filename, 'w') as file_obj:
... | Post-process a generated journal file on Travis macOS.
Args:
journal_filename (str): The name of the journal file. | codesearchnet |
def predict(self, documents, **kwargs):
if isinstance(documents, (str, bytes, unicode_, np.unicode_)):
return self._predict_one(documents, **kwargs)
else:
return np.concatenate([self._predict_one(doc, **kwargs) for doc in documents]) | Predict class (content=1 or not-content=0) of the blocks in one or many
HTML document(s).
Args:
documents (str or List[str]): HTML document(s)
Returns:
``np.ndarray`` or List[``np.ndarray``]: array of binary predictions
for content (1) or not-content (0). | juraj-google-style |
def handle_subscribe(self, request, path):
ret = []
if path:
name = path[0]
if name not in self.children:
self.children[name] = NotifierNode(
getattr(self.data, name, None), self)
ret += self.children[... | Add to the list of request to notify, and notify the initial value of
the data held
Args:
request (Subscribe): The subscribe request
path (list): The relative path from ourself
Returns:
list: [(callback, Response)] that need to be called | juraj-google-style |
def format_sec_to_dhm(sec):
(rem_int, s_int) = divmod(int(sec), 60)
(rem_int, m_int) = divmod(rem_int, 60)
(d_int, h_int) = divmod(rem_int, 24)
return '{}d{:02d}h{:02d}m'.format(d_int, h_int, m_int) | Format seconds to days, hours, minutes.
Args:
sec: float or int
Number of seconds in a period of time
Returns:
Period of time represented as a string on the form ``0d:00h:00m``. | codesearchnet |
def get_data(self, url, *args, **kwargs):
res = self._conn.get(url, headers=self._prepare_headers(**kwargs))
if (res.status_code == 200):
return res.text
else:
return None | Gets data from url as text
Returns content under the provided url as text
Args:
**url**: address of the wanted data
.. versionadded:: 0.3.2
**additional_headers**: (optional) Additional headers
to be used with request
Returns:
string | codesearchnet |
def __init__(self, root, attached_dependencies=None):
trackable_view.TrackableView.__init__(self, root)
self._root_ref = root if isinstance(root, weakref.ref) else weakref.ref(root)
self._attached_dependencies = attached_dependencies | Configure the graph view.
Args:
root: A `Trackable` object whose variables (including the variables of
dependencies, recursively) should be saved. May be a weak reference.
attached_dependencies: List of dependencies to attach to the root object.
Used when saving a Checkpoint with a defined root object. To avoid
refere... | github-repos |
def set_defaults(self, defaults: Sequence[cfg.Variable]) -> 'PyTDSignature':
defaults = list(defaults)
params = []
for param in reversed(self.pytd_sig.params):
if defaults:
defaults.pop()
params.append(pytd.Parameter(name=param.name, type=param.type, kind=param.kind, optional... | Set signature's default arguments. Requires rebuilding PyTD signature.
Args:
defaults: An iterable of function argument defaults.
Returns:
Self with an updated signature. | github-repos |
def add_roles(self, databaseName, roleNames, collectionName=None):
for roleName in roleNames:
self.add_role(databaseName, roleName, collectionName) | Add multiple roles
Args:
databaseName (str): Database Name
roleNames (list of RoleSpecs): roles
Keyword Args:
collectionName (str): Collection
Raises:
ErrRoleException: role not compatible with the databaseName and/or collectionName | juraj-google-style |
def PrintMessage(self, message):
fields = message.ListFields()
if self.use_index_order:
fields.sort(key=(lambda x: x[0].index))
for (field, value) in fields:
if _IsMapEntry(field):
for key in sorted(value):
entry_submsg = field.message_type._concrete_class(key=key... | Convert protobuf message to text format.
Args:
message: The protocol buffers message. | codesearchnet |
def unsubscribe(self, subscription, max=None):
if (max is None):
self._send(('UNSUB %d' % subscription.sid))
self._subscriptions.pop(subscription.sid)
else:
subscription.max = max
self._send(('UNSUB %d %s' % (subscription.sid, max))) | Unsubscribe will remove interest in the given subject. If max is
provided an automatic Unsubscribe that is processed by the server
when max messages have been received
Args:
subscription (pynats.Subscription): a Subscription object
max (int=None): number of messages | codesearchnet |
def describe_file_set(modules):
descriptor = FileSet()
file_descriptors = []
for module in modules:
file_descriptors.append(describe_file(module))
if file_descriptors:
descriptor.files = file_descriptors
return descriptor | Build a file set from a specified Python modules.
Args:
modules: Iterable of Python module to describe.
Returns:
Initialized FileSet instance describing the modules. | codesearchnet |
def month(self, value=None):
if (value is not None):
try:
value = int(value)
except ValueError:
raise ValueError('value {} need to be of type int for field `month`'.format(value))
if (value < 1):
raise ValueError('value need to be greater or equal 1 for fi... | Corresponds to IDD Field `month`
Args:
value (int): value for IDD Field `month`
value >= 1
value <= 12
if `value` is None it will not be checked against the
specification and is assumed to be a missing value
Raises:
ValueError: if `value` is not a valid value | codesearchnet |
def defaults(cls, *options, **kwargs):
if (kwargs and (len(kwargs) != 1) and (list(kwargs.keys())[0] != 'backend')):
raise Exception('opts.defaults only accepts "backend" keyword argument')
cls._linemagic(cls._expand_options(merge_options_to_dict(options)), backend=kwargs.get('backend')) | Set default options for a session.
Set default options for a session. whether in a Python script or
a Jupyter notebook.
Args:
*options: Option objects used to specify the defaults.
backend: The plotting extension the options apply to | codesearchnet |
def create(cls, hashing_algorithm=HashingAlgorithmEnum.SHA_256, digest_value=b'', key_format_type=KeyFormatTypeEnum.RAW):
algorithm = HashingAlgorithm(hashing_algorithm)
value = DigestValue(bytearray(digest_value))
format_type = KeyFormatType(key_format_type)
return Digest(hashing_algorithm=algorithm, d... | Construct a Digest object from provided digest values.
Args:
hashing_algorithm (HashingAlgorithm): An enumeration representing
the hash algorithm used to compute the digest. Optional,
defaults to HashingAlgorithm.SHA_256.
digest_value (byte string): The bytes of the digest hash. Optional,
defaults to the empty byte st... | codesearchnet |
def get_kpoint_weights(self, kpoints, atol=1e-5):
kpts = np.array(kpoints)
shift = []
mesh = []
for i in range(3):
nonzero = [i for i in kpts[:, i] if abs(i) > 1e-5]
if len(nonzero) != len(kpts):
if not nonzero:
... | Calculate the weights for a list of kpoints.
Args:
kpoints (Sequence): Sequence of kpoints. np.arrays is fine. Note
that the code does not check that the list of kpoints
provided does not contain duplicates.
atol (float): Tolerance for fractional coordinates comparisons.
Returns:
List of weights, in the SAME order as... | juraj-google-style |
def rotate_view(self, axis_ind=0, angle=0):
camera = self.ren.GetActiveCamera()
if (axis_ind == 0):
camera.Roll(angle)
elif (axis_ind == 1):
camera.Azimuth(angle)
else:
camera.Pitch(angle)
self.ren_win.Render() | Rotate the camera view.
Args:
axis_ind: Index of axis to rotate. Defaults to 0, i.e., a-axis.
angle: Angle to rotate by. Defaults to 0. | codesearchnet |
async def get_random_popular_person(self, limit=500):
index = random.randrange(limit)
data = await self._get_popular_people_page()
if data is None:
return
if index >= len(data['results']):
page, index = self._calculate_page_index(index, data)... | Randomly select a popular person.
Notes:
Requires at least two API calls. May require three API calls
if the randomly-selected index isn't within the first page of
required data.
Arguments:
limit (:py:class:`int`, optional): How many of the most
popular people to make random choice from (defaults to top
``500``).
Re... | juraj-google-style |
def _Open(self, path_spec=None, mode='rb'):
if not self._file_object_set_in_init and not path_spec:
raise ValueError('Missing path specification.')
if self._file_object_set_in_init:
return
self._file_object = self._OpenFileObject(path_spec)
if not self._file_object:
raise IOErro... | Opens the file-like object defined by path specification.
Args:
path_spec (Optional[PathSpec]): path specification.
mode (Optional[str]): file access mode.
Raises:
AccessError: if the access to open the file was denied.
IOError: if the file-like object could not be opened.
OSError: if the file-like object could not b... | juraj-google-style |
def Artifacts(self, os_name=None, cpe=None, label=None):
return [
c.artifact for c in self.conditions if c.Artifacts(os_name, cpe, label)
] | Find the artifacts that correspond with other trigger conditions.
Args:
os_name: An OS string.
cpe: A CPE string.
label: A label string.
Returns:
A list of artifacts to be processed. | juraj-google-style |
def normal(self, shape, mean=0.0, stddev=1.0, dtype=dtypes.float32, name=None):
with ops.name_scope(name, 'stateful_normal', [shape, mean, stddev]) as name:
shape = _shape_tensor(shape)
mean = ops.convert_to_tensor(mean, dtype=dtype, name='mean')
stddev = ops.convert_to_tensor(stddev, dtype=... | Outputs random values from a normal distribution.
Args:
shape: A 1-D integer Tensor or Python array. The shape of the output
tensor.
mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal
distribution.
stddev: A 0-D Tensor or Python value of type `dtype`. The standard
deviation of the normal distri... | github-repos |
def add_string_parameters(self, string):
if isinstance(string, list):
for x in string:
self.add_string_parameters(x)
return
self._parameters.append("{ \"value\": \"" + string + "\" }") | Add given string parameters to the internal list.
Args:
string (list of str or str): A string or list of strings to add to the parameters. | juraj-google-style |
def __call__(self, y_true, y_pred, sample_weight=None, regularization_losses=None):
y_true = self._conform_to_outputs(y_pred, y_true)
sample_weight = self._conform_to_outputs(y_pred, sample_weight)
if not self._built:
self.build(y_pred)
y_pred = nest.flatten(y_pred)
y_true = nest.flatten(y_t... | Computes the overall loss.
Args:
y_true: An arbitrary structure of Tensors representing the ground truth.
y_pred: An arbitrary structure of Tensors representing a Model's outputs.
sample_weight: An arbitrary structure of Tensors representing the
per-sample loss weights. If one Tensor is passed, it is used for all
loss... | github-repos |
def ch_start_time(self, *channels: List[Channel]) -> int:
return self.timeslots.ch_start_time(*channels) | Return minimum start time for supplied channels.
Args:
*channels: Supplied channels | juraj-google-style |
def _create_datadict(cls, internal_name):
if (internal_name == 'LOCATION'):
return Location()
if (internal_name == 'DESIGN CONDITIONS'):
return DesignConditions()
if (internal_name == 'TYPICAL/EXTREME PERIODS'):
return TypicalOrExtremePeriods()
if (internal_name == 'GROUND TEMPER... | Creates an object depending on `internal_name`
Args:
internal_name (str): IDD name
Raises:
ValueError: if `internal_name` cannot be matched to a data dictionary object | codesearchnet |
def SetHasherNames(self, hasher_names_string):
hasher_names = hashers_manager.HashersManager.GetHasherNamesFromString(
hasher_names_string)
debug_hasher_names = ', '.join(hasher_names)
logger.debug('Got hasher names: {0:s}'.format(debug_hasher_names))
self._hashers = hashers_manager.Hashe... | Sets the hashers that should be enabled.
Args:
hasher_names_string (str): comma separated names of hashers to enable. | juraj-google-style |
def valUserCert(self, byts, cacerts=None):
cert = crypto.load_certificate(crypto.FILETYPE_PEM, byts)
if cacerts is None:
cacerts = self.getCaCerts()
store = crypto.X509Store()
[store.add_cert(cacert) for cacert in cacerts]
ctx = crypto.X509StoreContext(sto... | Validate the PEM encoded x509 user certificate bytes and return it.
Args:
byts (bytes): The bytes for the User Certificate.
cacerts (tuple): A tuple of OpenSSL.crypto.X509 CA Certificates.
Raises:
OpenSSL.crypto.X509StoreContextError: If the certificate is not valid.
Returns:
OpenSSL.crypto.X509: The certificate, if... | juraj-google-style |
def get(self, client_id, client_secret, code, redirect_uri):
check_type(client_id, basestring, may_be_none=False)
check_type(client_secret, basestring, may_be_none=False)
check_type(code, basestring, may_be_none=False)
check_type(redirect_uri, basestring, may_be_none=False)
post_data = dict_from_ite... | Exchange an Authorization Code for an Access Token.
Exchange an Authorization Code for an Access Token that can be used to
invoke the APIs.
Args:
client_id(basestring): Provided when you created your integration.
client_secret(basestring): Provided when you created your
integration.
code(basestring): The Authorizatio... | codesearchnet |
def GetVSSStoreIdentifiers(self, volume_system, volume_identifiers):
print_header = True
while True:
if print_header:
self._PrintVSSStoreIdentifiersOverview(volume_system, volume_identifiers)
print_header = False
self._output_writer.Write('\n')
lines = self._textw... | Retrieves VSS store identifiers.
This method can be used to prompt the user to provide VSS store identifiers.
Args:
volume_system (VShadowVolumeSystem): volume system.
volume_identifiers (list[str]): volume identifiers including prefix.
Returns:
list[str]: selected volume identifiers including prefix or None. | codesearchnet |
def get_display_name(self, room=None):
if room:
try:
return room.members_displaynames[self.user_id]
except KeyError:
return self.user_id
if not self.displayname:
self.displayname = self.api.get_display_name(self.user_id)
... | Get this user's display name.
Args:
room (Room): Optional. When specified, return the display name of the user
in this room.
Returns:
The display name. Defaults to the user ID if not set. | juraj-google-style |
def graph_op_digests(self, op_type=None):
if op_type is not None:
return [digest for digest in self._graph_op_digests if digest.op_type == op_type]
else:
return self._graph_op_digests | Get the list of the digests for graph-op creation so far.
Args:
op_type: Optional op type to filter the creation events with.
Returns:
A list of `GraphOpCreationDigest` objects. | github-repos |
def _initialize_memory(self, policy_params):
template = (self._batch_env.observ[0], self._batch_env.action[0], tools.nested.map((lambda x: x[(0, 0)]), policy_params), self._batch_env.reward[0])
with tf.variable_scope('ppo_temporary'):
self._current_episodes = parts.EpisodeMemory(template, len(self._batc... | Initialize temporary and permanent memory.
Args:
policy_params: Nested tuple of policy parameters with all dimensions set.
Initializes the attributes `self._current_episodes`,
`self._finished_episodes`, and `self._num_finished_episodes`. The episodes
memory serves to collect multiple episodes in parallel. Finished ep... | codesearchnet |
def add_header(self, key, value, **params):
key = self.escape(key)
ci_key = key.casefold()
def quoted_params(items):
for p in items:
param_name = self.escape(p[0])
param_val = self.de_quote(self.escape(p[1]))
(yield (param_name, param_val))
sorted_items = sor... | Add a header to the collection, including potential parameters.
Args:
key (str): The name of the header
value (str): The value to store under that key
params: Option parameters to be appended to the value,
automatically formatting them in a standard way | codesearchnet |
def render_chart_data(data):
builder = HtmlBuilder()
builder._render_objects(data, datatype='chartdata')
return builder._to_html() | Return a dictionary list formatted as a HTML table.
Args:
data: data in the form consumed by Google Charts. | juraj-google-style |
def _create(cls, model_class, *args, **kwargs):
manager = cls._get_manager(model_class)
return manager.create_user(*args, **kwargs) | Create a new user instance.
Args:
model_class:
The type of model to create an instance of.
args:
Positional arguments to create the instance with.
kwargs:
Keyword arguments to create the instance with.
Returns:
A new user instance of the type specified by
``model_class``. | juraj-google-style |
def open_image(fn):
flags = cv2.IMREAD_UNCHANGED+cv2.IMREAD_ANYDEPTH+cv2.IMREAD_ANYCOLOR
if not os.path.exists(fn) and not str(fn).startswith("http"):
raise OSError('No such file or directory: {}'.format(fn))
elif os.path.isdir(fn) and not str(fn).startswith("http"):
raise OSError('Is a... | Opens an image using OpenCV given the file path.
Arguments:
fn: the file path of the image
Returns:
The image in RGB format as numpy array of floats normalized to range between 0.0 - 1.0 | juraj-google-style |
def get_model_field(model, field_name):
meta = model._meta
try:
if DJANGO19:
field = meta.get_field(field_name)
else:
field = meta.get_field_by_name(field_name)[0]
return field
except:
if DJANGO19:
related_objs = (
f fo... | Return a field given a model and field name.
Arguments:
model: a Django model
field_name: the name of a field
Returns:
A Django field if `field_name` is a valid field for `model`,
None otherwise. | juraj-google-style |
def __init__(self, parent=None):
super(SupportedDtypesTranslator, self).__init__(parent)
self._strs = [(np.dtype(object), self.tr('text'))]
self._ints = [(np.dtype(np.int8), self.tr('small integer (8 bit)')),
(np.dtype(np.int16), self.tr('small integer (... | Constructs the object with the given parent.
Args:
parent (QtCore.QObject, optional): Causes the objected to be owned
by `parent` instead of Qt. Defaults to `None`. | juraj-google-style |
def __init__(self, vertex_out, vertex_in, weight=1):
self.vertex_out = None
self.vertex_in = None
self.weight = weight
self.go_from(vertex_out)
self.go_in(vertex_in) | Initialization method.
Args:
vertex_out (Vertex): source vertex (edge going out).
vertex_in (Vertex): target vertex (edge going in).
weight (int): weight of the edge. | juraj-google-style |
def rgb_to_grayscale(images, name=None):
with ops.name_scope(name, 'rgb_to_grayscale', [images]) as name:
images = ops.convert_to_tensor(images, name='images')
orig_dtype = images.dtype
flt_image = convert_image_dtype(images, dtypes.float32)
rgb_weights = [0.2989, 0.587, 0.114]
... | Converts one or more images from RGB to Grayscale.
Outputs a tensor of the same `DType` and rank as `images`. The size of the
last dimension of the output is 1, containing the Grayscale value of the
pixels.
>>> original = tf.constant([[[1.0, 2.0, 3.0]]])
>>> converted = tf.image.rgb_to_grayscale(original)
>>> print(... | github-repos |
def _wrap_2d_function(inputs, compute_op, dim=-1, name=None):
def _swap_axis(input_tensor, dim_index, last_index, name=None):
return array_ops.transpose(input_tensor, array_ops.concat([math_ops.range(dim_index), [last_index], math_ops.range(dim_index + 1, last_index), [dim_index]], 0), name=name)
... | Helper function for ops that accept and return 2d inputs of same shape.
It reshapes and transposes the inputs into a 2-D Tensor and then invokes
the given function. The output would be transposed and reshaped back.
If the given function returns a tuple of tensors, each of them will be
transposed and reshaped.
Args:
i... | github-repos |
def get_invalid_txn_info(self, batch_id):
with self._lock:
return [info.copy() for info in self._invalid.get(batch_id, [])] | Fetches the id of the Transaction that failed within a particular
Batch, as well as any error message or other data about the failure.
Args:
batch_id (str): The id of the Batch containing an invalid txn
Returns:
list of dict: A list of dicts with three possible keys:
* 'id' - the header_signature of the invalid Trans... | codesearchnet |
def _get_overlaps_tensor(self, L):
(n, m) = L.shape
LY = np.array([np.where((L == y), 1, 0) for y in range(self.k_0, (self.k + 1))])
O = (np.einsum('abc,dbe,fbg->cegadf', LY, LY, LY) / n)
return torch.from_numpy(O).float() | Transforms the input label matrix to a three-way overlaps tensor.
Args:
L: (np.array) An n x m array of LF output labels, in {0,...,k} if
self.abstains, else in {1,...,k}, generated by m conditionally
independent LFs on n data points
Outputs:
O: (torch.Tensor) A (m, m, m, k, k, k) tensor of the label-specific
empiric... | codesearchnet |
def derive_annotations(self, annotations):
cls = type(self)
return cls(
self[0],
self[1],
self[2],
self[3],
annotations,
self[5]
) | Derives a new event from this one setting the ``annotations`` attribute.
Args:
annotations: (Sequence[Union[amazon.ion.symbols.SymbolToken, unicode]]):
The annotations associated with the derived event.
Returns:
IonEvent: The newly generated event. | juraj-google-style |
def register_key_flag_for_module(self, module_name, flag):
key_flags_by_module = self.key_flags_by_module_dict()
key_flags = key_flags_by_module.setdefault(module_name, [])
if flag not in key_flags:
key_flags.append(flag) | Specifies that a flag is a key flag for a module.
Args:
module_name: str, the name of a Python module.
flag: Flag, the Flag instance that is key to the module. | juraj-google-style |
def filter(self, scored_list):
top_n_key = ((- 1) * self.top_n)
top_n_list = sorted(scored_list, key=(lambda x: x[1]))[top_n_key:]
result_list = sorted(top_n_list, key=(lambda x: x[0]))
return result_list | Filtering with top-n ranking.
Args:
scored_list: The list of scoring.
Retruns:
The list of filtered result. | codesearchnet |
def peek(self, index, name=None):
if name is None:
name = '%s_peek' % self._name
fn = lambda: gen_data_flow_ops.stage_peek(index, dtypes=self._dtypes, shared_name=self._name, name=name, capacity=self._capacity, memory_limit=self._memory_limit)
return self.__internal_get(fn, name) | Peeks at an element in the staging area.
If the staging area is too small to contain the element at
the specified index, it will block until enough elements
are inserted to complete the operation.
The placement of the returned tensor will be determined by
the current device scope when this function is called.
Args:
... | github-repos |
def get_numpy_iterator(self):
raise NotImplementedError | Get a Python iterable for the `DataAdapter`, that yields NumPy
arrays.
Returns:
A Python iterator. | github-repos |
def save_model_to_hdf5(model, filepath, overwrite=True, include_optimizer=True):
if h5py is None:
raise ImportError('`save_model` requires h5py.')
if len(model.weights) != len(model._undeduplicated_weights):
logging.warning('Found duplicated `Variable`s in Model\'s `weights`. This is usually cau... | Saves a model to a HDF5 file.
The saved model contains:
- the model's configuration (topology)
- the model's weights
- the model's optimizer's state (if any)
Thus the saved model can be reinstantiated in
the exact same state, without any of the code
used for model definition or training.
Args:
model: Keras model ins... | github-repos |
def convert_ids_to_tokens(self, ids: Union[int, list[int]], skip_special_tokens: bool=False) -> Union[str, list[str]]:
if isinstance(ids, int):
return self._tokenizer.id_to_token(ids)
tokens = []
ids_to_skip = set(self.all_special_ids) if skip_special_tokens else set()
for index in ids:
... | Converts a single index or a sequence of indices in a token or a sequence of tokens, using the vocabulary and
added tokens.
Args:
ids (`int` or `List[int]`):
The token id (or token ids) to convert to tokens.
skip_special_tokens (`bool`, *optional*, defaults to `False`):
Whether or not to remove special tokens in the d... | github-repos |
def record_batch_metrics(self, requests_in_batch: List) -> None:
if not _has_opentelemetry or not requests_in_batch:
return
decode_tokens = 0
prefill_tokens = 0
for state in requests_in_batch:
if state.status == RequestStatus.DECODING:
decode_tokens += 1
elif state.st... | Record metrics about the batch composition including decode/prefill ratio and batch fill percentage.
Args:
requests_in_batch: List of request states in the current batch | github-repos |
def remove(self, *dic):
dicList = list(flatten(dic))
for d in dicList:
di = []
for k in d:
di.append(Pair(k, IntegerSingle(d[k])))
dictSingle = DictSingle(di)
self._remove([dictSingle], self.l) | remove a calendar config.
Args:
*dic (dict): dictionary with format {'Day': 12, 'Hour': 34} Avaliable keys are Month, Day, Weekday, Hour, Minute. *Note the uppercase.* You can use gen(), genMix() to generate complex config dictionary. | juraj-google-style |
def get_random_numeric_tensor(self, dtype=None, min_size=_MIN_SIZE, max_size=_MAX_SIZE, min_val=_MIN_INT, max_val=_MAX_INT):
if max_size > 8:
raise tf.errors.InvalidArgumentError(None, None, 'Given size of {} will result in an OOM error'.format(max_size))
seed = self.get_int()
shape = self.get_int_l... | Return a tensor of random shape and values.
Generated tensors are capped at dimension sizes of 8, as 2^32 bytes of
requested memory crashes the fuzzer (see b/34190148).
Returns only type that tf.random.uniform can generate. If you need a
different type, consider using tf.cast.
Args:
dtype: Type of tensor, must of one... | github-repos |
def export_gpx_file(self):
gpx = create_elem('gpx', GPX_ELEM_ATTRIB)
if (not self.metadata.bounds):
self.metadata.bounds = [j for i in self for j in i]
gpx.append(self.metadata.togpx())
track = create_elem('trk')
gpx.append(track)
for segment in self:
chunk = create_elem('trkseg'... | Generate GPX element tree from ``Trackpoints``.
Returns:
etree.ElementTree: GPX element tree depicting ``Trackpoints``
objects | codesearchnet |
def __init__(self, visitor):
self._visitor = visitor
self._root_name = 'tf'
self._private_map = {'tf': ['compiler', 'core', 'security', 'dtensor', 'python', 'tsl'], 'tf.flags': ['cpp_flags']}
self._do_not_descend_map = {'tf': ['examples', 'flags', 'platform', 'pywrap_tensorflow', 'user_ops', 'tools', 't... | Constructor.
`visitor` should be a callable suitable as a visitor for `traverse`. It will
be called only for members of the public TensorFlow API.
Args:
visitor: A visitor to call for the public API. | github-repos |
def from_arrays(cls, path, trn, val, bs=64, tfms=(None, None), classes=None, num_workers=4, test=None, continuous=False):
f = (ArraysIndexRegressionDataset if continuous else ArraysIndexDataset)
datasets = cls.get_ds(f, trn, val, tfms, test=test)
return cls(path, datasets, bs, num_workers, classes=classes) | Read in images and their labels given as numpy arrays
Arguments:
path: a root path of the data (used for storing trained models, precomputed values, etc)
trn: a tuple of training data matrix and target label/classification array (e.g. `trn=(x,y)` where `x` has the
shape of `(5000, 784)` and `y` has the shape of `(5000... | codesearchnet |
def start_dag(self, dag, *, data=None):
return self._client.send(
Request(
action='start_dag',
payload={'name': dag.name if isinstance(dag, Dag) else dag,
'data': data if isinstance(data, MultiTaskData) else None}
)
... | Schedule the execution of a dag by sending a signal to the workflow.
Args:
dag (Dag, str): The dag object or the name of the dag that should be started.
data (MultiTaskData): The data that should be passed on to the new dag.
Returns:
str: The name of the successfully started dag. | juraj-google-style |
def forward(self, device_port, local_port=None):
port = self._adb_device.forward(device_port, local_port)
return (self._host, port) | Forward device port to local
Args:
device_port: port inside device
local_port: port on PC, if this value is None, a port will random pick one.
Returns:
tuple, (host, local_port) | juraj-google-style |
def pixel_image(shape, sd=None, init_val=None):
if sd is not None and init_val is not None:
warnings.warn(
"`pixel_image` received both an initial value and a sd argument. Ignoring sd in favor of the supplied initial value."
)
sd = sd or 0.01
init_val = init_val or np.rando... | A naive, pixel-based image parameterization.
Defaults to a random initialization, but can take a supplied init_val argument
instead.
Args:
shape: shape of resulting image, [batch, width, height, channels].
sd: standard deviation of param initialization noise.
init_val: an initial value to use instead of a random initi... | juraj-google-style |
def _get_bit(self, n, hash_bytes):
if hash_bytes[n
return True
return False | Determines if the n-th bit of passed bytes is 1 or 0.
Arguments:
hash_bytes - List of hash byte values for which the n-th bit value
should be checked. Each element of the list should be an integer from
0 to 255.
Returns:
True if the bit is 1. False if the bit is 0. | juraj-google-style |
def update_dns_zone_record(env, zone_id, **kwargs):
client = boto3.Session(profile_name=env).client('route53')
response = {}
hosted_zone_info = client.get_hosted_zone(Id=zone_id)
zone_name = hosted_zone_info['HostedZone']['Name'].rstrip('.')
dns_name = kwargs.get('dns_name')
if (dns_name and dns... | Create a Route53 CNAME record in _env_ zone.
Args:
env (str): Deployment environment.
zone_id (str): Route53 zone id.
Keyword Args:
dns_name (str): FQDN of application's dns entry to add/update.
dns_name_aws (str): FQDN of AWS resource
dns_ttl (int): DNS time-to-live (ttl) | codesearchnet |
def __init__(self, input_queue, output_queue):
super(WorkflowThread, self).__init__(input_queue, output_queue)
self.pending = PendingBarriers()
self.worker_threads = []
self.register(WorkflowItem, input_queue) | Initializer.
Args:
input_queue: Queue this worker consumes work from. These should be
WorkflowItems to process, or any WorkItems registered with this
class using the register() method.
output_queue: Queue where this worker puts finished work items,
if any. | juraj-google-style |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.