code stringclasses 25
values | signature stringlengths 38 735 | docstring stringlengths 36 4.44k | loss_without_docstring float64 3.06 121k | loss_with_docstring float64 16 904k | factor float64 0.02 0.19 | __index_level_0__ int64 3.7k 390k |
|---|---|---|---|---|---|---|
pass | def create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
options: Dict[str, Dict[str, Any]]) -> ParsingPlan[T] | Creates a parsing plan to parse the given filesystem object into the given desired_type.
Implementing classes may wish to support additional parameters.
:param desired_type: the type of object that should be created as the output of parsing plan execution.
:param filesystem_object: the persiste... | 6,004.365723 | 323,999.28125 | 0.018532 | 342,608 |
pass | def create_network_profile(projectArn=None, name=None, description=None, type=None, uplinkBandwidthBits=None, downlinkBandwidthBits=None, uplinkDelayMs=None, downlinkDelayMs=None, uplinkJitterMs=None, downlinkJitterMs=None, uplinkLossPercent=None, downlinkLossPercent=None) | Creates a network profile.
See also: AWS API Documentation
:example: response = client.create_network_profile(
projectArn='string',
name='string',
description='string',
type='CURATED'|'PRIVATE',
uplinkBandwidthBits=123,
downlinkBandwidthBits=123,
... | 6,889.181641 | 323,436.15625 | 0.0213 | 129,865 |
pass | def pre_build(self, user, install_path, variants=None, release_message=None,
changelog=None, previous_version=None,
previous_revision=None, **kwargs) | Pre-build hook.
Args:
user: Name of person who did the release.
install_path: Directory the package was installed into.
variants: List of variant indices we are attempting to build, or
None
release_message: User-supplied release message.
... | 5,403.59668 | 200,466.921875 | 0.026955 | 274,744 |
raise NotImplementedError | def move_out_8(self, session, space, offset, length, data, extended=False) | Moves an 8-bit block of data from local memory to the specified address space and offset.
Corresponds to viMoveOut8* functions of the VISA library.
:param session: Unique logical identifier to a session.
:param space: Specifies the address space. (Constants.*SPACE*)
:param offset: Offs... | 519.81311 | 14,925.515625 | 0.034827 | 276,779 |
raise NotImplementedError | def history_bars(self, instrument, bar_count, frequency, fields, dt, skip_suspended=True,
include_now=False, adjust_type='pre', adjust_orig=None) | 获取历史数据
:param instrument: 合约对象
:type instrument: :class:`~Instrument`
:param int bar_count: 获取的历史数据数量
:param str frequency: 周期频率，`1d` 表示日周期, `1m` 表示分钟周期
:param str fields: 返回数据字段
========================= ===================================================
fi... | 764.779053 | 21,873.466797 | 0.034964 | 108,424 |
... | async def select_mailbox(self, name: str, readonly: bool = False) \
-> Tuple[MailboxInterface, SelectedMailbox] | Selects an existing mailbox owned by the user. The returned session
is then used as the ``selected`` argument to other methods to fetch
mailbox updates.
See Also:
`RFC 3501 6.3.1.
<https://tools.ietf.org/html/rfc3501#section-6.3.1>`_,
`RFC 3501 6.3.2.
... | 18,261.103516 | 515,564.15625 | 0.03542 | 154,599 |
raise NotImplementedError() | def set_transaction_execution_result(
self, txn_signature, is_valid, context_id, state_changes, events,
data, error_message, error_data) | Set the status of an executed transaction.
Called by the executor after a transaction has been processed.
The scheduler must know when transactions have finished being
applied so that it can determine which transactions will become
eligible for processing.
Args:
tx... | 137.20752 | 3,795.463867 | 0.03615 | 201,649 |
pass | def create_nfs_file_share(ClientToken=None, NFSFileShareDefaults=None, GatewayARN=None, KMSEncrypted=None, KMSKey=None, Role=None, LocationARN=None, DefaultStorageClass=None, ClientList=None, Squash=None, ReadOnly=None) | Creates a file share on an existing file gateway. In Storage Gateway, a file share is a file system mount point backed by Amazon S3 cloud storage. Storage Gateway exposes file shares using a Network File System (NFS) interface. This operation is only supported in the file gateway architecture.
See also: AWS API Doc... | 13,010.769531 | 346,118.5625 | 0.03759 | 129,861 |
pass | def describe_events(ApplicationName=None, VersionLabel=None, TemplateName=None, EnvironmentId=None, EnvironmentName=None, PlatformArn=None, RequestId=None, Severity=None, StartTime=None, EndTime=None, MaxRecords=None, NextToken=None) | Returns list of event descriptions matching criteria up to the last 6 weeks.
See also: AWS API Documentation
Examples
The following operation retrieves events for an environment named my-env:
Expected Output:
:example: response = client.describe_events(
ApplicationName='string',
... | 29,160.408203 | 696,562.4375 | 0.041863 | 129,878 |
raise NotImplementedError | def expect_column_values_to_be_between(self,
column,
min_value=None,
max_value=None,
allow_cross_type_comparisons=None,
... | Expect column entries to be between a minimum value and a maximum value (inclusive).
expect_column_values_to_be_between is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
... | 1,651.116211 | 36,721.40625 | 0.044963 | 258,403 |
pass | def references(self, env, object_name, model, assoc_class,
result_class_name, role, result_role, keys_only) | Instrument Associations.
All four association-related operations (Associators, AssociatorNames,
References, ReferenceNames) are mapped to this method.
This method is a python generator
Keyword arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
object_n... | 5,468.001465 | 120,471.007813 | 0.045389 | 163,738 |
raise NotImplementedError | def expect_column_pair_values_A_to_be_greater_than_B(self,
column_A,
column_B,
or_equal=None,
... | Expect values in column A to be greater than column B.
Args:
column_A (str): The first column name
column_B (str): The second column name
or_equal (boolean or None): If True, then values can be equal, not strictly greater
Keyword Args:
allow_cross_type_c... | 755.112915 | 16,200.813477 | 0.04661 | 258,417 |
pass | def stream_download(self, chunk_size: Optional[int] = None, callback: Optional[Callable] = None) -> AsyncIterator[bytes] | Generator for streaming request body data.
Should be implemented by sub-classes if streaming download
is supported.
:param callback: Custom callback for monitoring progress.
:param int chunk_size: | 8,901.126953 | 189,269.03125 | 0.047029 | 300,237 |
pass | def process_answer(self, user, item, asked, answered, time, answer, response_time, guess, **kwargs) | This method is used during the answer streaming and is called after the
predictive model for each answer.
Args:
user (int):
identifier of ther user answering the question
asked (int):
identifier of the asked item
answered (int):
... | 3,391.612793 | 70,850.90625 | 0.04787 | 248,330 |
raise NotImplementedError | def expect_column_value_lengths_to_be_between(self,
column,
min_value=None,
max_value=None,
mostly=None,
... | Expect column entries to be strings with length between a minimum value and a maximum value (inclusive).
This expectation only works for string-type values. Invoking it on ints or floats will raise a TypeError.
expect_column_value_lengths_to_be_between is a :func:`column_map_expectation <great_expecta... | 2,083.296631 | 41,936.882813 | 0.049677 | 258,405 |
pass | def update_network_profile(arn=None, name=None, description=None, type=None, uplinkBandwidthBits=None, downlinkBandwidthBits=None, uplinkDelayMs=None, downlinkDelayMs=None, uplinkJitterMs=None, downlinkJitterMs=None, uplinkLossPercent=None, downlinkLossPercent=None) | Updates the network profile with specific settings.
See also: AWS API Documentation
:example: response = client.update_network_profile(
arn='string',
name='string',
description='string',
type='CURATED'|'PRIVATE',
uplinkBandwidthBits=123,
downlinkBandwidt... | 13,111.739258 | 259,419.015625 | 0.050543 | 129,866 |
def optimization_at(self,
circuit: Circuit,
index: int,
op: ops.Operation
) -> Optional[PointOptimizationSummary] | Describes how to change operations near the given location.
For example, this method could realize that the given operation is an
X gate and that in the very next moment there is a Z gate. It would
indicate that they should be combined into a Y gate by returning
PointOptimizationSummary... | 32,516.857422 | 624,670.3125 | 0.052054 | 189,265 | |
raise NotImplementedError | def expect_column_values_to_not_match_regex_list(self, column, regex_list,
mostly=None,
result_format=None, include_config=False, catch_exceptions=None, meta=None) | Expect the column entries to be strings that do not match any of a list of regular expressions. Matches can \
be anywhere in the string.
expect_column_values_to_not_match_regex_list is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Arg... | 788.291504 | 15,053.569336 | 0.052366 | 258,409 |
raise NotImplementedError | def expect_column_pair_values_to_be_in_set(self,
column_A,
column_B,
value_pairs_set,
ignore_row_if="both_values_are_missing",
... | Expect paired values from columns A and B to belong to a set of valid pairs.
Args:
column_A (str): The first column name
column_B (str): The second column name
value_pairs_set (list of tuples): All the valid pairs to be matched
Keyword Args:
ignore_row_i... | 1,102.577515 | 20,246.111328 | 0.054459 | 258,418 |
raise NotImplementedError | def expect_column_min_to_be_between(self,
column,
min_value=None,
max_value=None,
parse_strings_as_datetimes=None,
outpu... | Expect the column to sum to be between an min and max value
expect_column_min_to_be_between is a :func:`column_aggregate_expectation <great_expectations.data_asset.dataset.Dataset.column_aggregate_expectation>`.
Args:
column (str): \
The column name
min_value (c... | 2,174.617432 | 36,963.839844 | 0.058831 | 258,415 |
pass | def create_qualification_type(Name=None, Keywords=None, Description=None, QualificationTypeStatus=None, RetryDelayInSeconds=None, Test=None, AnswerKey=None, TestDurationInSeconds=None, AutoGranted=None, AutoGrantedValue=None) | The CreateQualificationType operation creates a new Qualification type, which is represented by a QualificationType data structure.
See also: AWS API Documentation
:example: response = client.create_qualification_type(
Name='string',
Keywords='string',
Description='string',
... | 20,615.230469 | 350,310.71875 | 0.058848 | 129,886 |
raise NotImplementedError() | def restore_backup(
self, bootstrap=False, constraints=None, archive=None,
backup_id=None, upload_tools=False) | Restore a backup archive to a new controller.
:param bool bootstrap: Bootstrap a new state machine
:param constraints: Model constraints
:type constraints: :class:`juju.Constraints`
:param str archive: Path to backup archive to restore
:param str backup_id: Id of backup to resto... | 207.373856 | 3,481.953613 | 0.059557 | 158,574 |
def get_all_in_collection(self, collection_paths: Union[str, Iterable[str]], load_metadata: bool = True) \
-> Sequence[EntityType] | Gets entities contained within the given iRODS collections.
If one or more of the collection_paths does not exist, a `FileNotFound` exception will be raised.
:param collection_paths: the collection(s) to get the entities from
:param load_metadata: whether metadata associated to the entities sho... | 51,822.335938 | 865,407.375 | 0.059882 | 208,615 | |
pass | def provision_product(AcceptLanguage=None, ProductId=None, ProvisioningArtifactId=None, PathId=None, ProvisionedProductName=None, ProvisioningParameters=None, Tags=None, NotificationArns=None, ProvisionToken=None) | Requests a Provision of a specified product. A ProvisionedProduct is a resourced instance for a product. For example, provisioning a CloudFormation-template-backed product results in launching a CloudFormation stack and all the underlying resources that come with it.
You can check the status of this request using t... | 21,847.072266 | 362,532.34375 | 0.060262 | 129,881 |
pass | def init_params(self, initializer=Uniform(0.01), arg_params=None, aux_params=None,
allow_missing=False, force_init=False, allow_extra=False) | Initializes the parameters and auxiliary states. By default this function
does nothing. Subclass should override this method if contains parameters.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
... | 3,954.343506 | 62,496.734375 | 0.063273 | 94,669 |
pass | def describe_users(OrganizationId=None, UserIds=None, Query=None, Include=None, Order=None, Sort=None, Marker=None, Limit=None, Fields=None) | Describes the specified users. You can describe all users or filter the results (for example, by status or organization).
By default, Amazon WorkDocs returns the first 24 active or pending users. If there are more results, the response includes a marker that you can use to request the next set of results.
See a... | 12,651.352539 | 193,414.578125 | 0.065411 | 129,870 |
raise NotImplementedError | def expect_column_values_to_be_in_set(self,
column,
value_set,
mostly=None,
parse_strings_as_datetimes=None,
r... | Expect each column value to be in a given set.
For example:
::
# my_df.my_col = [1,2,2,3,3,3]
>>> my_df.expect_column_values_to_be_in_set(
"my_col",
[2,3]
)
{
"success": false
"result": {
... | 1,632.004639 | 24,750.21875 | 0.065939 | 258,402 |
... | async def search_mailbox(self, selected: SelectedMailbox,
keys: FrozenSet[SearchKey]) \
-> Tuple[Iterable[Tuple[int, MessageInterface]], SelectedMailbox] | Get the messages in the current mailbox that meet all of the
given search criteria.
See Also:
`RFC 3501 7.2.5.
<https://tools.ietf.org/html/rfc3501#section-7.2.5>`_
Args:
selected: The selected mailbox session.
keys: Search keys specifying the me... | 45,825.734375 | 691,319.8125 | 0.066287 | 154,602 |
raise NotImplementedError() | def sync_tools(
self, all_=False, destination=None, dry_run=False, public=False,
source=None, stream=None, version=None) | Copy Juju tools into this model.
:param bool all_: Copy all versions, not just the latest
:param str destination: Path to local destination directory
:param bool dry_run: Don't do the actual copy
:param bool public: Tools are for a public cloud, so generate mirrors
informati... | 197.413071 | 2,943.444336 | 0.067069 | 158,580 |
pass | def describe_db_engine_versions(Engine=None, EngineVersion=None, DBParameterGroupFamily=None, Filters=None, MaxRecords=None, Marker=None, DefaultOnly=None, ListSupportedCharacterSets=None, ListSupportedTimezones=None) | Returns a list of the available DB engines.
See also: AWS API Documentation
Examples
This example lists settings for the specified DB engine version.
Expected Output:
:example: response = client.describe_db_engine_versions(
Engine='string',
EngineVersion='string',
D... | 27,880.251953 | 408,334.4375 | 0.068278 | 129,883 |
def UpdateCronJob(self,
cronjob_id,
last_run_status=unchanged,
last_run_time=unchanged,
current_run_id=unchanged,
state=unchanged,
forced_run_requested=unchanged) | Updates run information for an existing cron job.
Args:
cronjob_id: The id of the cron job to update.
last_run_status: A CronJobRunStatus object.
last_run_time: The last time a run was started for this cron job.
current_run_id: The id of the currently active run.
state: The state dict... | 8,146.264648 | 116,665.4375 | 0.069826 | 190,713 | |
raise NotImplemented | def html_to_obj(cls, file_path=None, text='', columns=None,
key_on=None, ignore_code_blocks=True, eval_cells=True) | This will convert a html file or text to a seaborn table
:param file_path: str of the path to the file
:param text: str of the csv text
:param columns: list of str of columns to use
:param remove_empty_rows: bool if True will remove empty rows
:param key_on: list of str of column... | 1,474.549438 | 20,564.021484 | 0.071705 | 240,318 |
def UpdateFlow(self,
client_id,
flow_id,
flow_obj=unchanged,
flow_state=unchanged,
client_crash_info=unchanged,
pending_termination=unchanged,
processing_on=unchanged,
processing_since... | Updates flow objects in the database.
Args:
client_id: The client id on which this flow is running.
flow_id: The id of the flow to update.
flow_obj: An updated rdf_flow_objects.Flow object.
flow_state: An update rdf_flow_objects.Flow.FlowState value.
client_crash_info: A rdf_client.Cl... | 5,329.850586 | 71,049.429688 | 0.075016 | 190,714 | |
pass | def register_task_with_maintenance_window(WindowId=None, Targets=None, TaskArn=None, ServiceRoleArn=None, TaskType=None, TaskParameters=None, Priority=None, MaxConcurrency=None, MaxErrors=None, LoggingInfo=None, ClientToken=None) | Adds a new task to a Maintenance Window.
See also: AWS API Documentation
:example: response = client.register_task_with_maintenance_window(
WindowId='string',
Targets=[
{
'Key': 'string',
'Values': [
'string',
... | 38,049.972656 | 504,650.46875 | 0.075399 | 129,879 |
raise NotImplementedError | def expect_column_pair_values_to_be_equal(self,
column_A,
column_B,
ignore_row_if="both_values_are_missing",
result_format=None, include... | Expect the values in column A to be the same as column B.
Args:
column_A (str): The first column name
column_B (str): The second column name
Keyword Args:
ignore_row_if (str): "both_values_are_missing", "either_value_is_missing", "neither"
Other Parameters:... | 1,611.422241 | 21,352.916016 | 0.075466 | 258,416 |
pass | def update_phase(self, environment, data, prediction, user, item, correct, time, answer_id, **kwargs) | After the prediction update the environment and persist some
information for the predictive model.
Args:
environment (proso.models.environment.Environment):
environment where all the important data are persist
data (object):
data from the prepare ... | 3,571.927246 | 47,124.558594 | 0.075798 | 248,616 |
pass | def create_product(AcceptLanguage=None, Name=None, Owner=None, Description=None, Distributor=None, SupportDescription=None, SupportEmail=None, SupportUrl=None, ProductType=None, Tags=None, ProvisioningArtifactParameters=None, IdempotencyToken=None) | Creates a new product.
See also: AWS API Documentation
:example: response = client.create_product(
AcceptLanguage='string',
Name='string',
Owner='string',
Description='string',
Distributor='string',
SupportDescription='string',
SupportEmail='stri... | 39,687.054688 | 522,826.8125 | 0.075909 | 129,880 |
... | async def update_flags(self, selected: SelectedMailbox,
sequence_set: SequenceSet,
flag_set: FrozenSet[Flag],
mode: FlagOp = FlagOp.REPLACE) \
-> Tuple[Iterable[Tuple[int, MessageInterface]], SelectedMailbox] | Update the flags for the given set of messages.
See Also:
`RFC 3501 6.4.6.
<https://tools.ietf.org/html/rfc3501#section-6.4.6>`_
Args:
selected: The selected mailbox session.
sequence_set: Sequence set of message sequences or UIDs.
flag_set: ... | 69,181.007813 | 904,429.125 | 0.076491 | 154,604 |
raise NotImplementedError | def set_header_info(self, r_free, r_work, resolution, title,
deposition_date, release_date, experimental_methods) | Sets the header information.
:param r_free: the measured R-Free for the structure
:param r_work: the measure R-Work for the structure
:param resolution: the resolution of the structure
:param title: the title of the structure
:param deposition_date: the deposition date of the str... | 544.612793 | 7,056.354492 | 0.07718 | 127,106 |
pass | def start_instance(self, key_name, public_key_path, private_key_path,
security_group, flavor, image_id, image_userdata,
username=None, node_name=None) | Starts a new instance on the cloud using the given properties.
Multiple instances might be started in different threads at the same
time. The implementation should handle any problems regarding this
itself.
:param str key_name: name of the ssh key to connect
:param str public_ke... | 6,482.572266 | 77,491.765625 | 0.083655 | 385,855 |
raise NotImplementedError | def expect_column_values_to_be_of_type(
self,
column,
type_,
mostly=None,
result_format=None, include_config=False, catch_exceptions=None, meta=None
) | Expect each column entry to be a specified data type.
expect_column_values_to_be_of_type is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
type\_ (str): \
... | 717.6203 | 8,260.705078 | 0.086872 | 258,400 |
raise NotImplementedError | def expect_column_values_to_be_in_type_list(
self,
column,
type_list,
mostly=None,
result_format=None, include_config=False, catch_exceptions=None, meta=None
) | Expect each column entry to match a list of specified data types.
expect_column_values_to_be_in_type_list is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
type_list... | 692.396484 | 7,952.368164 | 0.087068 | 258,401 |
raise NotImplementedError | def expect_multicolumn_values_to_be_unique(self,
column_list,
ignore_row_if="all_values_are_missing",
result_format=None, include_config=False, catch_exceptions=None, meta=None
... | Expect the values for each row to be unique across the columns listed.
Args:
column_list (tuple or list): The first column name
Keyword Args:
ignore_row_if (str): "all_values_are_missing", "any_value_is_missing", "never"
Other Parameters:
result_format (str... | 1,844.891724 | 20,401.927734 | 0.090427 | 258,419 |
def _read(self, directory, filename, session, path, name, extension, spatial, spatialReferenceID, replaceParamFile) | Private file object read method. Classes that inherit from this base class must implement this method.
The ``read()`` method that each file object inherits from this base class performs the processes common to all
file read methods, after which it calls the file object's ``_read()`` (the preceding unde... | 55,405.910156 | 610,800.125 | 0.09071 | 234,062 | |
raise NotImplementedError() | def draw_path(self, data, coordinates, pathcodes, style,
offset=None, offset_coordinates="data", mplobj=None) | Draw a path.
In matplotlib, paths are created by filled regions, histograms,
contour plots, patches, etc.
Parameters
----------
data : array_like
A shape (N, 2) array of datapoints.
coordinates : string
A string code, which should be either 'data... | 123.2939 | 1,334.936646 | 0.092359 | 139,467 |
raise NotImplementedError | def move(self, session, source_space, source_offset, source_width, destination_space,
destination_offset, destination_width, length) | Moves a block of data.
Corresponds to viMove function of the VISA library.
:param session: Unique logical identifier to a session.
:param source_space: Specifies the address space of the source.
:param source_offset: Offset of the starting address or register from which to read.
... | 349.256592 | 3,741.341553 | 0.093351 | 276,778 |
return chain([x], xs) | def prepend(x: T, xs: Iterable[T]) -> Iterator[T] | Prepend a value to an iterable.
Parameters
----------
x
An element of type T.
xs
An iterable of elements of type T.
Returns
-------
Iterator
An iterator that yields *x* followed by elements of *xs*.
Examples
--------
>>> from delphi.utils.fp import pre... | 9.201097 | 97.896278 | 0.093988 | 24,958 |
raise NotImplementedError | def log(
self, revrange=None, limit=None, firstparent=False, merges=None,
path=None, follow=False
) | Get commit logs
:param revrange: Either a single revision or a range of revisions as a
2-element list or tuple.
:param int limit: Limit the number of log entries.
:param bool firstparent: Only follow the first parent of merges.
:param bool merges: True means onl... | 1,329.300415 | 14,012.62793 | 0.094864 | 344,624 |
raise NotImplementedError | def set_atom_info(self, atom_name, serial_number, alternative_location_id,
x, y, z, occupancy, temperature_factor, element, charge) | Create an atom object an set the information.
:param atom_name: the atom name, e.g. CA for this atom
:param serial_number: the serial id of the atom (e.g. 1)
:param alternative_location_id: the alternative location id for the atom, if present
:param x: the x coordiante of the atom
... | 193.778091 | 1,993.160645 | 0.097222 | 127,104 |
return default | def get_flag_value(self, name, default): # pylint: disable=invalid-name
value = self.__getattr__(name)
if value is not None: # Can't do if not value, b/c value might be '0' or ""
return value
else | Returns the value of a flag (if not None) or a default value.
Args:
name: str, the name of a flag.
default: Default value to use if the flag value is None.
Returns:
Requested flag value or default. | 279.951752 | 2,826.536377 | 0.099044 | 256,116 |
return all(equal)
return equal | def equal(self, value_a, value_b): #pylint: disable=no-self-use
equal = value_a == value_b
if hasattr(equal, '__iter__') | Check if two valid Property values are equal
.. note::
This method assumes that :code:`None` and
:code:`properties.undefined` are never passed in as values | 14.475471 | 140.182343 | 0.103262 | 25,565 |
pass | def update_product(AcceptLanguage=None, Id=None, Name=None, Owner=None, Description=None, Distributor=None, SupportDescription=None, SupportEmail=None, SupportUrl=None, AddTags=None, RemoveTags=None) | Updates an existing product.
See also: AWS API Documentation
:example: response = client.update_product(
AcceptLanguage='string',
Id='string',
Name='string',
Owner='string',
Description='string',
Distributor='string',
SupportDescription='string',... | 74,581.617188 | 696,339.25 | 0.107105 | 129,882 |
raise NotImplementedError | def expect_column_values_to_be_decreasing(self,
column,
strictly=None,
parse_strings_as_datetimes=None,
mostly=None,
... | Expect column values to be decreasing.
By default, this expectation only works for numeric or datetime data.
When `parse_strings_as_datetimes=True`, it can also parse strings to datetimes.
If `strictly=True`, then this expectation is only satisfied if each consecutive value
is strictly... | 2,359.071045 | 21,831.972656 | 0.108056 | 258,404 |
raise NotImplementedError | def expect_column_mean_to_be_between(self,
column,
min_value=None,
max_value=None,
result_format=None, include_config=False, catch_exceptions=None, meta=Non... | Expect the column mean to be between a minimum value and a maximum value (inclusive).
expect_column_mean_to_be_between is a :func:`column_aggregate_expectation <great_expectations.data_asset.dataset.Dataset.column_aggregate_expectation>`.
Args:
column (str): \
The column na... | 2,126.948486 | 19,663.164063 | 0.108169 | 258,413 |
raise NotImplementedError() | def bootstrap(
self, controller_name, region=None, agent_version=None,
auto_upgrade=False, bootstrap_constraints=None,
bootstrap_series=None, config=None, constraints=None,
credential=None, default_model=None, keep_broken=False,
metadata_source=None, no_gui=Fa... | Initialize a cloud environment.
:param str controller_name: Name of controller to create
:param str region: Cloud region in which to bootstrap
:param str agent_version: Version of tools to use for Juju agents
:param bool auto_upgrade: Upgrade to latest path release tools on first
... | 109.203484 | 997.911377 | 0.109432 | 158,772 |
raise NotImplementedError | def expect_table_row_count_to_be_between(self,
min_value=0,
max_value=None,
result_format=None, include_config=False, catch_exceptions=None, meta=None
... | Expect the number of rows to be between two values.
expect_table_row_count_to_be_between is a :func:`expectation <great_expectations.data_asset.dataset.Dataset.expectation>`, \
not a `column_map_expectation` or `column_aggregate_expectation`.
Keyword Args:
min_value (int or None): ... | 3,696.635986 | 33,710.601563 | 0.109658 | 258,399 |
raise NotImplementedError | def expect_column_most_common_value_to_be_in_set(self,
column,
value_set,
ties_okay=None,
result_format=None... | Expect the most common value to be within the designated value set
expect_column_most_common_value_to_be_in_set is a :func:`column_aggregate_expectation <great_expectations.data_asset.dataset.Dataset.column_aggregate_expectation>`.
Args:
column (str): \
The column name
... | 1,311.018799 | 11,803.147461 | 0.111074 | 258,414 |
raise NotImplementedError() | def compile(self, ctx, args, dependency_classpath, upstream_analysis,
settings, compiler_option_sets, zinc_file_manager,
javac_plugin_map, scalac_plugin_map) | Invoke the compiler.
Subclasses must implement. Must raise TaskError on compile failure.
:param CompileContext ctx: A CompileContext for the target to compile.
:param list args: Arguments to the compiler (such as javac or zinc).
:param list dependency_classpath: List of classpath entries of type Class... | 256.899292 | 2,240.695068 | 0.114652 | 327,776 |
raise NotImplementedError | def search(self, query: Optional[dict] = None,
offset: int = 0,
limit: Optional[int] = None,
order_by: Optional[tuple] = None,
secure: bool = False) -> List[IModel] | Search for models
Filtering is done through ``rulez`` based JSON/dict query, which
defines boolean statements in JSON/dict structure.
: param query: Rulez based query
: param offset: Result offset
: param limit: Maximum number of result
: param order_by: Tuple of ``(fie... | 816.153748 | 7,110.66748 | 0.114779 | 42,153 |
pass | def validate(cls, full_config: typing.Dict[str, typing.Any]) -> typing.Optional[typing.Dict[str, typing.Any]] | Validate and parse config.
This method will be called by the filters factory when you bind this filter.
Must be overridden.
:param full_config: dict with arguments passed to handler registrar
:return: Current filter config | 13,173.957031 | 114,005.617188 | 0.115555 | 262,203 |
async def resolve(self, host: str,
port: int, family: int) -> List[Dict[str, Any]] | Return IP address for given hostname | 69,030.75 | 594,727.375 | 0.116071 | 99,915 | |
... | async def fetch_messages(self, selected: SelectedMailbox,
sequence_set: SequenceSet,
attributes: FrozenSet[FetchAttribute]) \
-> Tuple[Iterable[Tuple[int, MessageInterface]], SelectedMailbox] | Get a list of loaded message objects corresponding to given sequence
set.
Args:
selected: The selected mailbox session.
sequence_set: Sequence set of message sequences or UIDs.
attributes: Fetch attributes for the messages.
Raises:
:class:`~pymap... | 53,048.03125 | 439,669.75 | 0.120654 | 154,601 |
pass | def init_states(self,
source_encoded: mx.sym.Symbol,
source_encoded_lengths: mx.sym.Symbol,
source_encoded_max_length: int) -> List[mx.sym.Symbol] | Returns a list of symbolic states that represent the initial states of this decoder.
Used for inference.
:param source_encoded: Encoded source. Shape: (batch_size, source_encoded_max_length, encoder_depth).
:param source_encoded_lengths: Lengths of encoded source sequences. Shape: (batch_size,)... | 22,452.630859 | 183,224.125 | 0.122542 | 325,268 |
raise NotImplementedError | def send(self, request, stream=False, timeout=None, verify=True,
cert=None, proxies=None) | Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up... | 1,139.674438 | 9,010.757813 | 0.126479 | 96,421 |
raise NotImplementedError | def show_stat_base(count_value, max_count_value, prepend, speed, tet, ttg, width, **kwargs) | A function that formats the progress information
This function will be called periodically for each progress that is monitored.
Overwrite this function in a subclass to implement a specific formating of the progress information
:param count_value: a number holding the current state
:param max_cou... | 846.220825 | 6,561.044922 | 0.128977 | 73,666 |
return epoch + datetime.timedelta(n) | def datetime_from_timestamp(n, epoch=datetime.datetime.fromordinal(693594)) | Return datetime object from timestamp in Excel serial format.
Examples
--------
>>> datetime_from_timestamp(40237.029999999795)
datetime.datetime(2010, 2, 28, 0, 43, 11, 999982) | 5.605204 | 43.017445 | 0.130301 | 353,260 |
raise NotImplementedError | def ping(self, destination, source=c.PING_SOURCE, ttl=c.PING_TTL, timeout=c.PING_TIMEOUT,
size=c.PING_SIZE, count=c.PING_COUNT, vrf=c.PING_VRF) | Executes ping on the device and returns a dictionary with the result
:param destination: Host or IP Address of the destination
:param source (optional): Source address of echo request
:param ttl (optional): Maximum number of hops
:param timeout (optional): Maximum seconds to wait after ... | 768.502625 | 5,844.904785 | 0.131482 | 129,849 |
raise NotImplementedError | def pad_token_sequence(self,
tokens: Dict[str, List[TokenType]],
desired_num_tokens: Dict[str, int],
padding_lengths: Dict[str, int]) -> Dict[str, List[TokenType]] | This method pads a list of tokens to ``desired_num_tokens`` and returns a padded copy of the
input tokens. If the input token list is longer than ``desired_num_tokens`` then it will be
truncated.
``padding_lengths`` is used to provide supplemental padding parameters which are needed
in... | 650.777649 | 4,826.189453 | 0.134843 | 93,663 |
def get_by_path(self, paths: Union[str, Iterable[str]], load_metadata: bool=True) \
-> Union[EntityType, Sequence[EntityType]] | Gets the entity or entities with the given path or paths from iRODS.
If one or more of the entities does not exist, a `FileNotFound` exception will be raised.
:param paths: the paths of the entities to get from iRODS
:param load_metadata: whether metadata associated to the entities should be lo... | 32,622.931641 | 236,035.734375 | 0.138212 | 208,614 | |
raise NotImplementedError() | def debug_log(
self, no_tail=False, exclude_module=None, include_module=None,
include=None, level=None, limit=0, lines=10, replay=False,
exclude=None) | Get log messages for this model.
:param bool no_tail: Stop after returning existing log messages
:param list exclude_module: Do not show log messages for these logging
modules
:param list include_module: Only show log messages for these logging
modules
:param lis... | 262.521271 | 1,803.283569 | 0.14558 | 158,567 |
... | async def apply(self, sender: str, recipient: str, mailbox: str,
append_msg: AppendMessage) \
-> Tuple[Optional[str], AppendMessage] | Run the filter and return the mailbox where it should be appended,
or None to discard, and the message to be appended, which is usually
the same as ``append_msg``.
Args:
sender: The envelope sender of the message.
recipient: The envelope recipient of the message.
... | 37,842.035156 | 256,599.234375 | 0.147475 | 154,594 |
pass | def _convert(self, desired_type: Type[T], source_obj: S, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T | Implementing classes should implement this method to perform the conversion itself
:param desired_type: the destination type of the conversion
:param source_obj: the source object that should be converter
:param logger: a logger to use if any is available, or None
:param options: additi... | 96,397.210938 | 649,434.1875 | 0.148433 | 343,499 |
... | async def append_messages(self, name: str,
messages: Sequence[AppendMessage],
selected: SelectedMailbox = None) \
-> Tuple[AppendUid, Optional[SelectedMailbox]] | Appends a message to the end of the mailbox.
See Also:
`RFC 3502 6.3.11.
<https://tools.ietf.org/html/rfc3502#section-6.3.11>`_
Args:
name: The name of the mailbox.
messages: The messages to append.
selected: If applicable, the currently sele... | 82,348.070313 | 549,812.125 | 0.149775 | 154,598 |
raise NotImplementedError | def expect_column_values_to_match_json_schema(self,
column,
json_schema,
mostly=None,
result_format=None, include_config... | Expect column entries to be JSON objects matching a given JSON schema.
expect_column_values_to_match_json_schema is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
Keywo... | 1,195.238525 | 7,953.141602 | 0.150285 | 258,412 |
return clusters
else:
return list(clusters) | def match(self, messy_data, threshold=0.5, n_matches=1, generator=False): # pragma: no cover
blocked_pairs = self._blockData(messy_data)
clusters = self.matchBlocks(blocked_pairs, threshold, n_matches)
clusters = (cluster for cluster in clusters if len(cluster))
if generator | Identifies pairs of records that refer to the same entity, returns
tuples containing a set of record ids and a confidence score as a float
between 0 and 1. The record_ids within each set should refer to the
same entity and the confidence score is the estimated probability that
the record... | 14.712981 | 97.465431 | 0.150956 | 255,532 |
for series in seriesList:
series.options['lineWidth'] = width
return seriesList | def lineWidth(requestContext, seriesList, width) | Takes one metric or a wildcard seriesList, followed by a float F.
Draw the selected metrics with a line width of F, overriding the default
value of 1, or the &lineWidth=X.X parameter.
Useful for highlighting a single metric out of many, or having multiple
line widths in one graph.
Example::
... | 3.541772 | 22.88199 | 0.154784 | 3,697 |
def act_on_cloned_repo(self, path: Union[str, pathlib.Path],
api) -> Optional[HookResult] | Do something with a cloned repo.
Args:
path: Path to the repo.
api: An instance of :py:class:`repobee.github_api.GitHubAPI`.
Returns:
optionally returns a HookResult namedtuple for reporting the
outcome of the hook. May also return None, in which case no... | 41,678.753906 | 269,053 | 0.154909 | 20,252 | |
raise NotImplementedError | def expect_column_values_to_match_regex(self,
column,
regex,
mostly=None,
result_format=None, include_config=False, catch_exceptions=None, meta=... | Expect column entries to be strings that match a given regular expression. Valid matches can be found \
anywhere in the string, for example "[at]+" will identify the following strings as expected: "cat", "hat", \
"aa", "a", and "t", and the following strings as unexpected: "fish", "dog".
expect... | 1,895.895752 | 12,147.418945 | 0.156074 | 258,407 |
raise NotImplementedError | def set_group_info(self, group_name, group_number, insertion_code,
group_type, atom_count, bond_count, single_letter_code,
sequence_index, secondary_structure_type) | Set the information for a group
:param group_name: the name of this group,e.g. LYS
:param group_number: the residue number of this group
:param insertion_code: the insertion code for this group
:param group_type: a string indicating the type of group (as found in the chemcomp dictionary.... | 290.753479 | 1,836.647217 | 0.158307 | 127,105 |
pass | def describe_reserved_db_instances(ReservedDBInstanceId=None, ReservedDBInstancesOfferingId=None, DBInstanceClass=None, Duration=None, ProductDescription=None, OfferingType=None, MultiAZ=None, Filters=None, MaxRecords=None, Marker=None) | Returns information about reserved DB instances for this account, or about a specified reserved DB instance.
See also: AWS API Documentation
Examples
This example lists information for all reserved DB instances for the specified DB instance class, duration, product, offering type, and availability zone... | 64,889.835938 | 409,362.96875 | 0.158514 | 129,884 |
pass | def modify_image_attribute(DryRun=None, ImageId=None, Attribute=None, OperationType=None, UserIds=None, UserGroups=None, ProductCodes=None, Value=None, LaunchPermission=None, Description=None) | Modifies the specified attribute of the specified AMI. You can specify only one attribute at a time.
See also: AWS API Documentation
:example: response = client.modify_image_attribute(
DryRun=True|False,
ImageId='string',
Attribute='string',
OperationType='add'|'remove'... | 44,382.585938 | 271,414.65625 | 0.163523 | 129,875 |
pass | def create_authorizer(restApiId=None, name=None, type=None, providerARNs=None, authType=None, authorizerUri=None, authorizerCredentials=None, identitySource=None, identityValidationExpression=None, authorizerResultTtlInSeconds=None) | Adds a new Authorizer resource to an existing RestApi resource.
See also: AWS API Documentation
:example: response = client.create_authorizer(
restApiId='string',
name='string',
type='TOKEN'|'COGNITO_USER_POOLS',
providerARNs=[
'string',
],
... | 6,663.012695 | 40,229.082031 | 0.165627 | 129,868 |
with self.__listeners_change_condition:
self.listeners[name] = listener | def set_listener(self, name, listener) | Set a named listener to use with this connection.
See :py:class:`stomp.listener.ConnectionListener`
:param str name: the name of the listener
:param ConnectionListener listener: the listener object | 9.302919 | 56.159794 | 0.165651 | 379,682 |
raise NotImplementedError | def expect_column_values_to_match_regex_list(self,
column,
regex_list,
match_on="any",
mostly=None,
... | Expect the column entries to be strings that can be matched to either any of or all of a list of regular expressions.
Matches can be anywhere in the string.
expect_column_values_to_match_regex_list is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>... | 2,596.597168 | 15,613.920898 | 0.1663 | 258,408 |
return sys.modules.get(name) | def get_module(name: str) -> typing.Union[types.ModuleType, None] | Retrieves the loaded module for the given module name or returns None if
no such module has been loaded.
:param name:
The name of the module to be retrieved
:return:
Either the loaded module with the specified name, or None if no such
module has been imported. | 5.505513 | 33.082333 | 0.166419 | 43,420 |
raise NotImplementedError | def spawn_shell(self, context_file, tmpdir, rcfile=None, norc=False,
stdin=False, command=None, env=None, quiet=False,
pre_command=None, add_rez=True,
package_commands_sourced_first=None, **Popen_args) | Spawn a possibly interactive subshell.
Args:
context:_file File that must be sourced in the new shell, this
configures the Rez environment.
tmpdir: Tempfiles, if needed, should be created within this path.
rcfile: Custom startup script.
norc: Don't... | 708.300659 | 4,195.678223 | 0.168817 | 274,620 |
return clusters
else:
return list(clusters) | def match(self, data_1, data_2, threshold=0.5, generator=False): # pragma: no cover
blocked_pairs = self._blockData(data_1, data_2)
clusters = self.matchBlocks(blocked_pairs, threshold)
if generator | Identifies pairs of records that refer to the same entity, returns
tuples containing a set of record ids and a confidence score as a float
between 0 and 1. The record_ids within each set should refer to the
same entity and the confidence score is the estimated probability that
the record... | 16.133535 | 94.208672 | 0.171253 | 255,522 |
return clusters
else:
return list(clusters) | def match(self, data, threshold=0.5, generator=False): # pragma: no cover
blocked_pairs = self._blockData(data)
clusters = self.matchBlocks(blocked_pairs, threshold)
if generator | Identifies records that all refer to the same entity, returns
tuples
containing a set of record ids and a confidence score as a
float between 0 and 1. The record_ids within each set should
refer to the same entity and the confidence score is a measure
of our confidence that all ... | 17.807142 | 103.822197 | 0.171516 | 255,519 |
_main(**locals()) | def main(config, host, port, logfile, debug, daemon, uid, gid, pidfile, umask, rundir) | Main entry point for running a socket server from the commandline.
This method will read in options from the commandline and call the L{config.init_config} method
to get everything setup. Then, depending on whether deamon mode was specified or not,
the process may be forked (or not) and the server will b... | 50.74435 | 293.555969 | 0.172861 | 39,503 |
... | async def get_mailbox(self, name: str, selected: SelectedMailbox = None) \
-> Tuple[MailboxInterface, Optional[SelectedMailbox]] | Retrieves a :class:`~pymap.interfaces.mailbox.MailboxInterface`
object corresponding to an existing mailbox owned by the user. Raises
an exception if the mailbox does not yet exist.
Args:
name: The name of the mailbox.
selected: If applicable, the currently selected mail... | 32,817.304688 | 185,693.578125 | 0.176728 | 154,596 |
return observable | def get_hist(self, observable: Any, **kwargs: Dict[str, Any]) -> Any | Get the histogram that may be stored in some object.
This histogram is used to project from.
Note:
The output object could just be the raw ROOT histogram.
Note:
This function is just a basic placeholder and likely should be overridden.
Args:
observ... | 3,512.919678 | 19,226.46875 | 0.182713 | 253,476 |
... | async def copy_messages(self, selected: SelectedMailbox,
sequence_set: SequenceSet,
mailbox: str) \
-> Tuple[Optional[CopyUid], SelectedMailbox] | Copy a set of messages into the given mailbox.
See Also:
`RFC 3501 6.4.7.
<https://tools.ietf.org/html/rfc3501#section-6.4.7>`_
Args:
selected: The selected mailbox session.
sequence_set: Sequence set of message sequences or UIDs.
mailbox: Na... | 120,500.195313 | 654,181.375 | 0.1842 | 154,603 |
return boolbox(msg, title, choices, image=image) | def ccbox(msg="Shall I continue?"
, title=" "
, choices=("Continue", "Cancel")
, image=None
) | Display a msgbox with choices of Continue and Cancel.
The default is "Continue".
The returned value is calculated this way::
if the first choice ("Continue") is chosen, or if the dialog is cancelled:
return 1
else:
return 0
If invoked without a msg argument, displa... | 5.088627 | 27.262482 | 0.186653 | 390,248 |
raise NotImplementedError | def get_changesets(self, start=None, end=None, start_date=None,
end_date=None, branch_name=None, reverse=False) | Returns iterator of ``MercurialChangeset`` objects from start to end
not inclusive This should behave just like a list, ie. end is not
inclusive
:param start: None or str
:param end: None or str
:param start_date:
:param end_date:
:param branch_name:
:par... | 686.450256 | 3,672.243896 | 0.186929 | 361,976 |
return schedule_at(time.time() + secs, target, args, kwargs) | def schedule_in(secs, target=None, args=(), kwargs=None) | insert a greenlet into the scheduler to run after a set time
If provided a function, it is wrapped in a new greenlet
:param secs: the number of seconds to wait before running the target
:type unixtime: int or float
:param target: what to schedule
:type target: function or greenlet
:param args:... | 3.645199 | 19.403128 | 0.187867 | 237,547 |
return boolbox(msg, title, choices, image=image) | def ynbox(msg="Shall I continue?"
, title=" "
, choices=("Yes", "No")
, image=None
) | Display a msgbox with choices of Yes and No.
The default is "Yes".
The returned value is calculated this way::
if the first choice ("Yes") is chosen, or if the dialog is cancelled:
return 1
else:
return 0
If invoked without a msg argument, displays a generic reques... | 5.305628 | 27.891972 | 0.190221 | 390,247 |
return output_hist | def output_hist(self, output_hist: Hist, input_observable: Any, **kwargs: Dict[str, Any]) -> Union[Hist, Any] | Return an output object. It should store the ``output_hist``.
Note:
The output object could just be the raw histogram.
Note:
This function is just a basic placeholder which returns the given output object (a histogram)
and likely should be overridden.
Args:... | 34.377708 | 180.207672 | 0.190767 | 253,478 |
return bool(_egg_info_re.search(s)) | def _contains_egg_info(
s, _egg_info_re=re.compile(r'([a-z0-9_.]+)-([a-z0-9_.!+-]+)', re.I)) | Determine whether the string looks like an egg_info.
:param s: The string to parse. E.g. foo-2.1 | 3.064325 | 15.962599 | 0.191969 | 96,491 |
raise NotImplementedError | def map_address(self, session, map_space, map_base, map_size,
access=False, suggested=None) | Maps the specified memory space into the process's address space.
Corresponds to viMapAddress function of the VISA library.
:param session: Unique logical identifier to a session.
:param map_space: Specifies the address space to map. (Constants.*SPACE*)
:param map_base: Offset (in byte... | 517.143127 | 2,687.061523 | 0.192457 | 276,777 |
def get_by_metadata(self, metadata_search_criteria: Union[SearchCriterion, Iterable[SearchCriterion]],
load_metadata: bool=True, zone: str=None) -> Sequence[EntityType] | Gets entities from iRODS that have metadata that matches the given search criteria.
:param metadata_search_criteria: the metadata search criteria
:param load_metadata: whether metadata associated to the entities should be loaded
:param zone: limit query to specific zone in iRODS
:return:... | 29,052.511719 | 150,910.796875 | 0.192514 | 208,613 |
- Downloads last month
- 6