Dataset Viewer
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 persisted object that should be parsed
:param logger: an optional logger to log all parsing plan creation and execution information
:param options: a dictionary additional implementation-specific parameters (one dict per parser id).
Implementing classes may use 'self._get_applicable_options()' to get the options that are of interest for this
parser.
:return: | 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,
uplinkDelayMs=123,
downlinkDelayMs=123,
uplinkJitterMs=123,
downlinkJitterMs=123,
uplinkLossPercent=123,
downlinkLossPercent=123
)
:type projectArn: string
:param projectArn: [REQUIRED]
The Amazon Resource Name (ARN) of the project for which you want to create a network profile.
:type name: string
:param name: [REQUIRED]
The name you wish to specify for the new network profile.
:type description: string
:param description: The description of the network profile.
:type type: string
:param type: The type of network profile you wish to create. Valid values are listed below.
:type uplinkBandwidthBits: integer
:param uplinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
:type downlinkBandwidthBits: integer
:param downlinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
:type uplinkDelayMs: integer
:param uplinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
:type downlinkDelayMs: integer
:param downlinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
:type uplinkJitterMs: integer
:param uplinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
:type downlinkJitterMs: integer
:param downlinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
:type uplinkLossPercent: integer
:param uplinkLossPercent: Proportion of transmitted packets that fail to arrive from 0 to 100 percent.
:type downlinkLossPercent: integer
:param downlinkLossPercent: Proportion of received packets that fail to arrive from 0 to 100 percent.
:rtype: dict
:return: {
'networkProfile': {
'arn': 'string',
'name': 'string',
'description': 'string',
'type': 'CURATED'|'PRIVATE',
'uplinkBandwidthBits': 123,
'downlinkBandwidthBits': 123,
'uplinkDelayMs': 123,
'downlinkDelayMs': 123,
'uplinkJitterMs': 123,
'downlinkJitterMs': 123,
'uplinkLossPercent': 123,
'downlinkLossPercent': 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.
changelog: List of strings describing changes since last release.
previous_version: Version object - previously-release package, or
None if no previous release.
previous_revision: Revision of previously-released package (type
depends on repo - see ReleaseVCS.get_current_revision().
kwargs: Reserved.
Note:
This method should raise a `ReleaseHookCancellingError` if the
release process should be cancelled. | 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: Offset (in bytes) of the address or register from which to read.
:param length: Number of elements to transfer, where the data width of the elements to transfer
is identical to the source data width.
:param data: Data to write to bus.
:param extended: Use 64 bits offset independent of the platform.
:return: return value of the library call.
:rtype: :class:`pyvisa.constants.StatusCode`
Corresponds to viMoveOut8 function of the VISA library. | 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: 返回数据字段
========================= ===================================================
fields 字段名
========================= ===================================================
datetime 时间戳
open 开盘价
high 最高价
low 最低价
close 收盘价
volume 成交量
total_turnover 成交额
datetime int类型时间戳
open_interest 持仓量（期货专用）
basis_spread 期现差（股指期货专用）
settlement 结算价（期货日线专用）
prev_settlement 结算价（期货日线专用）
========================= ===================================================
:param datetime.datetime dt: 时间
:param bool skip_suspended: 是否跳过停牌日
:param bool include_now: 是否包含当天最新数据
:param str adjust_type: 复权类型，'pre', 'none', 'post'
:param datetime.datetime adjust_orig: 复权起点；
:return: `numpy.ndarray` | 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.
<https://tools.ietf.org/html/rfc3501#section-6.3.2>`_
Args:
name: The name of the mailbox.
readonly: True if the mailbox is read-only.
Raises:
:class:`~pymap.exceptions.MailboxNotFound` | 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:
txn_signature (str): The signature of the transaction, which
must match the header_signature field of the Transaction
object which was part of the added Batch.
is_valid (bool): True if transaction applied successfully or False
if the transaction failed and was not applied.
context_id (str): If status is True, contains the context_id
associated with the state changes made by the transaction.
If status is False, this should be set to None.
Raises:
ValueError: Thrown if transaction_signature does not match a
transaction. | 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 Documentation
:example: response = client.create_nfs_file_share(
ClientToken='string',
NFSFileShareDefaults={
'FileMode': 'string',
'DirectoryMode': 'string',
'GroupId': 123,
'OwnerId': 123
},
GatewayARN='string',
KMSEncrypted=True|False,
KMSKey='string',
Role='string',
LocationARN='string',
DefaultStorageClass='string',
ClientList=[
'string',
],
Squash='string',
ReadOnly=True|False
)
:type ClientToken: string
:param ClientToken: [REQUIRED]
A unique string value that you supply that is used by file gateway to ensure idempotent file share creation.
:type NFSFileShareDefaults: dict
:param NFSFileShareDefaults: File share default values. Optional.
FileMode (string) --The Unix file mode in the form 'nnnn'. For example, '0666' represents the default file mode inside the file share. The default value is 0666.
DirectoryMode (string) --The Unix directory mode in the form 'nnnn'. For example, '0666' represents the default access mode for all directories inside the file share. The default value is 0777.
GroupId (integer) --The default group ID for the file share (unless the files have another group ID specified). The default value is nfsnobody.
OwnerId (integer) --The default owner ID for files in the file share (unless the files have another owner ID specified). The default value is nfsnobody.
:type GatewayARN: string
:param GatewayARN: [REQUIRED]
The Amazon Resource Name (ARN) of the file gateway on which you want to create a file share.
:type KMSEncrypted: boolean
:param KMSEncrypted: True to use Amazon S3 server side encryption with your own AWS KMS key, or false to use a key managed by Amazon S3. Optional.
:type KMSKey: string
:param KMSKey: The KMS key used for Amazon S3 server side encryption. This value can only be set when KmsEncrypted is true. Optional.
:type Role: string
:param Role: [REQUIRED]
The ARN of the AWS Identity and Access Management (IAM) role that a file gateway assumes when it accesses the underlying storage.
:type LocationARN: string
:param LocationARN: [REQUIRED]
The ARN of the backed storage used for storing file data.
:type DefaultStorageClass: string
:param DefaultStorageClass: The default storage class for objects put into an Amazon S3 bucket by file gateway. Possible values are S3_STANDARD or S3_STANDARD_IA. If this field is not populated, the default value S3_STANDARD is used. Optional.
:type ClientList: list
:param ClientList: The list of clients that are allowed to access the file gateway. The list must contain either valid IP addresses or valid CIDR blocks.
(string) --
:type Squash: string
:param Squash: Maps a user to anonymous user. Valid options are the following:
'RootSquash' - Only root is mapped to anonymous user.
'NoSquash' - No one is mapped to anonymous user.
'AllSquash' - Everyone is mapped to anonymous user.
:type ReadOnly: boolean
:param ReadOnly: Sets the write status of a file share: 'true' if the write status is read-only, and otherwise 'false'.
:rtype: dict
:return: {
'FileShareARN': 'string'
} | 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',
VersionLabel='string',
TemplateName='string',
EnvironmentId='string',
EnvironmentName='string',
PlatformArn='string',
RequestId='string',
Severity='TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR'|'FATAL',
StartTime=datetime(2015, 1, 1),
EndTime=datetime(2015, 1, 1),
MaxRecords=123,
NextToken='string'
)
:type ApplicationName: string
:param ApplicationName: If specified, AWS Elastic Beanstalk restricts the returned descriptions to include only those associated with this application.
:type VersionLabel: string
:param VersionLabel: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those associated with this application version.
:type TemplateName: string
:param TemplateName: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those that are associated with this environment configuration.
:type EnvironmentId: string
:param EnvironmentId: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those associated with this environment.
:type EnvironmentName: string
:param EnvironmentName: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those associated with this environment.
:type PlatformArn: string
:param PlatformArn: The ARN of the version of the custom platform.
:type RequestId: string
:param RequestId: If specified, AWS Elastic Beanstalk restricts the described events to include only those associated with this request ID.
:type Severity: string
:param Severity: If specified, limits the events returned from this call to include only those with the specified severity or higher.
:type StartTime: datetime
:param StartTime: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those that occur on or after this time.
:type EndTime: datetime
:param EndTime: If specified, AWS Elastic Beanstalk restricts the returned descriptions to those that occur up to, but not including, the EndTime .
:type MaxRecords: integer
:param MaxRecords: Specifies the maximum number of events that can be returned, beginning with the most recent event.
:type NextToken: string
:param NextToken: Pagination token. If specified, the events return the next batch of results.
:rtype: dict
:return: {
'Events': [
{
'EventDate': datetime(2015, 1, 1),
'Message': 'string',
'ApplicationName': 'string',
'VersionLabel': 'string',
'TemplateName': 'string',
'EnvironmentName': 'string',
'PlatformArn': 'string',
'RequestId': 'string',
'Severity': 'TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR'|'FATAL'
},
],
'NextToken': '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,
parse_strings_as_datetimes=None,
output_strftime_format=None,
mostly=None,
result_format=None, include_config=False, catch_exceptions=None, meta=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.
min_value (comparable type or None): The minimum value for a column entry.
max_value (comparable type or None): The maximum value for a column entry.
Keyword Args:
allow_cross_type_comparisons (boolean or None) : If True, allow comparisons between types (e.g. integer and\
string). Otherwise, attempting such comparisons will raise an exception.
parse_strings_as_datetimes (boolean or None) : If True, parse min_value, max_value, and all non-null column\
values to datetimes before making comparisons.
output_strftime_format (str or None): \
A valid strfime format for datetime output. Only used if parse_strings_as_datetimes=True.
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
* min_value and max_value are both inclusive.
* If min_value is None, then max_value is treated as an upper bound, and the number of acceptable rows has no minimum.
* If max_value is None, then min_value is treated as a lower bound, and the number of acceptable rows has no maximum.
See Also:
expect_column_value_lengths_to_be_between | 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_name -- A pywbem.CIMInstanceName that defines the source
CIM Object whose associated Objects are to be returned.
model -- A template pywbem.CIMInstance to serve as a model
of the objects to be returned. Only properties present on this
model need to be set.
assoc_class -- The pywbem.CIMClass.
result_class_name -- If not empty, this string acts as a filter on
the returned set of Instances by mandating that each returned
Instances MUST represent an association between object_name
and an Instance of a Class whose name matches this parameter
or a subclass.
role -- If not empty, MUST be a valid Property name. It acts as a
filter on the returned set of Instances by mandating that each
returned Instance MUST refer to object_name via a Property
whose name matches the value of this parameter.
result_role -- If not empty, MUST be a valid Property name. It acts
as a filter on the returned set of Instances by mandating that
each returned Instance MUST represent associations of
object_name to other Instances, where the other Instances play
the specified result_role in the association (i.e. the
name of the Property in the Association Class that refers to
the Object related to object_name MUST match the value of this
parameter).
keys_only -- A boolean. True if only the key properties should be
set on the generated instances.
The following diagram may be helpful in understanding the role,
result_role, and result_class_name parameters.
+------------------------+ +-------------------+
| object_name.classname | | result_class_name |
| ~~~~~~~~~~~~~~~~~~~~~ | | ~~~~~~~~~~~~~~~~~ |
+------------------------+ +-------------------+
| +-----------------------------------+ |
| | [Association] assoc_class | |
| object_name | ~~~~~~~~~~~~~~~~~~~~~~~~~ | |
+--------------+ object_name.classname REF role | |
(CIMInstanceName) | result_class_name REF result_role +------+
| |(CIMInstanceName)
+-----------------------------------+
Possible Errors:
CIM_ERR_ACCESS_DENIED
CIM_ERR_NOT_SUPPORTED
CIM_ERR_INVALID_NAMESPACE
CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized
or otherwise incorrect parameters)
CIM_ERR_FAILED (some other unspecified error occurred) | 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,
parse_strings_as_datetimes=None,
allow_cross_type_comparisons=None,
ignore_row_if="both_values_are_missing",
result_format=None, include_config=False, catch_exceptions=None, meta=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_comparisons (boolean or None) : If True, allow comparisons between types (e.g. integer and\
string). Otherwise, attempting such comparisons will raise an exception.
Keyword Args:
ignore_row_if (str): "both_values_are_missing", "either_value_is_missing", "neither
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`. | 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):
identifier of the answered item or None if the user answered
"I don't know"
response_time (int)
time the answer took in milliseconds
time (datetime.datetime)
time when the user answered the question
guess (float):
probability of correct response in case of random answer | 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,
result_format=None, include_config=False, catch_exceptions=None, meta=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_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
Keyword Args:
min_value (int or None): \
The minimum value for a column entry length.
max_value (int or None): \
The maximum value for a column entry length.
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
* min_value and max_value are both inclusive.
* If min_value is None, then max_value is treated as an upper bound, and the number of acceptable rows has no minimum.
* If max_value is None, then min_value is treated as a lower bound, and the number of acceptable rows has no maximum.
See Also:
expect_column_value_lengths_to_equal | 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,
downlinkBandwidthBits=123,
uplinkDelayMs=123,
downlinkDelayMs=123,
uplinkJitterMs=123,
downlinkJitterMs=123,
uplinkLossPercent=123,
downlinkLossPercent=123
)
:type arn: string
:param arn: [REQUIRED]
The Amazon Resource Name (ARN) of the project that you wish to update network profile settings.
:type name: string
:param name: The name of the network profile about which you are returning information.
:type description: string
:param description: The descriptoin of the network profile about which you are returning information.
:type type: string
:param type: The type of network profile you wish to return information about. Valid values are listed below.
:type uplinkBandwidthBits: integer
:param uplinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
:type downlinkBandwidthBits: integer
:param downlinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
:type uplinkDelayMs: integer
:param uplinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
:type downlinkDelayMs: integer
:param downlinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
:type uplinkJitterMs: integer
:param uplinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
:type downlinkJitterMs: integer
:param downlinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
:type uplinkLossPercent: integer
:param uplinkLossPercent: Proportion of transmitted packets that fail to arrive from 0 to 100 percent.
:type downlinkLossPercent: integer
:param downlinkLossPercent: Proportion of received packets that fail to arrive from 0 to 100 percent.
:rtype: dict
:return: {
'networkProfile': {
'arn': 'string',
'name': 'string',
'description': 'string',
'type': 'CURATED'|'PRIVATE',
'uplinkBandwidthBits': 123,
'downlinkBandwidthBits': 123,
'uplinkDelayMs': 123,
'downlinkDelayMs': 123,
'uplinkJitterMs': 123,
'downlinkJitterMs': 123,
'uplinkLossPercent': 123,
'downlinkLossPercent': 123
}
} | 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(clear_span=2,
clear_qubits=op.qubits,
new_operations=cirq.Y(op.qubits[0]))
Args:
circuit: The circuit to improve.
index: The index of the moment with the operation to focus on.
op: The operation to focus improvements upon.
Returns:
A description of the optimization to perform, or else None if no
change should be made. | 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>`.
Args:
column (str): \
The column name.
regex_list (list): \
The list of regular expressions which the column entries should not match
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_match_regex_list | 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",
result_format=None, include_config=False, catch_exceptions=None, meta=None
) | 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_if (str): "both_values_are_missing", "either_value_is_missing", "never"
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`. | 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,
output_strftime_format=None,
result_format=None, include_config=False, catch_exceptions=None, meta=None
) | 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 (comparable type or None): \
The minimum number of unique values allowed.
max_value (comparable type or None): \
The maximum number of unique values allowed.
Keyword Args:
parse_strings_as_datetimes (Boolean or None): \
If True, parse min_value, max_values, and all non-null column values to datetimes before making comparisons.
output_strftime_format (str or None): \
A valid strfime format for datetime output. Only used if parse_strings_as_datetimes=True.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
These fields in the result object are customized for this expectation:
::
{
"observed_value": (list) The actual column min
}
* min_value and max_value are both inclusive.
* If min_value is None, then max_value is treated as an upper bound
* If max_value is None, then min_value is treated as a lower bound | 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',
QualificationTypeStatus='Active'|'Inactive',
RetryDelayInSeconds=123,
Test='string',
AnswerKey='string',
TestDurationInSeconds=123,
AutoGranted=True|False,
AutoGrantedValue=123
)
:type Name: string
:param Name: [REQUIRED]
The name you give to the Qualification type. The type name is used to represent the Qualification to Workers, and to find the type using a Qualification type search. It must be unique across all of your Qualification types.
:type Keywords: string
:param Keywords: One or more words or phrases that describe the Qualification type, separated by commas. The keywords of a type make the type easier to find during a search.
:type Description: string
:param Description: [REQUIRED]
A long description for the Qualification type. On the Amazon Mechanical Turk website, the long description is displayed when a Worker examines a Qualification type.
:type QualificationTypeStatus: string
:param QualificationTypeStatus: [REQUIRED]
The initial status of the Qualification type.
Constraints: Valid values are: Active | Inactive
:type RetryDelayInSeconds: integer
:param RetryDelayInSeconds: The number of seconds that a Worker must wait after requesting a Qualification of the Qualification type before the worker can retry the Qualification request.
Constraints: None. If not specified, retries are disabled and Workers can request a Qualification of this type only once, even if the Worker has not been granted the Qualification. It is not possible to disable retries for a Qualification type after it has been created with retries enabled. If you want to disable retries, you must delete existing retry-enabled Qualification type and then create a new Qualification type with retries disabled.
:type Test: string
:param Test: The questions for the Qualification test a Worker must answer correctly to obtain a Qualification of this type. If this parameter is specified, TestDurationInSeconds must also be specified.
Constraints: Must not be longer than 65535 bytes. Must be a QuestionForm data structure. This parameter cannot be specified if AutoGranted is true.
Constraints: None. If not specified, the Worker may request the Qualification without answering any questions.
:type AnswerKey: string
:param AnswerKey: The answers to the Qualification test specified in the Test parameter, in the form of an AnswerKey data structure.
Constraints: Must not be longer than 65535 bytes.
Constraints: None. If not specified, you must process Qualification requests manually.
:type TestDurationInSeconds: integer
:param TestDurationInSeconds: The number of seconds the Worker has to complete the Qualification test, starting from the time the Worker requests the Qualification.
:type AutoGranted: boolean
:param AutoGranted: Specifies whether requests for the Qualification type are granted immediately, without prompting the Worker with a Qualification test.
Constraints: If the Test parameter is specified, this parameter cannot be true.
:type AutoGrantedValue: integer
:param AutoGrantedValue: The Qualification value to use for automatically granted Qualifications. This parameter is used only if the AutoGranted parameter is true.
:rtype: dict
:return: {
'QualificationType': {
'QualificationTypeId': 'string',
'CreationTime': datetime(2015, 1, 1),
'Name': 'string',
'Description': 'string',
'Keywords': 'string',
'QualificationTypeStatus': 'Active'|'Inactive',
'Test': 'string',
'TestDurationInSeconds': 123,
'AnswerKey': 'string',
'RetryDelayInSeconds': 123,
'IsRequestable': True|False,
'AutoGranted': True|False,
'AutoGrantedValue': 123
}
} | 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 restore
:param bool upload_tools: Upload tools if bootstrapping a new machine | 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 should be loaded
:return: the entities loaded from iRODS | 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 the DescribeRecord operation.
See also: AWS API Documentation
:example: response = client.provision_product(
AcceptLanguage='string',
ProductId='string',
ProvisioningArtifactId='string',
PathId='string',
ProvisionedProductName='string',
ProvisioningParameters=[
{
'Key': 'string',
'Value': 'string'
},
],
Tags=[
{
'Key': 'string',
'Value': 'string'
},
],
NotificationArns=[
'string',
],
ProvisionToken='string'
)
:type AcceptLanguage: string
:param AcceptLanguage: The language code to use for this operation. Supported language codes are as follows:
'en' (English)
'jp' (Japanese)
'zh' (Chinese)
If no code is specified, 'en' is used as the default.
:type ProductId: string
:param ProductId: [REQUIRED]
The product identifier.
:type ProvisioningArtifactId: string
:param ProvisioningArtifactId: [REQUIRED]
The provisioning artifact identifier for this product.
:type PathId: string
:param PathId: The identifier of the path for this product's provisioning. This value is optional if the product has a default path, and is required if there is more than one path for the specified product.
:type ProvisionedProductName: string
:param ProvisionedProductName: [REQUIRED]
A user-friendly name to identify the ProvisionedProduct object. This value must be unique for the AWS account and cannot be updated after the product is provisioned.
:type ProvisioningParameters: list
:param ProvisioningParameters: Parameters specified by the administrator that are required for provisioning the product.
(dict) --The arameter key/value pairs used to provision a product.
Key (string) --The ProvisioningArtifactParameter.ParameterKey parameter from DescribeProvisioningParameters .
Value (string) --The value to use for provisioning. Any constraints on this value can be found in ProvisioningArtifactParameter for Key .
:type Tags: list
:param Tags: A list of tags to use as provisioning options.
(dict) --Key/value pairs to associate with this provisioning. These tags are entirely discretionary and are propagated to the resources created in the provisioning.
Key (string) -- [REQUIRED]The ProvisioningArtifactParameter.TagKey parameter from DescribeProvisioningParameters .
Value (string) -- [REQUIRED]The esired value for this key.
:type NotificationArns: list
:param NotificationArns: Passed to CloudFormation. The SNS topic ARNs to which to publish stack-related events.
(string) --
:type ProvisionToken: string
:param ProvisionToken: [REQUIRED]
An idempotency token that uniquely identifies the provisioning request.
This field is autopopulated if not provided.
:rtype: dict
:return: {
'RecordDetail': {
'RecordId': 'string',
'ProvisionedProductName': 'string',
'Status': 'IN_PROGRESS'|'SUCCEEDED'|'ERROR',
'CreatedTime': datetime(2015, 1, 1),
'UpdatedTime': datetime(2015, 1, 1),
'ProvisionedProductType': 'string',
'RecordType': 'string',
'ProvisionedProductId': 'string',
'ProductId': 'string',
'ProvisioningArtifactId': 'string',
'PathId': 'string',
'RecordErrors': [
{
'Code': 'string',
'Description': 'string'
},
],
'RecordTags': [
{
'Key': 'string',
'Value': 'string'
},
]
}
} | 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
If not ``None``, should be a dictionary of existing `arg_params`. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing `aux_params`. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor. | 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 also: AWS API Documentation
:example: response = client.describe_users(
OrganizationId='string',
UserIds='string',
Query='string',
Include='ALL'|'ACTIVE_PENDING',
Order='ASCENDING'|'DESCENDING',
Sort='USER_NAME'|'FULL_NAME'|'STORAGE_LIMIT'|'USER_STATUS'|'STORAGE_USED',
Marker='string',
Limit=123,
Fields='string'
)
:type OrganizationId: string
:param OrganizationId: The ID of the organization.
:type UserIds: string
:param UserIds: The IDs of the users.
:type Query: string
:param Query: A query to filter users by user name.
:type Include: string
:param Include: The state of the users. Specify 'ALL' to include inactive users.
:type Order: string
:param Order: The order for the results.
:type Sort: string
:param Sort: The sorting criteria.
:type Marker: string
:param Marker: The marker for the next set of results. (You received this marker from a previous call.)
:type Limit: integer
:param Limit: The maximum number of items to return.
:type Fields: string
:param Fields: A comma-separated list of values. Specify 'STORAGE_METADATA' to include the user storage quota and utilization information.
:rtype: dict
:return: {
'Users': [
{
'Id': 'string',
'Username': 'string',
'EmailAddress': 'string',
'GivenName': 'string',
'Surname': 'string',
'OrganizationId': 'string',
'RootFolderId': 'string',
'RecycleBinFolderId': 'string',
'Status': 'ACTIVE'|'INACTIVE'|'PENDING',
'Type': 'USER'|'ADMIN',
'CreatedTimestamp': datetime(2015, 1, 1),
'ModifiedTimestamp': datetime(2015, 1, 1),
'TimeZoneId': 'string',
'Locale': 'en'|'fr'|'ko'|'de'|'es'|'ja'|'ru'|'zh_CN'|'zh_TW'|'pt_BR'|'default',
'Storage': {
'StorageUtilizedInBytes': 123,
'StorageRule': {
'StorageAllocatedInBytes': 123,
'StorageType': 'UNLIMITED'|'QUOTA'
}
}
},
],
'TotalNumberOfUsers': 123,
'Marker': 'string'
} | 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,
result_format=None, include_config=False, catch_exceptions=None, meta=None
) | 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": {
"unexpected_count": 1
"unexpected_percent": 0.16666666666666666,
"unexpected_percent_nonmissing": 0.16666666666666666,
"partial_unexpected_list": [
1
],
},
}
expect_column_values_to_be_in_set is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
value_set (set-like): \
A set of objects used for comparison.
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
parse_strings_as_datetimes (boolean or None) : If True values provided in value_set will be parsed as \
datetimes before making comparisons.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_not_be_in_set | 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 message criteria.
Raises:
:class:`~pymap.exceptions.MailboxNotFound` | 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
information
:param str source: Path to local source directory
:param str stream: Simplestreams stream for which to sync metadata
:param str version: Copy a specific major.minor version | 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',
DBParameterGroupFamily='string',
Filters=[
{
'Name': 'string',
'Values': [
'string',
]
},
],
MaxRecords=123,
Marker='string',
DefaultOnly=True|False,
ListSupportedCharacterSets=True|False,
ListSupportedTimezones=True|False
)
:type Engine: string
:param Engine: The database engine to return.
:type EngineVersion: string
:param EngineVersion: The database engine version to return.
Example: 5.1.49
:type DBParameterGroupFamily: string
:param DBParameterGroupFamily: The name of a specific DB parameter group family to return details for.
Constraints:
Must be 1 to 255 alphanumeric characters
First character must be a letter
Cannot end with a hyphen or contain two consecutive hyphens
:type Filters: list
:param Filters: Not currently supported.
(dict) --This type is not currently supported.
Name (string) -- [REQUIRED]This parameter is not currently supported.
Values (list) -- [REQUIRED]This parameter is not currently supported.
(string) --
:type MaxRecords: integer
:param MaxRecords: The maximum number of records to include in the response. If more than the MaxRecords value is available, a pagination token called a marker is included in the response so that the following results can be retrieved.
Default: 100
Constraints: Minimum 20, maximum 100.
:type Marker: string
:param Marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords .
:type DefaultOnly: boolean
:param DefaultOnly: Indicates that only the default version of the specified engine or engine and major version combination is returned.
:type ListSupportedCharacterSets: boolean
:param ListSupportedCharacterSets: If this parameter is specified and the requested engine supports the CharacterSetName parameter for CreateDBInstance , the response includes a list of supported character sets for each engine version.
:type ListSupportedTimezones: boolean
:param ListSupportedTimezones: If this parameter is specified and the requested engine supports the TimeZone parameter for CreateDBInstance , the response includes a list of supported time zones for each engine version.
:rtype: dict
:return: {
'Marker': 'string',
'DBEngineVersions': [
{
'Engine': 'string',
'EngineVersion': 'string',
'DBParameterGroupFamily': 'string',
'DBEngineDescription': 'string',
'DBEngineVersionDescription': 'string',
'DefaultCharacterSet': {
'CharacterSetName': 'string',
'CharacterSetDescription': 'string'
},
'SupportedCharacterSets': [
{
'CharacterSetName': 'string',
'CharacterSetDescription': 'string'
},
],
'ValidUpgradeTarget': [
{
'Engine': 'string',
'EngineVersion': 'string',
'Description': 'string',
'AutoUpgrade': True|False,
'IsMajorVersionUpgrade': True|False
},
],
'SupportedTimezones': [
{
'TimezoneName': 'string'
},
]
},
]
} | 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 for stateful cron jobs.
forced_run_requested: A boolean indicating if a forced run is pending for
this job.
Raises:
UnknownCronJobError: A cron job with the given id does not exist. | 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 columns to key on
:param deliminator: str to use as a deliminator
:param eval_cells: bool if True will try to evaluate numbers
:return: SeabornTable | 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=unchanged,
processing_deadline=unchanged) | 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.ClientCrash object to store with the flow.
pending_termination: An rdf_flow_objects.PendingFlowTermination object.
Indicates that this flow is scheduled for termination.
processing_on: Worker this flow is currently processed on.
processing_since: Timstamp when the worker started processing this flow.
processing_deadline: Time after which this flow will be considered stuck
if processing hasn't finished. | 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',
]
},
],
TaskArn='string',
ServiceRoleArn='string',
TaskType='RUN_COMMAND',
TaskParameters={
'string': {
'Values': [
'string',
]
}
},
Priority=123,
MaxConcurrency='string',
MaxErrors='string',
LoggingInfo={
'S3BucketName': 'string',
'S3KeyPrefix': 'string',
'S3Region': 'string'
},
ClientToken='string'
)
:type WindowId: string
:param WindowId: [REQUIRED]
The id of the Maintenance Window the task should be added to.
:type Targets: list
:param Targets: [REQUIRED]
The targets (either instances or tags). Instances are specified using Key=instanceids,Values=instanceid1,instanceid2. Tags are specified using Key=tag name,Values=tag value.
(dict) --An array of search criteria that targets instances using a Key,Value combination that you specify. Targets is required if you don't provide one or more instance IDs in the call.
Key (string) --User-defined criteria for sending commands that target instances that meet the criteria. Key can be tag:Amazon EC2 tagor InstanceIds. For more information about how to send commands that target instances using Key,Value parameters, see Executing a Command Using Systems Manager Run Command .
Values (list) --User-defined criteria that maps to Key. For example, if you specified tag:ServerRole, you could specify value:WebServer to execute a command on instances that include Amazon EC2 tags of ServerRole,WebServer. For more information about how to send commands that target instances using Key,Value parameters, see Executing a Command Using Systems Manager Run Command .
(string) --
:type TaskArn: string
:param TaskArn: [REQUIRED]
The ARN of the task to execute
:type ServiceRoleArn: string
:param ServiceRoleArn: [REQUIRED]
The role that should be assumed when executing the task.
:type TaskType: string
:param TaskType: [REQUIRED]
The type of task being registered.
:type TaskParameters: dict
:param TaskParameters: The parameters that should be passed to the task when it is executed.
(string) --
(dict) --Defines the values for a task parameter.
Values (list) --This field contains an array of 0 or more strings, each 1 to 255 characters in length.
(string) --
:type Priority: integer
:param Priority: The priority of the task in the Maintenance Window, the lower the number the higher the priority. Tasks in a Maintenance Window are scheduled in priority order with tasks that have the same priority scheduled in parallel.
:type MaxConcurrency: string
:param MaxConcurrency: [REQUIRED]
The maximum number of targets this task can be run for in parallel.
:type MaxErrors: string
:param MaxErrors: [REQUIRED]
The maximum number of errors allowed before this task stops being scheduled.
:type LoggingInfo: dict
:param LoggingInfo: A structure containing information about an Amazon S3 bucket to write instance-level logs to.
S3BucketName (string) -- [REQUIRED]The name of an Amazon S3 bucket where execution logs are stored .
S3KeyPrefix (string) --(Optional) The Amazon S3 bucket subfolder.
S3Region (string) -- [REQUIRED]The region where the Amazon S3 bucket is located.
:type ClientToken: string
:param ClientToken: User-provided idempotency token.
This field is autopopulated if not provided.
:rtype: dict
:return: {
'WindowTaskId': '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_config=False, catch_exceptions=None, meta=None
) | 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:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`. | 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 phase
user (int):
identifier of the user answering the question
item (int):
identifier of the question item
correct (bool):
corretness of the answer | 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='string',
SupportUrl='string',
ProductType='CLOUD_FORMATION_TEMPLATE',
Tags=[
{
'Key': 'string',
'Value': 'string'
},
],
ProvisioningArtifactParameters={
'Name': 'string',
'Description': 'string',
'Info': {
'string': 'string'
},
'Type': 'CLOUD_FORMATION_TEMPLATE'
},
IdempotencyToken='string'
)
:type AcceptLanguage: string
:param AcceptLanguage: The language code to use for this operation. Supported language codes are as follows:
'en' (English)
'jp' (Japanese)
'zh' (Chinese)
If no code is specified, 'en' is used as the default.
:type Name: string
:param Name: [REQUIRED]
The name of the product.
:type Owner: string
:param Owner: [REQUIRED]
The owner of the product.
:type Description: string
:param Description: The text description of the product.
:type Distributor: string
:param Distributor: The distributor of the product.
:type SupportDescription: string
:param SupportDescription: Support information about the product.
:type SupportEmail: string
:param SupportEmail: Contact email for product support.
:type SupportUrl: string
:param SupportUrl: Contact URL for product support.
:type ProductType: string
:param ProductType: [REQUIRED]
The type of the product to create.
:type Tags: list
:param Tags: Tags to associate with the new product.
(dict) --Key/value pairs to associate with this provisioning. These tags are entirely discretionary and are propagated to the resources created in the provisioning.
Key (string) -- [REQUIRED]The ProvisioningArtifactParameter.TagKey parameter from DescribeProvisioningParameters .
Value (string) -- [REQUIRED]The esired value for this key.
:type ProvisioningArtifactParameters: dict
:param ProvisioningArtifactParameters: [REQUIRED]
Parameters for the provisioning artifact.
Name (string) --The name assigned to the provisioning artifact properties.
Description (string) --The text description of the provisioning artifact properties.
Info (dict) -- [REQUIRED]Additional information about the provisioning artifact properties.
(string) --
(string) --
Type (string) --The type of the provisioning artifact properties.
:type IdempotencyToken: string
:param IdempotencyToken: [REQUIRED]
A token to disambiguate duplicate requests. You can create multiple resources using the same input in multiple requests, provided that you also specify a different idempotency token for each request.
This field is autopopulated if not provided.
:rtype: dict
:return: {
'ProductViewDetail': {
'ProductViewSummary': {
'Id': 'string',
'ProductId': 'string',
'Name': 'string',
'Owner': 'string',
'ShortDescription': 'string',
'Type': 'CLOUD_FORMATION_TEMPLATE',
'Distributor': 'string',
'HasDefaultPath': True|False,
'SupportEmail': 'string',
'SupportDescription': 'string',
'SupportUrl': 'string'
},
'Status': 'AVAILABLE'|'CREATING'|'FAILED',
'ProductARN': 'string',
'CreatedTime': datetime(2015, 1, 1)
},
'ProvisioningArtifactDetail': {
'Id': 'string',
'Name': 'string',
'Description': 'string',
'Type': 'CLOUD_FORMATION_TEMPLATE',
'CreatedTime': datetime(2015, 1, 1)
},
'Tags': [
{
'Key': 'string',
'Value': 'string'
},
]
} | 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: Set of flags to update.
mode: Update mode for the flag set.
Raises:
:class:`~pymap.exceptions.MailboxNotFound`
:class:`~pymap.exceptions.MailboxReadOnly` | 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 structure
:param release_date: the release date of the structure
:param experimnetal_methods: the list of experimental methods in the structure | 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_key_path: path to ssh public key
:param str private_key_path: path to ssh private key
:param str security_group: firewall rule definition to apply on the
instance
:param str flavor: machine type to use for the instance
:param str image_name: image type (os) to use for the instance
:param str image_userdata: command to execute after startup
:param str username: username for the given ssh key, default None
:return: str - instance id of the started instance | 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): \
A string representing the data type that each column should have as entries.
For example, "double integer" refers to an integer with double precision.
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Warning:
expect_column_values_to_be_of_type is slated for major changes in future versions of great_expectations.
As of v0.3, great_expectations is exclusively based on pandas, which handles typing in its own peculiar way.
Future versions of great_expectations will allow for Datasets in SQL, spark, etc.
When we make that change, we expect some breaking changes in parts of the codebase that are based strongly on pandas notions of typing.
See also:
expect_column_values_to_be_in_type_list | 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 (list of str): \
A list of strings representing the data type that each column should have as entries.
For example, "double integer" refers to an integer with double precision.
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Warning:
expect_column_values_to_be_in_type_list is slated for major changes in future versions of great_expectations.
As of v0.3, great_expectations is exclusively based on pandas, which handles typing in its own peculiar way.
Future versions of great_expectations will allow for Datasets in SQL, spark, etc.
When we make that change, we expect some breaking changes in parts of the codebase that are based strongly on pandas notions of typing.
See also:
expect_column_values_to_be_of_type | 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 or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`. | 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 underscore denotes that
the method is a private method).
The purpose of the ``_read()`` method is to perform the file read operations that are specific to the file that
the file object represents. This method should add any supporting SQLAlchemy objects to the session without
committing. The common ``read()`` method handles the database commit for all file objects.
The ``read()`` method processes the user input and passes on the information through the many parameters of the
``_read()`` method. As the ``_read()`` method should never be called by the user directly, the arguments will
be defined in terms of what they offer for the developer of a new file object needing to implement this method.
Args:
directory (str): Directory containing the file to be read. Same as given by user in ``read()``.
filename (str): Name of the file which will be read (e.g.: 'example.prj'). Same as given by user. Same as
given by user in ``read()``.
session (:mod:`sqlalchemy.orm.session.Session`): SQLAlchemy session object bound to PostGIS enabled
database. Same as given by user in ``read()``.
path (str): Directory and filename combined into the path to the file. This is a convenience parameter.
name (str): Name of the file without extension. This is a convenience parameter.
extension (str): Extension of the file without the name. This is a convenience parameter.
spatial (bool, optional): If True, spatially enabled objects will be read in as PostGIS spatial objects.
Defaults to False. Same as given by user in ``read()``.
spatialReferenceID (int, optional): Integer id of spatial reference system for the model. Required if
spatial is True. Same as given by user in ``read()``.
replaceParamFile (:class:`gsshapy.orm.ReplaceParamFile`, optional): Handle the case when replacement
parameters are used in place of normal variables. If this is not None, then the user expects there
to be replacement variables in the file. Use the gsshapy.lib.parsetools.valueReadPreprocessor() to
handle these. | 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' for data coordinates,
'figure' for figure (pixel) coordinates, or "points" for raw
point coordinates (useful in conjunction with offsets, below).
pathcodes : list
A list of single-character SVG pathcodes associated with the data.
Path codes are one of ['M', 'm', 'L', 'l', 'Q', 'q', 'T', 't',
'S', 's', 'C', 'c', 'Z', 'z']
See the SVG specification for details. Note that some path codes
consume more than one datapoint (while 'Z' consumes none), so
in general, the length of the pathcodes list will not be the same
as that of the data array.
style : dictionary
a dictionary specifying the appearance of the line.
offset : list (optional)
the (x, y) offset of the path. If not given, no offset will
be used.
offset_coordinates : string (optional)
A string code, which should be either 'data' for data coordinates,
or 'figure' for figure (pixel) coordinates.
mplobj : matplotlib object
the matplotlib plot element which generated this path | 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.
:param source_width: Specifies the data width of the source.
:param destination_space: Specifies the address space of the destination.
:param destination_offset: Offset of the starting address or register to which to write.
:param destination_width: Specifies the data width of the destination.
:param length: Number of elements to transfer, where the data width of the elements to transfer
is identical to the source data width.
:return: return value of the library call.
:rtype: :class:`pyvisa.constants.StatusCode` | 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 prepend
>>> list(prepend(1, [2, 3]))
[1, 2, 3] | 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 only merges, False means no merges,
None means both merges and non-merges.
:param str path: Only match commits containing changes on this path.
:param bool follow: Follow file history across renames.
:returns: log information
:rtype: :class:`CommitLogEntry` or list of :class:`CommitLogEntry`
If revrange is None, return a list of all log entries in reverse
chronological order.
If revrange is a single revision, return a single log entry.
If revrange is a 2 element list [A,B] or tuple (A,B), return a list of log
entries starting at B and following that branch back to A or one of its
ancestors (not inclusive. If A is None, follow branch B back to the
beginning of history. If B is None, list all descendants in reverse
chronological order. | 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
:param y: the y coordinate of the atom
:param z: the z coordinate of the atom
:param occupancy: the occupancy of the atom
:param temperature_factor: the temperature factor of the atom
:param element: the element of the atom, e.g. C for carbon. According to IUPAC. Calcium is Ca
:param charge: the formal atomic charge 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',
SupportEmail='string',
SupportUrl='string',
AddTags=[
{
'Key': 'string',
'Value': 'string'
},
],
RemoveTags=[
'string',
]
)
:type AcceptLanguage: string
:param AcceptLanguage: The language code to use for this operation. Supported language codes are as follows:
'en' (English)
'jp' (Japanese)
'zh' (Chinese)
If no code is specified, 'en' is used as the default.
:type Id: string
:param Id: [REQUIRED]
The identifier of the product for the update request.
:type Name: string
:param Name: The updated product name.
:type Owner: string
:param Owner: The updated owner of the product.
:type Description: string
:param Description: The updated text description of the product.
:type Distributor: string
:param Distributor: The updated distributor of the product.
:type SupportDescription: string
:param SupportDescription: The updated support description for the product.
:type SupportEmail: string
:param SupportEmail: The updated support email for the product.
:type SupportUrl: string
:param SupportUrl: The updated support URL for the product.
:type AddTags: list
:param AddTags: Tags to add to the existing list of tags associated with the product.
(dict) --Key/value pairs to associate with this provisioning. These tags are entirely discretionary and are propagated to the resources created in the provisioning.
Key (string) -- [REQUIRED]The ProvisioningArtifactParameter.TagKey parameter from DescribeProvisioningParameters .
Value (string) -- [REQUIRED]The esired value for this key.
:type RemoveTags: list
:param RemoveTags: Tags to remove from the existing list of tags associated with the product.
(string) --
:rtype: dict
:return: {
'ProductViewDetail': {
'ProductViewSummary': {
'Id': 'string',
'ProductId': 'string',
'Name': 'string',
'Owner': 'string',
'ShortDescription': 'string',
'Type': 'CLOUD_FORMATION_TEMPLATE',
'Distributor': 'string',
'HasDefaultPath': True|False,
'SupportEmail': 'string',
'SupportDescription': 'string',
'SupportUrl': 'string'
},
'Status': 'AVAILABLE'|'CREATING'|'FAILED',
'ProductARN': 'string',
'CreatedTime': datetime(2015, 1, 1)
},
'Tags': [
{
'Key': 'string',
'Value': '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,
result_format=None, include_config=False, catch_exceptions=None, meta=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 decreasing--equal values are treated as failures.
expect_column_values_to_be_decreasing is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
Keyword Args:
strictly (Boolean or None): \
If True, values must be strictly greater than previous values
parse_strings_as_datetimes (boolean or None) : \
If True, all non-null column values to datetimes before making comparisons
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_be_increasing | 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=None
) | 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 name.
min_value (float or None): \
The minimum value for the column mean.
max_value (float or None): \
The maximum value for the column mean.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
These fields in the result object are customized for this expectation:
::
{
"observed_value": (float) The true mean for the column
}
* min_value and max_value are both inclusive.
* If min_value is None, then max_value is treated as an upper bound.
* If max_value is None, then min_value is treated as a lower bound.
See Also:
expect_column_median_to_be_between
expect_column_stdev_to_be_between | 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=False, to=None,
upload_tools=False) | 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
bootstrap
:param bootstrap_constraints: Constraints for the bootstrap machine
:type bootstrap_constraints: :class:`juju.Constraints`
:param str bootstrap_series: Series of the bootstrap machine
:param dict config: Controller configuration
:param constraints: Default constraints for all future workload
machines
:type constraints: :class:`juju.Constraints`
:param credential: Credential to use when bootstrapping
:type credential: :class:`juju.Credential`
:param str default_model: Name to give the default model
:param bool keep_broken: Don't destroy model if bootstrap fails
:param str metadata_source: Local path to use as tools and/or metadata
source
:param bool no_gui: Don't install the Juju GUI in the controller when
bootstrapping
:param str to: Placement directive for bootstrap node (typically used
with MAAS)
:param bool upload_tools: Upload local version of tools before
bootstrapping | 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): \
The minimum number of rows, inclusive.
max_value (int or None): \
The maximum number of rows, inclusive.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
* min_value and max_value are both inclusive.
* If min_value is None, then max_value is treated as an upper bound, and the number of acceptable rows has no minimum.
* If max_value is None, then min_value is treated as a lower bound, and the number of acceptable rows has no maximum.
See Also:
expect_table_row_count_to_equal | 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, include_config=False, catch_exceptions=None, meta=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
value_set (set-like): \
A list of potential values to match
Keyword Args:
ties_okay (boolean or None): \
If True, then the expectation will still succeed if values outside the designated set are as common (but not more common) than designated values
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
Notes:
These fields in the result object are customized for this expectation:
::
{
"observed_value": (list) The most common values in the column
}
`observed_value` contains a list of the most common values.
Often, this will just be a single element. But if there's a tie for most common among multiple values,
`observed_value` will contain a single copy of each most common value. | 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 ClasspathEntry for
dependencies.
:param upstream_analysis: A map from classpath entry to analysis file for dependencies.
:param JvmPlatformSettings settings: platform settings determining the -source, -target, etc for
javac to use.
:param list compiler_option_sets: The compiler_option_sets flags for the target.
:param zinc_file_manager: whether to use zinc provided file manager.
:param javac_plugin_map: Map of names of javac plugins to use to their arguments.
:param scalac_plugin_map: Map of names of scalac plugins to use to their arguments. | 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 ``(field, order)`` where ``order`` is
``'asc'`` or ``'desc'``
: param secure: When set to True, this will filter out any object which
current logged in user is not allowed to see
: todo: ``order_by`` need to allow multiple field ordering | 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.exceptions.MailboxNotFound` | 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,).
:param source_encoded_max_length: Size of encoder time dimension.
:return: List of symbolic initial states. | 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, as a float, or a :ref:`(connect timeout,
read timeout) <timeouts>` tuple.
:type timeout: float or tuple
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request. | 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_count_value: should be the largest number `count_value` can reach
:param prepend: additional text for each progress
:param speed: the speed estimation
:param tet: the total elapsed time
:param ttg: the time to go
:param width: the width for the progressbar, when set to `"auto"` this function
should try to detect the width available
:type width: int or "auto" | 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 sending final packet
:param size (optional): Size of request (bytes)
:param count (optional): Number of ping request to send
Output dictionary has one of following keys:
* success
* error
In case of success, inner dictionary will have the followin keys:
* probes_sent (int)
* packet_loss (int)
* rtt_min (float)
* rtt_max (float)
* rtt_avg (float)
* rtt_stddev (float)
* results (list)
'results' is a list of dictionaries with the following keys:
* ip_address (str)
* rtt (float)
Example::
{
'success': {
'probes_sent': 5,
'packet_loss': 0,
'rtt_min': 72.158,
'rtt_max': 72.433,
'rtt_avg': 72.268,
'rtt_stddev': 0.094,
'results': [
{
'ip_address': u'1.1.1.1',
'rtt': 72.248
},
{
'ip_address': '2.2.2.2',
'rtt': 72.299
}
]
}
}
OR
{
'error': 'unknown host 8.8.8.8.8'
} | 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 some cases. For example, it contains the widths to pad characters to when doing
character-level padding. | 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 loaded
:return: the single entity retrieved from iRODS if a single path is given, else a sequence of retrieved entities | 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 list include: Only show log messages for these entities
:param str level: Log level to show, valid options are 'TRACE',
'DEBUG', 'INFO', 'WARNING', 'ERROR,
:param int limit: Return this many of the most recent (possibly
filtered) lines are shown
:param int lines: Yield this many of the most recent lines, and keep
yielding
:param bool replay: Yield the entire log, and keep yielding
:param list exclude: Do not show log messages for these entities | 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.
mailbox: The intended mailbox to append the message.
append_msg: The message to be appended.
raises:
:exc:`~pymap.exceptions.AppendFailure` | 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: additional options map. Implementing classes may use 'self.get_applicable_options()' to get the
options that are of interest for this converter.
:return: | 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 selected mailbox name.
Raises:
:class:`~pymap.exceptions.MailboxNotFound`
:class:`~pymap.exceptions.AppendFailure` | 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=False, catch_exceptions=None, meta=None
) | 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.
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_be_json_parseable
The JSON-schema docs at: http://json-schema.org/ | 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 records refer to the same entity.
This method should only used for small to moderately sized datasets
for larger data, use matchBlocks
Arguments:
messy_data -- Dictionary of records from messy dataset, where the
keys are record_ids and the values are dictionaries with
the keys being field names
threshold -- Number between 0 and 1 (default is .5). We will consider
records as potential duplicates if the predicted
probability of being a duplicate is above the threshold.
Lowering the number will increase recall, raising it
will increase precision
n_matches -- Maximum number of possible matches from the canonical
record set to match against each record in the messy
record set | 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::
&target=lineWidth(server01.instance01.memory.free,5) | 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
reporting will be performed for the hook. | 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=None
) | 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_column_values_to_match_regex is a :func:`column_map_expectation <great_expectations.data_asset.dataset.Dataset.column_map_expectation>`.
Args:
column (str): \
The column name.
regex (str): \
The regular expression the column entries should match.
Keyword Args:
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_not_match_regex
expect_column_values_to_match_regex_list | 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.
Empty string if none available.
:param atom_count: the number of atoms in the group
:param bond_count: the number of unique bonds in the group
:param single_letter_code: the single letter code of the group
:param sequence_index: the index of this group in the sequence defined by the enttiy
:param secondary_structure_type: the type of secondary structure used (types are according to DSSP and
number to type mappings are defined in the specification) | 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 settings.
Expected Output:
:example: response = client.describe_reserved_db_instances(
ReservedDBInstanceId='string',
ReservedDBInstancesOfferingId='string',
DBInstanceClass='string',
Duration='string',
ProductDescription='string',
OfferingType='string',
MultiAZ=True|False,
Filters=[
{
'Name': 'string',
'Values': [
'string',
]
},
],
MaxRecords=123,
Marker='string'
)
:type ReservedDBInstanceId: string
:param ReservedDBInstanceId: The reserved DB instance identifier filter value. Specify this parameter to show only the reservation that matches the specified reservation ID.
:type ReservedDBInstancesOfferingId: string
:param ReservedDBInstancesOfferingId: The offering identifier filter value. Specify this parameter to show only purchased reservations matching the specified offering identifier.
:type DBInstanceClass: string
:param DBInstanceClass: The DB instance class filter value. Specify this parameter to show only those reservations matching the specified DB instances class.
:type Duration: string
:param Duration: The duration filter value, specified in years or seconds. Specify this parameter to show only reservations for this duration.
Valid Values: 1 | 3 | 31536000 | 94608000
:type ProductDescription: string
:param ProductDescription: The product description filter value. Specify this parameter to show only those reservations matching the specified product description.
:type OfferingType: string
:param OfferingType: The offering type filter value. Specify this parameter to show only the available offerings matching the specified offering type.
Valid Values: 'Partial Upfront' | 'All Upfront' | 'No Upfront'
:type MultiAZ: boolean
:param MultiAZ: The Multi-AZ filter value. Specify this parameter to show only those reservations matching the specified Multi-AZ parameter.
:type Filters: list
:param Filters: This parameter is not currently supported.
(dict) --This type is not currently supported.
Name (string) -- [REQUIRED]This parameter is not currently supported.
Values (list) -- [REQUIRED]This parameter is not currently supported.
(string) --
:type MaxRecords: integer
:param MaxRecords: The maximum number of records to include in the response. If more than the MaxRecords value is available, a pagination token called a marker is included in the response so that the following results can be retrieved.
Default: 100
Constraints: Minimum 20, maximum 100.
:type Marker: string
:param Marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords .
:rtype: dict
:return: {
'Marker': 'string',
'ReservedDBInstances': [
{
'ReservedDBInstanceId': 'string',
'ReservedDBInstancesOfferingId': 'string',
'DBInstanceClass': 'string',
'StartTime': datetime(2015, 1, 1),
'Duration': 123,
'FixedPrice': 123.0,
'UsagePrice': 123.0,
'CurrencyCode': 'string',
'DBInstanceCount': 123,
'ProductDescription': 'string',
'OfferingType': 'string',
'MultiAZ': True|False,
'State': 'string',
'RecurringCharges': [
{
'RecurringChargeAmount': 123.0,
'RecurringChargeFrequency': 'string'
},
],
'ReservedDBInstanceArn': 'string'
},
]
} | 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',
UserIds=[
'string',
],
UserGroups=[
'string',
],
ProductCodes=[
'string',
],
Value='string',
LaunchPermission={
'Add': [
{
'UserId': 'string',
'Group': 'all'
},
],
'Remove': [
{
'UserId': 'string',
'Group': 'all'
},
]
},
Description={
'Value': 'string'
}
)
:type DryRun: boolean
:param DryRun: Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is DryRunOperation . Otherwise, it is UnauthorizedOperation .
:type ImageId: string
:param ImageId: [REQUIRED]
The ID of the AMI.
:type Attribute: string
:param Attribute: The name of the attribute to modify.
:type OperationType: string
:param OperationType: The operation type.
:type UserIds: list
:param UserIds: One or more AWS account IDs. This is only valid when modifying the launchPermission attribute.
(string) --
:type UserGroups: list
:param UserGroups: One or more user groups. This is only valid when modifying the launchPermission attribute.
(string) --
:type ProductCodes: list
:param ProductCodes: One or more product codes. After you add a product code to an AMI, it can't be removed. This is only valid when modifying the productCodes attribute.
(string) --
:type Value: string
:param Value: The value of the attribute being modified. This is only valid when modifying the description attribute.
:type LaunchPermission: dict
:param LaunchPermission: A launch permission modification.
Add (list) --The AWS account ID to add to the list of launch permissions for the AMI.
(dict) --Describes a launch permission.
UserId (string) --The AWS account ID.
Group (string) --The name of the group.
Remove (list) --The AWS account ID to remove from the list of launch permissions for the AMI.
(dict) --Describes a launch permission.
UserId (string) --The AWS account ID.
Group (string) --The name of the group.
:type Description: dict
:param Description: A description for the AMI.
Value (string) --The attribute value. Note that the value is case-sensitive. | 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',
],
authType='string',
authorizerUri='string',
authorizerCredentials='string',
identitySource='string',
identityValidationExpression='string',
authorizerResultTtlInSeconds=123
)
:type restApiId: string
:param restApiId: [REQUIRED]
The RestApi identifier under which the Authorizer will be created.
:type name: string
:param name: [REQUIRED]
[Required] The name of the authorizer.
:type type: string
:param type: [REQUIRED]
[Required] The type of the authorizer.
:type providerARNs: list
:param providerARNs: A list of the Cognito Your User Pool authorizer's provider ARNs.
(string) --
:type authType: string
:param authType: Optional customer-defined field, used in Swagger imports/exports. Has no functional impact.
:type authorizerUri: string
:param authorizerUri: [Required] Specifies the authorizer's Uniform Resource Identifier (URI).
:type authorizerCredentials: string
:param authorizerCredentials: Specifies the credentials required for the authorizer, if any.
:type identitySource: string
:param identitySource: [REQUIRED]
[Required] The source of the identity in an incoming request.
:type identityValidationExpression: string
:param identityValidationExpression: A validation expression for the incoming identity.
:type authorizerResultTtlInSeconds: integer
:param authorizerResultTtlInSeconds: The TTL of cached authorizer results.
:rtype: dict
:return: {
'id': 'string',
'name': 'string',
'type': 'TOKEN'|'COGNITO_USER_POOLS',
'providerARNs': [
'string',
],
'authType': 'string',
'authorizerUri': 'string',
'authorizerCredentials': 'string',
'identitySource': 'string',
'identityValidationExpression': 'string',
'authorizerResultTtlInSeconds': 123
}
:returns:
(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,
result_format=None, include_config=False, catch_exceptions=None, meta=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>`.
Args:
column (str): \
The column name.
regex_list (list): \
The list of regular expressions which the column entries should match
Keyword Args:
match_on= (string): \
"any" or "all".
Use "any" if the value should match at least one regular expression in the list.
Use "all" if it should match each regular expression in the list.
mostly (None or a float between 0 and 1): \
Return `"success": True` if at least mostly percent of values match the expectation. \
For more detail, see :ref:`mostly`.
Other Parameters:
result_format (str or None): \
Which output mode to use: `BOOLEAN_ONLY`, `BASIC`, `COMPLETE`, or `SUMMARY`.
For more detail, see :ref:`result_format <result_format>`.
include_config (boolean): \
If True, then include the expectation config as part of the result object. \
For more detail, see :ref:`include_config`.
catch_exceptions (boolean or None): \
If True, then catch exceptions and include them as part of the result object. \
For more detail, see :ref:`catch_exceptions`.
meta (dict or None): \
A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. \
For more detail, see :ref:`meta`.
Returns:
A JSON-serializable expectation result object.
Exact fields vary depending on the values passed to :ref:`result_format <result_format>` and
:ref:`include_config`, :ref:`catch_exceptions`, and :ref:`meta`.
See Also:
expect_column_values_to_match_regex
expect_column_values_to_not_match_regex | 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 run startup scripts. Overrides rcfile.
stdin: If True, read commands from stdin in a non-interactive shell.
If a different non-False value, such as subprocess.PIPE, the same
occurs, but stdin is also passed to the resulting subprocess.Popen
object.
command: If not None, execute this command in a non-interactive shell.
If an empty string, don't run a command, but don't open an
interactive shell either.
env: Environ dict to execute the shell within; uses the current
environment if None.
quiet: If True, don't show the configuration summary, and suppress
any stdout from startup scripts.
pre_command: Command to inject before the shell command itself. This
is for internal use.
add_rez: If True, assume this shell is being used with rez, and do
things such as set the prompt etc.
package_commands_sourced_first: If True, source the context file before
sourcing startup scripts (such as .bashrc). If False, source
the context file AFTER. If None, use the configured setting.
popen_args: args to pass to the shell process object constructor.
Returns:
A subprocess.Popen object representing the shell process. | 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 records refer to the same entity.
This method should only used for small to moderately sized datasets
for larger data, use matchBlocks
Arguments:
data_1 -- Dictionary of records from first dataset, where the
keys are record_ids and the values are dictionaries
with the keys being field names
data_2 -- Dictionary of records from second dataset, same form
as data_1
threshold -- Number between 0 and 1 (default is .5). We will consider
records as potential duplicates if the predicted
probability of being a duplicate is above the threshold.
Lowering the number will increase recall, raising it
will increase precision | 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 the records in a cluster refer to
the same entity.
This method should only used for small to moderately sized
datasets for larger data, use matchBlocks
Arguments:
data -- Dictionary of records, where the keys are record_ids
and the values are dictionaries with the keys being
field names
threshold -- Number between 0 and 1 (default is .5). We will
consider records as potential duplicates if the
predicted probability of being a duplicate is
above the threshold.
Lowering the number will increase recall,
raising it will increase precision | 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 be started. | 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 mailbox name.
Raises:
:class:`~pymap.exceptions.MailboxNotFound` | 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:
observable (object): The input object. It could be a histogram or something more complex
kwargs: Additional arguments passed to the projection function
Return:
ROOT.TH1 or ROOT.THnBase histogram which should be projected. By default, it returns the
observable (input object). | 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: Name of the mailbox to copy messages into.
Raises:
:class:`~pymap.exceptions.MailboxNotFound`
:class:`~pymap.exceptions.MailboxReadOnly` | 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, displays a generic request for a confirmation
that the user wishes to continue. So it can be used this way::
if ccbox():
pass # continue
else:
sys.exit(0) # exit the program
@arg msg: the msg to be displayed.
@arg title: the window title
@arg choices: a list or tuple of the choices to be displayed | 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:
:param reversed: | 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:
arguments for the function (only used if ``target`` is a function)
:type args: tuple
:param kwargs:
keyword arguments for the function (only used if ``target`` is a
function)
:type kwargs: dict or None
:returns: the ``target`` argument
This function can also be used as a decorator:
>>> @schedule_in(30)
>>> def f():
... print 'hello from f'
and args/kwargs can also be preloaded:
>>> @schedule_in(30, args=('world',))
>>> def f(name):
... print 'hello %s' % name | 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 request for a confirmation
that the user wishes to continue. So it can be used this way::
if ynbox(): pass # continue
else: sys.exit(0) # exit the program
@arg msg: the msg to be displayed.
@arg title: the window title
@arg choices: a list or tuple of the choices to be displayed | 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:
output_hist: The output histogram
input_observable (object): The corresponding input object. It could be a histogram or something
more complex.
kwargs: Projection information dict combined with additional arguments passed to the
projection function
Return:
The output object which should be stored in the output dict. By default, it returns the
output hist. | 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 bytes) of the memory to be mapped.
:param map_size: Amount of memory to map (in bytes).
:param access:
:param suggested: If not Constants.VI_NULL (0), the operating system attempts to map the memory to the address
specified in suggested. There is no guarantee, however, that the memory will be mapped to
that address. This operation may map the memory into an address region different from
suggested.
:return: address in your process space where the memory was mapped, return value of the library call.
:rtype: address, :class:`pyvisa.constants.StatusCode` | 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: the matched entities in iRODS | 29,052.511719 | 150,910.796875 | 0.192514 | 208,613 |
- Downloads last month
- 7