data_ps.decldesc.valid

def _block2d_to_blocknd(values, placement, shape, labels, ref_items): DCNL 'pivot to the labels shape'
def create_cow_image(backing_file, path, size=None): DCNL 'Create COW image DCNL Creates a COW image with the given backing file DCNL :param backing_file: Existing image on which to base the COW image DCNL :param path: Desired location of the COW image'
def reload_config(): DCNL 'Reload the configuration from environment variables, if necessary.'
def encode_morse(msg, sep='|', mapping=None): DCNL 'Encodes a plaintext into popular Morse Code with letters DCNL separated by `sep` and words by a double `sep`. DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Morse_code DCNL Examples DCNL >>> from sympy.crypto.crypto import encode_morse DCNL >>> msg = \'ATTACK RIGHT FLANK\' DCNL >>> encode_morse(msg)'
def test_boolean_field_choices_with_real_model_instances(): DCNL 'If a booleanField has choices defined, the value argument passed to DCNL BooleanColumn.render() is the rendered value, not a bool.'
def p_constant_expression(t): DCNL 'constant_expression : conditional_expression'
def nsmallest(arr, n, keep='first'): DCNL 'Find the indices of the n smallest values of a numpy array. DCNL Note: Fails silently with NaN.'
def consolidate_hashes(partition_dir): DCNL 'Take what\'s in hashes.pkl and hashes.invalid, combine them, write the DCNL result back to hashes.pkl, and clear out hashes.invalid. DCNL :param suffix_dir: absolute path to partition dir containing hashes.pkl DCNL and hashes.invalid DCNL :returns: the hashes, or None if there\'s no hashes.pkl.'
def get_BAIDUID(): DCNL '获取一个cookie - BAIDUID. DCNL 这里, 我们访问百度首页, 返回的response header里面有我们需要的cookie'
def cg_has_volumes_filter(attached_or_with_snapshots=False): DCNL 'Return a filter to check if a CG has volumes. DCNL When attached_or_with_snapshots parameter is given a True value only DCNL attached volumes or those with snapshots will be considered.'
def url_is_from_spider(url, spider): DCNL 'Return True if the url belongs to the given spider'
def dup_spherical_bessel_fn_minus(n, K): DCNL 'Low-level implementation of fn(-n, x)'
def _toggle_proj(event, params): DCNL 'Operation to perform when proj boxes clicked.'
def restore_ring(output, coord, width, dense_input, start_idx): DCNL '.. todo:: DCNL WRITEME DCNL Parameters DCNL output : WRITEME DCNL output matrix in topological order DCNL (batch, height, width, channels) DCNL coord : WRITEME DCNL perform average pooling starting at coordinate (coord,coord) DCNL width : WRITEME DCNL width of "square ring" to average pool DCNL dense_input : WRITEME DCNL dense design matrix to convert (batchsize, dims) DCNL start_idx : WRITEME DCNL column index where to start writing the output'
def negate_real(builder, val): DCNL 'Negate real number *val*, with proper handling of zeros.'
def smoothness_p(n, m=(-1), power=0, visual=None): DCNL 'Return a list of [m, (p, (M, sm(p + m), psm(p + m)))...] DCNL where: DCNL 1. p**M is the base-p divisor of n DCNL 2. sm(p + m) is the smoothness of p + m (m = -1 by default) DCNL 3. psm(p + m) is the power smoothness of p + m DCNL The list is sorted according to smoothness (default) or by power smoothness DCNL if power=1. DCNL The smoothness of the numbers to the left (m = -1) or right (m = 1) of a DCNL factor govern the results that are obtained from the p +/- 1 type factoring DCNL methods. DCNL >>> from sympy.ntheory.factor_ import smoothness_p, factorint DCNL >>> smoothness_p(10431, m=1) DCNL (1, [(3, (2, 2, 4)), (19, (1, 5, 5)), (61, (1, 31, 31))]) DCNL >>> smoothness_p(10431) DCNL (-1, [(3, (2, 2, 2)), (19, (1, 3, 9)), (61, (1, 5, 5))]) DCNL >>> smoothness_p(10431, power=1) DCNL (-1, [(3, (2, 2, 2)), (61, (1, 5, 5)), (19, (1, 3, 9))]) DCNL If visual=True then an annotated string will be returned: DCNL >>> print(smoothness_p(21477639576571, visual=1)) DCNL p**i=4410317**1 has p-1 B=1787, B-pow=1787 DCNL p**i=4869863**1 has p-1 B=2434931, B-pow=2434931 DCNL This string can also be generated directly from a factorization dictionary DCNL and vice versa: DCNL >>> factorint(17*9) DCNL {3: 2, 17: 1} DCNL >>> smoothness_p(_) DCNL \'p**i=3**2 has p-1 B=2, B-pow=2\np**i=17**1 has p-1 B=2, B-pow=16\' DCNL >>> smoothness_p(_) DCNL {3: 2, 17: 1} DCNL The table of the output logic is: DCNL |              Visual DCNL Input  True   False   other DCNL dict    str    tuple   str DCNL str     str    tuple   dict DCNL tuple   str    tuple   str DCNL n       str    tuple   tuple DCNL mul     str    tuple   tuple DCNL See Also DCNL factorint, smoothness'
def download_zlib(dest_dir, version): DCNL 'Downloads zlib, returning the filename where the library was downloaded'
def build_auxiliary_node_connectivity(G): DCNL 'Creates a directed graph D from an undirected graph G to compute flow DCNL based node connectivity. DCNL For an undirected graph G having `n` nodes and `m` edges we derive a DCNL directed graph D with `2n` nodes and `2m+n` arcs by replacing each DCNL original node `v` with two nodes `vA`, `vB` linked by an (internal) DCNL arc in D. Then for each edge (`u`, `v`) in G we add two arcs (`uB`, `vA`) DCNL and (`vB`, `uA`) in D. Finally we set the attribute capacity = 1 for each DCNL arc in D [1]_. DCNL For a directed graph having `n` nodes and `m` arcs we derive a DCNL directed graph D with `2n` nodes and `m+n` arcs by replacing each DCNL original node `v` with two nodes `vA`, `vB` linked by an (internal) DCNL arc (`vA`, `vB`) in D. Then for each arc (`u`, `v`) in G we add one DCNL arc (`uB`, `vA`) in D. Finally we set the attribute capacity = 1 for DCNL each arc in D. DCNL A dictionary with a mapping between nodes in the original graph and the DCNL auxiliary digraph is stored as a graph attribute: H.graph[\'mapping\']. DCNL References DCNL .. [1] Kammer, Frank and Hanjo Taubig. Graph Connectivity. in Brandes and DCNL Erlebach, \'Network Analysis: Methodological Foundations\', Lecture DCNL Notes in Computer Science, Volume 3418, Springer-Verlag, 2005. DCNL http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf'
def get_mem_info_linux(): DCNL 'Get information about available memory. DCNL Returns a dict of items in /proc/meminfo'
def get_service(hass, config, discovery_info=None): DCNL 'Get the Telegram notification service.'
def reverse_course_url(handler_name, course_key, kwargs=None): DCNL 'Creates the URL for handlers that use course_keys as URL parameters.'
def _mask_to_limits(a, limits, inclusive): DCNL 'Mask an array for values outside of given limits. DCNL This is primarily a utility function. DCNL Parameters DCNL a : array DCNL limits : (float or None, float or None) DCNL A tuple consisting of the (lower limit, upper limit).  Values in the DCNL input array less than the lower limit or greater than the upper limit DCNL will be masked out. None implies no limit. DCNL inclusive : (bool, bool) DCNL A tuple consisting of the (lower flag, upper flag).  These flags DCNL determine whether values exactly equal to lower or upper are allowed. DCNL Returns DCNL A MaskedArray. DCNL Raises DCNL A ValueError if there are no values within the given limits.'
def _split_digest_auth(data): DCNL 'This function handles (Proxy-)Authorization: Digest values'
def getPathByKey(key, xmlElement): DCNL 'Get path from prefix and xml element.'
def check_named(option, opt, value): DCNL 'check a named value DCNL return a dictionary containing (name, value) associations'
def connections_support_transactions(): DCNL 'Returns True if all connections support transactions.  This is messy DCNL because 2.4 doesn\'t support any or all.'
@pytest.fixture(autouse=True) DCNL def _annotate_environment(request): DCNL 'Add project-specific information to test-run environment: DCNL * behave.version DCNL NOTE: autouse: Fixture is automatically used when test-module is imported.'
def escape_sql_like_special_characters(term, escape='\\'): DCNL 'Escapes characters that are special to the the sql LIKE expression. DCNL In particular, for both postgres and sqlite this means \'%\' and \'_\'.'
def strip_version(idstr): DCNL 'identity function if arxiv id has no version, otherwise strips it.'
@lru_cache(maxsize=1024) DCNL def extract_real_url_from_embedded_url(embedded_url): DCNL '将 embed_real_url_to_embedded_url() 编码后的url转换为原来的带有参数的url DCNL `cdn_redirect_encode_query_str_into_url`设置依赖于本函数, 详细说明请看配置文件中这个参数的部分 DCNL eg: https://cdn.domain.com/a.php_zm24_.cT1zb21ldGhpbmc=._zm24_.css DCNL ---> https://foo.com/a.php?q=something (assume it returns an css) (base64 only) DCNL eg2: https://cdn.domain.com/a/b/_zm24_.bG92ZT1saXZl._zm24_.jpg DCNL ---> https://foo.com/a/b/?love=live (assume it returns an jpg) (base64 only) DCNL eg3: https://cdn.domain.com/a/b/_zm24z_.[some long long base64 encoded string]._zm24_.jpg DCNL ---> https://foo.com/a/b/?love=live[and a long long query string] (assume it returns an jpg) (gzip + base64) DCNL eg4:https://cdn.domain.com/a  (no change) DCNL ---> (no query string): https://foo.com/a (assume it returns an png) (no change) DCNL :param embedded_url: 可能被编码的URL DCNL :return: 如果传入的是编码后的URL, 则返回解码后的URL, 否则返回None DCNL :type embedded_url: str DCNL :rtype: Union[str, None]'
def fetch_20newsgroups(data_home=None, subset='train', categories=None, shuffle=True, random_state=42, remove=(), download_if_missing=True): DCNL 'Load the filenames and data from the 20 newsgroups dataset. DCNL Read more in the :ref:`User Guide <20newsgroups>`. DCNL Parameters DCNL subset : \'train\' or \'test\', \'all\', optional DCNL Select the dataset to load: \'train\' for the training set, \'test\' DCNL for the test set, \'all\' for both, with shuffled ordering. DCNL data_home : optional, default: None DCNL Specify a download and cache folder for the datasets. If None, DCNL all scikit-learn data is stored in \'~/scikit_learn_data\' subfolders. DCNL categories : None or collection of string or unicode DCNL If None (default), load all the categories. DCNL If not None, list of category names to load (other categories DCNL ignored). DCNL shuffle : bool, optional DCNL Whether or not to shuffle the data: might be important for models that DCNL make the assumption that the samples are independent and identically DCNL distributed (i.i.d.), such as stochastic gradient descent. DCNL random_state : numpy random number generator or seed integer DCNL Used to shuffle the dataset. DCNL download_if_missing : optional, True by default DCNL If False, raise an IOError if the data is not locally available DCNL instead of trying to download the data from the source site. DCNL remove : tuple DCNL May contain any subset of (\'headers\', \'footers\', \'quotes\'). Each of DCNL these are kinds of text that will be detected and removed from the DCNL newsgroup posts, preventing classifiers from overfitting on DCNL metadata. DCNL \'headers\' removes newsgroup headers, \'footers\' removes blocks at the DCNL ends of posts that look like signatures, and \'quotes\' removes lines DCNL that appear to be quoting another post. DCNL \'headers\' follows an exact standard; the other filters are not always DCNL correct.'
def get_body_region(defined): DCNL 'Return the start and end offsets of function body'
def open_tasks_for_project(): DCNL 'Simplified controller to select a project and open the DCNL list of open tasks for it'
def get_node_host(name, region=None, key=None, keyid=None, profile=None): DCNL 'Get hostname from cache node DCNL CLI example:: DCNL salt myminion boto_elasticache.get_node_host myelasticache'
def __virtual__(): DCNL 'Set up the libcloud functions and check for Rackspace configuration.'
def _enum_to_int(value): DCNL 'Convert an IntEnum member to a numeric value. DCNL If it\'s not an IntEnum member return the value itself.'
def winsorize(a, limits=None, inclusive=(True, True), inplace=False, axis=None): DCNL 'Returns a Winsorized version of the input array. DCNL The (limits[0])th lowest values are set to the (limits[0])th percentile, DCNL and the (limits[1])th highest values are set to the (1 - limits[1])th DCNL percentile. DCNL Masked values are skipped. DCNL Parameters DCNL a : sequence DCNL Input array. DCNL limits : {None, tuple of float}, optional DCNL Tuple of the percentages to cut on each side of the array, with respect DCNL to the number of unmasked data, as floats between 0. and 1. DCNL Noting n the number of unmasked data before trimming, the DCNL (n*limits[0])th smallest data and the (n*limits[1])th largest data are DCNL masked, and the total number of unmasked data after trimming DCNL is n*(1.-sum(limits)) The value of one limit can be set to None to DCNL indicate an open interval. DCNL inclusive : {(True, True) tuple}, optional DCNL Tuple indicating whether the number of data being masked on each side DCNL should be rounded (True) or truncated (False). DCNL inplace : {False, True}, optional DCNL Whether to winsorize in place (True) or to use a copy (False) DCNL axis : {None, int}, optional DCNL Axis along which to trim. If None, the whole array is trimmed, but its DCNL shape is maintained. DCNL Notes DCNL This function is applied to reduce the effect of possibly spurious outliers DCNL by limiting the extreme values.'
def maybe_add_auth(url, auth, force=False): DCNL 'Add auth if the url doesn\'t currently have it. DCNL By default, does not replace auth if it already exists.  Setting ``force`` to ``True`` DCNL overrides this behavior. DCNL Examples: DCNL >>> maybe_add_auth("https://www.conda.io", "user:passwd") DCNL \'https://user:passwd@www.conda.io\''
def date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs): DCNL 'Return a fixed frequency datetime index, with day (calendar) as the default DCNL frequency DCNL Parameters DCNL start : string or datetime-like, default None DCNL Left bound for generating dates DCNL end : string or datetime-like, default None DCNL Right bound for generating dates DCNL periods : integer or None, default None DCNL If None, must specify start and end DCNL freq : string or DateOffset, default \'D\' (calendar daily) DCNL Frequency strings can have multiples, e.g. \'5H\' DCNL tz : string or None DCNL Time zone name for returning localized DatetimeIndex, for example DCNL Asia/Hong_Kong DCNL normalize : bool, default False DCNL Normalize start/end dates to midnight before generating date range DCNL name : str, default None DCNL Name of the resulting index DCNL closed : string or None, default None DCNL Make the interval closed with respect to the given frequency to DCNL the \'left\', \'right\', or both sides (None) DCNL Notes DCNL 2 of start, end, or periods must be specified DCNL To learn more about the frequency strings, please see `this link DCNL <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__. DCNL Returns DCNL rng : DatetimeIndex'
def p_external_declaration_2(t): DCNL 'external_declaration : declaration'
def update_cached_instance(sender, instance, **kwargs): DCNL 'Re-cache the given instance in the idmapper cache.'
def capfirst(value): DCNL 'Capitalizes the first character of the value'
def blank_lines(logical_line, blank_lines, indent_level, line_number, previous_logical): DCNL 'Separate top-level function and class definitions with two blank lines. DCNL Method definitions inside a class are separated by a single blank line. DCNL Extra blank lines may be used (sparingly) to separate groups of related DCNL functions.  Blank lines may be omitted between a bunch of related DCNL one-liners (e.g. a set of dummy implementations). DCNL Use blank lines in functions, sparingly, to indicate logical sections.'
def setup_scanner(hass, config, see): DCNL 'Setup the Host objects and return the update function.'
def is_monotonic(Z): DCNL 'Returns True if the linkage passed is monotonic. DCNL The linkage is monotonic if for every cluster :math:`s` and :math:`t` DCNL joined, the distance between them is no less than the distance DCNL between any previously joined clusters. DCNL Parameters DCNL Z : ndarray DCNL The linkage matrix to check for monotonicity. DCNL Returns DCNL b : bool DCNL A boolean indicating whether the linkage is monotonic.'
def _create_trigger(trigger_type): DCNL ':param trigger_type: TriggerType db object. DCNL :type trigger_type: :class:`TriggerTypeDB`'
def sdm_LC(f, K): DCNL 'Returns the leading coeffcient of ``f``.'
def compile_file(fullname, ddir=None, force=0, rx=None, quiet=0): DCNL 'Byte-compile one file. DCNL Arguments (only fullname is required): DCNL fullname:  the file to byte-compile DCNL ddir:      if given, the directory name compiled in to the DCNL byte-code file. DCNL force:     if 1, force compilation, even if timestamps are up-to-date DCNL quiet:     if 1, be quiet during compilation'
def hrm_human_resource_controller(extra_filter=None): DCNL 'Human Resources Controller, defined in the model for use from DCNL multiple controllers for unified menus DCNL - used for Summary & Profile views, Imports and S3AddPersonWidget2'
def getLoopsWithCorners(corners, importRadius, loops, pointTable): DCNL 'Add corners to the loops.'
def validate(obj, obj_type): DCNL 'Validate a dictionary, list, or graph object as \'obj_type\'. DCNL This will not alter the \'obj\' referenced in the call signature. It will DCNL raise an error if the \'obj\' reference could not be instantiated as a DCNL valid \'obj_type\' graph object.'
@retry(exception=(EnvironmentError, AssertionError), logfun=None, timeout=GLOBAL_TIMEOUT, interval=0.001) DCNL def wait_for_file(fname, delete_file=True, empty=False): DCNL 'Wait for a file to be written on disk with some content.'
def py_encode_basestring_ascii(s): DCNL 'Return an ASCII-only JSON representation of a Python string'
def load(f, persistent_load=PersistentNdarrayLoad): DCNL 'Load a file that was dumped to a zip file. DCNL :param f: The file handle to the zip file to load the object from. DCNL :type f: file DCNL :param persistent_load: The persistent loading function to use for DCNL unpickling. This must be compatible with the `persisten_id` function DCNL used when pickling. DCNL :type persistent_load: callable, optional DCNL .. versionadded:: 0.8'
def linear_transform_weights(input_dim, output_dim, param_list=None, name=''): DCNL 'theano shared variable given input and output dimension'
def bfs_beam_edges(G, source, value, width=None): DCNL 'Iterates over edges in a beam search. DCNL The beam search is a generalized breadth-first search in which only DCNL the "best" *w* neighbors of the current node are enqueued, where *w* DCNL is the beam width and "best" is an application-specific DCNL heuristic. In general, a beam search with a small beam width might DCNL not visit each node in the graph. DCNL Parameters DCNL G : NetworkX graph DCNL source : node DCNL Starting node for the breadth-first search; this function DCNL iterates over only those edges in the component reachable from DCNL this node. DCNL value : function DCNL A function that takes a node of the graph as input and returns a DCNL real number indicating how "good" it is. A higher value means it DCNL is more likely to be visited sooner during the search. When DCNL visiting a new node, only the `width` neighbors with the highest DCNL `value` are enqueued (in decreasing order of `value`). DCNL width : int (default = None) DCNL The beam width for the search. This is the number of neighbors DCNL (ordered by `value`) to enqueue when visiting each new node. DCNL Yields DCNL edge DCNL Edges in the beam search starting from `source`, given as a pair DCNL of nodes. DCNL Examples DCNL To give nodes with, for example, a higher centrality precedence DCNL during the search, set the `value` function to return the centrality DCNL value of the node:: DCNL >>> G = nx.karate_club_graph() DCNL >>> centrality = nx.eigenvector_centrality(G) DCNL >>> source = 0 DCNL >>> width = 5 DCNL >>> for u, v in nx.bfs_beam_edges(G, source, centrality.get, width): DCNL ...     print((u, v))  # doctest: +SKIP'
def repeat(sequence): DCNL 'Return a driver function that can advance a repeated of values. DCNL .. code-block:: none DCNL seq = [0, 1, 2, 3] DCNL # repeat(seq) => [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, ...] DCNL Args: DCNL sequence (seq) : a sequence of values for the driver to bounce'
def dump_and_add_to_dump(object_, file_, parameters=None, to_add=None, use_cpickle=False, protocol=DEFAULT_PROTOCOL, **kwargs): DCNL 'Calls both `dump` and `add_to_dump` to serialze several objects. DCNL This function is used to serialize several at the same time, using DCNL persistent ID. Its main advantage is that it can be used with DCNL `secure_dump`. DCNL Parameters DCNL object_ : object DCNL The object to pickle. If None, only the parameters passed to the DCNL `parameters` argument will be saved. DCNL file_ : file DCNL The destination for saving. DCNL parameters : list, optional DCNL Shared variables whose internal numpy arrays should be saved DCNL separately in the `_parameters` field of the tar file. DCNL to_add : dict of objects DCNL A {\'name\': object} dictionnary of additional objects to save in DCNL the tar archive. Its keys will be used as name in the tar file. DCNL use_cpickle : bool DCNL Use cPickle instead of pickle. Setting it to true will disable the DCNL warning message if you try to pickle objects from the main module, DCNL so be sure that there is no warning before turning this flag DCNL on. Default: False. DCNL protocol : int, optional DCNL The pickling protocol to use. Unlike Python\'s built-in pickle, the DCNL default is set to `2` instead of 0 for Python 2. The Python 3 DCNL default (level 3) is maintained. DCNL \*\*kwargs DCNL Keyword arguments to be passed to `pickle.Pickler`.'
def write_file(filename, contents): DCNL 'Create a file with the specified name and write \'contents\' (a DCNL sequence of strings without line terminators) to it.'
def _tgrep_nltk_tree_pos_action(_s, _l, tokens): DCNL 'Builds a lambda function representing a predicate on a tree node DCNL which returns true if the node is located at a specific tree DCNL position.'
def filter_factory(global_conf, **local_conf): DCNL 'Returns a WSGI filter app for use with paste.deploy.'
def createBrushMask(shape, style='Round', offset=(0, 0, 0), box=None, chance=100, hollow=False): DCNL 'Return a boolean array for a brush with the given shape and style. DCNL If \'offset\' and \'box\' are given, then the brush is offset into the world DCNL and only the part of the world contained in box is returned as an array'
def get_ordered_categories(): DCNL 'Return list-copy of categories section that\'s ordered DCNL by user\'s ordering including Default-category'
def getCraftedTextFromText(gcodeText, towerRepository=None): DCNL 'Tower a gcode linear move text.'
@handle_response_format DCNL @treeio_login_required DCNL def service_add(request, response_format='html'): DCNL 'Service add'
def nlargest(n, iterable, key=None): DCNL 'Find the n largest elements in a dataset. DCNL Equivalent to:  sorted(iterable, key=key, reverse=True)[:n]'
def active(display_progress=False): DCNL 'Return a report on all actively running jobs from a job id centric DCNL perspective DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-run jobs.active'
def openshift_deploy_canceller(registry, xml_parent, data): DCNL 'yaml: openshift-deploy-canceller DCNL This action is intended to provide cleanup for any OpenShift deployments DCNL left running when the Job completes; this step will allow you to perform DCNL the equivalent of a oc deploy --cancel for the provided deployment config. DCNL Requires the Jenkins :jenkins-wiki:`OpenShift DCNL Pipeline Plugin <OpenShift+Pipeline+Plugin>`. DCNL :arg str api-url: this would be the value you specify if you leverage the DCNL --server option on the OpenShift `oc` command. DCNL (default \'\https://openshift.default.svc.cluster.local\') DCNL :arg str dep-cfg: The value here should be whatever was the output DCNL form `oc project` when you created the BuildConfig you want to run a DCNL Build on (default frontend) DCNL :arg str namespace: If you run `oc get bc` for the project listed in DCNL "namespace", that is the value you want to put here. (default \'test\') DCNL :arg str auth-token: The value here is what you supply with the --token DCNL option when invoking the OpenShift `oc` command. (default \'\') DCNL :arg bool verbose: This flag is the toggle for DCNL turning on or off detailed logging in this plug-in. (default false) DCNL Full Example: DCNL .. literalinclude:: DCNL ../../tests/publishers/fixtures/openshift-deploy-canceller001.yaml DCNL :language: yaml DCNL Minimal Example: DCNL .. literalinclude:: DCNL ../../tests/publishers/fixtures/openshift-deploy-canceller002.yaml DCNL :language: yaml'
@with_open_mode('r') DCNL @with_sizes('medium') DCNL def seek_forward_blockwise(f): DCNL 'seek forward 1000 units at a time'
@register.filter DCNL @stringfilter DCNL def cut(value, arg): DCNL 'Removes all values of arg from the given string.'
def format_source_url(url): DCNL 'Format URL suitable for \'Source\' stage'
def string_escape(text): DCNL 'Escape values special to javascript in strings. DCNL With this we should be able to use something like: DCNL elem.evaluateJavaScript("this.value=\'{}\'".format(string_escape(...))) DCNL And all values should work.'
def _list_files(path, suffix=''): DCNL '.. todo:: DCNL WRITEME DCNL Parameters DCNL path : str DCNL a filepath DCNL suffix : str DCNL Returns DCNL l : list DCNL A list of all files ending in `suffix` contained within `path`. DCNL (If `path` is a file rather than a directory, it is considered DCNL to "contain" itself)'
def parse(handle, **kwargs): DCNL 'Iterate over the trees in a CDAO file handle. DCNL :returns: generator of Bio.Phylo.CDAO.Tree objects.'
@datastore_rpc._positional(1) DCNL def inject_results(query, updated_entities=None, deleted_keys=None): DCNL 'Creates a query object that will inject changes into results. DCNL Args: DCNL query: The datastore_query.Query to augment DCNL updated_entities: A list of entity_pb.EntityProto\'s that have been updated DCNL and should take priority over any values returned by query. DCNL deleted_keys: A list of entity_pb.Reference\'s for entities that have been DCNL deleted and should be removed from query results. DCNL Returns: DCNL A datastore_query.AugmentedQuery if in memory filtering is required, DCNL query otherwise.'
def encoded_hash(sha): DCNL 'Return a short, 7-bit-safe representation of a hash. DCNL If you pass a sha256, this results in the hash algorithm that the Wheel DCNL format (PEP 427) uses, except here it\'s intended to be run across the DCNL downloaded archive before unpacking.'
def cos(x): DCNL 'Computes cos of x element-wise. DCNL # Arguments DCNL x: input tensor. DCNL # Returns DCNL A tensor.'
def getRadiusAverage(radiusComplex): DCNL 'Get average radius from radiusComplex.'
def test_lambda(n): DCNL '>>> [f() for f in test_lambda(3)] DCNL [0, 1, 2]'
def simplefilter(f): DCNL 'Decorator that converts a function into a filter:: DCNL @simplefilter DCNL def lowercase(lexer, stream, options): DCNL for ttype, value in stream: DCNL yield ttype, value.lower()'
def returner(ret): DCNL 'Return data to a remote carbon server using the text metric protocol DCNL Each metric will look like:: DCNL [module].[function].[minion_id].[metric path [...]].[metric name]'
def decode_byte_list(byte_list): DCNL 'Helper function that takes a list of byte strings and decodes each item DCNL according to the __salt_system_encoding__ value. Returns a list of strings.'
def organization_purge(context, data_dict): DCNL 'Purge an organization. DCNL .. warning:: Purging an organization cannot be undone! DCNL Purging an organization completely removes the organization from the CKAN DCNL database, whereas deleting an organization simply marks the organization as DCNL deleted (it will no longer show up in the frontend, but is still in the DCNL db). DCNL Datasets owned by the organization will remain, just not in an DCNL organization any more. DCNL You must be authorized to purge the organization. DCNL :param id: the name or id of the organization to be purged DCNL :type id: string'
def tests_get_by_job_idx(job_idx): DCNL 'Returns all tests based on its job idx'
def mod_aggregate(low, chunks, running): DCNL 'The mod_aggregate function which looks up all rules in the available DCNL low chunks and merges them into a single rules ref in the present low data'
def xsym(sym): DCNL 'get symbology for a \'character\''
def require(divisions, parts, required=None): DCNL 'Clear out divisions where required components are not present DCNL In left, right, or inner joins we exclude portions of the dataset if one DCNL side or the other is not present.  We can achieve this at the partition DCNL level as well DCNL >>> divisions = [1, 3, 5, 7, 9] DCNL >>> parts = [((\'a\', 0), None), DCNL ...          ((\'a\', 1), (\'b\', 0)), DCNL ...          ((\'a\', 2), (\'b\', 1)), DCNL ...          (None, (\'b\', 2))] DCNL >>> divisions2, parts2 = require(divisions, parts, required=[0]) DCNL >>> divisions2 DCNL (1, 3, 5, 7) DCNL >>> parts2  # doctest: +NORMALIZE_WHITESPACE DCNL (((\'a\', 0), None), DCNL ((\'a\', 1), (\'b\', 0)), DCNL ((\'a\', 2), (\'b\', 1))) DCNL >>> divisions2, parts2 = require(divisions, parts, required=[1]) DCNL >>> divisions2 DCNL (3, 5, 7, 9) DCNL >>> parts2  # doctest: +NORMALIZE_WHITESPACE DCNL (((\'a\', 1), (\'b\', 0)), DCNL ((\'a\', 2), (\'b\', 1)), DCNL (None, (\'b\', 2))) DCNL >>> divisions2, parts2 = require(divisions, parts, required=[0, 1]) DCNL >>> divisions2 DCNL (3, 5, 7) DCNL >>> parts2  # doctest: +NORMALIZE_WHITESPACE DCNL (((\'a\', 1), (\'b\', 0)), DCNL ((\'a\', 2), (\'b\', 1)))'
def separate_users(node, user_ids): DCNL 'Separates users into ones with permissions and ones without given a list. DCNL :param node: Node to separate based on permissions DCNL :param user_ids: List of ids, will also take and return User instances DCNL :return: list of subbed, list of removed user ids'
def hash_of_file(path): DCNL 'Return the hash of a downloaded file.'
@protocol.commands.add(u'rescan') DCNL def rescan(context, uri=None): DCNL '*musicpd.org, music database section:* DCNL ``rescan [URI]`` DCNL Same as ``update``, but also rescans unmodified files.'
def test_record_good(): DCNL 'Tests that when we record a sequence of events, then DCNL repeat it exactly, the Record class: DCNL 1) Records it correctly DCNL 2) Does not raise any errors'
def docker_custom_build_env(registry, xml_parent, data): DCNL 'yaml: docker-custom-build-env DCNL Allows the definition of a build environment for a job using a Docker DCNL container. DCNL Requires the Jenkins :jenkins-wiki:`CloudBees Docker Custom Build DCNL Environment Plugin<CloudBees+Docker+Custom+Build+Environment+Plugin>`. DCNL :arg str image-type: Docker image type. Valid values and their DCNL additional attributes described in the image_types_ table DCNL :arg str docker-tool: The name of the docker installation to use DCNL (default \'Default\') DCNL :arg str host: URI to the docker host you are using DCNL :arg str credentials-id: Argument to specify the ID of credentials to use DCNL for docker host (optional) DCNL :arg str registry-credentials-id: Argument to specify the ID of DCNL credentials to use for docker registry (optional) DCNL :arg list volumes: Volumes to bind mound from slave host into container DCNL :volume: * **host-path** (`str`) Path on host DCNL * **path** (`str`) Path inside container DCNL :arg bool verbose: Log docker commands executed by plugin on build log DCNL (default false) DCNL :arg bool privileged: Run in privileged mode (default false) DCNL :arg bool force-pull: Force pull (default false) DCNL :arg str group: The user to run build has to be the same as the Jenkins DCNL slave user so files created in workspace have adequate owner and DCNL permission set DCNL :arg str command: Container start command (default \'/bin/cat\') DCNL :arg str net: Network bridge (default \'bridge\') DCNL .. _image_types: DCNL Image Type         Description DCNL dockerfile         Build docker image from a Dockerfile in project DCNL workspace. With this option, project can define the DCNL build environment as a Dockerfile stored in SCM with DCNL project source code DCNL :context-path: (str) Path to docker context DCNL (default \'.\') DCNL :dockerfile: (str) Use an alternate Dockerfile to DCNL build the container hosting this build DCNL (default \'Dockerfile\') DCNL pull               Pull specified docker image from Docker repository DCNL :image: (str) Image id/tag DCNL Example: DCNL .. literalinclude:: DCNL /../../tests/wrappers/fixtures/docker-custom-build-env001.yaml DCNL :language: yaml'
def _SecToUsec(t): DCNL 'Converts a time in seconds since the epoch to usec since the epoch. DCNL Args: DCNL t: Time in seconds since the unix epoch DCNL Returns: DCNL An integer containing the number of usec since the unix epoch.'
def auth(username, password, **kwargs): DCNL 'Returns True if the given user cert (password is the cert contents) DCNL was issued by the CA and if cert\'s Common Name is equal to username. DCNL Returns False otherwise. DCNL ``username``: we need it to run the auth function from CLI/API; DCNL it should be in master config auth/acl DCNL ``password``: contents of user certificate (pem-encoded user public key); DCNL why "password"? For CLI, it\'s the only available name DCNL Configure the CA cert in the master config file: DCNL .. code-block:: yaml DCNL external_auth: DCNL pki: DCNL ca_file: /etc/pki/tls/ca_certs/trusted-ca.crt DCNL your_user:'
def MapItemsIterator(function, items): DCNL 'Maps ItemsIterator via given function.'
def _revs_equal(rev1, rev2, rev_type): DCNL 'Shorthand helper function for comparing SHA1s. If rev_type == \'sha1\' then DCNL the comparison will be done using str.startwith() to allow short SHA1s to DCNL compare successfully. DCNL NOTE: This means that rev2 must be the short rev.'
def check_virtualserver(lb, name): DCNL 'Check to see if a virtual server exists DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt-run f5.check_virtualserver load_balancer virtual_server'
def cpu_freq(): DCNL 'Return CPU frequency. DCNL On Windows per-cpu frequency is not supported.'
def add_permission(user, model, permission_codename): DCNL 'Add a permission to a user. DCNL Creates the permission if it doesn\'t exist.'
def git(registry, xml_parent, data): DCNL 'yaml: git DCNL This plugin will configure the Jenkins Git plugin to DCNL push merge results, tags, and/or branches to DCNL remote repositories after the job completes. DCNL Requires the Jenkins :jenkins-wiki:`Git Plugin <Git+Plugin>`. DCNL :arg bool push-merge: push merges back to the origin specified in the DCNL pre-build merge options (default false) DCNL :arg bool push-only-if-success: Only push to remotes if the build succeeds DCNL - otherwise, nothing will be pushed. DCNL (default true) DCNL :arg bool force-push: Add force option to git push (default false) DCNL :arg list tags: tags to push at the completion of the build DCNL :tag: * **remote** (`str`) remote repo name to push to DCNL (default \'origin\') DCNL * **name** (`str`) name of tag to push DCNL * **message** (`str`) message content of the tag DCNL * **create-tag** (`bool`) whether or not to create the tag DCNL after the build, if this is False then the tag needs to DCNL exist locally (default false) DCNL * **update-tag** (`bool`) whether to overwrite a remote tag DCNL or not (default false) DCNL :arg list branches: branches to push at the completion of the build DCNL :branch: * **remote** (`str`) remote repo name to push to DCNL (default \'origin\') DCNL * **name** (`str`) name of remote branch to push to DCNL :arg list notes: notes to push at the completion of the build DCNL :note: * **remote** (`str`) remote repo name to push to DCNL (default \'origin\') DCNL * **message** (`str`) content of the note DCNL * **namespace** (`str`) namespace of the note DCNL (default master) DCNL * **replace-note** (`bool`) whether to overwrite a note or not DCNL (default false) DCNL Example: DCNL .. literalinclude:: /../../tests/publishers/fixtures/git001.yaml DCNL :language: yaml'
def preserve_value(namespace, name): DCNL 'Function decorator to wrap a function that sets a namespace item. DCNL In particular if we modify a global namespace and want to restore the value DCNL after we have finished, use this function. DCNL This is decorator version of the context manager from DCNL http://stackoverflow.com/a/6811921. We use a decorator since Python 2.4 DCNL doesn\'t have context managers. DCNL :param namespace: namespace to modify, e.g. sys DCNL :type namespace: object DCNL :param name: attribute in the namespace, e.g. dont_write_bytecode DCNL :type name: str DCNL :return: New function decorator that wraps the attribute modification DCNL :rtype: function'
def to_marshallable_type(obj): DCNL 'Helper for converting an object to a dictionary only if it is not DCNL dictionary already or an indexable object nor a simple type'
def random_shift(x, wrg, hrg, row_axis=1, col_axis=2, channel_axis=0, fill_mode='nearest', cval=0.0): DCNL 'Performs a random spatial shift of a Numpy image tensor. DCNL # Arguments DCNL x: Input tensor. Must be 3D. DCNL wrg: Width shift range, as a float fraction of the width. DCNL hrg: Height shift range, as a float fraction of the height. DCNL row_axis: Index of axis for rows in the input tensor. DCNL col_axis: Index of axis for columns in the input tensor. DCNL channel_axis: Index of axis for channels in the input tensor. DCNL fill_mode: Points outside the boundaries of the input DCNL are filled according to the given mode DCNL (one of `{\'constant\', \'nearest\', \'reflect\', \'wrap\'}`). DCNL cval: Value used for points outside the boundaries DCNL of the input if `mode=\'constant\'`. DCNL # Returns DCNL Shifted Numpy image tensor.'
def build_repository_type_select_field(trans, repository=None, name='repository_type'): DCNL 'Called from the Tool Shed to generate the current list of supported repository types.'
def dict_factory(cursor, row): DCNL 'Return a dictionary for the current database position'
@cinder_utils.trace_method DCNL @cinder_utils.synchronized('map_es_volume') DCNL def map_volume_to_single_host(client, volume, eseries_vol, host, vol_map, multiattach_enabled): DCNL 'Maps the e-series volume to host with initiator.'
def get_dependencies(): DCNL 'Warn if dependencies aren\'t met.'
def save_sent_email(crispin_client, account_id, message_id): DCNL 'Create an email on the remote backend. Generic providers expect DCNL us to create a copy of the message in the sent folder.'
def polygamma(n, x): DCNL 'Polygamma function n. DCNL This is the nth derivative of the digamma (psi) function. DCNL Parameters DCNL n : array_like of int DCNL The order of the derivative of `psi`. DCNL x : array_like DCNL Where to evaluate the polygamma function. DCNL Returns DCNL polygamma : ndarray DCNL The result. DCNL Examples DCNL >>> from scipy import special DCNL >>> x = [2, 3, 25.5] DCNL >>> special.polygamma(1, x) DCNL array([ 0.64493407,  0.39493407,  0.03999467]) DCNL >>> special.polygamma(0, x) == special.psi(x) DCNL array([ True,  True,  True], dtype=bool)'
def safe_minidom_parse_string(xml_string): DCNL 'Parse an XML string using minidom safely.'
def add_indep(x, varnames, dtype=None): DCNL 'construct array with independent columns DCNL x is either iterable (list, tuple) or instance of ndarray or a subclass of it. DCNL If x is an ndarray, then each column is assumed to represent a variable with DCNL observations in rows.'
def prompt_n(msg, inputs): DCNL 'Presents the user with N input widgets and returns the results'
def run(app=None, server='wsgiref', host='127.0.0.1', port=8080, interval=1, reloader=False, quiet=False, plugins=None, debug=None, config=None, **kargs): DCNL 'Start a server instance. This method blocks until the server terminates. DCNL :param app: WSGI application or target string supported by DCNL :func:`load_app`. (default: :func:`default_app`) DCNL :param server: Server adapter to use. See :data:`server_names` keys DCNL for valid names or pass a :class:`ServerAdapter` subclass. DCNL (default: `wsgiref`) DCNL :param host: Server address to bind to. Pass ``0.0.0.0`` to listens on DCNL all interfaces including the external one. (default: 127.0.0.1) DCNL :param port: Server port to bind to. Values below 1024 require root DCNL privileges. (default: 8080) DCNL :param reloader: Start auto-reloading server? (default: False) DCNL :param interval: Auto-reloader interval in seconds (default: 1) DCNL :param quiet: Suppress output to stdout and stderr? (default: False) DCNL :param options: Options passed to the server adapter.'
def _check_for_exception_catch(evaluator, jedi_obj, exception, payload=None): DCNL 'Checks if a jedi object (e.g. `Statement`) sits inside a try/catch and DCNL doesn\'t count as an error (if equal to `exception`). DCNL Also checks `hasattr` for AttributeErrors and uses the `payload` to compare DCNL it. DCNL Returns True if the exception was catched.'
def dent(individual, lambda_=0.85): DCNL 'Test problem Dent. Two-objective problem with a "dent". *individual* has DCNL two attributes that take values in [-1.5, 1.5]. DCNL From: Schuetze, O., Laumanns, M., Tantar, E., Coello Coello, C.A., & Talbi, E.-G. (2010). DCNL Computing gap free Pareto front approximations with stochastic search algorithms. DCNL Evolutionary Computation, 18(1), 65--96. doi:10.1162/evco.2010.18.1.18103 DCNL Note that in that paper Dent source is stated as: DCNL K. Witting and M. Hessel von Molo. Private communication, 2006.'
def hours(h): DCNL 'Return hours as days.'
def test_retry_on_normal_error(collect): DCNL 'Ensure retries are processed for most errors.'
def createFactoryCopy(state): DCNL 'Factory of L{SimpleFactoryCopy}, getting a created instance given the DCNL C{id} found in C{state}.'
def clone(git_path, module, repo, dest, remote, depth, version, bare, reference, refspec, verify_commit): DCNL 'makes a new git repo if it does not already exist'
def send_email(subject=None, recipients=[], html=''): DCNL 'Given a message, will send that message over SES or SMTP, depending upon how the app is configured.'
def load_pandas(): DCNL 'Load the Spector dataset and returns a Dataset class instance. DCNL Returns DCNL Dataset instance: DCNL See DATASET_PROPOSAL.txt for more information.'
def schedule_delayed_delete_from_backend(context, image_id, location): DCNL 'Given a location, schedule the deletion of an image location and DCNL update location status to db. DCNL :param context: The request context DCNL :param image_id: The image identifier DCNL :param location: The image location entry'
def cache_page(*args, **kwargs): DCNL 'Decorator for views that tries getting the page from the cache and DCNL populates the cache if the page isn\'t in the cache yet. DCNL The cache is keyed by the URL and some data from the headers. DCNL Additionally there is the key prefix that is used to distinguish different DCNL cache areas in a multi-site setup. You could use the DCNL sites.get_current().domain, for example, as that is unique across a Django DCNL project. DCNL Additionally, all headers from the response\'s Vary header will be taken DCNL into account on caching -- just like the middleware does.'
def _warn_node(self, msg, node, *args, **kwargs): DCNL 'Mute warnings that are like ``WARNING: nonlocal image URI found: https://img. ...`` DCNL Solution was found by googling, copied it from SO: DCNL http://stackoverflow.com/questions/12772927/specifying-an-online-image-in-sphinx-restructuredtext-format'
def to_string(ip): DCNL 'Convert 32-bit integer to dotted IPv4 address.'
def setup_masquerade(request, course_key, staff_access=False, reset_masquerade_data=False): DCNL 'Sets up masquerading for the current user within the current request. The request\'s user is DCNL updated to have a \'masquerade_settings\' attribute with the dict of all masqueraded settings if DCNL called from within a request context. The function then returns a pair (CourseMasquerade, User) DCNL with the masquerade settings for the specified course key or None if there isn\'t one, and the DCNL user we are masquerading as or request.user if masquerading as a specific user is not active. DCNL If the reset_masquerade_data flag is set, the field data stored in the session will be cleared.'
def init_widgets(): DCNL 'Initialize the widgets subsystem. DCNL This will listen for events in order to manage the widget caches.'
def get_client(env): DCNL 'Guesses the client address from the environment variables DCNL First tries \'http_x_forwarded_for\', secondly \'remote_addr\' DCNL if all fails, assume \'127.0.0.1\' or \'::1\' (running locally)'
def is_internal_attribute(obj, attr): DCNL 'Test if the attribute given is an internal python attribute.  For DCNL example this function returns `True` for the `func_code` attribute of DCNL python objects.  This is useful if the environment method DCNL :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden. DCNL >>> from jinja2.sandbox import is_internal_attribute DCNL >>> is_internal_attribute(str, "mro") DCNL True DCNL >>> is_internal_attribute(str, "upper") DCNL False'
def all_pairs_shortest_path(G, cutoff=None): DCNL 'Compute shortest paths between all nodes. DCNL Parameters DCNL G : NetworkX graph DCNL cutoff : integer, optional DCNL Depth at which to stop the search. Only paths of length at most DCNL `cutoff` are returned. DCNL Returns DCNL lengths : dictionary DCNL Dictionary, keyed by source and target, of shortest paths. DCNL Examples DCNL >>> G = nx.path_graph(5) DCNL >>> path = nx.all_pairs_shortest_path(G) DCNL >>> print(path[0][4]) DCNL [0, 1, 2, 3, 4] DCNL See Also DCNL floyd_warshall()'
def get_type_hints(obj, globalns=None, localns=None): DCNL 'In Python 2 this is not supported and always returns None.'
def _section_certificates(course): DCNL 'Section information for the certificates panel. DCNL The certificates panel allows global staff to generate DCNL example certificates and enable self-generated certificates DCNL for a course. DCNL Arguments: DCNL course (Course) DCNL Returns: DCNL dict'
def ms_payload(payload): DCNL 'Receives the input given by the user from create_payload.py DCNL and create_payloads.py'
def extract(path, to_path=''): DCNL 'Unpack the tar or zip file at the specified path to the directory DCNL specified by to_path.'
def parse_field_path(field_path): DCNL 'Take a path to a field like "mezzanine.pages.models.Page.feature_image" DCNL and return a model key, which is a tuple of the form (\'pages\', \'page\'), DCNL and a field name, e.g. "feature_image".'
def stub_set_host_enabled(context, host_name, enabled): DCNL 'Simulates three possible behaviours for VM drivers or compute drivers when DCNL enabling or disabling a host. DCNL \'enabled\' means new instances can go to this host DCNL \'disabled\' means they can\'t'
def secgroup_create(name, description, profile=None): DCNL 'Add a secgroup to nova (nova secgroup-create) DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nova.secgroup_create mygroup \'This is my security group\''
@nottest DCNL def _get_tests(fname, selector=None, nose_params=NOSE_COLLECT_PARAMS): DCNL 'Collect tests and return them. DCNL :param fname: The tests will be written to fname in xunit format DCNL :param selector: Tests are filtered based on selector DCNL :return: A test suite as returned by xunitparser with all the tests available DCNL in the w3af framework source code, without any selectors.'
@check_feature_enabled(feature_name='ENTRANCE_EXAMS') DCNL def create_entrance_exam(request, course_key, entrance_exam_minimum_score_pct): DCNL 'api method to create an entrance exam. DCNL First clean out any old entrance exams.'
def request_authenticate(request, username, password): DCNL 'Autenticate the given request (in place) using the HTTP basic access DCNL authentication mechanism (RFC 2617) and the given username and password'
def siva(x, y): DCNL 'Made me fall in love with Python'
def servicegroup_add(sg_name, sg_type='HTTP', **connection_args): DCNL 'Add a new service group DCNL If no service type is specified, HTTP will be used. DCNL Most common service types: HTTP, SSL, and SSL_BRIDGE DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' netscaler.servicegroup_add \'serviceGroupName\' DCNL salt \'*\' netscaler.servicegroup_add \'serviceGroupName\' \'serviceGroupType\''
def _is_ipv4_like(s): DCNL 'Find if a string superficially looks like an IPv4 address. DCNL AWS documentation plays it fast and loose with this; in other DCNL regions, it seems like even non-valid IPv4 addresses (in DCNL particular, ones that possess decimal numbers out of range for DCNL IPv4) are rejected.'
def parsehttpdate(string_): DCNL 'Parses an HTTP date into a datetime object. DCNL >>> parsehttpdate(\'Thu, 01 Jan 1970 01:01:01 GMT\') DCNL datetime.datetime(1970, 1, 1, 1, 1, 1)'
def unsafe_eval_enabled(response): DCNL 'Method to detect if CSP Policies are specified for Script, DCNL to allow use of the javascript "eval()" function. DCNL :param response: A HTTPResponse object. DCNL :return: True if CSP Policies are specified for Script to allow DCNL use of the javascript "eval()" function, False otherwise.'
def _to_micropennies_per_op(pennies, per): DCNL 'The price of a single op in micropennies.'
def find_xpath_with_wait(context, id_str, **kwargs): DCNL 'Tries to find an element with given XPATH with an explicit timeout. DCNL context: a behave context DCNL id_str: A string with the XPATH (no leading #) DCNL kwargs: can optionally pass "wait_time", which will be the max wait time in DCNL seconds. Default is defined by behave_helpers.py DCNL Returns the element if found or raises TimeoutException'
def subscribe(hass, callback): DCNL 'Subscribe to incoming ZigBee frames.'
def _current_component(view_func, dashboard=None, panel=None): DCNL 'Sets the currently-active dashboard and/or panel on the request.'
def modify_profile(hostname, username, password, profile_type, name, **kwargs): DCNL 'A function to connect to a bigip device and create a profile. DCNL A function to connect to a bigip device and create a profile. DCNL hostname DCNL The host/address of the bigip device DCNL username DCNL The iControl REST username DCNL password DCNL The iControl REST password DCNL profile_type DCNL The type of profile to create DCNL name DCNL The name of the profile to create DCNL kwargs DCNL ``[ arg=val ] ... [arg=key1:val1,key2:val2] ...`` DCNL Consult F5 BIGIP user guide for specific options for each monitor type. DCNL Typically, tmsh arg names are used. DCNL Creating Complex Args DCNL Profiles can get pretty complicated in terms of the amount of possible DCNL config options. Use the following shorthand to create complex arguments such DCNL as lists, dictionaries, and lists of dictionaries. An option is also DCNL provided to pass raw json as well. DCNL lists ``[i,i,i]``: DCNL ``param=\'item1,item2,item3\'`` DCNL Dictionary ``[k:v,k:v,k,v]``: DCNL ``param=\'key-1:val-1,key-2:val2,key-3:va-3\'`` DCNL List of Dictionaries ``[k:v,k:v|k:v,k:v|k:v,k:v]``: DCNL ``param=\'key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2\'`` DCNL JSON: ``\'j{ ... }j\'``: DCNL ``cert-key-chain=\'j{ "default": { "cert": "default.crt", "chain": "default.crt", "key": "default.key" } }j\'`` DCNL Escaping Delimiters: DCNL Use ``\,`` or ``\:`` or ``\|`` to escape characters which shouldn\'t DCNL be treated as delimiters i.e. ``ciphers=\'DEFAULT\:!SSLv3\'`` DCNL CLI Examples:: DCNL salt \'*\' bigip.modify_profile bigip admin admin http my-http-profile defaultsFrom=\'/Common/http\' DCNL salt \'*\' bigip.modify_profile bigip admin admin http my-http-profile defaultsFrom=\'/Common/http\' \ DCNL enforcement=maxHeaderCount:3200,maxRequests:10 DCNL salt \'*\' bigip.modify_profile bigip admin admin client-ssl my-client-ssl-1 retainCertificate=false \ DCNL ciphers=\'DEFAULT\:!SSLv3\' DCNL cert_key_chain=\'j{ "default": { "cert": "default.crt", "chain": "default.crt", "key": "default.key" } }j\''
def is_string_secure(string): DCNL 'Validates that this string does not contain any possible characters DCNL that are indicative of a security breach. DCNL Args: DCNL string: The string to validate DCNL Returns: DCNL True if the string is valid, False otherwise'
def _try_all(image, methods=None, figsize=None, num_cols=2, verbose=True): DCNL 'Returns a figure comparing the outputs of different methods. DCNL Parameters DCNL image : (N, M) ndarray DCNL Input image. DCNL methods : dict, optional DCNL Names and associated functions. DCNL Functions must take and return an image. DCNL figsize : tuple, optional DCNL Figure size (in inches). DCNL num_cols : int, optional DCNL Number of columns. DCNL verbose : bool, optional DCNL Print function name for each method. DCNL Returns DCNL fig, ax : tuple DCNL Matplotlib figure and axes.'
def size(N): DCNL 'size(N:long) : int DCNL Returns the size of the number N in bits.'
def _media_path_url_from_info(root_desc, path_url): DCNL 'Creates an absolute media path URL. DCNL Constructed using the API root URI and service path from the discovery DCNL document and the relative path for the API method. DCNL Args: DCNL root_desc: Dictionary; the entire original deserialized discovery document. DCNL path_url: String; the relative URL for the API method. Relative to the API DCNL root, which is specified in the discovery document. DCNL Returns: DCNL String; the absolute URI for media upload for the API method.'
def test_json(): DCNL 'Ensure that the json input format works as intended'
def convertFsDirWavToWav(dirName, Fs, nC): DCNL 'This function converts the WAV files stored in a folder to WAV using a different sampling freq and number of channels. DCNL ARGUMENTS: DCNL - dirName:             the path of the folder where the WAVs are stored DCNL - Fs:                  the sampling rate of the generated WAV files DCNL - nC:                  the number of channesl of the generated WAV files'
def parse_as_json(lines): DCNL 'Parse lines into json objects'
def _read_signify_ed25519_signature(signature_file): DCNL 'Read a Ed25519 signature file created with OpenBSD signify. DCNL http://man.openbsd.org/OpenBSD-current/man1/signify.1'
def glob_escape(input_string): DCNL 'Escapes the given string with ``[c]`` pattern. Examples: DCNL >>> from coalib.parsing.Globbing import glob_escape DCNL >>> glob_escape(\'test (1)\') DCNL \'test [(]1[)]\' DCNL >>> glob_escape(\'test folder?\') DCNL \'test folder[?]\' DCNL >>> glob_escape(\'test*folder\') DCNL \'test[*]folder\' DCNL :param input_string: String that is to be escaped with ``[ ]``. DCNL :return:             Escaped string in which all the special glob characters DCNL ``()[]|?*`` are escaped.'
def get_info(process=None, interval=0, with_childs=False): DCNL 'Return information about a process. (can be an pid or a Process object) DCNL If process is None, will return the information about the current process.'
def delete_blob(bucket_name, blob_name): DCNL 'Deletes a blob from the bucket.'
@must_be_valid_project DCNL @must_be_contributor_or_public DCNL @must_not_be_registration DCNL def togglewatch_post(auth, node, **kwargs): DCNL 'View for toggling watch mode for a node.'
def formatstring(cols, colwidth=_colwidth, spacing=_spacing): DCNL 'Returns a string formatted from n strings, centered within n columns.'
def import_library(taglib_module): DCNL 'Load a template tag library module. DCNL Verifies that the library contains a \'register\' attribute, and DCNL returns that attribute as the representation of the library'
def fdr_correction(pvals, alpha=0.05, method='indep'): DCNL 'P-value correction with False Discovery Rate (FDR). DCNL Correction for multiple comparison using FDR. DCNL This covers Benjamini/Hochberg for independent or positively correlated and DCNL Benjamini/Yekutieli for general or negatively correlated tests. DCNL Parameters DCNL pvals : array_like DCNL set of p-values of the individual tests. DCNL alpha : float DCNL error rate DCNL method : \'indep\' | \'negcorr\' DCNL If \'indep\' it implements Benjamini/Hochberg for independent or if DCNL \'negcorr\' it corresponds to Benjamini/Yekutieli. DCNL Returns DCNL reject : array, bool DCNL True if a hypothesis is rejected, False if not DCNL pval_corrected : array DCNL pvalues adjusted for multiple hypothesis testing to limit FDR DCNL Notes DCNL Reference: DCNL Genovese CR, Lazar NA, Nichols T. DCNL Thresholding of statistical maps in functional neuroimaging using the false DCNL discovery rate. Neuroimage. 2002 Apr;15(4):870-8.'
def p_namespace_scope(p): DCNL 'namespace_scope : \'*\' DCNL | IDENTIFIER'
def waist2rayleigh(w, wavelen): DCNL 'Calculate the rayleigh range from the waist of a gaussian beam. DCNL See Also DCNL rayleigh2waist, BeamParameter DCNL Examples DCNL >>> from sympy.physics.optics import waist2rayleigh DCNL >>> from sympy import symbols DCNL >>> w, wavelen = symbols(\'w wavelen\') DCNL >>> waist2rayleigh(w, wavelen) DCNL pi*w**2/wavelen'
def count_sprintf_parameters(string): DCNL 'Counts the number of sprintf parameters in a string.'
def GetBatchJob(client, batch_job_id): DCNL 'Retrieves the BatchJob with the given id. DCNL Args: DCNL client: an instantiated AdWordsClient used to retrieve the BatchJob. DCNL batch_job_id: a long identifying the BatchJob to be retrieved. DCNL Returns: DCNL The BatchJob associated with the given id.'
def reverse_url(handler_name, key_name=None, key_value=None, kwargs=None): DCNL 'Creates the URL for the given handler. DCNL The optional key_name and key_value are passed in as kwargs to the handler.'
def isInIOThread(): DCNL 'Are we in the thread responsible for I/O requests (the event loop)?'
def scan_postfix_cleanup_line(date, _, collector): DCNL 'Scan a postfix cleanup log line and extract interesting data DCNL It is assumed that every log of postfix/cleanup indicates an email that was successfulfy received by Postfix.'
def test_different_caller(): DCNL 'It\'s possible to not use names, but another function result or an array DCNL index and then get the call signature of it.'
def fuse_getitem(dsk, func, place): DCNL 'Fuse getitem with lower operation DCNL Parameters DCNL dsk: dict DCNL dask graph DCNL func: function DCNL A function in a task to merge DCNL place: int DCNL Location in task to insert the getitem key DCNL Examples DCNL >>> def load(store, partition, columns): DCNL ...     pass DCNL >>> dsk = {\'x\': (load, \'store\', \'part\', [\'a\', \'b\']), DCNL ...        \'y\': (getitem, \'x\', \'a\')} DCNL >>> dsk2 = fuse_getitem(dsk, load, 3)  # columns in arg place 3 DCNL >>> cull(dsk2, \'y\')[0] DCNL {\'y\': (<function load at ...>, \'store\', \'part\', \'a\')}'
def find_dataset_changes(uuid, current_state, desired_state): DCNL 'Find what actions need to be taken to deal with changes in dataset DCNL manifestations between current state and desired state of the cluster. DCNL XXX The logic here assumes the mountpoints have not changed, DCNL and will act unexpectedly if that is the case. See DCNL https://clusterhq.atlassian.net/browse/FLOC-351 for more details. DCNL XXX The logic here assumes volumes are never added or removed to DCNL existing applications, merely moved across nodes. As a result test DCNL coverage for those situations is not implemented. See DCNL https://clusterhq.atlassian.net/browse/FLOC-352 for more details. DCNL :param UUID uuid: The uuid of the node for which to find changes. DCNL :param Deployment current_state: The old state of the cluster on which the DCNL changes are based. DCNL :param Deployment desired_state: The new state of the cluster towards which DCNL the changes are working. DCNL :return DatasetChanges: Changes to datasets that will be needed in DCNL order to match desired configuration.'
def test_all_fields(script): DCNL 'Test that all the fields are present'
def neg_sampling(W_list, b_list, nsamples, beta=1.0, pa_bias=None, marginalize_odd=True, theano_rng=None): DCNL 'Generate a sample from the intermediate distribution defined at inverse DCNL temperature \'beta\', starting from state \'nsamples\'. See file docstring for DCNL equation of p_k(h1). DCNL Parameters DCNL W_list : array-like object of theano shared variables DCNL Weight matrices of the DBM. Its first element is ignored, since in the DCNL Pylearn2 framework a visible layer does not have a weight matrix. DCNL b_list : array-like object of theano shared variables DCNL Biases of the DBM DCNL nsamples : array-like object of theano shared variables DCNL Negative samples corresponding to the previous states DCNL beta : theano.tensor.scalar DCNL Inverse temperature parameter DCNL marginalize_odd : boolean DCNL Whether to marginalize odd layers DCNL theano_rng : theano RandomStreams DCNL Random number generator DCNL Returns DCNL new_nsamples : array-like object of symbolic matrices DCNL new_nsamples[i] contains new samples for i-th layer.'
def roundrobin(iterables): DCNL 'roundrobin(\'ABC\', \'D\', \'EF\') --> A D E B F C'
def _pipeline_present_with_definition(name, expected_pipeline_objects, expected_parameter_objects, expected_parameter_values, region, key, keyid, profile): DCNL 'Return true if the pipeline exists and the definition matches. DCNL name DCNL The name of the pipeline. DCNL expected_pipeline_objects DCNL Pipeline objects that must match the definition. DCNL expected_parameter_objects DCNL Parameter objects that must match the definition. DCNL expected_parameter_values DCNL Parameter values that must match the definition. DCNL region DCNL Region to connect to. DCNL key DCNL Secret key to be used. DCNL keyid DCNL Access key to be used. DCNL profile DCNL A dict with region, key and keyid, or a pillar key (string) DCNL that contains a dict with region, key and keyid.'
@require_admin_context DCNL def instance_type_access_add(context, flavor_id, project_id): DCNL 'Add given tenant to the flavor access list.'
def parse_inlinefunc(string, strip=False, **kwargs): DCNL 'Parse the incoming string. DCNL Args: DCNL string (str): The incoming string to parse. DCNL strip (bool, optional): Whether to strip function calls rather than DCNL execute them. DCNL Kwargs: DCNL session (Session): This is sent to this function by Evennia when triggering DCNL it. It is passed to the inlinefunc. DCNL kwargs (any): All other kwargs are also passed on to the inlinefunc.'
def _log(msg, facility, loglevel): DCNL 'Outputs a debugging message'
def update_single(f, new): DCNL 'update in tabSingles'
def p_expression_uminus(p): DCNL 'expression : \'-\' expression %prec UMINUS'
def convert_case(s): DCNL 'Given a string in snake case, convert to CamelCase DCNL Ex: DCNL date_created -> DateCreated'
def normal(state, text, i, formats, user_data): DCNL 'The normal state (outside content blocks {})'
def istraceback(object): DCNL 'Return true if the object is a traceback. DCNL Traceback objects provide these attributes: DCNL tb_frame        frame object at this level DCNL tb_lasti        index of last attempted instruction in bytecode DCNL tb_lineno       current line number in Python source code DCNL tb_next         next inner traceback object (called by this level)'
def list_of_array_equal(s, t): DCNL 'Compare two lists of ndarrays DCNL s, t: lists of numpy.ndarrays'
def merge_ownership_periods(mappings): DCNL 'Given a dict of mappings where the values are lists of DCNL OwnershipPeriod objects, returns a dict with the same structure with DCNL new OwnershipPeriod objects adjusted so that the periods have no DCNL gaps. DCNL Orders the periods chronologically, and pushes forward the end date DCNL of each period to match the start date of the following period. The DCNL end date of the last period pushed forward to the max Timestamp.'
def _key_split(matchobj): DCNL 'Expands a {key a+b+c} syntax into <span class="key">a</span> + ... DCNL More explicitly, it takes a regex matching {key ctrl+alt+del} and returns: DCNL <span class="key">ctrl</span> + <span class="key">alt</span> + DCNL <span class="key">del</span>'
@require_POST DCNL def post_receive_hook_close_submitted(request, local_site_name=None, repository_id=None, hosting_service_id=None, hooks_uuid=None): DCNL 'Closes review requests as submitted automatically after a push.'
@require_context DCNL def group_types_get_by_name_or_id(context, group_type_list): DCNL 'Return a dict describing specific group_type.'
def setup_logging(args): DCNL 'Prepares logging for the program'
def mixing_dict(xy, normalized=False): DCNL 'Return a dictionary representation of mixing matrix. DCNL Parameters DCNL xy : list or container of two-tuples DCNL Pairs of (x,y) items. DCNL attribute : string DCNL Node attribute key DCNL normalized : bool (default=False) DCNL Return counts if False or probabilities if True. DCNL Returns DCNL d: dictionary DCNL Counts or Joint probability of occurrence of values in xy.'
def move_by_taskmap(map, **kwargs): DCNL 'Move tasks by matching from a ``task_name: queue`` mapping. DCNL ``queue`` is the queue to move the task to. DCNL Example: DCNL >>> move_by_taskmap({ DCNL ...     \'tasks.add\': Queue(\'name\'), DCNL ...     \'tasks.mul\': Queue(\'name\'),'
def gen_preprocess_options(macros, include_dirs): DCNL 'Generate C pre-processor options (-D, -U, -I) as used by at least DCNL two types of compilers: the typical Unix compiler and Visual C++. DCNL \'macros\' is the usual thing, a list of 1- or 2-tuples, where (name,) DCNL means undefine (-U) macro \'name\', and (name,value) means define (-D) DCNL macro \'name\' to \'value\'.  \'include_dirs\' is just a list of directory DCNL names to be added to the header file search path (-I).  Returns a list DCNL of command-line options suitable for either Unix compilers or Visual DCNL C++.'
def convert_time_to_utc(timestr): DCNL 'Take a string like 08:00:00 and convert it to a unix timestamp.'
def share_db(): DCNL 'Generate db client for sharejs db'
def comparison_type(logical_line, noqa): DCNL 'Object type comparisons should always use isinstance(). DCNL Do not compare types directly. DCNL Okay: if isinstance(obj, int): DCNL E721: if type(obj) is type(1): DCNL When checking if an object is a string, keep in mind that it might be a DCNL unicode string too! In Python 2.3, str and unicode have a common base DCNL class, basestring, so you can do: DCNL Okay: if isinstance(obj, basestring): DCNL Okay: if type(a1) is type(b1):'
def create_patch_ports(source, destination): DCNL 'Hook up two OVS bridges. DCNL The result is two patch ports, each end connected to a bridge. DCNL The two patch port names will start with \'patch-\', followed by identical DCNL four characters. For example patch-xyzw-fedora, and patch-xyzw-ubuntu, DCNL where fedora and ubuntu are random strings. DCNL :param source: Instance of OVSBridge DCNL :param destination: Instance of OVSBridge'
@image_comparison(baseline_images=[u'colorbar_extensions_uniform', u'colorbar_extensions_proportional'], extensions=[u'png']) DCNL def test_colorbar_extension_length(): DCNL 'Test variable length colorbar extensions.'
def vpn_ping(address, port, timeout=0.05, session_id=None): DCNL 'Sends a vpn negotiation packet and returns the server session. DCNL Returns False on a failure. Basic packet structure is below. DCNL Client packet (14 bytes):: DCNL 0 1      8 9  13 DCNL |x| cli_id |?????| DCNL x = packet identifier 0x38 DCNL cli_id = 64 bit identifier DCNL ? = unknown, probably flags/padding DCNL Server packet (26 bytes):: DCNL 0 1      8 9  13 14    21 2225 DCNL |x| srv_id |?????| cli_id |????| DCNL x = packet identifier 0x40 DCNL cli_id = 64 bit identifier DCNL ? = unknown, probably flags/padding DCNL bit 9 was 1 and the rest were 0 in testing'
def get_documentation(): DCNL 'Search documentation and append to current buffer.'
def httpdate(date_obj): DCNL 'Formats a datetime object for use in HTTP headers.'
def cmServiceRequest(PriorityLevel_presence=0): DCNL 'CM SERVICE REQUEST Section 9.2.9'
def get_ring(): DCNL 'Return the ring status in a structured way. DCNL Returns: DCNL A list of nodes represented by dictionaries.'
def skill_type(): DCNL 'Skill Types Controller'
def running(ctid_or_name): DCNL 'Check if the container is running.'
def get_int(int_str, default=_no_default): DCNL 'For convenience a get-like method for taking the int() of a string. DCNL :param int_str: the string to convert to integer DCNL :param default: an optional value to return if ValueError is raised. DCNL :return: the int() of «int_str» or «default» on exception.'
def is_color_like(c): DCNL 'Return *True* if *c* can be converted to *RGB*'
def getEvaluatorSplitWords(value): DCNL 'Get split words for evaluators.'
@dispatch(object) DCNL def shape(expr): DCNL 'Shape of expression DCNL >>> symbol(\'s\', \'3 * 5 * int32\').shape DCNL (3, 5) DCNL Works on anything discoverable DCNL >>> shape([[1, 2], [3, 4]]) DCNL (2, 2)'
def sample(prediction): DCNL 'Turn a (column) prediction into 1-hot encoded samples.'
def systemd_result_parser(command): DCNL 'Parse results from systemd style commands. DCNL :param command: command. DCNL :type command: str. DCNL :return: different from the command. DCNL command is status: return true if service is running. DCNL command is is_enabled: return true if service is enalbled. DCNL command is list: return a dict from service name to status. DCNL command is others: return true if operate success.'
def _get_lut(): DCNL 'Helper to get the FreeSurfer LUT.'
def page_not_found(request, template_name='404.html'): DCNL 'Default 404 handler, which looks for the requested URL in the redirects DCNL table, redirects if found, and displays 404 page if not redirected. DCNL Templates: `404.html` DCNL Context: DCNL request_path DCNL The path of the requested URL (e.g., \'/app/pages/bad_page/\')'
def test_show_verbose_installer(script, data): DCNL 'Test that the installer is shown (this currently needs a wheel install)'
def rsolve_poly(coeffs, f, n, **hints): DCNL 'Given linear recurrence operator `\operatorname{L}` of order DCNL `k` with polynomial coefficients and inhomogeneous equation DCNL `\operatorname{L} y = f`, where `f` is a polynomial, we seek for DCNL all polynomial solutions over field `K` of characteristic zero. DCNL The algorithm performs two basic steps: DCNL (1) Compute degree `N` of the general polynomial solution. DCNL (2) Find all polynomials of degree `N` or less DCNL of `\operatorname{L} y = f`. DCNL There are two methods for computing the polynomial solutions. DCNL If the degree bound is relatively small, i.e. it\'s smaller than DCNL or equal to the order of the recurrence, then naive method of DCNL undetermined coefficients is being used. This gives system DCNL of algebraic equations with `N+1` unknowns. DCNL In the other case, the algorithm performs transformation of the DCNL initial equation to an equivalent one, for which the system of DCNL algebraic equations has only `r` indeterminates. This method is DCNL quite sophisticated (in comparison with the naive one) and was DCNL invented together by Abramov, Bronstein and Petkovsek. DCNL It is possible to generalize the algorithm implemented here to DCNL the case of linear q-difference and differential equations. DCNL Lets say that we would like to compute `m`-th Bernoulli polynomial DCNL up to a constant. For this we can use `b(n+1) - b(n) = m n^{m-1}` DCNL recurrence, which has solution `b(n) = B_m + C`. For example: DCNL >>> from sympy import Symbol, rsolve_poly DCNL >>> n = Symbol(\'n\', integer=True) DCNL >>> rsolve_poly([-1, 1], 4*n**3, n) DCNL C0 + n**4 - 2*n**3 + n**2 DCNL References DCNL .. [1] S. A. Abramov, M. Bronstein and M. Petkovsek, On polynomial DCNL solutions of linear operator equations, in: T. Levelt, ed., DCNL Proc. ISSAC \'95, ACM Press, New York, 1995, 290-296. DCNL .. [2] M. Petkovsek, Hypergeometric solutions of linear recurrences DCNL with polynomial coefficients, J. Symbolic Computation, DCNL 14 (1992), 243-264. DCNL .. [3] M. Petkovsek, H. S. Wilf, D. Zeilberger, A = B, 1996.'
def base64_encodestring(instr): DCNL 'Encode a string as base64 using the "legacy" Python interface. DCNL Among other possible differences, the "legacy" encoder includes DCNL a newline (\'\n\') character after every 76 characters and always DCNL at the end of the encoded string. DCNL .. versionadded:: 2014.7.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' hashutil.base64_encodestring \'get salted\''
def cmd_map(args): DCNL 'map command'
def get_disable_keyboard_on_lock(): DCNL 'Get whether or not the keyboard should be disabled when the X Serve enclosure DCNL lock is engaged. DCNL :return: True if disable keyboard on lock is on, False if off DCNL :rtype: bool DCNL CLI Example: DCNL ..code-block:: bash DCNL salt \'*\' system.get_disable_keyboard_on_lock'
def course_detail(request, username, course_key): DCNL 'Return a single course identified by `course_key`. DCNL The course must be visible to the user identified by `username` and the DCNL logged-in user should have permission to view courses available to that DCNL user. DCNL Arguments: DCNL request (HTTPRequest): DCNL Used to identify the logged-in user and to instantiate the course DCNL module to retrieve the course about description DCNL username (string): DCNL The name of the user `requesting_user would like to be identified as. DCNL course_key (CourseKey): Identifies the course of interest DCNL Return value: DCNL `CourseOverview` object representing the requested course'
def extended_linecache_checkcache(filename=None, orig_checkcache=linecache.checkcache): DCNL 'Extend linecache.checkcache to preserve the <pyshell#...> entries DCNL Rather than repeating the linecache code, patch it to save the DCNL <pyshell#...> entries, call the original linecache.checkcache() DCNL (which destroys them), and then restore the saved entries. DCNL orig_checkcache is bound at definition time to the original DCNL method, allowing it to be patched.'
def convertSP(pySp, newSeed): DCNL 'Given an instance of a python spatial_pooler return an instance of the CPP DCNL spatial_pooler with identical parameters.'
def pop(queue, quantity=1): DCNL 'Pop one or more or all items from the queue return them.'
def add_resource_manager_extra_kwargs_hook(f, hook): DCNL 'Add hook to bind CLI arguments to ResourceManager calls. DCNL The `do_foo` calls in shell.py will receive CLI args and then in turn pass DCNL them through to the ResourceManager. Before passing through the args, the DCNL hooks registered here will be called, giving us a chance to add extra DCNL kwargs (taken from the command-line) to what\'s passed to the DCNL ResourceManager.'
def test_barn_prefixes(): DCNL 'Regression test for https://github.com/astropy/astropy/issues/3753'
@treeio_login_required DCNL def ajax_location_lookup(request, response_format='html'): DCNL 'Returns a list of matching locations'
def ping(host=None, port=None, db=None, password=None): DCNL 'Ping the server, returns False on connection errors DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' redis.ping'
def create_resource(): DCNL 'ResourceTypeAssociation resource factory method'
def do_cli(manager, options): DCNL 'Handle irc cli'
@catch_error('queue DCSP the DCSP specified DCSP image DCSP for DCSP caching') DCNL def queue_image(options, args): DCNL '%(prog)s queue-image <IMAGE_ID> [options] DCNL Queues an image for caching'
def __virtual__(): DCNL 'Only load if the Zenoss execution module is available.'
def hex_digest(x): DCNL 'Returns a short, mostly hexadecimal hash of a numpy ndarray'
def starts_with(text, substring): DCNL 'Assert `text` starts with `substring`.'
def minimum(image, selem, out=None, mask=None, shift_x=False, shift_y=False): DCNL 'Return local minimum of an image. DCNL Parameters DCNL image : 2-D array (uint8, uint16) DCNL Input image. DCNL selem : 2-D array DCNL The neighborhood expressed as a 2-D array of 1\'s and 0\'s. DCNL out : 2-D array (same dtype as input) DCNL If None, a new array is allocated. DCNL mask : ndarray DCNL Mask array that defines (>0) area of the image included in the local DCNL neighborhood. If None, the complete image is used (default). DCNL shift_x, shift_y : int DCNL Offset added to the structuring element center point. Shift is bounded DCNL to the structuring element sizes (center must be inside the given DCNL structuring element). DCNL Returns DCNL out : 2-D array (same dtype as input image) DCNL Output image. DCNL See also DCNL skimage.morphology.erosion DCNL Notes DCNL The lower algorithm complexity makes `skimage.filters.rank.minimum` more DCNL efficient for larger images and structuring elements. DCNL Examples DCNL >>> from skimage import data DCNL >>> from skimage.morphology import disk DCNL >>> from skimage.filters.rank import minimum DCNL >>> img = data.camera() DCNL >>> out = minimum(img, disk(5))'
def entropy_of_byte(packets, position): DCNL 'Compute the entropy of a byte at a given offset'
def hrm_competency_list_layout(list_id, item_id, resource, rfields, record): DCNL 'Default dataList item renderer for Skills on the HRM Profile DCNL @param list_id: the HTML ID of the list DCNL @param item_id: the HTML ID of the item DCNL @param resource: the S3Resource to render DCNL @param rfields: the S3ResourceFields to render DCNL @param record: the record as dict'
@pytest.fixture(scope='session') DCNL def stubs(): DCNL 'Provide access to stub objects useful for testing.'
def get_repository_file_contents(app, file_path, repository_id, is_admin=False): DCNL 'Return the display-safe contents of a repository file for display in a browser.'
def read_stored_checksum(target, timestamped=True): DCNL 'Read the checksum. DCNL Returns the checksum (as hex) or None.'
def _enable_libraries(libraries): DCNL 'Add enabled libraries to the path. DCNL Args: DCNL libraries: A repeated Config.Library containing the libraries to enable. DCNL Returns: DCNL A list of paths containing the enabled libraries.'
@util.positional(2) DCNL def new_webhook_channel(url, token=None, expiration=None, params=None): DCNL 'Create a new webhook Channel. DCNL Args: DCNL url: str, URL to post notifications to. DCNL token: str, An arbitrary string associated with the channel that DCNL is delivered to the target address with each notification delivered DCNL over this channel. DCNL expiration: datetime.datetime, A time in the future when the channel DCNL should expire. Can also be None if the subscription should use the DCNL default expiration. Note that different services may have different DCNL limits on how long a subscription lasts. Check the response from the DCNL watch() method to see the value the service has set for an expiration DCNL time. DCNL params: dict, Extra parameters to pass on channel creation. Currently DCNL not used for webhook channels.'
def main(): DCNL 'Get the current package directory. DCNL Prints the package directory out so callers can consume it.'
def showroom_get_roomid_by_room_url_key(room_url_key): DCNL 'str->str'
def deserialize(collection, topological=True): DCNL 'Load a collection from file system DCNL @param Collection collection collection DCNL @param bool topological'
def get_rules(): DCNL 'Get the virtual server rules DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' lvs.get_rules'
def group_membership(): DCNL 'RESTful CRUD controller'
def mu_law_encode(audio, quantization_channels): DCNL 'Quantizes waveform amplitudes.'
def location_to_query(location, wildcard=True, tag='i4x'): DCNL 'Takes a Location and returns a SON object that will query for that location by subfields DCNL rather than subdoc. DCNL Fields in location that are None are ignored in the query. DCNL If `wildcard` is True, then a None in a location is treated as a wildcard DCNL query. Otherwise, it is searched for literally'
def _dict_to_list_ids(objects): DCNL 'Convert a dictionary to a list of dictionaries, where each element has DCNL a key value pair {\'id\': key}. This makes it easy to override pillar values DCNL while still satisfying the boto api.'
def profile_get(user, default_hidden=True): DCNL 'List profiles for user DCNL user : string DCNL username DCNL default_hidden : boolean DCNL hide default profiles DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' rbac.profile_get leo DCNL salt \'*\' rbac.profile_get leo default_hidden=False'
def avail_locations(call=None): DCNL 'List all available locations'
def size(key, shape): DCNL 'Finds the dimensions of a sliced expression. DCNL Args: DCNL key: The key used to index/slice. DCNL shape: The shape (row, col) of the expression. DCNL Returns: DCNL The dimensions of the expression as (rows, cols).'
def format_html(format_string, *args, **kwargs): DCNL 'Similar to str % foo, but passes all arguments through conditional_websafe, DCNL and calls \'unsafe\' on the result. This function should be used instead DCNL of str.format or % interpolation to build up small HTML fragments. DCNL Example: DCNL format_html("Are you %s? %s", name, unsafe(checkbox_html))'
def chfullname(name, fullname): DCNL 'Change the full name of the user DCNL :param str name: DCNL user name for which to change the full name DCNL :param str fullname: DCNL the new value for the full name DCNL :return: DCNL True if successful. False is unsuccessful. DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' user.chfullname user \'First Last\''
@export_as_api DCNL def update_universe(id_or_symbols): DCNL 'This method takes one or a list of id_or_symbol(s) as argument(s), to DCNL update the current subscription set of the instruments. It takes DCNL effect on the next bar event. DCNL :param id_or_symbols: one or a list of id_or_symbol(s). DCNL :type id_or_symbols: str or an iterable of strings'
def get_deleted_objects(objs, opts, user, admin_site, using): DCNL 'Find all objects related to ``objs`` that should also be deleted. ``objs`` DCNL must be a homogenous iterable of objects (e.g. a QuerySet). DCNL Returns a nested list of strings suitable for display in the DCNL template with the ``unordered_list`` filter.'
def _interpolate_bads_eeg(inst): DCNL 'Interpolate bad EEG channels. DCNL Operates in place. DCNL Parameters DCNL inst : mne.io.Raw, mne.Epochs or mne.Evoked DCNL The data to interpolate. Must be preloaded.'
def beacons(opts, functions, context=None): DCNL 'Load the beacon modules DCNL :param dict opts: The Salt options dictionary DCNL :param dict functions: A dictionary of minion modules, with module names as DCNL keys and funcs as values.'
def find_vpc(module, vpc_conn, vpc_id=None, cidr=None): DCNL 'Finds a VPC that matches a specific id or cidr + tags DCNL module : AnsibleModule object DCNL vpc_conn: authenticated VPCConnection connection object DCNL Returns: DCNL A VPC object that matches either an ID or CIDR and one or more tag values'
@attr('root') DCNL def onlyroot(meth): DCNL 'Function to decorate tests that should be called as root. DCNL Raises a nose SkipTest exception if the user doesn\'t have root permissions.'
def alter_db(name, character_set=None, collate=None, **connection_args): DCNL 'Modify database using ``ALTER DATABASE %(dbname)s CHARACTER SET %(charset)s DCNL COLLATE %(collation)s;`` query. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' mysql.alter_db testdb charset=\'latin1\''
def extract_javascript_msgids(source): DCNL 'Return message ids of translateable strings in JS source.'
def filter_on_wire_representation(ava, acs, required=None, optional=None): DCNL ':param ava: A dictionary with attributes and values DCNL :param acs: List of tuples (Attribute Converter name, DCNL Attribute Converter instance) DCNL :param required: A list of saml.Attributes DCNL :param optional: A list of saml.Attributes DCNL :return: Dictionary of expected/wanted attributes and values'
def server_cert_absent(name, region=None, key=None, keyid=None, profile=None): DCNL 'Deletes a server certificate. DCNL .. versionadded:: 2015.8.0 DCNL name (string) DCNL The name for the server certificate. Do not include the path in this value. DCNL region (string) DCNL The name of the region to connect to. DCNL key (string) DCNL The key to be used in order to connect DCNL keyid (string) DCNL The keyid to be used in order to connect DCNL profile (string) DCNL The profile that contains a dict of region, key, keyid'
def generate_timestamp(): DCNL 'Get seconds since epoch (UTC). DCNL Per `section 3.3`_ of the OAuth 1 RFC 5849 spec. DCNL Per `section 3.2.1`_ of the MAC Access Authentication spec. DCNL .. _`section 3.2.1`: http://tools.ietf.org/html/draft-ietf-oauth-v2-http-mac-01#section-3.2.1 DCNL .. _`section 3.3`: http://tools.ietf.org/html/rfc5849#section-3.3'
def _initial_nodes_a(n, k): DCNL 'Tricomi initial guesses DCNL Computes an initial approximation to the square of the `k`-th DCNL (positive) root :math:`x_k` of the Hermite polynomial :math:`H_n` DCNL of order :math:`n`. The formula is the one from lemma 3.1 in the DCNL original paper. The guesses are accurate except in the region DCNL near :math:`\sqrt{2n + 1}`. DCNL Parameters DCNL n : int DCNL Quadrature order DCNL k : ndarray of type int DCNL Index of roots to compute DCNL Returns DCNL xksq : ndarray DCNL Square of the approximate roots DCNL See Also DCNL initial_nodes DCNL roots_hermite_asy'
def _handle_zeros_in_scale(scale, copy=True): DCNL 'Makes sure that whenever scale is zero, we handle it correctly. DCNL This happens in most scalers when we have constant features.'
def _incs_list_to_string(incs): DCNL 'Convert incs list to string DCNL [\'thirdparty\', \'include\'] -> -I thirdparty -I include'
def _dnsmasq_pid_for(dev): DCNL 'Returns the pid for prior dnsmasq instance for a bridge/device. DCNL Returns None if no pid file exists. DCNL If machine has rebooted pid might be incorrect (caller should check).'
def ipNum(w, x, y, z): DCNL 'Generate unsigned int from components of IP address DCNL returns: w << 24 | x << 16 | y << 8 | z'
def create_figure(): DCNL 'Simply create a figure with the default settings'
def getOnePayload(results): DCNL 'From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, DCNL return the payload of the first record in the answer section.'
@register.tag DCNL def url(parser, token): DCNL 'Return an absolute URL matching the given view with its parameters. DCNL This is a way to define links that aren\'t tied to a particular URL DCNL configuration:: DCNL {% url "url_name" arg1 arg2 %} DCNL or DCNL {% url "url_name" name1=value1 name2=value2 %} DCNL The first argument is a django.conf.urls.url() name. Other arguments are DCNL space-separated values that will be filled in place of positional and DCNL keyword arguments in the URL. Don\'t mix positional and keyword arguments. DCNL All arguments for the URL must be present. DCNL For example, if you have a view ``app_name.views.client_details`` taking DCNL the client\'s id and the corresponding line in a URLconf looks like this:: DCNL url(\'^client/(\d+)/$\', views.client_details, name=\'client-detail-view\') DCNL and this app\'s URLconf is included into the project\'s URLconf under some DCNL path:: DCNL url(\'^clients/\', include(\'app_name.urls\')) DCNL then in a template you can create a link for a certain client like this:: DCNL {% url "client-detail-view" client.id %} DCNL The URL will look like ``/clients/client/123/``. DCNL The first argument may also be the name of a template variable that will be DCNL evaluated to obtain the view name or the URL name, e.g.:: DCNL {% with url_name="client-detail-view" %} DCNL {% url url_name client.id %} DCNL {% endwith %}'
def make_instance(klass, spec, base64encode=False): DCNL 'Constructs a class instance containing the specified information DCNL :param klass: The class DCNL :param spec: Information to be placed in the instance (a dictionary) DCNL :return: The instance'
def get_CC_operators(): DCNL 'Returns a tuple (T1,T2) of unique operators.'
def _ValidateSourcesForMSVSProject(spec, version): DCNL 'Makes sure if duplicate basenames are not specified in the source list. DCNL Arguments: DCNL spec: The target dictionary containing the properties of the target. DCNL version: The VisualStudioVersion object.'
def setup(hass, config): DCNL 'Setup the InfluxDB component.'
def moment(a, moment=1, axis=0, nan_policy='propagate'): DCNL 'Calculates the nth moment about the mean for a sample. DCNL A moment is a specific quantitative measure of the shape of a set of points. DCNL It is often used to calculate coefficients of skewness and kurtosis due DCNL to its close relationship with them. DCNL Parameters DCNL a : array_like DCNL data DCNL moment : int or array_like of ints, optional DCNL order of central moment that is returned. Default is 1. DCNL axis : int or None, optional DCNL Axis along which the central moment is computed. Default is 0. DCNL If None, compute over the whole array `a`. DCNL nan_policy : {\'propagate\', \'raise\', \'omit\'}, optional DCNL Defines how to handle when input contains nan. \'propagate\' returns nan, DCNL \'raise\' throws an error, \'omit\' performs the calculations ignoring nan DCNL values. Default is \'propagate\'. DCNL Returns DCNL n-th central moment : ndarray or float DCNL The appropriate moment along the given axis or over all values if axis DCNL is None. The denominator for the moment calculation is the number of DCNL observations, no degrees of freedom correction is done. DCNL See also DCNL kurtosis, skew, describe DCNL Notes DCNL The k-th central moment of a data sample is: DCNL .. math:: DCNL m_k = \frac{1}{n} \sum_{i = 1}^n (x_i - \bar{x})^k DCNL Where n is the number of samples and x-bar is the mean. This function uses DCNL exponentiation by squares [1]_ for efficiency. DCNL References DCNL .. [1] http://eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms'
def create(vm_): DCNL 'Create a single VM from a data dict'
def get_mem_info(): DCNL 'Get information about available memory'
def get_resource_ignore_params(params): DCNL 'Helper method to determine which parameters to ignore for actions DCNL :returns: A list of the parameter names that does not need to be DCNL included in a resource\'s method call for documentation purposes.'
def test_array___subclasshook__(): DCNL 'TODO'
def get_nominal(attribute): DCNL 'If attribute is nominal, returns a list of the values'
def derivation(p, DE, coefficientD=False, basic=False): DCNL 'Computes Dp. DCNL Given the derivation D with D = d/dx and p is a polynomial in t over DCNL K(x), return Dp. DCNL If coefficientD is True, it computes the derivation kD DCNL (kappaD), which is defined as kD(sum(ai*Xi**i, (i, 0, n))) == DCNL sum(Dai*Xi**i, (i, 1, n)) (Definition 3.2.2, page 80).  X in this case is DCNL T[-1], so coefficientD computes the derivative just with respect to T[:-1], DCNL with T[-1] treated as a constant. DCNL If basic=True, the returns a Basic expression.  Elements of D can still be DCNL instances of Poly.'
def clear_caches(): DCNL 'Jinja2 keeps internal caches for environments and lexers.  These are DCNL used so that Jinja2 doesn\'t have to recreate environments and lexers all DCNL the time.  Normally you don\'t have to care about that but if you are DCNL messuring memory consumption you may want to clean the caches.'
def get_issue(issue_number, repo_name=None, profile='github', output='min'): DCNL 'Return information about a single issue in a named repository. DCNL .. versionadded:: 2016.11.0 DCNL issue_number DCNL The number of the issue to retrieve. DCNL repo_name DCNL The name of the repository from which to get the issue. This argument is DCNL required, either passed via the CLI, or defined in the configured DCNL profile. A ``repo_name`` passed as a CLI argument will override the DCNL repo_name defined in the configured profile, if provided. DCNL profile DCNL The name of the profile configuration to use. Defaults to ``github``. DCNL output DCNL The amount of data returned by each issue. Defaults to ``min``. Change DCNL to ``full`` to see all issue output. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion github.get_issue 514 DCNL salt myminion github.get_issue 514 repo_name=salt'
def difference(G, H): DCNL 'Return a new graph that contains the edges that exist in G but not in H. DCNL The node sets of H and G must be the same. DCNL Parameters DCNL G,H : graph DCNL A NetworkX graph.  G and H must have the same node sets. DCNL Returns DCNL D : A new graph with the same type as G. DCNL Notes DCNL Attributes from the graph, nodes, and edges are not copied to the new DCNL graph.  If you want a new graph of the difference of G and H with DCNL with the attributes (including edge data) from G use remove_nodes_from() DCNL as follows: DCNL >>> G = nx.path_graph(3) DCNL >>> H = nx.path_graph(5) DCNL >>> R = G.copy() DCNL >>> R.remove_nodes_from(n for n in G if n in H)'
def check_uri_syntax(uri, host=None): DCNL ':return: True if the syntax of the URI section of HTTP is valid; else DCNL raise an exception.'
def get_course_info_section_module(request, user, course, section_key): DCNL 'This returns the course info module for a given section_key. DCNL Valid keys: DCNL - handouts DCNL - guest_handouts DCNL - updates DCNL - guest_updates'
def force_release(hosts_to_release, username=None): DCNL 'Force release a collection of hosts from user DCNL This will remove all ACLs from the hosts DCNL :param hosts_to_release: strings or idents for hosts to release DCNL :type hosts_to_release: list DCNL :param username: login of the user reserving hosts DCNL :type username: str'
def benchmark(): DCNL 'multi-threading vs async-io vs regular'
@intercept_errors(UserAPIInternalError, ignore_errors=[UserAPIRequestError]) DCNL def delete_user_preference(requesting_user, preference_key, username=None): DCNL 'Deletes a user preference on behalf of a requesting user. DCNL Note: DCNL It is up to the caller of this method to enforce the contract that this method is only called DCNL with the user who made the request. DCNL Arguments: DCNL requesting_user (User): The user requesting to delete the preference. Only the user with username DCNL \'username\' has permissions to delete their own preference. DCNL preference_key (str): The key for the user preference. DCNL username (str): Optional username specifying which account should be updated. If not specified, DCNL `requesting_user.username` is assumed. DCNL Returns: DCNL True if the preference was deleted, False if the user did not have a preference with the supplied key. DCNL Raises: DCNL UserNotFound: no user with username `username` exists (or `requesting_user.username` if DCNL `username` is not specified) DCNL UserNotAuthorized: the requesting_user does not have access to change the account DCNL associated with `username` DCNL PreferenceUpdateError: the operation failed when performing the update. DCNL UserAPIInternalError: the operation failed due to an unexpected error.'
def delete_disk(kwargs=None, conn=None, call=None): DCNL '.. versionadded:: 2015.8.0 DCNL Delete a specific disk associated with the account DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt-cloud -f delete_disk my-azure name=my_disk DCNL salt-cloud -f delete_disk my-azure name=my_disk delete_vhd=True'
def failing_job(): DCNL 'A background job that fails.'
def mkXRDTag(t): DCNL 'basestring -> basestring DCNL Create a tag name in the XRD 2.0 XML namespace suitable for using DCNL with ElementTree'
def mkfs(device, fs_type, **kwargs): DCNL 'Create a file system on the specified device DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' extfs.mkfs /dev/sda1 fs_type=ext4 opts=\'acl,noexec\' DCNL Valid options are: DCNL * **block_size**: 1024, 2048 or 4096 DCNL * **check**: check for bad blocks DCNL * **direct**: use direct IO DCNL * **ext_opts**: extended file system options (comma-separated) DCNL * **fragment_size**: size of fragments DCNL * **force**: setting force to True will cause mke2fs to specify the -F DCNL option twice (it is already set once); this is truly dangerous DCNL * **blocks_per_group**: number of blocks in a block group DCNL * **number_of_groups**: ext4 option for a virtual block group DCNL * **bytes_per_inode**: set the bytes/inode ratio DCNL * **inode_size**: size of the inode DCNL * **journal**: set to True to create a journal (default on ext3/4) DCNL * **journal_opts**: options for the fs journal (comma separated) DCNL * **blocks_file**: read bad blocks from file DCNL * **label**: label to apply to the file system DCNL * **reserved**: percentage of blocks reserved for super-user DCNL * **last_dir**: last mounted directory DCNL * **test**: set to True to not actually create the file system (mke2fs -n) DCNL * **number_of_inodes**: override default number of inodes DCNL * **creator_os**: override "creator operating system" field DCNL * **opts**: mount options (comma separated) DCNL * **revision**: set the filesystem revision (default 1) DCNL * **super**: write superblock and group descriptors only DCNL * **fs_type**: set the filesystem type (REQUIRED) DCNL * **usage_type**: how the filesystem is going to be used DCNL * **uuid**: set the UUID for the file system DCNL See the ``mke2fs(8)`` manpage for a more complete description of these DCNL options.'
def _enqueue(revent): DCNL 'Enqueue the event'
def nanmax(a, axis=None, out=None, keepdims=False): DCNL 'Returns the maximum of an array along an axis ignoring NaN. DCNL When there is a slice whose elements are all NaN, a :class:`RuntimeWarning` DCNL is raised and NaN is returned. DCNL Args: DCNL a (cupy.ndarray): Array to take the maximum. DCNL axis (int): Along which axis to take the maximum. The flattened array DCNL is used by default. DCNL out (cupy.ndarray): Output array. DCNL keepdims (bool): If ``True``, the axis is remained as an axis of DCNL size one. DCNL Returns: DCNL cupy.ndarray: The maximum of ``a``, along the axis if specified. DCNL .. seealso:: :func:`numpy.nanmax`'
def pager(text): DCNL 'The first time this is called, determine what kind of pager to use.'
def get_browse_partitioned_table_limit(): DCNL 'Get the old default'
def shorten_paths(path_list, is_unsaved): DCNL 'Takes a list of paths and tries to "intelligently" shorten them all. The DCNL aim is to make it clear to the user where the paths differ, as that is DCNL likely what they care about. Note that this operates on a list of paths DCNL not on individual paths. DCNL If the path ends in an actual file name, it will be trimmed off.'
def dnslib_record2iplist(record): DCNL 'convert dnslib.DNSRecord to iplist'
def install_setuptools(python_cmd='python', use_sudo=True): DCNL 'Install the latest version of `setuptools`_. DCNL import fabtools DCNL fabtools.python_setuptools.install_setuptools()'
def collect_error_snapshots(): DCNL 'Scheduled task to collect error snapshots from files and push into Error Snapshot table'
def patch_tpool_proxy(): DCNL 'eventlet.tpool.Proxy doesn\'t work with old-style class in __str__() DCNL or __repr__() calls. See bug #962840 for details. DCNL We perform a monkey patch to replace those two instance methods.'
def auto_reconnect_connection(func): DCNL 'Attempt to safely reconnect when an error is hit that resembles the DCNL bouncer disconnecting the client due to a timeout/etc.'
def _getExcelCellName(col, row): DCNL 'Returns the excel cell name for a row and column (zero-indexed) DCNL >>> _getExcelCellName(0,0) DCNL \'A1\' DCNL >>> _getExcelCellName(2,1) DCNL \'C2\''
def target_info_from_filename(filename): DCNL 'Transforms /some/path/foo.png into (\'/some/path\', \'foo.png\', \'png\').'
def warn(msg): DCNL 'Issue a warning. DCNL If msg is a string, :class:`.exc.SAWarning` is used as DCNL the category.'
def same_file(a, b): DCNL 'Return 0 if A and B have nothing in common DCNL return 1 if A and B are actually the same path DCNL return 2 if B is a subfolder of A'
def client_generator(port=5557, host='localhost', hwm=20): DCNL 'Generator in client side should extend this generator DCNL Parameters DCNL port : int DCNL hwm : int, optional DCNL The `ZeroMQ high-water mark (HWM) DCNL <http://zguide.zeromq.org/page:all#High-Water-Marks>`_ on the DCNL sending socket. Increasing this increases the buffer, which can be DCNL useful if your data preprocessing times are very random.  However, DCNL it will increase memory usage. There is no easy way to tell how DCNL many batches will actually be queued with a particular HWM. DCNL Defaults to 10. Be sure to set the corresponding HWM on the DCNL receiving end as well.'
def dmp_mul_ground(f, c, u, K): DCNL 'Multiply ``f`` by a constant value in ``K[X]``. DCNL Examples DCNL >>> from sympy.polys import ring, ZZ DCNL >>> R, x,y = ring("x,y", ZZ) DCNL >>> R.dmp_mul_ground(2*x + 2*y, ZZ(3)) DCNL 6*x + 6*y'
def build_title(title_dict, canonical=None, canonicalSeries=None, canonicalEpisode=None, ptdf=0, lang=None, _doYear=1, _emptyString=u'', appendKind=True): DCNL 'Given a dictionary that represents a "long" IMDb title, DCNL return a string. DCNL If canonical is None (default), the title is returned in the stored style. DCNL If canonical is True, the title is converted to canonical style. DCNL If canonical is False, the title is converted to normal format. DCNL lang can be used to specify the language of the title. DCNL If ptdf is true, the plain text data files format is used.'
def BoundedSemaphore(value=1): DCNL 'Returns a bounded semaphore object'
def no_such_executable_logged(case, logger): DCNL 'Validate the error logging behavior of ``_sync_command_error_squashed``.'
def substitute_bindings(fstruct, bindings, fs_class=u'default'): DCNL 'Return the feature structure that is obtained by replacing each DCNL variable bound by ``bindings`` with its binding.  If a variable is DCNL aliased to a bound variable, then it will be replaced by that DCNL variable\'s value.  If a variable is aliased to an unbound DCNL variable, then it will be replaced by that variable. DCNL :type bindings: dict(Variable -> any) DCNL :param bindings: A dictionary mapping from variables to values.'
def createModel(modelParams): DCNL 'Given a model params dictionary, create a CLA Model. Automatically enables DCNL inference for kw_energy_consumption. DCNL :param modelParams: Model params dict DCNL :return: OPF Model object'
def make_pidlockfile_scenarios(): DCNL 'Make a collection of scenarios for testing PIDLockFile instances.'
def getBevelPath(begin, center, close, end, radius): DCNL 'Get bevel path.'
def test_dont_break_imports_without_namespaces(): DCNL 'The code checking for ``from __future__ import absolute_import`` shouldn\'t DCNL assume that all imports have non-``None`` namespaces.'
def _make_req(node, part, method, path, _headers, stype, conn_timeout=5, response_timeout=15): DCNL 'Make request to backend storage node. DCNL (i.e. \'Account\', \'Container\', \'Object\') DCNL :param node: a node dict from a ring DCNL :param part: an integer, the partion number DCNL :param method: a string, the HTTP method (e.g. \'PUT\', \'DELETE\', etc) DCNL :param path: a string, the request path DCNL :param headers: a dict, header name => value DCNL :param stype: a string, describing the type of service DCNL :returns: an HTTPResponse object'
def build_model(vectors, shape, settings): DCNL 'Compile the model.'
def main(): DCNL 'The main function runs the BloggerExample application with the provided DCNL username and password values.  Authentication credentials are required. DCNL NOTE:  It is recommended that you run this sample using a test account.'
def parse_alpha(args): DCNL 'If args is a list of a single INTEGER or NUMBER token, DCNL retur its value clipped to the 0..1 range DCNL Otherwise, return None.'
def _statsmodels_univariate_kde(data, kernel, bw, gridsize, cut, clip, cumulative=False): DCNL 'Compute a univariate kernel density estimate using statsmodels.'
def version(parser, token): DCNL 'Displaying a version of an existing Image according to the predefined VERSIONS settings (see filebrowser settings). DCNL {% version fileobject version_suffix %} DCNL Use {% version fileobject \'medium\' %} in order to DCNL display the medium-size version of an image. DCNL version_suffix can be a string or a variable. if version_suffix is a string, use quotes. DCNL Return a context variable \'var_name\' with the FileObject DCNL {% version fileobject version_suffix as var_name %} DCNL Use {% version fileobject \'medium\' as version_medium %} in order to DCNL retrieve the medium version of an image stored in a variable version_medium. DCNL version_suffix can be a string or a variable. If version_suffix is a string, use quotes.'
@xmlrpc_func(returns='string', args=['string', 'string', 'string', 'struct', 'boolean']) DCNL def new_post(blog_id, username, password, post, publish): DCNL 'metaWeblog.newPost(blog_id, username, password, post, publish) DCNL => post_id'
def checkCrash(player, upperPipes, lowerPipes): DCNL 'returns True if player collders with base or pipes.'
def unpickle(fname): DCNL 'Load pickled object from `fname`'
def __virtual__(): DCNL 'Only works on Windows systems'
def _write_with_fallback(s, write, fileobj): DCNL 'Write the supplied string with the given write function like DCNL ``write(s)``, but use a writer for the locale\'s preferred encoding in case DCNL of a UnicodeEncodeError.  Failing that attempt to write with \'utf-8\' or DCNL \'latin-1\'.'
def check_existing(package, pkg_files, formula_def, conn=None): DCNL 'Check the filesystem for existing files'
def test_give_classifier_obj(): DCNL 'Test the fit and sample routine with classifier a object'
@core_helper DCNL def nav_link(text, *args, **kwargs): DCNL ':param class_: pass extra class(es) to add to the ``<a>`` tag DCNL :param icon: name of ckan icon to use within the link DCNL :param condition: if ``False`` then no link is returned'
def role_list(): DCNL 'List all available roles DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' rbac.role_list'
def claim_build(registry, xml_parent, data): DCNL 'yaml: claim-build DCNL Claim build failures DCNL Requires the Jenkins :jenkins-wiki:`Claim Plugin <Claim+plugin>`. DCNL Example: DCNL .. literalinclude::  /../../tests/publishers/fixtures/claim-build001.yaml DCNL :language: yaml'
@register.simple_tag(takes_context=True) DCNL def locale_js_include(context): DCNL 'If the user has a non-English locale set, returns a <script> tag pointing DCNL to the relevant locale JavaScript file'
def _raise_document_too_large(operation, doc_size, max_size): DCNL 'Internal helper for raising DocumentTooLarge.'
def create_model(session, forward_only): DCNL 'Create translation model and initialize or load parameters in session.'
def setup_platform(hass, config, add_devices, discovery_info=None): DCNL 'Setup the dovado platform for sensors.'
def create_credential_resolver(session): DCNL 'Create a default credential resolver. DCNL This creates a pre-configured credential resolver DCNL that includes the default lookup chain for DCNL credentials.'
@cli.command() DCNL def edit(): DCNL 'Opens an editor with some text in it.'
def test_randomize_corrmat_dist(): DCNL 'Test that the distribution looks right.'
def to_str_py27(value): DCNL 'Encode dictionary for python 2'
def _nonlinear_3eq_order1_type5(x, y, t, eq): DCNL '.. math:: x\' = x (c F_2 - b F_3), \enspace y\' = y (a F_3 - c F_1), \enspace z\' = z (b F_1 - a F_2) DCNL where `F_n = F_n (x, y, z, t)` and are arbitrary functions. DCNL First Integral: DCNL .. math:: \left|x\right|^{a} \left|y\right|^{b} \left|z\right|^{c} = C_1 DCNL where `C` is an arbitrary constant. If the function `F_n` is independent of `t`, DCNL then, by eliminating `t` and `z` from the first two equations of the system, one DCNL arrives at a first-order equation. DCNL References DCNL -http://eqworld.ipmnet.ru/en/solutions/sysode/sode0406.pdf'
def folders_at_path(path, include_parent=False, show_hidden=False): DCNL 'Returns a list of dictionaries with the folders contained at the given path DCNL Give the empty string as the path to list the contents of the root path DCNL under Unix this means "/", on Windows this will be a list of drive letters)'
def getGaleraFile(): DCNL 'Used for ensuring that Percona XtraDB Cluster is installed DCNL and not a common MySQL-Server'
def test_pick_bio(): DCNL 'Test picking BIO channels.'
def get_func_full_args(func): DCNL 'Return a list of (argument name, default value) tuples. If the argument DCNL does not have a default value, omit it in the tuple. Arguments such as DCNL *args and **kwargs are also included.'
def opening_tag(cdata_tags, state, text, i, formats, user_data): DCNL 'An opening tag, like <a>'
@evalcontextfilter DCNL def do_replace(eval_ctx, s, old, new, count=None): DCNL 'Return a copy of the value with all occurrences of a substring DCNL replaced with a new one. The first argument is the substring DCNL that should be replaced, the second is the replacement string. DCNL If the optional third argument ``count`` is given, only the first DCNL ``count`` occurrences are replaced: DCNL .. sourcecode:: jinja DCNL {{ "Hello World"|replace("Hello", "Goodbye") }} DCNL -> Goodbye World DCNL {{ "aaaaargh"|replace("a", "d\'oh, ", 2) }} DCNL -> d\'oh, d\'oh, aaargh'
def html_unquote(s, encoding=None): DCNL 'Decode the value.'
@check_is_trading DCNL @export_as_api DCNL @ExecutionContext.enforce_phase(EXECUTION_PHASE.HANDLE_BAR, EXECUTION_PHASE.SCHEDULED) DCNL def order_lots(id_or_ins, amount, style=None): DCNL 'Place an order by specified number of lots. Order type is also passed DCNL in as parameters if needed. If style is omitted, it fires a market DCNL order by default. DCNL :param id_or_ins: the instrument to be ordered DCNL :type id_or_ins: str or Instrument DCNL :param float amount: Number of lots to order. Positive means buy, DCNL negative means sell. DCNL :param style: Order type and default is `MarketOrder()`. The DCNL available order types are: `MarketOrder()` and DCNL `LimitOrder(limit_price)` DCNL :return:  A unique order id. DCNL :rtype: int'
def test_basic_auth(): DCNL 'Test to ensure hug provides basic_auth handler works as expected'
def build_flow_dict(G, R): DCNL 'Build a flow dictionary from a residual network.'
def detach_principal_policy(policyName, principal, region=None, key=None, keyid=None, profile=None): DCNL 'Detach the specified policy from the specified principal (certificate or other DCNL credential.) DCNL Returns {detached: true} if the policy was detached DCNL {detached: False} if the policy was not detached. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_iot.detach_principal_policy mypolicy mycognitoID'
def disabled(name): DCNL 'Return True if the named service is enabled, false otherwise DCNL .. versionadded:: 2015.5.6 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' daemontools.disabled <service name>'
def setup(hass, config): DCNL 'Use config values to set up a function enabling status retrieval.'
def getfullargspec(func): DCNL 'Compatibility function to provide inspect.getfullargspec in Python 2 DCNL This should be rewritten using a backport of Python 3 signature DCNL once we drop support for Python 2.6. We went for a simpler DCNL approach at the time of writing because signature uses OrderedDict DCNL which is not available in Python 2.6.'
def group_create(context, data_dict): DCNL 'Create a new group. DCNL You must be authorized to create groups. DCNL Plugins may change the parameters of this function depending on the value DCNL of the ``type`` parameter, see the DCNL :py:class:`~ckan.plugins.interfaces.IGroupForm` plugin interface. DCNL :param name: the name of the group, a string between 2 and 100 characters DCNL long, containing only lowercase alphanumeric characters, ``-`` and DCNL :type name: string DCNL :param id: the id of the group (optional) DCNL :type id: string DCNL :param title: the title of the group (optional) DCNL :type title: string DCNL :param description: the description of the group (optional) DCNL :type description: string DCNL :param image_url: the URL to an image to be displayed on the group\'s page DCNL (optional) DCNL :type image_url: string DCNL :param type: the type of the group (optional), DCNL :py:class:`~ckan.plugins.interfaces.IGroupForm` plugins DCNL associate themselves with different group types and provide custom DCNL group handling behaviour for these types DCNL Cannot be \'organization\' DCNL :type type: string DCNL :param state: the current state of the group, e.g. ``\'active\'`` or DCNL ``\'deleted\'``, only active groups show up in search results and DCNL other lists of groups, this parameter will be ignored if you are not DCNL authorized to change the state of the group (optional, default: DCNL ``\'active\'``) DCNL :type state: string DCNL :param approval_status: (optional) DCNL :type approval_status: string DCNL :param extras: the group\'s extras (optional), extras are arbitrary DCNL (key: value) metadata items that can be added to groups, each extra DCNL dictionary should have keys ``\'key\'`` (a string), ``\'value\'`` (a DCNL string), and optionally ``\'deleted\'`` DCNL :type extras: list of dataset extra dictionaries DCNL :param packages: the datasets (packages) that belong to the group, a list DCNL of dictionaries each with keys ``\'name\'`` (string, the id or name of DCNL the dataset) and optionally ``\'title\'`` (string, the title of the DCNL dataset) DCNL :type packages: list of dictionaries DCNL :param groups: the groups that belong to the group, a list of dictionaries DCNL each with key ``\'name\'`` (string, the id or name of the group) and DCNL optionally ``\'capacity\'`` (string, the capacity in which the group is DCNL a member of the group) DCNL :type groups: list of dictionaries DCNL :param users: the users that belong to the group, a list of dictionaries DCNL each with key ``\'name\'`` (string, the id or name of the user) and DCNL optionally ``\'capacity\'`` (string, the capacity in which the user is DCNL a member of the group) DCNL :type users: list of dictionaries DCNL :returns: the newly created group (unless \'return_id_only\' is set to True DCNL in the context, in which case just the group id will DCNL be returned) DCNL :rtype: dictionary'
def find_and_create_file_from_metadata(children, source, destination, destination_node, obj): DCNL 'Given a Guid obj, recursively search for the metadata of its referent (a file obj) DCNL in the waterbutler response. If found, create a new addon FileNode with that metadata DCNL and return the new file.'
def generate_gantt_chart(logfile, cores, minute_scale=10, space_between_minutes=50, colors=[u'#7070FF', u'#4E4EB2', u'#2D2D66', u'#9B9BFF']): DCNL 'Generates a gantt chart in html showing the workflow execution based on a callback log file. DCNL This script was intended to be used with the MultiprocPlugin. DCNL The following code shows how to set up the workflow in order to generate the log file: DCNL Parameters DCNL logfile : string DCNL filepath to the callback log file to plot the gantt chart of DCNL cores : integer DCNL the number of cores given to the workflow via the \'n_procs\' DCNL plugin arg DCNL minute_scale : integer (optional); default=10 DCNL the scale, in minutes, at which to plot line markers for the DCNL gantt chart; for example, minute_scale=10 means there are lines DCNL drawn at every 10 minute interval from start to finish DCNL space_between_minutes : integer (optional); default=50 DCNL scale factor in pixel spacing between minute line markers DCNL colors : list (optional) DCNL a list of colors to choose from when coloring the nodes in the DCNL gantt chart DCNL Returns DCNL None DCNL the function does not return any value but writes out an html DCNL file in the same directory as the callback log path passed in DCNL Usage DCNL # import logging DCNL # import logging.handlers DCNL # from nipype.pipeline.plugins.callback_log import log_nodes_cb DCNL # log_filename = \'callback.log\' DCNL # logger = logging.getLogger(\'callback\') DCNL # logger.setLevel(logging.DEBUG) DCNL # handler = logging.FileHandler(log_filename) DCNL # logger.addHandler(handler) DCNL # #create workflow DCNL # workflow = ... DCNL # workflow.run(plugin=\'MultiProc\', DCNL #     plugin_args={\'n_procs\':8, \'memory\':12, \'status_callback\': log_nodes_cb}) DCNL # generate_gantt_chart(\'callback.log\', 8)'
def check_page_faults(con, host, port, warning, critical, perf_data): DCNL 'A function to get page_faults per second from the system'
def collect_emojis(): DCNL 'Returns a dictionary containing all emojis with their DCNL name and filename. If the folder doesn\'t exist it returns a empty DCNL dictionary.'
def abstract(cls): DCNL 'A decorator to mark abstract base classes derived from |HasProps|.'
@pytest.fixture(autouse=True) DCNL def mock_inline_css(monkeypatch): DCNL 'Mock jingo_minify.helpers.is_external: don\'t break on missing files. DCNL When testing, we don\'t want nor need the bundled/minified css files, so DCNL pretend that all the css files are external. DCNL Mocking this will prevent amo.helpers.inline_css to believe it should DCNL bundle the css.'
def assert_json_response(response, status_code, body, headers=None, body_cmp=operator.eq): DCNL 'Assert JSON response has the expected status_code, body, and headers. DCNL Asserts that the response\'s content-type is application/json. DCNL body_cmp is a callable that takes the JSON-decoded response body and DCNL expected body and returns a boolean stating whether the comparison DCNL succeeds. DCNL body_cmp(json.loads(response.data.decode(\'utf-8\')), body)'
def wait_for_volume_status(client, volume_id, status): DCNL 'Waits for a Volume to reach a given status.'
def between(expr, lower_bound, upper_bound, symmetric=False): DCNL 'Produce a ``BETWEEN`` predicate clause. DCNL E.g.:: DCNL from sqlalchemy import between DCNL stmt = select([users_table]).where(between(users_table.c.id, 5, 7)) DCNL Would produce SQL resembling:: DCNL SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2 DCNL The :func:`.between` function is a standalone version of the DCNL :meth:`.ColumnElement.between` method available on all DCNL SQL expressions, as in:: DCNL stmt = select([users_table]).where(users_table.c.id.between(5, 7)) DCNL All arguments passed to :func:`.between`, including the left side DCNL column expression, are coerced from Python scalar values if a DCNL the value is not a :class:`.ColumnElement` subclass.   For example, DCNL three fixed values can be compared as in:: DCNL print(between(5, 3, 7)) DCNL Which would produce:: DCNL :param_1 BETWEEN :param_2 AND :param_3 DCNL :param expr: a column expression, typically a :class:`.ColumnElement` DCNL instance or alternatively a Python scalar expression to be coerced DCNL into a column expression, serving as the left side of the ``BETWEEN`` DCNL expression. DCNL :param lower_bound: a column or Python scalar expression serving as the DCNL lower bound of the right side of the ``BETWEEN`` expression. DCNL :param upper_bound: a column or Python scalar expression serving as the DCNL upper bound of the right side of the ``BETWEEN`` expression. DCNL :param symmetric: if True, will render " BETWEEN SYMMETRIC ". Note DCNL that not all databases support this syntax. DCNL .. versionadded:: 0.9.5 DCNL .. seealso:: DCNL :meth:`.ColumnElement.between`'
def new_figure_manager(num, *args, **kwargs): DCNL 'Create a new figure manager instance'
def _abstractPath(case): DCNL 'Return a new, unique abstract namespace path to be listened on.'
def set_review_unavailable(apps, schema_editor): DCNL 'For historic DocumentSpamAttempt, set to REVIEW_UNAVAILABLE.'
@dispatch(Expr, Mapping) DCNL def compute(expr, d, return_type=no_default, **kwargs): DCNL 'Compute expression against data sources. DCNL Parameters DCNL expr : Expr DCNL The blaze expression to compute. DCNL d : any DCNL The data source to compute expression on. DCNL return_type : {\'native\', \'core\', type}, optional DCNL Type to return data as. Defaults to \'native\' but will be changed DCNL to \'core\' in version 0.11.  \'core\' forces the computation into a core DCNL type. \'native\' returns the result as is from the respective backend\'s DCNL ``post_compute``. If a type is passed, it will odo the result into the DCNL type before returning. DCNL Examples DCNL >>> t = symbol(\'t\', \'var * {name: string, balance: int}\') DCNL >>> deadbeats = t[t[\'balance\'] < 0][\'name\'] DCNL >>> data = [[\'Alice\', 100], [\'Bob\', -50], [\'Charlie\', -20]] DCNL >>> list(compute(deadbeats, {t: data})) DCNL [\'Bob\', \'Charlie\']'
def replace(old_value, new_value, full_match=False): DCNL 'Replace string or full line matches in switch\'s running config DCNL If full_match is set to True, then the whole line will need to be matched DCNL as part of the old value. DCNL .. code-block:: bash DCNL salt \'*\' nxos.cmd replace \'TESTSTRINGHERE\' \'NEWTESTSTRINGHERE\''
@verbose DCNL def read_epochs(fname, proj=True, preload=True, verbose=None): DCNL 'Read epochs from a fif file. DCNL Parameters DCNL fname : str DCNL The name of the file, which should end with -epo.fif or -epo.fif.gz. DCNL proj : bool | \'delayed\' DCNL Apply SSP projection vectors. If proj is \'delayed\' and reject is not DCNL None the single epochs will be projected before the rejection DCNL decision, but used in unprojected state if they are kept. DCNL This way deciding which projection vectors are good can be postponed DCNL to the evoked stage without resulting in lower epoch counts and DCNL without producing results different from early SSP application DCNL given comparable parameters. Note that in this case baselining, DCNL detrending and temporal decimation will be postponed. DCNL If proj is False no projections will be applied which is the DCNL recommended value if SSPs are not used for cleaning the data. DCNL preload : bool DCNL If True, read all epochs from disk immediately. If False, epochs will DCNL be read on demand. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL epochs : instance of Epochs DCNL The epochs'
def resource_create(context, data_dict): DCNL 'Appends a new resource to a datasets list of resources. DCNL :param package_id: id of package that the resource should be added to. DCNL :type package_id: string DCNL :param url: url of resource DCNL :type url: string DCNL :param revision_id: (optional) DCNL :type revision_id: string DCNL :param description: (optional) DCNL :type description: string DCNL :param format: (optional) DCNL :type format: string DCNL :param hash: (optional) DCNL :type hash: string DCNL :param name: (optional) DCNL :type name: string DCNL :param resource_type: (optional) DCNL :type resource_type: string DCNL :param mimetype: (optional) DCNL :type mimetype: string DCNL :param mimetype_inner: (optional) DCNL :type mimetype_inner: string DCNL :param cache_url: (optional) DCNL :type cache_url: string DCNL :param size: (optional) DCNL :type size: int DCNL :param created: (optional) DCNL :type created: iso date string DCNL :param last_modified: (optional) DCNL :type last_modified: iso date string DCNL :param cache_last_updated: (optional) DCNL :type cache_last_updated: iso date string DCNL :param upload: (optional) DCNL :type upload: FieldStorage (optional) needs multipart/form-data DCNL :returns: the newly created resource DCNL :rtype: dictionary'
@not_implemented_for('directed') DCNL @not_implemented_for('multigraph') DCNL def cycle_basis(G, root=None): DCNL 'Returns a list of cycles which form a basis for cycles of G. DCNL A basis for cycles of a network is a minimal collection of DCNL cycles such that any cycle in the network can be written DCNL as a sum of cycles in the basis.  Here summation of cycles DCNL is defined as "exclusive or" of the edges. Cycle bases are DCNL useful, e.g. when deriving equations for electric circuits DCNL using Kirchhoff\'s Laws. DCNL Parameters DCNL G : NetworkX Graph DCNL root : node, optional DCNL Specify starting node for basis. DCNL Returns DCNL A list of cycle lists.  Each cycle list is a list of nodes DCNL which forms a cycle (loop) in G. DCNL Examples DCNL >>> G=nx.Graph() DCNL >>> nx.add_cycle(G, [0, 1, 2, 3]) DCNL >>> nx.add_cycle(G, [0, 3, 4, 5]) DCNL >>> print(nx.cycle_basis(G,0)) DCNL [[3, 4, 5, 0], [1, 2, 3, 0]] DCNL Notes DCNL This is adapted from algorithm CACM 491 [1]_. DCNL References DCNL .. [1] Paton, K. An algorithm for finding a fundamental set of DCNL cycles of a graph. Comm. ACM 12, 9 (Sept 1969), 514-518. DCNL See Also DCNL simple_cycles'
def computeEncryptionKey(password, dictOwnerPass, dictUserPass, dictOE, dictUE, fileID, pElement, dictKeyLength=128, revision=3, encryptMetadata=False, passwordType=None): DCNL 'Compute an encryption key to encrypt/decrypt the PDF file DCNL @param password: The password entered by the user DCNL @param dictOwnerPass: The owner password from the standard security handler dictionary DCNL @param dictUserPass: The user password from the standard security handler dictionary DCNL @param dictOE: The owner encrypted string from the standard security handler dictionary DCNL @param dictUE:The user encrypted string from the standard security handler dictionary DCNL @param fileID: The /ID element in the trailer dictionary of the PDF file DCNL @param pElement: The /P element of the Encryption dictionary DCNL @param dictKeyLength: The length of the key DCNL @param revision: The algorithm revision DCNL @param encryptMetadata: A boolean extracted from the standard security handler dictionary to specify if it\'s necessary to encrypt the document metadata or not DCNL @param passwordType: It specifies the given password type. It can be \'USER\', \'OWNER\' or None. DCNL @return: A tuple (status,statusContent), where statusContent is the encryption key in case status = 0 or an error message in case status = -1'
def redirect(uri, permanent=False, abort=False, code=None, body=None, request=None, response=None): DCNL 'Issues an HTTP redirect to the given relative URI. DCNL This won\'t stop code execution unless **abort** is True. A common DCNL practice is to return when calling this method:: DCNL return redirect(\'/some-path\') DCNL :param uri: DCNL A relative or absolute URI (e.g., ``\'../flowers.html\'``). DCNL :param permanent: DCNL If True, uses a 301 redirect instead of a 302 redirect. DCNL :param abort: DCNL If True, raises an exception to perform the redirect. DCNL :param code: DCNL The redirect status code. Supported codes are 301, 302, 303, 305, DCNL and 307.  300 is not supported because it\'s not a real redirect DCNL and 304 because it\'s the answer for a request with defined DCNL ``If-Modified-Since`` headers. DCNL :param body: DCNL Response body, if any. DCNL :param request: DCNL Optional request object. If not set, uses :func:`get_request`. DCNL :param response: DCNL Optional response object. If not set, a new response is created. DCNL :returns: DCNL A :class:`Response` instance.'
def _handleDescriptionFromFileOption(filename, outDir, usageStr, hsVersion, claDescriptionTemplateFile): DCNL 'Parses and validates the --descriptionFromFile option and executes the DCNL request DCNL Parameters: DCNL filename:   File from which we\'ll extract description JSON DCNL outDir:     where to place generated experiment files DCNL usageStr:   program usage string DCNL hsVersion:  which version of hypersearch permutations file to generate, can DCNL be \'v1\' or \'v2\' DCNL claDescriptionTemplateFile: Filename containing the template description DCNL retval:     nothing'
def get_create_test_view_sql(): DCNL 'Returns the SQL code that creates the test view'
def lv_check(vg_name, lv_name): DCNL 'Check whether provided logical volume exists.'
def raw_cron(user): DCNL 'Return the contents of the user\'s crontab DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' cron.raw_cron root'
def create_logger(app): DCNL 'Creates a logger for the given application.  This logger works DCNL similar to a regular Python logger but changes the effective logging DCNL level based on the application\'s debug flag.  Furthermore this DCNL function also removes all attached handlers in case there was a DCNL logger with the log name before.'
def _parse_relators(rels): DCNL 'Parse the passed relators.'
def get_future_timestamp(idx, timestamps): DCNL 'recursive function to find most recent valid timestamp in the future'
def get_pull_request(project, num, auth=False): DCNL 'get pull request info  by number'
def shebang_matches(text, regex): DCNL 'Check if the given regular expression matches the last part of the DCNL shebang if one exists. DCNL >>> from pygments.util import shebang_matches DCNL >>> shebang_matches(\'#!/usr/bin/env python\', r\'python(2\.\d)?\') DCNL True DCNL >>> shebang_matches(\'#!/usr/bin/python2.4\', r\'python(2\.\d)?\') DCNL True DCNL >>> shebang_matches(\'#!/usr/bin/python-ruby\', r\'python(2\.\d)?\') DCNL False DCNL >>> shebang_matches(\'#!/usr/bin/python/ruby\', r\'python(2\.\d)?\') DCNL False DCNL >>> shebang_matches(\'#!/usr/bin/startsomethingwith python\', DCNL ...                 r\'python(2\.\d)?\') DCNL True DCNL It also checks for common windows executable file extensions:: DCNL >>> shebang_matches(\'#!C:\Python2.4\Python.exe\', r\'python(2\.\d)?\') DCNL True DCNL Parameters (``\'-f\'`` or ``\'--foo\'`` are ignored so ``\'perl\'`` does DCNL the same as ``\'perl -e\'``) DCNL Note that this method automatically searches the whole string (eg: DCNL the regular expression is wrapped in ``\'^$\'``)'
@cython.test_fail_if_path_exists('//ForInStatNode') DCNL def for_in_empty(): DCNL '>>> for_in_empty()'
def theq(a, b): DCNL 'theano equality'
def PrintUsageExit(code): DCNL 'Prints usage information and exits with a status code. DCNL Args: DCNL code: Status code to pass to sys.exit() after displaying usage information.'
def shutdown(opts): DCNL 'This is called when the proxy-minion is exiting to make sure the DCNL connection to the device is closed cleanly.'
def process_mistral_config(config_path): DCNL 'Remove sensitive data (credentials) from the Mistral config. DCNL :param config_path: Full absolute path to the mistral config inside /tmp. DCNL :type config_path: ``str``'
def upgrade_config(config, config_path=os.path.expanduser('~/.jrnl_conf')): DCNL 'Checks if there are keys missing in a given config dict, and if so, updates the config file accordingly. DCNL This essentially automatically ports jrnl installations if new config parameters are introduced in later DCNL versions.'
def get_klass_info(klass, max_depth=0, cur_depth=0, requested=None, only_load=None, from_parent=None): DCNL 'Helper function that recursively returns an information for a klass, to be DCNL used in get_cached_row.  It exists just to compute this information only DCNL once for entire queryset. Otherwise it would be computed for each row, which DCNL leads to poor perfomance on large querysets. DCNL Arguments: DCNL * klass - the class to retrieve (and instantiate) DCNL * max_depth - the maximum depth to which a select_related() DCNL relationship should be explored. DCNL * cur_depth - the current depth in the select_related() tree. DCNL Used in recursive calls to determin if we should dig deeper. DCNL * requested - A dictionary describing the select_related() tree DCNL that is to be retrieved. keys are field names; values are DCNL dictionaries describing the keys on that related object that DCNL are themselves to be select_related(). DCNL * only_load - if the query has had only() or defer() applied, DCNL this is the list of field names that will be returned. If None, DCNL the full field list for `klass` can be assumed. DCNL * from_parent - the parent model used to get to this model DCNL Note that when travelling from parent to child, we will only load child DCNL fields which aren\'t in the parent.'
def _install(quidditch, retries=5): DCNL 'and the last wrapper method. keeping things simple.'
def _reorder_unifrac_res(unifrac_res, sample_names_in_desired_order): DCNL 'reorder unifrac result DCNL unifrac res is distmtx,sample_names.  sample names not in unifrac\'s DCNL sample names (not in tree, all zeros in otu table(?)) will be included, DCNL with a user warning.'
def organisation(): DCNL 'RESTful Controller for Organisation (Referral Agencies)'
def download_youtube_subs(youtube_id, video_descriptor, settings): DCNL 'Download transcripts from Youtube and save them to assets. DCNL Args: DCNL youtube_id: str, actual youtube_id of the video. DCNL video_descriptor: video descriptor instance. DCNL We save transcripts for 1.0 speed, as for other speed conversion is done on front-end. DCNL Returns: DCNL None, if transcripts were successfully downloaded and saved. DCNL Raises: DCNL GetTranscriptsFromYouTubeException, if fails.'
def _collapse_address_list_recursive(addresses): DCNL 'Loops through the addresses, collapsing concurrent netblocks. DCNL Example: DCNL ip1 = IPv4Network\'1.1.0.0/24\') DCNL ip2 = IPv4Network\'1.1.1.0/24\') DCNL ip3 = IPv4Network\'1.1.2.0/24\') DCNL ip4 = IPv4Network\'1.1.3.0/24\') DCNL ip5 = IPv4Network\'1.1.4.0/24\') DCNL ip6 = IPv4Network\'1.1.0.1/22\') DCNL _collapse_address_list_recursive([ip1, ip2, ip3, ip4, ip5, ip6]) -> DCNL [IPv4Network(\'1.1.0.0/22\'), IPv4Network(\'1.1.4.0/24\')] DCNL This shouldn\'t be called directly; it is called via DCNL collapse_address_list([]). DCNL Args: DCNL addresses: A list of IPv4Network\'s or IPv6Network\'s DCNL Returns: DCNL A list of IPv4Network\'s or IPv6Network\'s depending on what we were DCNL passed.'
def add_handlers(handler_list, subparsers): DCNL 'Registers CommandHandlers for interacting with Stackdriver.'
def splitline(text): DCNL 'Splits the given text at newline. DCNL >>> splitline(\'foo\nbar\') DCNL (\'foo\n\', \'bar\') DCNL >>> splitline(\'foo\') DCNL (\'foo\', \'\') DCNL >>> splitline(\'\')'
def prism(): DCNL 'set the default colormap to prism and apply to current image if any. DCNL See help(colormaps) for more information'
def _machinectl(cmd, output_loglevel='debug', ignore_retcode=False, use_vt=False): DCNL 'Helper function to run machinectl'
def scott_bin_width(data, return_bins=False): DCNL 'Return the optimal histogram bin width using Scott\'s rule DCNL Scott\'s rule is a normal reference rule: it minimizes the integrated DCNL mean squared error in the bin approximation under the assumption that the DCNL data is approximately Gaussian. DCNL Parameters DCNL data : array-like, ndim=1 DCNL observed (one-dimensional) data DCNL return_bins : bool (optional) DCNL if True, then return the bin edges DCNL Returns DCNL width : float DCNL optimal bin width using Scott\'s rule DCNL bins : ndarray DCNL bin edges: returned if ``return_bins`` is True DCNL Notes DCNL The optimal bin width is DCNL .. math:: DCNL \Delta_b = \frac{3.5\sigma}{n^{1/3}} DCNL where :math:`\sigma` is the standard deviation of the data, and DCNL :math:`n` is the number of data points [1]_. DCNL References DCNL .. [1] Scott, David W. (1979). "On optimal and data-based histograms". DCNL Biometricka 66 (3): 605-610 DCNL See Also DCNL knuth_bin_width DCNL freedman_bin_width DCNL bayesian_blocks DCNL histogram'
def _quoteattr(data, entities={}): DCNL 'Escape and quote an attribute value. DCNL Escape &, <, and > in a string of data, then quote it for use as DCNL an attribute value.  The " character will be escaped as well, if DCNL necessary. DCNL You can escape other strings of data by passing a dictionary as DCNL the optional entities parameter.  The keys and values must all be DCNL strings; each key will be replaced with its corresponding value.'
def default_key_func(key, key_prefix, version): DCNL 'Default function to generate keys. DCNL Constructs the key used by all other methods. By default it prepends DCNL the `key_prefix\'. KEY_FUNCTION can be used to specify an alternate DCNL function with custom key making behavior.'
def get_host_numa_usage_from_instance(host, instance, free=False, never_serialize_result=False): DCNL 'Calculate new host NUMA usage from an instance\'s NUMA usage. DCNL Until the RPC version is bumped to 5.x, both host and instance DCNL representations may be provided in a variety of formats. Extract DCNL both host and instance numa topologies from provided DCNL representations, and use the latter to update the NUMA usage DCNL information of the former. DCNL :param host: nova.objects.ComputeNode instance, or a db object or DCNL dict DCNL :param instance: nova.objects.Instance instance, or a db object or DCNL dict DCNL :param free: if True the returned topology will have its usage DCNL decreased instead DCNL :param never_serialize_result: if True result will always be an DCNL instance of objects.NUMATopology DCNL :returns: a objects.NUMATopology instance if never_serialize_result DCNL was True, else numa_usage in the format it was on the DCNL host'
@protocol.commands.add(u'pause', state=protocol.BOOL) DCNL def pause(context, state=None): DCNL '*musicpd.org, playback section:* DCNL ``pause {PAUSE}`` DCNL Toggles pause/resumes playing, ``PAUSE`` is 0 or 1. DCNL *MPDroid:* DCNL - Calls ``pause`` without any arguments to toogle pause.'
def send_message(to, text, sender=None): DCNL 'Send a private message. DCNL :arg to: a list of Users to send the message to DCNL :arg sender: the User who is sending the message DCNL :arg text: the message text'
def validate(filename): DCNL 'Use W3C validator service: https://bitbucket.org/nmb10/py_w3c/ . DCNL :param filename: the filename to validate'
def __get_hosts_filename(): DCNL 'Return the path to the appropriate hosts file'
def collect_bears(bear_dirs, bear_globs, kinds, log_printer, warn_if_unused_glob=True): DCNL 'Collect all bears from bear directories that have a matching kind DCNL matching the given globs. DCNL :param bear_dirs:           Directory name or list of such that can contain DCNL bears. DCNL :param bear_globs:          Globs of bears to collect. DCNL :param kinds:               List of bear kinds to be collected. DCNL :param log_printer:         log_printer to handle logging. DCNL :param warn_if_unused_glob: True if warning message should be shown if a DCNL glob didn\'t give any bears. DCNL :return:                    Tuple of list of matching bear classes based on DCNL kind. The lists are in the same order as kinds.'
def _format_content(password, salt, encrypt=True): DCNL 'Format the password and salt for saving DCNL :arg password: the plaintext password to save DCNL :arg salt: the salt to use when encrypting a password DCNL :arg encrypt: Whether the user requests that this password is encrypted. DCNL Note that the password is saved in clear.  Encrypt just tells us if we DCNL must save the salt value for idempotence.  Defaults to True. DCNL :returns: a text string containing the formatted information DCNL .. warning:: Passwords are saved in clear.  This is because the playbooks DCNL expect to get cleartext passwords from this lookup.'
def _prep_stats_dict(values): DCNL 'Make list of ComputeNodeStats.'
def metric_init(params): DCNL 'metric_init(params) this is called by gmond to initialise the metrics'
def arcball_nearest_axis(point, axes): DCNL 'Return axis, which arc is nearest to point.'
def regions(): DCNL 'Get all available regions for the Amazon Elastic MapReduce service. DCNL :rtype: list DCNL :return: A list of :class:`boto.regioninfo.RegionInfo`'
def contains_nan(arr, node=None, var=None): DCNL 'Test whether a numpy.ndarray contains any `np.nan` values. DCNL Parameters DCNL arr : np.ndarray or output of any Theano op DCNL node : None or an Apply instance. DCNL If arr is the output of a Theano op, the node associated to it. DCNL var : The Theano symbolic variable. DCNL Returns DCNL contains_nan : bool DCNL `True` if the array contains any `np.nan` values, `False` otherwise. DCNL Notes DCNL Tests for the presence of `np.nan`\'s using `np.isnan(np.min(ndarray))`. DCNL This approach is faster and more memory efficient than the obvious DCNL alternative, calling `np.any(np.isnan(ndarray))`, which requires the DCNL construction of a boolean array with the same shape as the input array.'
def strip_html_tags(text): DCNL 'Remove html tags from text'
def runtests(args=None): DCNL 'Run the Bokeh tests under the bokeh python directory using pytest. DCNL Does not run tests from bokehjs or examples. DCNL Args: DCNL args(list, optional): command line arguments accepted by py.test DCNL e.g. args=[\'-s\', \'-k charts\'] prevents capture of standard out DCNL and only runs tests that match charts. For more py.test options DCNL see http://pytest.org/latest/usage.html#usage. DCNL Returns: DCNL int: pytest exitcode'
def wait_for_free_port(host, port, timeout=None): DCNL 'Wait for the specified port to become free (drop requests).'
def _get_service_result_parser(run=utils.run): DCNL 'Get the ServiceResultParser using the auto-detect init command. DCNL :return: ServiceResultParser fro the current init command. DCNL :rtype: _ServiceResultParser'
def update(context, qos_specs_id, specs): DCNL 'Update qos specs. DCNL :param specs: dictionary that contains key/value pairs for updating DCNL existing specs. DCNL e.g. {\'consumer\': \'front-end\', DCNL \'total_iops_sec\': 500, DCNL \'total_bytes_sec\': 512000,}'
def handle_extensions(extensions=('html',), ignored=('py',)): DCNL 'Organizes multiple extensions that are separated with commas or passed by DCNL using --extension/-e multiple times. Note that the .py extension is ignored DCNL here because of the way non-*.py files are handled in make_messages() (they DCNL are copied to file.ext.py files to trick xgettext to parse them as Python DCNL files). DCNL For example: running \'django-admin makemessages -e js,txt -e xhtml -a\' DCNL would result in an extension list: [\'.js\', \'.txt\', \'.xhtml\'] DCNL >>> handle_extensions([\'.html\', \'html,js,py,py,py,.py\', \'py,.py\']) DCNL set([\'.html\', \'.js\']) DCNL >>> handle_extensions([\'.html, txt,.tpl\']) DCNL set([\'.html\', \'.tpl\', \'.txt\'])'
def dtlz7(ind, n_objs): DCNL 'DTLZ7 multiobjective function. It returns a tuple of *obj* values. The DCNL individual must have at least *obj* elements. DCNL From: K. Deb, L. Thiele, M. Laumanns and E. Zitzler. Scalable Multi-Objective DCNL Optimization Test Problems. CEC 2002, p. 825-830, IEEE Press, 2002.'
def offset_spines(offset=10, fig=None, ax=None): DCNL 'Simple function to offset spines away from axes. DCNL Use this immediately after creating figure and axes objects. DCNL Offsetting spines after plotting or manipulating the axes DCNL objects may result in loss of labels, ticks, and formatting. DCNL Parameters DCNL offset : int, optional DCNL Absolute distance, in points, spines should be moved away DCNL from the axes (negative values move spines inward). DCNL fig : matplotlib figure, optional DCNL Figure to despine all axes of, default uses current figure. DCNL ax : matplotlib axes, optional DCNL Specific axes object to despine DCNL Returns DCNL None'
@verbose DCNL def spatio_temporal_dist_connectivity(src, n_times, dist, verbose=None): DCNL 'Compute connectivity from distances in a source space and time instants. DCNL Parameters DCNL src : instance of SourceSpaces DCNL The source space must have distances between vertices computed, such DCNL that src[\'dist\'] exists and is useful. This can be obtained using MNE DCNL with a call to mne_add_patch_info with the --dist option. DCNL n_times : int DCNL Number of time points DCNL dist : float DCNL Maximal geodesic distance (in m) between vertices in the DCNL source space to consider neighbors. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL connectivity : sparse COO matrix DCNL The connectivity matrix describing the spatio-temporal DCNL graph structure. If N is the number of vertices in the DCNL source space, the N first nodes in the graph are the DCNL vertices are time 1, the nodes from 2 to 2N are the vertices DCNL during time 2, etc.'
def security_group_rule_get_by_instance(context, instance_uuid): DCNL 'Get all rules for a given instance.'
def get_font(section='main', option='font', font_size_delta=0): DCNL 'Get console font properties depending on OS and user options'
@pytest.mark.django_db DCNL def test_save_store_fs_bad_lang(po_directory, tp0_store_fs): DCNL 'Try to save a store with a non-existent lang code'
def flexible_boolean(boolean): DCNL 'Returns True for any of "1", "true", or "True".  Returns False otherwise.'
def get_all_remote_methods(resolver=None, ns_prefix=u''): DCNL 'Returns a dictionary to be used for calling ``djangoCall.configure()``, which itself extends the DCNL Angular API to the client, offering him to call remote methods.'
def removeGeneratedFiles(): DCNL 'Remove generated files.'
def print_and_modify(obj, mods, dels): DCNL 'Print the modifications to an item and return a bool indicating DCNL whether any changes were made. DCNL `mods` is a dictionary of fields and values to update on the object; DCNL `dels` is a sequence of fields to delete.'
def labeled_comprehension(input, labels, index, func, out_dtype, default, pass_positions=False): DCNL 'Roughly equivalent to [func(input[labels == i]) for i in index]. DCNL Sequentially applies an arbitrary function (that works on array_like input) DCNL to subsets of an n-D image array specified by `labels` and `index`. DCNL The option exists to provide the function with positional parameters as the DCNL second argument. DCNL Parameters DCNL input : array_like DCNL Data from which to select `labels` to process. DCNL labels : array_like or None DCNL Labels to objects in `input`. DCNL If not None, array must be same shape as `input`. DCNL If None, `func` is applied to raveled `input`. DCNL index : int, sequence of ints or None DCNL Subset of `labels` to which to apply `func`. DCNL If a scalar, a single value is returned. DCNL If None, `func` is applied to all non-zero values of `labels`. DCNL func : callable DCNL Python function to apply to `labels` from `input`. DCNL out_dtype : dtype DCNL Dtype to use for `result`. DCNL default : int, float or None DCNL Default return value when a element of `index` does not exist DCNL in `labels`. DCNL pass_positions : bool, optional DCNL If True, pass linear indices to `func` as a second argument. DCNL Default is False. DCNL Returns DCNL result : ndarray DCNL Result of applying `func` to each of `labels` to `input` in `index`. DCNL Examples DCNL >>> a = np.array([[1, 2, 0, 0], DCNL ...               [5, 3, 0, 4], DCNL ...               [0, 0, 0, 7], DCNL ...               [9, 3, 0, 0]]) DCNL >>> from scipy import ndimage DCNL >>> lbl, nlbl = ndimage.label(a) DCNL >>> lbls = np.arange(1, nlbl+1) DCNL >>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, 0) DCNL array([ 2.75,  5.5 ,  6.  ]) DCNL Falling back to `default`: DCNL >>> lbls = np.arange(1, nlbl+2) DCNL >>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, -1) DCNL array([ 2.75,  5.5 ,  6.  , -1.  ]) DCNL Passing positions: DCNL >>> def fn(val, pos): DCNL ...     print("fn says: %s : %s" % (val, pos)) DCNL ...     return (val.sum()) if (pos.sum() % 2 == 0) else (-val.sum()) DCNL >>> ndimage.labeled_comprehension(a, lbl, lbls, fn, float, 0, True) DCNL fn says: [1 2 5 3] : [0 1 4 5] DCNL fn says: [4 7] : [ 7 11] DCNL fn says: [9 3] : [12 13] DCNL array([ 11.,  11., -12.,   0.])'
def get_file_hash(filePath): DCNL 'Returns the ed2k hash of a given file.'
def backup_destroy(context, backup_id): DCNL 'Destroy the backup or raise if it does not exist.'
def __determine_resource_obj(service, resource): DCNL 'Find the desired resource object method container from the service. DCNL Args: DCNL service: [stub] Google API stub object. DCNL resource: [string]  \'.\' delimited resource name in service API.'
def t_preprocessor(t): DCNL '\#(.)*?\n'
def _list_designs(user, querydict, page_size, prefix='', is_trashed=False): DCNL '_list_designs(user, querydict, page_size, prefix, is_trashed) -> (page, filter_param) DCNL A helper to gather the designs page. It understands all the GET params in DCNL ``list_designs``, by reading keys from the ``querydict`` with the given ``prefix``.'
def _get_hold(line, pattern=__HOLD_PATTERN, full=True): DCNL 'Resolve a package name from a line containing the hold expression. If the DCNL regex is not matched, None is returned. DCNL yum ==> 2:vim-enhanced-7.4.629-5.el6.* DCNL dnf ==> vim-enhanced-2:7.4.827-1.fc22.*'
def boxplot_frame_groupby(grouped, subplots=True, column=None, fontsize=None, rot=0, grid=True, ax=None, figsize=None, layout=None, **kwds): DCNL 'Make box plots from DataFrameGroupBy data. DCNL Parameters DCNL grouped : Grouped DataFrame DCNL subplots : DCNL * ``False`` - no subplots will be used DCNL * ``True`` - create a subplot for each group DCNL column : column name or list of names, or vector DCNL Can be any valid input to groupby DCNL fontsize : int or string DCNL rot : label rotation angle DCNL grid : Setting this to True will show the grid DCNL ax : Matplotlib axis object, default None DCNL figsize : A tuple (width, height) in inches DCNL layout : tuple (optional) DCNL (rows, columns) for the layout of the plot DCNL kwds : other plotting keyword arguments to be passed to matplotlib boxplot DCNL function DCNL Returns DCNL dict of key/value = group key/DataFrame.boxplot return value DCNL or DataFrame.boxplot return value in case subplots=figures=False DCNL Examples DCNL >>> import pandas DCNL >>> import numpy as np DCNL >>> import itertools DCNL >>> tuples = [t for t in itertools.product(range(1000), range(4))] DCNL >>> index = pandas.MultiIndex.from_tuples(tuples, names=[\'lvl0\', \'lvl1\']) DCNL >>> data = np.random.randn(len(index),4) DCNL >>> df = pandas.DataFrame(data, columns=list(\'ABCD\'), index=index) DCNL >>> grouped = df.groupby(level=\'lvl1\') DCNL >>> boxplot_frame_groupby(grouped) DCNL >>> grouped = df.unstack(level=\'lvl1\').groupby(level=0, axis=1) DCNL >>> boxplot_frame_groupby(grouped, subplots=False)'
@login_required DCNL def delete_favorite(req, id): DCNL 'delete favorite and put favorite_info object in response. DCNL method is idempotent, if favorite does not exist, just return favorite_info.'
def set_task_user(f): DCNL 'Sets the user to be the task user, then unsets it.'
@treeio_login_required DCNL @handle_response_format DCNL def ordered_product_add(request, order_id=None, response_format='html'): DCNL 'Add new Ordered Product'
@nx.utils.open_file(5, 'w') DCNL def view_pygraphviz(G, edgelabel=None, prog='dot', args='', suffix='', path=None): DCNL 'Views the graph G using the specified layout algorithm. DCNL Parameters DCNL G : NetworkX graph DCNL The machine to draw. DCNL edgelabel : str, callable, None DCNL If a string, then it specifes the edge attribute to be displayed DCNL on the edge labels. If a callable, then it is called for each DCNL edge and it should return the string to be displayed on the edges. DCNL The function signature of `edgelabel` should be edgelabel(data), DCNL where `data` is the edge attribute dictionary. DCNL prog : string DCNL Name of Graphviz layout program. DCNL args : str DCNL Additional arguments to pass to the Graphviz layout program. DCNL suffix : str DCNL If `filename` is None, we save to a temporary file.  The value of DCNL `suffix` will appear at the tail end of the temporary filename. DCNL path : str, None DCNL The filename used to save the image.  If None, save to a temporary DCNL file.  File formats are the same as those from pygraphviz.agraph.draw. DCNL Returns DCNL path : str DCNL The filename of the generated image. DCNL A : PyGraphviz graph DCNL The PyGraphviz graph instance used to generate the image. DCNL Notes DCNL If this function is called in succession too quickly, sometimes the DCNL image is not displayed. So you might consider time.sleep(.5) between DCNL calls if you experience problems.'
def parseString(string, namespaces=True): DCNL 'Parse a document from a string, returning the resulting DCNL Document node.'
def getblock(lines): DCNL 'Extract the block of code at the top of the given list of lines.'
def tolist(val): DCNL 'Convert a value that may be a list or a (possibly comma-separated) DCNL string into a list. The exception: None is returned as None, not [None]. DCNL >>> tolist(["one", "two"]) DCNL [\'one\', \'two\'] DCNL >>> tolist("hello") DCNL [\'hello\'] DCNL >>> tolist("separate,values, with, commas,  spaces , are    ,ok") DCNL [\'separate\', \'values\', \'with\', \'commas\', \'spaces\', \'are\', \'ok\']'
def worker_destroy(context, **filters): DCNL 'Delete a worker (no soft delete).'
def get_output_volume(): DCNL 'Get the output volume (range 0 to 100) DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' desktop.get_output_volume'
@manager_config DCNL @no_xinerama DCNL def test_last_float_size(qtile): DCNL 'When you re-float something it would be preferable to have it use the previous float size'
def create_chunks(sequence, size): DCNL 'Generate chunks from a sequence. DCNL Parameters DCNL sequence : iterable DCNL Any iterable object DCNL size : int DCNL The chunksize to be returned'
def simplefilter(action, category=Warning, lineno=0, append=0): DCNL 'Insert a simple entry into the list of warnings filters (at the front). DCNL A simple filter matches all modules and messages. DCNL \'action\' -- one of "error", "ignore", "always", "default", "module", DCNL or "once" DCNL \'category\' -- a class that the warning must be a subclass of DCNL \'lineno\' -- an integer line number, 0 matches all warnings DCNL \'append\' -- if true, append to the list of filters'
def dont_import_local_tempest_into_lib(logical_line, filename): DCNL 'Check that tempest.lib should not import local tempest code DCNL T112'
def modify(name, **kwargs): DCNL 'Modify an existing job in the schedule DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' schedule.modify job1 function=\'test.ping\' seconds=3600'
def task_upgrade_kernel(distribution): DCNL 'Upgrade kernel.'
@app.route('/delay/<delay>') DCNL def delay_response(delay): DCNL 'Returns a delayed response'
def is_larger(unit_1, unit_2): DCNL 'Returns a boolean indicating whether unit_1 is larger than unit_2. DCNL E.g: DCNL >>> is_larger(\'KB\', \'B\') DCNL True DCNL >>> is_larger(\'min\', \'day\') DCNL False'
def requirement_available(requirement): DCNL 'Checks if requirement can be imported. DCNL :rtype: bool DCNL :returns: ``True`` iff requirement can be imported'
def _trace_D(gj, p_i, Dxtrav): DCNL 'Return the representative h satisfying h[gj] == p_i DCNL If there is not such a representative return None'
def launch(no_flow=False, network='192.168.0.0/24', first=1, last=None, count=None, ip='192.168.0.254', router=(), dns=()): DCNL 'Launch DHCP server DCNL Defaults to serving 192.168.0.1 to 192.168.0.253 DCNL network  Subnet to allocate addresses from DCNL first    First\'th address in subnet to use (256 is x.x.1.0 in a /16) DCNL last     Last\'th address in subnet to use DCNL count    Alternate way to specify last address to use DCNL ip       IP to use for DHCP server DCNL router   Router IP to tell clients. Defaults to \'ip\'. \'None\' will DCNL stop the server from telling clients anything DCNL dns      DNS IP to tell clients.  Defaults to \'router\'.  \'None\' will DCNL stop the server from telling clients anything.'
def getparser(use_datetime=0): DCNL 'getparser() -> parser, unmarshaller DCNL Create an instance of the fastest available parser, and attach it DCNL to an unmarshalling object.  Return both objects.'
def detachAcceptMsOriginating(): DCNL 'DETACH ACCEPT Section 9.4.6.2'
def protected_view(context, request): DCNL ''
def parse_http_load(full_load, http_methods): DCNL 'Split the raw load into list of headers and body string'
def long_to_bson_ts(val): DCNL 'Convert integer into BSON timestamp.'
def run(cmd, cwd=None, stdin=None, runas=None, shell=DEFAULT_SHELL, python_shell=None, env=None, clean_env=False, template=None, rstrip=True, umask=None, output_loglevel='debug', log_callback=None, timeout=None, reset_system_locale=True, ignore_retcode=False, saltenv='base', use_vt=False, bg=False, password=None, encoded_cmd=False, **kwargs): DCNL 'Execute the passed command and return the output as a string DCNL Note that ``env`` represents the environment variables for the command, and DCNL should be formatted as a dict, or a YAML string which resolves to a dict. DCNL :param str cmd: The command to run. ex: ``ls -lart /home`` DCNL :param str cwd: The current working directory to execute the command in. DCNL Defaults to the home directory of the user specified by ``runas``. DCNL :param str stdin: A string of standard input can be specified for the DCNL command to be run using the ``stdin`` parameter. This can be useful in cases DCNL where sensitive information must be read from standard input.: DCNL :param str runas: User to run script as. If running on a Windows minion you DCNL must also pass a password DCNL :param str password: Windows only. Required when specifying ``runas``. This DCNL parameter will be ignored on non-Windows platforms. DCNL .. versionadded:: 2016.3.0 DCNL :param str shell: Shell to execute under. Defaults to the system default DCNL shell. DCNL :param bool python_shell: If False, let python handle the positional DCNL arguments. Set to True to use shell features, such as pipes or redirection DCNL :param bool bg: If True, run command in background and do not await or deliver it\'s results DCNL :param list env: A list of environment variables to be set prior to DCNL execution. DCNL Example: DCNL .. code-block:: yaml DCNL salt://scripts/foo.sh: DCNL cmd.script: DCNL - env: DCNL - BATCH: \'yes\' DCNL .. warning:: DCNL The above illustrates a common PyYAML pitfall, that **yes**, DCNL **no**, **on**, **off**, **true**, and **false** are all loaded as DCNL boolean ``True`` and ``False`` values, and must be enclosed in DCNL quotes to be used as strings. More info on this (and other) PyYAML DCNL idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`. DCNL Variables as values are not evaluated. So $PATH in the following DCNL example is a literal \'$PATH\': DCNL .. code-block:: yaml DCNL salt://scripts/bar.sh: DCNL cmd.script: DCNL - env: "PATH=/some/path:$PATH" DCNL One can still use the existing $PATH by using a bit of Jinja: DCNL .. code-block:: yaml DCNL {% set current_path = salt[\'environ.get\'](\'PATH\', \'/bin:/usr/bin\') %} DCNL mycommand: DCNL cmd.run: DCNL - name: ls -l / DCNL - env: DCNL - PATH: {{ [current_path, \'/my/special/bin\']|join(\':\') }} DCNL :param bool clean_env: Attempt to clean out all other shell environment DCNL variables and set only those provided in the \'env\' argument to this DCNL function. DCNL :param str template: If this setting is applied then the named templating DCNL engine will be used to render the downloaded file. Currently jinja, mako, DCNL and wempy are supported DCNL :param bool rstrip: Strip all whitespace off the end of output before it is DCNL returned. DCNL :param str umask: The umask (in octal) to use when running the command. DCNL :param str output_loglevel: Control the loglevel at which the output from DCNL the command is logged. Note that the command being run will still be logged DCNL (loglevel: DEBUG) regardless, unless ``quiet`` is used for this value. DCNL :param int timeout: A timeout in seconds for the executed process to return. DCNL :param bool use_vt: Use VT utils (saltstack) to stream the command output DCNL more interactively to the console and the logs. This is experimental. DCNL :param bool encoded_cmd: Specify if the supplied command is encoded. DCNL Only applies to shell \'powershell\'. DCNL .. warning:: DCNL This function does not process commands through a shell DCNL unless the python_shell flag is set to True. This means that any DCNL shell-specific functionality such as \'echo\' or the use of pipes, DCNL redirection or &&, should either be migrated to cmd.shell or DCNL have the python_shell=True flag set here. DCNL The use of python_shell=True means that the shell will accept _any_ input DCNL including potentially malicious commands such as \'good_command;rm -rf /\'. DCNL Be absolutely certain that you have sanitized your input prior to using DCNL python_shell=True DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run "ls -l | awk \'/foo/{print \\$2}\'" DCNL The template arg can be set to \'jinja\' or another supported template DCNL engine to render the command arguments before execution. DCNL For example: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run template=jinja "ls -l /tmp/{{grains.id}} | awk \'/foo/{print \\$2}\'" DCNL Specify an alternate shell with the shell parameter: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run "Get-ChildItem C:\\ " shell=\'powershell\' DCNL A string of standard input can be specified for the command to be run using DCNL the ``stdin`` parameter. This can be useful in cases where sensitive DCNL information must be read from standard input.: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run "grep f" stdin=\'one\\ntwo\\nthree\\nfour\\nfive\\n\' DCNL If an equal sign (``=``) appears in an argument to a Salt command it is DCNL interpreted as a keyword argument in the format ``key=val``. That DCNL processing can be bypassed in order to pass an equal sign through to the DCNL remote shell command by manually specifying the kwarg: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run cmd=\'sed -e s/=/:/g\''
@core_helper DCNL def resource_preview(resource, package): DCNL 'Returns a rendered snippet for a embedded resource preview. DCNL Depending on the type, different previews are loaded. DCNL This could be an img tag where the image is loaded directly or an iframe DCNL that embeds a web page or a recline preview.'
def keybinding(attr): DCNL 'Return keybinding'
def forwards(apps, schema_editor): DCNL 'Add the service user.'
def get_current_timezone(): DCNL 'Returns the currently active time zone as a tzinfo instance.'
def _get_lights(): DCNL 'Get all available lighting devices.'
def saltstack(parser, xml_parent, data): DCNL 'yaml: saltstack DCNL Send a message to Salt API. Requires the :jenkins-wiki:`saltstack plugin DCNL <saltstack-plugin>`. DCNL :arg str servername: Salt master server name (required) DCNL :arg str authtype: Authentication type (\'pam\' or \'ldap\', default \'pam\') DCNL :arg str credentials: Credentials ID for which to authenticate to Salt DCNL master (required) DCNL :arg str target: Target minions (default \'\') DCNL :arg str targettype: Target type (\'glob\', \'pcre\', \'list\', \'grain\', DCNL \'pillar\', \'nodegroup\', \'range\', or \'compound\', default \'glob\') DCNL :arg str function: Function to execute (default \'\') DCNL :arg str arguments: Salt function arguments (default \'\') DCNL :arg str kwarguments: Salt keyword arguments (default \'\') DCNL :arg bool saveoutput: Save Salt return data into environment variable DCNL (default false) DCNL :arg str clientinterface: Client interface type (\'local\', \'local-batch\', DCNL or \'runner\', default \'local\') DCNL :arg bool wait: Wait for completion of command (default false) DCNL :arg str polltime: Number of seconds to wait before polling job completion DCNL status (default \'\') DCNL :arg str batchsize: Salt batch size, absolute value or %-age (default 100%) DCNL :arg str mods: Mods to runner (default \'\') DCNL :arg bool setpillardata: Set Pillar data (default false) DCNL :arg str pillarkey: Pillar key (default \'\') DCNL :arg str pillarvalue: Pillar value (default \'\') DCNL Minimal Example: DCNL .. literalinclude:: ../../tests/builders/fixtures/saltstack-minimal.yaml DCNL :language: yaml DCNL Full Example: DCNL .. literalinclude:: ../../tests/builders/fixtures/saltstack-full.yaml DCNL :language: yaml'
def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True, extra_args=None): DCNL 'Return the compile contract code. DCNL Args: DCNL filepath (str): The path to the contract source code. DCNL libraries (dict): A dictionary mapping library name to it\'s address. DCNL combined (str): The argument for solc\'s --combined-json. DCNL optimize (bool): Enable/disables compiler optimization. DCNL Returns: DCNL dict: A mapping from the contract name to it\'s binary.'
def test_try_finally_regression(c): DCNL '>>> test_try_finally_regression(True) DCNL (123,) DCNL >>> test_try_finally_regression(False) DCNL Traceback (most recent call last): DCNL UnboundLocalError: local variable \'a\' referenced before assignment'
def send_notif_for_after_purchase(user, invoice_id, order_url): DCNL 'Send notification with order invoice link after purchase'
def make_letterboxed_thumbnail(image, shape): DCNL 'Scales image down to shape. Preserves proportions of image, introduces DCNL black letterboxing if necessary. DCNL Parameters DCNL image : WRITEME DCNL shape : WRITEME DCNL Returns DCNL WRITEME'
def threshold_minimum(image, nbins=256, bias='min', max_iter=10000): DCNL 'Return threshold value based on minimum method. DCNL The histogram of the input `image` is computed and smoothed until there are DCNL only two maxima. Then the minimum in between is the threshold value. DCNL Parameters DCNL image : (M, N) ndarray DCNL Input image. DCNL nbins : int, optional DCNL Number of bins used to calculate histogram. This value is ignored for DCNL integer arrays. DCNL bias : {\'min\', \'mid\', \'max\'}, optional DCNL \'min\', \'mid\', \'max\' return lowest, middle, or highest pixel value DCNL with minimum histogram value. DCNL max_iter: int, optional DCNL Maximum number of iterations to smooth the histogram. DCNL Returns DCNL threshold : float DCNL Upper threshold value. All pixels with an intensity higher than DCNL this value are assumed to be foreground. DCNL Raises DCNL RuntimeError DCNL If unable to find two local maxima in the histogram or if the DCNL smoothing takes more than 1e4 iterations. DCNL References DCNL .. [1] Prewitt, JMS & Mendelsohn, ML (1966), "The analysis of cell images", DCNL Annals of the New York Academy of Sciences 128: 1035-1053 DCNL DOI:10.1111/j.1749-6632.1965.tb11715.x DCNL Examples DCNL >>> from skimage.data import camera DCNL >>> image = camera() DCNL >>> thresh = threshold_minimum(image) DCNL >>> binary = image > thresh'
def Pluralize(count, singular='', plural='s'): DCNL 'Return the pluralization suffix for "count" item(s). For example: DCNL \'item\' + Pluralize(1) = \'item\' DCNL \'item\' + Pluralize(2) = \'items\' DCNL \'activit\' + Pluralize(1, \'y\', \'ies\') = \'activity\' DCNL \'activit\' + Pluralize(0, \'y\', \'ies\') = \'activities\''
@handle_response_format DCNL @treeio_login_required DCNL def index(request, response_format='html'): DCNL 'Default index page'
def _ssh_slave_addresses(ssh_bin, master_address, ec2_key_pair_file): DCNL 'Get the IP addresses of the slave nodes. Fails silently because it DCNL makes testing easier and if things are broken they will fail before this DCNL function is called.'
def _algorithm_2_2(A, AT, t): DCNL 'This is Algorithm 2.2. DCNL Parameters DCNL A : ndarray or other linear operator DCNL A linear operator that can produce matrix products. DCNL AT : ndarray or other linear operator DCNL The transpose of A. DCNL t : int, optional DCNL A positive parameter controlling the tradeoff between DCNL accuracy versus time and memory usage. DCNL Returns DCNL g : sequence DCNL A non-negative decreasing vector DCNL such that g[j] is a lower bound for the 1-norm DCNL of the column of A of jth largest 1-norm. DCNL The first entry of this vector is therefore a lower bound DCNL on the 1-norm of the linear operator A. DCNL This sequence has length t. DCNL ind : sequence DCNL The ith entry of ind is the index of the column A whose 1-norm DCNL is given by g[i]. DCNL This sequence of indices has length t, and its entries are DCNL chosen from range(n), possibly with repetition, DCNL where n is the order of the operator A. DCNL Notes DCNL This algorithm is mainly for testing. DCNL It uses the \'ind\' array in a way that is similar to DCNL its usage in algorithm 2.4.  This algorithm 2.2 may be easier to test, DCNL so it gives a chance of uncovering bugs related to indexing DCNL which could have propagated less noticeably to algorithm 2.4.'
def get_user_api_key(): DCNL 'Test user API key to use for functional tests. If set, this should drive DCNL API based testing - if not set master API key should be used to create a new DCNL user and API key for tests.'
def pad_sequences(sequences, maxlen=None, dtype='int32', padding='post', truncating='pre', value=0.0): DCNL 'Pads each sequence to the same length: DCNL the length of the longest sequence. DCNL If maxlen is provided, any sequence longer DCNL than maxlen is truncated to maxlen. DCNL Truncation happens off either the beginning (default) or DCNL the end of the sequence. DCNL Supports post-padding and pre-padding (default). DCNL Parameters DCNL sequences : list of lists where each element is a sequence DCNL maxlen : int, maximum length DCNL dtype : type to cast the resulting sequence. DCNL padding : \'pre\' or \'post\', pad either before or after each sequence. DCNL truncating : \'pre\' or \'post\', remove values from sequences larger than DCNL maxlen either in the beginning or in the end of the sequence DCNL value : float, value to pad the sequences to the desired value. DCNL Returns DCNL x : numpy array with dimensions (number_of_sequences, maxlen) DCNL Examples DCNL >>> sequences = [[1,1,1,1,1],[2,2,2],[3,3]] DCNL >>> sequences = pad_sequences(sequences, maxlen=None, dtype=\'int32\', DCNL ...                  padding=\'post\', truncating=\'pre\', value=0.) DCNL ... [[1 1 1 1 1] DCNL ...  [2 2 2 0 0] DCNL ...  [3 3 0 0 0]]'
def trim_lex(tokens): DCNL 'Takes a lexed set of tokens, and removes whitespace when there is DCNL a directive on a line by itself: DCNL >>> tokens = lex(\'{{if x}}\nx\n{{endif}}\ny\', trim_whitespace=False) DCNL >>> tokens DCNL [(\'if x\', (1, 3)), \'\nx\n\', (\'endif\', (3, 3)), \'\ny\'] DCNL >>> trim_lex(tokens) DCNL [(\'if x\', (1, 3)), \'x\n\', (\'endif\', (3, 3)), \'y\']'
def overwrite_from_dates(asof, dense_dates, sparse_dates, asset_idx, value): DCNL 'Construct a `Float64Overwrite` with the correct DCNL start and end date based on the asof date of the delta, DCNL the dense_dates, and the dense_dates. DCNL Parameters DCNL asof : datetime DCNL The asof date of the delta. DCNL dense_dates : pd.DatetimeIndex DCNL The dates requested by the loader. DCNL sparse_dates : pd.DatetimeIndex DCNL The dates that appeared in the dataset. DCNL asset_idx : tuple of int DCNL The index of the asset in the block. If this is a tuple, then this DCNL is treated as the first and last index to use. DCNL value : np.float64 DCNL The value to overwrite with. DCNL Returns DCNL overwrite : Float64Overwrite DCNL The overwrite that will apply the new value to the data. DCNL Notes DCNL This is forward-filling all dense dates that are between the asof_date date DCNL and the next sparse date after the asof_date. DCNL For example: DCNL let ``asof = pd.Timestamp(\'2014-01-02\')``, DCNL ``dense_dates = pd.date_range(\'2014-01-01\', \'2014-01-05\')`` DCNL ``sparse_dates = pd.to_datetime([\'2014-01\', \'2014-02\', \'2014-04\'])`` DCNL Then the overwrite will apply to indexes: 1, 2, 3, 4'
def item_create(item, item_id, item_type, create='create', extra_args=None, cibfile=None): DCNL 'Create an item via pcs command DCNL (mainly for use with the pcs state module) DCNL item DCNL config, property, resource, constraint etc. DCNL item_id DCNL id of the item DCNL item_type DCNL item type DCNL create DCNL create command (create or set f.e., default: create) DCNL extra_args DCNL additional options for the pcs command DCNL cibfile DCNL use cibfile instead of the live CIB'
def random_reduce(circuit, gate_ids, seed=None): DCNL 'Shorten the length of a quantum circuit. DCNL random_reduce looks for circuit identities in circuit, randomly chooses DCNL one to remove, and returns a shorter yet equivalent circuit.  If no DCNL identities are found, the same circuit is returned. DCNL Parameters DCNL circuit : Gate tuple of Mul DCNL A tuple of Gates representing a quantum circuit DCNL gate_ids : list, GateIdentity DCNL List of gate identities to find in circuit DCNL seed : int or list DCNL seed used for _randrange; to override the random selection, provide a DCNL list of integers: the elements of gate_ids will be tested in the order DCNL given by the list'
def _connect_user(request, facebook, overwrite=True): DCNL 'Update the fields on the user model and connects it to the facebook account'
def path_separator(): DCNL 'Get the path separator for the current operating system. The path DCNL separator is used to separate elements of a path string, such as DCNL "PATH" or "CLASSPATH". (It\'s a ":" on Unix-like systems and a ";" DCNL on Windows.) DCNL :rtype: str DCNL :return: the path separator'
def write_cron_file(user, path): DCNL 'Writes the contents of a file to a user\'s crontab DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' cron.write_cron_file root /tmp/new_cron DCNL .. versionchanged:: 2015.8.9 DCNL .. note:: DCNL Some OS\' do not support specifying user via the `crontab` command i.e. (Solaris, AIX)'
def get_img_channel(image_path): DCNL 'Load a image and return the channel of the image DCNL :param image_path: DCNL :return: the channel of the image'
def get_partial_date_formats(): DCNL 'Checks whether translation files provide a translation for some technical DCNL message ID to store partial date formats. If it doesn\'t contain one, the DCNL formats provided in the settings will be used.'
def _string_from_json(value, _): DCNL 'NOOP string -> string coercion'
def generate_cert(name): DCNL 'Generate an icinga2 certificate and key on the client. DCNL name DCNL The domain name for which this certificate and key will be generated'
def check_mount(root, drive): DCNL 'Verify that the path to the device is a mount point and mounted.  This DCNL allows us to fast fail on drives that have been unmounted because of DCNL issues, and also prevents us for accidentally filling up the root DCNL partition. DCNL :param root:  base path where the devices are mounted DCNL :param drive: drive name to be checked DCNL :returns: True if it is a valid mounted device, False otherwise'
def show(config_file=False): DCNL 'Return a list of sysctl parameters for this minion DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' sysctl.show'
def _step4(state): DCNL 'Find a noncovered zero and prime it. If there is no starred zero DCNL in the row containing this primed zero, Go to Step 5. Otherwise, DCNL cover this row and uncover the column containing the starred DCNL zero. Continue in this manner until there are no uncovered zeros DCNL left. Save the smallest uncovered value and Go to Step 6.'
def hook(ui, repo, **kwargs): DCNL 'Invoked by configuring a [hook] entry in .hg/hgrc.'
def is_coroutine(function): DCNL 'Returns True if the passed in function is a coroutine'
def decompress(fileobj, path): DCNL 'Take a *fileobj* correponding to the given path and returns an iterator DCNL that yield chunks of bytes, or, if *path* doesn\'t correspond to a DCNL compressed file type, *fileobj* itself.'
def nextLine(): DCNL 'Retrive the file name and line number immediately after where this function DCNL is called. DCNL @return: the file name and line number DCNL @rtype: 2-L{tuple} of L{str}, L{int}'
def _ConvertToCygpath(path): DCNL 'Convert to cygwin path if we are using cygwin.'
def load_werkzeug(path): DCNL 'Load werkzeug.'
def signature(obj): DCNL 'Get a signature object for the passed callable.'
def set_server_setting(settings, server=_DEFAULT_SERVER): DCNL 'Set the value of the setting for the SMTP virtual server. DCNL .. note:: DCNL The setting names are case-sensitive. DCNL :param str settings: A dictionary of the setting names and their values. DCNL :param str server: The SMTP server name. DCNL :return: A boolean representing whether all changes succeeded. DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' win_smtp_server.set_server_setting settings="{\'MaxRecipients\': \'500\'}"'
def get_ip_version(network): DCNL 'Returns the IP version of a network (IPv4 or IPv6). Raises DCNL AddrFormatError if invalid network.'
def task_accepted(request, _all_total_count=all_total_count, add_active_request=active_requests.add, add_to_total_count=total_count.update): DCNL 'Update global state when a task has been accepted.'
def ustr(value, hint_encoding='utf-8', errors='strict'): DCNL 'This method is similar to the builtin `unicode`, except DCNL that it may try multiple encodings to find one that works DCNL for decoding `value`, and defaults to \'utf-8\' first. DCNL :param: value: the value to convert DCNL :param: hint_encoding: an optional encoding that was detecte DCNL upstream and should be tried first to decode ``value``. DCNL :param str errors: optional `errors` flag to pass to the unicode DCNL built-in to indicate how illegal character values should be DCNL treated when converting a string: \'strict\', \'ignore\' or \'replace\' DCNL (see ``unicode()`` constructor). DCNL Passing anything other than \'strict\' means that the first DCNL encoding tried will be used, even if it\'s not the correct DCNL one to use, so be careful! Ignored if value is not a string/unicode. DCNL :raise: UnicodeError if value cannot be coerced to unicode DCNL :return: unicode string representing the given value'
def make_secret_key(project_directory): DCNL 'Generates and saves random secret key'
def deprecatedModuleAttribute(version, message, moduleName, name): DCNL 'Declare a module-level attribute as being deprecated. DCNL @type version: L{incremental.Version} DCNL @param version: Version that the attribute was deprecated in DCNL @type message: C{str} DCNL @param message: Deprecation message DCNL @type moduleName: C{str} DCNL @param moduleName: Fully-qualified Python name of the module containing DCNL the deprecated attribute; if called from the same module as the DCNL attributes are being deprecated in, using the C{__name__} global can DCNL be helpful DCNL @type name: C{str} DCNL @param name: Attribute name to deprecate'
def _tgrep_rel_disjunction_action(_s, _l, tokens): DCNL 'Builds a lambda function representing a predicate on a tree node DCNL from the disjunction of several other such lambda functions.'
def EnumTlbs(excludeFlags=0): DCNL 'Return a list of TypelibSpec objects, one for each registered library.'
def samplesize_confint_proportion(proportion, half_length, alpha=0.05, method='normal'): DCNL 'find sample size to get desired confidence interval length DCNL Parameters DCNL proportion : float in (0, 1) DCNL proportion or quantile DCNL half_length : float in (0, 1) DCNL desired half length of the confidence interval DCNL alpha : float in (0, 1) DCNL significance level, default 0.05, DCNL coverage of the two-sided interval is (approximately) ``1 - alpha`` DCNL method : string in [\'normal\'] DCNL method to use for confidence interval, DCNL currently only normal approximation DCNL Returns DCNL n : float DCNL sample size to get the desired half length of the confidence interval DCNL Notes DCNL this is mainly to store the formula. DCNL possible application: number of replications in bootstrap samples'
def test_resample(): DCNL 'Github issue #6025 pointed to incorrect ListedColormap._resample; DCNL here we test the method for LinearSegmentedColormap as well.'
@treeio_login_required DCNL def account_view(request, response_format='html'): DCNL 'Account view'
def _is_resumable(exc): DCNL 'Check if caught exception represents EINTR error. DCNL :param exc: exception; must be one of classes in _SELECT_ERRORS'
def get_pointer(ctypes_func): DCNL 'Get a pointer to the underlying function for a ctypes function as an DCNL integer.'
def _invalidWin32App(pywinerr): DCNL 'Determine if a pywintypes.error is telling us that the given process is DCNL \'not a valid win32 application\', i.e. not a PE format executable. DCNL @param pywinerr: a pywintypes.error instance raised by CreateProcess DCNL @return: a boolean'
def _generate_meta(): DCNL 'Generate Meta information for export'
def assert_array_list_equal(xlist, ylist, err_msg='', verbose=True): DCNL 'Compares lists of arrays pairwise with ``assert_array_equal``. DCNL Args: DCNL x(array_like): Array of the actual objects. DCNL y(array_like): Array of the desired, expected objects. DCNL err_msg(str): The error message to be printed in case of failure. DCNL verbose(bool): If ``True``, the conflicting values DCNL are appended to the error message. DCNL Each element of ``x`` and ``y`` must be either :class:`numpy.ndarray` DCNL or :class:`cupy.ndarray`. ``x`` and ``y`` must have same length. DCNL Otherwise, this function raises ``AssertionError``. DCNL It compares elements of ``x`` and ``y`` pairwise DCNL with :func:`assert_array_equal` and raises error if at least one DCNL pair is not equal. DCNL .. seealso:: :func:`numpy.testing.assert_array_equal`'
def test_system_numerics_complex(): DCNL 'http://msdn.microsoft.com/en-us/library/system.numerics.complex(VS.100).aspx DCNL This should be tested minimally here, and hit comprehensively from number DCNL tests. Basically any "complex" test should pass against a Complex.'
def _get_output_filename(dataset_dir, split_name): DCNL 'Creates the output filename. DCNL Args: DCNL dataset_dir: The dataset directory where the dataset is stored. DCNL split_name: The name of the train/test split. DCNL Returns: DCNL An absolute file path.'
@auth.route('/reset-password', methods=['GET', 'POST']) DCNL def forgot_password(): DCNL 'Sends a reset password token to the user.'
def request_elements(*args, **kwargs): DCNL '.. warning:: DCNL This function is **deprecated** and will be removed in version 0.1.0! DCNL Use the :meth:`.Authomatic.request_elements` method instead.'
def lambdify(leaves, expr): DCNL 'Lambda for an expresion DCNL >>> t = symbol(\'t\', \'{x: int, y: int, z: int, when: datetime}\') DCNL >>> f = lambdify([t], t.x + t.y) DCNL >>> f((1, 10, 100, \'\')) DCNL 11 DCNL >>> f = lambdify([t.x, t.y, t.z, t.when], t.x + cos(t.y)) DCNL >>> f(1, 0, 100, \'\') DCNL 2.0'
def test_escape_decode(): DCNL ''
def CheckForFunctionLengths(filename, clean_lines, linenum, function_state, error): DCNL 'Reports for long function bodies. DCNL For an overview why this is done, see: DCNL http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions DCNL Uses a simplistic algorithm assuming other style guidelines DCNL (especially spacing) are followed. DCNL Only checks unindented functions, so class members are unchecked. DCNL Trivial bodies are unchecked, so constructors with huge initializer lists DCNL may be missed. DCNL Blank/comment lines are not counted so as to avoid encouraging the removal DCNL of vertical space and comments just to get through a lint check. DCNL NOLINT *on the last line of a function* disables this check. DCNL Args: DCNL filename: The name of the current file. DCNL clean_lines: A CleansedLines instance containing the file. DCNL linenum: The number of the line to check. DCNL function_state: Current function name and lines in body so far. DCNL error: The function to call with any errors found.'
def display_path(path): DCNL 'Gives the display value for a given path, making it relative to cwd DCNL if possible.'
def run_all(plugin, args=''): DCNL 'Run nagios plugin and return all the data execution with cmd.run_all'
def next_redirect(data, default, default_view, **get_kwargs): DCNL 'Handle the "where should I go next?" part of comment views. DCNL The next value could be a kwarg to the function (``default``), or a DCNL ``?next=...`` GET arg, or the URL of a given view (``default_view``). See DCNL the view modules for examples. DCNL Returns an ``HttpResponseRedirect``.'
def _iexp(x, M, L=8): DCNL 'Given integers x and M, M > 0, such that x/M is small in absolute DCNL value, compute an integer approximation to M*exp(x/M).  For 0 <= DCNL x/M <= 2.4, the absolute error in the result is bounded by 60 (and DCNL is usually much smaller).'
def ContactVCard(parent): DCNL 'A factory for generating contact commands'
def safecall(func): DCNL 'Wraps a function so that it swallows exceptions.'
def quote_unix(value): DCNL 'Return a quoted (shell-escaped) version of the value which can be used as one token in a shell DCNL command line. DCNL :param value: Value to quote. DCNL :type value: ``str`` DCNL :rtype: ``str``'
@LocalContext DCNL def unpack_many(data, word_size=None): DCNL 'unpack(data, word_size = None, endianness = None, sign = None) -> int list DCNL Splits `data` into groups of ``word_size//8`` bytes and calls :func:`unpack` on each group.  Returns a list of the results. DCNL `word_size` must be a multiple of `8` or the string "all".  In the latter case a singleton list will always be returned. DCNL Args DCNL number (int): String to convert DCNL word_size (int): Word size of the converted integers or the string "all". DCNL endianness (str): Endianness of the converted integer ("little"/"big") DCNL sign (str): Signedness of the converted integer (False/True) DCNL kwargs: Anything that can be passed to context.local DCNL Returns: DCNL The unpacked numbers. DCNL Examples: DCNL >>> map(hex, unpack_many(\'\xaa\x55\xcc\x33\', 16, endian=\'little\', sign=False)) DCNL [\'0x55aa\', \'0x33cc\'] DCNL >>> map(hex, unpack_many(\'\xaa\x55\xcc\x33\', 16, endian=\'big\', sign=False)) DCNL [\'0xaa55\', \'0xcc33\'] DCNL >>> map(hex, unpack_many(\'\xaa\x55\xcc\x33\', 16, endian=\'big\', sign=True)) DCNL [\'-0x55ab\', \'-0x33cd\'] DCNL >>> map(hex, unpack_many(\'\xff\x02\x03\', \'all\', endian=\'little\', sign=True)) DCNL [\'0x302ff\'] DCNL >>> map(hex, unpack_many(\'\xff\x02\x03\', \'all\', endian=\'big\', sign=True)) DCNL [\'-0xfdfd\']'
def prox_l21(Y, alpha, n_orient, shape=None, is_stft=False): DCNL 'Proximity operator for l21 norm. DCNL L2 over columns and L1 over rows => groups contain n_orient rows. DCNL It can eventually take into account the negative frequencies DCNL when a complex value is passed and is_stft=True. DCNL Example DCNL >>> Y = np.tile(np.array([0, 4, 3, 0, 0], dtype=np.float), (2, 1)) DCNL >>> Y = np.r_[Y, np.zeros_like(Y)] DCNL >>> print(Y) DCNL [[ 0.  4.  3.  0.  0.] DCNL [ 0.  4.  3.  0.  0.] DCNL [ 0.  0.  0.  0.  0.] DCNL [ 0.  0.  0.  0.  0.]] DCNL >>> Yp, active_set = prox_l21(Y, 2, 2) DCNL >>> print(Yp) DCNL [[ 0.          2.86862915  2.15147186  0.          0.        ] DCNL [ 0.          2.86862915  2.15147186  0.          0.        ]] DCNL >>> print(active_set) DCNL [ True  True False False]'
def interval_distance(label1, label2): DCNL 'Krippendorff\'s interval distance metric DCNL >>> from nltk.metrics import interval_distance DCNL >>> interval_distance(1,10) DCNL 81 DCNL Krippendorff 1980, Content Analysis: An Introduction to its Methodology'
@_FFI.callback(u'Value(ExternContext*, DCSP uint8_t*, DCSP uint64_t)') DCNL def extern_create_exception(context_handle, msg_ptr, msg_len): DCNL 'Given a utf8 message string, create an Exception object.'
def deprecatedProperty(version, replacement=None): DCNL 'Return a decorator that marks a property as deprecated. To deprecate a DCNL regular callable or class, see L{deprecated}. DCNL @type version: L{incremental.Version} DCNL @param version: The version in which the callable will be marked as DCNL having been deprecated.  The decorated function will be annotated DCNL with this version, having it set as its C{deprecatedVersion} DCNL attribute. DCNL @param version: the version that the callable was deprecated in. DCNL @type version: L{incremental.Version} DCNL @param replacement: what should be used in place of the callable. DCNL Either pass in a string, which will be inserted into the warning DCNL message, or a callable, which will be expanded to its full import DCNL path. DCNL @type replacement: C{str} or callable DCNL @return: A new property with deprecated setter and getter. DCNL @rtype: C{property} DCNL @since: 16.1.0'
def get_flow(db_api, image_service_api, availability_zones, create_what, scheduler_rpcapi=None, volume_rpcapi=None): DCNL 'Constructs and returns the api entrypoint flow. DCNL This flow will do the following: DCNL 1. Inject keys & values for dependent tasks. DCNL 2. Extracts and validates the input keys & values. DCNL 3. Reserves the quota (reverts quota on any failures). DCNL 4. Creates the database entry. DCNL 5. Commits the quota. DCNL 6. Casts to volume manager or scheduler for further processing.'
def ensure_completely_loaded(force=False): DCNL 'This method ensures all models are completely loaded DCNL FeinCMS requires Django to be completely initialized before proceeding, DCNL because of the extension mechanism and the dynamically created content DCNL types. DCNL For more informations, have a look at issue #23 on github: DCNL http://github.com/feincms/feincms/issues#issue/23'
def stub_out(test, funcs): DCNL 'Set the stubs in mapping in the db api.'
def _close_conn(conn): DCNL 'Close the postgres connection.'
def deleted(cond): DCNL '>>> deleted(False) DCNL >>> deleted(True) DCNL Traceback (most recent call last): DCNL UnboundLocalError: local variable \'a\' referenced before assignment'
def run(command): DCNL 'Execute a single command and check the returns'
def decode_barcode_8(nt_barcode): DCNL 'Decode length 8 barcode (16 bits)'
def gen_lower_listing(path=None): DCNL 'Generate lowering listing to ``path`` or (if None) to stdout.'
def getmacbyip(ip, chainCC=0): DCNL 'Return MAC address corresponding to a given IP address'
def RekallEProcessRenderer(x): DCNL 'Function used to render Rekall \'_EPROCESS\' objects.'
def requires_auth(f): DCNL 'Custom decorator to restrict non-login access to views DCNL sets g.user to the successfully authenticated user DCNL Allows JWT token based access and Basic auth access DCNL Falls back to active session if both are not present'
def test_get_editor_filter(): DCNL 'Tests editor filters are correctly constructed.'
def build_docs(branch): DCNL 'Changes into gitdname and builds the docs using BUILDENV virtualenv'
def global_subsystem_instance(subsystem_type, options=None): DCNL 'Returns the global instance of a subsystem, for use in tests. DCNL :API: public DCNL :param type subsystem_type: The subclass of :class:`pants.subsystem.subsystem.Subsystem` DCNL to create. DCNL :param options: dict of scope -> (dict of option name -> value). DCNL The scopes may be that of the global instance of the subsystem (i.e., DCNL subsystem_type.options_scope) and/or the scopes of instances of the DCNL subsystems it transitively depends on.'
def _check_surfaces(surfs): DCNL 'Check that the surfaces are complete and non-intersecting.'
def is_pidfile_stale(pidfile): DCNL 'Determine whether a PID file is stale. DCNL Return ``True`` (“stale”) if the contents of the PID file are DCNL valid but do not match the PID of a currently-running process; DCNL otherwise return ``False``.'
def _lookup_syslog_config(config): DCNL 'Helper function that looks up syslog_config keys available from DCNL ``vsphere.get_syslog_config``.'
def trimHistory(): DCNL 'Trims history table to 1 month of history from today'
def create_comment(request, comment_data): DCNL 'Create a comment. DCNL Arguments: DCNL request: The django request object used for build_absolute_uri and DCNL determining the requesting user. DCNL comment_data: The data for the created comment. DCNL Returns: DCNL The created comment; see discussion_api.views.CommentViewSet for more DCNL detail.'
@hook.command('scuser') DCNL def soundcloud_user(text): DCNL '<query> -- Searches for users on SoundCloud.'
def EMSA_PSS_ENCODE(mhash, emBits, randFunc, mgf, sLen): DCNL 'Implement the ``EMSA-PSS-ENCODE`` function, as defined DCNL in PKCS#1 v2.1 (RFC3447, 9.1.1). DCNL The original ``EMSA-PSS-ENCODE`` actually accepts the message ``M`` as input, DCNL and hash it internally. Here, we expect that the message has already DCNL been hashed instead. DCNL :Parameters: DCNL mhash : hash object DCNL The hash object that holds the digest of the message being signed. DCNL emBits : int DCNL Maximum length of the final encoding, in bits. DCNL randFunc : callable DCNL An RNG function that accepts as only parameter an int, and returns DCNL a string of random bytes, to be used as salt. DCNL mgf : callable DCNL A mask generation function that accepts two parameters: a string to DCNL use as seed, and the lenth of the mask to generate, in bytes. DCNL sLen : int DCNL Length of the salt, in bytes. DCNL :Return: An ``emLen`` byte long string that encodes the hash DCNL (with ``emLen = \ceil(emBits/8)``). DCNL :Raise ValueError: DCNL When digest or salt length are too big.'
@verbose DCNL def _apply_dics(data, info, tmin, forward, noise_csd, data_csd, reg, label=None, picks=None, pick_ori=None, verbose=None): DCNL 'Dynamic Imaging of Coherent Sources (DICS). DCNL Calculate the DICS spatial filter based on a given cross-spectral DCNL density object and return estimates of source activity based on given data. DCNL Parameters DCNL data : array or list / iterable DCNL Sensor space data. If data.ndim == 2 a single observation is assumed DCNL and a single stc is returned. If data.ndim == 3 or if data is DCNL a list / iterable, a list of stc\'s is returned. DCNL info : dict DCNL Measurement info. DCNL tmin : float DCNL Time of first sample. DCNL forward : dict DCNL Forward operator. DCNL noise_csd : instance of CrossSpectralDensity DCNL The noise cross-spectral density. DCNL data_csd : instance of CrossSpectralDensity DCNL The data cross-spectral density. DCNL reg : float DCNL The regularization for the cross-spectral density. DCNL label : Label | None DCNL Restricts the solution to a given label. DCNL picks : array-like of int | None DCNL Indices (in info) of data channels. If None, MEG and EEG data channels DCNL (without bad channels) will be used. DCNL pick_ori : None | \'normal\' DCNL If \'normal\', rather than pooling the orientations by taking the norm, DCNL only the radial component is kept. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL stc : SourceEstimate | VolSourceEstimate DCNL Source time courses'
def spearmanr(a, b=None, axis=0, nan_policy='propagate'): DCNL 'Calculates a Spearman rank-order correlation coefficient and the p-value DCNL to test for non-correlation. DCNL The Spearman correlation is a nonparametric measure of the monotonicity DCNL of the relationship between two datasets. Unlike the Pearson correlation, DCNL the Spearman correlation does not assume that both datasets are normally DCNL distributed. Like other correlation coefficients, this one varies DCNL between -1 and +1 with 0 implying no correlation. Correlations of -1 or DCNL +1 imply an exact monotonic relationship. Positive correlations imply that DCNL as x increases, so does y. Negative correlations imply that as x DCNL increases, y decreases. DCNL The p-value roughly indicates the probability of an uncorrelated system DCNL producing datasets that have a Spearman correlation at least as extreme DCNL as the one computed from these datasets. The p-values are not entirely DCNL reliable but are probably reasonable for datasets larger than 500 or so. DCNL Parameters DCNL a, b : 1D or 2D array_like, b is optional DCNL One or two 1-D or 2-D arrays containing multiple variables and DCNL observations. When these are 1-D, each represents a vector of DCNL observations of a single variable. For the behavior in the 2-D case, DCNL see under ``axis``, below. DCNL Both arrays need to have the same length in the ``axis`` dimension. DCNL axis : int or None, optional DCNL If axis=0 (default), then each column represents a variable, with DCNL observations in the rows. If axis=1, the relationship is transposed: DCNL each row represents a variable, while the columns contain observations. DCNL If axis=None, then both arrays will be raveled. DCNL nan_policy : {\'propagate\', \'raise\', \'omit\'}, optional DCNL Defines how to handle when input contains nan. \'propagate\' returns nan, DCNL \'raise\' throws an error, \'omit\' performs the calculations ignoring nan DCNL values. Default is \'propagate\'. DCNL Returns DCNL correlation : float or ndarray (2-D square) DCNL Spearman correlation matrix or correlation coefficient (if only 2 DCNL variables are given as parameters. Correlation matrix is square with DCNL length equal to total number of variables (columns or rows) in a and b DCNL combined. DCNL pvalue : float DCNL The two-sided p-value for a hypothesis test whose null hypothesis is DCNL that two sets of data are uncorrelated, has same dimension as rho. DCNL Notes DCNL Changes in scipy 0.8.0: rewrite to add tie-handling, and axis. DCNL References DCNL .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard DCNL Probability and Statistics Tables and Formulae. Chapman & Hall: New DCNL York. 2000. DCNL Section  14.7 DCNL Examples DCNL >>> from scipy import stats DCNL >>> stats.spearmanr([1,2,3,4,5], [5,6,7,8,7]) DCNL (0.82078268166812329, 0.088587005313543798) DCNL >>> np.random.seed(1234321) DCNL >>> x2n = np.random.randn(100, 2) DCNL >>> y2n = np.random.randn(100, 2) DCNL >>> stats.spearmanr(x2n) DCNL (0.059969996999699973, 0.55338590803773591) DCNL >>> stats.spearmanr(x2n[:,0], x2n[:,1]) DCNL (0.059969996999699973, 0.55338590803773591) DCNL >>> rho, pval = stats.spearmanr(x2n, y2n) DCNL >>> rho DCNL array([[ 1.        ,  0.05997   ,  0.18569457,  0.06258626], DCNL [ 0.05997   ,  1.        ,  0.110003  ,  0.02534653], DCNL [ 0.18569457,  0.110003  ,  1.        ,  0.03488749], DCNL [ 0.06258626,  0.02534653,  0.03488749,  1.        ]]) DCNL >>> pval DCNL array([[ 0.        ,  0.55338591,  0.06435364,  0.53617935], DCNL [ 0.55338591,  0.        ,  0.27592895,  0.80234077], DCNL [ 0.06435364,  0.27592895,  0.        ,  0.73039992], DCNL [ 0.53617935,  0.80234077,  0.73039992,  0.        ]]) DCNL >>> rho, pval = stats.spearmanr(x2n.T, y2n.T, axis=1) DCNL >>> rho DCNL array([[ 1.        ,  0.05997   ,  0.18569457,  0.06258626], DCNL [ 0.05997   ,  1.        ,  0.110003  ,  0.02534653], DCNL [ 0.18569457,  0.110003  ,  1.        ,  0.03488749], DCNL [ 0.06258626,  0.02534653,  0.03488749,  1.        ]]) DCNL >>> stats.spearmanr(x2n, y2n, axis=None) DCNL (0.10816770419260482, 0.1273562188027364) DCNL >>> stats.spearmanr(x2n.ravel(), y2n.ravel()) DCNL (0.10816770419260482, 0.1273562188027364) DCNL >>> xint = np.random.randint(10, size=(100, 2)) DCNL >>> stats.spearmanr(xint) DCNL (0.052760927029710199, 0.60213045837062351)'
def get_default_gcs_bucket_name(deadline=None): DCNL 'Gets the default gs bucket name for the app. DCNL Args: DCNL deadline: Optional deadline in seconds for the operation; the default DCNL is a system-specific deadline (typically 5 seconds). DCNL Returns: DCNL Default bucket name for the app.'
def notify_info_yielded(event): DCNL 'Makes a generator send the event \'event\' every time it yields. DCNL This decorator is supposed to decorate a generator, but any function DCNL returning an iterable should work. DCNL Each yielded value is passed to plugins using the \'info\' parameter of DCNL \'send\'.'
def LoadSingleAppInfo(app_info): DCNL 'Load a single AppInfo object where one and only one is expected. DCNL Validates that the the values in the AppInfo match the validators defined DCNL in this file. (in particular, in AppInfoExternal.ATTRIBUTES) DCNL Args: DCNL app_info: A file-like object or string.  If it is a string, parse it as DCNL a configuration file.  If it is a file-like object, read in data and DCNL parse. DCNL Returns: DCNL An instance of AppInfoExternal as loaded from a YAML file. DCNL Raises: DCNL ValueError: if a specified service is not valid. DCNL EmptyConfigurationFile: when there are no documents in YAML file. DCNL MultipleConfigurationFile: when there is more than one document in YAML DCNL file. DCNL DuplicateBackend: if backend is found more than once in \'backends\'. DCNL yaml_errors.EventError: if the app.yaml fails validation. DCNL appinfo_errors.MultipleProjectNames: if the app.yaml has both \'application\' DCNL and \'project\'.'
def IDAnalyzer(lowercase=False): DCNL 'Deprecated, just use an IDTokenizer directly, with a LowercaseFilter if DCNL desired.'
def _CopyDocumentToProtocolBuffer(document, pb): DCNL 'Copies Document to a document_pb.Document protocol buffer.'
def buttap(N): DCNL 'Return (z,p,k) for analog prototype of Nth-order Butterworth filter. DCNL The filter will have an angular (e.g. rad/s) cutoff frequency of 1. DCNL See Also DCNL butter : Filter design function using this prototype'
def _get_limit_param(request): DCNL 'Extract integer limit from request or fail'
def _validate_snap_name(name, snap_name, strict=True, runas=None): DCNL 'Validate snapshot name and convert to snapshot ID DCNL :param str name: DCNL Name/ID of VM whose snapshot name is being validated DCNL :param str snap_name: DCNL Name/ID of snapshot DCNL :param bool strict: DCNL Raise an exception if multiple snapshot IDs are found DCNL :param str runas: DCNL The user that the prlctl command will be run as'
def read_font_record(data, extent=1040): DCNL 'Return the font encoded in the MOBI FONT record represented by data. DCNL The return value in a dict with fields raw_data, font_data, err, ext, DCNL headers. DCNL :param extent: The number of obfuscated bytes. So far I have only DCNL encountered files with 1040 obfuscated bytes. If you encounter an DCNL obfuscated record for which this function fails, try different extent DCNL values (easily automated). DCNL raw_data is the raw data in the font record DCNL font_data is the decoded font_data or None if an error occurred DCNL err is not None if some error occurred DCNL ext is the font type (ttf for TrueType, dat for unknown and failed if an DCNL error occurred) DCNL headers is the list of decoded headers from the font record or None if DCNL decoding failed'
def create_version_h(svn_version): DCNL 'Create lxml-version.h'
@authenticated_json_view DCNL @has_request_variables DCNL def json_subscription_property(request, user_profile, subscription_data=REQ(validator=check_list(check_dict([('stream', check_string), ('property', check_string), ('value', check_variable_type([check_string, check_bool]))])))): DCNL 'This is the entry point to changing subscription properties. This DCNL is a bulk endpoint: requestors always provide a subscription_data DCNL list containing dictionaries for each stream of interest. DCNL Requests are of the form: DCNL [{"stream": "devel", "property": "in_home_view", "value": False}, DCNL {"stream": "devel", "property": "color", "value": "#c2c2c2"}]'
def process_options(arglist=None, parse_argv=False, config_file=None, parser=None): DCNL 'Process options passed either via arglist or via command line args.'
def project_time_week(row): DCNL 'Virtual field for project_time - returns the date of the Monday DCNL (=first day of the week) of this entry, used for project time report. DCNL Requires "date" to be in the additional report_fields DCNL @param row: the Row'
def start_time(pid): DCNL 'Provides the unix timestamp when the given process started. DCNL :param int pid: process id of the process to be queried DCNL :returns: **float** for the unix timestamp when the process began, **None** DCNL if it can\'t be determined'
def init(mpstate): DCNL 'initialise module'
def get_avg_dists(state1_samids, state2_samids, distdict): DCNL 'foreach sample in stat1_sams, return average dist to all state2_sams DCNL doesn\'t include distance to self in average, but usually state2 doesn\'t DCNL overlap with state1, so it dist to self doesn\'t apply DCNL returns a list of length = len(state1_samids)'
@handle_response_format DCNL @treeio_login_required DCNL def project_edit(request, project_id, response_format='html'): DCNL 'Project edit page'
def _get_search_rank(collection_id): DCNL 'Gets the search rank of a given collection. DCNL Args: DCNL collection_id: str. ID of the collection whose rank is to be retrieved. DCNL Returns: DCNL int. An integer determining the document\'s rank in search. DCNL Featured collections get a ranking bump, and so do collections that DCNL have been more recently updated.'
def register(): DCNL 'Plugin registration.'
def abspath(path): DCNL 'Return an absolute path.'
def foldersAtPath(path, includeParent=False): DCNL 'Returns a list of dictionaries with the folders contained at the given path DCNL Give the empty string as the path to list the contents of the root path DCNL under Unix this means "/", on Windows this will be a list of drive letters)'
def in6_get6to4Prefix(addr): DCNL 'Returns the /48 6to4 prefix associated with provided IPv4 address DCNL On error, None is returned. No check is performed on public/private DCNL status of the address'
def _aggr_mean(inList): DCNL 'Returns mean of non-None elements of the list'
def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False): DCNL 'Recursively copy a directory tree. DCNL The destination directory must not already exist. DCNL If exception(s) occur, an Error is raised with a list of reasons. DCNL If the optional symlinks flag is true, symbolic links in the DCNL source tree result in symbolic links in the destination tree; if DCNL it is false, the contents of the files pointed to by symbolic DCNL links are copied. If the file pointed by the symlink doesn\'t DCNL exist, an exception will be added in the list of errors raised in DCNL an Error exception at the end of the copy process. DCNL You can set the optional ignore_dangling_symlinks flag to true if you DCNL want to silence this exception. Notice that this has no effect on DCNL platforms that don\'t support os.symlink. DCNL The optional ignore argument is a callable. If given, it DCNL is called with the `src` parameter, which is the directory DCNL being visited by copytree(), and `names` which is the list of DCNL `src` contents, as returned by os.listdir(): DCNL callable(src, names) -> ignored_names DCNL Since copytree() is called recursively, the callable will be DCNL called once for each directory that is copied. It returns a DCNL list of names relative to the `src` directory that should DCNL not be copied. DCNL The optional copy_function argument is a callable that will be used DCNL to copy each file. It will be called with the source path and the DCNL destination path as arguments. By default, copy2() is used, but any DCNL function that supports the same signature (like copy()) can be used.'
def test_zeros(): DCNL 'Test reconstruction with image and mask of zeros'
def append_slash_redirect(environ, code=301): DCNL 'Redirect to the same URL but with a slash appended.  The behavior DCNL of this function is undefined if the path ends with a slash already. DCNL :param environ: the WSGI environment for the request that triggers DCNL the redirect. DCNL :param code: the status code for the redirect.'
def javascript_catalog(request, domain='djangojs', packages=None): DCNL 'Returns the selected language catalog as a javascript library. DCNL Receives the list of packages to check for translations in the DCNL packages parameter either from an infodict or as a +-delimited DCNL string from the request. Default is \'django.conf\'. DCNL Additionally you can override the gettext domain for this view, DCNL but usually you don\'t want to do that, as JavaScript messages DCNL go to the djangojs domain. But this might be needed if you DCNL deliver your JavaScript source from Django templates.'
def serialize(node, stream=None, Dumper=Dumper, **kwds): DCNL 'Serialize a representation tree into a YAML stream. DCNL If stream is None, return the produced string instead.'
def group_list_of_dict(array): DCNL 'Helper method to group list of dict to dict with all possible values'
def log(s): DCNL 'Print a log message to stderr.'
def bind_expression_to_resources(expr, resources): DCNL 'Bind a Blaze expression to resources. DCNL Parameters DCNL expr : bz.Expr DCNL The expression to which we want to bind resources. DCNL resources : dict[bz.Symbol -> any] DCNL Mapping from the loadable terms of ``expr`` to actual data resources. DCNL Returns DCNL bound_expr : bz.Expr DCNL ``expr`` with bound resources.'
@release.command() DCNL def changelog(): DCNL 'Get the most recent version\'s changelog as Markdown.'
def test_sobel_h_horizontal(): DCNL 'Horizontal Sobel on an edge should be a horizontal line.'
def _other_endian(typ): DCNL 'Return the type with the \'other\' byte order.  Simple types like DCNL c_int and so on already have __ctype_be__ and __ctype_le__ DCNL attributes which contain the types, for more complicated types DCNL only arrays are supported.'
def farray(ptr, shape, dtype=None): DCNL 'Return a Numpy array view over the data pointed to by *ptr* with the DCNL given *shape*, in Fortran order.  If *dtype* is given, it is used as the DCNL array\'s dtype, otherwise the array\'s dtype is inferred from *ptr*\'s type.'
@protocol.commands.add(u'listmounts') DCNL def listmounts(context): DCNL '*musicpd.org, mounts and neighbors section:* DCNL ``listmounts`` DCNL Queries a list of all mounts. By default, this contains just the DCNL configured music_directory. Example:: DCNL listmounts DCNL mount: DCNL storage: /home/foo/music DCNL mount: foo DCNL storage: nfs://192.168.1.4/export/mp3 DCNL OK DCNL .. versionadded:: 0.19 DCNL New in MPD protocol version 0.19'
def cscore(v1, v2): DCNL 'Calculate C-score between v1 and v2 according to Stone and Roberts 1990. DCNL Parameters DCNL v1 : array-like DCNL List or array of numeric values to be tested. DCNL v2 : array-like DCNL List or array of numeric values to be tested. DCNL Returns DCNL cscore : float DCNL C-score between v1 and v2 DCNL Notes DCNL This function calculates the C-score between equal length vectors v1 and v2 DCNL according to the formulation given in [1]_. DCNL References DCNL .. [1] Stone and Roberts. 1990, Oecologia 85:74-79'
@verbose DCNL def source_induced_power(epochs, inverse_operator, frequencies, label=None, lambda2=(1.0 / 9.0), method='dSPM', nave=1, n_cycles=5, decim=1, use_fft=False, pick_ori=None, baseline=None, baseline_mode='logratio', pca=True, n_jobs=1, zero_mean=False, prepared=False, verbose=None): DCNL 'Compute induced power and phase lock. DCNL Computation can optionaly be restricted in a label. DCNL Parameters DCNL epochs : instance of Epochs DCNL The epochs. DCNL inverse_operator : instance of InverseOperator DCNL The inverse operator. DCNL frequencies : array DCNL Array of frequencies of interest. DCNL label : Label DCNL Restricts the source estimates to a given label. DCNL lambda2 : float DCNL The regularization parameter of the minimum norm. DCNL method : "MNE" | "dSPM" | "sLORETA" DCNL Use mininum norm, dSPM or sLORETA. DCNL nave : int DCNL The number of averages used to scale the noise covariance matrix. DCNL n_cycles : float | array of float DCNL Number of cycles. Fixed number or one per frequency. DCNL decim : int DCNL Temporal decimation factor. DCNL use_fft : bool DCNL Do convolutions in time or frequency domain with FFT. DCNL pick_ori : None | "normal" DCNL If "normal", rather than pooling the orientations by taking the norm, DCNL only the radial component is kept. This is only implemented DCNL when working with loose orientations. DCNL baseline : None (default) or tuple of length 2 DCNL The time interval to apply baseline correction. DCNL If None do not apply it. If baseline is (a, b) DCNL the interval is between "a (s)" and "b (s)". DCNL If a is None the beginning of the data is used DCNL and if b is None then b is set to the end of the interval. DCNL If baseline is equal ot (None, None) all the time DCNL interval is used. DCNL baseline_mode : None | \'logratio\' | \'zscore\' DCNL Do baseline correction with ratio (power is divided by mean DCNL power during baseline) or zscore (power is divided by standard DCNL deviation of power during baseline after subtracting the mean, DCNL power = [power - mean(power_baseline)] / std(power_baseline)). DCNL pca : bool DCNL If True, the true dimension of data is estimated before running DCNL the time-frequency transforms. It reduces the computation times DCNL e.g. with a dataset that was maxfiltered (true dim is 64). DCNL n_jobs : int DCNL Number of jobs to run in parallel. DCNL zero_mean : bool DCNL Make sure the wavelets are zero mean. DCNL prepared : bool DCNL If True, do not call `prepare_inverse_operator`. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more).'
def read_metadata_kfx(stream, read_cover=True): DCNL 'Read the metadata.kfx file that is found in the sdr book folder for KFX files'
def compute_grad(J, f): DCNL 'Compute gradient of the least-squares cost function.'
def secgroup_info(call=None, kwargs=None): DCNL 'Retrieves information for the given security group. Either a name or a DCNL secgroup_id must be supplied. DCNL .. versionadded:: 2016.3.0 DCNL name DCNL The name of the security group for which to gather information. Can be DCNL used instead of ``secgroup_id``. DCNL secgroup_id DCNL The ID of the security group for which to gather information. Can be DCNL used instead of ``name``. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-cloud -f secgroup_info opennebula name=my-secgroup DCNL salt-cloud --function secgroup_info opennebula secgroup_id=5'
def _make_complex_eigvecs(w, vin, dtype): DCNL 'Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output'
@conf.commands.register DCNL def corrupt_bits(s, p=0.01, n=None): DCNL 'Flip a given percentage or number of bits from a string'
def require_module(module): DCNL 'Check if the given module is loaded. Skip the test if not.'
def bayesian_info_criterion_lsq(ssr, n_params, n_samples): DCNL 'Computes the Bayesian Information Criterion (BIC) assuming that the DCNL observations come from a Gaussian distribution. DCNL In this case, BIC is given as DCNL .. math:: DCNL \mathrm{BIC} = n\ln\left(\dfrac{\mathrm{SSR}}{n}\right) + k\ln(n) DCNL in which :math:`n` is the sample size, :math:`k` is the number of free DCNL parameters and :math:`\mathrm{SSR}` stands for the sum of squared residuals DCNL between model and data. DCNL This is applicable, for instance, when the parameters of a model are DCNL estimated using the least squares statistic. See [1]_ and [2]_. DCNL Parameters DCNL ssr : float DCNL Sum of squared residuals (SSR) between model and data. DCNL n_params : int DCNL Number of free parameters of the model, i.e., dimension of the DCNL parameter space. DCNL n_samples : int DCNL Number of observations. DCNL Returns DCNL bic : float DCNL Examples DCNL Consider the simple 1-D fitting example presented in the Astropy DCNL modeling webpage [3]_. There, two models (Box and Gaussian) were fitted to DCNL a source flux using the least squares statistic. However, the fittings DCNL themselves do not tell much about which model better represents this DCNL hypothetical source. Therefore, we are going to apply to BIC in order to DCNL decide in favor of a model. DCNL >>> import numpy as np DCNL >>> from astropy.modeling import models, fitting DCNL >>> from astropy.stats.info_theory import bayesian_info_criterion_lsq DCNL >>> # Generate fake data DCNL >>> np.random.seed(0) DCNL >>> x = np.linspace(-5., 5., 200) DCNL >>> y = 3 * np.exp(-0.5 * (x - 1.3)**2 / 0.8**2) DCNL >>> y += np.random.normal(0., 0.2, x.shape) DCNL >>> # Fit the data using a Box model DCNL >>> t_init = models.Trapezoid1D(amplitude=1., x_0=0., width=1., slope=0.5) DCNL >>> fit_t = fitting.LevMarLSQFitter() DCNL >>> t = fit_t(t_init, x, y) DCNL >>> # Fit the data using a Gaussian DCNL >>> g_init = models.Gaussian1D(amplitude=1., mean=0, stddev=1.) DCNL >>> fit_g = fitting.LevMarLSQFitter() DCNL >>> g = fit_g(g_init, x, y) DCNL >>> # Compute the mean squared errors DCNL >>> ssr_t = np.sum((t(x) - y)*(t(x) - y)) DCNL >>> ssr_g = np.sum((g(x) - y)*(g(x) - y)) DCNL >>> # Compute the bics DCNL >>> bic_t = bayesian_info_criterion_lsq(ssr_t, 4, x.shape[0]) DCNL >>> bic_g = bayesian_info_criterion_lsq(ssr_g, 3, x.shape[0]) DCNL >>> bic_t - bic_g # doctest: +FLOAT_CMP DCNL 30.644474706065466 DCNL Hence, there is a very strong evidence that the Gaussian model has a DCNL significantly better representation of the data than the Box model. This DCNL is, obviously, expected since the true model is Gaussian. DCNL References DCNL .. [1] Wikipedia. Bayesian Information Criterion. DCNL <https://en.wikipedia.org/wiki/Bayesian_information_criterion> DCNL .. [2] Origin Lab. Comparing Two Fitting Functions. DCNL <http://www.originlab.com/doc/Origin-Help/PostFit-CompareFitFunc> DCNL .. [3] Astropy Models and Fitting DCNL <http://docs.astropy.org/en/stable/modeling>'
def sort_dependencies(app_list): DCNL 'Sort a list of app,modellist pairs into a single list of models. DCNL The single list of models is sorted so that any model with a natural key DCNL is serialized before a normal model, and any model with a natural key DCNL dependency has it\'s dependencies serialized first.'
def _sig_key(key, date_stamp, regionName, serviceName): DCNL 'Get a signature key. See: DCNL http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-python'
def mask_secret_parameters(parameters, secret_parameters): DCNL 'Introspect the parameters dict and return a new dict with masked secret DCNL parameters. DCNL :param parameters: Parameters to process. DCNL :type parameters: ``dict`` DCNL :param secret_parameters: List of parameter names which are secret. DCNL :type secret_parameters: ``list``'
@mock_ec2 DCNL def test_eip_release_bogus_eip(): DCNL 'Release bogus EIP'
def validate_int_or_basestring(option, value): DCNL 'Validates that \'value\' is an integer or string.'
def with_inline_css(html_without_css): DCNL 'Returns html with inline css if the css file path exists DCNL else returns html with out the inline css.'
def track_distance(item, info): DCNL 'Gets the track distance calculated by all loaded plugins. DCNL Returns a Distance object.'
def user(pid): DCNL 'Provides the user a process is running under. DCNL :param int pid: process id of the process to be queried DCNL :returns: **str** with the username a process is running under, **None** if DCNL it can\'t be determined'
@testing.requires_testing_data DCNL @requires_fs_or_nibabel DCNL def test_vertex_to_mni(): DCNL 'Test conversion of vertices to MNI coordinates'
def get_database_password(name): DCNL 'Return the configured database password.'
def retrieve_token(userid, secret): DCNL 'Return a token for the backend of annotations. DCNL It uses the course id to retrieve a variable that contains the secret DCNL token found in inheritance.py. It also contains information of when DCNL the token was issued. This will be stored with the user along with DCNL the id for identification purposes in the backend.'
@testing.requires_testing_data DCNL def test_preload_modify(): DCNL 'Test preloading and modifying data.'
def sample_content(name): DCNL 'Read content into a string from a file.'
def parse229(resp, peer): DCNL 'Parse the \'229\' response for an EPSV request. DCNL Raises error_proto if it does not contain \'(|||port|)\' DCNL Return (\'host.addr.as.numbers\', port#) tuple.'
def set_(key, value, profile=None, ttl=None, directory=False): DCNL '.. versionadded:: 2014.7.0 DCNL Set a key in etcd by direct path. Optionally, create a directory DCNL or set a TTL on the key.  Returns None on failure. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion etcd.set /path/to/key value DCNL salt myminion etcd.set /path/to/key value profile=my_etcd_config DCNL salt myminion etcd.set /path/to/dir \'\' directory=True DCNL salt myminion etcd.set /path/to/key value ttl=5'
@login_required DCNL def comment(request, pk): DCNL 'Adds new comment.'
def getFloatListListsByPaths(paths): DCNL 'Get float lists by paths.'
def write_trace(expt_dir, best_val, best_job, n_candidates, n_pending, n_complete): DCNL 'Append current experiment state to trace file.'
def tag_item(item, search_artist=None, search_title=None, search_id=None): DCNL 'Attempts to find metadata for a single track. Returns a DCNL `(candidates, recommendation)` pair where `candidates` is a list of DCNL TrackMatch objects. `search_artist` and `search_title` may be used DCNL to override the current metadata for the purposes of the MusicBrainz DCNL title; likewise `search_id`.'
@click.command(cls=ComplexCLI, context_settings=CONTEXT_SETTINGS) DCNL @click.option('--home', type=click.Path(exists=True, file_okay=False, resolve_path=True), help='Changes DCSP the DCSP folder DCSP to DCSP operate DCSP on.') DCNL @click.option('-v', '--verbose', is_flag=True, help='Enables DCSP verbose DCSP mode.') DCNL @pass_context DCNL def cli(ctx, verbose, home): DCNL 'A complex command line interface.'
def main(): DCNL 'Display the carve dialog.'
def get_engine(): DCNL 'Return a SQLAlchemy engine.'
def dictreverse(mapping): DCNL 'Returns a new dictionary with keys and values swapped. DCNL >>> dictreverse({1: 2, 3: 4}) DCNL {2: 1, 4: 3}'
def squared_loss(y_true, y_pred): DCNL 'Compute the squared loss for regression. DCNL Parameters DCNL y_true : array-like or label indicator matrix DCNL Ground truth (correct) values. DCNL y_pred : array-like or label indicator matrix DCNL Predicted values, as returned by a regression estimator. DCNL Returns DCNL loss : float DCNL The degree to which the samples are correctly predicted.'
def GroupDecoder(field_number, is_repeated, is_packed, key, new_default): DCNL 'Returns a decoder for a group field.'
def _get_pnics(host_reference): DCNL 'Helper function that returns a list of PhysicalNics and their information.'
def getFundamentalsPath(subName=''): DCNL 'Get the evaluate_fundamentals directory path.'
def loads(data, use_datetime=0): DCNL 'data -> unmarshalled data, method name DCNL Convert an XML-RPC packet to unmarshalled data plus a method DCNL name (None if not present). DCNL If the XML-RPC packet represents a fault condition, this function DCNL raises a Fault exception.'
def code_name(code, number=0): DCNL 'Compute a (probably) unique name for code for caching. DCNL This now expects code to be unicode.'
def iriToURI(iri): DCNL 'Transform an IRI to a URI by escaping unicode.'
def pack_bitstring(bits): DCNL 'Creates a string out of an array of bits DCNL :param bits: A bit array DCNL example:: DCNL bits   = [False, True, False, True] DCNL result = pack_bitstring(bits)'
def safe_walk(top, topdown=True, onerror=None, followlinks=True, _seen=None): DCNL 'A clone of the python os.walk function with some checks for recursive DCNL symlinks. Unlike os.walk this follows symlinks by default.'
def get_introspection_module(namespace): DCNL 'Returns the non proxied module for a namespace'
def generate_fused_type(codes): DCNL 'Generate name of and cython code for a fused type. DCNL Parameters DCNL typecodes : str DCNL Valid inputs to CY_TYPES (i.e. f, d, g, ...).'
@timefunc(1) DCNL def conesearch_timer(*args, **kwargs): DCNL 'Time a single Cone Search using `astropy.utils.timer.timefunc` DCNL with a single try and a verbose timer. DCNL Parameters DCNL args, kwargs : see :func:`conesearch` DCNL Returns DCNL t : float DCNL Run time in seconds. DCNL obj : `astropy.io.votable.tree.Table` DCNL First table from first successful VO service request.'
def to_unicode_optional_iterator(x): DCNL 'Raise TypeError if x is a str containing non-utf8 bytes or if x is DCNL an iterable which contains such a str.'
def test_setitem(hist): DCNL 'Test __setitem__.'
def run_bg(cmd, cwd=None, runas=None, shell=DEFAULT_SHELL, python_shell=None, env=None, clean_env=False, template=None, umask=None, timeout=None, output_loglevel='debug', log_callback=None, reset_system_locale=True, ignore_retcode=False, saltenv='base', password=None, **kwargs): DCNL '.. versionadded: 2016.3.0 DCNL Execute the passed command in the background and return it\'s PID DCNL Note that ``env`` represents the environment variables for the command, and DCNL should be formatted as a dict, or a YAML string which resolves to a dict. DCNL :param str cmd: The command to run. ex: \'ls -lart /home\' DCNL :param str cwd: The current working directory to execute the command in. DCNL Defaults to the home directory of the user specified by ``runas``. DCNL :param str output_loglevel: Control the loglevel at which the output from DCNL the command is logged. Note that the command being run will still be logged DCNL (loglevel: DEBUG) regardless, unless ``quiet`` is used for this value. DCNL :param str runas: User to run script as. If running on a Windows minion you DCNL must also pass a password DCNL :param str password: Windows only. Required when specifying ``runas``. This DCNL parameter will be ignored on non-Windows platforms. DCNL .. versionadded:: 2016.3.0 DCNL :param str shell: Shell to execute under. Defaults to the system default DCNL shell. DCNL :param bool python_shell: If False, let python handle the positional DCNL arguments. Set to True to use shell features, such as pipes or redirection DCNL :param list env: A list of environment variables to be set prior to DCNL execution. DCNL Example: DCNL .. code-block:: yaml DCNL salt://scripts/foo.sh: DCNL cmd.script: DCNL - env: DCNL - BATCH: \'yes\' DCNL .. warning:: DCNL The above illustrates a common PyYAML pitfall, that **yes**, DCNL **no**, **on**, **off**, **true**, and **false** are all loaded as DCNL boolean ``True`` and ``False`` values, and must be enclosed in DCNL quotes to be used as strings. More info on this (and other) PyYAML DCNL idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`. DCNL Variables as values are not evaluated. So $PATH in the following DCNL example is a literal \'$PATH\': DCNL .. code-block:: yaml DCNL salt://scripts/bar.sh: DCNL cmd.script: DCNL - env: "PATH=/some/path:$PATH" DCNL One can still use the existing $PATH by using a bit of Jinja: DCNL .. code-block:: yaml DCNL {% set current_path = salt[\'environ.get\'](\'PATH\', \'/bin:/usr/bin\') %} DCNL mycommand: DCNL cmd.run: DCNL - name: ls -l / DCNL - env: DCNL - PATH: {{ [current_path, \'/my/special/bin\']|join(\':\') }} DCNL :param bool clean_env: Attempt to clean out all other shell environment DCNL variables and set only those provided in the \'env\' argument to this DCNL function. DCNL :param str template: If this setting is applied then the named templating DCNL engine will be used to render the downloaded file. Currently jinja, mako, DCNL and wempy are supported DCNL :param str umask: The umask (in octal) to use when running the command. DCNL :param int timeout: A timeout in seconds for the executed process to return. DCNL .. warning:: DCNL This function does not process commands through a shell DCNL unless the python_shell flag is set to True. This means that any DCNL shell-specific functionality such as \'echo\' or the use of pipes, DCNL redirection or &&, should either be migrated to cmd.shell or DCNL have the python_shell=True flag set here. DCNL The use of python_shell=True means that the shell will accept _any_ input DCNL including potentially malicious commands such as \'good_command;rm -rf /\'. DCNL Be absolutely certain that you have sanitized your input prior to using DCNL python_shell=True DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run_bg "fstrim-all" DCNL The template arg can be set to \'jinja\' or another supported template DCNL engine to render the command arguments before execution. DCNL For example: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run_bg template=jinja "ls -l /tmp/{{grains.id}} | awk \'/foo/{print \\$2}\'" DCNL Specify an alternate shell with the shell parameter: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run_bg "Get-ChildItem C:\\ " shell=\'powershell\' DCNL If an equal sign (``=``) appears in an argument to a Salt command it is DCNL interpreted as a keyword argument in the format ``key=val``. That DCNL processing can be bypassed in order to pass an equal sign through to the DCNL remote shell command by manually specifying the kwarg: DCNL .. code-block:: bash DCNL salt \'*\' cmd.run_bg cmd=\'ls -lR / | sed -e s/=/:/g > /tmp/dontwait\''
def mock_action(action_name): DCNL 'Decorator to easily mock a CKAN action in the context of a test function DCNL It adds a mock object for the provided action as a parameter to the test DCNL function. The mock is discarded at the end of the function, even if there DCNL is an exception raised. DCNL Note that this mocks the action both when it\'s called directly via DCNL ``ckan.logic.get_action`` and via ``ckan.plugins.toolkit.get_action``. DCNL Usage:: DCNL @mock_action(\'user_list\') DCNL def test_mock_user_list(self, mock_user_list): DCNL mock_user_list.return_value = \'hi\' DCNL # user_list is mocked DCNL eq_(helpers.call_action(\'user_list\', {}), \'hi\') DCNL assert mock_user_list.called DCNL :param action_name: the name of the action to be mocked, DCNL e.g. ``package_create`` DCNL :type action_name: string'
def schema_create(dbname, name, owner=None, user=None, db_user=None, db_password=None, db_host=None, db_port=None): DCNL 'Creates a Postgres schema. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' postgres.schema_create dbname name owner=\'owner\' \ DCNL user=\'user\' \ DCNL db_user=\'user\' db_password=\'password\' DCNL db_host=\'hostname\' db_port=\'port\''
def is_valid_connection_id(entry): DCNL 'Checks if a string is a valid format for being a connection identifier. DCNL Currently, this is just an alias to :func:`~stem.util.tor_tools.is_valid_circuit_id`. DCNL :returns: **True** if the string could be a connection id, **False** otherwise'
def generate_random_str(N): DCNL ''
def join_list(delimeter): DCNL 'Join a list into a string using the delimeter. DCNL This is just a wrapper for string.join. DCNL Args: DCNL delimeter: The delimiter to use when joining the string. DCNL Returns: DCNL Method which joins the list into a string with the delimeter.'
def get_elliptic_curves(): DCNL 'Return a set of objects representing the elliptic curves supported in the DCNL OpenSSL build in use. DCNL The curve objects have a :py:class:`unicode` ``name`` attribute by which DCNL they identify themselves. DCNL The curve objects are useful as values for the argument accepted by DCNL :py:meth:`Context.set_tmp_ecdh` to specify which elliptical curve should be DCNL used for ECDHE key exchange.'
def upload_fileobj(self, Fileobj, Bucket, Key, ExtraArgs=None, Callback=None, Config=None): DCNL 'Upload a file-like object to S3. DCNL The file-like object must be in binary mode. DCNL This is a managed transfer which will perform a multipart upload in DCNL multiple threads if necessary. DCNL Usage:: DCNL import boto3 DCNL s3 = boto3.client(\'s3\') DCNL with open(\'filename\', \'rb\') as data: DCNL s3.upload_fileobj(data, \'mybucket\', \'mykey\') DCNL :type Fileobj: a file-like object DCNL :param Fileobj: A file-like object to upload. At a minimum, it must DCNL implement the `read` method, and must return bytes. DCNL :type Bucket: str DCNL :param Bucket: The name of the bucket to upload to. DCNL :type Key: str DCNL :param Key: The name of the key to upload to. DCNL :type ExtraArgs: dict DCNL :param ExtraArgs: Extra arguments that may be passed to the DCNL client operation. DCNL :type Callback: method DCNL :param Callback: A method which takes a number of bytes transferred to DCNL be periodically called during the upload. DCNL :type Config: boto3.s3.transfer.TransferConfig DCNL :param Config: The transfer configuration to be used when performing the DCNL upload.'
def reset(): DCNL 'Reset the CUDA subsystem for the current thread. DCNL In the main thread: DCNL This removes all CUDA contexts.  Only use this at shutdown or for DCNL cleaning up between tests. DCNL In non-main threads: DCNL This clear the CUDA context stack only.'
def escape4xml(value): DCNL 'Escape some chars that can\'t be present in a XML value.'
def make_cgi_application(global_conf, script, path=None, include_os_environ=None, query_string=None): DCNL 'Paste Deploy interface for :class:`CGIApplication` DCNL This object acts as a proxy to a CGI application.  You pass in the DCNL script path (``script``), an optional path to search for the DCNL script (if the name isn\'t absolute) (``path``).  If you don\'t give DCNL a path, then ``$PATH`` will be used.'
def owner(*paths): DCNL 'Return the name of the package that owns the file. Multiple file paths can DCNL be passed. If a single path is passed, a string will be returned, DCNL and if multiple paths are passed, a dictionary of file/package name DCNL pairs will be returned. DCNL If the file is not owned by a package, or is not present on the minion, DCNL then an empty string will be returned for that path. DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt \'*\' pkg.owner /usr/bin/apachectl DCNL salt \'*\' pkg.owner /usr/bin/apachectl /etc/httpd/conf/httpd.conf'
def locks(registry, xml_parent, data): DCNL 'yaml: locks DCNL Control parallel execution of jobs. DCNL Requires the Jenkins :jenkins-wiki:`Locks and Latches Plugin DCNL <Locks+and+Latches+plugin>`. DCNL :arg: list of locks to use DCNL Example: DCNL .. literalinclude::  /../../tests/wrappers/fixtures/locks002.yaml DCNL :language: yaml'
def entity_to_unicode(match, exceptions=[], encoding='cp1252', result_exceptions={}): DCNL ':param match: A match object such that \'&\'+match.group(1)\';\' is the entity. DCNL :param exceptions: A list of entities to not convert (Each entry is the name of the entity, for e.g. \'apos\' or \'#1234\' DCNL :param encoding: The encoding to use to decode numeric entities between 128 and 256. DCNL If None, the Unicode UCS encoding is used. A common encoding is cp1252. DCNL :param result_exceptions: A mapping of characters to entities. If the result DCNL is in result_exceptions, result_exception[result] is returned instead. DCNL Convenient way to specify exception for things like < or > that can be DCNL specified by various actual entities.'
@debug DCNL @timeit DCNL @cacheit DCNL def limitinf(e, x): DCNL 'Limit e(x) for x-> oo'
def connected(perspective): DCNL 'Login callback which invokes the remote "foo" method on the perspective DCNL which the server returned.'
def date_range(start_date, end_date=None, num=None, delta=None): DCNL 'Get a set of dates as a list based on a start, end and delta, delta DCNL can be something that can be added to ``datetime.datetime`` DCNL or a cron expression as a ``str`` DCNL :param start_date: anchor date to start the series from DCNL :type start_date: datetime.datetime DCNL :param end_date: right boundary for the date range DCNL :type end_date: datetime.datetime DCNL :param num: alternatively to end_date, you can specify the number of DCNL number of entries you want in the range. This number can be negative, DCNL output will always be sorted regardless DCNL :type num: int DCNL >>> date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta=timedelta(1)) DCNL [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0), datetime.datetime(2016, 1, 3, 0, 0)] DCNL >>> date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta=\'0 0 * * *\') DCNL [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0), datetime.datetime(2016, 1, 3, 0, 0)] DCNL >>> date_range(datetime(2016, 1, 1), datetime(2016, 3, 3), delta="0 0 0 * *") DCNL [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 2, 1, 0, 0), datetime.datetime(2016, 3, 1, 0, 0)]'
def set_default_etree(etree): DCNL 'Sets the default interface that will called apon to both de/serialise XML DCNL entities. This means providing both C{tostring} and C{fromstring} functions. DCNL For testing purposes, will return the previous value for this (if any).'
def create_pull_queue_tables(cluster, session): DCNL 'Create the required tables for pull queues. DCNL Args: DCNL cluster: A cassandra-driver cluster. DCNL session: A cassandra-driver session.'
def find_it(): DCNL 'Find occurrences.'
def inroot_notwritable(prefix): DCNL 'return True if the prefix is under root and root is not writeable'
def find_tables(clause, check_columns=False, include_aliases=False, include_joins=False, include_selects=False, include_crud=False): DCNL 'locate Table objects within the given expression.'
def p_additive_expression_1(t): DCNL 'additive_expression : multiplicative_expression'
def _skip_bytes(f, n): DCNL 'Skip `n` bytes'
def locate(path, forceload=0): DCNL 'Locate an object by name or dotted path, importing as necessary.'
def get_benchmark_returns(symbol, start_date, end_date): DCNL 'Get a Series of benchmark returns from Yahoo. DCNL Returns a Series with returns from (start_date, end_date]. DCNL start_date is **not** included because we need the close from day N - 1 to DCNL compute the returns for day N.'
def cheby2(N, rs, Wn, btype='low', analog=False, output='ba'): DCNL 'Chebyshev type II digital and analog filter design. DCNL Design an Nth-order digital or analog Chebyshev type II filter and DCNL return the filter coefficients. DCNL Parameters DCNL N : int DCNL The order of the filter. DCNL rs : float DCNL The minimum attenuation required in the stop band. DCNL Specified in decibels, as a positive number. DCNL Wn : array_like DCNL A scalar or length-2 sequence giving the critical frequencies. DCNL For Type II filters, this is the point in the transition band at which DCNL the gain first reaches -`rs`. DCNL For digital filters, `Wn` is normalized from 0 to 1, where 1 is the DCNL Nyquist frequency, pi radians/sample.  (`Wn` is thus in DCNL half-cycles / sample.) DCNL For analog filters, `Wn` is an angular frequency (e.g. rad/s). DCNL btype : {\'lowpass\', \'highpass\', \'bandpass\', \'bandstop\'}, optional DCNL The type of filter.  Default is \'lowpass\'. DCNL analog : bool, optional DCNL When True, return an analog filter, otherwise a digital filter is DCNL returned. DCNL output : {\'ba\', \'zpk\', \'sos\'}, optional DCNL Type of output:  numerator/denominator (\'ba\'), pole-zero (\'zpk\'), or DCNL second-order sections (\'sos\'). Default is \'ba\'. DCNL Returns DCNL b, a : ndarray, ndarray DCNL Numerator (`b`) and denominator (`a`) polynomials of the IIR filter. DCNL Only returned if ``output=\'ba\'``. DCNL z, p, k : ndarray, ndarray, float DCNL Zeros, poles, and system gain of the IIR filter transfer DCNL function.  Only returned if ``output=\'zpk\'``. DCNL sos : ndarray DCNL Second-order sections representation of the IIR filter. DCNL Only returned if ``output==\'sos\'``. DCNL See Also DCNL cheb2ord, cheb2ap DCNL Notes DCNL The Chebyshev type II filter maximizes the rate of cutoff between the DCNL frequency response\'s passband and stopband, at the expense of ripple in DCNL the stopband and increased ringing in the step response. DCNL Type II filters do not roll off as fast as Type I (`cheby1`). DCNL The ``\'sos\'`` output parameter was added in 0.16.0. DCNL Examples DCNL Plot the filter\'s frequency response, showing the critical points: DCNL >>> from scipy import signal DCNL >>> import matplotlib.pyplot as plt DCNL >>> b, a = signal.cheby2(4, 40, 100, \'low\', analog=True) DCNL >>> w, h = signal.freqs(b, a) DCNL >>> plt.semilogx(w, 20 * np.log10(abs(h))) DCNL >>> plt.title(\'Chebyshev Type II frequency response (rs=40)\') DCNL >>> plt.xlabel(\'Frequency [radians / second]\') DCNL >>> plt.ylabel(\'Amplitude [dB]\') DCNL >>> plt.margins(0, 0.1) DCNL >>> plt.grid(which=\'both\', axis=\'both\') DCNL >>> plt.axvline(100, color=\'green\') # cutoff frequency DCNL >>> plt.axhline(-40, color=\'green\') # rs DCNL >>> plt.show()'
def pick_disk_driver_name(hypervisor_version, is_block_dev=False): DCNL 'Pick the libvirt primary backend driver name DCNL If the hypervisor supports multiple backend drivers we have to tell libvirt DCNL which one should be used. DCNL Xen supports the following drivers: "tap", "tap2", "phy", "file", or DCNL "qemu", being "qemu" the preferred one. Qemu only supports "qemu". DCNL :param is_block_dev: DCNL :returns: driver_name or None'
def test_multi_explicit_fail(): DCNL 'Model a failure of the explicit segment under concurrency.'
def set_value(dictionary, keys, value): DCNL 'Similar to Python\'s built in `dictionary[key] = value`, DCNL but takes a list of nested keys instead of a single key. DCNL set_value({\'a\': 1}, [], {\'b\': 2}) -> {\'a\': 1, \'b\': 2} DCNL set_value({\'a\': 1}, [\'x\'], 2) -> {\'a\': 1, \'x\': 2} DCNL set_value({\'a\': 1}, [\'x\', \'y\'], 2) -> {\'a\': 1, \'x\': {\'y\': 2}}'
@require_admin_context DCNL def instance_type_create(context, values): DCNL 'Create a new instance type. In order to pass in extra specs, DCNL the values dict should contain a \'extra_specs\' key/value pair: DCNL {\'extra_specs\' : {\'k1\': \'v1\', \'k2\': \'v2\', ...}}'
@testing.requires_testing_data DCNL def test_sensitivity_maps(): DCNL 'Test sensitivity map computation.'
def cmd_log(cmd, cwd): DCNL 'Helper function to redirect stderr to stdout and log the command DCNL used along with the output. Will raise subprocess.CalledProcessError if DCNL command doesn\'t return 0, and returns the command\'s output.'
def remove_invalid_options(context, search_options, allowed_search_options): DCNL 'Remove search options that are not valid for non-admin API/context.'
def set_date(name, date): DCNL 'Sets the value for the date the password was last changed to days since the DCNL epoch (January 1, 1970). See man chage. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' shadow.set_date username 0'
def get_os_vendor(): DCNL 'Try to guess what\'s the os vendor.'
def ljust(value, arg): DCNL 'Left-aligns the value in a field of a given width DCNL Argument: field size'
def get_image_label(name, default='not_found.png'): DCNL 'Return image inside a QLabel object'
def path_to_local_track_uri(relpath): DCNL 'Convert path relative to :confval:`local/media_dir` to local track DCNL URI.'
def flatten_const_node_list(environment, node_list): DCNL 'Try to flatten the given node list into a single string. DCNL :param environment: Jinja2 environment DCNL :type environment: jinja2.environment.Environment DCNL :param node_list: List of nodes DCNL :type node_list: list[jinja2.nodes.Node] DCNL :return: String of content DCNL :rtype: str DCNL :raise Unflattenable: Raised when the node list can\'t be flattened into DCNL a constant'
@contextmanager DCNL @deprecated(u'1.4.0', _deprecation_msg) DCNL def subsystem_instance(subsystem_type, scope=None, **options): DCNL 'Creates a Subsystem instance for test. DCNL :API: public DCNL :param type subsystem_type: The subclass of :class:`pants.subsystem.subsystem.Subsystem` DCNL to create. DCNL :param string scope: An optional scope to create the subsystem in; defaults to global. DCNL :param **options: Keyword args representing option values explicitly set via the command line.'
def count(s, *args): DCNL 'count(s, sub[, start[,end]]) -> int DCNL Return the number of occurrences of substring sub in string DCNL s[start:end].  Optional arguments start and end are DCNL interpreted as in slice notation.'
@command(('rmp\\s*(\\d+|%s)' % WORD)) DCNL def playlist_remove(name): DCNL 'Delete a saved playlist by name - or purge working playlist if *all.'
def set_present(name, set_type, family='ipv4', **kwargs): DCNL '.. versionadded:: 2014.7.0 DCNL Verify the set exists. DCNL name DCNL A user-defined set name. DCNL set_type DCNL The type for the set. DCNL family DCNL Networking family, either ipv4 or ipv6'
@must_be_valid_project DCNL @must_have_permission(ADMIN) DCNL @must_not_be_registration DCNL def project_contributors_post(auth, node, **kwargs): DCNL 'Add contributors to a node.'
def findController(controllers=DefaultControllers): DCNL 'Return first available controller from list, if any'
def port_create_vxlan(br, port, id, remote, dst_port=None): DCNL 'Virtual eXtensible Local Area Network - creates VXLAN tunnel between endpoints. DCNL Args: DCNL br: A string - bridge name. DCNL port: A string - port name. DCNL id: An integer - unsigned 64-bit number, tunnel\'s key. DCNL remote: A string - remote endpoint\'s IP address. DCNL dst_port: An integer - port to use when creating tunnelport in the switch. DCNL Returns: DCNL True on success, else False. DCNL .. versionadded:: 2016.3.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' openvswitch.port_create_vxlan br0 vx1 5001 192.168.1.10 8472'
def setup_redis(): DCNL 'Starts the connection pool for all configured redis servers'
def log_methods_calls(fname, some_class, prefix=None): DCNL 'Hack `some_class` to log all method calls into `fname` file. DCNL If `prefix` format is not set, each log entry is prefixed with: DCNL --[ asked / called / defined ] -- DCNL asked   - name of `some_class` DCNL called  - name of class for which a method is called DCNL defined - name of class where method is defined DCNL Must be used carefully, because it monkeypatches __getattribute__ call. DCNL Example:  log_methods_calls(\'log.log\', ShellBaseWidget)'
@hook.command('octopart', 'octo') DCNL def octopart(text, reply): DCNL 'octopart <keyword> -- Search for any part on the Octopart database.'
def create_config_file(watch, start_cmd, stop_cmd, ports, env_vars={}, max_memory=500, syslog_server='', host=None, upgrade_flag=False, match_cmd=''): DCNL 'Reads in a template file for monit and fills it with the DCNL correct configuration. The caller is responsible for deleting DCNL the created file. DCNL Args: DCNL watch: A string which identifies this process with monit DCNL start_cmd: The start command to start the process DCNL stop_cmd: The stop command to kill the process DCNL ports: A list of ports that are being watched DCNL env_vars: The environment variables used when starting the process DCNL max_memory: An int that names the maximum amount of memory that this process DCNL is allowed to use (in megabytes) before monit should restart it. DCNL syslog_server: The IP of the remote syslog server to use. DCNL host: The private IP of a server that runs the appengine role; used for DCNL reliably detecting a running app server process. DCNL Returns: DCNL The name of the created configuration file. DCNL Raises: DCNL TypeError with bad argument types'
def save_categories(shop, categories_pk): DCNL 'Save a list of PK as a list of sample categories for a shop'
def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For', scheme='X-Forwarded-Proto', debug=False): DCNL 'Change the base URL (scheme://host[:port][/path]). DCNL For running a CP server behind Apache, lighttpd, or other HTTP server. DCNL If you want the new request.base to include path info (not just the host), DCNL you must explicitly set base to the full base path, and ALSO set \'local\' DCNL to \'\', so that the X-Forwarded-Host request header (which never includes DCNL path info) does not override it. Regardless, the value for \'base\' MUST DCNL NOT end in a slash. DCNL cherrypy.request.remote.ip (the IP address of the client) will be DCNL rewritten if the header specified by the \'remote\' arg is valid. DCNL By default, \'remote\' is set to \'X-Forwarded-For\'. If you do not DCNL want to rewrite remote.ip, set the \'remote\' arg to an empty string.'
def _strips(direction, text, remove): DCNL 'strips \'remove\' from \'text\' at \'direction\' end'
def setAttributeDictionaryByArguments(argumentNames, arguments, xmlElement): DCNL 'Set the attribute dictionary to the arguments.'
def expand_dimension_links(metadata): DCNL 'Expands links to dimensions. `metadata` should be a list of strings or DCNL dictionaries (might be mixed). Returns a list of dictionaries with at DCNL least one key `name`. Other keys are: `hierarchies`, DCNL `default_hierarchy_name`, `nonadditive`, `cardinality`, `template`'
@register.inclusion_tag(u'generic/includes/comment.html', takes_context=True) DCNL def comment_thread(context, parent): DCNL 'Return a list of child comments for the given parent, storing all DCNL comments in a dict in the context when first called, using parents DCNL as keys for retrieval on subsequent recursive calls from the DCNL comments template.'
def listify_value(arg, split=None): DCNL 'Make a list out of an argument. DCNL Values from `distutils` argument parsing are always single strings; DCNL values from `optparse` parsing may be lists of strings that may need DCNL to be further split. DCNL No matter the input, this function returns a flat list of whitespace-trimmed DCNL strings, with `None` values filtered out. DCNL >>> listify_value("foo bar") DCNL [\'foo\', \'bar\'] DCNL >>> listify_value(["foo bar"]) DCNL [\'foo\', \'bar\'] DCNL >>> listify_value([["foo"], "bar"]) DCNL [\'foo\', \'bar\'] DCNL >>> listify_value([["foo"], ["bar", None, "foo"]]) DCNL [\'foo\', \'bar\', \'foo\'] DCNL >>> listify_value("foo, bar, quux", ",") DCNL [\'foo\', \'bar\', \'quux\'] DCNL :param arg: A string or a list of strings DCNL :param split: The argument to pass to `str.split()`. DCNL :return:'
def temp_fail_retry(error, fun, *args): DCNL 'Retry to execute function, ignoring EINTR error (interruptions)'
def paginated(model, query=None, increment=200, each=True): DCNL 'Paginate a MODM query. DCNL :param StoredObject model: Model to query. DCNL :param Q query: Optional query object. DCNL :param int increment: Page size DCNL :param bool each: If True, each record is yielded. If False, pages DCNL are yielded.'
def power_divergence(f_obs, f_exp=None, ddof=0, axis=0, lambda_=None): DCNL 'Cressie-Read power divergence statistic and goodness of fit test. DCNL This function tests the null hypothesis that the categorical data DCNL has the given frequencies, using the Cressie-Read power divergence DCNL statistic. DCNL Parameters DCNL f_obs : array_like DCNL Observed frequencies in each category. DCNL f_exp : array_like, optional DCNL Expected frequencies in each category.  By default the categories are DCNL assumed to be equally likely. DCNL ddof : int, optional DCNL "Delta degrees of freedom": adjustment to the degrees of freedom DCNL for the p-value.  The p-value is computed using a chi-squared DCNL distribution with ``k - 1 - ddof`` degrees of freedom, where `k` DCNL is the number of observed frequencies.  The default value of `ddof` DCNL is 0. DCNL axis : int or None, optional DCNL The axis of the broadcast result of `f_obs` and `f_exp` along which to DCNL apply the test.  If axis is None, all values in `f_obs` are treated DCNL as a single data set.  Default is 0. DCNL lambda_ : float or str, optional DCNL `lambda_` gives the power in the Cressie-Read power divergence DCNL statistic.  The default is 1.  For convenience, `lambda_` may be DCNL assigned one of the following strings, in which case the DCNL corresponding numerical value is used:: DCNL String              Value   Description DCNL "pearson"             1     Pearson\'s chi-squared statistic. DCNL In this case, the function is DCNL equivalent to `stats.chisquare`. DCNL "log-likelihood"      0     Log-likelihood ratio. Also known as DCNL the G-test [3]_. DCNL "freeman-tukey"      -1/2   Freeman-Tukey statistic. DCNL "mod-log-likelihood" -1     Modified log-likelihood ratio. DCNL "neyman"             -2     Neyman\'s statistic. DCNL "cressie-read"        2/3   The power recommended in [5]_. DCNL Returns DCNL statistic : float or ndarray DCNL The Cressie-Read power divergence test statistic.  The value is DCNL a float if `axis` is None or if` `f_obs` and `f_exp` are 1-D. DCNL pvalue : float or ndarray DCNL The p-value of the test.  The value is a float if `ddof` and the DCNL return value `stat` are scalars. DCNL See Also DCNL chisquare DCNL Notes DCNL This test is invalid when the observed or expected frequencies in each DCNL category are too small.  A typical rule is that all of the observed DCNL and expected frequencies should be at least 5. DCNL When `lambda_` is less than zero, the formula for the statistic involves DCNL dividing by `f_obs`, so a warning or error may be generated if any value DCNL in `f_obs` is 0. DCNL Similarly, a warning or error may be generated if any value in `f_exp` is DCNL zero when `lambda_` >= 0. DCNL The default degrees of freedom, k-1, are for the case when no parameters DCNL of the distribution are estimated. If p parameters are estimated by DCNL efficient maximum likelihood then the correct degrees of freedom are DCNL k-1-p. If the parameters are estimated in a different way, then the DCNL dof can be between k-1-p and k-1. However, it is also possible that DCNL the asymptotic distribution is not a chisquare, in which case this DCNL test is not appropriate. DCNL This function handles masked arrays.  If an element of `f_obs` or `f_exp` DCNL is masked, then data at that position is ignored, and does not count DCNL towards the size of the data set. DCNL .. versionadded:: 0.13.0 DCNL References DCNL .. [1] Lowry, Richard.  "Concepts and Applications of Inferential DCNL Statistics". Chapter 8. http://faculty.vassar.edu/lowry/ch8pt1.html DCNL .. [2] "Chi-squared test", http://en.wikipedia.org/wiki/Chi-squared_test DCNL .. [3] "G-test", http://en.wikipedia.org/wiki/G-test DCNL .. [4] Sokal, R. R. and Rohlf, F. J. "Biometry: the principles and DCNL practice of statistics in biological research", New York: Freeman DCNL (1981) DCNL .. [5] Cressie, N. and Read, T. R. C., "Multinomial Goodness-of-Fit DCNL Tests", J. Royal Stat. Soc. Series B, Vol. 46, No. 3 (1984), DCNL pp. 440-464. DCNL Examples DCNL (See `chisquare` for more examples.) DCNL When just `f_obs` is given, it is assumed that the expected frequencies DCNL are uniform and given by the mean of the observed frequencies.  Here we DCNL perform a G-test (i.e. use the log-likelihood ratio statistic): DCNL >>> from scipy.stats import power_divergence DCNL >>> power_divergence([16, 18, 16, 14, 12, 12], lambda_=\'log-likelihood\') DCNL (2.006573162632538, 0.84823476779463769) DCNL The expected frequencies can be given with the `f_exp` argument: DCNL >>> power_divergence([16, 18, 16, 14, 12, 12], DCNL ...                  f_exp=[16, 16, 16, 16, 16, 8], DCNL ...                  lambda_=\'log-likelihood\') DCNL (3.3281031458963746, 0.6495419288047497) DCNL When `f_obs` is 2-D, by default the test is applied to each column. DCNL >>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T DCNL >>> obs.shape DCNL (6, 2) DCNL >>> power_divergence(obs, lambda_="log-likelihood") DCNL (array([ 2.00657316,  6.77634498]), array([ 0.84823477,  0.23781225])) DCNL By setting ``axis=None``, the test is applied to all data in the array, DCNL which is equivalent to applying the test to the flattened array. DCNL >>> power_divergence(obs, axis=None) DCNL (23.31034482758621, 0.015975692534127565) DCNL >>> power_divergence(obs.ravel()) DCNL (23.31034482758621, 0.015975692534127565) DCNL `ddof` is the change to make to the default degrees of freedom. DCNL >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=1) DCNL (2.0, 0.73575888234288467) DCNL The calculation of the p-values is done by broadcasting the DCNL test statistic with `ddof`. DCNL >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=[0,1,2]) DCNL (2.0, array([ 0.84914504,  0.73575888,  0.5724067 ])) DCNL `f_obs` and `f_exp` are also broadcast.  In the following, `f_obs` has DCNL shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting DCNL `f_obs` and `f_exp` has shape (2, 6).  To compute the desired chi-squared DCNL statistics, we must use ``axis=1``: DCNL >>> power_divergence([16, 18, 16, 14, 12, 12], DCNL ...                  f_exp=[[16, 16, 16, 16, 16, 8], DCNL ...                         [8, 20, 20, 16, 12, 12]], DCNL ...                  axis=1) DCNL (array([ 3.5 ,  9.25]), array([ 0.62338763,  0.09949846]))'
def get_version(): DCNL 'Return the VERSION as a string, e.g. for VERSION == (0, 10, 7), DCNL return \'0.10.7\'.'
def to_dict(sequences, key_function=None): DCNL 'Turns a sequence iterator or list into a dictionary. DCNL - sequences  - An iterator that returns SeqRecord objects, DCNL or simply a list of SeqRecord objects. DCNL - key_function - Optional callback function which when given a DCNL SeqRecord should return a unique key for the dictionary. DCNL e.g. key_function = lambda rec : rec.name DCNL or,  key_function = lambda rec : rec.description.split()[0] DCNL If key_function is omitted then record.id is used, on the assumption DCNL that the records objects returned are SeqRecords with a unique id. DCNL If there are duplicate keys, an error is raised. DCNL Example usage, defaulting to using the record.id as key: DCNL >>> from Bio import SeqIO DCNL >>> filename = "GenBank/cor6_6.gb" DCNL >>> format = "genbank" DCNL >>> id_dict = SeqIO.to_dict(SeqIO.parse(filename, format)) DCNL >>> print(sorted(id_dict)) DCNL [\'AF297471.1\', \'AJ237582.1\', \'L31939.1\', \'M81224.1\', \'X55053.1\', \'X62281.1\'] DCNL >>> print(id_dict["L31939.1"].description) DCNL Brassica rapa (clone bif72) kin mRNA, complete cds DCNL A more complex example, using the key_function argument in order to DCNL use a sequence checksum as the dictionary key: DCNL >>> from Bio import SeqIO DCNL >>> from Bio.SeqUtils.CheckSum import seguid DCNL >>> filename = "GenBank/cor6_6.gb" DCNL >>> format = "genbank" DCNL >>> seguid_dict = SeqIO.to_dict(SeqIO.parse(filename, format), DCNL ...               key_function = lambda rec : seguid(rec.seq)) DCNL >>> for key, record in sorted(seguid_dict.items()): DCNL ...     print("%s %s" % (key, record.id)) DCNL /wQvmrl87QWcm9llO4/efg23Vgg AJ237582.1 DCNL BUg6YxXSKWEcFFH0L08JzaLGhQs L31939.1 DCNL SabZaA4V2eLE9/2Fm5FnyYy07J4 X55053.1 DCNL TtWsXo45S3ZclIBy4X/WJc39+CY M81224.1 DCNL l7gjJFE6W/S1jJn5+1ASrUKW/FA X62281.1 DCNL uVEYeAQSV5EDQOnFoeMmVea+Oow AF297471.1 DCNL This approach is not suitable for very large sets of sequences, as all DCNL the SeqRecord objects are held in memory. Instead, consider using the DCNL Bio.SeqIO.index() function (if it supports your particular file format).'
def get_best_language(accept_lang): DCNL 'Given an Accept-Language header, return the best-matching language.'
def certificate(): DCNL 'Certificates Controller'
def diff(*paths): DCNL 'Return a formatted diff between current files and original in a package. DCNL NOTE: this function includes all files (configuration and not), but does DCNL not work on binary content. DCNL :param path: Full path to the installed file DCNL :return: Difference string or raises and exception if examined file is binary. DCNL CLI example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.diff /etc/apache2/httpd.conf /etc/sudoers'
def base64_decode(input, errors='strict'): DCNL 'Decodes the object input and returns a tuple (output DCNL object, length consumed). DCNL input must be an object which provides the bf_getreadbuf DCNL buffer slot. Python strings, buffer objects and memory DCNL mapped files are examples of objects providing this slot. DCNL errors defines the error handling to apply. It defaults to DCNL \'strict\' handling which is the only currently supported DCNL error handling for this codec.'
def metric_cleanup(): DCNL 'Teardown; part of Gmond interface'
def search(request): DCNL 'Search Scan by MD5 Route'
def initialize(): DCNL 'Initializes local config object'
def shlex_quote(s): DCNL 'Return a shell-escaped version of the string *s*. DCNL Backported from Python 3.3 standard library module shlex.'
def simple_norm(data, stretch='linear', power=1.0, asinh_a=0.1, min_cut=None, max_cut=None, min_percent=None, max_percent=None, percent=None, clip=True): DCNL 'Return a Normalization class that can be used for displaying images DCNL with Matplotlib. DCNL This function enables only a subset of image stretching functions DCNL available in `~astropy.visualization.mpl_normalize.ImageNormalize`. DCNL This function is used by the DCNL ``astropy.visualization.scripts.fits2bitmap`` script. DCNL Parameters DCNL data : `~numpy.ndarray` DCNL The image array. DCNL stretch : {\'linear\', \'sqrt\', \'power\', log\', \'asinh\'}, optional DCNL The stretch function to apply to the image.  The default is DCNL \'linear\'. DCNL power : float, optional DCNL The power index for ``stretch=\'power\'``.  The default is 1.0. DCNL asinh_a : float, optional DCNL For ``stretch=\'asinh\'``, the value where the asinh curve DCNL transitions from linear to logarithmic behavior, expressed as a DCNL fraction of the normalized image.  Must be in the range between DCNL 0 and 1.  The default is 0.1. DCNL min_cut : float, optional DCNL The pixel value of the minimum cut level.  Data values less than DCNL ``min_cut`` will set to ``min_cut`` before stretching the image. DCNL The default is the image minimum.  ``min_cut`` overrides DCNL ``min_percent``. DCNL max_cut : float, optional DCNL The pixel value of the maximum cut level.  Data values greater DCNL than ``min_cut`` will set to ``min_cut`` before stretching the DCNL image.  The default is the image maximum.  ``max_cut`` overrides DCNL ``max_percent``. DCNL min_percent : float, optional DCNL The percentile value used to determine the pixel value of DCNL minimum cut level.  The default is 0.0.  ``min_percent`` DCNL overrides ``percent``. DCNL max_percent : float, optional DCNL The percentile value used to determine the pixel value of DCNL maximum cut level.  The default is 100.0.  ``max_percent`` DCNL overrides ``percent``. DCNL percent : float, optional DCNL The percentage of the image values used to determine the pixel DCNL values of the minimum and maximum cut levels.  The lower cut DCNL level will set at the ``(100 - percent) / 2`` percentile, while DCNL the upper cut level will be set at the ``(100 + percent) / 2`` DCNL percentile.  The default is 100.0.  ``percent`` is ignored if DCNL either ``min_percent`` or ``max_percent`` is input. DCNL clip : bool, optional DCNL If `True` (default), data values outside the [0:1] range are DCNL clipped to the [0:1] range. DCNL Returns DCNL result : `ImageNormalize` instance DCNL An `ImageNormalize` instance that can be used for displaying DCNL images with Matplotlib.'
def get_role_permissions(meta, user=None, verbose=False): DCNL 'Returns dict of evaluated role permissions like `{"read": True, "write":False}` DCNL If user permissions are applicable, it adds a dict of user permissions like DCNL // user permissions will apply on these rights DCNL "apply_user_permissions": {"read": 1, "write": 1}, DCNL // doctypes that will be applicable for each right DCNL "user_permission_doctypes": { DCNL "read": [ DCNL // AND between "DocType 1" and "DocType 2" DCNL ["DocType 1", "DocType 2"], DCNL // OR DCNL ["DocType 3"] DCNL "if_owner": {"read": 1, "write": 1}'
def evaluation(y_test=None, y_predict=None, n_classes=None): DCNL 'Input the predicted results, targets results and DCNL the number of class, return the confusion matrix, F1-score of each class, DCNL accuracy and macro F1-score. DCNL Parameters DCNL y_test : numpy.array or list DCNL target results DCNL y_predict : numpy.array or list DCNL predicted results DCNL n_classes : int DCNL number of classes DCNL Examples DCNL >>> c_mat, f1, acc, f1_macro = evaluation(y_test, y_predict, n_classes)'
def auto_fields(resource): DCNL 'Returns a list of automatically handled fields for a resource. DCNL :param resource: the resource currently being accessed by the client. DCNL .. versionchanged: 0.5 DCNL ETAG is now a preserved meta data (#369). DCNL .. versionadded:: 0.4'
def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir): DCNL 'Automatically find/download setuptools and make it available on sys.path DCNL `version` should be a valid setuptools version number that is available DCNL as an egg for download under the `download_base` URL (which should end with DCNL a \'/\').  `to_dir` is the directory where setuptools will be downloaded, if DCNL it is not already available. DCNL If an older version of setuptools is installed, this will print a message DCNL to ``sys.stderr`` and raise SystemExit in an attempt to abort the calling DCNL script.'
def setup(**attrs): DCNL 'The gateway to the Distutils: do everything your setup script needs DCNL to do, in a highly flexible and user-driven way.  Briefly: create a DCNL Distribution instance; find and parse config files; parse the command DCNL line; run each Distutils command found there, customized by the options DCNL supplied to \'setup()\' (as keyword arguments), in config files, and on DCNL the command line. DCNL The Distribution instance might be an instance of a class supplied via DCNL the \'distclass\' keyword argument to \'setup\'; if no such class is DCNL supplied, then the Distribution class (in dist.py) is instantiated. DCNL All other arguments to \'setup\' (except for \'cmdclass\') are used to set DCNL attributes of the Distribution instance. DCNL The \'cmdclass\' argument, if supplied, is a dictionary mapping command DCNL names to command classes.  Each command encountered on the command line DCNL will be turned into a command class, which is in turn instantiated; any DCNL class found in \'cmdclass\' is used in place of the default, which is DCNL (for command \'foo_bar\') class \'foo_bar\' in module DCNL \'distutils.command.foo_bar\'.  The command class must provide a DCNL \'user_options\' attribute which is a list of option specifiers for DCNL \'distutils.fancy_getopt\'.  Any command-line options between the current DCNL and the next command are used to set attributes of the current command DCNL object. DCNL When the entire command-line has been successfully parsed, calls the DCNL \'run()\' method on each command object in turn.  This method will be DCNL driven entirely by the Distribution object (which each command object DCNL has a reference to, thanks to its constructor), and the DCNL command-specific options that became attributes of each command DCNL object.'
def get_messages(request): DCNL 'Returns the message storage on the request if it exists, otherwise returns DCNL user.message_set.all() as the old auth context processor did.'
def __virtual__(): DCNL 'Only load if the mfs commands are installed'
def document_batch_action(section, resource_name, event_emitter, batch_action_model, service_model, collection_model, include_signature=True): DCNL 'Documents a collection\'s batch action DCNL :param section: The section to write to DCNL :param resource_name: The name of the resource DCNL :param action_name: The name of collection action. Currently only DCNL can be all, filter, limit, or page_size DCNL :param event_emitter: The event emitter to use to emit events DCNL :param batch_action_model: The model of the batch action DCNL :param collection_model: The model of the collection DCNL :param service_model: The model of the service DCNL :param include_signature: Whether or not to include the signature. DCNL It is useful for generating docstrings.'
def tuple2str(tagged_token, sep='/'): DCNL 'Given the tuple representation of a tagged token, return the DCNL corresponding string representation.  This representation is DCNL formed by concatenating the token\'s word string, followed by the DCNL separator, followed by the token\'s tag.  (If the tag is None, DCNL then just return the bare word string.) DCNL >>> from nltk.tag.util import tuple2str DCNL >>> tagged_token = (\'fly\', \'NN\') DCNL >>> tuple2str(tagged_token) DCNL \'fly/NN\' DCNL :type tagged_token: tuple(str, str) DCNL :param tagged_token: The tuple representation of a tagged token. DCNL :type sep: str DCNL :param sep: The separator string used to separate word strings DCNL from tags.'
def close_enough(sa, sb): DCNL 'Compare two strings and return true if they\'re the same notwithstanding any whitespace or case.'
def SynthesizeUserId(email): DCNL 'Return a synthetic user ID from an email address. DCNL Note that this is not the same user ID found in the production system. DCNL Args: DCNL email: An email address. DCNL Returns: DCNL A string userid derived from the email address.'
def get_cache(): DCNL 'Returns internal cache object from globally installed ``CachedSession``'
def set_store(store, key=_store_registry_key, app=None): DCNL 'Sets an instance of :class:`AuthStore` in the app registry. DCNL :param store: DCNL An instance of :class:`AuthStore`. DCNL :param key: DCNL The key used to retrieve the instance from the registry. A default DCNL is used if it is not set. DCNL :param request: DCNL A :class:`webapp2.WSGIApplication` instance used to retrieve the DCNL instance. The active app is used if it is not set.'
def get_server_info(request=None): DCNL 'Returns server information for use in the API. DCNL This is used for the root resource and for the deprecated server DCNL info resource.'
def holdings_cover_maked_nextbar(data, cover_entries, capital, short_margin, volume_multiple): DCNL '策略: 空头限价平仓且下一根bar成交 DCNL 买入点：[相关bar的最低点减去OFFSET] DCNL 当天卖出点：sell1'
def flatten(x, outdim=1): DCNL 'Reshapes the variable x by keeping DCNL the first outdim-1 dimension size(s) of x the same, DCNL and making the last dimension size of x equal to DCNL the multiplication of its remaining dimension size(s). DCNL Parameters DCNL x : theano.tensor.var.TensorVariable DCNL the variable that should be reshaped. DCNL outdim : int DCNL the number of dimensions of the returned variable DCNL Returns DCNL theano.tensor.var.TensorVariable DCNL the flattend variable with dimensionality of outdim'
def distros_for_filename(filename, metadata=None): DCNL 'Yield possible egg or source distribution objects based on a filename'
def _parseTCP(factory, port, interface='', backlog=50): DCNL 'Internal parser function for L{_parseServer} to convert the string DCNL arguments for a TCP(IPv4) stream endpoint into the structured arguments. DCNL @param factory: the protocol factory being parsed, or L{None}.  (This was a DCNL leftover argument from when this code was in C{strports}, and is now DCNL mostly None and unused.) DCNL @type factory: L{IProtocolFactory} or L{None} DCNL @param port: the integer port number to bind DCNL @type port: C{str} DCNL @param interface: the interface IP to listen on DCNL @param backlog: the length of the listen queue DCNL @type backlog: C{str} DCNL @return: a 2-tuple of (args, kwargs), describing  the parameters to DCNL L{IReactorTCP.listenTCP} (or, modulo argument 2, the factory, arguments DCNL to L{TCP4ServerEndpoint}.'
def show_snapshot(kwargs=None, call=None): DCNL 'Show the details of an existing snapshot. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-cloud -f show_snapshot gce name=mysnapshot'
def diff_jid(jid, config='root'): DCNL 'Returns the changes applied by a `jid` DCNL jid DCNL The job id to lookup DCNL config DCNL Configuration name. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' snapper.diff_jid jid=20160607130930720112'
def _is_host_full(client, host): DCNL 'Checks whether maximum volumes attached to a host have been reached.'
def get_xstatic_dirs(XSTATIC_MODULES, HORIZON_CONFIG): DCNL 'Discover static file configuration of the xstatic modules. DCNL For each entry in the XSTATIC_MODULES list we determine the entry DCNL point files (which may come from the xstatic MAIN var) and then DCNL determine where in the Django static tree the xstatic package\'s contents DCNL should be placed. DCNL For jquery.bootstrap.wizard.js the module name is None the static file is DCNL actually a 3rd-party file but resides in the Horizon source tree and not DCNL an xstatic package. DCNL The xstatic.pkg.jquery_ui package had its contents moved by packagers so DCNL it must be handled as a special case.'
def dict_subset(d, keys): DCNL 'Return a new dictionary that is built from copying select keys from d'
def Repr(class_instance, ordered_dictionary): DCNL 'Generates an unambiguous representation for instance and ordered dict.'
def team_absent(name, profile='github', **kwargs): DCNL 'Ensure a team is absent. DCNL Example: DCNL .. code-block:: yaml DCNL ensure team test is present in github: DCNL github.team_absent: DCNL - name: \'test\' DCNL The following parameters are required: DCNL name DCNL This is the name of the team in the organization. DCNL .. versionadded:: 2016.11.0'
def count(typename, objects=None): DCNL 'Count objects tracked by the garbage collector with a given class name. DCNL Example: DCNL >>> count(\'dict\') DCNL 42 DCNL >>> count(\'MyClass\', get_leaking_objects()) DCNL 3 DCNL >>> count(\'mymodule.MyClass\') DCNL 2 DCNL Note that the GC does not track simple objects like int or str. DCNL .. versionchanged:: 1.7 DCNL New parameter: ``objects``. DCNL .. versionchanged:: 1.8 DCNL Accepts fully-qualified type names (i.e. \'package.module.ClassName\') DCNL as well as short type names (i.e. \'ClassName\').'
def _split_symbol_mappings(df): DCNL 'Split out the symbol: sid mappings from the raw data. DCNL Parameters DCNL df : pd.DataFrame DCNL The dataframe with multiple rows for each symbol: sid pair. DCNL Returns DCNL asset_info : pd.DataFrame DCNL The asset info with one row per asset. DCNL symbol_mappings : pd.DataFrame DCNL The dataframe of just symbol: sid mappings. The index will be DCNL the sid, then there will be three columns: symbol, start_date, and DCNL end_date.'
def set_cache_under_settings(destination, setting, key_prefix, value, ttl, list_=False): DCNL 'Take the value passed, and merge the current `setting` over it. Once DCNL complete, take the value and set the cache `key` and destination.settings DCNL `setting` to that value, using the `ttl` for set_cache(). DCNL :param destination: DCNL An object that has a `.settings` attribute that is a dict DCNL :param setting: DCNL The dict key to use when pushing the value into the settings dict DCNL :param key_prefix: DCNL The string to prefix to `setting` to make the cache key DCNL :param value: DCNL The value to set DCNL :param ttl: DCNL The cache ttl to use'
def _getPlatformString(dist=None): DCNL 'If generic==True then returns empty __build_platform__ string'
@snippet DCNL def topic_publish_messages(client, to_delete): DCNL 'Publish messages to a topic.'
def simulate_head(app, path, **kwargs): DCNL 'Simulates a HEAD request to a WSGI application. DCNL Equivalent to:: DCNL simulate_request(app, \'HEAD\', path, **kwargs) DCNL Args: DCNL app (callable): The WSGI application to call DCNL path (str): The URL path to request DCNL Keyword Args: DCNL params (dict): A dictionary of query string parameters, DCNL where each key is a parameter name, and each value is DCNL either a ``str`` or something that can be converted DCNL into a ``str``, or a list of such values. If a ``list``, DCNL the value will be converted to a comma-delimited string DCNL of values (e.g., \'thing=1,2,3\'). DCNL params_csv (bool): Set to ``False`` to encode list values DCNL in query string params by specifying multiple instances DCNL of the parameter (e.g., \'thing=1&thing=2&thing=3\'). DCNL Otherwise, parameters will be encoded as comma-separated DCNL values (e.g., \'thing=1,2,3\'). Defaults to ``True``. DCNL query_string (str): A raw query string to include in the DCNL request (default: ``None``). If specified, overrides DCNL `params`. DCNL headers (dict): Additional headers to include in the request DCNL (default: ``None``)'
def extract_lsq_problems(): DCNL 'Extract all least squares problems in this file for benchmarking. DCNL Returns DCNL OrderedDict, str -> LSQBenchmarkProblem DCNL The key is a problem name. DCNL The value is an instance of LSQBenchmarkProblem.'
def test_cons_correct(): DCNL 'Ensure cons gets compiled correctly'
def remove_file(source): DCNL 'Remove file or directory.'
def is_operator(element): DCNL 'Test whether an object is a valid domain operator.'
def should_use_rendered(doc, params, html=None): DCNL '* The service isn\'t disabled with a timeout of 0 DCNL * The document isn\'t empty DCNL * The request has *not* asked for raw source DCNL (eg. ?raw) DCNL * The request has *not* asked for no macro evaluation DCNL (eg. ?nomacros) DCNL * The request *has* asked for macro evaluation DCNL (eg. ?raw&macros)'
@pytest.mark.parametrize('parallel', [True, False]) DCNL def test_not_enough_cols(parallel, read_csv): DCNL 'If a row does not have enough columns, the FastCsv reader should add empty DCNL fields while the FastBasic reader should raise an error.'
@memoize(maxsize=None) DCNL def find(name, namespace=u'celery'): DCNL 'Find setting by name.'
def expand_dims(a, axis): DCNL 'Expands given arrays. DCNL Args: DCNL a (cupy.ndarray): Array to be expanded. DCNL axis (int): Position where new axis is to be inserted. DCNL Returns: DCNL cupy.ndarray: The number of dimensions is one greater than that of DCNL the input array. DCNL .. seealso:: :func:`numpy.expand_dims`'
def delete_volume(target, stop=True): DCNL 'Deletes a gluster volume DCNL target DCNL Volume to delete DCNL stop DCNL Stop volume before delete if it is started, True by default'
def simple_seq(seq): DCNL '>>> x = simple_seq("abc") DCNL >>> list(x) DCNL [\'a\', \'b\', \'c\']'
def tree(node): DCNL 'Returns a tree representation of "node" as a string. DCNL It uses print_node() together with pprint_nodes() on node.args recursively. DCNL See also: print_tree()'
def join(): DCNL 'Pause until sigint'
def RunInTransactionCustomRetries(retries, function, *args, **kwargs): DCNL 'Runs a function inside a datastore transaction. DCNL Runs the user-provided function inside transaction, with a specified DCNL number of retries. DCNL Args: DCNL retries: number of retries (not counting the initial try) DCNL function: a function to be run inside the transaction on all remaining DCNL arguments DCNL *args: positional arguments for function. DCNL **kwargs: keyword arguments for function. DCNL Returns: DCNL the function\'s return value, if any DCNL Raises: DCNL TransactionFailedError, if the transaction could not be committed.'
def calculateNonce(realm, algorithm=MD5): DCNL 'This is an auxaliary function that calculates \'nonce\' value. It is used DCNL to handle sessions.'
def confirm(question, error_response='Valid DCSP options DCSP : DCSP yes DCSP or DCSP no'): DCNL 'ask the user if they would like to perform the action DCNL Parameters: DCNL question       - the question you would like to ask the user to confirm. DCNL error_response - the message to display if an invalid option is given.'
def asStructuredText(I, munge=0): DCNL 'Output structured text format.  Note, this will whack any existing DCNL \'structured\' format of the text.'
def install_packages_from_file(packages_to_install): DCNL '(Force)Installs packages from files, but does DCNL not update installed.lst files. DCNL caveat: not as tested as everything else. DCNL :param packages_to_install: list of files to install DCNL :raises: IOErrors'
def restoreConfigZip(archive, targetDir): DCNL 'Restores a Config ZIP file back in place DCNL :param archive: ZIP filename DCNL :param targetDir: Directory to restore to DCNL :return: True on success, False on failure'
def load(config_string, default_name=None): DCNL 'Given a module name and an object expected to be contained within, DCNL return said object.'
@verbose DCNL def gamma_map(evoked, forward, noise_cov, alpha, loose=0.2, depth=0.8, xyz_same_gamma=True, maxit=10000, tol=1e-06, update_mode=1, gammas=None, pca=True, return_residual=False, verbose=None): DCNL 'Hierarchical Bayes (Gamma-MAP) sparse source localization method. DCNL Models each source time course using a zero-mean Gaussian prior with an DCNL unknown variance (gamma) parameter. During estimation, most gammas are DCNL driven to zero, resulting in a sparse source estimate, as in DCNL [1]_ and [2]_. DCNL For fixed-orientation forward operators, a separate gamma is used for each DCNL source time course, while for free-orientation forward operators, the same DCNL gamma is used for the three source time courses at each source space point DCNL (separate gammas can be used in this case by using xyz_same_gamma=False). DCNL Parameters DCNL evoked : instance of Evoked DCNL Evoked data to invert. DCNL forward : dict DCNL Forward operator. DCNL noise_cov : instance of Covariance DCNL Noise covariance to compute whitener. DCNL alpha : float DCNL Regularization parameter (noise variance). DCNL loose : float in [0, 1] DCNL Value that weights the source variances of the dipole components DCNL that are parallel (tangential) to the cortical surface. If loose DCNL is 0 or None then the solution is computed with fixed orientation. DCNL If loose is 1, it corresponds to free orientations. DCNL depth: None | float in [0, 1] DCNL Depth weighting coefficients. If None, no depth weighting is performed. DCNL xyz_same_gamma : bool DCNL Use same gamma for xyz current components at each source space point. DCNL Recommended for free-orientation forward solutions. DCNL maxit : int DCNL Maximum number of iterations. DCNL tol : float DCNL Tolerance parameter for convergence. DCNL update_mode : int DCNL Update mode, 1: MacKay update (default), 2: Modified MacKay update. DCNL gammas : array, shape=(n_sources,) DCNL Initial values for posterior variances (gammas). If None, a DCNL variance of 1.0 is used. DCNL pca : bool DCNL If True the rank of the data is reduced to the true dimension. DCNL return_residual : bool DCNL If True, the residual is returned as an Evoked instance. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL stc : instance of SourceEstimate DCNL Source time courses. DCNL residual : instance of Evoked DCNL The residual a.k.a. data not explained by the sources. DCNL Only returned if return_residual is True. DCNL References DCNL .. [1] Wipf et al. Analysis of Empirical Bayesian Methods for DCNL Neuroelectromagnetic Source Localization, Advances in Neural DCNL Information Process. Systems (2007) DCNL .. [2] Wipf et al. A unified Bayesian framework for MEG/EEG source DCNL imaging, NeuroImage, vol. 44, no. 3, pp. 947-66, Mar. 2009.'
def set_hostname(hostname=None, commit_change=True): DCNL 'To set the name of the device. DCNL Usage: DCNL .. code-block:: bash DCNL salt \'device_name\' junos.set_hostname hostname=salt-device DCNL Options: DCNL * hostname: The name to be set. DCNL * commit_change: Whether to commit the changes.(default=True)'
def with_backing_lock(method): DCNL 'A decorator to perform a lock-*-unlock cycle. DCNL When applied to a method, this decorator will automatically wrap DCNL calls to the method in a backing file lock and before the call DCNL followed by a backing file unlock.'
def build_function(name, args=None, defaults=None, flag=0, doc=None): DCNL 'create and initialize a astroid Function node'
def js_escaped_string(string_for_js): DCNL 'Mako filter that escapes text for use in a JavaScript string. DCNL If None is provided, returns an empty string. DCNL Usage: DCNL Used as follows in a Mako template inside a <SCRIPT> tag:: DCNL var my_string_for_js = "${my_string_for_js | n, js_escaped_string}" DCNL The surrounding quotes for the string must be included. DCNL Use the "n" Mako filter above.  It is possible that the default filter DCNL may include html escaping in the future, and this ensures proper DCNL escaping. DCNL Mako\'s default filter decode.utf8 is applied here since this default DCNL filter is skipped in the Mako template with "n". DCNL Arguments: DCNL string_for_js (string): Text to be properly escaped for use in a DCNL JavaScript string. DCNL Returns: DCNL (string) Text properly escaped for use in a JavaScript string as DCNL unicode.  Returns empty string if argument is None.'
def reset_extensions_translations_locales(apps, schema_editor): DCNL 'Reset the locale field for all translations on existing Extensions. This DCNL is done to fix bug 1215094: some translations were created with the wrong DCNL language - the one from the request, instead of the one from the DCNL default_language field.'
def listen(description, factory, default=None): DCNL 'Listen on a port corresponding to a description DCNL @type description: C{str} DCNL @type factory: L{twisted.internet.interfaces.IProtocolFactory} DCNL @type default: C{str} or C{None} DCNL @rtype: C{twisted.internet.interfaces.IListeningPort} DCNL @return: the port corresponding to a description of a reliable DCNL virtual circuit server. DCNL See the documentation of the C{parse} function for description DCNL of the semantics of the arguments.'
def test_ros_fit_sample(): DCNL 'Test the fit sample routine'
def _check_storage_models(current_release): DCNL 'Check if files in core/storage have changed and returns them. DCNL Args: DCNL current_release: The current release version DCNL Returns: DCNL (list): The changed files (if any)'
def get_help(): DCNL 'Provides our --help usage information. DCNL :returns: **str** with our usage information'
def metric_to_Christoffel_2nd(expr): DCNL 'Return the nested list of Christoffel symbols for the given metric. DCNL This returns the Christoffel symbol of second kind that represents the DCNL Levi-Civita connection for the given metric. DCNL Examples DCNL >>> from sympy.diffgeom.rn import R2 DCNL >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct DCNL >>> TP = TensorProduct DCNL >>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) DCNL [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] DCNL >>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) DCNL [[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]]'
def _generic_factor_list(expr, gens, args, method): DCNL 'Helper function for :func:`sqf_list` and :func:`factor_list`.'
@register(u'accept-line') DCNL def accept_line(event): DCNL 'Accept the line regardless of where the cursor is.'
def log_loss(y_true, y_prob): DCNL 'Compute Logistic loss for classification. DCNL Parameters DCNL y_true : array-like or label indicator matrix DCNL Ground truth (correct) labels. DCNL y_prob : array-like of float, shape = (n_samples, n_classes) DCNL Predicted probabilities, as returned by a classifier\'s DCNL predict_proba method. DCNL Returns DCNL loss : float DCNL The degree to which the samples are correctly predicted.'
def start(hass, server_config): DCNL 'Initialize MQTT Server.'
def export_to_zip_file(exploration_id, version=None): DCNL 'Returns a ZIP archive of the exploration.'
def convolution_nd(x, W, b=None, stride=1, pad=0, use_cudnn=True, cover_all=False): DCNL 'N-dimensional convolution function. DCNL This is an implementation of N-dimensional convolution which is generalized DCNL two-dimensional convolution in ConvNets. It takes three variables: the DCNL input ``x``, the filter weight ``W`` and the bias vector ``b``. DCNL Notation: here is a notation for dimensionalities. DCNL - :math:`N` is the number of spatial dimensions. DCNL - :math:`n` is the batch size. DCNL - :math:`c_I` and :math:`c_O` are the number of the input and output DCNL channels, respectively. DCNL - :math:`d_1, d_2, ..., d_N` are the size of each axis of the input\'s DCNL spatial dimensions, respectively. DCNL - :math:`k_1, k_2, ..., k_N` are the size of each axis of the filters, DCNL respectively. DCNL Args: DCNL x (~chainer.Variable): Input variable of shape DCNL :math:`(n, c_I, d_1, d_2, ..., d_N)`. DCNL W (~chainer.Variable): Weight variable of shape DCNL :math:`(c_O, c_I, k_1, k_2, ..., k_N)`. DCNL b (~chainer.Variable): One-dimensional bias variable with length DCNL :math:`c_O` (optional). DCNL stride (int or tuple of ints): Stride of filter applications DCNL :math:`(s_1, s_2, ..., s_N)`. ``stride=s`` is equivalent to DCNL ``(s, s, ..., s)``. DCNL pad (int or tuple of ints): Spatial padding width for input arrays DCNL :math:`(p_1, p_2, ..., p_N)`. ``pad=p`` is equivalent to DCNL ``(p, p, ..., p)``. DCNL use_cudnn (bool): If ``True``, then this function uses cuDNN if DCNL available. See below for the excact conditions. DCNL cover_all (bool): If ``True``, all spatial locations are convoluted DCNL into some output pixels. It may make the output size larger. DCNL `cover_all` needs to be ``False`` if you want to use cuDNN. DCNL Returns: DCNL ~chainer.Variable: Output variable. DCNL This function uses cuDNN implementation for its forward and backward DCNL computation if ALL of the following conditions are satisfied: DCNL - ``cuda.cudnn_enabled`` is ``True`` DCNL - ``use_cudnn`` is ``True`` DCNL - The number of spatial dimensions is more than one. DCNL - ``cover_all`` is ``False`` DCNL - The input\'s ``dtype`` is equal to the filter weight\'s. DCNL - The ``dtype`` is FP32, FP64 or FP16(cuDNN version is equal to or greater DCNL than v3) DCNL .. seealso:: :class:`~chainer.links.ConvolutionND`, :func:`convolution_2d`'
def normpath(path): DCNL 'Normalize path, eliminating double slashes, etc.'
def select(start, end): DCNL 'Select the span in Select mode.'
def log_mean_exp(a): DCNL '.. todo:: DCNL WRITEME'
def fullmatch(pattern, string, flags=0): DCNL 'Try to apply the pattern to all of the string, returning DCNL a match object, or None if no match was found.'
def _variable_with_weight_decay(name, shape, stddev, wd): DCNL 'Helper to create an initialized Variable with weight decay. DCNL Note that the Variable is initialized with a truncated normal distribution. DCNL A weight decay is added only if one is specified. DCNL Args: DCNL name: name of the variable DCNL shape: list of ints DCNL stddev: standard deviation of a truncated Gaussian DCNL wd: add L2Loss weight decay multiplied by this float. If None, weight DCNL decay is not added for this Variable. DCNL Returns: DCNL Variable Tensor'
def lookupNamingAuthorityPointer(name, timeout=None): DCNL 'NAPTR lookup. DCNL @type name: C{str} DCNL @param name: DNS name to resolve. DCNL @type timeout: Sequence of C{int} DCNL @param timeout: Number of seconds after which to reissue the query. DCNL When the last timeout expires, the query is considered failed. DCNL @rtype: C{Deferred}'
def db_exists(name, **client_args): DCNL 'Checks if a database exists in InfluxDB. DCNL name DCNL Name of the database to check. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' influxdb.db_exists <name>'
def build_auxiliary_edge_connectivity(G): DCNL 'Auxiliary digraph for computing flow based edge connectivity DCNL If the input graph is undirected, we replace each edge (`u`,`v`) with DCNL two reciprocal arcs (`u`, `v`) and (`v`, `u`) and then we set the attribute DCNL \'capacity\' for each arc to 1. If the input graph is directed we simply DCNL add the \'capacity\' attribute. Part of algorithm 1 in [1]_ . DCNL References DCNL .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms. (this is a DCNL chapter, look for the reference of the book). DCNL http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf'
def build_graph(git_dir, roles_dirs, aws_play_dirs, docker_play_dirs): DCNL 'Builds a dependency graph that shows relationships between roles and playbooks. DCNL An edge [A, B], where A and B are roles, signifies that A depends on B. An edge DCNL [C, D], where C is a playbook and D is a role, signifies that C uses D. DCNL Input: DCNL git_dir: A path to the top-most directory in the local git repository tool is to be run in. DCNL roles_dirs: A list of relative paths to directories in which Ansible roles reside. DCNL aws_play_dirs: A list of relative paths to directories in which AWS Ansible playbooks reside. DCNL docker_play_dirs: A list of relative paths to directories in which Docker Ansible playbooks reside.'
def change_state(api_url, post_data): DCNL 'Update a state using the Zoneminder API.'
def test_factory(support_as_data=True): DCNL 'A helper for returning a unittest TestCase for testing'
def get_error_page(status, **kwargs): DCNL 'Return an HTML page, containing a pretty error response. DCNL status should be an int or a str. DCNL kwargs will be interpolated into the page template.'
def run_convert_to_html(output_dir): DCNL 'Converts markdown files into their respective html files'
def _chunk_write(chunk, local_file, progress): DCNL 'Write a chunk to file and update the progress bar'
def get_features(): DCNL 'Get the value of FEATURES variable in the make.conf DCNL Return the value of the variable or None if the variable is DCNL not in the make.conf DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' makeconf.get_features'
def _plot_topomap_multi_cbar(data, pos, ax, title=None, unit=None, vmin=None, vmax=None, cmap=None, outlines='head', colorbar=False, cbar_fmt='%3.3f'): DCNL 'Plot topomap multi cbar.'
def rectangle(width, height, dtype=np.uint8): DCNL 'Generates a flat, rectangular-shaped structuring element. DCNL Every pixel in the rectangle generated for a given width and given height DCNL belongs to the neighborhood. DCNL Parameters DCNL width : int DCNL The width of the rectangle. DCNL height : int DCNL The height of the rectangle. DCNL Other Parameters DCNL dtype : data-type DCNL The data type of the structuring element. DCNL Returns DCNL selem : ndarray DCNL A structuring element consisting only of ones, i.e. every DCNL pixel belongs to the neighborhood.'
def tokenize_annotated(doc, annotation): DCNL 'Tokenize a document and add an annotation attribute to each token'
def _is_hierarchical(x): DCNL 'Checks if the first item of an array-like object is also array-like DCNL If so, we have a MultiIndex and returns True. Else returns False.'
def listen(opts): DCNL 'Attach to the pub socket and grab messages'
def column_index_from_string(column, fast=False): DCNL 'Convert a column letter into a column number (e.g. B -> 2) DCNL Excel only supports 1-3 letter column names from A -> ZZZ, so we DCNL restrict our column names to 1-3 characters, each in the range A-Z. DCNL .. note:: DCNL Fast mode is faster but does not check that all letters are capitals between A and Z'
def quietRun(cmd, **kwargs): DCNL 'Run a command and return merged stdout and stderr'
def dup_random(n, a, b, K): DCNL 'Return a polynomial of degree ``n`` with coefficients in ``[a, b]``. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.densebasic import dup_random DCNL >>> dup_random(3, -10, 10, ZZ) #doctest: +SKIP DCNL [-2, -8, 9, -4]'
def reconstruct_interp_matrix(idx, proj): DCNL 'Reconstruct interpolation matrix from ID. DCNL The interpolation matrix can be reconstructed from the ID indices and DCNL coefficients `idx` and `proj`, respectively, as:: DCNL P = numpy.hstack([numpy.eye(proj.shape[0]), proj])[:,numpy.argsort(idx)] DCNL The original matrix can then be reconstructed from its skeleton matrix `B` DCNL via:: DCNL numpy.dot(B, P) DCNL See also :func:`reconstruct_matrix_from_id` and DCNL :func:`reconstruct_skel_matrix`. DCNL ..  This function automatically detects the matrix data type and calls the DCNL appropriate backend. For details, see :func:`backend.idd_reconint` and DCNL :func:`backend.idz_reconint`. DCNL Parameters DCNL idx : :class:`numpy.ndarray` DCNL Column index array. DCNL proj : :class:`numpy.ndarray` DCNL Interpolation coefficients. DCNL Returns DCNL :class:`numpy.ndarray` DCNL Interpolation matrix.'
def no_4byte_params(f): DCNL 'Checks that no 4 byte unicode characters are allowed DCNL in dicts\' keys/values and string\'s parameters'
def device_exists_with_ips_and_mac(device_name, ip_cidrs, mac, namespace=None): DCNL 'Return True if the device with the given IP addresses and MAC address DCNL exists in the namespace.'
def index_alt(): DCNL 'Module homepage for non-Admin users when no CMS content found'
def get_indices(expr): DCNL 'Determine the outer indices of expression ``expr`` DCNL By *outer* we mean indices that are not summation indices.  Returns a set DCNL and a dict.  The set contains outer indices and the dict contains DCNL information about index symmetries. DCNL Examples DCNL >>> from sympy.tensor.index_methods import get_indices DCNL >>> from sympy import symbols DCNL >>> from sympy.tensor import IndexedBase, Idx DCNL >>> x, y, A = map(IndexedBase, [\'x\', \'y\', \'A\']) DCNL >>> i, j, a, z = symbols(\'i j a z\', integer=True) DCNL The indices of the total expression is determined, Repeated indices imply a DCNL summation, for instance the trace of a matrix A: DCNL >>> get_indices(A[i, i]) DCNL (set(), {}) DCNL In the case of many terms, the terms are required to have identical DCNL outer indices.  Else an IndexConformanceException is raised. DCNL >>> get_indices(x[i] + A[i, j]*y[j]) DCNL ({i}, {}) DCNL :Exceptions: DCNL An IndexConformanceException means that the terms ar not compatible, e.g. DCNL >>> get_indices(x[i] + y[j])                #doctest: +SKIP DCNL IndexConformanceException: Indices are not consistent: x(i) + y(j) DCNL .. warning:: DCNL The concept of *outer* indices applies recursively, starting on the deepest DCNL level.  This implies that dummies inside parenthesis are assumed to be DCNL summed first, so that the following expression is handled gracefully: DCNL >>> get_indices((x[i] + A[i, j]*y[j])*x[j]) DCNL ({i, j}, {}) DCNL This is correct and may appear convenient, but you need to be careful DCNL with this as SymPy will happily .expand() the product, if requested.  The DCNL resulting expression would mix the outer ``j`` with the dummies inside DCNL the parenthesis, which makes it a different expression.  To be on the DCNL safe side, it is best to avoid such ambiguities by using unique indices DCNL for all contractions that should be held separate.'
def WriteXmlIfChanged(content, path, encoding='utf-8', pretty=False, win32=False): DCNL 'Writes the XML content to disk, touching the file only if it has changed. DCNL Args: DCNL content:  The structured content to be written. DCNL path: Location of the file. DCNL encoding: The encoding to report on the first line of the XML file. DCNL pretty: True if we want pretty printing with indents and new lines.'
def ansible_dict_to_boto3_filter_list(filters_dict): DCNL 'Convert an Ansible dict of filters to list of dicts that boto3 can use DCNL Args: DCNL filters_dict (dict): Dict of AWS filters. DCNL Basic Usage: DCNL >>> filters = {\'some-aws-id\', \'i-01234567\'} DCNL >>> ansible_dict_to_boto3_filter_list(filters) DCNL \'some-aws-id\': \'i-01234567\' DCNL Returns: DCNL List: List of AWS filters and their values DCNL \'Name\': \'some-aws-id\', DCNL \'Values\': [ DCNL \'i-01234567\','
def _hide_frame(ax): DCNL 'Helper to hide axis frame for topomaps.'
def _auth_from_available(le_client, config, domains=None, certname=None, lineage=None): DCNL 'Authenticate and enroll certificate. DCNL This method finds the relevant lineage, figures out what to do with it, DCNL then performs that action. Includes calls to hooks, various reports, DCNL checks, and requests for user input. DCNL :returns: Tuple of (str action, cert_or_None) as per _find_lineage_for_domains_and_certname DCNL action can be: "newcert" | "renew" | "reinstall"'
def renyientropy(px, alpha=1, logbase=2, measure='R'): DCNL 'Renyi\'s generalized entropy DCNL Parameters DCNL px : array-like DCNL Discrete probability distribution of random variable X.  Note that DCNL px is assumed to be a proper probability distribution. DCNL logbase : int or np.e, optional DCNL Default is 2 (bits) DCNL alpha : float or inf DCNL The order of the entropy.  The default is 1, which in the limit DCNL is just Shannon\'s entropy.  2 is Renyi (Collision) entropy.  If DCNL the string "inf" or numpy.inf is specified the min-entropy is returned. DCNL measure : str, optional DCNL The type of entropy measure desired.  \'R\' returns Renyi entropy DCNL measure.  \'T\' returns the Tsallis entropy measure. DCNL Returns DCNL 1/(1-alpha)*log(sum(px**alpha)) DCNL In the limit as alpha -> 1, Shannon\'s entropy is returned. DCNL In the limit as alpha -> inf, min-entropy is returned.'
@pytest.mark.parametrize((u'expr', u'result'), [((lambda x, y: (x + y)), [5.0, 5.0]), ((lambda x, y: (x - y)), [(-1.0), (-1.0)]), ((lambda x, y: (x * y)), [6.0, 6.0]), ((lambda x, y: (x / y)), [(2.0 / 3.0), (2.0 / 3.0)]), ((lambda x, y: (x ** y)), [8.0, 8.0])]) DCNL def test_model_set_raises_value_error(expr, result): DCNL 'Check that creating model sets with components whose _n_models are DCNL different raise a value error'
def websettings(): DCNL 'Generate websettings'
def check_chain(table='filter', chain=None, family='ipv4'): DCNL '.. versionadded:: 2014.7.0 DCNL Check for the existence of a chain in the table DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nftables.check_chain filter input DCNL IPv6: DCNL salt \'*\' nftables.check_chain filter input family=ipv6'
def parse_format_method_string(format_string): DCNL 'Parses a PEP 3101 format string, returning a tuple of DCNL (keys, num_args, manual_pos_arg), DCNL where keys is the set of mapping keys in the format string, num_args DCNL is the number of arguments required by the format string and DCNL manual_pos_arg is the number of arguments passed with the position.'
def internalerror(): DCNL 'Returns a `500 Internal Server` error.'
def GetFlavor(params): DCNL 'Returns |params.flavor| if it\'s set, the system\'s default flavor else.'
def proportions_chisquare_pairscontrol(count, nobs, value=None, multitest_method='hs', alternative='two-sided'): DCNL 'chisquare test of proportions for pairs of k samples compared to control DCNL Performs a chisquare test for proportions for pairwise comparisons with a DCNL control (Dunnet\'s test). The control is assumed to be the first element DCNL of ``count`` and ``nobs``. The alternative is two-sided, larger or DCNL smaller. DCNL Parameters DCNL count : integer or array_like DCNL the number of successes in nobs trials. DCNL nobs : integer DCNL the number of trials or observations. DCNL prop : float, optional DCNL The probability of success under the null hypothesis, DCNL `0 <= prop <= 1`. The default value is `prop = 0.5` DCNL multitest_method : string DCNL This chooses the method for the multiple testing p-value correction, DCNL that is used as default in the results. DCNL It can be any method that is available in  ``multipletesting``. DCNL The default is Holm-Sidak \'hs\'. DCNL alternative : string in [\'two-sided\', \'smaller\', \'larger\'] DCNL alternative hypothesis, which can be two-sided or either one of the DCNL one-sided tests. DCNL Returns DCNL result : AllPairsResults instance DCNL The returned results instance has several statistics, such as p-values, DCNL attached, and additional methods for using a non-default DCNL ``multitest_method``. DCNL Notes DCNL Yates continuity correction is not available. DCNL ``value`` and ``alternative`` options are not yet implemented.'
def regions(): DCNL 'Get all available regions for the AWS Cloudtrail service. DCNL :rtype: list DCNL :return: A list of :class:`boto.regioninfo.RegionInfo`'
def upsample_2d(incoming, kernel_size, name='UpSample2D'): DCNL 'UpSample 2D. DCNL Input: DCNL 4-D Tensor [batch, height, width, in_channels]. DCNL Output: DCNL 4-D Tensor [batch, pooled height, pooled width, in_channels]. DCNL Arguments: DCNL incoming: `Tensor`. Incoming 4-D Layer to upsample. DCNL kernel_size: \'int` or `list of int`. Upsampling kernel size. DCNL name: A name for this layer (optional). Default: \'UpSample2D\'. DCNL Attributes: DCNL scope: `Scope`. This layer scope.'
def getAllDirectoriesWithFile(path, filename, excludeDirs): DCNL 'Returns a list of directories in the <path> with a given <filename>, excluding DCNL <excludeDirs>'
def plot_scatter(fig, x, y, x2, y2, binnum): DCNL 'docstring for plot_test'
def getTestOutput(): DCNL 'Returns stdout and stderr output for a console test.'
@hook.command('feed', 'rss', 'news') DCNL def rss(text): DCNL '<feed> -- Gets the first three items from the RSS/ATOM feed <feed>.'
@require_role('admin') DCNL def group_list(request): DCNL 'list asset group'
def load_plain_keyfile(filename): DCNL 'A "plain" keyfile is a file containing only the key. DCNL Any other file (JPEG, MP3, ...) can also be used as keyfile.'
def create_subnet_group(name, description, subnet_ids=None, subnet_names=None, tags=None, region=None, key=None, keyid=None, profile=None): DCNL 'Create an ElastiCache subnet group DCNL CLI example to create an ElastiCache subnet group:: DCNL salt myminion boto_elasticache.create_subnet_group my-subnet-group             "group description" subnet_ids=\'[subnet-12345678, subnet-87654321]\'             region=us-east-1'
def update(kernel=False): DCNL 'Upgrade all packages, skip obsoletes if ``obsoletes=0`` in ``yum.conf``. DCNL Exclude *kernel* upgrades by default.'
def default_locale(category=None, aliases=LOCALE_ALIASES): DCNL 'Returns the system default locale for a given category, based on DCNL environment variables. DCNL >>> for name in [\'LANGUAGE\', \'LC_ALL\', \'LC_CTYPE\']: DCNL ...     os.environ[name] = \'\' DCNL >>> os.environ[\'LANG\'] = \'fr_FR.UTF-8\' DCNL >>> default_locale(\'LC_MESSAGES\') DCNL \'fr_FR\' DCNL The "C" or "POSIX" pseudo-locales are treated as aliases for the DCNL "en_US_POSIX" locale: DCNL >>> os.environ[\'LC_MESSAGES\'] = \'POSIX\' DCNL >>> default_locale(\'LC_MESSAGES\') DCNL \'en_US_POSIX\' DCNL The following fallbacks to the variable are always considered: DCNL - ``LANGUAGE`` DCNL - ``LC_ALL`` DCNL - ``LC_CTYPE`` DCNL - ``LANG`` DCNL :param category: one of the ``LC_XXX`` environment variable names DCNL :param aliases: a dictionary of aliases for locale identifiers'
def get_sequential_open_distrib(course_id): DCNL 'Returns the number of students that opened each subsection/sequential of the course DCNL `course_id` the course ID for the course interested in DCNL Outputs a dict mapping the \'module_id\' to the number of students that have opened that subsection/sequential.'
def highlight(code, lexer, formatter, outfile=None): DCNL 'Lex ``code`` with ``lexer`` and format it with the formatter ``formatter``. DCNL If ``outfile`` is given and a valid file object (an object DCNL with a ``write`` method), the result will be written to it, otherwise DCNL it is returned as a string.'
def write_rels(worksheet, comments_id=None, vba_controls_id=None): DCNL 'Write relationships for the worksheet to xml.'
def test_ecliptic_heliobary(): DCNL 'Check that the ecliptic transformations for heliocentric and barycentric DCNL at least more or less make sense'
def plot_img_and_hist(img, axes, bins=256): DCNL 'Plot an image along with its histogram and cumulative histogram.'
def load_overrides(file_path, loaded_config=config): DCNL 'Convenience function for overriding default configuration. DCNL file_path : <string> the full path to a file containing valid DCNL JSON for configuration overrides'
@intercept_errors(UserAPIInternalError, ignore_errors=[UserAPIRequestError]) DCNL def set_user_preference(requesting_user, preference_key, preference_value, username=None): DCNL 'Update a user preference for the given username. DCNL Note: DCNL It is up to the caller of this method to enforce the contract that this method is only called DCNL with the user who made the request. DCNL Arguments: DCNL requesting_user (User): The user requesting to modify account information. Only the user with username DCNL \'username\' has permissions to modify account information. DCNL preference_key (str): The key for the user preference. DCNL preference_value (str): The value to be stored. Non-string values will be converted to strings. DCNL username (str): Optional username specifying which account should be updated. If not specified, DCNL `requesting_user.username` is assumed. DCNL Raises: DCNL UserNotFound: no user with username `username` exists (or `requesting_user.username` if DCNL `username` is not specified) DCNL UserNotAuthorized: the requesting_user does not have access to change the account DCNL associated with `username` DCNL PreferenceValidationError: the update was not attempted because validation errors were found DCNL PreferenceUpdateError: the operation failed when performing the update. DCNL UserAPIInternalError: the operation failed due to an unexpected error.'
def _process_node(node, aliases, duplicates): DCNL 'Takes a node from the tree and searchs for any previously processed DCNL duplicates. DCNL If not a duplicate, returns a stage based from that node. DCNL If a duplicate, the node is replaced with an alias to the dup stage. DCNL In both cases the tree is removed below this node (and the alias remains).'
@register.filter(is_safe=False) DCNL def yesno(value, arg=None): DCNL 'Given a string mapping values for true, false and (optionally) None, DCNL returns one of those strings according to the value: DCNL Value       Argument                Outputs DCNL ``True``    ``"yeah,no,maybe"``     ``yeah`` DCNL ``False``   ``"yeah,no,maybe"``     ``no`` DCNL ``None``    ``"yeah,no,maybe"``     ``maybe`` DCNL ``None``    ``"yeah,no"``           ``"no"`` (converts None to False DCNL if no mapping for None is given.'
def get_res_pool_ref(session, cluster): DCNL 'Get the resource pool.'
def verify(user, password): DCNL 'Returns a simple verification callback that simply verifies that the users and password match that provided'
def basic_auth(realm, users, encrypt=None, debug=False): DCNL 'If auth fails, raise 401 with a basic authentication header. DCNL realm: a string containing the authentication realm. DCNL users: a dict of the form: {username: password} or a callable returning a dict. DCNL encrypt: callable used to encrypt the password returned from the user-agent. DCNL if None it defaults to a md5 encryption.'
def url_replace_param(url, name, value): DCNL 'Replace a GET parameter in an URL'
def _contains(exp, cls): DCNL 'Does `node` contain a sub node of type `cls`'
def libvlc_hex_version(): DCNL 'Return the libvlc version in hex or 0 if unavailable.'
def index_alt(): DCNL 'Module homepage for non-Admin users when no CMS content found'
def render_openid_request(request, openid_request, return_to, trust_root=None): DCNL 'Render an OpenID authentication request.'
def _unwrap_stream(uri, timeout, scanner, requests_session): DCNL 'Get a stream URI from a playlist URI, ``uri``. DCNL Unwraps nested playlists until something that\'s not a playlist is found or DCNL the ``timeout`` is reached.'
def _read_ch_info_struct(fid, tag, shape, rlims): DCNL 'Read channel info struct tag.'
@require_POST DCNL def request_permissions(request): DCNL 'Request permission to download a resource.'
def _load_editor(caller): DCNL 'Called when the editor loads contents'
def get_redirects(redirects_filename): DCNL 'Parse the redirections and build a transitively closed map out of it'
def looks_like_a_tool(path, invalid_names=[], enable_beta_formats=False): DCNL 'Quick check to see if a file looks like it may be a tool file. DCNL Whether true in a strict sense or not, lets say the intention and DCNL purpose of this procedure is to serve as a filter - all valid tools must DCNL "looks_like_a_tool" but not everything that looks like a tool is actually DCNL a valid tool. DCNL invalid_names may be supplied in the context of the tool shed to quickly DCNL rule common tool shed XML files.'
def bin_constructor(func): DCNL 'Generates a prototype for binary construction (HEX, WKB) GEOS routines.'
@commands(u'title') DCNL @example(u'.title DCSP http://google.com', u'[ DCSP Google DCSP ] DCSP - DCSP google.com') DCNL def title_command(bot, trigger): DCNL 'Show the title or URL information for the given URL, or the last URL seen DCNL in this channel.'
def find_playlist_changes(orig_tracks, modified_tracks): DCNL 'Finds the changes between two playlists. DCNL Returns a tuple of (deletions, additions, staying). DCNL Deletions and additions are both Counters of (sid, eid) tuples; DCNL staying is a set of (sid, eid) tuples. DCNL :param old: the original playlist. DCNL :param modified: the modified playlist.'
def _find_vpcs(vpc_id=None, vpc_name=None, cidr=None, tags=None, region=None, key=None, keyid=None, profile=None): DCNL 'Given VPC properties, find and return matching VPC ids.'
def is_threshold_sequence(degree_sequence): DCNL 'Returns True if the sequence is a threshold degree seqeunce. DCNL Uses the property that a threshold graph must be constructed by DCNL adding either dominating or isolated nodes. Thus, it can be DCNL deconstructed iteratively by removing a node of degree zero or a DCNL node that connects to the remaining nodes.  If this deconstruction DCNL failes then the sequence is not a threshold sequence.'
def inception_v3(inputs, num_classes=1000, is_training=True, dropout_keep_prob=0.8, min_depth=16, depth_multiplier=1.0, prediction_fn=slim.softmax, spatial_squeeze=True, reuse=None, scope='InceptionV3'): DCNL 'Inception model from http://arxiv.org/abs/1512.00567. DCNL "Rethinking the Inception Architecture for Computer Vision" DCNL Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, DCNL Zbigniew Wojna. DCNL With the default arguments this method constructs the exact model defined in DCNL the paper. However, one can experiment with variations of the inception_v3 DCNL network by changing arguments dropout_keep_prob, min_depth and DCNL depth_multiplier. DCNL The default image size used to train this network is 299x299. DCNL Args: DCNL inputs: a tensor of size [batch_size, height, width, channels]. DCNL num_classes: number of predicted classes. DCNL is_training: whether is training or not. DCNL dropout_keep_prob: the percentage of activation values that are retained. DCNL min_depth: Minimum depth value (number of channels) for all convolution ops. DCNL Enforced when depth_multiplier < 1, and not an active constraint when DCNL depth_multiplier >= 1. DCNL depth_multiplier: Float multiplier for the depth (number of channels) DCNL for all convolution ops. The value must be greater than zero. Typical DCNL usage will be to set this value in (0, 1) to reduce the number of DCNL parameters or computation cost of the model. DCNL prediction_fn: a function to get predictions out of logits. DCNL spatial_squeeze: if True, logits is of shape is [B, C], if false logits is DCNL of shape [B, 1, 1, C], where B is batch_size and C is number of classes. DCNL reuse: whether or not the network and its variables should be reused. To be DCNL able to reuse \'scope\' must be given. DCNL scope: Optional variable_scope. DCNL Returns: DCNL logits: the pre-softmax activations, a tensor of size DCNL [batch_size, num_classes] DCNL end_points: a dictionary from components of the network to the corresponding DCNL activation. DCNL Raises: DCNL ValueError: if \'depth_multiplier\' is less than or equal to zero.'
def cmServiceAccept(): DCNL 'CM SERVICE ACCEPT Section 9.2.5'
def get_resampler_for_grouping(groupby, rule, how=None, fill_method=None, limit=None, kind=None, **kwargs): DCNL 'return our appropriate resampler when grouping as well'
@celery.task(name='redash.tasks.refresh_schemas', base=BaseTask) DCNL def refresh_schemas(): DCNL 'Refreshes the data sources schemas.'
def load_config(config_file): DCNL 'Validates the given file for use as the settings file for BGPSpeaker DCNL and loads the configuration from the given file as a module instance.'
def path_tail(apath, bpath): DCNL 'Given two paths (B is longer than A), find the part in B not in A'
def _url_replace_regex(prefix): DCNL 'Match static urls in quotes that don\'t end in \'?raw\'. DCNL To anyone contemplating making this more complicated: DCNL http://xkcd.com/1171/'
def _check_user(user, group): DCNL 'Checks if the named user and group are present on the minion'
def rmtree(path, ignore_errors=False, onerror=auto_chmod): DCNL 'Recursively delete a directory tree. DCNL This code is taken from the Python 2.4 version of \'shutil\', because DCNL the 2.3 version doesn\'t really work right.'
def debug(*args, **kwargs): DCNL 'Helper function for local debugging.'
def frame_msg(body, header=None, raw_body=False): DCNL 'Frame the given message with our wire protocol'
def _update_secret(namespace, name, data, apiserver_url): DCNL 'Replace secrets data by a new one'
def all_argmax(x): DCNL 'Return the indices of all values that are equal to the maximum: no breaking ties.'
def course(): DCNL 'Courses Controller'
def friedmanchisquare(*args): DCNL 'Friedman Chi-Square is a non-parametric, one-way within-subjects ANOVA. DCNL This function calculates the Friedman Chi-square test for repeated measures DCNL and returns the result, along with the associated probability value. DCNL Each input is considered a given group. Ideally, the number of treatments DCNL among each group should be equal. If this is not the case, only the first DCNL n treatments are taken into account, where n is the number of treatments DCNL of the smallest group. DCNL If a group has some missing values, the corresponding treatments are masked DCNL in the other groups. DCNL The test statistic is corrected for ties. DCNL Masked values in one group are propagated to the other groups. DCNL Returns DCNL statistic : float DCNL the test statistic. DCNL pvalue : float DCNL the associated p-value.'
def list_catalogs(results=30, start=0): DCNL 'Returns list of all catalogs created on this API key DCNL Args: DCNL Kwargs: DCNL results (int): An integer number of results to return DCNL start (int): An integer starting value for the result set DCNL Returns: DCNL A list of catalog objects DCNL Example: DCNL >>> catalog.list_catalogs() DCNL [<catalog - test_artist_catalog>, <catalog - test_song_catalog>, <catalog - my_songs>]'
def render(hjson_data, saltenv='base', sls='', **kws): DCNL 'Accepts HJSON as a string or as a file object and runs it through the HJSON DCNL parser. DCNL :rtype: A Python data structure'
def version(contact_points=None, port=None, cql_user=None, cql_pass=None): DCNL 'Show the Cassandra version. DCNL :param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs. DCNL :type  contact_points: str | list[str] DCNL :param cql_user:       The Cassandra user if authentication is turned on. DCNL :type  cql_user:       str DCNL :param cql_pass:       The Cassandra user password if authentication is turned on. DCNL :type  cql_pass:       str DCNL :param port:           The Cassandra cluster port, defaults to None. DCNL :type  port:           int DCNL :return:               The version for this Cassandra cluster. DCNL :rtype:                str DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'minion1\' cassandra_cql.version DCNL salt \'minion1\' cassandra_cql.version contact_points=minion1'
def tick2period(code, period, start, end): DCNL 'get tick data from tushare and resample to certain period data DCNL selected by input: period'
def test_simple_create(): DCNL 'Check __init__.'
def make_routine(name, expr, argument_sequence=None, global_vars=None, language='F95'): DCNL 'A factory that makes an appropriate Routine from an expression. DCNL Parameters DCNL name : string DCNL The name of this routine in the generated code. DCNL expr : expression or list/tuple of expressions DCNL A SymPy expression that the Routine instance will represent.  If DCNL given a list or tuple of expressions, the routine will be DCNL considered to have multiple return values and/or output arguments. DCNL argument_sequence : list or tuple, optional DCNL List arguments for the routine in a preferred order.  If omitted, DCNL the results are language dependent, for example, alphabetical order DCNL or in the same order as the given expressions. DCNL global_vars : iterable, optional DCNL Sequence of global variables used by the routine.  Variables DCNL listed here will not show up as function arguments. DCNL language : string, optional DCNL Specify a target language.  The Routine itself should be DCNL language-agnostic but the precise way one is created, error DCNL checking, etc depend on the language.  [default: "F95"]. DCNL A decision about whether to use output arguments or return values is made DCNL depending on both the language and the particular mathematical expressions. DCNL For an expression of type Equality, the left hand side is typically made DCNL into an OutputArgument (or perhaps an InOutArgument if appropriate). DCNL Otherwise, typically, the calculated expression is made a return values of DCNL the routine. DCNL Examples DCNL >>> from sympy.utilities.codegen import make_routine DCNL >>> from sympy.abc import x, y, f, g DCNL >>> from sympy import Eq DCNL >>> r = make_routine(\'test\', [Eq(f, 2*x), Eq(g, x + y)]) DCNL >>> [arg.result_var for arg in r.results] DCNL >>> [arg.name for arg in r.arguments] DCNL [x, y, f, g] DCNL >>> [arg.name for arg in r.result_variables] DCNL [f, g] DCNL >>> r.local_vars DCNL set() DCNL Another more complicated example with a mixture of specified and DCNL automatically-assigned names.  Also has Matrix output. DCNL >>> from sympy import Matrix DCNL >>> r = make_routine(\'fcn\', [x*y, Eq(f, 1), Eq(g, x + g), Matrix([[x, 2]])]) DCNL >>> [arg.result_var for arg in r.results]  # doctest: +SKIP DCNL [result_5397460570204848505] DCNL >>> [arg.expr for arg in r.results] DCNL [x*y] DCNL >>> [arg.name for arg in r.arguments]  # doctest: +SKIP DCNL [x, y, f, g, out_8598435338387848786] DCNL We can examine the various arguments more closely: DCNL >>> from sympy.utilities.codegen import (InputArgument, OutputArgument, DCNL ...                                      InOutArgument) DCNL >>> [a.name for a in r.arguments if isinstance(a, InputArgument)] DCNL [x, y] DCNL >>> [a.name for a in r.arguments if isinstance(a, OutputArgument)]  # doctest: +SKIP DCNL [f, out_8598435338387848786] DCNL >>> [a.expr for a in r.arguments if isinstance(a, OutputArgument)] DCNL [1, Matrix([[x, 2]])] DCNL >>> [a.name for a in r.arguments if isinstance(a, InOutArgument)] DCNL [g] DCNL >>> [a.expr for a in r.arguments if isinstance(a, InOutArgument)] DCNL [g + x]'
@contextmanager DCNL def temporary_folder(): DCNL 'creates a temporary folder, return it and delete it afterwards. DCNL This allows to do something like this in tests: DCNL >>> with temporary_folder() as d: DCNL # do whatever you want'
def __determine_before_str(options): DCNL 'Determine the date string for the newest timestamp to filter by.'
def get_next_page_of_all_feedback_messages(page_size=feconf.FEEDBACK_TAB_PAGE_SIZE, urlsafe_start_cursor=None): DCNL 'Fetches a single page from the list of all feedback messages that have DCNL been posted to any exploration on the site. DCNL Args: DCNL page_size: int. The number of feedback messages to display per page. DCNL Defaults to feconf.FEEDBACK_TAB_PAGE_SIZE. DCNL urlsafe_start_cursor: str or None. The cursor which represents the DCNL current position to begin the fetch from. If None, the fetch is DCNL started from the beginning of the list of all messages. DCNL Returns: DCNL tuple of (messages, new_urlsafe_start_cursor, more), where DCNL messages: list of FeedbackMessage. Contains all the messages we DCNL want. DCNL new_urlsafe_start_cursor: str. The new cursor. DCNL more: bool. Whether there are more messages available to fetch after DCNL this batch.'
def footnotes(document): DCNL 'Find footnotes in the given document, move them to the end of the body, and DCNL generate links to them. DCNL A footnote is any node with a C{class} attribute set to C{footnote}. DCNL Footnote links are generated as superscript.  Footnotes are collected in a DCNL C{ol} node at the end of the document. DCNL @type document: A DOM Node or Document DCNL @param document: The input document which contains all of the content to be DCNL presented. DCNL @return: C{None}'
def main(argv=None): DCNL 'Main Entry'
def group_remove(groupname, user=None, host=None, port=None, maintenance_db=None, password=None, runas=None): DCNL 'Removes a group from the Postgres server. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' postgres.group_remove \'groupname\''
def sem(a, axis=0, ddof=1, nan_policy='propagate'): DCNL 'Calculates the standard error of the mean (or standard error of DCNL measurement) of the values in the input array. DCNL Parameters DCNL a : array_like DCNL An array containing the values for which the standard error is DCNL returned. DCNL axis : int or None, optional DCNL Axis along which to operate. Default is 0. If None, compute over DCNL the whole array `a`. DCNL ddof : int, optional DCNL Delta degrees-of-freedom. How many degrees of freedom to adjust DCNL for bias in limited samples relative to the population estimate DCNL of variance. Defaults to 1. DCNL nan_policy : {\'propagate\', \'raise\', \'omit\'}, optional DCNL Defines how to handle when input contains nan. \'propagate\' returns nan, DCNL \'raise\' throws an error, \'omit\' performs the calculations ignoring nan DCNL values. Default is \'propagate\'. DCNL Returns DCNL s : ndarray or float DCNL The standard error of the mean in the sample(s), along the input axis. DCNL Notes DCNL The default value for `ddof` is different to the default (0) used by other DCNL ddof containing routines, such as np.std and np.nanstd. DCNL Examples DCNL Find standard error along the first axis: DCNL >>> from scipy import stats DCNL >>> a = np.arange(20).reshape(5,4) DCNL >>> stats.sem(a) DCNL array([ 2.8284,  2.8284,  2.8284,  2.8284]) DCNL Find standard error across the whole array, using n degrees of freedom: DCNL >>> stats.sem(a, axis=None, ddof=0) DCNL 1.2893796958227628'
def safe_open_w(path): DCNL 'Open "path" for writing, creating any parent directories as needed.'
def _get_data_volumes(vm_): DCNL 'Construct a list of optional data volumes from the cloud profile'
def encode_notifications(tokens, notifications): DCNL 'Returns the encoded bytes of tokens and notifications DCNL tokens          a list of tokens or a string of only one token DCNL notifications   a list of notifications or a dictionary of only one'
def _upgrade_from_setuptools(python_cmd, use_sudo): DCNL 'Upgrading from setuptools 0.6 to 0.7+ is supported'
def fnames_presuffix(fnames, prefix=u'', suffix=u'', newpath=None, use_ext=True): DCNL 'Calls fname_presuffix for a list of files.'
@ensure_csrf_cookie DCNL @cache_control(no_cache=True, no_store=True, must_revalidate=True) DCNL @coach_dashboard DCNL def dashboard(request, course, ccx=None): DCNL 'Display the CCX Coach Dashboard.'
def publish_progress(*args, **kwargs): DCNL 'Show the user progress for a long request DCNL :param percent: Percent progress DCNL :param title: Title DCNL :param doctype: Optional, for DocType DCNL :param name: Optional, for Document name'
def _url_as_string(url): DCNL 'Returns the URL string from a URL value that is either a string or DCNL urllib2.Request.. DCNL @param url: URL DCNL @type url: basestring or urllib2.Request DCNL @return: URL string DCNL @rtype: basestring'
def remove_elasticbeanstalk(): DCNL 'Removes elastic beanstalk components'
def _poll_for(fd, readable, writable, error, timeout): DCNL 'Poll polling backend. DCNL @param fd: File descriptor DCNL @type fd: int DCNL @param readable: Whether to wait for readability DCNL @type readable: bool DCNL @param writable: Whether to wait for writability DCNL @type writable: bool DCNL @param timeout: Deadline timeout (expiration time, in seconds) DCNL @type timeout: float DCNL @return True on success, False on timeout'
def use_resources(num_threads, num_gb): DCNL 'Function to execute multiple use_gb_ram functions in parallel'
@requires_good_network DCNL def test_megsim(): DCNL 'Test MEGSIM URL handling'
def get_async_pillar(opts, grains, minion_id, saltenv=None, ext=None, funcs=None, pillar=None, pillarenv=None): DCNL 'Return the correct pillar driver based on the file_client option'
def __virtual__(): DCNL 'Only work on Mac OS and Windows'
def generate_jmx_configs(agentConfig, hostname, checknames=None): DCNL 'Similar logic to load_check_directory for JMX checks'
def parse_propspec(propspec): DCNL 'Parses property specifications.  Returns sequence of 2-tuples, each DCNL containing a managed object type and a list of properties applicable DCNL to that type DCNL :type propspec: collections.Sequence DCNL :rtype: collections.Sequence'
def NormalizeString(value): DCNL 'Lowers case, removes punctuation and collapses whitespace.'
def create_index(): DCNL 'create index for books_fs.book_detail'
def geoserver_pre_delete(instance, sender, **kwargs): DCNL 'Removes the layer from GeoServer'
def read_valuation(s, encoding=None): DCNL 'Convert a valuation string into a valuation. DCNL :param s: a valuation string DCNL :type s: str DCNL :param encoding: the encoding of the input string, if it is binary DCNL :type encoding: str DCNL :return: a ``nltk.sem`` valuation DCNL :rtype: Valuation'
def _context_dict_to_string(context): DCNL 'Converts an SELinux file context from a dict to a string.'
def addElementToPixelList(element, pixelDictionary, x, y): DCNL 'Add an element to the pixel list.'
def _get_address_binary(address): DCNL 'Provides the binary value for an IPv4 or IPv6 address. DCNL :returns: **str** with the binary representation of this address DCNL :raises: **ValueError** if address is neither an IPv4 nor IPv6 address'
def is_enabled(iface): DCNL 'Returns ``True`` if interface is enabled, otherwise ``False`` DCNL CLI Example: DCNL .. code-block:: bash DCNL salt -G \'os_family:Windows\' ip.is_enabled \'Local Area Connection #2\''
def adjacency_data(G, attrs=_attrs): DCNL 'Return data in adjacency format that is suitable for JSON serialization DCNL and use in Javascript documents. DCNL Parameters DCNL G : NetworkX graph DCNL attrs : dict DCNL A dictionary that contains two keys \'id\' and \'key\'. The corresponding DCNL values provide the attribute names for storing NetworkX-internal graph DCNL data. The values should be unique. Default value: DCNL :samp:`dict(id=\'id\', key=\'key\')`. DCNL If some user-defined graph data use these attribute names as data keys, DCNL they may be silently dropped. DCNL Returns DCNL data : dict DCNL A dictionary with adjacency formatted data. DCNL Raises DCNL NetworkXError DCNL If values in attrs are not unique. DCNL Examples DCNL >>> from networkx.readwrite import json_graph DCNL >>> G = nx.Graph([(1,2)]) DCNL >>> data = json_graph.adjacency_data(G) DCNL To serialize with json DCNL >>> import json DCNL >>> s = json.dumps(data) DCNL Notes DCNL Graph, node, and link attributes will be written when using this format DCNL but attribute keys must be strings if you want to serialize the resulting DCNL data with JSON. DCNL The default value of attrs will be changed in a future release of NetworkX. DCNL See Also DCNL adjacency_graph, node_link_data, tree_data'
def network_delete_safe(context, network_id): DCNL 'Delete network with key network_id. DCNL This method assumes that the network is not associated with any project'
def _check_cron(user, path, mask, cmd): DCNL 'Return the changes'
def frozen(*args): DCNL 'Dummy method for raising errors when trying to modify frozen graphs'
@permission_required([('Apps', 'ReadAbuse')]) DCNL def queue_abuse(request): DCNL 'Queue for reviewing abuse reports for apps.'
def api_get_manageable_volumes(*args, **kwargs): DCNL 'Replacement for cinder.volume.api.API.get_manageable_volumes.'
def numpy_cupy_array_less(err_msg='', verbose=True, name='xp', type_check=True, accept_error=False): DCNL 'Decorator that checks the CuPy result is less than NumPy result. DCNL Args: DCNL err_msg(str): The error message to be printed in case of failure. DCNL verbose(bool): If ``True``, the conflicting values are DCNL appended to the error message. DCNL name(str): Argument name whose value is either DCNL ``numpy`` or ``cupy`` module. DCNL type_check(bool): If ``True``, consistency of dtype is also checked. DCNL accept_error(bool, Exception or tuple of Exception): Sepcify DCNL acceptable errors. When both NumPy test and CuPy test raises the DCNL same type of errors, and the type of the errors is specified with DCNL this argument, the errors are ignored and not raised. DCNL If it is ``True`` all error types are acceptable. DCNL If it is ``False`` no error is acceptable. DCNL Decorated test fixture is required to return the smaller array DCNL when ``xp`` is ``cupy`` than the one when ``xp`` is ``numpy``. DCNL .. seealso:: :func:`cupy.testing.assert_array_less`'
def custom_verify_access_cookie(zmirror_verify_cookie, flask_request): DCNL 'verify user\'s access cookie. return True for access granted, False for denied DCNL See option `enable_custom_access_cookie_generate_and_verify` DCNL :param zmirror_verify_cookie: cookie string DCNL :param flask_request: the flask request object DCNL :type zmirror_verify_cookie: str DCNL :return: bool'
def releaseMsToNet(Cause_presence=0, Cause_presence1=0, Facility_presence=0, UserUser_presence=0, SsVersionIndicator_presence=0): DCNL 'RELEASE Section 9.3.18.2'
def printExc(msg='', indent=4, prefix='|'): DCNL 'Print an error message followed by an indented exception backtrace DCNL (This function is intended to be called within except: blocks)'
def makeMissingCustomDataframe(nrows, ncols, density=0.9, random_state=None, c_idx_names=True, r_idx_names=True, c_idx_nlevels=1, r_idx_nlevels=1, data_gen_f=None, c_ndupe_l=None, r_ndupe_l=None, dtype=None, c_idx_type=None, r_idx_type=None): DCNL 'Parameters DCNL Density : float, optional DCNL Float in (0, 1) that gives the percentage of non-missing numbers in DCNL the DataFrame. DCNL random_state : {np.random.RandomState, int}, optional DCNL Random number generator or random seed. DCNL See makeCustomDataframe for descriptions of the rest of the parameters.'
def get_review_type(file_): DCNL 'Return \'full\' or None depending on the file/addon status.'
def postreleaser_middle(data): DCNL 'postreleaser.middle hook to update the setup.py with the new version. See DCNL prereleaser_middle for more details.'
def idle(priority=0): DCNL 'Cause the calling greenlet to wait until the event loop is idle. DCNL Idle is defined as having no other events of the same or higher DCNL *priority* pending. That is, as long as sockets, timeouts or even DCNL signals of the same or higher priority are being processed, the loop DCNL is not idle. DCNL .. seealso:: :func:`sleep`'
def test_run_srs(*sr_names): DCNL 'Inject Subreddits by name into the index'
def document_custom_method(section, method_name, method): DCNL 'Documents a non-data driven method DCNL :param section: The section to write the documentation to. DCNL :param method_name: The name of the method DCNL :param method: The handle to the method being documented'
def make_rng(rng_or_seed=None, default_seed=None, which_method=None, constructor=None): DCNL 'Returns a RNG object. DCNL Parameters DCNL rng_or_seed : RNG object or integer or list of integers DCNL A random number generator or a valid seed. DCNL default_seed : integer or list of integers DCNL Seed used if rng_or_seed is None DCNL which_method : string or list of strings DCNL One or more methods that must be defined by the RNG object. DCNL If one or more specified methods are not defined by it, a DCNL new one will be constructed with the given constructor. DCNL constructor : function or class DCNL Must return a RNG object. DCNL constructor is called with rng_or_seed, default_seed or 42 DCNL as argument. DCNL Notes DCNL The RNG object is generated using the first of these cases that produces a DCNL valid result and doesn\'t use an argument with the value of None: DCNL 1) rng_or_seed itself DCNL 2) constructor(rng_or_seed) DCNL 3) constructor(default_seed) DCNL 4) constructor(42)'
def invert(d): DCNL 'Invert a dictionary into a dictionary of sets. DCNL >>> invert({\'a\': 1, \'b\': 2, \'c\': 1})  # doctest: +SKIP DCNL {1: {\'a\', \'c\'}, 2: {\'b\'}}'
@yield_once DCNL def _iter_choices(pattern): DCNL 'Iterate through each choice of an alternative. Splits pattern on \'|\'s if DCNL they are not bracketed. DCNL :param pattern: String of choices separated by \'|\'s DCNL :return:        Iterator that yields parts of string separated by DCNL non-bracketed \'|\'s'
def tags_for(cls, model, instance=None, **extra_filters): DCNL 'Sadly copied from taggit to work around the issue of not being DCNL able to use the TaggedItemBase class that has tag field already DCNL defined.'
def register_babel(app): DCNL 'Configure Babel for internationality.'
def _extend_mode_to_code(mode): DCNL 'Convert an extension mode to the corresponding integer code.'
def make_nditer_cls(nditerty): DCNL 'Return the Structure representation of the given *nditerty* (an DCNL instance of types.NumpyNdIterType).'
def null_javascript_catalog(request, domain=None, packages=None): DCNL 'Returns "identity" versions of the JavaScript i18n functions -- i.e., DCNL versions that don\'t actually do anything.'
@lru_cache(1000) DCNL def traversal_path_info(path): DCNL 'Given``path``, return a tuple representing that path which can be DCNL used to traverse a resource tree.  ``path`` is assumed to be an DCNL already-URL-decoded ``str`` type as if it had come to us from an upstream DCNL WSGI server as the ``PATH_INFO`` environ variable. DCNL The ``path`` is first decoded to from its WSGI representation to Unicode; DCNL it is decoded differently depending on platform: DCNL - On Python 2, ``path`` is decoded to Unicode from bytes using the UTF-8 DCNL decoding directly; a :exc:`pyramid.exc.URLDecodeError` is raised if a the DCNL URL cannot be decoded. DCNL - On Python 3, as per the PEP 3333 spec, ``path`` is first encoded to DCNL bytes using the Latin-1 encoding; the resulting set of bytes is DCNL subsequently decoded to text using the UTF-8 encoding; a DCNL :exc:`pyramid.exc.URLDecodeError` is raised if a the URL cannot be DCNL decoded. DCNL The ``path`` is split on slashes, creating a list of segments.  If a DCNL segment name is empty or if it is ``.``, it is ignored.  If a segment DCNL name is ``..``, the previous segment is deleted, and the ``..`` is DCNL ignored. DCNL Examples: DCNL ``/foo/bar/baz`` DCNL (u\'foo\', u\'bar\', u\'baz\') DCNL ``foo/bar/baz`` DCNL (u\'foo\', u\'bar\', u\'baz\') DCNL ``/foo/bar/baz/`` DCNL (u\'foo\', u\'bar\', u\'baz\') DCNL ``/foo//bar//baz/`` DCNL (u\'foo\', u\'bar\', u\'baz\') DCNL ``/foo/bar/baz/..`` DCNL (u\'foo\', u\'bar\') DCNL ``/my%20archives/hello`` DCNL (u\'my archives\', u\'hello\') DCNL ``/archives/La%20Pe%C3%B1a`` DCNL (u\'archives\', u\'<unprintable unicode>\') DCNL .. note:: DCNL This function does not generate the same type of tuples that DCNL :func:`pyramid.traversal.resource_path_tuple` does.  In particular, the DCNL leading empty string is not present in the tuple it returns, unlike tuples DCNL returned by :func:`pyramid.traversal.resource_path_tuple`.  As a result, DCNL tuples generated by ``traversal_path`` are not resolveable by the DCNL :func:`pyramid.traversal.find_resource` API.  ``traversal_path`` is a DCNL function mostly used by the internals of :app:`Pyramid` and by people DCNL writing their own traversal machinery, as opposed to users writing DCNL applications in :app:`Pyramid`.'
def test_ada_wrong_nn_obj(): DCNL 'Test either if an error is raised while passing a wrong NN object'
@utils.arg('monitor_id', metavar='<monitor-id>', help='ID DCSP of DCSP the DCSP monitor DCSP to DCSP snapshot') DCNL @utils.arg('--force', metavar='<True|False>', help="Optional DCSP flag DCSP to DCSP indicate DCSP whether DCSP to DCSP snapshot DCSP a DCSP monitor DCSP even DCSP if DCSP it's DCSP attached DCSP to DCSP an DCSP instance. DCSP (Default=False)", default=False) DCNL @utils.arg('--display-name', metavar='<display-name>', default=None, help='Optional DCSP snapshot DCSP name. DCSP (Default=None)') DCNL @utils.arg('--display_name', help=argparse.SUPPRESS) DCNL @utils.arg('--display-description', metavar='<display-description>', default=None, help='Optional DCSP snapshot DCSP description. DCSP (Default=None)') DCNL @utils.arg('--display_description', help=argparse.SUPPRESS) DCNL @utils.service_type('monitor') DCNL def do_snapshot_create(cs, args): DCNL 'Add a new snapshot.'
def get(key, default='', delimiter=DEFAULT_TARGET_DELIM, ordered=True): DCNL 'Attempt to retrieve the named value from grains, if the named value is not DCNL available return the passed default. The default return is an empty string. DCNL The value can also represent a value in a nested dict using a ":" delimiter DCNL for the dict. This means that if a dict in grains looks like this:: DCNL {\'pkg\': {\'apache\': \'httpd\'}} DCNL To retrieve the value associated with the apache key in the pkg dict this DCNL key can be passed:: DCNL pkg:apache DCNL :param delimiter: DCNL Specify an alternate delimiter to use when traversing a nested dict DCNL .. versionadded:: 2014.7.0 DCNL :param ordered: DCNL Outputs an ordered dict if applicable (default: True) DCNL .. versionadded:: 2016.11.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' grains.get pkg:apache'
def breakfast(): DCNL 'Serves a Pythonic breakfast'
@register.tag DCNL def comment(parser, token): DCNL 'Ignores everything between ``{% comment %}`` and ``{% endcomment %}``.'
def get_field(data, param, linestart='', sep=' DCSP '): DCNL 'Parse data from string. DCNL :param data: Data to parse. DCNL example: DCNL data: DCNL cpu   324 345 34  5 345 DCNL cpu0  34  11  34 34  33 DCNL start of line DCNL params 0   1   2  3   4 DCNL :param param: Position of parameter after linestart marker. DCNL :param linestart: String to which start line with parameters. DCNL :param sep: Separator between parameters regular expression.'
def GetVersionObject(): DCNL 'Gets the version of the SDK by parsing the VERSION file. DCNL Returns: DCNL A Yaml object or None if the VERSION file does not exist.'
def configure_sc_logging(use_syslog=False): DCNL 'Configure logging for StarCluster *application* code DCNL By default StarCluster\'s logger has no formatters and a NullHandler so that DCNL other developers using StarCluster as a library can configure logging as DCNL they see fit. This method is used in StarCluster\'s application code (i.e. DCNL the \'starcluster\' command) to toggle StarCluster\'s application specific DCNL formatters/handlers DCNL use_syslog - enable logging all messages to syslog. currently only works if DCNL /dev/log exists on the system (standard for most Linux distros)'
def validate_color(s): DCNL 'return a valid color arg'
def dict_error_formatting(errors, index=None): DCNL 'Formats all dictionary error messages for both single and bulk requests'
def main(args=None): DCNL 'Run the main command-line interface for beets. Includes top-level DCNL exception handlers that print friendly error messages.'
def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=None, mode='w'): DCNL 'Create a zip file from all the files under \'base_dir\'.  The output DCNL zip file will be named \'base_dir\' + ".zip".  Uses either the "zipfile" DCNL Python module (if available) or the InfoZIP "zip" utility (if installed DCNL and found on the default search path).  If neither tool is available, DCNL raises DistutilsExecError.  Returns the name of the output zip file.'
def timeBoundExecution(algo, maxtime): DCNL 'wrap the algo, to stop execution after it has used all its allocated time'
def update_hash_dict(filehash, filename): DCNL 'Opens the pickled hash dictionary, adds an entry, and dumps it back.'
def _manageRoles(mo): DCNL 'Perform some transformation on the html, so that roleIDs can DCNL be easily retrieved.'
@deprecated(u'1.0', message=DEPRECATION_MESSAGE) DCNL def join(left, right, keys=None, join_type=u'inner', uniq_col_name=u'{col_name}_{table_name}', table_names=[u'1', u'2'], col_name_map=None): DCNL 'Perform a join of the left and right numpy structured array on specified keys. DCNL Parameters DCNL left : structured array DCNL Left side table in the join DCNL right : structured array DCNL Right side table in the join DCNL keys : str or list of str DCNL Name(s) of column(s) used to match rows of left and right tables. DCNL Default is to use all columns which are common to both tables. DCNL join_type : str DCNL Join type (\'inner\' | \'outer\' | \'left\' | \'right\'), default is \'inner\' DCNL uniq_col_name : str or None DCNL String generate a unique output column name in case of a conflict. DCNL The default is \'{col_name}_{table_name}\'. DCNL table_names : list of str or None DCNL Two-element list of table names used when generating unique output DCNL column names.  The default is [\'1\', \'2\']. DCNL col_name_map : empty dict or None DCNL If passed as a dict then it will be updated in-place with the DCNL mapping of output to input column names.'
@gof.local_optimizer([AdvancedIncSubtensor1], inplace=True) DCNL def local_inplace_incsubtensor1(node): DCNL 'Also work for GpuAdvancedIncSubtensor1.'
def scan(entry, max_depth=3, scan_filter=None, depth=0): DCNL 'Scan a path for videos and subtitles DCNL :param string entry: path DCNL :param int max_depth: maximum folder depth DCNL :param function scan_filter: filter function that takes a path as argument and returns a boolean indicating whether it has to be filtered out (``True``) or not (``False``) DCNL :param int depth: starting depth DCNL :return: found videos and subtitles DCNL :rtype: list of (:class:`Video`, [:class:`~subliminal.subtitles.Subtitle`])'
def resnet_v2_101(inputs, num_classes=None, is_training=True, global_pool=True, output_stride=None, reuse=None, scope='resnet_v2_101'): DCNL 'ResNet-101 model of [1]. See resnet_v2() for arg and return description.'
def list_option(option, opt, value, parser): DCNL 'Callback for `make_option` for `ogrinspect` keywords that require DCNL a string list.  If the string is \'True\'/\'true\' then the option DCNL value will be a boolean instead.'
def is_primary_language(language=None): DCNL 'Returns true if current or passed language is the primary language for this DCNL site.  (The primary language is defined as the first language in DCNL settings.LANGUAGES.)'
def make_filter(name, op, values): DCNL 'Constructs a FilterPredicate from the given name, op and values. DCNL Args: DCNL name: A non-empty string, the name of the property to filter. DCNL op: One of PropertyFilter._OPERATORS.keys(), the operator to use. DCNL values: A supported value, the value to compare against. DCNL Returns: DCNL if values is a list, a CompositeFilter that uses AND to combine all DCNL values, otherwise a PropertyFilter for the single value. DCNL Raises: DCNL datastore_errors.BadPropertyError: if the property name is invalid. DCNL datastore_errors.BadValueError: if the property did not validate correctly DCNL or the value was an empty list. DCNL Other exception types (like OverflowError): if the property value does not DCNL meet type-specific criteria.'
def effective_request_host(request): DCNL 'Return the effective request-host, as defined by RFC 2965.'
def enabled(name='allprofiles'): DCNL 'Enable all the firewall profiles (Windows only)'
@step(u'{word:w} DCSP step DCSP fails DCSP with DCSP "{message}"') DCNL def step_fails_with_message(context, word, message): DCNL 'Step that always fails, mostly needed in examples.'
def deploy_application(war_file, webapp_path=None): DCNL 'Deploy an application into the webapp path for a Tomcat installation.'
def except_keyword(source, start, keyword): DCNL 'Returns position after keyword if found else None DCNL Note: skips white space'
def _resolve(name): DCNL 'Resolve a dotted name to a global object.'
def graphsize_args_report(unique_kmers, fp_rate): DCNL 'Assemble output string for optimal arg sandbox scripts. DCNL - unique_kmers: number of uniqe k-mers DCNL - fp_rate: desired false positive rate'
def _euclidean_algorithm(f, g, minpoly, p): DCNL 'Compute the monic GCD of two univariate polynomials in DCNL `\mathbb{Z}_p[z]/(\check m_{\alpha}(z))[x]` with the Euclidean DCNL Algorithm. DCNL In general, `\check m_{\alpha}(z)` is not irreducible, so it is possible DCNL that some leading coefficient is not invertible modulo DCNL `\check m_{\alpha}(z)`. In that case ``None`` is returned. DCNL Parameters DCNL f, g : PolyElement DCNL polynomials in `\mathbb Z[x, z]` DCNL minpoly : PolyElement DCNL polynomial in `\mathbb Z[z]`, not necessarily irreducible DCNL p : Integer DCNL prime number, modulus of `\mathbb Z_p` DCNL Returns DCNL h : PolyElement DCNL GCD of `f` and `g` in `\mathbb Z[z, x]` or ``None``, coefficients DCNL are in `\left[ -\frac{p-1} 2, \frac{p-1} 2 \right]`'
def log(txt): DCNL 'Logs fatal errors to a log file if WSGI_LOG env var is defined'
def _draw_epochs_axes(epoch_idx, good_ch_idx, bad_ch_idx, data, times, axes, title_str, axes_handler): DCNL 'Handle drawing epochs axes.'
def check_cuda(feature_name='You DCSP are DCSP using DCSP code DCSP that DCSP relies DCSP on DCSP cuda-convnet. DCSP Cuda-convnet', check_enabled=True): DCNL 'Call this function before sections of code that depend on the cuda_convnet module. DCNL It will raise a RuntimeError if the GPU is not available. DCNL feature_name: The name of the feature the user should be told is unavailable.'
def install(packages, update=False, options=None): DCNL 'Install one or more packages. DCNL If *update* is ``True``, the package definitions will be updated DCNL first, using :py:func:`~fabtools.opkg.update_index`. DCNL Extra *options* may be passed to ``opkg`` if necessary. DCNL Example:: DCNL import fabtools DCNL # Update index, then install a single package DCNL fabtools.opkg.install(\'build-essential\', update=True) DCNL # Install multiple packages DCNL fabtools.opkg.install([ DCNL \'mc\', DCNL \'htop\','
def token_get(profile=None, **connection_args): DCNL 'Return the configured tokens (keystone token-get) DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' keystone.token_get c965f79c4f864eaaa9c3b41904e67082'
def patch_vary_headers(response, newheaders): DCNL 'Adds (or updates) the "Vary" header in the given HttpResponse object. DCNL newheaders is a list of header names that should be in "Vary". Existing DCNL headers in "Vary" aren\'t removed.'
def vertical_flip(image_data, output_encoding=PNG, quality=None, correct_orientation=UNCHANGED_ORIENTATION, rpc=None, transparent_substitution_rgb=None): DCNL 'Flip the image vertically. DCNL Args: DCNL image_data: str, source image data. DCNL output_encoding: a value from OUTPUT_ENCODING_TYPES. DCNL quality: A value between 1 and 100 to specify the quality of the DCNL encoding.  This value is only used for JPEG quality control. DCNL correct_orientation: one of ORIENTATION_CORRECTION_TYPE, to indicate if DCNL orientation correction should be performed during the transformation. DCNL rpc: An Optional UserRPC object DCNL transparent_substition_rgb: When transparent pixels are not support in the DCNL destination image format then transparent pixels will be substituted DCNL for the specified color, which must be 32 bit rgb format. DCNL Raises: DCNL Error when something went wrong with the call.  See Image.ExecuteTransforms DCNL for more details.'
@receiver(post_save, sender=settings.AUTH_USER_MODEL) DCNL def user_post_save(sender, **kwargs): DCNL 'After User.save is called we check to see if it was a created user. If so, DCNL we check if the User object wants account creation. If all passes we DCNL create an Account object. DCNL We only run on user creation to avoid having to check for existence on DCNL each call to User.save.'
def compare_code_with_srcfile(pyc_filename, src_filename): DCNL 'Compare a .pyc with a source code file.'
def _plot_option_logic(plot_options_from_call_signature): DCNL 'Given some plot_options as part of a plot call, decide on final options. DCNL Precedence: DCNL 1 - Start with DEFAULT_PLOT_OPTIONS DCNL 2 - Update each key with ~/.plotly/.config options (tls.get_config) DCNL 3 - Update each key with session plot options (set by py.sign_in) DCNL 4 - Update each key with plot, iplot call signature options'
def _parse_tdim(tdim): DCNL 'Parse the ``TDIM`` value into a tuple (may return an empty tuple if DCNL the value ``TDIM`` value is empty or invalid).'
@atomic DCNL def create_version_for_upload(addon, upload, channel): DCNL 'Note this function is only used for API uploads.'
def _list_removed(old, new): DCNL 'List the packages which have been removed between the two package objects'
@requires_segment_info DCNL def workspace(pl, segment_info, workspace=None, strip=False): DCNL 'Return the specified workspace name DCNL :param str workspace: DCNL Specifies which workspace to show. If unspecified, may be set by the DCNL ``list_workspaces`` lister if used, otherwise falls back to DCNL currently focused workspace. DCNL :param bool strip: DCNL Specifies whether workspace numbers (in the ``1: name`` format) should DCNL be stripped from workspace names before being displayed. Defaults to false. DCNL Highlight groups used: ``workspace`` or ``w_visible``, ``workspace`` or ``w_focused``, ``workspace`` or ``w_urgent``.'
def write_feed(file_obj): DCNL 'Writes feed contents info provided file object'
def nextprime(n, ith=1): DCNL 'Return the ith prime greater than n. DCNL i must be an integer. DCNL Notes DCNL Potential primes are located at 6*j +/- 1. This DCNL property is used during searching. DCNL >>> from sympy import nextprime DCNL >>> [(i, nextprime(i)) for i in range(10, 15)] DCNL [(10, 11), (11, 13), (12, 13), (13, 17), (14, 17)] DCNL >>> nextprime(2, ith=2) # the 2nd prime after 2 DCNL 5 DCNL See Also DCNL prevprime : Return the largest prime smaller than n DCNL primerange : Generate all primes in a given range'
def process_files_and_demultiplex_sequences(mapping_file, fasta_files, qual_files, output_dir='./', keep_barcode=False, barcode_type='golay_12', max_bc_errors=0.5, start_index=1, write_unassigned_reads=False, disable_bc_correction=False, added_demultiplex_field=None, save_barcode_frequencies=False): DCNL 'Handles file IO, calls main demultiplexing function DCNL mapping_file:  filepath to metadata mapping file. DCNL fasta_files:  list of fasta filepaths DCNL qual_files: list of qual filepaths DCNL output_dir:  output directory to write all output files. DCNL keep_barcode:  If True, will not remove barcode from output files. DCNL barcode_type:  Specified barcode, can be golay_12, hamming_8, DCNL variable_length, or an integer specifying length. DCNL max_bc_errors:  Number of changes allowed for error correcting barcodes, DCNL for generic barcodes, specifies the number of mismatches allowed. DCNL start_index:  Specifies the first number used to enumerate output sequences. DCNL write_unassigned_reads:  If True, will write sequences that could not be DCNL demultiplexed into a separate output file. DCNL disable_bc_correction:  Only tests for exact matches to barcodes. DCNL added_demultiplex_field:  Uses data supplied in metadata mapping field DCNL and demultiplexes according to data in fasta labels. DCNL save_barcode_frequencies:  Saves the frequencies of barcode sequences in DCNL a separate output file.'
def prompt_for_password(args): DCNL 'if no password is specified on the command line, prompt for it'
def make_ip_network(port, network): DCNL 'Make an IPNetwork object from port and network. DCNL Function returns IPNetwork object containing fixed IP address from port DCNL dictionary with prefixlen from network object. DCNL :param port: Port dictionary returned by Neutron API DCNL :param network: IPNetwork object in which the port\'s IP will be assigned.'
def makeUnicode(text): DCNL 'Convert text to printable Unicode string. For byte string (type \'str\'), DCNL use charset ISO-8859-1 for the conversion to Unicode DCNL >>> makeUnicode(u\'abc\0d\') DCNL u\'abc\\0d\' DCNL >>> makeUnicode(\'a\xe9\') DCNL u\'a\xe9\''
def beacon(config): DCNL 'Check if current number of sessions of a server for a specific haproxy backend DCNL is over a defined threshold. DCNL .. code-block:: yaml DCNL beacons: DCNL haproxy: DCNL - www-backend: DCNL threshold: 45 DCNL servers: DCNL - web1 DCNL - web2 DCNL - interval: 120'
@cli.command() DCNL @click.argument('url') DCNL def locate(url): DCNL 'Opens a file or URL In the default application.'
def wait_for_login(client, host, port, username, password, prompt, linesep='\n', log_filename=None, timeout=240, internal_timeout=10, interface=None): DCNL 'Make multiple attempts to log into a remote host (guest) until one succeeds DCNL or timeout expires. DCNL :param timeout: Total time duration to wait for a successful login DCNL :param internal_timeout: The maximal time duration (in seconds) to wait for DCNL each step of the login procedure (e.g. the "Are you sure" prompt DCNL or the password prompt) DCNL :interface: The interface the neighbours attach to (only use when using ipv6 DCNL linklocal address.) DCNL :see:: remote_login() DCNL :raise: Whatever remote_login() raises DCNL :return: A ShellSession object.'
@cli.command() DCNL @click.argument('result-file', type=click.Path(exists=True), required=True) DCNL def plot(result_file): DCNL 'draw result DataFrame'
def get_service(hass, config, discovery_info=None): DCNL 'Get the mail notification service.'
def package_data(pkg, root_list): DCNL 'Generic function to find package_data for `pkg` under `root`.'
def copyfileobj(fsrc, fdst, length=(64 * 1024)): DCNL 'copy data from file-like object fsrc to file-like object fdst'
def training(): DCNL 'Training Controller - used for Searching for Participants'
def map_download(request, mapid, template='maps/map_download.html'): DCNL 'Download all the layers of a map as a batch DCNL XXX To do, remove layer status once progress id done DCNL This should be fix because'
def run_cmd(cmd): DCNL 'Run a command DCNL @param str cmd command DCNL @return str output DCNL @raise Exception if return code is not 0'
def test_issue595(): DCNL 'Test lemmatization of base forms'
def fetch_from_url_to_file(url, config, output_file, data=None, handlers=None): DCNL 'Writes data retrieved from a URL to a file. DCNL @param url: URL to attempt to open DCNL @type url: basestring DCNL @param config: SSL context configuration DCNL @type config: Configuration DCNL @param output_file: output file DCNL @type output_file: basestring DCNL @return: tuple ( DCNL returned HTTP status code or 0 if an error occurred DCNL returned message DCNL boolean indicating whether access was successful)'
def flag_calls(func): DCNL 'Wrap a function to detect and flag when it gets called. DCNL This is a decorator which takes a function and wraps it in a function with DCNL a \'called\' attribute. wrapper.called is initialized to False. DCNL The wrapper.called attribute is set to False right before each call to the DCNL wrapped function, so if the call fails it remains False.  After the call DCNL completes, wrapper.called is set to True and the output is returned. DCNL Testing for truth in wrapper.called allows you to determine if a call to DCNL func() was attempted and succeeded.'
def softmax(X, copy=True): DCNL 'Calculate the softmax function. DCNL The softmax function is calculated by DCNL np.exp(X) / np.sum(np.exp(X), axis=1) DCNL This will cause overflow when large values are exponentiated. DCNL Hence the largest value in each row is subtracted from each data DCNL point to prevent this. DCNL Parameters DCNL X : array-like, shape (M, N) DCNL Argument to the logistic function DCNL copy : bool, optional DCNL Copy X or not. DCNL Returns DCNL out : array, shape (M, N) DCNL Softmax function evaluated at every point in x'
def new_scratch_buffer(text): DCNL 'Create a new scratch buffer with the text given.'
def AD(barDs, count): DCNL 'Chaikin A/D Line'
def iso8601_from_timestamp(timestamp, microsecond=False): DCNL 'Returns an iso8601 formatted date from timestamp.'
def diff(*args, **kwargs): DCNL 'Return the DIFFERENCE of the result sets returned by each matching minion DCNL pool DCNL .. versionadded:: 2014.7.0 DCNL These pools are determined from the aggregated and sorted results of DCNL a salt command. DCNL This command displays the "diffs" as a series of 2-way differences -- DCNL namely the difference between the FIRST displayed minion pool DCNL (according to sort order) and EACH SUBSEQUENT minion pool result set. DCNL Differences are displayed according to the Python ``difflib.unified_diff()`` DCNL as in the case of the salt execution module ``file.get_diff``. DCNL This command is submitted via a salt runner using the general form:: DCNL salt-run survey.diff [survey_sort=up/down] <target> DCNL <salt-execution-module> <salt-execution-module parameters> DCNL Optionally accept a ``survey_sort=`` parameter. Default: DCNL ``survey_sort=down`` DCNL CLI Example #1: (Example to display the "differences of files") DCNL .. code-block:: bash DCNL salt-run survey.diff survey_sort=up "*" cp.get_file_str file:///etc/hosts'
def filter_interdiff_opcodes(opcodes, filediff_data, interfilediff_data): DCNL 'Filters the opcodes for an interdiff to remove unnecessary lines. DCNL An interdiff may contain lines of code that have changed as the result of DCNL updates to the tree between the time that the first and second diff were DCNL created. This leads to some annoyances when reviewing. DCNL This function will filter the opcodes to remove as much of this as DCNL possible. It will only output non-"equal" opcodes if it falls into the DCNL ranges of lines dictated in the uploaded diff files.'
def wol(mac, bcast='255.255.255.255', destport=9): DCNL 'Send Wake On Lan packet to a host DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' network.wol 08-00-27-13-69-77 DCNL salt \'*\' network.wol 080027136977 255.255.255.255 7 DCNL salt \'*\' network.wol 08:00:27:13:69:77 255.255.255.255 7'
def __escape_command(command): DCNL 'This function escapes the command so that can be passed in the command line to JBoss CLI. DCNL Escaping commands passed to jboss is extremely confusing. DCNL If you want to save a binding that contains a single backslash character read the following explanation. DCNL A sample value, let\'s say "a" (with single backslash), that is saved in the config.xml file: DCNL <bindings> DCNL <simple name="java:/app/binding1" value="a"/> DCNL </bindings> DCNL Eventhough it is just a single "" if you want to read it from command line you will get: DCNL /opt/jboss/jboss-eap-6.0.1/bin/jboss-cli.sh --connect --controller=ip_addr:9999 --user=user --password=pass --command="/subsystem=naming/binding="java:/app/binding1":read-resource" DCNL "outcome" => "success", DCNL "result" => { DCNL "binding-type" => "simple", DCNL "value" => "a\b" DCNL So, now you have two backslashes in the output, even though in the configuration file you have one. DCNL Now, if you want to update this property, the easiest thing to do is to create a file with appropriate command: DCNL /tmp/update-binding.cli: DCNL /subsystem=naming/binding="java:/app/binding1":write-attribute(name=value, value="a\\b") DCNL And run cli command: DCNL ${JBOSS_HOME}/bin/jboss-cli.sh --connect --controller=ip_addr:9999 --user=user --password=pass --file="/tmp/update-binding.cli" DCNL As you can see, here you need 4 backslashes to save it as one to the configuration file. Run it and go to the configuration file to check. DCNL (You may need to reload jboss afterwards:  ${JBOSS_HOME}/bin/jboss-cli.sh --connect --controller=ip_addr:9999 --user=user --password=pass --command=":reload" ) DCNL But if you want to run the same update operation directly from command line, prepare yourself for more escaping: DCNL ${JBOSS_HOME}/bin/jboss-cli.sh --connect --controller=ip_addr:9999 --user=user --password=pass --command="/subsystem=naming/binding="java:/app/binding1":write-attribute(name=value, value="a\\\\b")" DCNL So, here you need 8 backslashes to force JBoss to save it as one. DCNL To sum up this behavior: DCNL (1) 1 backslash in configuration file DCNL (2) 2 backslashes when reading DCNL (3) 4 backslashes when writing from file DCNL (4) 8 backslashes when writing from command line DCNL ... are all the same thing:) DCNL Remember that the command that comes in is already (3) format. Now we need to escape it further to be able to pass it to command line.'
def _int_arg(s): DCNL 'Convert a string argument to an integer for use in a template DCNL function.  May raise a ValueError.'
def build(spec, distpath, workpath, clean_build): DCNL 'Build the executable according to the created SPEC file.'
def get_vsphere_location(context, image_id): DCNL 'Get image location in vsphere or None.'
@testing.requires_testing_data DCNL def test_source_psd(): DCNL 'Test source PSD computation in label.'
def generate_track_info(track_id='track DCSP info', values={}): DCNL 'Return `TrackInfo` populated with mock data. DCNL The `track_id` field is set to the corresponding argument. All other DCNL string fields are set to "track info".'
def dmp_swap(f, i, j, u, K): DCNL 'Transform ``K[..x_i..x_j..]`` to ``K[..x_j..x_i..]``. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.densebasic import dmp_swap DCNL >>> f = ZZ.map([[[2], [1, 0]], []]) DCNL >>> dmp_swap(f, 0, 1, 2, ZZ) DCNL [[[2], []], [[1, 0], []]] DCNL >>> dmp_swap(f, 1, 2, 2, ZZ) DCNL [[[1], [2, 0]], [[]]] DCNL >>> dmp_swap(f, 0, 2, 2, ZZ) DCNL [[[1, 0]], [[2, 0], []]]'
def _generateScalar(filename='simple.csv', numSequences=2, elementsPerSeq=1, numRepeats=10, stepSize=0.1, includeRandom=False): DCNL 'Generate a simple dataset. This contains a bunch of non-overlapping DCNL sequences of scalar values. DCNL Parameters: DCNL filename:       name of the file to produce, including extension. It will DCNL be created in a \'datasets\' sub-directory within the DCNL directory containing this script. DCNL numSequences:   how many sequences to generate DCNL elementsPerSeq: length of each sequence DCNL numRepeats:     how many times to repeat each sequence in the output DCNL stepSize:       how far apart each scalar is DCNL includeRandom:  if true, include another random field'
def get_version(package): DCNL 'Return package version as listed in `__version__` in `init.py`.'
def connect_to_region(region_name, **kw_params): DCNL 'Given a valid region name, return a DCNL :class:`boto.sns.connection.SNSConnection`. DCNL :type: str DCNL :param region_name: The name of the region to connect to. DCNL :rtype: :class:`boto.sns.connection.SNSConnection` or ``None`` DCNL :return: A connection to the given region, or None if an invalid region DCNL name is given'
def varying_between(table, idvarlist): DCNL 'Return a list of all variables with non constant values between DCNL groups defined by `idvarlist`.'
def create_resource(prefix, creation_func, *args, **kwargs): DCNL 'Create a new resource that does not already exist. DCNL If prefix isn\'t \'max_length\' in size, a random suffix is concatenated to DCNL ensure it is random. Otherwise, \'prefix\' is used as is. DCNL :param prefix: The prefix for a randomly generated name DCNL :param creation_func: A function taking the name of the resource DCNL to be created as it\'s first argument.  An error is assumed DCNL to indicate a name collision. DCNL :param *args *kwargs: These will be passed to the create function.'
@requires_pandas DCNL def test_to_data_frame(): DCNL 'Test raw Pandas exporter.'
def images(): DCNL 'Iterate over all (image,label) pairs DCNL This function will return'
def ceil_shift(n, b): DCNL 'Return ceil(n / 2**b) without performing any floating-point or division operations. DCNL This is done by right-shifting n by b bits and incrementing the result by 1 DCNL if any \'1\' bits were shifted out.'
@handle_response_format DCNL @treeio_login_required DCNL def service_edit(request, service_id, response_format='html'): DCNL 'Service edit'
def _enqueue_feedback_thread_status_change_email_task(user_id, reference, old_status, new_status): DCNL 'Adds a task for sending email when a feedback thread status is changed. DCNL Args: DCNL user_id: str. The user to be notified. DCNL reference: FeedbackMessageReference. DCNL old_status: str, one of STATUS_CHOICES. DCNL new_status: str, one of STATUS_CHOICES.'
def test_close_connections(): DCNL 'A test that exposes the problem where connections are returned to the DCNL connection pool (and closed) before the caller reads the response. DCNL I couldn\'t think of a way to test it without greenlets, so this test DCNL doesn\'t run as part of the standard test suite.  That way, no more DCNL dependencies are added to the test suite.'
def _CheckExpression(expression): DCNL 'Checks whether the expression is a string.'
def gethostbyname(hostname): DCNL 'gethostbyname(host) -> address DCNL Return the IP address (a string of the form \'255.255.255.255\') for a host. DCNL .. seealso:: :doc:`dns`'
def yield_address(space, start, length=None, reverse=False): DCNL 'A function to read a series of values starting at a certain address. DCNL @param space: address space DCNL @param start: starting address DCNL @param length: the size of the values to read DCNL @param reverse: option to read in the other direction DCNL @return: an iterator'
def ensure_relative(path): DCNL 'Take the full path \'path\', and make it a relative path so DCNL it can be the second argument to os.path.join().'
def addXIntersectionsFromLoopsForTable(loops, xIntersectionsTable, width): DCNL 'Add the x intersections for a loop into a table.'
def get_cache_duration(cache_key): DCNL 'Determine a cache duration for the given cache key. DCNL :param cache_key: Cache key string DCNL :type cache_key: str DCNL :return: Timeout seconds DCNL :rtype: int'
def eagerload(*args, **kwargs): DCNL 'A synonym for :func:`joinedload()`.'
def list_env(saltenv='base'): DCNL 'Return all of the file paths found in an environment'
def read_reflog(f): DCNL 'Read reflog. DCNL :param f: File-like object DCNL :returns: Iterator over Entry objects'
@flake8ext DCNL def check_python3_no_iteritems(logical_line): DCNL 'N327 - Use six.iteritems()'
def list2cmdline(seq): DCNL 'Translate a sequence of arguments into a command line DCNL string, using the same rules as the MS C runtime: DCNL 1) Arguments are delimited by white space, which is either a DCNL space or a tab. DCNL 2) A string surrounded by double quotation marks is DCNL interpreted as a single argument, regardless of white space DCNL or pipe characters contained within.  A quoted string can be DCNL embedded in an argument. DCNL 3) A double quotation mark preceded by a backslash is DCNL interpreted as a literal double quotation mark. DCNL 4) Backslashes are interpreted literally, unless they DCNL immediately precede a double quotation mark. DCNL 5) If backslashes immediately precede a double quotation mark, DCNL every pair of backslashes is interpreted as a literal DCNL backslash.  If the number of backslashes is odd, the last DCNL backslash escapes the next double quotation mark as DCNL described in rule 3.'
def add_stderr_logger(level=logging.DEBUG): DCNL 'Helper for quickly adding a StreamHandler to the logger. Useful for DCNL debugging. DCNL Returns the handler after adding it.'
def same_origin(url1, url2): DCNL 'Checks if two URLs are \'same-origin\''
@requires_version('scipy', '0.16') DCNL @slow_test DCNL def test_filters(): DCNL 'Test low-, band-, high-pass, and band-stop filters plus resampling.'
def register_plugin(impl, name=None): DCNL 'Add a new plugin implementation to the registry. DCNL :param class impl: The plugin class. DCNL The implementation class must provide a :attr:`~BasePlugin.name` DCNL value that will be used as a short name for enabling and disabling DCNL the plugin. The name should be based on the specification used by DCNL the plugin. For example, a plugin implementing XEP-0030 would be DCNL named `\'xep_0030\'`.'
@with_setup(prepare_stdout) DCNL def test_background_without_header(): DCNL 'Running background without header'
def bad_filename2(filename): DCNL ''
def getoutput(cmd): DCNL 'getoutput(cmd) should work in a cli environment on Mac OSX, Linux, DCNL and Windows'
def test_json_view_normal_response(): DCNL 'Normal responses get passed through.'
def run(name, **kwargs): DCNL 'Run a single module function DCNL ``name`` DCNL The module function to execute DCNL ``returner`` DCNL Specify the returner to send the return of the module execution to DCNL ``kwargs`` DCNL Pass any arguments needed to execute the function'
def kegg_get(dbentries, option=None): DCNL 'KEGG get - Data retrieval. DCNL dbentries - Identifiers (single string, or list of strings), see below. DCNL option - One of "aaseq", "ntseq", "mol", "kcf", "image", "kgml" (string) DCNL The input is limited up to 10 entries. DCNL The input is limited to one pathway entry with the image or kgml option. DCNL The input is limited to one compound/glycan/drug entry with the image option. DCNL Returns a handle.'
def b64d(s): DCNL 'b64d(s) -> str DCNL Base64 decodes a string DCNL Example: DCNL >>> b64d(\'dGVzdA==\') DCNL \'test\''
def _get_col_o2o(parent, subname, subcls, fk_col_name, deferrable=None, initially=None, ondelete=None, onupdate=None): DCNL 'Gets key and child type and returns a column that points to the primary DCNL key of the child.'
def Cdf(cdf, complement=False, transform=None, **options): DCNL 'Plots a CDF as a line. DCNL Args: DCNL cdf: Cdf object DCNL complement: boolean, whether to plot the complementary CDF DCNL transform: string, one of \'exponential\', \'pareto\', \'weibull\', \'gumbel\' DCNL options: keyword args passed to pyplot.plot DCNL Returns: DCNL dictionary with the scale options that should be passed to DCNL Config, Show or Save.'
def fix_iteration_tables(): DCNL 'Since iteration tables don\'t have any real primary key, we "fake" one in the DCNL Django models.  So fix up the generated schema to match the real schema.'
def parse_qs(qs, keep_blank_values=0, strict_parsing=0, unquote=unquote): DCNL 'like cgi.parse_qs, only with custom unquote function'
@app.route('/', methods=['GET', 'POST', 'OPTIONS', 'PUT', 'DELETE', 'HEAD', 'PATCH']) DCNL @app.route('/<path:input_path>', methods=['GET', 'POST', 'OPTIONS', 'PUT', 'DELETE', 'HEAD', 'PATCH']) DCNL def zmirror_enter(input_path='/'): DCNL '入口函数的壳, 只是包了一层异常处理, 实际是 main_function()'
def check_seqs(fasta_out, fasta_files, starting_ix, valid_map, qual_mappings, filters, barcode_len, keep_primer, keep_barcode, barcode_type, max_bc_errors, retain_unassigned_reads, attempt_bc_correction, primer_seqs_lens, all_primers, max_primer_mm, disable_primer_check, reverse_primers, rev_primers, qual_out, qual_score_window=0, discard_bad_windows=False, min_qual_score=25, min_seq_len=200, median_length_filtering=None, added_demultiplex_field=None, reverse_primer_mismatches=0, truncate_ambi_bases=False): DCNL 'Checks fasta-format sequences and qual files for validity.'
def test_synchronize_join_node(tmpdir): DCNL 'Test join on an input node which has the ``synchronize`` flag set to True.'
def unique(list_, key=(lambda x: x)): DCNL 'efficient function to uniquify a list preserving item order'
@login_check DCNL def machines_show_all(request): DCNL '忽略用户，显示所有的machine'
@contextmanager DCNL def mocked_context(*args, **kwargs): DCNL 'To be directly patched into an ssh.tunnel invocation to prevent DCNL any real SSH attempt'
def main(): DCNL 'Use the django ORM to generate a config file.  We\'ll build the DCNL config file as a series of lines, and once that is done write it DCNL out in one go'
def walk_modules(path): DCNL 'Loads a module and all its submodules from the given module path and DCNL returns them. If *any* module throws an exception while importing, that DCNL exception is thrown back. DCNL For example: walk_modules(\'scrapy.utils\')'
def daily_return(prices): DCNL 'an array of daily returns from price array'
def traverse_tree(course): DCNL 'Load every descriptor in course.  Return bool success value.'
def green(text, attrib=None): DCNL 'Wrapper for colorize(text, \'green\')'
def topic_detail(request, slug, topic_id, template_name='groups/topics/topic_detail.html'): DCNL 'Returns a group topic detail page. DCNL Templates: ``groups/topics/topic_detail.html`` DCNL Context: DCNL topic DCNL GroupTopic object DCNL group DCNL Group object'
@task(name='clean-all', aliases=('distclean',)) DCNL def clean_all(ctx, dry_run=False): DCNL 'Clean up everything, even the precious stuff. DCNL NOTE: clean task is executed first.'
def retrieve_cors_header(response, key): DCNL 'Method to retrieve a CORS header value from a HTTP response. DCNL :param response: A HTTPResponse object. DCNL :param key: A key representing the desired header value to retrieve. DCNL :return: The header value or None if the header do not exists.'
def file_upload_filename_case_view(request): DCNL 'Check adding the file to the database will preserve the filename case.'
def test_identify_plugin(name, tests, modify_plugin=(lambda plugin: None), fail_missing_meta=True): DCNL ':param name: Plugin name DCNL :param tests: List of 2-tuples. Each two tuple is of the form (args, DCNL test_funcs). args is a dict of keyword arguments to pass to DCNL the identify method. test_funcs are callables that accept a DCNL Metadata object and return True iff the object passes the DCNL test.'
def InstallerNotifyServer(): DCNL 'An emergency function Invoked when the client installation failed.'
def compile_function(name, code, globs): DCNL 'Given a *code* string, compile it with globals *globs* and return DCNL the function named *name*.'
def line2d_seg_dist(p1, p2, p0): DCNL 'distance(s) from line defined by p1 - p2 to point(s) p0 DCNL p0[0] = x(s) DCNL p0[1] = y(s) DCNL intersection point p = p1 + u*(p2-p1) DCNL and intersection point lies within segment if u is between 0 and 1'
def get_scanner(hass, config): DCNL 'Validate the configuration and return an ASUS-WRT scanner.'
def _conf(family='ip'): DCNL 'Use the same file for rules for now.'
@_noconds_(True) DCNL def _fourier_transform(f, x, k, a, b, name, simplify=True): DCNL 'Compute a general Fourier-type transform DCNL F(k) = a int_-oo^oo exp(b*I*x*k) f(x) dx. DCNL For suitable choice of a and b, this reduces to the standard Fourier DCNL and inverse Fourier transforms.'
def _generateEncoderChoicesV1(fieldInfo): DCNL 'Return a list of possible encoder parameter combinations for the given DCNL field and the default aggregation function to use. Each parameter combination DCNL is a dict defining the parameters for the encoder. Here is an example DCNL return value for the encoderChoicesList: DCNL None, DCNL {\'fieldname\':\'timestamp\', DCNL \'name\': \'timestamp_timeOfDay\', DCNL \'type\':\'DateEncoder\' DCNL \'dayOfWeek\': (7,1) DCNL {\'fieldname\':\'timestamp\', DCNL \'name\': \'timestamp_timeOfDay\', DCNL \'type\':\'DateEncoder\' DCNL \'dayOfWeek\': (7,3) DCNL Parameters: DCNL fieldInfo:      item from the \'includedFields\' section of the DCNL description JSON object DCNL retval:  (encoderChoicesList, aggFunction) DCNL encoderChoicesList: a list of encoder choice lists for this field. DCNL Most fields will generate just 1 encoder choice list. DCNL DateTime fields can generate 2 or more encoder choice lists, DCNL one for dayOfWeek, one for timeOfDay, etc. DCNL aggFunction: name of aggregation function to use for this DCNL field type'
def addif(br=None, iface=None): DCNL 'Adds an interface to a bridge DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' bridge.addif br0 eth0'
def get_embeddings(options, word_idict, f_emb, use_norm=False): DCNL 'Extract the RNN embeddings from the model'
def convert_to_bcd(decimal): DCNL 'Converts a decimal value to a bcd value DCNL :param value: The decimal value to to pack into bcd DCNL :returns: The number in bcd form'
def _syscall_wrapper(func, recalc_timeout, *args, **kwargs): DCNL 'Wrapper function for syscalls that could fail due to EINTR. DCNL All functions should be retried if there is time left in the timeout DCNL in accordance with PEP 475.'
def NDP_Attack_NS_Spoofing(src_lladdr=None, src=None, target='2001:db8::1', dst=None, src_mac=None, dst_mac=None, loop=True, inter=1, iface=None): DCNL 'The main purpose of this function is to send fake Neighbor Solicitations DCNL messages to a victim, in order to either create a new entry in its neighbor DCNL cache or update an existing one. In section 7.2.3 of RFC 4861, it is stated DCNL that a node SHOULD create the entry or update an existing one (if it is not DCNL currently performing DAD for the target of the NS). The entry\'s reachability DCNL state is set to STALE. DCNL The two main parameters of the function are the source link-layer address DCNL (carried by the Source Link-Layer Address option in the NS) and the DCNL source address of the packet. DCNL Unlike some other NDP_Attack_* function, this one is not based on a DCNL stimulus/response model. When called, it sends the same NS packet in loop DCNL every second (the default) DCNL Following arguments can be used to change the format of the packets: DCNL src_lladdr: the MAC address used in the Source Link-Layer Address option DCNL included in the NS packet. This is the address that the peer should DCNL associate in its neighbor cache with the IPv6 source address of the DCNL packet. If None is provided, the mac address of the interface is DCNL used. DCNL src: the IPv6 address used as source of the packet. If None is provided, DCNL an address associated with the emitting interface will be used DCNL (based on the destination address of the packet). DCNL target: the target address of the NS packet. If no value is provided, DCNL a dummy address (2001:db8::1) is used. The value of the target DCNL has a direct impact on the destination address of the packet if it DCNL is not overridden. By default, the solicited-node multicast address DCNL associated with the target is used as destination address of the DCNL packet. Consider specifying a specific destination address if you DCNL intend to use a target address different than the one of the victim. DCNL dst: The destination address of the NS. By default, the solicited node DCNL multicast address associated with the target address (see previous DCNL parameter) is used if no specific value is provided. The victim DCNL is not expected to check the destination address of the packet, DCNL so using a multicast address like ff02::1 should work if you want DCNL the attack to target all hosts on the link. On the contrary, if DCNL you want to be more stealth, you should provide the target address DCNL for this parameter in order for the packet to be sent only to the DCNL victim. DCNL src_mac: the MAC address used as source of the packet. By default, this DCNL is the address of the interface. If you want to be more stealth, DCNL feel free to use something else. Note that this address is not the DCNL that the victim will use to populate its neighbor cache. DCNL dst_mac: The MAC address used as destination address of the packet. If DCNL the IPv6 destination address is multicast (all-nodes, solicited DCNL node, ...), it will be computed. If the destination address is DCNL unicast, a neighbor solicitation will be performed to get the DCNL associated address. If you want the attack to be stealth, you DCNL can provide the MAC address using this parameter. DCNL loop: By default, this parameter is True, indicating that NS packets DCNL will be sent in loop, separated by \'inter\' seconds (see below). DCNL When set to False, a single packet is sent. DCNL inter: When loop parameter is True (the default), this parameter provides DCNL the interval in seconds used for sending NS packets. DCNL iface: to force the sending interface.'
def TR13(rv): DCNL 'Change products of ``tan`` or ``cot``. DCNL Examples DCNL >>> from sympy.simplify.fu import TR13 DCNL >>> from sympy import tan, cot, cos DCNL >>> TR13(tan(3)*tan(2)) DCNL -tan(2)/tan(5) - tan(3)/tan(5) + 1 DCNL >>> TR13(cot(3)*cot(2)) DCNL cot(2)*cot(5) + 1 + cot(3)*cot(5)'
def apply_label(node): DCNL 'Return label of apply node.'
@handle_response_format DCNL @treeio_login_required DCNL def category_add(request, response_format='html'): DCNL 'Add new knowledge category'
@hook.command('litecoin', 'ltc', autohelp=False) DCNL def litecoin(): DCNL '-- Returns current litecoin value'
def from_any(size, fraction_ref=None): DCNL 'Creates Fixed unit when the first argument is a float, or a DCNL Fraction unit if that is a string that ends with %. The second DCNL argument is only meaningful when Fraction unit is created.:: DCNL >>> a = Size.from_any(1.2) # => Size.Fixed(1.2) DCNL >>> Size.from_any("50%", a) # => Size.Fraction(0.5, a)'
def derive_aggregation(dim_cols, agg_col, agg): DCNL 'Produces consistent aggregation spec from optional column specification. DCNL This utility provides some consistency to the flexible inputs that can be provided DCNL to charts, such as not specifying dimensions to aggregate on, not specifying an DCNL aggregation, and/or not specifying a column to aggregate on.'
def evaluate(x, y, expr, x_value, y_value): DCNL 'x: A theano variable DCNL y: A theano variable DCNL expr: A theano expression involving x and y DCNL x_value: A numpy value DCNL y_value: A numpy value DCNL Returns the value of expr when x_value is substituted for x DCNL and y_value is substituted for y'
def _item_to_sub_for_client(iterator, sub_pb, topics): DCNL 'Convert a subscription protobuf to the native object. DCNL .. note:: DCNL This method does not have the correct signature to be used as DCNL the ``item_to_value`` argument to DCNL :class:`~google.cloud.iterator.Iterator`. It is intended to be DCNL patched with a mutable topics argument that can be updated DCNL on subsequent calls. For an example, see how the method is DCNL used above in :meth:`_SubscriberAPI.list_subscriptions`. DCNL :type iterator: :class:`~google.cloud.iterator.Iterator` DCNL :param iterator: The iterator that is currently in use. DCNL :type sub_pb: :class:`.pubsub_pb2.Subscription` DCNL :param sub_pb: A subscription returned from the API. DCNL :type topics: dict DCNL :param topics: A dictionary of topics to be used (and modified) DCNL as new subscriptions are created bound to topics. DCNL :rtype: :class:`~google.cloud.pubsub.subscription.Subscription` DCNL :returns: The next subscription in the page.'
def export_loop(cls, instance_or_dict, field_converter=None, role=None, raise_error_on_role=True, export_level=None, app_data=None, context=None): DCNL 'The export_loop function is intended to be a general loop definition that DCNL can be used for any form of data shaping, such as application of roles or DCNL how a field is transformed. DCNL :param cls: DCNL The model definition. DCNL :param instance_or_dict: DCNL The structure where fields from cls are mapped to values. The only DCNL expectionation for this structure is that it implements a ``dict`` DCNL interface. DCNL :param field_converter: DCNL This function is applied to every field found in ``instance_or_dict``. DCNL :param role: DCNL The role used to determine if fields should be left out of the DCNL transformation. DCNL :param raise_error_on_role: DCNL This parameter enforces strict behavior which requires substructures DCNL to have the same role definition as their parent structures. DCNL :param app_data: DCNL An arbitrary container for application-specific data that needs to DCNL be available during the conversion. DCNL :param context: DCNL A ``Context`` object that encapsulates configuration options and ``app_data``. DCNL The context object is created upon the initial invocation of ``import_loop`` DCNL and is then propagated through the entire process.'
def test_score_2(): DCNL 'Assert that the TPOTClassifier score function outputs a known score for a fixed pipeline'
@gof.local_optimizer([T.Elemwise]) DCNL def local_fill_sink(node): DCNL 'f(fill(a, b), fill(c, d), e) -> fill(c, fill(a, f(b, d, e))) DCNL f need to be an elemwise that isn\'t a fill.'
def _password_validators_help_text_html(password_validators=None): DCNL 'Return an HTML string with all help texts of all configured validators DCNL in an <ul>.'
def test_forum_is_unread(guest, user, forum, topic, forumsread): DCNL 'Test the forum is unread function.'
@utils.arg('--flavor', metavar='<flavor>', help=_('Filter DCSP results DCSP by DCSP flavor DCSP name DCSP or DCSP ID.')) DCNL @utils.arg('--tenant', metavar='<tenant_id>', help=_('Filter DCSP results DCSP by DCSP tenant DCSP ID.'), action=shell.DeprecatedAction, real_action='nothing', use=_('this DCSP option DCSP is DCSP not DCSP supported, DCSP and DCSP will DCSP be DCSP removed DCSP in DCSP version DCSP 5.0.0.')) DCNL def do_flavor_access_list(cs, args): DCNL 'Print access information about the given flavor.'
def md5_shard(word): DCNL 'Assign data to servers using a public hash algorithm.'
def attribute_assortativity_coefficient(G, attribute, nodes=None): DCNL 'Compute assortativity for node attributes. DCNL Assortativity measures the similarity of connections DCNL in the graph with respect to the given attribute. DCNL Parameters DCNL G : NetworkX graph DCNL attribute : string DCNL Node attribute key DCNL nodes: list or iterable (optional) DCNL Compute attribute assortativity for nodes in container. DCNL The default is all nodes. DCNL Returns DCNL r: float DCNL Assortativity of graph for given attribute DCNL Examples DCNL >>> G=nx.Graph() DCNL >>> G.add_nodes_from([0,1],color=\'red\') DCNL >>> G.add_nodes_from([2,3],color=\'blue\') DCNL >>> G.add_edges_from([(0,1),(2,3)]) DCNL >>> print(nx.attribute_assortativity_coefficient(G,\'color\')) DCNL 1.0 DCNL Notes DCNL This computes Eq. (2) in Ref. [1]_ , trace(M)-sum(M))/(1-sum(M), DCNL where M is the joint probability distribution (mixing matrix) DCNL of the specified attribute. DCNL References DCNL .. [1] M. E. J. Newman, Mixing patterns in networks, DCNL Physical Review E, 67 026126, 2003'
def headers_cb(): DCNL 'Callback method for providing headers per request DCNL add_headers_cb is another callback providing headers (as a dict) to update the DCNL defaults in this method. This method can be set by adding a dcos_auth_python package DCNL with a get_auth_headers method'
def walk(top, func, arg): DCNL 'Directory tree walk with callback function. DCNL For each directory in the directory tree rooted at top (including top DCNL itself, but excluding \'.\' and \'..\'), call func(arg, dirname, fnames). DCNL dirname is the name of the directory, and fnames a list of the names of DCNL the files and subdirectories in dirname (excluding \'.\' and \'..\').  func DCNL may modify the fnames list in-place (e.g. via del or slice assignment), DCNL and walk will only recurse into the subdirectories whose names remain in DCNL fnames; this can be used to implement a filter, or to impose a specific DCNL order of visiting.  No semantics are defined for, or required of, arg, DCNL beyond that arg is always passed to func.  It can be used, e.g., to pass DCNL a filename pattern, or a mutable object designed to accumulate DCNL statistics.  Passing None for arg is common.'
def test_table_deletion(): DCNL 'Regression test for the reference cycle discussed in DCNL https://github.com/astropy/astropy/issues/2877'
def is_special_key(keystr): DCNL 'True if keystr is a \'special\' keystring (e.g. <ctrl-x> or <space>).'
def nonterminals(symbols): DCNL 'Given a string containing a list of symbol names, return a list of DCNL ``Nonterminals`` constructed from those symbols. DCNL :param symbols: The symbol name string.  This string can be DCNL delimited by either spaces or commas. DCNL :type symbols: str DCNL :return: A list of ``Nonterminals`` constructed from the symbol DCNL names given in ``symbols``.  The ``Nonterminals`` are sorted DCNL in the same order as the symbols names. DCNL :rtype: list(Nonterminal)'
def jsmin_for_posers(script, keep_bang_comments=False): DCNL 'Minify javascript based on `jsmin.c by Douglas Crockford`_\. DCNL Instead of parsing the stream char by char, it uses a regular DCNL expression approach which minifies the whole script with one big DCNL substitution regex. DCNL .. _jsmin.c by Douglas Crockford: DCNL http://www.crockford.com/javascript/jsmin.c DCNL :Warning: This function is the digest of a _make_jsmin() call. It just DCNL utilizes the resulting regexes. It\'s here for fun and may DCNL vanish any time. Use the `jsmin` function instead. DCNL :Parameters: DCNL `script` : ``str`` DCNL Script to minify DCNL `keep_bang_comments` : ``bool`` DCNL Keep comments starting with an exclamation mark? (``/*!...*/``) DCNL :Return: Minified script DCNL :Rtype: ``str``'
def missing_dependencies(): DCNL 'Return the status of missing dependencies (if any)'
def createNetwork(dataSource): DCNL 'Create the Network instance. DCNL The network has a sensor region reading data from `dataSource` and passing DCNL the encoded representation to an SPRegion. The SPRegion output is passed to DCNL a TPRegion. DCNL :param dataSource: a RecordStream instance to get data from DCNL :returns: a Network instance ready to run'
def unparse_multistring(values): DCNL 'Converts a `values` multistring object or a list of strings back to the DCNL in-DB multistring representation.'
def reload_(name): DCNL 'Wrapper for term() DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' daemontools.reload <service name>'
def submit_jobs(filenames, verbose=False): DCNL 'Submit jobs in filenames. DCNL filenames: list of prepared qsub job scripts, ready to be submitted DCNL verbose: a binary verbose flag'
def pr_contacts(r, **attr): DCNL 'Custom Method to provide the details for the Person\'s Contacts Tab: DCNL - provides a single view on: DCNL Addresses (pr_address) DCNL Contacts (pr_contact) DCNL Emergency Contacts DCNL @todo: deprecated, replaced by pr_Contacts, retained as reference DCNL (until address-support re-implemented in pr_Contacts)'
def conv1d_md(input, filters, image_shape, filter_shape, border_mode='valid', subsample=(1,), filter_flip=True): DCNL 'using multiple dot products'
def addsitepackages(known_paths): DCNL 'Add site-packages (and possibly site-python) to sys.path'
def deploy_rheader(r, tabs=[], profile=False): DCNL 'Deployment Resource Headers'
def CountErrors(ocr_text, truth_text): DCNL 'Counts the drops and adds between 2 bags of iterables. DCNL Simple bag of objects count returns the number of dropped and added DCNL elements, regardless of order, from anything that is iterable, eg DCNL a pair of strings gives character errors, and a pair of word lists give DCNL word errors. DCNL Args: DCNL ocr_text:    OCR text iterable (eg string for chars, word list for words). DCNL truth_text:  Truth text iterable. DCNL Returns: DCNL ErrorCounts named tuple.'
def _to_byte_string(value, num_bits): DCNL 'Convert an integer to a big-endian string of bytes with padding. DCNL Padding is added at the end (i.e. after the least-significant bit) if DCNL required.'
def script(name, source, saltenv='base', args=None, template=None, exec_driver=None, stdin=None, python_shell=True, output_loglevel='debug', ignore_retcode=False, use_vt=False, keep_env=None): DCNL 'Run :py:func:`cmd.script <salt.modules.cmdmod.script>` within a container DCNL .. note:: DCNL While the command is run within the container, it is initiated from the DCNL host. Therefore, the PID in the return dict is from the host, not from DCNL the container. DCNL name DCNL Container name or ID DCNL source DCNL Path to the script. Can be a local path on the Minion or a remote file DCNL from the Salt fileserver. DCNL args DCNL A string containing additional command-line options to pass to the DCNL script. DCNL template : None DCNL Templating engine to use on the script before running. DCNL exec_driver : None DCNL If not passed, the execution driver will be detected as described DCNL :ref:`above <docker-execution-driver>`. DCNL stdin : None DCNL Standard input to be used for the script DCNL output_loglevel : debug DCNL Level at which to log the output from the script. Set to ``quiet`` to DCNL suppress logging. DCNL use_vt : False DCNL Use SaltStack\'s utils.vt to stream output to console. DCNL keep_env : None DCNL If not passed, only a sane default PATH environment variable will be DCNL set. If ``True``, all environment variables from the container\'s host DCNL will be kept. Otherwise, a comma-separated list (or Python list) of DCNL environment variable names can be passed, and those environment DCNL variables will be kept. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion dockerng.script mycontainer salt://docker_script.py DCNL salt myminion dockerng.script mycontainer salt://scripts/runme.sh \'arg1 arg2 "arg 3"\' DCNL salt myminion dockerng.script mycontainer salt://scripts/runme.sh stdin=\'one\ntwo\nthree\nfour\nfive\n\' output_loglevel=quiet'
@contextmanager DCNL def temporary_file(suffix=''): DCNL 'Yield a writeable temporary filename that is deleted on context exit. DCNL Parameters DCNL suffix : string, optional DCNL The suffix for the file. DCNL Examples DCNL >>> import numpy as np DCNL >>> from skimage import io DCNL >>> with temporary_file(\'.tif\') as tempfile: DCNL ...     im = np.zeros((5, 5), np.uint8) DCNL ...     io.imsave(tempfile, im) DCNL ...     assert np.all(io.imread(tempfile) == im)'
def query_yes_no(question, default='yes'): DCNL 'Ask a yes/no question via raw_input() and return their answer. DCNL "question" is a string that is presented to the user. DCNL "default" is the presumed answer if the user just hits <Enter>. DCNL It must be "yes" (the default), "no" or None (meaning DCNL an answer is required of the user). DCNL The "answer" return value is one of "yes" or "no".'
def test_replace_string_type(): DCNL 'Test replacing python string'
def param_init_fflayer(options, params, prefix='ff', nin=None, nout=None, ortho=True): DCNL 'Affine transformation + point-wise nonlinearity'
def new(key, randfunc=None): DCNL 'Return a cipher object `PKCS115_Cipher` that can be used to perform PKCS#1 v1.5 encryption or decryption. DCNL :Parameters: DCNL key : RSA key object DCNL The key to use to encrypt or decrypt the message. This is a `Cryptodome.PublicKey.RSA` object. DCNL Decryption is only possible if *key* is a private RSA key. DCNL randfunc : callable DCNL Function that return random bytes. DCNL The default is `Cryptodome.Random.get_random_bytes`.'
def urlparse_cached(request_or_response): DCNL 'Return urlparse.urlparse caching the result, where the argument can be a DCNL Request or Response object'
def kernel(d1, d2, r=None, weights=None): DCNL 'general product kernel DCNL hardcoded split for the example: DCNL cat1 is continuous (time), other categories are discrete DCNL weights is e.g. Bartlett for cat1 DCNL r is (0,1) indicator vector for boolean weights 1{d1_i == d2_i} DCNL returns boolean if no continuous weights are used'
def _wns_authenticate(scope='notify.windows.com'): DCNL 'Requests an Access token for WNS communication. DCNL :return: dict: {\'access_token\': <str>, \'expires_in\': <int>, \'token_type\': \'bearer\'}'
def version(): DCNL 'Return a string with various version informations.'
def expected_text(*args): DCNL 'Helper to format text we expect the KeyHintView to generate. DCNL Args: DCNL args: One tuple for each row in the expected output. DCNL Tuples are of the form: (prefix, color, suffix, command).'
def reset_output(): DCNL '>> reset_output DCNL Reset twill output to go to the screen.'
def restore_version(): DCNL 'If we touch the version in __init__.py discard changes after install.'
def test_reset_out(): DCNL 'Test \'%reset out\' magic'
def check(actions, request, target=None): DCNL 'Wrapper of the configurable policy method.'
def marker_comparator_predicate(match): DCNL 'Match predicate used in comparator'
def _get_bus_number_for_scsi_controller(devices): DCNL 'Return usable bus number when create new SCSI controller.'
def lab2rgb(lab, illuminant='D65', observer='2'): DCNL 'Lab to RGB color space conversion. DCNL Parameters DCNL lab : array_like DCNL The image in Lab format, in a 3-D array of shape ``(.., .., 3)``. DCNL illuminant : {"A", "D50", "D55", "D65", "D75", "E"}, optional DCNL The name of the illuminant (the function is NOT case sensitive). DCNL observer : {"2", "10"}, optional DCNL The aperture angle of the observer. DCNL Returns DCNL out : ndarray DCNL The image in RGB format, in a 3-D array of shape ``(.., .., 3)``. DCNL Raises DCNL ValueError DCNL If `lab` is not a 3-D array of shape ``(.., .., 3)``. DCNL References DCNL .. [1] https://en.wikipedia.org/wiki/Standard_illuminant DCNL Notes DCNL This function uses lab2xyz and xyz2rgb. DCNL By default Observer= 2A, Illuminant= D65. CIE XYZ tristimulus values DCNL x_ref=95.047, y_ref=100., z_ref=108.883. See function `get_xyz_coords` for DCNL a list of supported illuminants.'
def minkowski(u, v, p): DCNL 'Computes the Minkowski distance between two 1-D arrays. DCNL The Minkowski distance between 1-D arrays `u` and `v`, DCNL is defined as DCNL .. math:: DCNL {||u-v||}_p = (\sum{|u_i - v_i|^p})^{1/p}. DCNL Parameters DCNL u : (N,) array_like DCNL Input array. DCNL v : (N,) array_like DCNL Input array. DCNL p : int DCNL The order of the norm of the difference :math:`{||u-v||}_p`. DCNL Returns DCNL d : double DCNL The Minkowski distance between vectors `u` and `v`.'
def keepvol_on_destroy(name, kwargs=None, call=None): DCNL 'Do not delete all/specified EBS volumes upon instance termination DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-cloud -a keepvol_on_destroy mymachine'
def produce_test(parent, child, direction): DCNL 'produce a testcase for A->B->C inheritance with a self-referential DCNL relationship between two of the classes, using either one-to-many or DCNL many-to-one. DCNL the old "no discriminator column" pattern is used.'
def normalizePath(filepath): DCNL 'Returns normalized string representation of a given filepath DCNL >>> normalizePath(\'//var///log/apache.log\') DCNL \'//var/log/apache.log\''
def splitQuoted(s): DCNL 'Split a string into whitespace delimited tokens DCNL Tokens that would otherwise be separated but are surrounded by " DCNL remain as a single token.  Any token that is not quoted and is DCNL equal to "NIL" is tokenized as L{None}. DCNL @type s: L{bytes} DCNL @param s: The string to be split DCNL @rtype: L{list} of L{bytes} DCNL @return: A list of the resulting tokens DCNL @raise MismatchedQuoting: Raised if an odd number of quotes are present'
@handle_response_format DCNL @treeio_login_required DCNL @_process_mass_form DCNL def index_unread(request, response_format='html'): DCNL 'Messaging unread page'
def convert_IMProperty(model, prop, kwargs): DCNL 'Returns a form field for a ``db.IMProperty``.'
def decode_cookie(value): DCNL 'Safely decodes a cookie value to unicode. DCNL Tries us-ascii, utf-8 and io8859 encodings, in that order. DCNL >>> decode_cookie(\'\') DCNL u\'\' DCNL >>> decode_cookie(\'asdf\') DCNL u\'asdf\' DCNL >>> decode_cookie(\'foo \xC3\xA9 bar\') DCNL u\'foo \xe9 bar\' DCNL >>> decode_cookie(\'foo \xE9 bar\') DCNL u\'foo \xe9 bar\''
def server_list_detailed(profile=None): DCNL 'Return detailed list of active servers DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nova.server_list_detailed'
def _align_method_FRAME(left, right, axis): DCNL 'convert rhs to meet lhs dims if input is list, tuple or np.ndarray'
def shard_df_on_index(df, divisions): DCNL 'Shard a DataFrame by ranges on its index DCNL Examples DCNL >>> df = pd.DataFrame({\'a\': [0, 10, 20, 30, 40], \'b\': [5, 4 ,3, 2, 1]}) DCNL >>> df DCNL a  b DCNL 0   0  5 DCNL 1  10  4 DCNL 2  20  3 DCNL 3  30  2 DCNL 4  40  1 DCNL >>> shards = list(shard_df_on_index(df, [2, 4])) DCNL >>> shards[0] DCNL a  b DCNL 0   0  5 DCNL 1  10  4 DCNL >>> shards[1] DCNL a  b DCNL 2  20  3 DCNL 3  30  2 DCNL >>> shards[2] DCNL a  b DCNL 4  40  1 DCNL >>> list(shard_df_on_index(df, []))[0]  # empty case DCNL a  b DCNL 0   0  5 DCNL 1  10  4 DCNL 2  20  3 DCNL 3  30  2 DCNL 4  40  1'
def keys_to_string(data): DCNL 'Function to convert all the unicode keys in string keys'
def test_threading_import(tmpdir): DCNL 'On Python 3.3+, PyInstaller doesn\'t acquire a lock when performing an DCNL import. Therefore, two thread could both be reading the .pyz archive at the DCNL same time. At the core, the ArchiveFile class performs these reads. This DCNL test verifies that multi-threaded reads work. DCNL For more information, see https://github.com/pyinstaller/pyinstaller/pull/2010.'
def _git_diff_name_status(left, right, diff_filter=''): DCNL 'Compare two branches/commits etc with git. DCNL Parameter: DCNL left: the lefthand comperator DCNL right: the righthand comperator DCNL diff_filter: arguments given to --diff-filter (ACMRTD...) DCNL Returns: DCNL List of FileDiffs (tuple with name/status) DCNL Raises: DCNL ValueError if git command fails'
def generate_file(fname, ns_func, dest_dir='.'): DCNL 'generate a constants file from its template'
def send(): DCNL 'RESTful CRUD controller'
def mainloop(n=0): DCNL 'Run the main loop of Tcl.'
def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False): DCNL 'Converts any URLs in text into clickable links. DCNL Works on http://, https://, www. links, and also on links ending in one of DCNL the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org). DCNL Links can have trailing punctuation (periods, commas, close-parens) and DCNL leading punctuation (opening parens) and it\'ll still do the right thing. DCNL If trim_url_limit is not None, the URLs in link text longer than this limit DCNL will truncated to trim_url_limit-3 characters and appended with an elipsis. DCNL If nofollow is True, the URLs in link text will get a rel="nofollow" DCNL attribute. DCNL If autoescape is True, the link text and URLs will get autoescaped.'
def docstring_summary(docstring): DCNL 'Return summary of docstring.'
def bool_from_string(subject): DCNL 'Interpret a string as a boolean-like value.'
def delete_policy(name, policy_name, region=None, key=None, keyid=None, profile=None): DCNL 'Delete an ELB policy. DCNL .. versionadded:: 2016.3.0 DCNL CLI example: DCNL .. code-block:: bash DCNL salt myminion boto_elb.delete_policy myelb mypolicy'
def _find_home(): DCNL 'Locates and return the home directory (or best approximation) on this DCNL system. DCNL Raises DCNL OSError DCNL If the home directory cannot be located - usually means you are running DCNL Astropy on some obscure platform that doesn\'t have standard home DCNL directories.'
def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error, io=codecs): DCNL 'Reports for missing stl includes. DCNL This function will output warnings to make sure you are including the headers DCNL necessary for the stl containers and functions that you use. We only give one DCNL reason to include a header. For example, if you use both equal_to<> and DCNL less<> in a .h file, only one (the latter in the file) of these will be DCNL reported as a reason to include the <functional>. DCNL Args: DCNL filename: The name of the current file. DCNL clean_lines: A CleansedLines instance containing the file. DCNL include_state: An _IncludeState instance. DCNL error: The function to call with any errors found. DCNL io: The IO factory to use to read the header file. Provided for unittest DCNL injection.'
def _convert_to_standard_attr(attr): DCNL 'Helper function for _process_info_installed_output() DCNL Converts an opkg attribute name to a standard attribute DCNL name which is used across \'pkg\' modules.'
def strtobool(term, table={u'false': False, u'no': False, u'0': False, u'true': True, u'yes': True, u'1': True, u'on': True, u'off': False}): DCNL 'Convert common terms for true/false to bool. DCNL Examples (true/false/yes/no/on/off/1/0).'
@contextlib.contextmanager DCNL def kill_on_error(proc): DCNL 'Context manager killing the subprocess if a Python exception is raised.'
def add_neigh_entry(ip_address, mac_address, device, namespace=None, **kwargs): DCNL 'Add a neighbour entry. DCNL :param ip_address: IP address of entry to add DCNL :param mac_address: MAC address of entry to add DCNL :param device: Device name to use in adding entry DCNL :param namespace: The name of the namespace in which to add the entry'
def _sanitize(migrate_engine, table): DCNL 'Avoid possible integrity error by removing deleted rows DCNL to accommdate less restrictive uniqueness constraint'
def dynamic_activity_data(request): DCNL 'Large database acitivity widget helper. DCNL This method serves as a helper for the activity widget, it\'s used with for DCNL AJAX requests based on date ranges passed to it.'
def getLiftedOutput(derivation, geometryOutput): DCNL 'Get extrude output for a rack.'
def permalink(func): DCNL 'Decorator that calls urlresolvers.reverse() to return a URL using DCNL parameters returned by the decorated function "func". DCNL "func" should be a function that returns a tuple in one of the DCNL following formats: DCNL (viewname, viewargs) DCNL (viewname, viewargs, viewkwargs)'
def get_service(hass, config, discovery_info=None): DCNL 'Return push service.'
def validatePort(switch, intf): DCNL 'Validate intf\'s OF port number'
@docfiller DCNL def convolve(input, weights, output=None, mode='reflect', cval=0.0, origin=0): DCNL 'Multidimensional convolution. DCNL The array is convolved with the given kernel. DCNL Parameters DCNL input : array_like DCNL Input array to filter. DCNL weights : array_like DCNL Array of weights, same number of dimensions as input DCNL output : ndarray, optional DCNL The `output` parameter passes an array in which to store the DCNL filter output. Output array should have different name as DCNL compared to input array to avoid aliasing errors. DCNL mode : {\'reflect\',\'constant\',\'nearest\',\'mirror\', \'wrap\'}, optional DCNL the `mode` parameter determines how the array borders are DCNL handled. For \'constant\' mode, values beyond borders are set to be DCNL `cval`. Default is \'reflect\'. DCNL cval : scalar, optional DCNL Value to fill past edges of input if `mode` is \'constant\'. Default DCNL is 0.0 DCNL origin : array_like, optional DCNL The `origin` parameter controls the placement of the filter, DCNL relative to the centre of the current element of the input. DCNL Default of 0 is equivalent to ``(0,)*input.ndim``. DCNL Returns DCNL result : ndarray DCNL The result of convolution of `input` with `weights`. DCNL See Also DCNL correlate : Correlate an image with a kernel. DCNL Notes DCNL Each value in result is :math:`C_i = \sum_j{I_{i+k-j} W_j}`, where DCNL W is the `weights` kernel, DCNL j is the n-D spatial index over :math:`W`, DCNL I is the `input` and k is the coordinate of the center of DCNL W, specified by `origin` in the input parameters. DCNL Examples DCNL Perhaps the simplest case to understand is ``mode=\'constant\', cval=0.0``, DCNL because in this case borders (i.e. where the `weights` kernel, centered DCNL on any one value, extends beyond an edge of `input`. DCNL >>> a = np.array([[1, 2, 0, 0], DCNL ...               [5, 3, 0, 4], DCNL ...               [0, 0, 0, 7], DCNL ...               [9, 3, 0, 0]]) DCNL >>> k = np.array([[1,1,1],[1,1,0],[1,0,0]]) DCNL >>> from scipy import ndimage DCNL >>> ndimage.convolve(a, k, mode=\'constant\', cval=0.0) DCNL array([[11, 10,  7,  4], DCNL [10,  3, 11, 11], DCNL [15, 12, 14,  7], DCNL [12,  3,  7,  0]]) DCNL Setting ``cval=1.0`` is equivalent to padding the outer edge of `input` DCNL with 1.0\'s (and then extracting only the original region of the result). DCNL >>> ndimage.convolve(a, k, mode=\'constant\', cval=1.0) DCNL array([[13, 11,  8,  7], DCNL [11,  3, 11, 14], DCNL [16, 12, 14, 10], DCNL [15,  6, 10,  5]]) DCNL With ``mode=\'reflect\'`` (the default), outer values are reflected at the DCNL edge of `input` to fill in missing values. DCNL >>> b = np.array([[2, 0, 0], DCNL ...               [1, 0, 0], DCNL ...               [0, 0, 0]]) DCNL >>> k = np.array([[0,1,0], [0,1,0], [0,1,0]]) DCNL >>> ndimage.convolve(b, k, mode=\'reflect\') DCNL array([[5, 0, 0], DCNL [3, 0, 0], DCNL [1, 0, 0]]) DCNL This includes diagonally at the corners. DCNL >>> k = np.array([[1,0,0],[0,1,0],[0,0,1]]) DCNL >>> ndimage.convolve(b, k) DCNL array([[4, 2, 0], DCNL [3, 2, 0], DCNL [1, 1, 0]]) DCNL With ``mode=\'nearest\'``, the single nearest value in to an edge in DCNL `input` is repeated as many times as needed to match the overlapping DCNL `weights`. DCNL >>> c = np.array([[2, 0, 1], DCNL ...               [1, 0, 0], DCNL ...               [0, 0, 0]]) DCNL >>> k = np.array([[0, 1, 0], DCNL ...               [0, 1, 0], DCNL ...               [0, 1, 0], DCNL ...               [0, 1, 0], DCNL ...               [0, 1, 0]]) DCNL >>> ndimage.convolve(c, k, mode=\'nearest\') DCNL array([[7, 0, 3], DCNL [5, 0, 2], DCNL [3, 0, 1]])'
def endtags(html): DCNL 'close all open html tags at the end of the string'
def sineModelAnal(x, fs, w, N, H, t, maxnSines=100, minSineDur=0.01, freqDevOffset=20, freqDevSlope=0.01): DCNL 'Analysis of a sound using the sinusoidal model with sine tracking DCNL x: input array sound, w: analysis window, N: size of complex spectrum, H: hop-size, t: threshold in negative dB DCNL maxnSines: maximum number of sines per frame, minSineDur: minimum duration of sines in seconds DCNL freqDevOffset: minimum frequency deviation at 0Hz, freqDevSlope: slope increase of minimum frequency deviation DCNL returns xtfreq, xtmag, xtphase: frequencies, magnitudes and phases of sinusoidal tracks'
def create_geq(lh_op, rh_op=None, constr_id=None): DCNL 'Creates an internal greater than or equal constraint. DCNL Parameters DCNL lh_term : LinOp DCNL The left-hand operator in the >= constraint. DCNL rh_term : LinOp DCNL The right-hand operator in the >= constraint. DCNL constr_id : int DCNL The id of the CVXPY equality constraint creating the constraint. DCNL Returns DCNL LinLeqConstr'
def get_current_module_name(): DCNL 'Returns the module name of the current instance. DCNL If this is version "v1" of module "module5" for app "my-app", this function DCNL will return "module5".'
def copyfile(src, dst): DCNL 'Copy data from src to dst'
def scale_timings(timelist, input_units, output_units, time_repetition): DCNL 'Scales timings given input and output units (scans/secs) DCNL Parameters DCNL timelist: list of times to scale DCNL input_units: \'secs\' or \'scans\' DCNL output_units: Ibid. DCNL time_repetition: float in seconds'
def _fit_edge(x, window_start, window_stop, interp_start, interp_stop, axis, polyorder, deriv, delta, y): DCNL 'Given an n-d array `x` and the specification of a slice of `x` from DCNL `window_start` to `window_stop` along `axis`, create an interpolating DCNL polynomial of each 1-d slice, and evaluate that polynomial in the slice DCNL from `interp_start` to `interp_stop`.  Put the result into the DCNL corresponding slice of `y`.'
def get_datetime_format(format='medium', locale=LC_TIME): DCNL 'Return the datetime formatting patterns used by the locale for the DCNL specified format. DCNL >>> get_datetime_format(locale=\'en_US\') DCNL u\'{1}, {0}\' DCNL :param format: the format to use, one of "full", "long", "medium", or DCNL "short" DCNL :param locale: the `Locale` object, or a locale string'
def encrypt_and_encode(data, key): DCNL 'Encrypts and endcodes `data` using `key\''
def offset_func(func, offset, *args): DCNL 'Offsets inputs by offset DCNL >>> double = lambda x: x * 2 DCNL >>> f = offset_func(double, (10,)) DCNL >>> f(1) DCNL 22 DCNL >>> f(300) DCNL 620'
def findMajorityElement(lst): DCNL 'lst: list of entries to find a majority element from DCNL return: majority element DCNL "Majority element" here refers to an element of a list that occurs the "majority" of the time (i.e. more than DCNL half of the elements are identical to the majority element). DCNL If no majority element is found, the function returns None.'
def _update_args(args, key, value): DCNL 'Add a new ``(key, value)`` pair to arguments ``dict``.'
def exampleCustomTags(): DCNL 'Simple example that exercises VLANStarTopo'
def downgrade(migrate_engine): DCNL 'Remove source volume id column to volumes.'
def unique_everseen(iterable, key=None): DCNL 'List unique elements, preserving order. Remember all elements ever seen.'
def describe_data(data): DCNL 'Return an :obj:`OrderedDict` describing the data DCNL Description contains keys "Data instances" (with the number of instances) DCNL and "Features", "Meta attributes" and "Targets" with the corresponding DCNL clipped lists of names. If the domain contains no meta attributes or DCNL targets, the value is `False`, which prevents it from being rendered. DCNL :param data: data DCNL :type data: Orange.data.Table DCNL :rtype: OrderedDict'
def samples_from_file(file_in, start=0, stop=(-1)): DCNL 'Read data from files, returns tuple (rate, np.array(.float64))'
def contrast_all_one(nm): DCNL 'contrast or restriction matrix for all against first comparison DCNL Parameters DCNL nm : int DCNL Returns DCNL contr : ndarray, 2d, (nm-1, nm) DCNL contrast matrix for all against first comparisons'
def _write_js(output_root, classes): DCNL 'Write the javascript fragments from all XModules in `classes` DCNL into `output_root` as individual files, hashed by the contents to remove DCNL duplicates'
@pytest.mark.parametrize('initial_text, DCSP edited_text', [('', 'Hello'), ('Hello', 'World'), ('H\xc3\xa4ll\xc3\xb6 DCSP W\xc3\xb6rld', '\xc3\x9cberpr\xc3\xbcfung'), ('\\u2603', '\\u2601')]) DCNL def test_modify(editor, initial_text, edited_text): DCNL 'Test if inputs get modified correctly.'
def set_register_stylesheet(obj): DCNL 'Set the stylesheet for an object based on it\'s STYLESHEET attribute. DCNL Also, register an update when the config is changed. DCNL Args: DCNL obj: The object to set the stylesheet for and register. DCNL Must have a STYLESHEET attribute.'
@dec.skip_win32 DCNL def test_arg_split(): DCNL 'Ensure that argument lines are correctly split like in a shell.'
def order_blocks(start_block, exit_block): DCNL 'Order blocks so that they are emitted in the right order'
@contextlib.contextmanager DCNL def register_dispatcher(disp): DCNL 'Register a Dispatcher for inference while it is not yet stored DCNL as global or closure variable (e.g. during execution of the @jit() DCNL call).  This allows resolution of recursive calls with eager DCNL compilation.'
def hash_rename(filename, hashvalue): DCNL 'renames a file given original filename and hash DCNL and sets path to output_directory'
def _check_set(ch, projs, ch_type): DCNL 'Helper to make sure type change is compatible with projectors.'
def test_step_description(): DCNL 'Step description takes a line and filename, and keeps the relative path for filename'
def get_horizontal_shift_value(label): DCNL 'Returns the value corresponding to a horizontal shift label int. DCNL The value is the int itself. This just sanity-checks the label for range DCNL errors. DCNL Parameters DCNL label: int DCNL Horizontal shift label.'
def find_diff(file1, file2): DCNL 'Find the differences between the two configuraiton files'
@logic.auth_audit_exempt DCNL def send_email_notifications(context, data_dict): DCNL 'Send any pending activity stream notification emails to users. DCNL You must provide a sysadmin\'s API key in the Authorization header of the DCNL request, or call this action from the command-line via a `paster post ...` DCNL command.'
def grey_closing(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0): DCNL 'Multi-dimensional greyscale closing. DCNL A greyscale closing consists in the succession of a greyscale dilation, DCNL and a greyscale erosion. DCNL Parameters DCNL input : array_like DCNL Array over which the grayscale closing is to be computed. DCNL size : tuple of ints DCNL Shape of a flat and full structuring element used for the grayscale DCNL closing. Optional if `footprint` or `structure` is provided. DCNL footprint : array of ints, optional DCNL Positions of non-infinite elements of a flat structuring element DCNL used for the grayscale closing. DCNL structure : array of ints, optional DCNL Structuring element used for the grayscale closing. `structure` DCNL may be a non-flat structuring element. DCNL output : array, optional DCNL An array used for storing the ouput of the closing may be provided. DCNL mode : {\'reflect\', \'constant\', \'nearest\', \'mirror\', \'wrap\'}, optional DCNL The `mode` parameter determines how the array borders are DCNL handled, where `cval` is the value when mode is equal to DCNL \'constant\'. Default is \'reflect\' DCNL cval : scalar, optional DCNL Value to fill past edges of input if `mode` is \'constant\'. Default DCNL is 0.0. DCNL origin : scalar, optional DCNL The `origin` parameter controls the placement of the filter. DCNL Default 0 DCNL Returns DCNL grey_closing : ndarray DCNL Result of the grayscale closing of `input` with `structure`. DCNL See also DCNL binary_closing, grey_dilation, grey_erosion, grey_opening, DCNL generate_binary_structure DCNL Notes DCNL The action of a grayscale closing with a flat structuring element amounts DCNL to smoothen deep local minima, whereas binary closing fills small holes. DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Mathematical_morphology DCNL Examples DCNL >>> from scipy import ndimage DCNL >>> a = np.arange(36).reshape((6,6)) DCNL >>> a[3,3] = 0 DCNL >>> a DCNL array([[ 0,  1,  2,  3,  4,  5], DCNL [ 6,  7,  8,  9, 10, 11], DCNL [12, 13, 14, 15, 16, 17], DCNL [18, 19, 20,  0, 22, 23], DCNL [24, 25, 26, 27, 28, 29], DCNL [30, 31, 32, 33, 34, 35]]) DCNL >>> ndimage.grey_closing(a, size=(3,3)) DCNL array([[ 7,  7,  8,  9, 10, 11], DCNL [ 7,  7,  8,  9, 10, 11], DCNL [13, 13, 14, 15, 16, 17], DCNL [19, 19, 20, 20, 22, 23], DCNL [25, 25, 26, 27, 28, 29], DCNL [31, 31, 32, 33, 34, 35]]) DCNL >>> # Note that the local minimum a[3,3] has disappeared'
def get_module(module_name): DCNL 'Loads a module and returns a specific object. DCNL module_name should \'module.file.object\'. DCNL Returns object or raises EAException on error.'
def wait_for_server(server, port): DCNL 'Wait for a server to respond with status 200'
def create_resource(): DCNL 'Image Members resource factory method'
def get_all_security_groups(groupnames=None, group_ids=None, filters=None, region=None, key=None, keyid=None, profile=None): DCNL 'Return a list of all Security Groups matching the given criteria and filters. DCNL Note that the \'groupnames\' argument only functions correctly for EC2 Classic DCNL and default VPC Security Groups.  To find groups by name in other VPCs you\'ll DCNL want to use the \'group-name\' filter instead. DCNL Valid keys for the filters argument are: DCNL description - The description of the security group. DCNL egress.ip-permission.prefix-list-id - The ID (prefix) of the AWS service to which the security group allows access. DCNL group-id - The ID of the security group. DCNL group-name - The name of the security group. DCNL ip-permission.cidr - A CIDR range that has been granted permission. DCNL ip-permission.from-port - The start of port range for the TCP and UDP protocols, or an ICMP type number. DCNL ip-permission.group-id - The ID of a security group that has been granted permission. DCNL ip-permission.group-name - The name of a security group that has been granted permission. DCNL ip-permission.protocol - The IP protocol for the permission (tcp | udp | icmp or a protocol number). DCNL ip-permission.to-port - The end of port range for the TCP and UDP protocols, or an ICMP code. DCNL ip-permission.user-id - The ID of an AWS account that has been granted permission. DCNL owner-id - The AWS account ID of the owner of the security group. DCNL tag-key - The key of a tag assigned to the security group. DCNL tag-value - The value of a tag assigned to the security group. DCNL vpc-id - The ID of the VPC specified when the security group was created. DCNL CLI example:: DCNL salt myminion boto_secgroup.get_all_security_groups filters=\'{group-name: mygroup}\''
def periodic_task(*args, **options): DCNL 'Decorator to create a task class out of any callable. DCNL .. admonition:: Examples DCNL .. code-block:: python DCNL @task DCNL def refresh_feed(url): DCNL return Feed.objects.get(url=url).refresh() DCNL With setting extra options and using retry. DCNL .. code-block:: python DCNL @task(exchange="feeds") DCNL def refresh_feed(url, **kwargs): DCNL try: DCNL return Feed.objects.get(url=url).refresh() DCNL except socket.error, exc: DCNL refresh_feed.retry(args=[url], kwargs=kwargs, exc=exc) DCNL Calling the resulting task: DCNL >>> refresh_feed("http://example.com/rss") # Regular DCNL <Feed: http://example.com/rss> DCNL >>> refresh_feed.delay("http://example.com/rss") # Async DCNL <AsyncResult: 8998d0f4-da0b-4669-ba03-d5ab5ac6ad5d>'
def stem(word, cached=True, history=10000, **kwargs): DCNL 'Returns the stem of the given word: ponies => poni. DCNL Note: it is often taken to be a crude error DCNL that a stemming algorithm does not leave a real word after removing the stem. DCNL But the purpose of stemming is to bring variant forms of a word together, DCNL not to map a word onto its "paradigm" form.'
def setup_proxy(element, config): DCNL 'Configure a GStreamer element with proxy settings. DCNL :param element: element to setup proxy in. DCNL :type element: :class:`Gst.GstElement` DCNL :param config: proxy settings to use. DCNL :type config: :class:`dict`'
@staff_member_required DCNL def security(request, template_name=u'admin/security.html'): DCNL 'Run security checks and report the results.'
def opts_to_pp(repair, unpack, delete): DCNL 'Convert (repair, unpack, delete) to numeric process options'
def python_3000_not_equal(logical_line): DCNL 'New code should always use != instead of <>. DCNL The older syntax is removed in Python 3. DCNL Okay: if a != \'no\': DCNL W603: if a <> \'no\':'
def get_context_iter(data, payload): DCNL ':param data: The HTML where the payload might be in DCNL :param payload: The payload as sent to the web application DCNL :return: A context iterator DCNL :see: https://github.com/andresriancho/w3af/issues/37'
def _get_item_key(item, key): DCNL 'Allow for lookups in nested dictionaries using \'.\'s within a key.'
def _TO_DATESTRING(obj): DCNL 'Creates datestring hash. DCNL Args: DCNL obj (Object): Database object. DCNL Returns: DCNL datestring (str): A datestring hash.'
def test(HandlerClass=BaseHTTPRequestHandler, ServerClass=HTTPServer, protocol='HTTP/1.0', port=8000, bind=''): DCNL 'Test the HTTP request handler class. DCNL This runs an HTTP server on port 8000 (or the first command line DCNL argument).'
def _dhtm(mag): DCNL 'Compute the modified 1D discrete Hilbert transform DCNL Parameters DCNL mag : ndarray DCNL The magnitude spectrum. Should be 1D with an even length, and DCNL preferably a fast length for FFT/IFFT.'
def handler(req): DCNL 'Execute the gluon app'
def channel_shift_multi(x, intensity, channel_index=2): DCNL 'Shift the channels of images with the same arguments, randomly or non-randomly, see `numpy.rollaxis <https://docs.scipy.org/doc/numpy/reference/generated/numpy.rollaxis.html>`_ . DCNL Usually be used for image segmentation which x=[X, Y], X and Y should be matched. DCNL Parameters DCNL x : list of numpy array DCNL List of images with dimension of [n_images, row, col, channel] (default). DCNL others : see ``channel_shift``.'
@requires_application() DCNL def test_regular_polygon_draw1(): DCNL 'Test drawing regular polygons without transforms using RegularPolygonVisual'
def _rfc3339_to_datetime(dt_str): DCNL 'Convert a microsecond-precision timetamp to a native datetime. DCNL :type dt_str: str DCNL :param dt_str: The string to convert. DCNL :rtype: :class:`datetime.datetime` DCNL :returns: The datetime object created from the string.'
def assign_regions(resource): DCNL 'Assign up to 5 regions to resource'
def load_path(path, target): DCNL 'Load dictionary implied by YAML file into target dictionary. DCNL Args: DCNL path: [string] Path to file containing YAML document text. DCNL target: [dict] To update from YAML.'
def test_smote_wrong_kind(): DCNL 'Test either if an error is raised when the wrong kind of SMOTE is DCNL given.'
@utils.arg('server', metavar='<server>', help=_('Name DCSP or DCSP ID DCSP of DCSP server.')) DCNL def do_unrescue(cs, args): DCNL 'Restart the server from normal boot disk again.'
def _diop_linear(var, coeff, param): DCNL 'Solves diophantine equations of the form: DCNL a_0*x_0 + a_1*x_1 + ... + a_n*x_n == c DCNL Note that no solution exists if gcd(a_0, ..., a_n) doesn\'t divide c.'
def force_link(src, dest): DCNL 'Link src to dest, overwriting it if it exists'
def test_rgb_to_hsl_part_2(): DCNL 'Test rgb to hsl color function'
def LocalService(name): DCNL 'The odoo.netsvc.LocalService() function is deprecated. It still works DCNL in two cases: workflows and reports. For workflows, instead of using DCNL LocalService(\'workflow\'), odoo.workflow should be used (better yet, DCNL methods on odoo.osv.orm.Model should be used). For reports, DCNL odoo.report.render_report() should be used (methods on the Model should DCNL be provided too in the future).'
@public DCNL def monic(f, *gens, **args): DCNL 'Divide all coefficients of ``f`` by ``LC(f)``. DCNL Examples DCNL >>> from sympy import monic DCNL >>> from sympy.abc import x DCNL >>> monic(3*x**2 + 4*x + 2) DCNL x**2 + 4*x/3 + 2/3'
def truncated(f): DCNL 'Ensure list truncation is detected in Driver list entity methods. DCNL This is designed to wrap Driver list_{entity} methods in order to DCNL calculate if the resultant list has been truncated. Provided a limit dict DCNL is found in the hints list, we increment the limit by one so as to ask the DCNL wrapped function for one more entity than the limit, and then once the list DCNL has been generated, we check to see if the original limit has been DCNL exceeded, in which case we truncate back to that limit and set the DCNL \'truncated\' boolean to \'true\' in the hints limit dict.'
def qtapi_version(): DCNL 'Return which QString API has been set, if any DCNL Returns DCNL The QString API version (1 or 2), or None if not set'
def get_docstring(node, clean=True): DCNL 'Return the docstring for the given node or None if no docstring can DCNL be found.  If the node provided does not have docstrings a TypeError DCNL will be raised.'
@contextmanager DCNL def setup_default_app(app, use_trap=False): DCNL 'Setup default app for testing. DCNL Ensures state is clean after the test returns.'
def unquote_to_bytes(string): DCNL 'unquote_to_bytes(\'abc%20def\') -> b\'abc def\'.'
def iprand_all(): DCNL 'Some ipython tests with fully random output. DCNL # all-random DCNL In [7]: 1 DCNL Out[7]: 99 DCNL In [8]: print(\'hello\') DCNL world DCNL In [9]: iprand_all() DCNL Out[9]: \'junk\''
def getManipulatedPaths(close, elementNode, loop, prefix, sideLength): DCNL 'Get inset path.'
def section_problem_grade_distrib(request, course_id, section): DCNL 'Creates a json with the grade distribution for the problems in the specified section. DCNL `request` django request DCNL `course_id` the course ID for the course interested in DCNL `section` The zero-based index of the section for the course DCNL Returns the format in dashboard_data.get_d3_section_grade_distrib DCNL If this is requested multiple times quickly for the same course, it is better to call all_problem_grade_distribution DCNL and pick out the sections of interest.'
def get_sql_sequence_reset(app): DCNL 'Returns a list of the SQL statements to reset PostgreSQL sequences for the given app.'
def get_makefile_filename(): DCNL 'Return full pathname of installed Makefile from the Python build.'
def get_technical_lengths(input_map, debug=False): DCNL 'Returns per-sample info on technical lengths. DCNL Note: KEY_SEQ, BARCODE and PRIMER fields are required. The LINKER DCNL field is optional.'
def fixup_simple_stmt(parent, i, stmt_node): DCNL 'if there is a semi-colon all the parts count as part of the same DCNL simple_stmt.  We just want the __metaclass__ part so we move DCNL everything efter the semi-colon into its own simple_stmt node'
def parse(handle, format, alphabet=None): DCNL 'Turns a sequence file into an iterator returning SeqRecords. DCNL - handle   - handle to the file, or the filename as a string DCNL (note older versions of Biopython only took a handle). DCNL - format   - lower case string describing the file format. DCNL - alphabet - optional Alphabet object, useful when the sequence type DCNL cannot be automatically inferred from the file itself DCNL (e.g. format="fasta" or "tab") DCNL Typical usage, opening a file to read in, and looping over the record(s): DCNL >>> from Bio import SeqIO DCNL >>> filename = "Fasta/sweetpea.nu" DCNL >>> for record in SeqIO.parse(filename, "fasta"): DCNL ...    print("ID %s" % record.id) DCNL ...    print("Sequence length %i" % len(record)) DCNL ...    print("Sequence alphabet %s" % record.seq.alphabet) DCNL ID gi|3176602|gb|U78617.1|LOU78617 DCNL Sequence length 309 DCNL Sequence alphabet SingleLetterAlphabet() DCNL For file formats like FASTA where the alphabet cannot be determined, it DCNL may be useful to specify the alphabet explicitly: DCNL >>> from Bio import SeqIO DCNL >>> from Bio.Alphabet import generic_dna DCNL >>> filename = "Fasta/sweetpea.nu" DCNL >>> for record in SeqIO.parse(filename, "fasta", generic_dna): DCNL ...    print("ID %s" % record.id) DCNL ...    print("Sequence length %i" % len(record)) DCNL ...    print("Sequence alphabet %s" % record.seq.alphabet) DCNL ID gi|3176602|gb|U78617.1|LOU78617 DCNL Sequence length 309 DCNL Sequence alphabet DNAAlphabet() DCNL If you have a string \'data\' containing the file contents, you must DCNL first turn this into a handle in order to parse it: DCNL >>> data = ">Alpha\nACCGGATGTA\n>Beta\nAGGCTCGGTTA\n" DCNL >>> from Bio import SeqIO DCNL >>> try: DCNL ...     from StringIO import StringIO # Python 2 DCNL ... except ImportError: DCNL ...     from io import StringIO # Python 3 DCNL >>> for record in SeqIO.parse(StringIO(data), "fasta"): DCNL ...     print("%s %s" % (record.id, record.seq)) DCNL Alpha ACCGGATGTA DCNL Beta AGGCTCGGTTA DCNL Use the Bio.SeqIO.read(...) function when you expect a single record DCNL only.'
def _send_message(room_id, message, from_name, api_key=None, api_version=None, api_url=None, color=None, notify=False): DCNL 'Send a message to a HipChat room. DCNL :param room_id:     The room id or room name, either will work. DCNL :param message:     The message to send to the HipChat room. DCNL :param from_name:   Specify who the message is from. DCNL :param api_url:     The HipChat API URL, if not specified in the configuration. DCNL :param api_key:     The HipChat api key, if not specified in the configuration. DCNL :param api_version: The HipChat api version, if not specified in the configuration. DCNL :param color:       The color for the message, default: yellow. DCNL :param notify:      Whether to notify the room, default: False. DCNL :return:            Boolean if message was sent successfully.'
def get_language_from_request(request): DCNL 'Analyzes the request to find what language the user wants the system to DCNL show. Only languages listed in settings.LANGUAGES are taken into account. DCNL If the user requests a sublanguage where we have a main language, we send DCNL out the main language.'
def create(context, entity_id, traversal_id, is_update, stack_id): DCNL 'Creates a sync point entry in DB.'
def freqs_zpk(z, p, k, worN=None): DCNL 'Compute frequency response of analog filter. DCNL Given the zeros `z`, poles `p`, and gain `k` of a filter, compute its DCNL frequency response:: DCNL (jw-z[0]) * (jw-z[1]) * ... * (jw-z[-1]) DCNL H(w) = k * ---------------------------------------- DCNL (jw-p[0]) * (jw-p[1]) * ... * (jw-p[-1]) DCNL Parameters DCNL z : array_like DCNL Zeroes of a linear filter DCNL p : array_like DCNL Poles of a linear filter DCNL k : scalar DCNL Gain of a linear filter DCNL worN : {None, int, array_like}, optional DCNL If None, then compute at 200 frequencies around the interesting parts DCNL of the response curve (determined by pole-zero locations).  If a single DCNL integer, then compute at that many frequencies.  Otherwise, compute the DCNL response at the angular frequencies (e.g. rad/s) given in `worN`. DCNL Returns DCNL w : ndarray DCNL The angular frequencies at which `h` was computed. DCNL h : ndarray DCNL The frequency response. DCNL See Also DCNL freqs : Compute the frequency response of an analog filter in TF form DCNL freqd : Compute the frequency response of a digital filter in TF form DCNL freqd_zpk : Compute the frequency response of a digital filter in ZPK form DCNL Notes DCNL .. versionadded: 0.19.0 DCNL Examples DCNL >>> from scipy.signal import freqs_zpk, iirfilter DCNL >>> z, p, k = iirfilter(4, [1, 10], 1, 60, analog=True, ftype=\'cheby1\', DCNL ...                     output=\'zpk\') DCNL >>> w, h = freqs_zpk(z, p, k, worN=np.logspace(-1, 2, 1000)) DCNL >>> import matplotlib.pyplot as plt DCNL >>> plt.semilogx(w, 20 * np.log10(abs(h))) DCNL >>> plt.xlabel(\'Frequency\') DCNL >>> plt.ylabel(\'Amplitude response [dB]\') DCNL >>> plt.grid() DCNL >>> plt.show()'
def validate_title(value): DCNL 'Validator for Node#title. Makes sure that the value exists and is not DCNL above 200 characters.'
def search_explorations(query, limit, sort=None, cursor=None): DCNL 'Searches through the available explorations. DCNL args: DCNL - query_string: the query string to search for. DCNL - sort: a string indicating how to sort results. This should be a string DCNL of space separated values. Each value should start with a \'+\' or a DCNL \'-\' character indicating whether to sort in ascending or descending DCNL order respectively. This character should be followed by a field name DCNL to sort on. When this is None, results are based on \'rank\'. See DCNL get_search_rank to see how rank is determined. DCNL - limit: the maximum number of results to return. DCNL - cursor: A cursor, used to get the next page of results. DCNL If there are more documents that match the query than \'limit\', this DCNL function will return a cursor to get the next page. DCNL returns: a 2-tuple consisting of: DCNL - a list of exploration ids that match the query. DCNL - a cursor if there are more matching explorations to fetch, None DCNL otherwise. If a cursor is returned, it will be a web-safe string that DCNL can be used in URLs.'
def captured_stdout(): DCNL 'Capture the output of sys.stdout: DCNL with captured_stdout() as stdout: DCNL print("hello") DCNL self.assertEqual(stdout.getvalue(), "hello'
def register_mimetype_handler(handler): DCNL 'Register a MimetypeHandler class. DCNL This will register a Mimetype Handler used by Review Board to render DCNL thumbnails for the file attachements across different mimetypes. DCNL Only MimetypeHandler subclasses are supported.'
def purge_deleted_rows(context, age_in_days, max_rows, session=None): DCNL 'Purges soft deleted rows DCNL Deletes rows of table images, table tasks and all dependent tables DCNL according to given age for relevant models.'
def test_bti2fiff(): DCNL 'Test mne bti2fiff.'
def reloaded(manager, containers, count, name): DCNL 'Ensure that exactly `count` matching containers exist and are DCNL running. If any associated settings have been changed (volumes, DCNL ports or so on), restart those containers.'
def build_pool(test_case): DCNL 'Create a ``StoragePool``. DCNL :param TestCase test_case: The test in which this pool will exist. DCNL :return: A new ``StoragePool``.'
def _fire_score_changed_for_block(course_id, student, block, module_state_key): DCNL 'Fires a PROBLEM_RAW_SCORE_CHANGED event for the given module. DCNL The earned points are always zero. We must retrieve the possible points DCNL from the XModule, as noted below. The effective time is now().'
@login_required DCNL @ensure_valid_course_key DCNL def submission_history(request, course_id, student_username, location): DCNL 'Render an HTML fragment (meant for inclusion elsewhere) that renders a DCNL history of all state changes made by this user for this problem location. DCNL Right now this only works for problems because that\'s all DCNL StudentModuleHistory records.'
def _readmailcapfile(fp, lineno): DCNL 'Read a mailcap file and return a dictionary keyed by MIME type. DCNL Each MIME type is mapped to an entry consisting of a list of DCNL dictionaries; the list will contain more than one such dictionary DCNL if a given MIME type appears more than once in the mailcap file. DCNL Each dictionary contains key-value pairs for that MIME type, where DCNL the viewing command is stored with the key "view".'
def timeuntil(d, now=None): DCNL 'Like timesince, but returns a string measuring the time until DCNL the given time.'
def run_job(tasks): DCNL 'Add the execution to the queue and waits until it is finished'
@contextmanager DCNL def assuming(*assumptions): DCNL 'Context manager for assumptions DCNL Examples DCNL >>> from sympy.assumptions import assuming, Q, ask DCNL >>> from sympy.abc import x, y DCNL >>> print(ask(Q.integer(x + y))) DCNL None DCNL >>> with assuming(Q.integer(x), Q.integer(y)): DCNL ...     print(ask(Q.integer(x + y))) DCNL True'
def double_redirect_view(request): DCNL 'A view that redirects all requests to a redirection view'
@hooks.register(u'before_serve_page') DCNL def check_view_restrictions(page, request, serve_args, serve_kwargs): DCNL 'Check whether there are any view restrictions on this page which are DCNL not fulfilled by the given request object. If there are, return an DCNL HttpResponse that will notify the user of that restriction (and possibly DCNL include a password / login form that will allow them to proceed). If DCNL there are no such restrictions, return None'
def close_all_open_files(exclude=set()): DCNL 'Close all open file descriptors. DCNL Closes every file descriptor (if open) of this process. If DCNL specified, `exclude` is a set of file descriptors to *not* DCNL close.'
def getstatementrange_old(lineno, source, assertion=False): DCNL 'return (start, end) tuple which spans the minimal DCNL statement region which containing the given lineno. DCNL raise an IndexError if no such statementrange can be found.'
def get_engine(hass, config): DCNL 'Setup Demo speech component.'
def replaceInFile(filename, oldToNew): DCNL 'I replace the text `oldstr\' with `newstr\' in `filename\' using science.'
def oversample(images, crop_dims): DCNL 'Crop an image into center, corners, and mirror images.'
@context.quietfunc DCNL @with_device DCNL def exists(path): DCNL 'Return :const:`True` if ``path`` exists on the target device. DCNL Examples: DCNL >>> adb.exists(\'/\') DCNL True DCNL >>> adb.exists(\'/init\') DCNL True DCNL >>> adb.exists(\'/does/not/exist\') DCNL False'
def decode_wanted(parts): DCNL 'Parse missing_check line parts to determine which parts of local DCNL diskfile were wanted by the receiver. DCNL The encoder for parts is DCNL :py:func:`~swift.obj.ssync_receiver.encode_wanted`'
def random_all(): DCNL 'A function where we ignore the output of ALL examples. DCNL Examples: DCNL # all-random DCNL This mark tells the testing machinery that all subsequent examples should DCNL be treated as random (ignoring their output).  They are still executed, DCNL so if a they raise an error, it will be detected as such, but their DCNL output is completely ignored. DCNL >>> 1+3 DCNL junk goes here... DCNL >>> 1+3 DCNL klasdfj; DCNL >>> 1+2 DCNL again,  anything goes DCNL blah...'
def read_headers(rfile, hdict=None): DCNL 'Read headers from the given stream into the given header dict. DCNL If hdict is None, a new header dict is created. Returns the populated DCNL header dict. DCNL Headers which are repeated are folded together using a comma if their DCNL specification so dictates. DCNL This function raises ValueError when the read bytes violate the HTTP spec. DCNL You should probably return "400 Bad Request" if this happens.'
def get_service(hass, config, discovery_info=None): DCNL 'Return the notify service.'
def linkage(y, method='single', metric='euclidean'): DCNL 'Performs hierarchical/agglomerative clustering. DCNL The input y may be either a 1d compressed distance matrix DCNL or a 2d array of observation vectors. DCNL If y is a 1d compressed distance matrix, DCNL then y must be a :math:`{n \choose 2}` sized DCNL vector where n is the number of original observations paired DCNL in the distance matrix. The behavior of this function is very DCNL similar to the MATLAB linkage function. DCNL A :math:`(n-1)` by 4 matrix ``Z`` is returned. At the DCNL :math:`i`-th iteration, clusters with indices ``Z[i, 0]`` and DCNL ``Z[i, 1]`` are combined to form cluster :math:`n + i`. A DCNL cluster with an index less than :math:`n` corresponds to one of DCNL the :math:`n` original observations. The distance between DCNL clusters ``Z[i, 0]`` and ``Z[i, 1]`` is given by ``Z[i, 2]``. The DCNL fourth value ``Z[i, 3]`` represents the number of original DCNL observations in the newly formed cluster. DCNL The following linkage methods are used to compute the distance DCNL :math:`d(s, t)` between two clusters :math:`s` and DCNL :math:`t`. The algorithm begins with a forest of clusters that DCNL have yet to be used in the hierarchy being formed. When two DCNL clusters :math:`s` and :math:`t` from this forest are combined DCNL into a single cluster :math:`u`, :math:`s` and :math:`t` are DCNL removed from the forest, and :math:`u` is added to the DCNL forest. When only one cluster remains in the forest, the algorithm DCNL stops, and this cluster becomes the root. DCNL A distance matrix is maintained at each iteration. The ``d[i,j]`` DCNL entry corresponds to the distance between cluster :math:`i` and DCNL :math:`j` in the original forest. DCNL At each iteration, the algorithm must update the distance matrix DCNL to reflect the distance of the newly formed cluster u with the DCNL remaining clusters in the forest. DCNL Suppose there are :math:`|u|` original observations DCNL :math:`u[0], \ldots, u[|u|-1]` in cluster :math:`u` and DCNL :math:`|v|` original objects :math:`v[0], \ldots, v[|v|-1]` in DCNL cluster :math:`v`. Recall :math:`s` and :math:`t` are DCNL combined to form cluster :math:`u`. Let :math:`v` be any DCNL remaining cluster in the forest that is not :math:`u`. DCNL The following are methods for calculating the distance between the DCNL newly formed cluster :math:`u` and each :math:`v`. DCNL * method=\'single\' assigns DCNL .. math:: DCNL d(u,v) = \min(dist(u[i],v[j])) DCNL for all points :math:`i` in cluster :math:`u` and DCNL :math:`j` in cluster :math:`v`. This is also known as the DCNL Nearest Point Algorithm. DCNL * method=\'complete\' assigns DCNL .. math:: DCNL d(u, v) = \max(dist(u[i],v[j])) DCNL for all points :math:`i` in cluster u and :math:`j` in DCNL cluster :math:`v`. This is also known by the Farthest Point DCNL Algorithm or Voor Hees Algorithm. DCNL * method=\'average\' assigns DCNL .. math:: DCNL d(u,v) = \sum_{ij} \frac{d(u[i], v[j])} DCNL {(|u|*|v|)} DCNL for all points :math:`i` and :math:`j` where :math:`|u|` DCNL and :math:`|v|` are the cardinalities of clusters :math:`u` DCNL and :math:`v`, respectively. This is also called the UPGMA DCNL algorithm. DCNL * method=\'weighted\' assigns DCNL .. math:: DCNL d(u,v) = (dist(s,v) + dist(t,v))/2 DCNL where cluster u was formed with cluster s and t and v DCNL is a remaining cluster in the forest. (also called WPGMA) DCNL * method=\'centroid\' assigns DCNL .. math:: DCNL dist(s,t) = ||c_s-c_t||_2 DCNL where :math:`c_s` and :math:`c_t` are the centroids of DCNL clusters :math:`s` and :math:`t`, respectively. When two DCNL clusters :math:`s` and :math:`t` are combined into a new DCNL cluster :math:`u`, the new centroid is computed over all the DCNL original objects in clusters :math:`s` and :math:`t`. The DCNL distance then becomes the Euclidean distance between the DCNL centroid of :math:`u` and the centroid of a remaining cluster DCNL :math:`v` in the forest. This is also known as the UPGMC DCNL algorithm. DCNL * method=\'median\' assigns :math:`d(s,t)` like the ``centroid`` DCNL method. When two clusters :math:`s` and :math:`t` are combined DCNL into a new cluster :math:`u`, the average of centroids s and t DCNL give the new centroid :math:`u`. This is also known as the DCNL WPGMC algorithm. DCNL * method=\'ward\' uses the Ward variance minimization algorithm. DCNL The new entry :math:`d(u,v)` is computed as follows, DCNL .. math:: DCNL d(u,v) = \sqrt{\frac{|v|+|s|} DCNL {T}d(v,s)^2 DCNL + \frac{|v|+|t|} DCNL {T}d(v,t)^2 DCNL - \frac{|v|} DCNL {T}d(s,t)^2} DCNL where :math:`u` is the newly joined cluster consisting of DCNL clusters :math:`s` and :math:`t`, :math:`v` is an unused DCNL cluster in the forest, :math:`T=|v|+|s|+|t|`, and DCNL :math:`|*|` is the cardinality of its argument. This is also DCNL known as the incremental algorithm. DCNL Warning: When the minimum distance pair in the forest is chosen, there DCNL may be two or more pairs with the same minimum distance. This DCNL implementation may chose a different minimum than the MATLAB DCNL version. DCNL Parameters DCNL y : ndarray DCNL A condensed distance matrix. A condensed distance matrix DCNL is a flat array containing the upper triangular of the distance matrix. DCNL This is the form that ``pdist`` returns. Alternatively, a collection of DCNL :math:`m` observation vectors in :math:`n` dimensions may be passed as an DCNL :math:`m` by :math:`n` array. All elements of the condensed distance matrix DCNL must be finite, i.e. no NaNs or infs. DCNL method : str, optional DCNL The linkage algorithm to use. See the ``Linkage Methods`` section below DCNL for full descriptions. DCNL metric : str or function, optional DCNL The distance metric to use in the case that y is a collection of DCNL observation vectors; ignored otherwise. See the ``pdist`` DCNL function for a list of valid distance metrics. A custom distance DCNL function can also be used. DCNL Returns DCNL Z : ndarray DCNL The hierarchical clustering encoded as a linkage matrix. DCNL Notes DCNL 1. For method \'single\' an optimized algorithm based on minimum spanning DCNL tree is implemented. It has time complexity :math:`O(n^2)`. DCNL For methods \'complete\', \'average\', \'weighted\' and \'ward\' an algorithm DCNL called nearest-neighbors chain is implemented. It also has time DCNL complexity :math:`O(n^2)`. DCNL For other methods a naive algorithm is implemented with :math:`O(n^3)` DCNL time complexity. DCNL All algorithms use :math:`O(n^2)` memory. DCNL Refer to [1]_ for details about the algorithms. DCNL 2. Methods \'centroid\', \'median\' and \'ward\' are correctly defined only if DCNL Euclidean pairwise metric is used. If `y` is passed as precomputed DCNL pairwise distances, then it is a user responsibility to assure that DCNL these distances are in fact Euclidean, otherwise the produced result DCNL will be incorrect. DCNL See Also DCNL scipy.spatial.distance.pdist : pairwise distance metrics DCNL References DCNL .. [1] Daniel Mullner, "Modern hierarchical, agglomerative clustering DCNL algorithms", :arXiv:`1109.2378v1`.'
@handle_response_format DCNL @treeio_login_required DCNL def account_edit(request, response_format='html'): DCNL 'Account edit'
def people_type(): DCNL 'REST Controller'
def captured_stdout(): DCNL 'Capture the output of sys.stdout: DCNL with captured_stdout() as stdout: DCNL print(\'hello\') DCNL self.assertEqual(stdout.getvalue(), \'hello DCNL Taken from Lib/support/__init__.py in the CPython repo.'
@Profiler.profile DCNL def test_flush_pk_given(n): DCNL 'Batched INSERT statements via the ORM, PKs already defined'
@api_wrapper DCNL def get_export(module, filesystem, system): DCNL 'Retrun export if found. When not found return None'
@login_required DCNL @permission_required('flagit.can_moderate') DCNL def queue(request, content_type=None): DCNL 'The moderation queue.'
@ensure_csrf_cookie DCNL @cache_control(no_cache=True, no_store=True, must_revalidate=True) DCNL @require_level('staff') DCNL def get_anon_ids(request, course_id): DCNL 'Respond with 2-column CSV output of user-id, anonymized-user-id'
def rte_classifier(trainer, features=rte_features): DCNL 'Classify RTEPairs'
def main(sys_argv): DCNL 'Run all tests in the project. DCNL Arguments: DCNL sys_argv: a reference to sys.argv.'
def config(settings): DCNL 'Template settings for Save the Children Philippines'
def urlquote(val): DCNL 'Quotes a string for use in a URL. DCNL >>> urlquote(\'://?f=1&j=1\') DCNL \'%3A//%3Ff%3D1%26j%3D1\' DCNL >>> urlquote(None) DCNL >>> urlquote(u\'\u203d\') DCNL \'%E2%80%BD\''
def disk_usage(path): DCNL 'Return disk usage associated with path. DCNL Note: UNIX usually reserves 5% disk space which is not accessible DCNL by user. In this function "total" and "used" values reflect the DCNL total and used disk space whereas "free" and "percent" represent DCNL the "free" and "used percent" user disk space.'
def sql_demo(): DCNL 'Print out every row from the \'city.db\' database.'
def get_unmounted_partition_list(root_part, job=None, min_blocks=0, filter_func=None, exclude_swap=True, open_func=open): DCNL 'Return a list of partition objects that are not mounted. DCNL :param root_part: The root device name (without the \'/dev/\' prefix, example DCNL \'hda2\') that will be filtered from the partition list. DCNL Reasoning: in Linux /proc/mounts will never directly mention the DCNL root partition as being mounted on / instead it will say that DCNL /dev/root is mounted on /. Thus require this argument to filter out DCNL the root_part from the ones checked to be mounted. DCNL :param job, min_blocks, filter_func, exclude_swap, open_func: Forwarded DCNL to get_partition_list(). DCNL :return: List of L{partition} objects that are not mounted.'
def get_slug(): DCNL 'Get slug'
@task(base=BaseInstructorTask, routing_key=settings.GRADES_DOWNLOAD_ROUTING_KEY) DCNL def calculate_grades_csv(entry_id, xmodule_instance_args): DCNL 'Grade a course and push the results to an S3 bucket for download.'
def do_vcs_install(manifest_in, versionfile_source, ipy): DCNL 'Git-specific installation logic for Versioneer. DCNL For Git, this means creating/changing .gitattributes to mark _version.py DCNL for export-time keyword substitution.'
def getGeometryOutputByManipulation(geometryOutput, xmlElement): DCNL 'Get geometryOutput manipulated by the plugins in the manipulation shapes & solids folders.'
def get_patch_verts(patch): DCNL 'Return a list of vertices for the path of a patch.'
def kegg_find(database, query, option=None): DCNL 'KEGG find - Data search. DCNL Finds entries with matching query keywords or other query data in DCNL a given database. DCNL db - database or organism (string) DCNL query - search terms (string) DCNL option - search option (string), see below. DCNL For the compound and drug database, set option to the string \'formula\', DCNL \'exact_mass\' or \'mol_weight\' to search on that field only. The DCNL chemical formula search is a partial match irrespective of the order DCNL of atoms given. The exact mass (or molecular weight) is checked by DCNL rounding off to the same decimal place as the query data. A range of DCNL values may also be specified with the minus(-) sign.'
def CheckInstalledVersion(name, desired, explicit): DCNL 'Check that the installed version of a package is acceptable. DCNL Args: DCNL name: Name of package. DCNL desired: Desired version string. DCNL explicit: Explicitly requested by the user or implicitly because of a DCNL dependency. DCNL Raises: DCNL UnacceptableVersionError if the installed version of a package is DCNL unacceptable.'
@register.inclusion_tag(u'admin/feincms/content_type_selection_widget.html', takes_context=True) DCNL def show_content_type_selection_widget(context, region): DCNL '{% show_content_type_selection_widget region %}'
def restrict(permission): DCNL 'Marks a decorated function as requiring ``permission``. DCNL If the invoking user doesn\'t have one, :class:`SecurityError` is raised.'
def post(): DCNL 'RESTful CRUD controller'
def logsafe(val): DCNL 'Coerce a potentially "problematic" value so it can be formatted DCNL in a Unicode log string. DCNL This works around a number of pitfalls when logging objects in DCNL Python 2: DCNL - Logging path names, which must be byte strings, requires DCNL conversion for output. DCNL - Some objects, including some exceptions, will crash when you call DCNL `unicode(v)` while `str(v)` works fine. CalledProcessError is an DCNL example.'
def cleanRequestURL(url): DCNL 'Clean a URL from a Request line.'
def test_cc_fit_single_class(): DCNL 'Test either if an error when there is a single class'
def _cluster_to_basic_summary(cluster, now=None): DCNL 'Extract fields such as creation time, owner, etc. from the cluster, DCNL so we can safely reference them without using :py:func:`getattr`. DCNL :param cluster: a :py:class:`boto.emr.EmrObject` DCNL :param now: the current UTC time, as a :py:class:`datetime.datetime`. DCNL Defaults to the current time. DCNL Returns a dictionary with the following keys. These will be ``None`` if the DCNL corresponding field in the cluster is unavailable. DCNL * *created*: UTC `datetime.datetime` that the cluster was created, DCNL or ``None`` DCNL * *end*: UTC `datetime.datetime` that the cluster finished, or ``None`` DCNL * *id*: cluster ID, or ``None`` (this should never happen) DCNL * *label*: The label for the cluster (usually the module name of the DCNL :py:class:`~mrjob.job.MRJob` script that started it), or DCNL ``None`` for non-:py:mod:`mrjob` clusters. DCNL * *name*: cluster name, or ``None`` (this should never happen) DCNL * *nih*: number of normalized instance hours used by the cluster. DCNL * *num_steps*: Number of steps in the cluster. DCNL * *owner*: The owner for the cluster (usually the user that started it), DCNL or ``None`` for non-:py:mod:`mrjob` clusters. DCNL * *pool*: pool name (e.g. ``\'default\'``) if the cluster is pooled, DCNL otherwise ``None``. DCNL * *ran*: How long the cluster ran, or has been running, as a DCNL :py:class:`datetime.timedelta`. This will be ``timedelta(0)`` if DCNL the cluster hasn\'t started. DCNL * *ready*: UTC `datetime.datetime` that the cluster finished DCNL bootstrapping, or ``None`` DCNL * *state*: The cluster\'s state as a string (e.g. ``\'RUNNING\'``)'
def _auc(y_true, y_score): DCNL 'Alternative implementation to check for correctness of DCNL `roc_auc_score`.'
def is_interactive(): DCNL 'General API for a script specifying that it is being run in an DCNL interactive environment. Many libraries may wish to change their DCNL behavior based on being interactive (e.g. disabling signal DCNL handlers on Ctrl-C). DCNL @return: True if interactive flag has been set DCNL @rtype: bool'
def get_dataset_toy(): DCNL 'The toy dataset is only meant to used for testing pipelines. DCNL Do not try to visualize weights on it. It is not picture and DCNL has no color channel info to support visualization'
def _create_image_html(figure, area_data, plot_info): DCNL 'Given the figure and drilldown data, construct the HTML that will render the DCNL graph as a PNG image, and attach the image map to that image. DCNL figure: figure containing the drawn plot(s) DCNL area_data: list of parameters for each area of the image map. See the DCNL definition of the template string \'_AREA_TEMPLATE\' DCNL plot_info: a MetricsPlot or QualHistogram'
def save_gamestate_to_sgf(gamestate, path, filename, black_player_name='Unknown', white_player_name='Unknown', size=19, komi=7.5): DCNL 'Creates a simplified sgf for viewing playouts or positions'
@must_have_permission(ADMIN) DCNL @must_be_valid_project DCNL def new_draft_registration(auth, node, *args, **kwargs): DCNL 'Create a new draft registration for the node DCNL :return: Redirect to the new draft\'s edit page DCNL :rtype: flask.redirect DCNL :raises: HTTPError'
def tree_item_iterator(items, ancestors=False): DCNL 'Given a list of tree items, iterates over the list, generating DCNL two-tuples of the current tree item and a ``dict`` containing DCNL information about the tree structure around the item, with the DCNL following keys: DCNL ``\'new_level\'`` DCNL ``True`` if the current item is the start of a new level in DCNL the tree, ``False`` otherwise. DCNL ``\'closed_levels\'`` DCNL A list of levels which end after the current item. This will DCNL be an empty list if the next item is at the same level as the DCNL current item. DCNL If ``ancestors`` is ``True``, the following key will also be DCNL available: DCNL ``\'ancestors\'`` DCNL A list of unicode representations of the ancestors of the DCNL current node, in descending order (root node first, immediate DCNL parent last). DCNL For example: given the sample tree below, the contents of the DCNL list which would be available under the ``\'ancestors\'`` key DCNL are given on the right:: DCNL Books                    ->  [] DCNL Sci-fi                ->  [u\'Books\'] DCNL Dystopian Futures  ->  [u\'Books\', u\'Sci-fi\']'
def ensure_treasury_data(bm_symbol, first_date, last_date, now): DCNL 'Ensure we have treasury data from treasury module associated with DCNL `bm_symbol`. DCNL Parameters DCNL bm_symbol : str DCNL Benchmark symbol for which we\'re loading associated treasury curves. DCNL first_date : pd.Timestamp DCNL First date required to be in the cache. DCNL last_date : pd.Timestamp DCNL Last date required to be in the cache. DCNL now : pd.Timestamp DCNL The current time.  This is used to prevent repeated attempts to DCNL re-download data that isn\'t available due to scheduling quirks or other DCNL failures. DCNL We attempt to download data unless we already have data stored in the cache DCNL for `module_name` whose first entry is before or on `first_date` and whose DCNL last entry is on or after `last_date`. DCNL If we perform a download and the cache criteria are not satisfied, we wait DCNL at least one hour before attempting a redownload.  This is determined by DCNL comparing the current time to the result of os.path.getmtime on the cache DCNL path.'
def _make_compatible_taxa_summaries(ts1, ts2, sample_id_map=None): DCNL 'Returns two taxa summaries that are ready for direct comparison. DCNL The returned taxa summaries will have their samples ordered such that DCNL direct comparisons may be made between each of the corresponding samples in DCNL the two summaries. For example, if ts1 has samples \'S1\' and \'S2\' and ts2 DCNL has samples \'S2\' and \'S3\' (and no sample ID map is provided), the resulting DCNL taxa summaries will only have the sample \'S2\'. DCNL As another example, assume ts1 has samples \'S1\' and \'S2\' and ts2 has DCNL samples \'T1\' and \'T2\'. A sample ID map may be provided that maps \'S1\' to DCNL \'T1\' and \'S2\' to \'T2\'. The first resulting compatible taxa summary DCNL will have the samples \'S1\' and \'S2\' and the second resulting compatible DCNL taxa summary will have samples \'T1\' and \'T2\'. Thus, these resulting taxa DCNL summaries can be directly compared because each sample lines up to the one DCNL it needs to be compared to. DCNL The input taxa summaries do not need to be already sorted and filled, but DCNL it is okay if they are. The taxonomic information is not altered by this DCNL function, only the order and presence/absence of samples (i.e. columns in DCNL the table). It is a good idea to sort and filter the taxa summaries (either DCNL before or after) before computing the correlation coefficients between DCNL samples. DCNL Arguments: DCNL ts1 - the first taxa summary DCNL ts2 - the second taxa summary DCNL sample_id_map - a dictionary describing which samples in the first taxa DCNL summary should be compared to which samples in the second taxa DCNL summary. If not provided, only samples whose sample IDs directly DCNL match will be compared'
def setSliceElementZ(decimalPlacesCarried, sliceElement, sliceElementIndex, z): DCNL 'Set the slice element z.'
def format_decimal(number, format=None, locale=LC_NUMERIC): DCNL 'Return the given decimal number formatted for a specific locale. DCNL >>> format_decimal(1.2345, locale=\'en_US\') DCNL u\'1.234\' DCNL >>> format_decimal(1.2346, locale=\'en_US\') DCNL u\'1.235\' DCNL >>> format_decimal(-1.2346, locale=\'en_US\') DCNL u\'-1.235\' DCNL >>> format_decimal(1.2345, locale=\'sv_SE\') DCNL u\'1,234\' DCNL >>> format_decimal(12345, locale=\'de\') DCNL u\'12.345\' DCNL The appropriate thousands grouping and the decimal separator are used for DCNL each locale: DCNL >>> format_decimal(12345.5, locale=\'en_US\') DCNL u\'12,345.5\' DCNL :param number: the number to format DCNL :param format: DCNL :param locale: the `Locale` object or locale identifier DCNL :return: the formatted decimal number DCNL :rtype: `unicode`'
def _count1Bits(num): DCNL 'Find the highest bit set to 1 in an integer.'
def compute_node_utilization_set(context, host, free_ram_mb=None, free_disk_gb=None, work=None, vms=None): DCNL 'Like compute_node_utilization_update() modify a specific host DCNL entry. But this function will set the metrics absolutely DCNL (vs. a delta update).'
def _set_contour_locator(vmin, vmax, contours): DCNL 'Function for setting correct contour levels.'
def get_instance_type_access_by_flavor_id(flavorid, ctxt=None): DCNL 'Retrieve instance type access list by flavor id.'
def holdReject(): DCNL 'HOLD REJECT Section 9.3.12'
def customize_config_vars(_config_vars): DCNL 'Customize Python build configuration variables. DCNL Called internally from sysconfig with a mutable mapping DCNL containing name/value pairs parsed from the configured DCNL makefile used to build this interpreter.  Returns DCNL the mapping updated as needed to reflect the environment DCNL in which the interpreter is running; in the case of DCNL a Python from a binary installer, the installed DCNL environment may be very different from the build DCNL environment, i.e. different OS levels, different DCNL built tools, different available CPU architectures. DCNL This customization is performed whenever DCNL distutils.sysconfig.get_config_vars() is first DCNL called.  It may be used in environments where no DCNL compilers are present, i.e. when installing pure DCNL Python dists.  Customization of compiler paths DCNL and detection of unavailable archs is deferred DCNL until the first extension module build is DCNL requested (in distutils.sysconfig.customize_compiler). DCNL Currently called from distutils.sysconfig'
def test_tanimoto_distances(): DCNL 'Check that the pairwise Tanimoto distances computation'
def rmtree(path): DCNL 'Remove the given recursively. DCNL :note: we use shutil rmtree but adjust its behaviour to see whether files that DCNL couldn\'t be deleted are read-only. Windows will not remove them in that case'
def cc_benchmark(name, deps=[], **kwargs): DCNL 'cc_benchmark target.'
def getcfs(key, filename, filter=None): DCNL 'Caches the *filtered* file `filename` with `key` until the file is DCNL modified. DCNL Args: DCNL key(str): the cache key DCNL filename: the file to cache DCNL filter: is the function used for filtering. Normally `filename` is a DCNL .py file and `filter` is a function that bytecode compiles the file. DCNL In this way the bytecode compiled file is cached. (Default = None) DCNL This is used on Google App Engine since pyc files cannot be saved.'
def read_dot(path): DCNL 'Return a NetworkX graph from a dot file on path. DCNL Parameters DCNL path : file or string DCNL File name or file handle to read.'
def EvalBinomialPmf(k, n, p): DCNL 'Evaluates the binomial PMF. DCNL Returns the probabily of k successes in n trials with probability p.'
def dict_to_str(args, sep=u'&'): DCNL 'Converts a dictionary to URL'
def unbare_repo(func): DCNL 'Methods with this decorator raise InvalidGitRepositoryError if they DCNL encounter a bare repository'
def calc_dihedral(v1, v2, v3, v4): DCNL 'Calculate the dihedral angle between 4 vectors DCNL representing 4 connected points. The angle is in DCNL ]-pi, pi]. DCNL @param v1, v2, v3, v4: the four points that define the dihedral angle DCNL @type v1, v2, v3, v4: L{Vector}'
def __virtual__(): DCNL 'By default, this will be available on all platforms; but not all distros DCNL will necessarily be supported'
def search_by_name(service, name, **kwargs): DCNL 'Search for the entity by its name. Nested entities don\'t support search DCNL via REST, so in case using search for nested entity we return all entities DCNL and filter them by name. DCNL :param service: service of the entity DCNL :param name: name of the entity DCNL :return: Entity object returned by Python SDK'
def blank_lines(logical_line, blank_lines, indent_level, line_number, previous_logical, previous_indent_level): DCNL 'Separate top-level function and class definitions with two blank lines. DCNL Method definitions inside a class are separated by a single blank line. DCNL Extra blank lines may be used (sparingly) to separate groups of related DCNL functions.  Blank lines may be omitted between a bunch of related DCNL one-liners (e.g. a set of dummy implementations). DCNL Use blank lines in functions, sparingly, to indicate logical sections. DCNL Okay: def a():\n    pass\n\n\ndef b():\n    pass DCNL Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass DCNL E301: class Foo:\n    b = 0\n    def bar():\n        pass DCNL E302: def a():\n    pass\n\ndef b(n):\n    pass DCNL E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass DCNL E303: def a():\n\n\n\n    pass DCNL E304: @decorator\n\ndef a():\n    pass'
def _deferGenerator(g, deferred): DCNL 'See L{deferredGenerator}.'
@gen.coroutine DCNL def QueryViewpoints(client, obj_store, user_id, device_id, request): DCNL 'Queries viewpoint metadata, as well as associated followers and episodes.'
def service_mapping(services, registry_path=DEFAULT_REGISTRY_PATH): DCNL 'Create a services mapping for use with webapp. DCNL Creates basic default configuration and registration for ProtoRPC services. DCNL Each service listed in the service mapping has a standard service handler DCNL factory created for it. DCNL The list of mappings can either be an explicit path to service mapping or DCNL just services.  If mappings are just services, they will automatically DCNL be mapped to their default name.  For exampel: DCNL package = \'my_package\' DCNL class MyService(remote.Service): DCNL server_mapping([(\'/my_path\', MyService),  # Maps to /my_path DCNL MyService,                # Maps to /my_package/MyService DCNL Specifying a service mapping: DCNL Normally services are mapped to URL paths by specifying a tuple DCNL (path, service): DCNL path: The path the service resides on. DCNL service: The service class or service factory for creating new instances DCNL of the service.  For more information about service factories, please DCNL see remote.Service.new_factory. DCNL If no tuple is provided, and therefore no path specified, a default path DCNL is calculated by using the fully qualified service name using a URL path DCNL separator for each of its components instead of a \'.\'. DCNL Args: DCNL services: Can be service type, service factory or string definition name of DCNL service being mapped or list of tuples (path, service): DCNL path: Path on server to map service to. DCNL service: Service type, service factory or string definition name of DCNL service being mapped. DCNL Can also be a dict.  If so, the keys are treated as the path and values as DCNL the service. DCNL registry_path: Path to give to registry service.  Use None to disable DCNL registry service. DCNL Returns: DCNL List of tuples defining a mapping of request handlers compatible with a DCNL webapp application. DCNL Raises: DCNL ServiceConfigurationError when duplicate paths are provided.'
@register.filter(name='user_which_groups') DCNL def user_which_group(user, member): DCNL 'instance is a user object, DCNL use to get the group of the user DCNL :param instance: DCNL :param member: DCNL :return:'
def failure_code(sub): DCNL 'Code contained in sub[\'fail\'], usually substituted for %(fail)s. DCNL It sets information about current error, then goto the code DCNL actually handling the failure, which is defined in struct_gen().'
def generate_change(branch, old_revno=None, old_revid=None, new_revno=None, new_revid=None, blame_merge_author=False): DCNL 'Return a dict of information about a change to the branch. DCNL Dict has keys of "files", "who", "comments", and "revision", as used by DCNL the buildbot Change (and the PBChangeSource). DCNL If only the branch is given, the most recent change is returned. DCNL If only the new_revno is given, the comparison is expected to be between DCNL it and the previous revno (new_revno -1) in the branch. DCNL Passing old_revid and new_revid is only an optimization, included because DCNL bzr hooks usually provide this information. DCNL blame_merge_author means that the author of the merged branch is DCNL identified as the "who", not the person who committed the branch itself. DCNL This is typically used for PQM.'
def _simplify_variable_coeff(sol, syms, func, funcarg): DCNL 'Helper function to replace constants by functions in 1st_linear_variable_coeff'
def ex(e): DCNL 'Returns a unicode string from the exception text if it exists.'
def _compile_from_parse_tree(root_node, *a, **kw): DCNL 'Compile grammar (given as parse tree), returning a `CompiledGrammar` DCNL instance.'
def deb_packages(attrs=None, where=None): DCNL 'Return deb_packages information from osquery DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' osquery.deb_packages'
def setvcpus(vm_, vcpus, config=False): DCNL 'Changes the amount of vcpus allocated to VM. The VM must be shutdown DCNL for this to work. DCNL vcpus is an int representing the number to be assigned DCNL If config is True then we ask libvirt to modify the config as well DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' virt.setvcpus <domain> <amount> DCNL salt \'*\' virt.setvcpus my_domain 4'
def cmd(name, fun=None, arg=(), **kwargs): DCNL 'Execute a runner async: DCNL USAGE: DCNL .. code-block:: yaml DCNL run_cloud: DCNL runner.cmd: DCNL - fun: cloud.create DCNL - arg: DCNL - my-ec2-config DCNL - myinstance DCNL run_cloud: DCNL runner.cmd: DCNL - fun: cloud.create DCNL - kwargs: DCNL provider: my-ec2-config DCNL instances: myinstance'
def pluralize(word, pos=NOUN, custom={}, classical=True): DCNL 'Returns the plural of a given word, e.g., child => children. DCNL Handles nouns and adjectives, using classical inflection by default DCNL (i.e., where "matrix" pluralizes to "matrices" and not "matrixes"). DCNL The custom dictionary is for user-defined replacements.'
def descrFromDoc(obj): DCNL 'Generate an appropriate description from docstring of the given object'
def _parse_circ_entry(entry): DCNL 'Parses a single relay\'s \'LongName\' or \'ServerID\'. See the DCNL :func:`~stem.control._parse_circ_path` function for more information. DCNL :param str entry: relay information to be parsed DCNL :returns: **(fingerprint, nickname)** tuple DCNL :raises: :class:`stem.ProtocolError` if the entry is malformed'
def get_interface(iface): DCNL 'Return the contents of an interface script DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' ip.get_interface eth0'
def test_diagonal_gaussian_conditional_expectation(): DCNL 'DiagonalGaussian.conditional_expectation doesn\'t crash'
def libvlc_media_set_user_data(p_md, p_new_user_data): DCNL 'Sets media descriptor\'s user_data. user_data is specialized data DCNL accessed by the host application, VLC.framework uses it as a pointer to DCNL an native object that references a L{Media} pointer. DCNL @param p_md: media descriptor object. DCNL @param p_new_user_data: pointer to user data.'
@requires_pyopengl() DCNL def test_import_vispy_pyopengl(): DCNL 'Importing vispy.gloo.gl.pyopengl2 should import PyOpenGL.'
def ComputeErrorRate(error_count, truth_count): DCNL 'Returns a sanitized percent error rate from the raw counts. DCNL Prevents div by 0 and clips return to 100%. DCNL Args: DCNL error_count: Number of errors. DCNL truth_count: Number to divide by. DCNL Returns: DCNL 100.0 * error_count / truth_count clipped to 100.'
def save_translations(key): DCNL 'For a given key, save all the translations. The key is used to ensure that DCNL we only save the translations for the given object (and not all of them). DCNL Once saved, they will be deleted.'
def find_program_variables(code): DCNL 'Return a dict describing program variables:: DCNL {\'var_name\': (\'uniform|attribute|varying\', type), ...}'
@not_implemented_for('directed') DCNL def biconnected_component_edges(G): DCNL 'Return a generator of lists of edges, one list for each biconnected DCNL component of the input graph. DCNL Biconnected components are maximal subgraphs such that the removal of a DCNL node (and all edges incident on that node) will not disconnect the DCNL subgraph.  Note that nodes may be part of more than one biconnected DCNL component.  Those nodes are articulation points, or cut vertices. DCNL However, each edge belongs to one, and only one, biconnected component. DCNL Notice that by convention a dyad is considered a biconnected component. DCNL Parameters DCNL G : NetworkX Graph DCNL An undirected graph. DCNL Returns DCNL edges : generator of lists DCNL Generator of lists of edges, one list for each bicomponent. DCNL Raises DCNL NetworkXNotImplemented : DCNL If the input graph is not undirected. DCNL Examples DCNL >>> G = nx.barbell_graph(4, 2) DCNL >>> print(nx.is_biconnected(G)) DCNL False DCNL >>> bicomponents_edges = list(nx.biconnected_component_edges(G)) DCNL >>> len(bicomponents_edges) DCNL 5 DCNL >>> G.add_edge(2, 8) DCNL >>> print(nx.is_biconnected(G)) DCNL True DCNL >>> bicomponents_edges = list(nx.biconnected_component_edges(G)) DCNL >>> len(bicomponents_edges) DCNL 1 DCNL See Also DCNL is_biconnected, DCNL biconnected_components, DCNL articulation_points, DCNL biconnected_component_subgraphs DCNL Notes DCNL The algorithm to find articulation points and biconnected DCNL components is implemented using a non-recursive depth-first-search DCNL (DFS) that keeps track of the highest level that back edges reach DCNL in the DFS tree.  A node `n` is an articulation point if, and only DCNL if, there exists a subtree rooted at `n` such that there is no DCNL back edge from any successor of `n` that links to a predecessor of DCNL `n` in the DFS tree.  By keeping track of all the edges traversed DCNL by the DFS we can obtain the biconnected components because all DCNL edges of a bicomponent will be traversed consecutively between DCNL articulation points. DCNL References DCNL .. [1] Hopcroft, J.; Tarjan, R. (1973). DCNL "Efficient algorithms for graph manipulation". DCNL Communications of the ACM 16: 372–378. doi:10.1145/362248.362272'
def yule_walker(X, order=1, method='unbiased', df=None, inv=False, demean=True): DCNL 'Estimate AR(p) parameters from a sequence X using Yule-Walker equation. DCNL Unbiased or maximum-likelihood estimator (mle) DCNL See, for example: DCNL http://en.wikipedia.org/wiki/Autoregressive_moving_average_model DCNL Parameters DCNL X : array-like DCNL 1d array DCNL order : integer, optional DCNL The order of the autoregressive process.  Default is 1. DCNL method : string, optional DCNL Method can be "unbiased" or "mle" and this determines denominator in DCNL estimate of autocorrelation function (ACF) at lag k. If "mle", the DCNL denominator is n=X.shape[0], if "unbiased" the denominator is n-k. DCNL The default is unbiased. DCNL df : integer, optional DCNL Specifies the degrees of freedom. If `df` is supplied, then it is assumed DCNL the X has `df` degrees of freedom rather than `n`.  Default is None. DCNL inv : bool DCNL If inv is True the inverse of R is also returned.  Default is False. DCNL demean : bool DCNL True, the mean is subtracted from `X` before estimation. DCNL Returns DCNL rho DCNL The autoregressive coefficients DCNL sigma DCNL TODO DCNL Examples DCNL >>> import statsmodels.api as sm DCNL >>> from statsmodels.datasets.sunspots import load DCNL >>> data = load() DCNL >>> rho, sigma = sm.regression.yule_walker(data.endog, DCNL order=4, method="mle") DCNL >>> rho DCNL array([ 1.28310031, -0.45240924, -0.20770299,  0.04794365]) DCNL >>> sigma DCNL 16.808022730464351'
def set_logging(log_level, myfilename=None): DCNL 'This function sets the threshold for the logging system and, if desired, DCNL directs the messages to a logfile. Level options: DCNL \'DEBUG\' or 1 DCNL \'INFO\' or 2 DCNL \'WARNING\' or 3 DCNL \'ERROR\' or 4 DCNL \'CRITICAL\' or 5 DCNL If the user is on the interactive shell and wants to log to file, a custom DCNL excepthook is set. By default, if logging to file is not enabled, the way DCNL errors are displayed on the interactive shell is not changed.'
def class_result(classname): DCNL 'Errcheck function. Returns a function that creates the specified class.'
def create_private_key(path=None, text=False, bits=2048, passphrase=None, cipher='aes_128_cbc', verbose=True): DCNL 'Creates a private key in PEM format. DCNL path: DCNL The path to write the file to, either ``path`` or ``text`` DCNL are required. DCNL text: DCNL If ``True``, return the PEM text without writing to a file. DCNL Default ``False``. DCNL bits: DCNL Length of the private key in bits. Default 2048 DCNL passphrase: DCNL Passphrase for encryting the private key DCNL cipher: DCNL Cipher for encrypting the private key. Has no effect if passhprase is None. DCNL verbose: DCNL Provide visual feedback on stdout. Default True DCNL .. versionadded:: 2016.11.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' x509.create_private_key path=/etc/pki/mykey.key'
def tokenize(*args, **kwargs): DCNL 'Deterministic token DCNL >>> tokenize([1, 2, \'3\']) DCNL \'7d6a880cd9ec03506eee6973ff551339\' DCNL >>> tokenize(\'Hello\') == tokenize(\'Hello\') DCNL True'
def compute_node_get(context, compute_id): DCNL 'Get a computeNode.'
def _makeGetterFactory(url, factoryFactory, contextFactory=None, *args, **kwargs): DCNL 'Create and connect an HTTP page getting factory. DCNL Any additional positional or keyword arguments are used when calling DCNL C{factoryFactory}. DCNL @param factoryFactory: Factory factory that is called with C{url}, C{args} DCNL and C{kwargs} to produce the getter DCNL @param contextFactory: Context factory to use when creating a secure DCNL connection, defaulting to L{None} DCNL @return: The factory created by C{factoryFactory}'
def import_site_function(path, module, funcname, dummy, modulefile=None): DCNL 'Try to import site specific function from site specific file if it exists DCNL Args: DCNL path: full filename of the source file calling this (ie __file__) DCNL module: full module name DCNL funcname: function name to be imported from site file DCNL dummy: dummy function to return in case there is no function to import DCNL modulefile: module filename DCNL Returns: site specific function object or dummy DCNL Raises: ImportError if the site file exists but imports fails'
def get_route(ip): DCNL 'Return routing information for given destination ip DCNL .. versionadded:: 2015.5.3 DCNL .. versionchanged:: 2015.8.0 DCNL Added support for SunOS (Solaris 10, Illumos, SmartOS) DCNL Added support for OpenBSD DCNL CLI Example:: DCNL salt \'*\' network.get_route 10.10.10.10'
def mkstemp(suffix=None, prefix=None, dir=None, text=False): DCNL 'User-callable function to create and return a unique temporary DCNL file.  The return value is a pair (fd, name) where fd is the DCNL file descriptor returned by os.open, and name is the filename. DCNL If \'suffix\' is not None, the file name will end with that suffix, DCNL otherwise there will be no suffix. DCNL If \'prefix\' is not None, the file name will begin with that prefix, DCNL otherwise a default prefix is used. DCNL If \'dir\' is not None, the file will be created in that directory, DCNL otherwise a default directory is used. DCNL If \'text\' is specified and true, the file is opened in text DCNL mode.  Else (the default) the file is opened in binary mode.  On DCNL some operating systems, this makes no difference. DCNL If any of \'suffix\', \'prefix\' and \'dir\' are not None, they must be the DCNL same type.  If they are bytes, the returned name will be bytes; str DCNL otherwise. DCNL The file is readable and writable only by the creating user ID. DCNL If the operating system uses permission bits to indicate whether a DCNL file is executable, the file is executable by no one. The file DCNL descriptor is not inherited by children of this process. DCNL Caller is responsible for deleting the file when done with it.'
def define_rate(name, description, unit_seconds=1, manager=counters): DCNL 'Creates a performance counter which tracks some rate at which a value accumulates DCNL over the course of the program. The counter has an optional \'unit_seconds\' parameter DCNL which determines the time unit associated with the value - the default is one second. DCNL The counter can be incremented using one of several increment methods: DCNL # Define a new rate counter in the module. DCNL rate_counter = counters.rate(\'module.counters.rate\', \'Accumulation per minute\', unit_seconds=60) DCNL rate_counter.increment()      # Increment by 1 DCNL rate_counter.increment(20) DCNL rate_counter.decrement()      # Decrement by 1 DCNL rate_counter.decrement(20) DCNL When sampled using a Meter, this counter returns the average rate of change in the underlying value DCNL per the given unit of time, taken over the time span since the previous sample of the Meter.'
def mail_new_user(user): DCNL 'Send an e-mail to administrators for newly registered users. DCNL Args: DCNL user (django.contrib.auth.models.User): DCNL The user to send an e-mail about.'
def review_request_closed_cb(sender, user, review_request, type, **kwargs): DCNL 'Send e-mail when a review request is closed. DCNL Listens to the DCNL :py:data:`~reviewboard.reviews.signals.review_request_closed` signal and DCNL sends an e-mail if this type of notification is enabled (through the DCNL ``mail_send_review_close_mail`` site configuration setting).'
def load_list_of_roles(ds, play, current_role_path=None, variable_manager=None, loader=None): DCNL 'Loads and returns a list of RoleInclude objects from the datastructure DCNL list of role definitions'
def test_seed_diff(): DCNL 'Verifies that two MNDs initialized with different DCNL seeds produce samples that differ at least somewhat DCNL (theoretically the samples could match even under DCNL valid behavior but this is extremely unlikely)'
def find_gwt_dir(): DCNL 'See if GWT is installed in site-packages or in the system, DCNL site-packages is favored over a system install.'
def filter_sff_file(flowgrams, header, filter_list, out_fh): DCNL 'Filters all flowgrams in handle with filter. DCNL flowgrams: a list of flowgrams (or something similar) DCNL header: the header for the flowgrams DCNL filter_list: list of filters to be applied on sff.txt file DCNL out_fh: output file handle DCNL returns: number of flowgrams in filtered out file'
def _get_resource_id(resource, name, region=None, key=None, keyid=None, profile=None): DCNL 'Get an AWS id for a VPC resource by type and name.'
def apply_policy(policy, r, name, sub): DCNL 'Apply the list of policies to name.r,sub DCNL Parameters DCNL policy DCNL List of functions that map a L{Variable} to a string, DCNL or a single such function. DCNL r: L{Variable} DCNL Returns DCNL object DCNL C{policy[0](r) + policy[1](r) + ...}.'
def FastaM10Iterator(handle, alphabet=single_letter_alphabet): DCNL 'Alignment iterator for the FASTA tool\'s pairwise alignment output. DCNL This is for reading the pairwise alignments output by Bill Pearson\'s DCNL FASTA program when called with the -m 10 command line option for machine DCNL readable output.  For more details about the FASTA tools, see the website DCNL http://fasta.bioch.virginia.edu/ and the paper: DCNL W.R. Pearson & D.J. Lipman PNAS (1988) 85:2444-2448 DCNL This class is intended to be used via the Bio.AlignIO.parse() function DCNL by specifying the format as "fasta-m10" as shown in the following code:: DCNL from Bio import AlignIO DCNL handle = ... DCNL for a in AlignIO.parse(handle, "fasta-m10"): DCNL assert len(a) == 2, "Should be pairwise!" DCNL print("Alignment length %i" % a.get_alignment_length()) DCNL for record in a: DCNL print("%s %s %s" % (record.seq, record.name, record.id)) DCNL Note that this is not a full blown parser for all the information DCNL in the FASTA output - for example, most of the header and all of the DCNL footer is ignored.  Also, the alignments are not batched according to DCNL the input queries. DCNL Also note that there can be up to about 30 letters of flanking region DCNL included in the raw FASTA output as contextual information.  This is NOT DCNL part of the alignment itself, and is not included in the resulting DCNL MultipleSeqAlignment objects returned.'
def determine_format(request, serializer, default_format=u'application/json'): DCNL 'Tries to "smartly" determine which output format is desired. DCNL First attempts to find a ``format`` override from the request and supplies DCNL that if found. DCNL If no request format was demanded, it falls back to ``mimeparse`` and the DCNL ``Accepts`` header, allowing specification that way. DCNL If still no format is found, returns the ``default_format`` (which defaults DCNL to ``application/json`` if not provided). DCNL NOTE: callers *must* be prepared to handle BadRequest exceptions due to DCNL malformed HTTP request headers!'
def _indent(s, indent=4): DCNL 'Add the given number of space characters to the beginning of DCNL every non-blank line in `s`, and return the result. DCNL If the string `s` is Unicode, it is encoded using the stdout DCNL encoding and the `backslashreplace` error handler.'
def _StrictParseLogEntry(entry, clean_message=True): DCNL 'Parses a single log entry emitted by app_logging.AppLogsHandler. DCNL Parses a log entry of the form LOG <level> <timestamp> <message> where the DCNL level is in the range [0, 4]. If the entry is not of that form, ValueError is DCNL raised. DCNL Args: DCNL entry: The log entry to parse. DCNL clean_message: should the message be cleaned (i.e.  -> DCNL Returns: DCNL A (timestamp, level, message, source_location) tuple, where source_location DCNL is None. DCNL Raises: DCNL ValueError: if the entry failed to be parsed.'
def remove_arrays(code, count=1): DCNL 'removes arrays and replaces them with ARRAY_LVALS DCNL returns new code and replacement dict DCNL *NOTE* has to be called AFTER remove objects'
def _toCSSname(DOMname): DCNL 'Return CSSname for given DOMname e.g. for DOMname \'fontStyle\' returns DCNL \'font-style\'.'
def plot_decision(features, labels): DCNL 'Plots decision boundary for KNN DCNL Parameters DCNL features : ndarray DCNL labels : sequence DCNL Returns DCNL fig : Matplotlib Figure DCNL ax  : Matplotlib Axes'
def run(*commands, **kwargs): DCNL 'Run one or more commands DCNL If more than one command is given, then this is equivalent to DCNL chaining them together with ``&&``; if all commands succeed, then DCNL ``(status, out, err)`` will represent the last successful command. DCNL If one command failed, then ``(status, out, err)`` will represent DCNL the failed command. DCNL :returns: ``(status, out, err)``'
def _FormatFirstToken(first_token, indent_depth, prev_uwline, final_lines): DCNL 'Format the first token in the unwrapped line. DCNL Add a newline and the required indent before the first token of the unwrapped DCNL line. DCNL Arguments: DCNL first_token: (format_token.FormatToken) The first token in the unwrapped DCNL line. DCNL indent_depth: (int) The line\'s indentation depth. DCNL prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line DCNL previous to this line. DCNL final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines DCNL that have already been processed.'
def fragment6(pkt, fragSize): DCNL 'Performs fragmentation of an IPv6 packet. Provided packet (\'pkt\') must already DCNL contain an IPv6ExtHdrFragment() class. \'fragSize\' argument is the expected DCNL maximum size of fragments (MTU). The list of packets is returned. DCNL If packet does not contain an IPv6ExtHdrFragment class, it is returned in DCNL result list.'
def to_seconds(time_string): DCNL 'Converts a string in M+:SS.SS format to S+.SS'
def split_string(text, chars_per_string): DCNL 'Splits one string into multiple strings, with a maximum amount of `chars_per_string` characters per string. DCNL This is very useful for splitting one giant message into multiples. DCNL :param text: The text to split DCNL :param chars_per_string: The number of characters per line the text is split into. DCNL :return: The splitted text as a list of strings.'
def getTempMarkdownPreviewPath(view): DCNL 'return a permanent full path of the temp markdown preview file'
def timestampUUID60(value): DCNL 'Convert UUID 60-bit timestamp to string. The timestamp format is DCNL a 60-bit number which represents number of 100ns since the DCNL the 15 October 1582 at 00:00. Result is an unicode string. DCNL >>> timestampUUID60(0) DCNL datetime.datetime(1582, 10, 15, 0, 0) DCNL >>> timestampUUID60(130435676263032368) DCNL datetime.datetime(1996, 2, 14, 5, 13, 46, 303236)'
def svm_read_problem(data_file_name): DCNL 'svm_read_problem(data_file_name) -> [y, x] DCNL Read LIBSVM-format data from data_file_name and return labels y DCNL and data instances x.'
def boto_supports_associate_public_ip_address(ec2): DCNL 'Check if Boto library has associate_public_ip_address in the NetworkInterfaceSpecification DCNL class. Added in Boto 2.13.0 DCNL ec2: authenticated ec2 connection object DCNL Returns: DCNL True if Boto library accepts associate_public_ip_address argument, else false'
def read_config_file(option, opt, value, parser): DCNL 'Read a configuration file during option processing.  (Option callback.)'
def get_suffixes(): DCNL '**DEPRECATED**'
@register.filter DCNL def xssafe(value): DCNL 'Like |safe but for strings with interpolation. DCNL By using |xssafe you assert that you have written tests proving an DCNL XSS can\'t happen here.'
def get_configured_provider(): DCNL 'Return the first configured instance.'
def delete_instance_profile(name, region=None, key=None, keyid=None, profile=None): DCNL 'Delete an instance profile. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_iam.delete_instance_profile myiprofile'
def version(raises=True): DCNL 'Return the current cuDNN version we link with. DCNL This also does a check that the header version matches the runtime version. DCNL :raises: If True, raise an exception if cuDNN is not present or badly installed. DCNL Otherwise, return -1.'
def get_pymodule_path(modulename, *joins): DCNL 'Return path of given Python module name. DCNL :param modulename: Python module name. DCNL :param *joins: Join additional path elements using `os.path.join`.'
def iter_first(sequence): DCNL 'Get the first element from an iterable or raise a ValueError if DCNL the iterator generates no values.'
def _CalculateNumberOfNewlines(first_token, indent_depth, prev_uwline, final_lines): DCNL 'Calculate the number of newlines we need to add. DCNL Arguments: DCNL first_token: (format_token.FormatToken) The first token in the unwrapped DCNL line. DCNL indent_depth: (int) The line\'s indentation depth. DCNL prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line DCNL previous to this line. DCNL final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines DCNL that have already been processed. DCNL Returns: DCNL The number of newlines needed before the first token.'
def _salt(fun, *args, **kw): DCNL 'Execute a salt function on a specific minion DCNL Special kwargs: DCNL salt_target DCNL target to exec things on DCNL salt_timeout DCNL timeout for jobs DCNL salt_job_poll DCNL poll interval to wait for job finish result'
def get_configured_hadoop_version(): DCNL 'CDH4 (hadoop 2+) has a slightly different syntax for interacting with hdfs DCNL via the command line. DCNL The default version is CDH4, but one can override DCNL this setting with "cdh3" or "apache1" in the hadoop section of the config DCNL in order to use the old syntax.'
def _replace_conditional(match, string): DCNL 'Replaces a conditional match in a transformation.'
def find_sr_by_uuid(session, sr_uuid): DCNL 'Return the storage repository given a uuid.'
def read_xml_config(xml_config_file, svc_params, optional_params): DCNL 'Read Hitachi driver specific xml config file. DCNL :param xml_config_file: string filename containing XML configuration DCNL :param svc_params: parameters to configure the services DCNL [\'volume_type\', \'hdp\', \'iscsi_ip\'] DCNL :param optional_params: parameters to configure that are not mandatory DCNL [\'ssc_cmd\', \'cluster_admin_ip0\', \'chap_enabled\']'
def colorize(text='', opts=(), **kwargs): DCNL 'Returns your text, enclosed in ANSI graphics codes. DCNL Depends on the keyword arguments \'fg\' and \'bg\', and the contents of DCNL the opts tuple/list. DCNL Returns the RESET code if no parameters are given. DCNL Valid colors: DCNL \'black\', \'red\', \'green\', \'yellow\', \'blue\', \'magenta\', \'cyan\', \'white\' DCNL Valid options: DCNL \'bold\' DCNL \'underscore\' DCNL \'blink\' DCNL \'reverse\' DCNL \'conceal\' DCNL \'noreset\' - string will not be auto-terminated with the RESET code DCNL Examples: DCNL colorize(\'hello\', fg=\'red\', bg=\'blue\', opts=(\'blink\',)) DCNL colorize() DCNL colorize(\'goodbye\', opts=(\'underscore\',)) DCNL print colorize(\'first line\', fg=\'red\', opts=(\'noreset\',)) DCNL print \'this should be red too\' DCNL print colorize(\'and so should this\') DCNL print \'this should not be red\''
def is_image_visible(context, image, status=None): DCNL 'Return True if the image is visible in this context.'
def assert_similar_pages(first, second, ratio=0.9, msg=None): DCNL 'Asserts that most of the lines (90% by default) in the two pages are identical, DCNL ignoring leading/trailing spaces.'
@library.filter DCNL def remove(list_, item): DCNL 'Removes an item from a list.'
def run_param(registry, xml_parent, data): DCNL 'yaml: run DCNL A run parameter. DCNL :arg str name: the name of the parameter DCNL :arg str project-name: the name of job from which the user can pick runs DCNL :arg str description: a description of the parameter (optional) DCNL Example: DCNL .. literalinclude::  /../../tests/parameters/fixtures/run-param001.yaml DCNL :language: yaml'
def create_request(url=None, method=None, body=None): DCNL 'Creates a tornado.httpclient.HTTPRequest with the given parameters. DCNL Args: DCNL url: A str, the URL to call. DCNL method: A str, one of GET, POST. DCNL body: A JSON object, the encoded dictionary that will be posted as payload. DCNL Returns: DCNL A tornado.httpclient.HTTPRequest object. DCNL Raises: DCNL MissingRequestArgs exception if one or more of the arguments is not set.'
def run_cmd(pl, cmd, stdin=None, strip=True): DCNL 'Run command and return its stdout, stripped DCNL If running command fails returns None and logs failure to ``pl`` argument. DCNL :param PowerlineLogger pl: DCNL Logger used to log failures. DCNL :param list cmd: DCNL Command which will be run. DCNL :param str stdin: DCNL String passed to command. May be None. DCNL :param bool strip: DCNL True if the result should be stripped.'
def check_key_expired(key, node, url): DCNL 'check if key expired if is return url with args so it will push status message DCNL else return url DCNL :param str key: the private link key passed in DCNL :param Node node: the node object wants to access DCNL :param str url: the url redirect to DCNL :return: url with pushed message added if key expired else just url'
def search_lxc_bridge(): DCNL 'Search the first bridge which is potentially available as LXC bridge DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' lxc.search_lxc_bridge'
def is_docstring(physical_line, previous_logical): DCNL 'Return True if found docstring DCNL \'A docstring is a string literal that occurs as the first statement in a DCNL module, function, class,\' DCNL http://www.python.org/dev/peps/pep-0257/#what-is-a-docstring'
def isPackageDirectory(dirname): DCNL 'Is the directory at path \'dirname\' a Python package directory? DCNL Returns the name of the __init__ file (it may have a weird extension) DCNL if dirname is a package directory.  Otherwise, returns False'
def _generate_cache_key(request, headerlist, key_prefix): DCNL 'Returns a cache key from the headers given in the header list.'
def already_backported(branch, since_tag=None): DCNL 'return set of PRs that have been backported already'
def get_location(http_info): DCNL 'Extract the redirect URL from a pysaml2 http_info object'
def lie_heuristic_linear(match, comp=False): DCNL 'This heuristic assumes DCNL 1. `\xi = ax + by + c` and DCNL 2. `\eta = fx + gy + h` DCNL After substituting the following assumptions in the determining PDE, it DCNL reduces to DCNL .. math:: f + (g - a)h - bh^{2} - (ax + by + c)\frac{\partial h}{\partial x} DCNL - (fx + gy + c)\frac{\partial h}{\partial y} DCNL Solving the reduced PDE obtained, using the method of characteristics, becomes DCNL impractical. The method followed is grouping similar terms and solving the system DCNL of linear equations obtained. The difference between the bivariate heuristic is that DCNL `h` need not be a rational function in this case. DCNL References DCNL - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order DCNL ODE Patterns, pp. 10 - pp. 12'
def _generate_indices(f, values=False): DCNL 'generate the indicies DCNL if values is True , use the axis values DCNL is False, use the range'
def read_file_as_root(file_path): DCNL 'Secure helper to read file as root.'
def demo(): DCNL 'Demo decoding a list of tagged reads from several samples'
def splev(x, tck, der=0, ext=0): DCNL 'Evaluate a B-spline or its derivatives. DCNL Given the knots and coefficients of a B-spline representation, evaluate DCNL the value of the smoothing polynomial and its derivatives.  This is a DCNL wrapper around the FORTRAN routines splev and splder of FITPACK. DCNL Parameters DCNL x : array_like DCNL An array of points at which to return the value of the smoothed DCNL spline or its derivatives.  If `tck` was returned from `splprep`, DCNL then the parameter values, u should be given. DCNL tck : tuple DCNL A sequence of length 3 returned by `splrep` or `splprep` containing DCNL the knots, coefficients, and degree of the spline. DCNL der : int, optional DCNL The order of derivative of the spline to compute (must be less than DCNL or equal to k). DCNL ext : int, optional DCNL Controls the value returned for elements of ``x`` not in the DCNL interval defined by the knot sequence. DCNL * if ext=0, return the extrapolated value. DCNL * if ext=1, return 0 DCNL * if ext=2, raise a ValueError DCNL * if ext=3, return the boundary value. DCNL The default value is 0. DCNL Returns DCNL y : ndarray or list of ndarrays DCNL An array of values representing the spline function evaluated at DCNL the points in ``x``.  If `tck` was returned from `splprep`, then this DCNL is a list of arrays representing the curve in N-dimensional space. DCNL See Also DCNL splprep, splrep, sproot, spalde, splint DCNL bisplrep, bisplev DCNL References DCNL .. [1] C. de Boor, "On calculating with b-splines", J. Approximation DCNL Theory, 6, p.50-62, 1972. DCNL .. [2] M.G. Cox, "The numerical evaluation of b-splines", J. Inst. Maths DCNL Applics, 10, p.134-149, 1972. DCNL .. [3] P. Dierckx, "Curve and surface fitting with splines", Monographs DCNL on Numerical Analysis, Oxford University Press, 1993.'
def fetch_streams_infinite(plugin, interval): DCNL 'Attempts to fetch streams until some are returned.'
def GetDefaultConcurrentLinks(): DCNL 'Returns a best-guess for a number of concurrent links.'
def locale_list(request): DCNL 'List the support KB locales.'
def patch_vary_headers(response, newheaders): DCNL 'Adds (or updates) the "Vary" header in the given HttpResponse object. DCNL newheaders is a list of header names that should be in "Vary". Existing DCNL headers in "Vary" aren\'t removed.'
def fix_ampersands(value): DCNL 'Returns the given HTML with all unencoded ampersands encoded correctly.'
def set_priority_js(): DCNL 'Output json for priority field'
def _replace_locals(tok): DCNL 'Replace local variables with a syntactically valid name. DCNL Parameters DCNL tok : tuple of int, str DCNL ints correspond to the all caps constants in the tokenize module DCNL Returns DCNL t : tuple of int, str DCNL Either the input or token or the replacement values DCNL Notes DCNL This is somewhat of a hack in that we rewrite a string such as ``\'@a\'`` as DCNL ``\'__pd_eval_local_a\'`` by telling the tokenizer that ``__pd_eval_local_`` DCNL is a ``tokenize.OP`` and to replace the ``\'@\'`` symbol with it.'
def localhost(): DCNL 'Return the IP address of the magic hostname \'localhost\'.'
def sqllist(lst): DCNL 'Converts the arguments for use in something like a WHERE clause. DCNL >>> sqllist([\'a\', \'b\']) DCNL \'a, b\' DCNL >>> sqllist(\'a\') DCNL \'a\''
def groupby(key, seq): DCNL 'Group a collection by a key function DCNL >>> names = [\'Alice\', \'Bob\', \'Charlie\', \'Dan\', \'Edith\', \'Frank\'] DCNL >>> groupby(len, names)  # doctest: +SKIP DCNL {3: [\'Bob\', \'Dan\'], 5: [\'Alice\', \'Edith\', \'Frank\'], 7: [\'Charlie\']} DCNL >>> iseven = lambda x: x % 2 == 0 DCNL >>> groupby(iseven, [1, 2, 3, 4, 5, 6, 7, 8])  # doctest: +SKIP DCNL {False: [1, 3, 5, 7], True: [2, 4, 6, 8]} DCNL Non-callable keys imply grouping on a member. DCNL >>> groupby(\'gender\', [{\'name\': \'Alice\', \'gender\': \'F\'}, DCNL ...                    {\'name\': \'Bob\', \'gender\': \'M\'}, DCNL ...                    {\'name\': \'Charlie\', \'gender\': \'M\'}]) # doctest:+SKIP DCNL {\'F\': [{\'gender\': \'F\', \'name\': \'Alice\'}], DCNL \'M\': [{\'gender\': \'M\', \'name\': \'Bob\'}, DCNL {\'gender\': \'M\', \'name\': \'Charlie\'}]} DCNL See Also: DCNL countby'
def create(name, profile='splunk', **kwargs): DCNL 'Create a splunk search DCNL CLI Example: DCNL splunk_search.create \'my search name\' search=\'error msg\''
def filter_re_search(val, pattern): DCNL 'Perform a search for given regexp pattern, return the matching portion of the text.'
def test_continuous_regression_with_overlap(): DCNL 'Test regression with overlap correction.'
@register.simple_tag() DCNL def product_first_image(product, size, method='crop'): DCNL 'Returns main product image'
def conlltags2tree(sentence, chunk_types=(u'NP', u'PP', u'VP'), root_label=u'S', strict=False): DCNL 'Convert the CoNLL IOB format to a tree.'
def http_connect_raw(ipaddr, port, method, path, headers=None, query_string=None, ssl=False): DCNL 'Helper function to create an HTTPConnection object. If ssl is set True, DCNL HTTPSConnection will be used. However, if ssl=False, BufferedHTTPConnection DCNL will be used, which is buffered for backend Swift services. DCNL :param ipaddr: IPv4 address to connect to DCNL :param port: port to connect to DCNL :param method: HTTP method to request (\'GET\', \'PUT\', \'POST\', etc.) DCNL :param path: request path DCNL :param headers: dictionary of headers DCNL :param query_string: request query string DCNL :param ssl: set True if SSL should be used (default: False) DCNL :returns: HTTPConnection object'
def random_game(nums_actions, random_state=None): DCNL 'Return a random NormalFormGame instance where the payoffs are drawn DCNL independently from the uniform distribution on [0, 1). DCNL Parameters DCNL nums_actions : tuple(int) DCNL Tuple of the numbers of actions, one for each player. DCNL random_state : scalar(int) or np.random.RandomState, DCNL optional(default=None) DCNL Random seed (integer) or np.random.RandomState instance to set DCNL the initial state of the random number generator for DCNL reproducibility. If None, a randomly initialized RandomState is DCNL used. DCNL Returns DCNL g : NormalFormGame'
def vlan_in_use(segmentation_id, namespace=None): DCNL 'Return True if VLAN ID is in use by an interface, else False.'
def after_all(context): DCNL 'Unset env parameters.'
def xml_format(a): DCNL 'Returns the given attribute (string, int, float, bool, None) as a quoted unicode string.'
def process_all_packages(pkgmgr, client_dir, remove=False): DCNL 'Process a full upload of packages as a directory upload.'
def nn_words(table, wordvecs, query, k=10): DCNL 'Get the nearest neighbour words'
def check_forhash(filename): DCNL 'checks if file has a hash in its filename'
def is_namespace_property_mutable(context, namespace_property): DCNL 'Return True if the object is mutable in this context.'
def daemonize(no_close=False, pidfile=None): DCNL 'Convert the calling process into a daemon. To make the current Python DCNL process into a daemon process, you need two lines of code: DCNL .. python:: DCNL from grizzled.os import daemonize DCNL daemonize.daemonize() DCNL If ``daemonize()`` fails for any reason, it throws a ``DaemonError``, DCNL which is a subclass of the standard ``OSError`` exception. also logs debug DCNL messages, using the standard Python ``logging`` package, to channel DCNL "grizzled.os.daemon". DCNL **Adapted from:** http://software.clapper.org/daemonize/ DCNL **See Also:** DCNL - Stevens, W. Richard. *Unix Network Programming* (Addison-Wesley, 1990). DCNL :Parameters: DCNL no_close : bool DCNL If ``True``, don\'t close the file descriptors. Useful if the DCNL calling process has already redirected file descriptors to an DCNL output file. **Warning**: Only set this parameter to ``True`` if DCNL you\'re *sure* there are no open file descriptors to the calling DCNL terminal. Otherwise, you\'ll risk having the daemon re-acquire a DCNL control terminal, which can cause it to be killed if someone logs DCNL off that terminal. DCNL pidfile : str DCNL Path to file to which to write daemon\'s process ID. The string may DCNL contain a ``${pid}`` token, which is replaced with the process ID DCNL of the daemon. e.g.: ``/var/run/myserver-${pid}`` DCNL :raise DaemonError: Error during daemonizing'
@protocol.commands.add(u'listfiles') DCNL def listfiles(context, uri=None): DCNL '*musicpd.org, music database section:* DCNL ``listfiles [URI]`` DCNL Lists the contents of the directory URI, including files are not DCNL recognized by MPD. URI can be a path relative to the music directory or DCNL an URI understood by one of the storage plugins. The response contains DCNL at least one line for each directory entry with the prefix "file: " or DCNL "directory: ", and may be followed by file attributes such as DCNL "Last-Modified" and "size". DCNL For example, "smb://SERVER" returns a list of all shares on the given DCNL SMB/CIFS server; "nfs://servername/path" obtains a directory listing DCNL from the NFS server. DCNL .. versionadded:: 0.19 DCNL New in MPD protocol version 0.19'
def _spg_optim(func, grad, start, project, maxiter=10000.0, M=10, ctol=0.001, maxiter_nmls=200, lam_min=1e-30, lam_max=1e+30, sig1=0.1, sig2=0.9, gam=0.0001): DCNL 'Implements the spectral projected gradient method for minimizing a DCNL differentiable function on a convex domain. DCNL Parameters DCNL func : real valued function DCNL The objective function to be minimized. DCNL grad : real array-valued function DCNL The gradient of the objective function DCNL start : array_like DCNL The starting point DCNL project : function DCNL In-place projection of the argument to the domain DCNL of func. DCNL ... See notes regarding additional arguments DCNL Returns DCNL rslt : Bunch DCNL rslt.params is the final iterate, other fields describe DCNL convergence status. DCNL Notes DCNL This can be an effective heuristic algorithm for problems where no DCNL gauranteed algorithm for computing a global minimizer is known. DCNL There are a number of tuning parameters, but these generally DCNL should not be changed except for `maxiter` (positive integer) and DCNL `ctol` (small positive real).  See the Birgin et al reference for DCNL more information about the tuning parameters. DCNL Reference DCNL E. Birgin, J.M. Martinez, and M. Raydan. Spectral projected DCNL gradient methods: Review and perspectives. Journal of Statistical DCNL Software (preprint).  Available at: DCNL http://www.ime.usp.br/~egbirgin/publications/bmr5.pdf'
def get_global_options(): DCNL 'Returns the global options used as defaults for web server execution.'
def extents_may_overlap(context, builder, a_start, a_end, b_start, b_end): DCNL 'Whether two memory extents [a_start, a_end) and [b_start, b_end) DCNL may overlap.'
def check_installed(name, path): DCNL 'Check if the current highest-priority match for a given alternatives link DCNL is set to the desired path DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' alternatives.check_installed name path'
def unregister_models(engine): DCNL 'Drop database tables for all models with the given engine.'
@contextlib.contextmanager DCNL def import_state(**kwargs): DCNL 'Context manager to manage the various importers and stored state in the DCNL sys module. DCNL The \'modules\' attribute is not supported as the interpreter state stores a DCNL pointer to the dict that the interpreter uses internally; DCNL reassigning to sys.modules does not have the desired effect.'
def find_undeclared_variables(ast): DCNL 'Returns a set of all variables in the AST that will be looked up from DCNL the context at runtime.  Because at compile time it\'s not known which DCNL variables will be used depending on the path the execution takes at DCNL runtime, all variables are returned. DCNL >>> from jinja2 import Environment, meta DCNL >>> env = Environment() DCNL >>> ast = env.parse(\'{% set foo = 42 %}{{ bar + foo }}\') DCNL >>> meta.find_undeclared_variables(ast) == set([\'bar\']) DCNL True DCNL .. admonition:: Implementation DCNL Internally the code generator is used for finding undeclared variables. DCNL This is good to know because the code generator might raise a DCNL :exc:`TemplateAssertionError` during compilation and as a matter of DCNL fact this function can currently raise that exception as well.'
@none_if_empty DCNL def blobproperty_from_base64(value): DCNL 'Return a datastore blob property containing the base64 decoded value.'
def _mbcs_to_unicode(instr): DCNL 'Converts from current users character encoding to unicode. DCNL When instr has a value of None, the return value of the function DCNL will also be None.'
def get_order_args(): DCNL 'Get order arguments, return a dictionary DCNL { <VIEW_NAME>: (ORDER_COL, ORDER_DIRECTION) } DCNL Arguments are passed like: _oc_<VIEW_NAME>=<COL_NAME>&_od_<VIEW_NAME>=\'asc\'|\'desc\''
def human_resource(): DCNL 'RESTful CRUD controller for options.s3json lookups DCNL - needed for templates, like DRMP, where HRM fields are embedded inside DCNL pr_person form'
def service_get(context, service_id=None, backend_match_level=None, **filters): DCNL 'Get a service that matches the criteria. DCNL A possible filter is is_up=True and it will filter nodes that are down. DCNL :param service_id: Id of the service. DCNL :param filters: Filters for the query in the form of key/value. DCNL :param backend_match_level: \'pool\', \'backend\', or \'host\' for host and DCNL cluster filters (as defined in _filter_host DCNL method) DCNL :raise ServiceNotFound: If service doesn\'t exist.'
def _control_segment_path(name): DCNL 'Get the pathname of the named control segment file.'
def save_to_store(content, name, mime_type, location): DCNL 'Save named content to store by location. DCNL Returns location of saved content.'
def dbg(*args, **kwds): DCNL 'Create a console window and begin watching for exceptions. DCNL All arguments are passed to :func:`ConsoleWidget.__init__() <pyqtgraph.console.ConsoleWidget.__init__>`.'
def autodiscover(): DCNL 'Include tasks for all applications in ``INSTALLED_APPS``.'
@ffi.callback('int(void* DCSP handle, DCSP int DCSP revents)') DCNL def _python_callback(handle, revents): DCNL 'Returns an integer having one of three values: DCNL - -1 DCNL An exception occurred during the callback and you must call DCNL :func:`_python_handle_error` to deal with it. The Python watcher DCNL object will have the exception tuple saved in ``_exc_info``. DCNL - 0 DCNL Everything went according to plan. You should check to see if the libev DCNL watcher is still active, and call :func:`_python_stop` if so. This will DCNL clean up the memory. DCNL - 1 DCNL Everything went according to plan, but the watcher has already DCNL been stopped. Its memory may no longer be valid.'
def write_backreferences(seen_backrefs, gallery_conf, target_dir, fname, snippet): DCNL 'Writes down back reference files, which include a thumbnail list DCNL of examples using a certain module'
def unescape_html(text): DCNL 'Created by Fredrik Lundh (http://effbot.org/zone/re-sub.htm#unescape-html)'
def is_frozen(): DCNL 'Return whether we are running in a frozen environment'
def get_keywords(lexer): DCNL 'Get the keywords for a given lexer.'
def factorialk(n, k, exact=True): DCNL 'Multifactorial of n of order k, n(!!...!). DCNL This is the multifactorial of n skipping k values.  For example, DCNL factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1 DCNL In particular, for any integer ``n``, we have DCNL factorialk(n, 1) = factorial(n) DCNL factorialk(n, 2) = factorial2(n) DCNL Parameters DCNL n : int DCNL Calculate multifactorial. If `n` < 0, the return value is 0. DCNL k : int DCNL Order of multifactorial. DCNL exact : bool, optional DCNL If exact is set to True, calculate the answer exactly using DCNL integer arithmetic. DCNL Returns DCNL val : int DCNL Multifactorial of `n`. DCNL Raises DCNL NotImplementedError DCNL Raises when exact is False DCNL Examples DCNL >>> from scipy.special import factorialk DCNL >>> factorialk(5, 1, exact=True) DCNL 120L DCNL >>> factorialk(5, 3, exact=True) DCNL 10L'
def resolve_model_string(model_string, default_app=None): DCNL 'Resolve an \'app_label.model_name\' string into an actual model class. DCNL If a model class is passed in, just return that. DCNL Raises a LookupError if a model can not be found, or ValueError if passed DCNL something that is neither a model or a string.'
def restart(name): DCNL 'Restart the named service. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' service.restart <service name>'
@pytest.yield_fixture() DCNL def use_vcr(request, monkeypatch): DCNL 'This fixture is applied automatically to any test using the `online` mark. It will record and playback network DCNL sessions using VCR. DCNL The record mode of VCR can be set using the VCR_RECORD_MODE environment variable when running tests.'
def getManipulatedPaths(close, elementNode, loop, prefix, sideLength): DCNL 'Get flipped paths.'
def depends(**dependencies): DCNL 'Decorates a method where dependencies are passed as keyword DCNL parameters.  Dependencies are specified as keywords with an DCNL optional accessor function or None if required.  Dependencies can DCNL be injected or passed directly as keyword parameters.  Example:: DCNL class HttpServer(object): DCNL @depends(http_port = const(80)) DCNL def listen(http_port = None): DCNL print "Listening on", http_port DCNL server = HttpServer() DCNL server.listen() DCNL server.listen(http_port = 8000) DCNL with inject(http_port = const(8000)).everywhere(): DCNL server.listen() DCNL Produces the output:: DCNL Listening on port 80 DCNL Listening on port 8000 DCNL Listening on port 8000'
def python(registry, xml_parent, data): DCNL 'yaml: python DCNL Execute a python command. Requires the Jenkins :jenkins-wiki:`Python plugin DCNL <Python+Plugin>`. DCNL :arg str parameter: the python command to execute DCNL Example: DCNL .. literalinclude:: /../../tests/builders/fixtures/python.yaml DCNL :language: yaml'
def read_config(options, args, arglist, parser): DCNL 'Read and parse configurations. DCNL If a config file is specified on the command line with the "--config" DCNL option, then only it is used for configuration. DCNL Otherwise, the user configuration (~/.config/pep8) and any local DCNL configurations in the current directory or above will be merged together DCNL (in that order) using the read method of ConfigParser.'
def isAquaTk(): DCNL 'Returns True if IDLE is using a native OS X Tk (Cocoa or Carbon).'
def _operation_complete(result): DCNL 'Return operation result.'
def _uninstall_flocker_ubuntu1604(): DCNL 'Return an ``Effect`` for uninstalling the Flocker package from an Ubuntu DCNL machine.'
def get_resource_and_action(action): DCNL 'Extract resource and action (write, read) from api operation'
def freeze(bin_env=None, user=None, cwd=None, use_vt=False): DCNL 'Return a list of installed packages either globally or in the specified DCNL virtualenv DCNL bin_env DCNL path to pip bin or path to virtualenv. If doing an uninstall from DCNL the system python and want to use a specific pip bin (pip-2.7, DCNL pip-2.6, etc..) just specify the pip bin you want. DCNL If uninstalling from a virtualenv, just use the path to the virtualenv DCNL (/home/code/path/to/virtualenv/) DCNL user DCNL The user under which to run pip DCNL cwd DCNL Current working directory to run pip from DCNL .. note:: DCNL If the version of pip available is older than 8.0.3, the list will not DCNL include the packages pip, wheel, setuptools, or distribute even if they DCNL are installed. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pip.freeze /home/code/path/to/virtualenv/ DCNL .. versionchanged:: 2016.11.2 DCNL The packages pip, wheel, setuptools, and distribute are included if the DCNL installed pip is new enough.'
def parse_query_part(part, query_classes={}, prefixes={}, default_class=query.SubstringQuery): DCNL 'Parse a single *query part*, which is a chunk of a complete query DCNL string representing a single criterion. DCNL A query part is a string consisting of: DCNL - A *pattern*: the value to look for. DCNL - Optionally, a *field name* preceding the pattern, separated by a DCNL colon. So in `foo:bar`, `foo` is the field name and `bar` is the DCNL pattern. DCNL - Optionally, a *query prefix* just before the pattern (and after the DCNL optional colon) indicating the type of query that should be used. For DCNL example, in `~foo`, `~` might be a prefix. (The set of prefixes to DCNL look for is given in the `prefixes` parameter.) DCNL - Optionally, a negation indicator, `-` or `^`, at the very beginning. DCNL Both prefixes and the separating `:` character may be escaped with a DCNL backslash to avoid their normal meaning. DCNL The function returns a tuple consisting of: DCNL - The field name: a string or None if it\'s not present. DCNL - The pattern, a string. DCNL - The query class to use, which inherits from the base DCNL :class:`Query` type. DCNL - A negation flag, a bool. DCNL The three optional parameters determine which query class is used (i.e., DCNL the third return value). They are: DCNL - `query_classes`, which maps field names to query classes. These DCNL are used when no explicit prefix is present. DCNL - `prefixes`, which maps prefix strings to query classes. DCNL - `default_class`, the fallback when neither the field nor a prefix DCNL indicates a query class. DCNL So the precedence for determining which query class to return is: DCNL prefix, followed by field, and finally the default. DCNL For example, assuming the `:` prefix is used for `RegexpQuery`: DCNL - `\'stapler\'` -> `(None, \'stapler\', SubstringQuery, False)` DCNL - `\'color:red\'` -> `(\'color\', \'red\', SubstringQuery, False)` DCNL - `\':^Quiet\'` -> `(None, \'^Quiet\', RegexpQuery, False)`, because DCNL the `^` follows the `:` DCNL - `\'color::b..e\'` -> `(\'color\', \'b..e\', RegexpQuery, False)` DCNL - `\'-color:red\'` -> `(\'color\', \'red\', SubstringQuery, True)`'
def setLoggerClass(klass): DCNL 'Set the class to be used when instantiating a logger. The class should DCNL define __init__() such that only a name argument is required, and the DCNL __init__() should call Logger.__init__()'
@utils.arg('pool', metavar='<floating-ip-pool>', help=_('Name DCSP of DCSP Floating DCSP IP DCSP Pool. DCSP (Optional)'), nargs='?', default=None) DCNL @deprecated_network DCNL def do_floating_ip_create(cs, args): DCNL 'Allocate a floating IP for the current tenant.'
@snippet DCNL def client_list_datasets(client, _): DCNL 'List datasets for a project.'
def cppcheck(registry, xml_parent, data): DCNL 'yaml: cppcheck DCNL Cppcheck result publisher DCNL Requires the Jenkins :jenkins-wiki:`Cppcheck Plugin <Cppcheck+Plugin>`. DCNL :arg str pattern: File pattern for cppcheck xml report (required) DCNL :arg bool ignoreblankfiles: Ignore blank files (default false) DCNL :arg bool allow-no-report: Do not fail the build if the Cppcheck report DCNL is not found (default false) DCNL :arg dict thresholds: DCNL :thresholds: Configure the build status and health. A build is DCNL considered as unstable or failure if the new or total number DCNL of issues exceeds the specified thresholds. The build health DCNL is also determined by thresholds. If the actual number of issues DCNL is between the provided thresholds, then the build health is DCNL interpolated. DCNL * **unstable** (`str`): Total number unstable threshold (default \'\') DCNL * **new-unstable** (`str`): New number unstable threshold (default \'\') DCNL * **failure** (`str`): Total number failure threshold (default \'\') DCNL * **new-failure** (`str`): New number failure threshold (default \'\') DCNL * **healthy** (`str`): Healthy threshold (default \'\') DCNL * **unhealthy** (`str`): Unhealthy threshold (default \'\') DCNL :arg dict severity: DCNL :severity: Determines which severity of issues should be considered DCNL when evaluating the build status and health, default all true DCNL * **error** (`bool`): Severity error (default true) DCNL * **warning** (`bool`): Severity warning (default true) DCNL * **style** (`bool`): Severity style (default true) DCNL * **performance** (`bool`): Severity performance (default true) DCNL * **information** (`bool`): Severity information (default true) DCNL * **nocategory** (`bool`): Severity nocategory (default true) DCNL * **portability** (`bool`): Severity portability (default true) DCNL :arg dict graph: DCNL :graph: Graph configuration DCNL * **xysize** (`array`): Chart width and height (default [500, 200]) DCNL * **num-builds-in-graph** (`int`): Builds number in graph (default 0) DCNL :arg dict display DCNL :display: which errors to display, default only sum DCNL * **sum** (`bool`): Display sum of all issues (default true) DCNL * **error** (`bool`): Display errors (default false) DCNL * **warning** (`bool`): Display warnings (default false) DCNL * **style** (`bool`): Display style (default false) DCNL * **performance** (`bool`): Display performance (default false) DCNL * **information** (`bool`): Display information (default false) DCNL * **nocategory** (`bool`): Display no category (default false) DCNL * **portability** (`bool`): Display portability (default false) DCNL Minimal Example: DCNL .. literalinclude:: DCNL /../../tests/publishers/fixtures/cppcheck-minimal.yaml DCNL :language: yaml DCNL Full Example: DCNL .. literalinclude:: DCNL /../../tests/publishers/fixtures/cppcheck-complete.yaml DCNL :language: yaml'
def _get_task_statuses(task_ids): DCNL 'Retrieve task statuses from ECS API DCNL Returns list of {RUNNING|PENDING|STOPPED} for each id in task_ids'
def test_special_bindings(keyhint, key_config_stub): DCNL 'Ensure a prefix of \'<\' doesn\'t suggest special keys.'
def fnpickle(object, fileorname, usecPickle=True, protocol=None, append=False): DCNL 'Pickle an object to a specified file. DCNL Parameters DCNL object DCNL The python object to pickle. DCNL fileorname : str or file-like DCNL The filename or file into which the `object` should be pickled. If a DCNL file object, it should have been opened in binary mode. DCNL usecPickle : bool DCNL If True (default), the :mod:`cPickle` module is to be used in place of DCNL :mod:`pickle` (cPickle is faster). This only applies for python 2.x. DCNL protocol : int or None DCNL Pickle protocol to use - see the :mod:`pickle` module for details on DCNL these options. If None, the most recent protocol will be used. DCNL append : bool DCNL If True, the object is appended to the end of the file, otherwise the DCNL file will be overwritten (if a file object is given instead of a DCNL file name, this has no effect).'
def annotate_webext_incompatibilities(results, file_, addon, version_string, channel): DCNL 'Check for WebExtension upgrades or downgrades. DCNL We avoid developers to downgrade their webextension to a XUL add-on DCNL at any cost and warn in case of an upgrade from XUL add-on to a DCNL WebExtension. DCNL Firefox doesn\'t support a downgrade. DCNL See https://github.com/mozilla/addons-server/issues/3061 and DCNL https://github.com/mozilla/addons-server/issues/3082 for more details.'
def monkeypatch(klass, methodname=None): DCNL 'Decorator extending class with the decorated callable. This is basically DCNL a syntactic sugar vs class assignment. DCNL >>> class A: DCNL ...     pass DCNL >>> @monkeypatch(A) DCNL ... def meth(self): DCNL ...     return 12 DCNL >>> a = A() DCNL >>> a.meth() DCNL 12 DCNL >>> @monkeypatch(A, \'foo\') DCNL ... def meth(self): DCNL ...     return 12 DCNL >>> a.foo() DCNL 12'
@pytest.mark.network DCNL def test_download_if_requested(script): DCNL 'It should download (in the scratch path) and not install if requested.'
def get_cpu_percentage(function, *args, **dargs): DCNL 'Returns a tuple containing the CPU% and return value from function call. DCNL This function calculates the usage time by taking the difference of DCNL the user and system times both before and after the function call.'
def test_evoked_arithmetic(): DCNL 'Test arithmetic of evoked data.'
def _parse_check(rule): DCNL 'Parse a single base check rule into an appropriate Check object.'
def check_password(environ, username, password): DCNL 'Authenticates against Django\'s auth database DCNL mod_wsgi docs specify None, True, False as return value depending DCNL on whether the user exists and authenticates.'
def build_parser(): DCNL 'Return a parser for parsing requirement lines'
def make_dependence_cmp(): DCNL 'Create a comparator to represent the dependence of nodes in a graph.'
def iplayer_from_raw(raw, linktype=1): DCNL 'Converts a raw packet to a dpkt packet regarding of link type. DCNL @param raw: raw packet DCNL @param linktype: integer describing link type as expected by dpkt'
def measure_mem_leakage(f, numsamples=(2 ** 7), iterspersample=(2 ** 4), *args, **kwargs): DCNL 'This does the same thing as measure_obj_leakage() but instead of using DCNL count_all_objects() it uses get_mem_usage(), which is currently DCNL implemented for Linux and barely implemented for Mac OS X. DCNL @param numsamples: recommended: 2**7 DCNL @param iterspersample: how many times `f()\' should be invoked per sample; DCNL Basically, choose `iterspersample\' such that DCNL (iterspersample * numsamples * DCNL how-long-it-takes-to-compute-`f()\') is slightly DCNL less than how long you are willing to wait for DCNL this leak test. DCNL @return: the slope of the best linear fit, which can be interpreted as DCNL \'the approximate number of system bytes allocated and not freed DCNL per invocation of f()\''
def generate_range(start=None, end=None, periods=None, offset=BDay(), time_rule=None): DCNL 'Generates a sequence of dates corresponding to the specified time DCNL offset. Similar to dateutil.rrule except uses pandas DateOffset DCNL objects to represent time increments DCNL Parameters DCNL start : datetime (default None) DCNL end : datetime (default None) DCNL periods : int, optional DCNL time_rule : (legacy) name of DateOffset object to be used, optional DCNL Corresponds with names expected by tseries.frequencies.get_offset DCNL Notes DCNL * This method is faster for generating weekdays than dateutil.rrule DCNL * At least two of (start, end, periods) must be specified. DCNL * If both start and end are specified, the returned dates will DCNL satisfy start <= date <= end. DCNL * If both time_rule and offset are specified, time_rule supersedes offset. DCNL Returns DCNL dates : generator object'
def render_record(response, record, file_url=None, extra_data=None): DCNL 'Render an appstats record in detail. DCNL This is a minor refactoring of DetailsHandler to support an offline DCNL tool for analyzing Appstats data and to allow that tool to call DCNL the original Appstats detailed record visualization. Since the offline DCNL tool may read Appstats records from other sources (e.g., a downloaded file), DCNL we are moving the logic of DetailsHandler related to processing and DCNL visualizing individual Appstats records to this function. This DCNL function may now be called from outside this file. DCNL Args: DCNL response: An instance of the webapp response class representing DCNL data to be sent in response to a web request. DCNL record: A RequestStatProto which contains detailed Appstats recording DCNL for an individual request. DCNL file_url: Indicates the URL to be used to follow links to files in DCNL application source code. A default value of \'None\' indicates that DCNL links to files in source code will not be shown. DCNL extra_data: Optional dict of additional parameters for template.'
def _get_proc_create_time(proc): DCNL 'Returns the create_time of a Process instance. DCNL It\'s backward compatible with < 2.0 versions of psutil.'
@context.quietfunc DCNL def packages(): DCNL 'Returns a list of packages installed on the system'
def get_disk_bus_for_device_type(virt_type, image_meta=None, device_type='disk'): DCNL 'Determine the best disk bus to use for a device type. DCNL Considering the currently configured virtualization DCNL type, return the optimal disk_bus to use for a given DCNL device type. For example, for a disk on KVM it will DCNL return \'virtio\', while for a CDROM it will return \'ide\' DCNL Returns the disk_bus, or returns None if the device DCNL type is not supported for this virtualization'
def version(proxy): DCNL 'Returns the OS version. DCNL Example: 13.3R6.5, 6.0.2 etc. DCNL CLI Example - select all network devices running JunOS 13.3R6.5 and return the model: DCNL .. code-block:: bash DCNL salt -G \'os:junos and version:13.3R6.5\' grains.get model DCNL Output: DCNL .. code-block:: yaml DCNL edge01.bjm01: DCNL MX2000 DCNL edge01.sjc01: DCNL MX960 DCNL edge01.mrs01: DCNL MX480 DCNL edge01.muc01: DCNL MX240'
@require_context DCNL def virtual_interface_get_by_uuid(context, vif_uuid): DCNL 'Gets a virtual interface from the table. DCNL :param vif_uuid: the uuid of the interface you\'re looking to get'
def spawn(coro): DCNL 'Event: add another coroutine to the scheduler. Both the parent DCNL and child coroutines run concurrently.'
def test_raw_unicode_escape_dashes(): DCNL 'Make sure that either dashes or underscores work in raw encoding name'
def implements(obj, interface): DCNL 'Return true if the give object (maybe an instance or class) implements DCNL the interface.'
@with_setup(prepare_stdout) DCNL def test_output_outlines_success_colorless(): DCNL 'Language: ru -> sucess outlines colorless'
def test_missing_data_pandas(): DCNL 'Fixes GH: #144'
def URL(a=None, c=None, f=None, r=None, args=None, vars=None, anchor='', extension=None, env=None, hmac_key=None, hash_vars=True, salt=None, user_signature=None, scheme=None, host=None, port=None, encode_embedded_slash=False, url_encode=True, language=None): DCNL 'generates a url \'/a/c/f\' corresponding to application a, controller c DCNL and function f. If r=request is passed, a, c, f are set, respectively, DCNL to r.application, r.controller, r.function. DCNL The more typical usage is: DCNL URL(\'index\') DCNL that generates a url for the index function DCNL within the present application and controller. DCNL Args: DCNL a: application (default to current if r is given) DCNL c: controller (default to current if r is given) DCNL f: function (default to current if r is given) DCNL r: request (optional) DCNL args: any arguments (optional). Additional "path" elements DCNL vars: any variables (optional). Querystring elements DCNL anchor: anchorname, without # (optional) DCNL extension: force an extension DCNL hmac_key: key to use when generating hmac signature (optional) DCNL hash_vars: which of the vars to include in our hmac signature DCNL True (default) - hash all vars, False - hash none of the vars, DCNL iterable - hash only the included vars [\'key1\',\'key2\'] DCNL salt: salt hashing with this string DCNL user_signature: signs automatically the URL in such way that only the DCNL user can access the URL (use with `URL.verify` or DCNL `auth.requires_signature()`) DCNL scheme: URI scheme (True, \'http\' or \'https\', etc); forces absolute URL (optional) DCNL host: string to force absolute URL with host (True means http_host) DCNL port: optional port number (forces absolute URL) DCNL encode_embedded_slash: encode slash characters included in args DCNL url_encode: encode characters included in vars DCNL Raises: DCNL SyntaxError: when no application, controller or function is available DCNL or when a CRLF is found in the generated url DCNL Examples: DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'x\', \'y\', \'z\'], DCNL ...     vars={\'p\':1, \'q\':2}, anchor=\'1\')) DCNL \'/a/c/f/x/y/z?p=1&q=2#1\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'x\', \'y\', \'z\'], DCNL ...     vars={\'p\':(1,3), \'q\':2}, anchor=\'1\')) DCNL \'/a/c/f/x/y/z?p=1&p=3&q=2#1\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'x\', \'y\', \'z\'], DCNL ...     vars={\'p\':(3,1), \'q\':2}, anchor=\'1\')) DCNL \'/a/c/f/x/y/z?p=3&p=1&q=2#1\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', anchor=\'1+2\')) DCNL \'/a/c/f#1%2B2\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'x\', \'y\', \'z\'], DCNL ...     vars={\'p\':(1,3), \'q\':2}, anchor=\'1\', hmac_key=\'key\')) DCNL \'/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f#1\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'w/x\', \'y/z\'])) DCNL \'/a/c/f/w/x/y/z\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'w/x\', \'y/z\'], encode_embedded_slash=True)) DCNL \'/a/c/f/w%2Fx/y%2Fz\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'%(id)d\'], url_encode=False)) DCNL \'/a/c/f/%(id)d\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', args=[\'%(id)d\'], url_encode=True)) DCNL \'/a/c/f/%25%28id%29d\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', vars={\'id\' : \'%(id)d\' }, url_encode=False)) DCNL \'/a/c/f?id=%(id)d\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', vars={\'id\' : \'%(id)d\' }, url_encode=True)) DCNL \'/a/c/f?id=%25%28id%29d\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', anchor=\'%(id)d\', url_encode=False)) DCNL \'/a/c/f#%(id)d\' DCNL >>> str(URL(a=\'a\', c=\'c\', f=\'f\', anchor=\'%(id)d\', url_encode=True)) DCNL \'/a/c/f#%25%28id%29d\''
@core_helper DCNL @maintain.deprecated('h.subnav_named_route DCSP is DCSP deprecated DCSP please DCSP use DCSP h.nav_link\nNOTE: DCSP you DCSP will DCSP need DCSP to DCSP pass DCSP the DCSP route_name DCSP as DCSP a DCSP named DCSP parameter') DCNL def subnav_named_route(text, named_route, **kwargs): DCNL 'Generate a subnav element based on a named route DCNL Deprecated in ckan 2.0'
def direct_get_object(node, part, account, container, obj, conn_timeout=5, response_timeout=15, resp_chunk_size=None, headers={}): DCNL 'Get object directly from the object server. DCNL :param node: node dictionary from the ring DCNL :param part: partition the container is on DCNL :param account: account name DCNL :param container: container name DCNL :param obj: object name DCNL :param conn_timeout: timeout in seconds for establishing the connection DCNL :param response_timeout: timeout in seconds for getting the response DCNL :param resp_chunk_size: if defined, chunk size of data to read. DCNL :param headers: dict to be passed into HTTPConnection headers DCNL :returns: a tuple of (response headers, the object\'s contents) The response DCNL headers will be a dict and all header names will be lowercase.'
def residue_reduce_to_basic(H, DE, z): DCNL 'Converts the tuple returned by residue_reduce() into a Basic expression.'
def get_sid_string(principal): DCNL 'Converts a PySID object to a string SID. DCNL Args: DCNL principal(str): The principal to lookup the sid. Must be a PySID object. DCNL Returns: DCNL str: A sid DCNL Usage: DCNL .. code-block:: python DCNL # Get a PySID object DCNL py_sid = salt.utils.win_dacl.get_sid(\'jsnuffy\') DCNL # Get the string version of the SID DCNL salt.utils.win_dacl.get_sid_string(py_sid)'
def get_bs_object_for_view(request, view, user, object=None): DCNL 'Help function to get BeautifulSoup object from the html rendered DCNL by the edit view. DCNL Also override ``service_provider_admin_form`` here to enable DCNL ``PseudoPaymentProcessor``'
def get_ratio(old, new): DCNL 'Return a "similiarity ratio" (in percent) representing the similarity DCNL between the two strings where 0 is equal and anything above less than equal.'
@auth_decorator DCNL def token_authenticated(self): DCNL 'decorator for a method authenticated only by the Authorization token header DCNL (no cookies)'
def f3(): DCNL 'Testing unboxed values'
def create_account_with_params(request, params): DCNL 'Given a request and a dict of parameters (which may or may not have come DCNL from the request), create an account for the requesting user, including DCNL creating a comments service user object and sending an activation email. DCNL This also takes external/third-party auth into account, updates that as DCNL necessary, and authenticates the user for the request\'s session. DCNL Does not return anything. DCNL Raises AccountValidationError if an account with the username or email DCNL specified by params already exists, or ValidationError if any of the given DCNL parameters is invalid for any other reason. DCNL Issues with this code: DCNL * It is not transactional. If there is a failure part-way, an incomplete DCNL account will be created and left in the database. DCNL * Third-party auth passwords are not verified. There is a comment that DCNL they are unused, but it would be helpful to have a sanity check that DCNL they are sane. DCNL * It is over 300 lines long (!) and includes disprate functionality, from DCNL registration e-mails to all sorts of other things. It should be broken DCNL up into semantically meaningful functions. DCNL * The user-facing text is rather unfriendly (e.g. "Username must be a DCNL minimum of two characters long" rather than "Please use a username of DCNL at least two characters").'
def compose(*functions): DCNL 'Compose functions DCNL This is useful for combining decorators.'
@require_role('admin') DCNL def asset_update(request): DCNL 'Asset update host info via ansible view'
def ode_1st_homogeneous_coeff_subs_dep_div_indep(eq, func, order, match): DCNL 'Solves a 1st order differential equation with homogeneous coefficients DCNL using the substitution `u_1 = \frac{\text{<dependent DCNL variable>}}{\text{<independent variable>}}`. DCNL This is a differential equation DCNL .. math:: P(x, y) + Q(x, y) dy/dx = 0 DCNL such that `P` and `Q` are homogeneous and of the same order.  A function DCNL `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`. DCNL Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`.  See DCNL also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`. DCNL If the coefficients `P` and `Q` in the differential equation above are DCNL homogeneous functions of the same order, then it can be shown that the DCNL substitution `y = u_1 x` (i.e. `u_1 = y/x`) will turn the differential DCNL equation into an equation separable in the variables `x` and `u`.  If DCNL `h(u_1)` is the function that results from making the substitution `u_1 = DCNL f(x)/x` on `P(x, f(x))` and `g(u_2)` is the function that results from the DCNL substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) + DCNL Q(x, f(x)) f\'(x) = 0`, then the general solution is:: DCNL >>> from sympy import Function, dsolve, pprint DCNL >>> from sympy.abc import x DCNL >>> f, g, h = map(Function, [\'f\', \'g\', \'h\']) DCNL >>> genform = g(f(x)/x) + h(f(x)/x)*f(x).diff(x) DCNL >>> pprint(genform) DCNL /f(x)\    /f(x)\ d DCNL g|----| + h|----|*--(f(x)) DCNL \ x  /    \ x  / dx DCNL >>> pprint(dsolve(genform, f(x), DCNL ... hint=\'1st_homogeneous_coeff_subs_dep_div_indep_Integral\')) DCNL f(x) DCNL x DCNL |       -h(u1) DCNL log(x) = C1 +   |  ---------------- d(u1) DCNL |  u1*h(u1) + g(u1) DCNL Where `u_1 h(u_1) + g(u_1) \ne 0` and `x \ne 0`. DCNL See also the docstrings of DCNL :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best` and DCNL :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`. DCNL Examples DCNL >>> from sympy import Function, dsolve DCNL >>> from sympy.abc import x DCNL >>> f = Function(\'f\') DCNL >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x), DCNL ... hint=\'1st_homogeneous_coeff_subs_dep_div_indep\', simplify=False)) DCNL /          3   \ DCNL |3*f(x)   f (x)| DCNL log|------ + -----| DCNL |  x         3 | DCNL \           x  / DCNL log(x) = log(C1) - ------------------- DCNL 3 DCNL References DCNL - http://en.wikipedia.org/wiki/Homogeneous_differential_equation DCNL - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", DCNL Dover 1963, pp. 59 DCNL # indirect doctest'
@register.inclusion_tag('inclusion.html') DCNL def inclusion_two_params(one, two): DCNL 'Expected inclusion_two_params __doc__'
def call_command(name, *args, **options): DCNL 'Calls the given command, with the given options and args/kwargs. DCNL This is the primary API you should use for calling specific commands. DCNL Some examples: DCNL call_command(\'syncdb\') DCNL call_command(\'shell\', plain=True) DCNL call_command(\'sqlall\', \'myapp\')'
def add_prerequisite(course_key, prereq_content_key): DCNL 'Creates a new Milestone and CourseContentMilestone indicating that DCNL the given course content fulfills a prerequisite for gating DCNL Arguments: DCNL course_key (str|CourseKey): The course key DCNL prereq_content_key (str|UsageKey): The prerequisite content usage key DCNL Returns: DCNL None'
def HostAPI(*args, **kwargs): DCNL 'Returns the \'HostAPI\' class from the same module as the configured DCNL compute api'
def run_script_with_context(script_path, cwd, context): DCNL 'Execute a script after rendering it with Jinja. DCNL :param script_path: Absolute path to the script to run. DCNL :param cwd: The directory to run the script from. DCNL :param context: Cookiecutter project template context.'
def _filter_ipv4(addresses): DCNL 'Select IPv4 addresses from the list of IP addresses. DCNL :param list addresses: The list of the addresses to filter. DCNL :return: The list of addresses that are IPv4 addresses. DCNL :rtype: list'
def square(x): DCNL 'Element-wise square. DCNL # Arguments DCNL x: input tensor. DCNL # Returns DCNL A tensor.'
def lag_select(data, max_lags=5, ic=None): DCNL 'Select number of lags based on a variety of information criteria DCNL Parameters DCNL data : DataFrame-like DCNL max_lags : int DCNL Maximum number of lags to evaluate DCNL ic : {None, \'aic\', \'bic\', ...} DCNL Choosing None will just display the results DCNL Returns DCNL None'
def setup_livestreamer(): DCNL 'Creates the Livestreamer session.'
def __virtual__(): DCNL 'Only load if boto libraries exist.'
def bokeh_tree(name, rawtext, text, lineno, inliner, options=None, content=None): DCNL 'Link to a URL in the Bokeh GitHub tree, pointing to appropriate tags DCNL for releases, or to master otherwise. DCNL The link text is simply the URL path supplied, so typical usage might DCNL look like: DCNL .. code-block:: none DCNL All of the examples are located in the :bokeh-tree:`examples` DCNL subdirectory of your Bokeh checkout. DCNL Returns 2 part tuple containing list of nodes to insert into the DCNL document and a list of system messages.  Both are allowed to be DCNL empty.'
def toptexts(query, texts, index, n=10): DCNL 'Debug fnc to help inspect the top `n` most similar documents (according to a DCNL similarity index `index`), to see if they are actually related to the query. DCNL `texts` is any object that can return something insightful for each document DCNL via `texts[docid]`, such as its fulltext or snippet. DCNL Return a list of 3-tuples (docid, doc\'s similarity to the query, texts[docid]).'
@register.tag('cache') DCNL def do_cache(parser, token): DCNL 'This will cache the contents of a template fragment for a given amount DCNL of time. DCNL Usage:: DCNL {% load cache %} DCNL {% cache [expire_time] [fragment_name] %} DCNL .. some expensive processing .. DCNL {% endcache %} DCNL This tag also supports varying by a list of arguments:: DCNL {% load cache %} DCNL {% cache [expire_time] [fragment_name] [var1] [var2] .. %} DCNL .. some expensive processing .. DCNL {% endcache %} DCNL Optionally the cache to use may be specified thus:: DCNL {% cache ....  using="cachename" %} DCNL Each unique set of arguments will result in a unique cache entry.'
def unlock(hass, entity_id=None, code=None): DCNL 'Unlock all or specified locks.'
def KernelVersion(): DCNL 'Gets the kernel version as string, eg. "5.1.2600". DCNL Returns: DCNL The kernel version, or "unknown" in the case of failure.'
@tasklets.tasklet DCNL def fetch_data_async(blob, start_index, end_index, **options): DCNL 'Async version of fetch_data().'
def csd(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None, detrend='constant', return_onesided=True, scaling='density', axis=(-1)): DCNL 'Estimate the cross power spectral density, Pxy, using Welch\'s method. DCNL Parameters DCNL x : array_like DCNL Time series of measurement values DCNL y : array_like DCNL Time series of measurement values DCNL fs : float, optional DCNL Sampling frequency of the `x` and `y` time series. Defaults to 1.0. DCNL window : str or tuple or array_like, optional DCNL Desired window to use. See `get_window` for a list of windows and DCNL required parameters. If `window` is array_like it will be used DCNL directly as the window and its length will be used for nperseg. DCNL Defaults to \'hann\'. DCNL nperseg : int, optional DCNL Length of each segment. Defaults to None, but if window is str or DCNL tuple, is set to 256, and if window is array_like, is set to the DCNL length of the window. DCNL noverlap: int, optional DCNL Number of points to overlap between segments. If None, DCNL ``noverlap = nperseg // 2``.  Defaults to None. DCNL nfft : int, optional DCNL Length of the FFT used, if a zero padded FFT is desired. If None, DCNL the FFT length is `nperseg`. Defaults to None. DCNL detrend : str or function or False, optional DCNL Specifies how to detrend each segment. If `detrend` is a string, DCNL it is passed as the ``type`` argument to `detrend`.  If it is a DCNL function, it takes a segment and returns a detrended segment. DCNL If `detrend` is False, no detrending is done.  Defaults to \'constant\'. DCNL return_onesided : bool, optional DCNL If True, return a one-sided spectrum for real data. If False return DCNL a two-sided spectrum. Note that for complex data, a two-sided DCNL spectrum is always returned. DCNL scaling : { \'density\', \'spectrum\' }, optional DCNL Selects between computing the cross spectral density (\'density\') DCNL where `Pxy` has units of V**2/Hz and computing the cross spectrum DCNL (\'spectrum\') where `Pxy` has units of V**2, if `x` and `y` are DCNL measured in V and fs is measured in Hz.  Defaults to \'density\' DCNL axis : int, optional DCNL Axis along which the CSD is computed for both inputs; the default is DCNL over the last axis (i.e. ``axis=-1``). DCNL Returns DCNL f : ndarray DCNL Array of sample frequencies. DCNL Pxy : ndarray DCNL Cross spectral density or cross power spectrum of x,y. DCNL See Also DCNL periodogram: Simple, optionally modified periodogram DCNL lombscargle: Lomb-Scargle periodogram for unevenly sampled data DCNL welch: Power spectral density by Welch\'s method. [Equivalent to csd(x,x)] DCNL coherence: Magnitude squared coherence by Welch\'s method. DCNL Notes DCNL By convention, Pxy is computed with the conjugate FFT of X multiplied by DCNL the FFT of Y. DCNL If the input series differ in length, the shorter series will be DCNL zero-padded to match. DCNL An appropriate amount of overlap will depend on the choice of window DCNL and on your requirements.  For the default \'hann\' window an DCNL overlap of 50\% is a reasonable trade off between accurately estimating DCNL the signal power, while not over counting any of the data.  Narrower DCNL windows may require a larger overlap. DCNL .. versionadded:: 0.16.0 DCNL References DCNL .. [1] P. Welch, "The use of the fast Fourier transform for the DCNL estimation of power spectra: A method based on time averaging DCNL over short, modified periodograms", IEEE Trans. Audio DCNL Electroacoust. vol. 15, pp. 70-73, 1967. DCNL .. [2] Rabiner, Lawrence R., and B. Gold. "Theory and Application of DCNL Digital Signal Processing" Prentice-Hall, pp. 414-419, 1975 DCNL Examples DCNL >>> from scipy import signal DCNL >>> import matplotlib.pyplot as plt DCNL Generate two test signals with some common features. DCNL >>> fs = 10e3 DCNL >>> N = 1e5 DCNL >>> amp = 20 DCNL >>> freq = 1234.0 DCNL >>> noise_power = 0.001 * fs / 2 DCNL >>> time = np.arange(N) / fs DCNL >>> b, a = signal.butter(2, 0.25, \'low\') DCNL >>> x = np.random.normal(scale=np.sqrt(noise_power), size=time.shape) DCNL >>> y = signal.lfilter(b, a, x) DCNL >>> x += amp*np.sin(2*np.pi*freq*time) DCNL >>> y += np.random.normal(scale=0.1*np.sqrt(noise_power), size=time.shape) DCNL Compute and plot the magnitude of the cross spectral density. DCNL >>> f, Pxy = signal.csd(x, y, fs, nperseg=1024) DCNL >>> plt.semilogy(f, np.abs(Pxy)) DCNL >>> plt.xlabel(\'frequency [Hz]\') DCNL >>> plt.ylabel(\'CSD [V**2/Hz]\') DCNL >>> plt.show()'
def check_output(command, cwd=None, shell=False, env=None, stdin=__sentinel__, stderr=__sentinel__, preexec_fn=None, use_texpath=True, show_window=False): DCNL 'Takes a command to be passed to subprocess.Popen. DCNL Returns the output if the command was successful. DCNL By default stderr is redirected to stdout, so this will return any output DCNL to either stream. This can be changed by calling execute_command with DCNL stderr set to subprocess.PIPE or any other valid value. DCNL Raises CalledProcessError if the command returned a non-zero value DCNL Raises OSError if the executable is not found DCNL This is pretty much identical to subprocess.check_output(), but DCNL implemented here since it is unavailable in Python 2.6\'s library.'
def run_pyreverse(): DCNL 'run pyreverse'
def scroll_page_up(event): DCNL 'Scroll page up. (Prefer the cursor at the bottom of the page, after scrolling.)'
@hook.command('ghissue', 'issue') DCNL def issue(text): DCNL '<username|repo> [number] - gets issue [number]\'s summary, or the open issue count if no issue is specified'
def skip_unless_lms(func): DCNL 'Only run the decorated test in the LMS test suite'
def getIndexedLoopFromIndexedGrid(indexedGrid): DCNL 'Get indexed loop from around the indexed grid.'
def validate_password(user, password): DCNL 'Tie in password policy enforcement as an optional level of DCNL security protection DCNL Args: DCNL user: the user object whose password we\'re checking. DCNL password: the user\'s proposed new password. DCNL Returns: DCNL is_valid_password: a boolean indicating if the new password DCNL passes the validation. DCNL err_msg: an error message if there\'s a violation of one of the password DCNL checks. Otherwise, `None`.'
def server_handled_successfully(status_int): DCNL 'True for successful responses *or* error codes that are not Swift\'s fault, DCNL False otherwise. For example, 500 is definitely the server\'s fault, but DCNL 412 is an error code (4xx are all errors) that is due to a header the DCNL client sent. DCNL If one is tracking error rates to monitor server health, one would be DCNL advised to use a function like this one, lest a client cause a flurry of DCNL 404s or 416s and make a spurious spike in your errors graph.'
def get_function_object(obj): DCNL 'Objects that wraps function should provide a "__numba__" magic attribute DCNL that contains a name of an attribute that contains the actual python DCNL function object.'
def get_service(hass, config, discovery_info=None): DCNL 'Get the Slack notification service.'
def maybeDeferred(f, *args, **kw): DCNL 'Invoke a function that may or may not return a L{Deferred}. DCNL Call the given function with the given arguments.  If the returned DCNL object is a L{Deferred}, return it.  If the returned object is a L{Failure}, DCNL wrap it with L{fail} and return it.  Otherwise, wrap it in L{succeed} and DCNL return it.  If an exception is raised, convert it to a L{Failure}, wrap it DCNL in L{fail}, and then return it. DCNL @type f: Any callable DCNL @param f: The callable to invoke DCNL @param args: The arguments to pass to C{f} DCNL @param kw: The keyword arguments to pass to C{f} DCNL @rtype: L{Deferred} DCNL @return: The result of the function call, wrapped in a L{Deferred} if DCNL necessary.'
def addToMenu(master, menu, repository, window): DCNL 'Add a tool plugin menu.'
def onlyPy26OrOlder(test): DCNL 'Skips this test unless you are on Python2.6.x or earlier.'
def grain_funcs(opts, proxy=None): DCNL 'Returns the grain functions DCNL .. code-block:: python DCNL import salt.config DCNL import salt.loader DCNL __opts__ = salt.config.minion_config(\'/etc/salt/minion\') DCNL grainfuncs = salt.loader.grain_funcs(__opts__)'
@_api_version(1.21) DCNL @_client_version('1.5.0') DCNL def connect_container_to_network(container, network_id): DCNL 'Connect container to network. DCNL container DCNL Container name or ID DCNL network_id DCNL ID of network DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion dockerng.connect_container_from_network web-1 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc'
def addListToListTable(elementList, key, listTable): DCNL 'Add a list to the list table.'
def test_isotonic_regression_ties_secondary_(): DCNL 'Test isotonic regression fit, transform  and fit_transform DCNL against the "secondary" ties method and "pituitary" data from R DCNL "isotone" package, as detailed in: J. d. Leeuw, K. Hornik, P. Mair, DCNL Isotone Optimization in R: Pool-Adjacent-Violators Algorithm DCNL (PAVA) and Active Set Methods DCNL Set values based on pituitary example and DCNL the following R command detailed in the paper above: DCNL > library("isotone") DCNL > data("pituitary") DCNL > res1 <- gpava(pituitary$age, pituitary$size, ties="secondary") DCNL > res1$x DCNL `isotone` version: 1.0-2, 2014-09-07 DCNL R version: R version 3.1.1 (2014-07-10)'
def publish_badges(request): DCNL 'Publish - Marketplace badges.'
def Run(arg_dict, oauth2_parameters=None): DCNL 'Sets up and runs the bulkloader, given the options as keyword arguments. DCNL Args: DCNL arg_dict: Dictionary of bulkloader options DCNL oauth2_parameters: None, or the parameters for OAuth2 authentication. DCNL Returns: DCNL An exit code.'
def __virtual__(): DCNL 'Only load if boto is available.'
def fitness_and_quality_parsed(mime_type, parsed_ranges): DCNL 'Find the best match for a given mime-type against DCNL a list of media_ranges that have already been DCNL parsed by parse_media_range(). Returns a tuple of DCNL the fitness value and the value of the \'q\' quality DCNL parameter of the best match, or (-1, 0) if no match DCNL was found. Just as for quality_parsed(), \'parsed_ranges\' DCNL must be a list of parsed media ranges.'
def native(s): DCNL 'Convert :py:class:`bytes` or :py:class:`unicode` to the native DCNL :py:class:`str` type, using UTF-8 encoding if conversion is necessary. DCNL :raise UnicodeError: The input string is not UTF-8 decodeable. DCNL :raise TypeError: The input is neither :py:class:`bytes` nor DCNL :py:class:`unicode`.'
def test_init(): DCNL 'Test the initialisation of the object'
def bump_version(version): DCNL 'Update the version number in setup.py, docs config, changelog, DCNL and root module.'
def getRevisionNumber(): DCNL 'Returns abbreviated commit hash number as retrieved with "git rev-parse --short HEAD"'
def test_ncr_fit_sample(): DCNL 'Test the fit sample routine'
def get_selections(pattern=None, state=None): DCNL 'View package state from the dpkg database. DCNL Returns a dict of dicts containing the state, and package names: DCNL .. code-block:: python DCNL {\'<host>\': DCNL {\'<state>\': [\'pkg1\', DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.get_selections DCNL salt \'*\' pkg.get_selections \'python-*\' DCNL salt \'*\' pkg.get_selections state=hold DCNL salt \'*\' pkg.get_selections \'openssh*\' state=hold'
def _diff_cache_subnet_group(current, desired): DCNL 'If you need to enhance what modify_cache_subnet_group() considers when deciding what is to be DCNL (or can be) updated, add it to \'modifiable\' below.  It\'s a dict mapping the param as used DCNL in modify_cache_subnet_group() to that in describe_cache_subnet_group().  Any data fiddlery that DCNL needs to be done to make the mappings meaningful should be done in the munging section DCNL below as well. DCNL This function will ONLY touch settings that are explicitly called out in \'desired\' - any DCNL settings which might have previously been changed from their \'default\' values will not be DCNL changed back simply by leaving them out of \'desired\'.  This is both intentional, and DCNL much, much easier to code :)'
def clearCache(indexerid=0): DCNL 'Deletes all "unknown" entries from the cache (names with indexer_id of 0).'
def is_staging(srv): DCNL 'Determine whether a given ACME server is a known test / staging server. DCNL :param str srv: the URI for the ACME server DCNL :returns: True iff srv is a known test / staging server DCNL :rtype bool:'
def _get_or_default(mylist, i, default=None): DCNL 'return list item number, or default if don\'t exist'
def pseudo_quoteattr(value): DCNL 'Quote attributes for pseudo-xml'
def getFillOfSurroundings(surroundingLoops): DCNL 'Get extra fill loops of surrounding loops.'
def decorator(caller, _func=None): DCNL 'decorator(caller) converts a caller function into a decorator'
def update_exploration_summary(exploration_id, contributor_id_to_add): DCNL 'Update the summary of an exploration.'
def clean_fuzzable_request(fuzzable_request, dc_handler=clean_data_container): DCNL 'We receive a fuzzable request and output includes the HTTP method and DCNL any parameters which might be sent over HTTP post-data in the request DCNL are appended to the result as query string params. DCNL :param fuzzable_request: The fuzzable request instance to clean'
def switchOff(): DCNL '(Not needed as of v1.76.00; kept for backwards compatibility only.)'
@register.simple_tag DCNL def absolute_asset_url(module, path): DCNL 'Returns a versioned absolute asset URL (located within Sentry\'s static files). DCNL Example: DCNL {% absolute_asset_url \'sentry\' \'dist/sentry.css\' %} DCNL =>  "http://sentry.example.com/_static/74d127b78dc7daf2c51f/sentry/dist/sentry.css"'
def create(context, namespace_name, values, session): DCNL 'Create an association, raise if already exists or ns not found.'
@curry DCNL def as_labelarray(initial_dtype, missing_value, array): DCNL 'Curried wrapper around LabelArray, that round-trips the input data through DCNL `initial_dtype` first.'
def is_equal(var, val): DCNL 'Returns True if `var` is always equal to `val`. DCNL This will only return True if the variable will always be equal to DCNL the value.  If it might not be true in some cases then it returns False. DCNL Parameters DCNL var DCNL Variable to compare DCNL val DCNL Python value'
def main(argv): DCNL 'Main program body'
def new_figure_manager_given_figure(num, figure): DCNL 'Create a new figure manager instance for the given figure.'
def _default_selem(ndim): DCNL 'Generates a cross-shaped structuring element (connectivity=1). DCNL This is the default structuring element (selem) if no selem was specified. DCNL Parameters DCNL ndim : int DCNL Number of dimensions of the image. DCNL Returns DCNL selem : ndarray DCNL The structuring element where elements of the neighborhood DCNL are 1 and 0 otherwise.'
@pytest.fixture DCNL def keyhint(qtbot, config_stub, key_config_stub): DCNL 'Fixture to initialize a KeyHintView.'
def decode_feedback(binary_tuples): DCNL 'Returns a list of tuples in (datetime, token_str) format DCNL binary_tuples   the binary-encoded feedback tuples'
def _partition_tasks(worker): DCNL 'Takes a worker and sorts out tasks based on their status. DCNL Still_pending_not_ext is only used to get upstream_failure, upstream_missing_dependency and run_by_other_worker'
def rmtree(dirname): DCNL 'A threadsafe and idempotent version of shutil.rmtree().  If the dir is DCNL already gone, do nothing and return without raising an exception.  If this DCNL call removes the dir, return without raising an exception.  If there is an DCNL error that prevents deletion or if the directory gets created again after DCNL rm_dir() deletes it and before rm_dir() checks that it is gone, raise an DCNL exception.'
def generate_skip_gram_batch(data, batch_size, num_skips, skip_window, data_index=0): DCNL 'Generate a training batch for the Skip-Gram model. DCNL Parameters DCNL data : a list DCNL To present context. DCNL batch_size : an int DCNL Batch size to return. DCNL num_skips : an int DCNL How many times to reuse an input to generate a label. DCNL skip_window : an int DCNL How many words to consider left and right. DCNL data_index : an int DCNL Index of the context location. DCNL without using yield, this code use data_index to instead. DCNL Returns DCNL batch : a list DCNL Inputs DCNL labels : a list DCNL Labels DCNL data_index : an int DCNL Index of the context location. DCNL Examples DCNL >>> Setting num_skips=2, skip_window=1, use the right and left words. DCNL >>> In the same way, num_skips=4, skip_window=2 means use the nearby 4 words. DCNL >>> data = [1,2,3,4,5,6,7,8,9,10,11] DCNL >>> batch, labels, data_index = tl.nlp.generate_skip_gram_batch(data=data, batch_size=8, num_skips=2, skip_window=1, data_index=0) DCNL >>> print(batch) DCNL ... [2 2 3 3 4 4 5 5] DCNL >>> print(labels) DCNL ... [[3] DCNL ... [1] DCNL ... [4] DCNL ... [2] DCNL ... [5] DCNL ... [3] DCNL ... [4] DCNL ... [6]] DCNL References DCNL - `TensorFlow word2vec tutorial <https://www.tensorflow.org/versions/r0.9/tutorials/word2vec/index.html#vector-representations-of-words>`_'
def default_sort_key(item, order=None): DCNL 'Return a key that can be used for sorting. DCNL The key has the structure: DCNL (class_key, (len(args), args), exponent.sort_key(), coefficient) DCNL This key is supplied by the sort_key routine of Basic objects when DCNL ``item`` is a Basic object or an object (other than a string) that DCNL sympifies to a Basic object. Otherwise, this function produces the DCNL key. DCNL The ``order`` argument is passed along to the sort_key routine and is DCNL used to determine how the terms *within* an expression are ordered. DCNL (See examples below) ``order`` options are: \'lex\', \'grlex\', \'grevlex\', DCNL and reversed values of the same (e.g. \'rev-lex\'). The default order DCNL value is None (which translates to \'lex\'). DCNL Examples DCNL >>> from sympy import S, I, default_sort_key, sin, cos, sqrt DCNL >>> from sympy.core.function import UndefinedFunction DCNL >>> from sympy.abc import x DCNL The following are equivalent ways of getting the key for an object: DCNL >>> x.sort_key() == default_sort_key(x) DCNL True DCNL Here are some examples of the key that is produced: DCNL >>> default_sort_key(UndefinedFunction(\'f\')) DCNL ((0, 0, \'UndefinedFunction\'), (1, (\'f\',)), ((1, 0, \'Number\'), DCNL (0, ()), (), 1), 1) DCNL >>> default_sort_key(\'1\') DCNL ((0, 0, \'str\'), (1, (\'1\',)), ((1, 0, \'Number\'), (0, ()), (), 1), 1) DCNL >>> default_sort_key(S.One) DCNL ((1, 0, \'Number\'), (0, ()), (), 1) DCNL >>> default_sort_key(2) DCNL ((1, 0, \'Number\'), (0, ()), (), 2) DCNL While sort_key is a method only defined for SymPy objects, DCNL default_sort_key will accept anything as an argument so it is DCNL more robust as a sorting key. For the following, using key= DCNL lambda i: i.sort_key() would fail because 2 doesn\'t have a sort_key DCNL method; that\'s why default_sort_key is used. Note, that it also DCNL handles sympification of non-string items likes ints: DCNL >>> a = [2, I, -I] DCNL >>> sorted(a, key=default_sort_key) DCNL [2, -I, I] DCNL The returned key can be used anywhere that a key can be specified for DCNL a function, e.g. sort, min, max, etc...: DCNL >>> a.sort(key=default_sort_key); a[0] DCNL 2 DCNL >>> min(a, key=default_sort_key) DCNL 2 DCNL Note DCNL The key returned is useful for getting items into a canonical order DCNL that will be the same across platforms. It is not directly useful for DCNL sorting lists of expressions: DCNL >>> a, b = x, 1/x DCNL Since ``a`` has only 1 term, its value of sort_key is unaffected by DCNL ``order``: DCNL >>> a.sort_key() == a.sort_key(\'rev-lex\') DCNL True DCNL If ``a`` and ``b`` are combined then the key will differ because there DCNL are terms that can be ordered: DCNL >>> eq = a + b DCNL >>> eq.sort_key() == eq.sort_key(\'rev-lex\') DCNL False DCNL >>> eq.as_ordered_terms() DCNL [x, 1/x] DCNL >>> eq.as_ordered_terms(\'rev-lex\') DCNL [1/x, x] DCNL But since the keys for each of these terms are independent of ``order``\'s DCNL value, they don\'t sort differently when they appear separately in a list: DCNL >>> sorted(eq.args, key=default_sort_key) DCNL [1/x, x] DCNL >>> sorted(eq.args, key=lambda i: default_sort_key(i, order=\'rev-lex\')) DCNL [1/x, x] DCNL The order of terms obtained when using these keys is the order that would DCNL be obtained if those terms were *factors* in a product. DCNL Although it is useful for quickly putting expressions in canonical order, DCNL it does not sort expressions based on their complexity defined by the DCNL number of operations, power of variables and others: DCNL >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key) DCNL [sin(x)*cos(x), sin(x)] DCNL >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key) DCNL [sqrt(x), x, x**2, x**3] DCNL See Also DCNL ordered, sympy.core.expr.as_ordered_factors, sympy.core.expr.as_ordered_terms'
def aggregate_metadata_add(context, aggregate_id, metadata, set_delete=False): DCNL 'Add/update metadata. If set_delete=True, it adds only.'
def remove_comments(code): DCNL 'Remove C-style comment from GLSL code string.'
def getGeometryOutput(derivation, elementNode): DCNL 'Get vector3 vertexes from attribute dictionary.'
def serialize(name, dataset=None, dataset_pillar=None, user=None, group=None, mode=None, backup='', makedirs=False, show_diff=True, create=True, merge_if_exists=False, **kwargs): DCNL 'Serializes dataset and store it into managed file. Useful for sharing DCNL simple configuration files. DCNL name DCNL The location of the file to create DCNL dataset DCNL The dataset that will be serialized DCNL dataset_pillar DCNL Operates like ``dataset``, but draws from a value stored in pillar, DCNL using the pillar path syntax used in :mod:`pillar.get DCNL <salt.modules.pillar.get>`. This is useful when the pillar value DCNL contains newlines, as referencing a pillar variable using a jinja/mako DCNL template can result in YAML formatting issues due to the newlines DCNL causing indentation mismatches. DCNL .. versionadded:: 2015.8.0 DCNL formatter DCNL Write the data as this format. See the list of :py:mod:`serializer DCNL modules <salt.serializers>` for supported output formats. DCNL user DCNL The user to own the directory, this defaults to the user salt is DCNL running as on the minion DCNL group DCNL The group ownership set for the directory, this defaults to the group DCNL salt is running as on the minion DCNL mode DCNL The permissions to set on this file, e.g. ``644``, ``0775``, or DCNL ``4664``. DCNL .. note:: DCNL This option is **not** supported on Windows. DCNL backup DCNL Overrides the default backup mode for this specific file. DCNL makedirs DCNL Create parent directories for destination file. DCNL .. versionadded:: 2014.1.3 DCNL show_diff DCNL If set to False, the diff will not be shown. DCNL create DCNL Default is True, if create is set to False then the file will only be DCNL managed if the file already exists on the system. DCNL merge_if_exists DCNL Default is False, if merge_if_exists is True then the existing file will DCNL be parsed and the dataset passed in will be merged with the existing DCNL content DCNL .. versionadded:: 2014.7.0 DCNL For example, this state: DCNL .. code-block:: yaml DCNL /etc/dummy/package.json: DCNL file.serialize: DCNL - dataset: DCNL name: naive DCNL description: A package using naive versioning DCNL author: A confused individual <iam@confused.com> DCNL dependencies: DCNL express: >= 1.2.0 DCNL optimist: >= 0.1.0 DCNL engine: node 0.4.1 DCNL - formatter: json DCNL will manage the file ``/etc/dummy/package.json``: DCNL .. code-block:: json DCNL "author": "A confused individual <iam@confused.com>", DCNL "dependencies": { DCNL "express": ">= 1.2.0", DCNL "optimist": ">= 0.1.0" DCNL "description": "A package using naive versioning", DCNL "engine": "node 0.4.1", DCNL "name": "naive"'
def _groupby_and_merge(by, on, left, right, _merge_pieces, check_duplicates=True): DCNL 'groupby & merge; we are always performing a left-by type operation DCNL Parameters DCNL by: field to group DCNL on: duplicates field DCNL left: left frame DCNL right: right frame DCNL _merge_pieces: function for merging DCNL check_duplicates: boolean, default True DCNL should we check & clean duplicates'
def draw_if_interactive(): DCNL 'For performance reasons, we don\'t want to redraw the figure after DCNL each draw command. Instead, we mark the figure as invalid, so that DCNL it will be redrawn as soon as the event loop resumes via PyOS_InputHook. DCNL This function should be called after each draw event, even if DCNL matplotlib is not running interactively.'
def _(msg, lang=None): DCNL 'Returns translated string in current lang, if exists.'
def privileges_revoke(name, object_name, object_type, privileges=None, prepend='public', maintenance_db=None, user=None, host=None, port=None, password=None, runas=None): DCNL '.. versionadded:: 2016.3.0 DCNL Revoke privileges on a postgres object DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' postgres.privileges_revoke user_name table_name table \ DCNL SELECT,UPDATE maintenance_db=db_name DCNL name DCNL Name of the role whose privileges should be revoked DCNL object_name DCNL Name of the object on which the revoke is to be performed DCNL object_type DCNL The object type, which can be one of the following: DCNL - table DCNL - sequence DCNL - schema DCNL - tablespace DCNL - language DCNL - database DCNL - group DCNL - function DCNL privileges DCNL Comma separated list of privileges to revoke, from the list below: DCNL - INSERT DCNL - CREATE DCNL - TRUNCATE DCNL - CONNECT DCNL - TRIGGER DCNL - SELECT DCNL - USAGE DCNL - TEMPORARY DCNL - UPDATE DCNL - EXECUTE DCNL - REFERENCES DCNL - DELETE DCNL - ALL DCNL maintenance_db DCNL The database to connect to DCNL user DCNL database username if different from config or default DCNL password DCNL user password if any password for a specified user DCNL host DCNL Database host if different from config or default DCNL port DCNL Database port if different from config or default DCNL runas DCNL System user all operations should be performed on behalf of'
def ensure_distance(dist): DCNL 'Makes sure the parameter passed in is a \'Distance\' object.'
def get_file_size(fileobj): DCNL 'Returns the size of a file-like object.'
def cli(): DCNL 'Command-line interface (looks at sys.argv to decide what to do).'
def iter_style_files(style_dir): DCNL 'Yield file path and name of styles in the given directory.'
def run_file(path_or_file, context=None): DCNL 'Context must be EvalJS object. Runs given path as a JS program. Returns (eval_value, context).'
def try_except(cond): DCNL '>>> try_except(True) DCNL >>> try_except(False) DCNL Traceback (most recent call last): DCNL UnboundLocalError: local variable \'a\' referenced before assignment'
def is_trunk_service_port(port_name): DCNL 'True if the port is any of the ports used to realize a trunk.'
def deprecated(func, name='Unknown'): DCNL 'This is a decorator which can be used to mark functions DCNL as deprecated. It will result in a warning being emmitted DCNL when the function is used.'
def CDLADVANCEBLOCK(barDs, count): DCNL 'Advance Block'
def iradon(radon_image, theta=None, output_size=None, filter='ramp', interpolation='linear', circle=None): DCNL 'Inverse radon transform. DCNL Reconstruct an image from the radon transform, using the filtered DCNL back projection algorithm. DCNL Parameters DCNL radon_image : array_like, dtype=float DCNL Image containing radon transform (sinogram). Each column of DCNL the image corresponds to a projection along a different angle. The DCNL tomography rotation axis should lie at the pixel index DCNL ``radon_image.shape[0] // 2`` along the 0th dimension of DCNL ``radon_image``. DCNL theta : array_like, dtype=float, optional DCNL Reconstruction angles (in degrees). Default: m angles evenly spaced DCNL between 0 and 180 (if the shape of `radon_image` is (N, M)). DCNL output_size : int DCNL Number of rows and columns in the reconstruction. DCNL filter : str, optional (default ramp) DCNL Filter used in frequency domain filtering. Ramp filter used by default. DCNL Filters available: ramp, shepp-logan, cosine, hamming, hann. DCNL Assign None to use no filter. DCNL interpolation : str, optional (default \'linear\') DCNL Interpolation method used in reconstruction. Methods available: DCNL \'linear\', \'nearest\', and \'cubic\' (\'cubic\' is slow). DCNL circle : boolean, optional DCNL Assume the reconstructed image is zero outside the inscribed circle. DCNL Also changes the default output_size to match the behaviour of DCNL ``radon`` called with ``circle=True``. DCNL The default behavior (None) is equivalent to False. DCNL Returns DCNL reconstructed : ndarray DCNL Reconstructed image. The rotation axis will be located in the pixel DCNL with indices DCNL ``(reconstructed.shape[0] // 2, reconstructed.shape[1] // 2)``. DCNL References DCNL .. [1] AC Kak, M Slaney, "Principles of Computerized Tomographic DCNL Imaging", IEEE Press 1988. DCNL .. [2] B.R. Ramesh, N. Srinivasa, K. Rajgopal, "An Algorithm for Computing DCNL the Discrete Radon Transform With Some Applications", Proceedings of DCNL the Fourth IEEE Region 10 International Conference, TENCON \'89, 1989 DCNL Notes DCNL It applies the Fourier slice theorem to reconstruct an image by DCNL multiplying the frequency domain of the filter with the FFT of the DCNL projection data. This algorithm is called filtered back projection.'
def spatial_dist_connectivity(src, dist, verbose=None): DCNL 'Compute connectivity from distances in a source space. DCNL Parameters DCNL src : instance of SourceSpaces DCNL The source space must have distances between vertices computed, such DCNL that src[\'dist\'] exists and is useful. This can be obtained using MNE DCNL with a call to mne_add_patch_info with the --dist option. DCNL dist : float DCNL Maximal geodesic distance (in m) between vertices in the DCNL source space to consider neighbors. DCNL verbose : bool, str, int, or None DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL connectivity : sparse COO matrix DCNL The connectivity matrix describing the spatial graph structure.'
def test_event_schema(): DCNL 'Test event_schema validation.'
def get_can_enable_dns(): DCNL 'Check whether we can query DNS to find the domain controller to use.'
def findall(pattern, string, flags=0, pos=None, endpos=None, overlapped=False, concurrent=None, **kwargs): DCNL 'Return a list of all matches in the string. The matches may be overlapped DCNL if overlapped is True. If one or more groups are present in the pattern, DCNL return a list of groups; this will be a list of tuples if the pattern has DCNL more than one group. Empty matches are included in the result.'
def store_job(opts, load, event=None, mminion=None): DCNL 'Store job information using the configured master_job_cache'
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs): DCNL 'Emit an XML document for the given `input_dict` (reverse of `parse`). DCNL The resulting XML document is returned as a string, but if `output` (a DCNL file-like object) is specified, it is written there instead. DCNL Dictionary keys prefixed with `attr_prefix` (default=`\'@\'`) are interpreted DCNL as XML node attributes, whereas keys equal to `cdata_key` DCNL (default=`\'#text\'`) are treated as character data. DCNL The `pretty` parameter (default=`False`) enables pretty-printing. In this DCNL mode, lines are terminated with `\' DCNL \'` and indented with `\' \'`, but this DCNL can be customized with the `newl` and `indent` parameters.'
def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False): DCNL 'Return a connection with a given alias.'
def _slice_1d(dim_shape, lengths, index): DCNL 'Returns a dict of {blocknum: slice} DCNL This function figures out where each slice should start in each DCNL block for a single dimension. If the slice won\'t return any elements DCNL in the block, that block will not be in the output. DCNL Parameters DCNL dim_shape - the number of elements in this dimension. DCNL This should be a positive, non-zero integer DCNL blocksize - the number of elements per block in this dimension DCNL This should be a positive, non-zero integer DCNL index - a description of the elements in this dimension that we want DCNL This might be an integer, a slice(), or an Ellipsis DCNL Returns DCNL dictionary where the keys are the integer index of the blocks that DCNL should be sliced and the values are the slices DCNL Examples DCNL Trivial slicing DCNL >>> _slice_1d(100, [60, 40], slice(None, None, None)) DCNL {0: slice(None, None, None), 1: slice(None, None, None)} DCNL 100 length array cut into length 20 pieces, slice 0:35 DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 35)) DCNL {0: slice(None, None, None), 1: slice(0, 15, 1)} DCNL Support irregular blocks and various slices DCNL >>> _slice_1d(100, [20, 10, 10, 10, 25, 25], slice(10, 35)) DCNL {0: slice(10, 20, 1), 1: slice(None, None, None), 2: slice(0, 5, 1)} DCNL Support step sizes DCNL >>> _slice_1d(100, [15, 14, 13], slice(10, 41, 3)) DCNL {0: slice(10, 15, 3), 1: slice(1, 14, 3), 2: slice(2, 12, 3)} DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 100, 40))  # step > blocksize DCNL {0: slice(0, 20, 40), 2: slice(0, 20, 40), 4: slice(0, 20, 40)} DCNL Also support indexing single elements DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], 25) DCNL {1: 5} DCNL And negative slicing DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 0, -3)) DCNL {0: slice(-2, -20, -3), 1: slice(-1, -21, -3), 2: slice(-3, -21, -3), 3: slice(-2, -21, -3), 4: slice(-1, -21, -3)} DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 12, -3)) DCNL {0: slice(-2, -8, -3), 1: slice(-1, -21, -3), 2: slice(-3, -21, -3), 3: slice(-2, -21, -3), 4: slice(-1, -21, -3)} DCNL >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, -12, -3)) DCNL {4: slice(-1, -12, -3)}'
def diff_states(start, end, ignore=None): DCNL 'Differences two "filesystem states" as represented by dictionaries DCNL of FoundFile and FoundDir objects. DCNL Returns a dictionary with following keys: DCNL ``deleted`` DCNL Dictionary of files/directories found only in the start state. DCNL ``created`` DCNL Dictionary of files/directories found only in the end state. DCNL ``updated`` DCNL Dictionary of files whose size has changed (FIXME not entirely DCNL reliable, but comparing contents is not possible because DCNL FoundFile.bytes is lazy, and comparing mtime doesn\'t help if DCNL we want to know if a file has been returned to its earlier DCNL state). DCNL Ignores mtime and other file attributes; only presence/absence and DCNL size are considered.'
def add_check(module, check): DCNL 'registers a check with the given agent. currently there is no way DCNL retrieve the full metadata of an existing check  through the consul api. DCNL Without this we can\'t compare to the supplied check and so we must assume DCNL a change.'
def get_precreated_datasets(trans, params, data_obj, controller='root'): DCNL 'Get any precreated datasets (when using asynchronous uploads).'
def HTTPInfoFromException(value): DCNL 'Returns a tuple containing the HTTP status code and error message, based on the passed DCNL exception info.'
def usages_add_import_modules(evaluator, definitions): DCNL 'Adds the modules of the imports'
def write_with_harness(codefile, sourcefile, start_linenum, linebuffer): DCNL 'write output with additional lines to make code likely compilable'
def parse(s, name=None): DCNL 'Parses a string into a kind of AST DCNL >>> parse(\'{{x}}\') DCNL [(\'expr\', (1, 3), \'x\')] DCNL >>> parse(\'foo\') DCNL [\'foo\'] DCNL >>> parse(\'{{if x}}test{{endif}}\') DCNL [(\'cond\', (1, 3), (\'if\', (1, 3), \'x\', [\'test\']))] DCNL >>> parse(\'series->{{for x in y}}x={{x}}{{endfor}}\') DCNL [\'series->\', (\'for\', (1, 11), (\'x\',), \'y\', [\'x=\', (\'expr\', (1, 27), \'x\')])] DCNL >>> parse(\'{{for x, y in z:}}{{continue}}{{endfor}}\') DCNL [(\'for\', (1, 3), (\'x\', \'y\'), \'z\', [(\'continue\', (1, 21))])] DCNL >>> parse(\'{{py:x=1}}\') DCNL [(\'py\', (1, 3), \'x=1\')] DCNL >>> parse(\'{{if x}}a{{elif y}}b{{else}}c{{endif}}\') DCNL [(\'cond\', (1, 3), (\'if\', (1, 3), \'x\', [\'a\']), (\'elif\', (1, 12), \'y\', [\'b\']), (\'else\', (1, 23), None, [\'c\']))] DCNL Some exceptions:: DCNL >>> parse(\'{{continue}}\') DCNL Traceback (most recent call last): DCNL TemplateError: continue outside of for loop at line 1 column 3 DCNL >>> parse(\'{{if x}}foo\') DCNL Traceback (most recent call last): DCNL TemplateError: No {{endif}} at line 1 column 3 DCNL >>> parse(\'{{else}}\') DCNL Traceback (most recent call last): DCNL TemplateError: else outside of an if block at line 1 column 3 DCNL >>> parse(\'{{if x}}{{for x in y}}{{endif}}{{endfor}}\') DCNL Traceback (most recent call last): DCNL TemplateError: Unexpected endif at line 1 column 25 DCNL >>> parse(\'{{if}}{{endif}}\') DCNL Traceback (most recent call last): DCNL TemplateError: if with no expression at line 1 column 3 DCNL >>> parse(\'{{for x y}}{{endfor}}\') DCNL Traceback (most recent call last): DCNL TemplateError: Bad for (no "in") in \'x y\' at line 1 column 3 DCNL >>> parse(\'{{py:x=1\ny=2}}\') DCNL Traceback (most recent call last): DCNL TemplateError: Multi-line py blocks must start with a newline at line 1 column 3'
def GetLabel(plist): DCNL 'Plists have a label.'
def make_scorer(score_func, greater_is_better=True, needs_proba=False, needs_threshold=False, **kwargs): DCNL 'Make a scorer from a performance metric or loss function. DCNL This factory function wraps scoring functions for use in GridSearchCV DCNL and cross_val_score. It takes a score function, such as ``accuracy_score``, DCNL ``mean_squared_error``, ``adjusted_rand_index`` or ``average_precision`` DCNL and returns a callable that scores an estimator\'s output. DCNL Read more in the :ref:`User Guide <scoring>`. DCNL Parameters DCNL score_func : callable, DCNL Score function (or loss function) with signature DCNL ``score_func(y, y_pred, **kwargs)``. DCNL greater_is_better : boolean, default=True DCNL Whether score_func is a score function (default), meaning high is good, DCNL or a loss function, meaning low is good. In the latter case, the DCNL scorer object will sign-flip the outcome of the score_func. DCNL needs_proba : boolean, default=False DCNL Whether score_func requires predict_proba to get probability estimates DCNL out of a classifier. DCNL needs_threshold : boolean, default=False DCNL Whether score_func takes a continuous decision certainty. DCNL This only works for binary classification using estimators that DCNL have either a decision_function or predict_proba method. DCNL For example ``average_precision`` or the area under the roc curve DCNL can not be computed using discrete predictions alone. DCNL **kwargs : additional arguments DCNL Additional parameters to be passed to score_func. DCNL Returns DCNL scorer : callable DCNL Callable object that returns a scalar score; greater is better. DCNL Examples DCNL >>> from sklearn.metrics import fbeta_score, make_scorer DCNL >>> ftwo_scorer = make_scorer(fbeta_score, beta=2) DCNL >>> ftwo_scorer DCNL make_scorer(fbeta_score, beta=2) DCNL >>> from sklearn.model_selection import GridSearchCV DCNL >>> from sklearn.svm import LinearSVC DCNL >>> grid = GridSearchCV(LinearSVC(), param_grid={\'C\': [1, 10]}, DCNL ...                     scoring=ftwo_scorer)'
def _get_borrowing_getitem(context, seqty): DCNL 'Return a getitem() implementation that doesn\'t incref its result.'
def _make_entity_from_pb(annotations): DCNL 'Create an entity from a protobuf response. DCNL :type annotations: DCNL :class:`~google.cloud.grpc.vision.v1.image_annotator_pb2.EntityAnnotation` DCNL :param annotations: protobuf instance of ``EntityAnnotation``. DCNL :rtype: list DCNL :returns: List of ``EntityAnnotation``.'
def route_view(request): DCNL ''
def splitByCommas(str): DCNL 'Split a string by unenclosed commas: that is, commas which are not inside of quotes or brackets. DCNL splitByCommas(\'foo, bar(baz, quux), fwip = "hey, hi"\') DCNL ==> [\'foo\', \'bar(baz, quux)\', \'fwip = "hey, hi"\']'
def read_style_directory(style_dir): DCNL 'Return dictionary of styles defined in `style_dir`.'
def getNumberOfBezierPoints(begin, end, xmlElement): DCNL 'Get the numberOfBezierPoints.'
def render_home(framework_name): DCNL 'Renders the homepage'
def educateDashesOldSchoolInverted(str): DCNL 'Parameter:  String. DCNL Returns:    The string, with each instance of "--" translated to DCNL an em-dash HTML entity, and each "---" translated to DCNL an en-dash HTML entity. Two reasons why: First, unlike the DCNL en- and em-dash syntax supported by DCNL EducateDashesOldSchool(), it\'s compatible with existing DCNL entries written before SmartyPants 1.1, back when "--" was DCNL only used for em-dashes.  Second, em-dashes are more DCNL common than en-dashes, and so it sort of makes sense that DCNL the shortcut should be shorter to type. (Thanks to Aaron DCNL Swartz for the idea.)'
def digest_secure_bootloader(args): DCNL 'Calculate the digest of a bootloader image, in the same way the hardware DCNL secure boot engine would do so. Can be used with a pre-loaded key to update a DCNL secure bootloader.'
def get_optional_parameters(dictionary): DCNL 'Extract all optional LTI parameters from a dictionary. This method does not DCNL fail if any parameters are missing. DCNL :param dictionary: A dictionary containing zero or more optional parameters. DCNL :return: A new dictionary containing all optional parameters from the DCNL original dictionary, or an empty dictionary if no optional parameters DCNL were present.'
def main(): DCNL 'Generate SwitchPort objects for database'
def title_from_columns(cols): DCNL 'Creates standard string representation of columns. DCNL If cols is None, then None is returned.'
def retention_action(client, stream_name, retention_period=24, action='increase', check_mode=False): DCNL 'Increase or Decreaste the retention of messages in the Kinesis stream. DCNL Args: DCNL client (botocore.client.EC2): Boto3 client. DCNL stream_name (str): The DCNL Kwargs: DCNL retention_period (int): This is how long messages will be kept before DCNL they are discarded. This can not be less than 24 hours. DCNL action (str): The action to perform. DCNL valid actions == create and delete DCNL default=create DCNL check_mode (bool): This will pass DryRun as one of the parameters to the aws api. DCNL default=False DCNL Basic Usage: DCNL >>> client = boto3.client(\'kinesis\') DCNL >>> stream_name = \'test-stream\' DCNL >>> retention_period = 48 DCNL >>> stream_action(client, stream_name, retention_period, action=\'create\') DCNL Returns: DCNL Tuple (bool, str)'
def test_javascript_url(): DCNL 'javascript: urls should never be linkified.'
def sign_string_v2(string_to_sign): DCNL 'Sign a string with the secret key, returning base64 encoded results. DCNL By default the configured secret key is used, but may be overridden as DCNL an argument. DCNL Useful for REST authentication. See http://s3.amazonaws.com/doc/s3-developer-guide/RESTAuthentication.html'
def getSquareLoopWiddershins(beginComplex, endComplex): DCNL 'Get a square loop from the beginning to the end and back.'
@treeio_login_required DCNL def ical_all_event(request, response_format='ical'): DCNL 'Export upcoming events'
def test_read_normal_names_include(): DCNL 'Nice, typical fixed format table with col names provided'
def get_database_string(fname): DCNL 'Read an IRAF database file DCNL Parameters DCNL fname : str DCNL name of an IRAF database file DCNL Returns DCNL the database file as a string'
def ipython_display(clip, filetype=None, maxduration=60, t=None, fps=None, rd_kwargs=None, center=True, **html_kwargs): DCNL 'clip DCNL Either the name of a file, or a clip to preview. The clip will DCNL actually be written to a file and embedded as if a filename was DCNL provided. DCNL filetype: DCNL One of \'video\',\'image\',\'audio\'. If None is given, it is determined DCNL based on the extension of ``filename``, but this can bug. DCNL maxduration DCNL An error will be raised if the clip\'s duration is more than the indicated DCNL value (in seconds), to avoid spoiling the  browser\'s cache and the RAM. DCNL t DCNL If not None, only the frame at time t will be displayed in the notebook, DCNL instead of a video of the clip DCNL fps DCNL Enables to specify an fps, as required for clips whose fps is unknown. DCNL **kwargs: DCNL Allow you to give some options, like width=260, etc. When editing DCNL looping gifs, a good choice is loop=1, autoplay=1. DCNL Remarks: If your browser doesn\'t support HTML5, this should warn you. DCNL If nothing is displayed, maybe your file or filename is wrong. DCNL Important: The media will be physically embedded in the notebook. DCNL Examples DCNL >>> import moviepy.editor as mpy DCNL >>> # later ... DCNL >>> clip.write_videofile("test.mp4") DCNL >>> mpy.ipython_display("test.mp4", width=360) DCNL >>> clip.audio.write_audiofile(\'test.ogg\') # Sound ! DCNL >>> mpy.ipython_display(\'test.ogg\') DCNL >>> clip.write_gif("test.gif") DCNL >>> mpy.ipython_display(\'test.gif\') DCNL >>> clip.save_frame("first_frame.jpeg") DCNL >>> mpy.ipython_display("first_frame.jpeg")'
def distance_transform_bf(input, metric='euclidean', sampling=None, return_distances=True, return_indices=False, distances=None, indices=None): DCNL 'Distance transform function by a brute force algorithm. DCNL This function calculates the distance transform of the `input`, by DCNL replacing each background element (zero values), with its DCNL shortest distance to the foreground (any element non-zero). DCNL In addition to the distance transform, the feature transform can DCNL be calculated. In this case the index of the closest background DCNL element is returned along the first axis of the result. DCNL Parameters DCNL input : array_like DCNL Input DCNL metric : str, optional DCNL Three types of distance metric are supported: \'euclidean\', \'taxicab\' DCNL and \'chessboard\'. DCNL sampling : {int, sequence of ints}, optional DCNL This parameter is only used in the case of the euclidean `metric` DCNL distance transform. DCNL The sampling along each axis can be given by the `sampling` parameter DCNL which should be a sequence of length equal to the input rank, or a DCNL single number in which the `sampling` is assumed to be equal along all DCNL axes. DCNL return_distances : bool, optional DCNL The `return_distances` flag can be used to indicate if the distance DCNL transform is returned. DCNL The default is True. DCNL return_indices : bool, optional DCNL The `return_indices` flags can be used to indicate if the feature DCNL transform is returned. DCNL The default is False. DCNL distances : float64 ndarray, optional DCNL Optional output array to hold distances (if `return_distances` is DCNL True). DCNL indices : int64 ndarray, optional DCNL Optional output array to hold indices (if `return_indices` is True). DCNL Returns DCNL distances : ndarray DCNL Distance array if `return_distances` is True. DCNL indices : ndarray DCNL Indices array if `return_indices` is True. DCNL Notes DCNL This function employs a slow brute force algorithm, see also the DCNL function distance_transform_cdt for more efficient taxicab and DCNL chessboard algorithms.'
def upload_dev_pdf(user='pandas'): DCNL 'push a copy to the pydata dev directory'
def load_csr(*names): DCNL 'Load certificate request.'
def auto_openstack_logging(interface, original): DCNL 'Create a class decorator which will add OpenStack-specific exception DCNL logging versions versions of all of the methods on ``interface``. DCNL Specifically, some Nova and Cinder client exceptions will have all of their DCNL details logged any time they are raised. DCNL :param zope.interface.InterfaceClass interface: The interface from which to DCNL take methods. DCNL :param str original: The name of an attribute on instances of the decorated DCNL class.  The attribute should refer to a provider of ``interface``. DCNL That object will have all of its methods called with additional DCNL exception logging to make more details of the underlying OpenStack API DCNL calls available. DCNL :return: The class decorator.'
def handle_translate(translation, request, user_locked, this_unit_url, next_unit_url): DCNL 'Saves translation or suggestion to database and backend.'
def get_group_type_by_name(context, name): DCNL 'Retrieves single group type by name.'
def get_github_releases(project): DCNL 'Query the Github API for a list of version tags and return them in DCNL sorted order. DCNL See https://developer.github.com/v3/repos/#list-tags'
def get_client(host, port=None, timeout=None, use_ssl=False, username=None, password=None, tenant=None, auth_url=None, auth_strategy=None, auth_token=None, region=None, is_silent_upload=False, insecure=False): DCNL 'Returns a new client Glance client object based on common kwargs. DCNL If an option isn\'t specified falls back to common environment variable DCNL defaults.'
def load_item_types(): DCNL 'Returns a dictionary containing the item_types of all the MetaSources'
def join_options(options): DCNL 'Given a list of option strings this joins them in the most appropriate DCNL way and returns them in the form ``(formatted_string, DCNL any_prefix_is_slash)`` where the second item in the tuple is a flag that DCNL indicates if any of the option prefixes was a slash.'
def fake_view(request): DCNL 'Fake view that returns the request META as a JSON-encoded string.'
def group_membership(): DCNL 'RESTful CRUD controller for options.s3json lookups'
def user_field(user, field, *args): DCNL 'Gets or sets (optional) user model fields. No-op if fields do not exist.'
def set_marker(folder): DCNL 'Set marker file and return name'
def bind_floating_ip(floating_ip, device): DCNL 'Bind ip to public interface.'
def test_hermite_cardinal(Chart, datas): DCNL 'Test hermite cardinal interpolation'
@frappe.whitelist() DCNL def rename_doc(doctype, old, new, force=False, merge=False, ignore_permissions=False): DCNL 'Renames a doc(dt, old) to doc(dt, new) and DCNL updates all linked fields of type "Link"'
def commit_transaction(hostname, username, password, label): DCNL 'A function to connect to a bigip device and commit an existing transaction. DCNL hostname DCNL The host/address of the bigip device DCNL username DCNL The iControl REST username DCNL password DCNL The iControl REST password DCNL label DCNL the label of this transaction stored within the grain: DCNL ``bigip_f5_trans:<label>`` DCNL CLI Example:: DCNL salt \'*\' bigip.commit_transaction bigip admin admin my_transaction'
def invoke_cmd(stdout, stderr, environ, prefix, cmd, cmd_args, error_msg, error_status): DCNL 'Helper function to call command and subcommands of the hadoop binary. DCNL Basically, combines prefix and cmd to make a function name, and calls DCNL it with cmd_args. If no such function exists, prints error_msg DCNL to stderr, and exits with status error_status.'
@register_stabilize DCNL @register_specialize DCNL @register_canonicalize DCNL @gof.local_optimizer([T.Elemwise]) DCNL def local_expm1(node): DCNL 'This optimization detects exp(a)-1 and converts this to expm1(a).'
@register.tag DCNL def firstof(parser, token): DCNL 'This is the future version of `firstof` with auto-escaping. DCNL This is equivalent to:: DCNL {% if var1 %} DCNL {{ var1 }} DCNL {% elif var2 %} DCNL {{ var2 }} DCNL {% elif var3 %} DCNL {{ var3 }} DCNL {% endif %} DCNL If you want to disable auto-escaping of variables you can use:: DCNL {% autoescape off %} DCNL {% firstof var1 var2 var3 "<strong>fallback value</strong>" %} DCNL {% autoescape %} DCNL Or if only some variables should be escaped, you can use:: DCNL {% firstof var1 var2|safe var3 "<strong>fallback value</strong>"|safe %}'
def freecpu(): DCNL 'Return an int representing the number of unallocated cpus on this DCNL hypervisor DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' virt.freecpu'
def unexpected_fail_on_npm_install(arg): DCNL 'For our tests, we need the call for diff-quality running pep8 reports to fail, since that is what DCNL is going to fail when we pass in a percentage ("p") requirement.'
def _list_interface_private_addrs(eni_desc): DCNL 'Returns a list of all of the private IP addresses attached to a DCNL network interface. The \'primary\' address will be listed first.'
def ls_(path='/', profile=None): DCNL '.. versionadded:: 2014.7.0 DCNL Return all keys and dirs inside a specific path. Returns an empty dict on DCNL failure. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion etcd.ls /path/to/dir/ DCNL salt myminion etcd.ls /path/to/dir/ profile=my_etcd_config'
def _detect_gce_environment(): DCNL 'Determine if the current environment is Compute Engine. DCNL Returns: DCNL Boolean indicating whether or not the current environment is Google DCNL Compute Engine.'
@testing.requires_testing_data DCNL def test_dipole_fitting_fixed(): DCNL 'Test dipole fitting with a fixed position.'
def _rec_list_terms(g, v, monom): DCNL 'Recursive helper for :func:`dmp_list_terms`.'
def update_quota(tenant_id, subnet=None, router=None, network=None, floatingip=None, port=None, security_group=None, security_group_rule=None, profile=None): DCNL 'Update a tenant\'s quota DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' neutron.update_quota tenant-id subnet=40 router=50 DCNL network=10 floatingip=30 port=30 DCNL :param tenant_id: ID of tenant DCNL :param subnet: Value of subnet quota (Optional) DCNL :param router: Value of router quota (Optional) DCNL :param network: Value of network quota (Optional) DCNL :param floatingip: Value of floatingip quota (Optional) DCNL :param port: Value of port quota (Optional) DCNL :param security_group: Value of security group (Optional) DCNL :param security_group_rule: Value of security group rule (Optional) DCNL :param profile: Profile to build on (Optional) DCNL :return: Value of updated quota'
@staff_member_required DCNL def static_proxy(request): DCNL 'Serves TinyMCE plugins inside the inline popups and the uploadify DCNL SWF, as these are normally static files, and will break with DCNL cross-domain JavaScript errors if ``STATIC_URL`` is an external DCNL host. URL for the file is passed in via querystring in the inline DCNL popup plugin template, and we then attempt to pull out the relative DCNL path to the file, so that we can serve it locally via Django.'
def test_cache_remove_data(config_stub, tmpdir): DCNL 'Test if a previously inserted entry can be removed from the cache.'
def _executeExternalCmdAndReapStdout(args): DCNL 'args:     Args list as defined for the args parameter in subprocess.Popen() DCNL Returns:  result dicionary: DCNL \'exitStatus\':<exit-status-of-external-command>, DCNL \'stdoutData\':"string", DCNL \'stderrData\':"string"'
def chars_to_ranges(s): DCNL 'Return a list of character codes consisting of pairs DCNL [code1a, code1b, code2a, code2b,...] which cover all DCNL the characters in |s|.'
def sfv_check(sfv_path): DCNL 'Verify files using SFV file, DCNL input: full path of sfv, file are assumed to be relative to sfv DCNL returns: List of failing files or [] when all is OK'
def wait_for_image_status(client, image_id, status): DCNL 'Waits for an image to reach a given status. DCNL The client should have a show_image(image_id) method to get the image. DCNL The client should also have build_interval and build_timeout attributes.'
def _get_profile_image_filename(name, size, file_extension=PROFILE_IMAGE_FILE_EXTENSION): DCNL 'Returns the full filename for a profile image, given the name and size.'
def get_loginclass(name): DCNL 'Get the login class of the user DCNL .. note:: DCNL This function only applies to OpenBSD systems. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' user.get_loginclass foo'
def find_path_file(specific_file, search_directory): DCNL 'result_path_filename'
def home_link(): DCNL 'Returns a link to the API entry point/home page. DCNL .. versionchanged:: 0.5 DCNL Link is relative to API root. DCNL .. versionchanged:: 0.0.3 DCNL Now returning a JSON link.'
def assert_array_less(x, y, err_msg='', verbose=True): DCNL 'Raises an AssertionError if array_like objects are not ordered by less than. DCNL Args: DCNL x(numpy.ndarray or cupy.ndarray): The smaller object to check. DCNL y(numpy.ndarray or cupy.ndarray): The larger object to compare. DCNL err_msg(str): The error message to be printed in case of failure. DCNL verbose(bool): If ``True``, the conflicting values DCNL are appended to the error message. DCNL .. seealso:: :func:`numpy.testing.assert_array_less`'
def load_token(session_file): DCNL 'Load authentication tokens from persistent storage, if exists.'
def reload_localzone(): DCNL 'Reload the cached localzone. You need to call this if the timezone has changed.'
@testing.requires_testing_data DCNL def test_make_field_map_eeg(): DCNL 'Test interpolation of EEG field onto head'
def main(): DCNL 'The main program.'
def formstyle_divs(form, fields): DCNL 'divs only'
def main(): DCNL 'Obtain the uptime from the show version output DCNL Prints to STDOUT \'12 weeks, 5 days, 1 hour, 4 minutes\''
def is_list(value, min=None, max=None): DCNL 'Check that the value is a list of values. DCNL You can optionally specify the minimum and maximum number of members. DCNL It does no check on list members. DCNL >>> vtor.check(\'list\', ()) DCNL >>> vtor.check(\'list\', []) DCNL >>> vtor.check(\'list\', (1, 2)) DCNL [1, 2] DCNL >>> vtor.check(\'list\', [1, 2]) DCNL [1, 2] DCNL >>> vtor.check(\'list(3)\', (1, 2)) DCNL Traceback (most recent call last): DCNL VdtValueTooShortError: the value "(1, 2)" is too short. DCNL >>> vtor.check(\'list(max=5)\', (1, 2, 3, 4, 5, 6)) DCNL Traceback (most recent call last): DCNL VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long. DCNL >>> vtor.check(\'list(min=3, max=5)\', (1, 2, 3, 4)) DCNL [1, 2, 3, 4] DCNL >>> vtor.check(\'list\', 0) DCNL Traceback (most recent call last): DCNL VdtTypeError: the value "0" is of the wrong type. DCNL >>> vtor.check(\'list\', \'12\') DCNL Traceback (most recent call last): DCNL VdtTypeError: the value "12" is of the wrong type.'
@pytest.mark.xfail DCNL def test_precision_neg(): DCNL 'Check precision when jd1 is negative.  Currently fails because ERFA routines use a DCNL test like jd1 > jd2 to decide which component to update.  Should be DCNL abs(jd1) > abs(jd2).'
def __virtual__(): DCNL 'Only load if the splunk_search module is available in __salt__'
def viewdefaults(wrapped): DCNL 'Decorator for add_view-like methods which takes into account DCNL __view_defaults__ attached to view it is passed.  Not a documented API but DCNL used by some external systems.'
def insert(tup, loc, val): DCNL '>>> insert((\'a\', \'b\', \'c\'), 0, \'x\') DCNL (\'x\', \'b\', \'c\')'
def parse_date(ims): DCNL 'Parse rfc1123, rfc850 and asctime timestamps and return UTC epoch.'
def get_pending_file_rename(): DCNL 'Determine whether there are pending file rename operations that require a reboot. DCNL :return: A boolean representing whether there are pending file rename operations. DCNL :rtype: bool DCNL .. versionadded:: 2016.11.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' system.get_pending_file_rename'
def fix_html(container, raw): DCNL 'Fix any parsing errors in the HTML represented as a string in raw. Fixing is done using the HTML5 parsing algorithm.'
def bivariate_normal(X, Y, sigmax=1.0, sigmay=1.0, mux=0.0, muy=0.0, sigmaxy=0.0): DCNL 'Bivariate Gaussian distribution for equal shape *X*, *Y*. DCNL See `bivariate normal DCNL <http://mathworld.wolfram.com/BivariateNormalDistribution.html>`_ DCNL at mathworld.'
@require_role('admin') DCNL def idc_edit(request): DCNL 'IDC edit view'
def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0): DCNL 'Translate a shell-like wildcard pattern to a compiled regular DCNL expression. DCNL Return the compiled regex.  If \'is_regex\' true, DCNL then \'pattern\' is directly compiled to a regex (if it\'s a string) DCNL or just returned as-is (assumes it\'s a regex object).'
def sample_ids_from_metadata_description(mapping_f, valid_states_str): DCNL 'Given a description of metadata, return the corresponding sample ids'
def _encode(s): DCNL 'Encode the string for inclusion in a URL (common to both DCNL LyricsWiki and Lyrics.com).'
def makeSplitter(lstrip=None, sep='|', comments=True, origNotesSep=' DCSP (', newNotesSep='::(', strip=None): DCNL 'Return a splitter function suitable for a given set of data.'
@requires_sklearn DCNL def test_XdawnTransformer(): DCNL 'Test _XdawnTransformer.'
@lower_getattr_generic(types.BaseNamedTuple) DCNL def namedtuple_getattr(context, builder, typ, value, attr): DCNL 'Fetch a namedtuple\'s field.'
def compute_logarithmic_scale(min_, max_, min_scale, max_scale): DCNL 'Compute an optimal scale for logarithmic'
def getGeometryOutputByArguments(arguments, elementNode): DCNL 'Get vector3 vertexes from attribute dictionary by arguments.'
def graph_process(mg, lenmavlist): DCNL 'process for a graph'
def is_py2exe_or_cx_Freeze(): DCNL 'Return True if this is a py2exe/cx_Freeze distribution of Spyder'
def get_profile_image_names(username): DCNL 'Returns a dict containing the filenames for a complete set of profile DCNL images, keyed by pixel size.'
def _wait_until_complete(operation, max_attempts=5): DCNL 'Wait until an operation has completed. DCNL :type operation: :class:`google.cloud.operation.Operation` DCNL :param operation: Operation that has not completed. DCNL :type max_attempts: int DCNL :param max_attempts: (Optional) The maximum number of times to check if DCNL the operation has completed. Defaults to 5. DCNL :rtype: bool DCNL :returns: Boolean indicating if the operation is complete.'
def _exit(code=0): DCNL 'Internal function. Calling it will raise the exception SystemExit.'
def is_list(value): DCNL 'Check if a variable is a list.'
def randomRange(start=0, stop=1000, seed=None): DCNL 'Returns random integer value in given range DCNL >>> random.seed(0) DCNL >>> randomRange(1, 500) DCNL 423'
def hash_file(filename, size=None, method='md5'): DCNL 'Calculate the hash of filename. DCNL If size is not None, limit to first size bytes. DCNL Throw exception if something is wrong with filename. DCNL Can be also implemented with bash one-liner (assuming size%1024==0): DCNL dd if=filename bs=1024 count=size/1024 | sha1sum - DCNL :param filename: Path of the file that will have its hash calculated. DCNL :param method: Method used to calculate the hash. Supported methods: DCNL * md5 DCNL * sha1 DCNL :return: Hash of the file, if something goes wrong, return None.'
def correlate_output_formatter(bt, test_stats, pvals, fdr_pvals, bon_pvals, md_key): DCNL 'Produce lines for a tab delimited text file for correlations.py. DCNL Paramaters DCNL bt : biom table object DCNL test_stats : array-like DCNL Floats representing correlation coefficients or paired t test DCNL statistics. DCNL pvals : array-like DCNL Floats representing pvalues for given correlation coefficients. DCNL fdr_pvals : array-like DCNL Floats representing FDR corrected pvals. DCNL bon_pvals : array-like DCNL Floats representing Bonferroni corrected pvals. DCNL md_key : str or None DCNL Key for extracting feature metadata from biom table. DCNL Returns DCNL list of strs'
def format_unixtime_ms(unixtime): DCNL 'Format a unix timestamp in ms to a human readable string'
def md5SessionKey(params, password): DCNL 'If the "algorithm" directive\'s value is "MD5-sess", then A1 DCNL [the session key] is calculated only once - on the first request by the DCNL client following receipt of a WWW-Authenticate challenge from the server. DCNL This creates a \'session key\' for the authentication of subsequent DCNL requests and responses which is different for each "authentication DCNL session", thus limiting the amount of material hashed with any one DCNL key. DCNL Because the server need only use the hash of the user DCNL credentials in order to create the A1 value, this construction could DCNL be used in conjunction with a third party authentication service so DCNL that the web server would not need the actual password value.  The DCNL specification of such a protocol is beyond the scope of this DCNL specification.'
def get_items(xml): DCNL 'Opens a WordPress xml file and returns a list of items'
def _AddSetListenerMethod(cls): DCNL 'Helper for _AddMessageMethods().'
def eglQueryString(display, name): DCNL 'Query string from display'
@register_opt() DCNL @local_optimizer([SparseBlockOuter, GpuFromHost]) DCNL def gpu_sparse_block_outer_opt(node): DCNL 'SparseBlockOuter(HostFromGpu(input)) -> DCNL HostFromGpu(GpuSparseBlockOuter(input)) DCNL or DCNL GpuFromHost(SparseBlockOuter) -> GpuSparseBlockOuter'
def import_library(taglib_module): DCNL 'Load a template tag library module. DCNL Verifies that the library contains a \'register\' attribute, and DCNL returns that attribute as the representation of the library'
def do_autopaginate(parser, token): DCNL 'Splits the arguments to the autopaginate tag and formats them correctly.'
@hook.command DCNL def escape(text): DCNL '<string> -- Unicode escapes <string>.'
def _validator(code_or_name, validator_type): DCNL 'Internal shared implementation to handle both error and warning DCNL validation checks. DCNL Args: DCNL code code_or_name (int or str) : a defined error code or custom message DCNL validator_type (str) : either "error" or "warning" DCNL Returns: DCNL validation decorator'
def lerp(a, b, t): DCNL 'Returns the linear interpolation between a and b at time t between 0.0-1.0. DCNL For example: lerp(100, 200, 0.5) => 150.'
def filter_factory(global_conf, **local_conf): DCNL 'Returns a WSGI filter app for use with paste.deploy.'
def _get_globals(): DCNL 'Return current Python interpreter globals namespace'
def mutShrink(individual): DCNL 'This operator shrinks the *individual* by chosing randomly a branch and DCNL replacing it with one of the branch\'s arguments (also randomly chosen). DCNL :param individual: The tree to be shrinked. DCNL :returns: A tuple of one tree.'
def logout_then_login(request, login_url=None, extra_context=_sentinel): DCNL 'Logs out the user if they are logged in. Then redirects to the log-in page.'
def create_relationship(model, instance, relation): DCNL 'Creates a relationship from the given relation name. DCNL Returns a dictionary representing a relationship as described in DCNL the `Relationships`_ section of the JSON API specification. DCNL `model` is the model class of the primary resource for which a DCNL relationship object is being created. DCNL `instance` is the instance of the model for which we are considering DCNL a related value. DCNL `relation` is the name of the relation of `instance` given as a DCNL string. DCNL This function may raise :exc:`ValueError` if an API has not been DCNL created for the primary model, `model`, or the model of the DCNL relation. DCNL .. _Relationships: DCNL http://jsonapi.org/format/#document-resource-object-relationships'
def _validate_post_params(params): DCNL 'Validate request POST parameters to the generate and regenerate certificates end-point. DCNL Arguments: DCNL params (QueryDict): Request parameters. DCNL Returns: tuple of (dict, HttpResponse)'
def to_numpy_matrix(G, nodelist=None, dtype=None, order=None, multigraph_weight=sum, weight='weight', nonedge=0.0): DCNL 'Return the graph adjacency matrix as a NumPy matrix. DCNL Parameters DCNL G : graph DCNL The NetworkX graph used to construct the NumPy matrix. DCNL nodelist : list, optional DCNL The rows and columns are ordered according to the nodes in `nodelist`. DCNL If `nodelist` is None, then the ordering is produced by G.nodes(). DCNL dtype : NumPy data type, optional DCNL A valid single NumPy data type used to initialize the array. DCNL This must be a simple type such as int or numpy.float64 and DCNL not a compound data type (see to_numpy_recarray) DCNL If None, then the NumPy default is used. DCNL order : {\'C\', \'F\'}, optional DCNL Whether to store multidimensional data in C- or Fortran-contiguous DCNL (row- or column-wise) order in memory. If None, then the NumPy default DCNL is used. DCNL multigraph_weight : {sum, min, max}, optional DCNL An operator that determines how weights in multigraphs are handled. DCNL The default is to sum the weights of the multiple edges. DCNL weight : string or None optional (default = \'weight\') DCNL The edge attribute that holds the numerical value used for DCNL the edge weight. If an edge does not have that attribute, then the DCNL value 1 is used instead. DCNL nonedge : float (default = 0.0) DCNL The matrix values corresponding to nonedges are typically set to zero. DCNL However, this could be undesirable if there are matrix values DCNL corresponding to actual edges that also have the value zero. If so, DCNL one might prefer nonedges to have some other value, such as nan. DCNL Returns DCNL M : NumPy matrix DCNL Graph adjacency matrix DCNL See Also DCNL to_numpy_recarray, from_numpy_matrix DCNL Notes DCNL The matrix entries are assigned to the weight edge attribute. When DCNL an edge does not have a weight attribute, the value of the entry is set to DCNL the number 1.  For multiple (parallel) edges, the values of the entries DCNL are determined by the `multigraph_weight` parameter.  The default is to DCNL sum the weight attributes for each of the parallel edges. DCNL When `nodelist` does not contain every node in `G`, the matrix is built DCNL from the subgraph of `G` that is induced by the nodes in `nodelist`. DCNL The convention used for self-loop edges in graphs is to assign the DCNL diagonal matrix entry value to the weight attribute of the edge DCNL (or the number 1 if the edge has no weight attribute).  If the DCNL alternate convention of doubling the edge weight is desired the DCNL resulting Numpy matrix can be modified as follows: DCNL >>> import numpy as np DCNL >>> G = nx.Graph([(1, 1)]) DCNL >>> A = nx.to_numpy_matrix(G) DCNL >>> A DCNL matrix([[ 1.]]) DCNL >>> A.A[np.diag_indices_from(A)] *= 2 DCNL >>> A DCNL matrix([[ 2.]]) DCNL Examples DCNL >>> G = nx.MultiDiGraph() DCNL >>> G.add_edge(0,1,weight=2) DCNL 0 DCNL >>> G.add_edge(1,0) DCNL 0 DCNL >>> G.add_edge(2,2,weight=3) DCNL 0 DCNL >>> G.add_edge(2,2) DCNL 1 DCNL >>> nx.to_numpy_matrix(G, nodelist=[0,1,2]) DCNL matrix([[ 0.,  2.,  0.], DCNL [ 1.,  0.,  0.], DCNL [ 0.,  0.,  4.]])'
def zeros_like(a, dtype=None): DCNL 'Returns an array of zeros with same shape and dtype as a given array. DCNL This function currently does not support ``order`` and ``subok`` options. DCNL Args: DCNL a (cupy.ndarray): Base array. DCNL dtype: Data type specifier. The dtype of ``a`` is used by default. DCNL Returns: DCNL cupy.ndarray: An array filled with ones. DCNL .. seealso:: :func:`numpy.zeros_like`'
def clean_db(): DCNL 'Delete kalite data associated with Zone, Facility and Device DCNL Does not remove the django admin accounts etc.'
def text_(s, encoding='latin-1', errors='strict'): DCNL 'If ``s`` is an instance of ``binary_type``, return DCNL ``s.decode(encoding, errors)``, otherwise return ``s``'
def delete_object(request, model, post_delete_redirect, object_id=None, slug=None, slug_field='slug', template_name=None, template_loader=loader, extra_context=None, login_required=False, context_processors=None, template_object_name='object'): DCNL 'Generic object-delete function. DCNL The given template will be used to confirm deletetion if this view is DCNL fetched using GET; for safty, deletion will only be performed if this DCNL view is POSTed. DCNL Templates: ``<app_label>/<model_name>_confirm_delete.html`` DCNL Context: DCNL object DCNL the original object being deleted'
def subscription_check_iam_permissions(client, to_delete): DCNL 'Check subscription IAM permissions.'
def getPage(url, contextFactory=None, response_transform=None, *args, **kwargs): DCNL 'Adapted version of twisted.web.client.getPage'
def set_var_value(hass, entity_id, value): DCNL 'Change value of homematic system variable.'
def beacon(config): DCNL 'Watch for changes on network settings DCNL By default, the beacon will emit when there is a value change on one of the DCNL settings on watch. The config also support the onvalue parameter for each DCNL setting, which instruct the beacon to only emit if the setting changed to the DCNL value defined. DCNL Example Config DCNL .. code-block:: yaml DCNL beacons: DCNL network_settings: DCNL eth0: DCNL ipaddr: DCNL promiscuity: DCNL onvalue: 1 DCNL eth1: DCNL linkmode: DCNL The config above will check for value changes on eth0 ipaddr and eth1 linkmode. It will also DCNL emit if the promiscuity value changes to 1. DCNL Beacon items can use the * wildcard to make a definition apply to several interfaces. For DCNL example an eth* would apply to all ethernet interfaces. DCNL Setting the argument coalesce = True will combine all the beacon results on a single event. DCNL The example below shows how to trigger coalesced results: DCNL .. code-block:: yaml DCNL beacons: DCNL network_settings: DCNL coalesce: True DCNL eth0: DCNL ipaddr: DCNL promiscuity:'
def testIBP(): DCNL 'Plot matrices generated by an IBP, for a few different settings.'
def train_model(name, g_train, d_train, sampler, generator, samples_per_epoch, nb_epoch, z_dim=100, verbose=1, callbacks=[], validation_data=None, nb_val_samples=None, saver=None): DCNL 'Main training loop. DCNL modified from Keras fit_generator'
def rebuild_topictree(remove_unknown_exercises=False, remove_disabled_topics=True, whitewash_node_data=whitewash_node_data, retrieve_API_data=retrieve_API_data, channel_data={}, channel=None): DCNL 'Downloads topictree (and supporting) data and uses it to DCNL rebuild the KA Lite topictree cache (topics.json). DCNL Does this by collecting all relevant topic_tree and content data from data source. DCNL Recurses over the entire topic tree to remove extraneous data. DCNL Denorms content data to reduce the bulk of the topic tree. DCNL Adds position data to every node in the topic tree.'
def p_command_let(p): DCNL 'command : LET variable EQUALS expr'
def _get_spec(tree_base, spec, template, saltenv='base'): DCNL 'Get the spec file (tarball of the debian sub-dir to use) DCNL and place it in build area'
def gf_compose_mod(g, h, f, p, K): DCNL 'Compute polynomial composition ``g(h)`` in ``GF(p)[x]/(f)``. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.galoistools import gf_compose_mod DCNL >>> gf_compose_mod(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 2]), ZZ.map([4, 3]), 5, ZZ) DCNL [4]'
def queryset_iterator(queryset, chunksize=1000): DCNL 'The queryset iterator helps to keep the memory consumption down. DCNL And also making it easier to process for weaker computers.'
def tweet(): DCNL 'Tweet'
def patched(f): DCNL ''
def _remove_intercept_patsy(terms): DCNL 'Remove intercept from Patsy terms.'
def ValidateStringLength(name, value, max_len): DCNL 'Raises an exception if the supplied string is too long. DCNL Args: DCNL name: Name of the property this is for. DCNL value: String value. DCNL max_len: Maximum length the string may be. DCNL Raises: DCNL OverflowError if the value is larger than the maximum length.'
def compat_tee(iterable): DCNL 'Return two independent iterators from a single iterable. DCNL Based on http://www.python.org/doc/2.3.5/lib/itertools-example.html'
def get_protocol_from_tool_shed_url(tool_shed_url): DCNL 'Return the protocol from the received tool_shed_url if it exists.'
def makeListCompatible(fn): DCNL 'Return a new function allowing fn( \'a 1 b\' ) to be called as DCNL newfn( \'a\', 1, \'b\' )'
def register(request): DCNL 'Allow external auth to intercept and handle a registration request. DCNL Arguments: DCNL request (Request): A request for the registration page. DCNL Returns: DCNL Response or None'
def _reconstitute(config, full_path): DCNL 'Try to instantiate a RenewableCert, updating config with relevant items. DCNL This is specifically for use in renewal and enforces several checks DCNL and policies to ensure that we can try to proceed with the renewal DCNL request. The config argument is modified by including relevant options DCNL read from the renewal configuration file. DCNL :param configuration.NamespaceConfig config: configuration for the DCNL current lineage DCNL :param str full_path: Absolute path to the configuration file that DCNL defines this lineage DCNL :returns: the RenewableCert object or None if a fatal error occurred DCNL :rtype: `storage.RenewableCert` or NoneType'
def format_acl_v2(acl_dict): DCNL 'Returns a version-2 Swift ACL JSON string. DCNL HTTP headers for Version 2 ACLs have the following form: DCNL Header-Name: {"arbitrary":"json","encoded":"string"} DCNL JSON will be forced ASCII (containing six-char \uNNNN sequences rather DCNL than UTF-8; UTF-8 is valid JSON but clients vary in their support for DCNL UTF-8 headers), and without extraneous whitespace. DCNL Advantages over V1: forward compatibility (new keys don\'t cause parsing DCNL exceptions); Unicode support; no reserved words (you can have a user DCNL named .rlistings if you want). DCNL :param acl_dict: dict of arbitrary data to put in the ACL; see specific DCNL auth systems such as tempauth for supported values DCNL :returns: a JSON string which encodes the ACL'
def test_version(): DCNL 'Should have a version string'
def done_command(client, args): DCNL 'Marks a task as done.'
def package_relationship_update(context, data_dict): DCNL 'Update a relationship between two datasets (packages). DCNL The subject, object and type parameters are required to identify the DCNL relationship. Only the comment can be updated. DCNL You must be authorized to edit both the subject and the object datasets. DCNL :param subject: the name or id of the dataset that is the subject of the DCNL relationship DCNL :type subject: string DCNL :param object: the name or id of the dataset that is the object of the DCNL relationship DCNL :param type: the type of the relationship, one of ``\'depends_on\'``, DCNL ``\'dependency_of\'``, ``\'derives_from\'``, ``\'has_derivation\'``, DCNL ``\'links_to\'``, ``\'linked_from\'``, ``\'child_of\'`` or ``\'parent_of\'`` DCNL :type type: string DCNL :param comment: a comment about the relationship (optional) DCNL :type comment: string DCNL :returns: the updated relationship DCNL :rtype: dictionary'
def scp(reactor, username, host, remote_path, local_path, direction, port=22, identity_file=None): DCNL ':param reactor: A ``twisted.internet.reactor``. DCNL :param bytes username: The SSH username. DCNL :param bytes host: The SSH host. DCNL :param FilePath remote_path: The path to the remote file. DCNL :param FilePath local_path: The path to the local file. DCNL :param direction: One of ``DOWNLOAD`` or ``UPLOAD``. DCNL :param int port: The SSH TCP port. DCNL :param FilePath identity_file: The path to an SSH private key. DCNL :returns: A ``Deferred`` that fires when the process is ended.'
def stitch_rbms(batch_size, rbm_list, niter, inference_procedure=None, targets=False): DCNL 'Returns a DBM initialized with pre-trained RBMs, with weights and biases DCNL initialized according to R. Salakhutdinov\'s policy. DCNL This method assumes the RBMs were trained normally. It divides the first DCNL and last hidden layer\'s weights by two and initialized a hidden layer\'s DCNL biases as the mean of its biases and the biases of the visible layer of the DCNL RBM above it.'
def add_required_label_tag(original_function): DCNL 'Adds the \'required\' CSS class and an asterisks to required field labels.'
def make_script_tests(executable): DCNL 'Generate a test suite which applies to any Flocker-installed node script. DCNL :param bytes executable: The basename of the script to be tested. DCNL :return: A ``TestCase`` subclass which defines some tests applied to the DCNL given executable.'
def no_import_translation_in_tests(logical_line, filename): DCNL 'Check for \'from nova.i18n import _\' DCNL N337'
def _find_clickable_elem_with_wait(context, by, wait_time=MAX_WAIT_TIME): DCNL 'Tries to find an enabled element with an explicit timeout. DCNL "Private" function to hide Selenium details. DCNL context: a behave context DCNL by: A tuple selector used by Selenium DCNL wait_time: The max time to wait in seconds DCNL Returns the element if found or raises TimeoutException'
def get_issues_from_bulk(bulk_data, **additional_fields): DCNL 'Convert `bulk_data` into a list of issues. DCNL :param bulk_data: List of issues in bulk format. DCNL :param additional_fields: Additional fields when instantiating each issue. DCNL :return: List of `Issue` instances.'
def parse_kwarg(string_): DCNL 'Parses the string and looks for the following kwarg format: DCNL "{argument name}={argument value}" DCNL For example: "my_message=Hello world" DCNL Returns the kwarg name and value, or (None, None) if the regex was not DCNL matched.'
def short_group_names(groups): DCNL 'Find AniDB short group names for release groups DCNL :param groups: list of groups to find short group names for DCNL :return: list of shortened group names'
def Internaldate2Time(resp): DCNL 'time_tuple = Internaldate2Time(resp) DCNL Convert IMAP4 INTERNALDATE to UT.'
def ftdi_to_clkbits(baudrate): DCNL '10,27 => divisor = 10000, rate = 300 DCNL 88,13 => divisor = 5000, rate = 600 DCNL C4,09 => divisor = 2500, rate = 1200 DCNL E2,04 => divisor = 1250, rate = 2,400 DCNL 71,02 => divisor = 625, rate = 4,800 DCNL 38,41 => divisor = 312.5, rate = 9,600 DCNL D0,80 => divisor = 208.25, rate = 14406 DCNL 9C,80 => divisor = 156, rate = 19,230 DCNL 4E,C0 => divisor = 78, rate = 38,461 DCNL 34,00 => divisor = 52, rate = 57,692 DCNL 1A,00 => divisor = 26, rate = 115,384 DCNL 0D,00 => divisor = 13, rate = 230,769'
def question_metadata(): DCNL 'RESTful CRUD controller'
def _find_es_dict_by_key(lookup_dict, term): DCNL 'Performs iterative dictionary search based upon the following conditions: DCNL 1. Subkeys may either appear behind a full stop (.) or at one lookup_dict level lower in the tree. DCNL 2. No wildcards exist within the provided ES search terms (these are treated as string literals) DCNL This is necessary to get around inconsistencies in ES data. DCNL For example: DCNL {\'ad.account_name\': \'bob\'} DCNL Or: DCNL {\'csp_report\': {\'blocked_uri\': \'bob.com\'}} DCNL And even: DCNL {\'juniper_duo.geoip\': {\'country_name\': \'Democratic People\'s Republic of Korea\'}} DCNL We want a search term of form "key.subkey.subsubkey" to match in all cases. DCNL :returns: A tuple with the first element being the dict that contains the key and the second DCNL element which is the last subkey used to access the target specified by the term. None is DCNL returned for both if the key can not be found.'
def set_ip_nonlocal_bind_for_namespace(namespace): DCNL 'Set ip_nonlocal_bind but don\'t raise exception on failure.'
def get_today_all(): DCNL 'return DCNL DataFrame'
def block(bdaddr): DCNL 'Block a specific bluetooth device by BD Address DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' bluetooth.block DE:AD:BE:EF:CA:FE'
def delete_comment(request, comment_id): DCNL 'Delete a comment. DCNL Arguments: DCNL request: The django request object used for build_absolute_uri and DCNL determining the requesting user. DCNL comment_id: The id of the comment to delete DCNL Raises: DCNL PermissionDenied: if user does not have permission to delete thread'
def regex_uri(e, regexes, tag, default=None): DCNL 'Filters incoming URI against a list of regexes'
def sort_otu_table(otu_table, sorted_sample_ids): DCNL 'Sort an OTU table by sorted sample ids'
def ordinal(value): DCNL 'Converts an integer to its ordinal as a string. 1 is \'1st\', 2 is \'2nd\', DCNL 3 is \'3rd\', etc. Works for any integer.'
def destroy(name, call=None): DCNL 'This function irreversibly destroys a virtual machine on the cloud provider. DCNL Before doing so, it should fire an event on the Salt event bus. DCNL The tag for this event is `salt/cloud/<vm name>/destroying`. DCNL Once the virtual machine has been destroyed, another event is fired. DCNL The tag for that event is `salt/cloud/<vm name>/destroyed`. DCNL Dependencies: DCNL list_nodes DCNL @param name: DCNL @type name: str DCNL @param call: DCNL @type call: DCNL @return: True if all went well, otherwise an error message DCNL @rtype: bool|str'
def get_images_table(meta): DCNL 'No changes to the images table from 008...'
def concatenate_paths(paths): DCNL 'concatenate list of paths into a single path.'
def label_table(dataset_id, table_id, label_key, label_value, project_id=None): DCNL 'Add or modify a label on a table.'
def prepro(I): DCNL 'prepro 210x160x3 uint8 frame into 6400 (80x80) 1D float vector'
def put_meta(module, cf, container, src, dest, meta, clear_meta): DCNL 'Set metadata on a container, single file, or comma-separated list. DCNL Passing a true value to clear_meta clears the metadata stored in Cloud DCNL Files before setting the new metadata to the value of "meta".'
def parse_ntlm_resp(msg3, seq): DCNL 'Parse the 3rd msg in NTLM handshake DCNL Thanks to psychomario'
def test_prefer_deep(): DCNL 'c DCNL y   b DCNL x   a DCNL Prefer longer chains first so we should start with c'
def _gs_decorrelation(w, W, j): DCNL 'Orthonormalize w wrt the first j rows of W DCNL Parameters DCNL w : ndarray of shape(n) DCNL Array to be orthogonalized DCNL W : ndarray of shape(p, n) DCNL Null space definition DCNL j : int < p DCNL The no of (from the first) rows of Null space W wrt which w is DCNL orthogonalized. DCNL Notes DCNL Assumes that W is orthogonal DCNL w changed in place'
def removed(name, dir=None, user=None): DCNL 'Verify that the given package is not installed. DCNL dir DCNL The target directory in which to install the package, or None for DCNL global installation DCNL user DCNL The user to run NPM with DCNL .. versionadded:: 0.17.0'
def create_gzip_message(payloads, key=None, compresslevel=None): DCNL 'Construct a Gzipped Message containing multiple Messages DCNL The given payloads will be encoded, compressed, and sent as a single atomic DCNL message to Kafka. DCNL Arguments: DCNL payloads: list(bytes), a list of payload to send be sent to Kafka DCNL key: bytes, a key used for partition routing (optional)'
def unpublish_exploration(committer_id, exploration_id): DCNL 'Unpublishes an exploration. Commits changes.'
def fork_exec(cmd, exec_env=None, logfile=None, pass_fds=None): DCNL 'Execute a command using fork/exec. DCNL This is needed for programs system executions that need path DCNL searching but cannot have a shell as their parent process, for DCNL example: glance-api.  When glance-api starts it sets itself as DCNL the parent process for its own process group.  Thus the pid that DCNL a Popen process would have is not the right pid to use for killing DCNL the process group.  This patch gives the test env direct access DCNL to the actual pid. DCNL :param cmd: Command to execute as an array of arguments. DCNL :param exec_env: A dictionary representing the environment with DCNL which to run the command. DCNL :param logfile: A path to a file which will hold the stdout/err of DCNL the child process. DCNL :param pass_fds: Sequence of file descriptors passed to the child.'
def custom_create(request): DCNL 'Calls create_object generic view with a custom form class.'
def getMinimumByPathsComplex(paths): DCNL 'Get a complex with each component the minimum of the respective components of lists of complex points.'
def iter_texts_from_json_bz2(loc): DCNL 'Iterator of unicode strings, one per document (here, a comment). DCNL Expects a a path to a BZ2 file, which should be new-line delimited JSON. The DCNL document text should be in a string field titled \'body\'. DCNL This is the data format of the Reddit comments corpus.'
def query_package(module, name): DCNL 'Search for the package by name. DCNL Possible return values: DCNL * "present"  - installed, no upgrade needed DCNL * "outdated" - installed, but can be upgraded DCNL * False      - not installed or not found'
def find_indentation(node): DCNL 'Find the indentation of *node*.'
def expect_warnings(*messages, **kw): DCNL 'Context manager which expects one or more warnings. DCNL With no arguments, squelches all SAWarnings emitted via DCNL sqlalchemy.util.warn and sqlalchemy.util.warn_limited.   Otherwise DCNL pass string expressions that will match selected warnings via regex; DCNL all non-matching warnings are sent through. DCNL The expect version **asserts** that the warnings were in fact seen. DCNL Note that the test suite sets SAWarning warnings to raise exceptions.'
def get_max_age(response): DCNL 'Returns the max-age from the response Cache-Control header as an integer DCNL (or ``None`` if it wasn\'t found or wasn\'t an integer.'
def disabled_xblocks(): DCNL 'Return the QuerySet of disabled XBlock types (which should not render in the LMS). DCNL Note that this method is independent of `XBlockStudioConfigurationFlag` and `XBlockStudioConfiguration`.'
@register.tag(name='crispy') DCNL def do_uni_form(parser, token): DCNL 'You need to pass in at least the form/formset object, and can also pass in the DCNL optional `crispy_forms.helpers.FormHelper` object. DCNL helper (optional): A `crispy_forms.helper.FormHelper` object. DCNL Usage:: DCNL {% load crispy_tags %} DCNL {% crispy form form.helper %} DCNL You can also provide the template pack as the third argument:: DCNL {% crispy form form.helper \'bootstrap\' %} DCNL If the `FormHelper` attribute is named `helper` you can simply do:: DCNL {% crispy form %} DCNL {% crispy form \'bootstrap\' %}'
def t_CPP_CHAR(t): DCNL '(L)?\\'([^\\\n]|(\\(.|\n)))*?\\''
def _CreateDbOperationMap(entry_list): DCNL 'Create an operation map from a list of OpMapEntry objects. Note DCNL that operation handlers must be classmethods, not staticmethods.'
def make_envvar(name): DCNL 'Makes a StoreNonEmpty node for an environment variable.'
def parse_rarefaction_record(line): DCNL 'Return (rarefaction_fn, [data])'
def validate_key(key, shape): DCNL 'Check if the key is a valid index. DCNL Args: DCNL key: The key used to index/slice. DCNL shape: The shape (rows, cols) of the expression. DCNL Returns: DCNL The key as a tuple of slices. DCNL Raises: DCNL Error: Index/slice out of bounds.'
def export_to_files(record_list=None, record_module=None, verbose=0, create_init=None): DCNL 'Export record_list to files. record_list is a list of lists ([doctype],[docname] )  ,'
def mkAssocResponse(*keys): DCNL 'Build an association response message that contains the DCNL specified subset of keys. The values come from DCNL `association_response_values`. DCNL This is useful for testing for missing keys and other times that DCNL we don\'t care what the values are.'
def test_end_pos_error_correction(): DCNL 'Source code without ending newline are given one, because the Python DCNL grammar needs it. However, they are removed again. We still want the right DCNL end_pos, even if something breaks in the parser (error correction).'
def int_from_geom(func, zero=False): DCNL 'Argument is a geometry, return type is an integer.'
def check_header_validity(header): DCNL 'Verifies that header value is a string which doesn\'t contain DCNL leading whitespace or return characters. This prevents unintended DCNL header injection. DCNL :param header: tuple, in the format (name, value).'
def defoveate_channel(img, rings, dense_input, start_idx): DCNL 'Defoveate a single channel of the DenseDesignMatrix dense_input into the DCNL variable, stored in topological ordering. DCNL Parameters DCNL img : WRITEME DCNL channel for defoveated image of shape (batch, img_h, img_w) DCNL rings : WRITEME DCNL list of ring_sizes which were used to generate dense_input DCNL dense_input : WRITEME DCNL DenseDesignMatrix containing foveated dataset, of shape DCNL (batch, dims) DCNL start_idx : WRITEME DCNL channel pointed to by img starts at dense_input[start_idx]'
def _get_options(ret=None): DCNL 'Get the SQLite3 options from salt.'
def create_resource(): DCNL 'Images resource factory method.'
def _get_constant(name): DCNL 'Read a __magic__ constant from qutebrowser/__init__.py. DCNL We don\'t import qutebrowser here because it can go wrong for multiple DCNL reasons. Instead we use re/ast to get the value directly from the source DCNL file. DCNL Args: DCNL name: The name of the argument to get. DCNL Return: DCNL The value of the argument.'
def assert_regex(result, expected, msg=''): DCNL 'Assert that ``expected`` matches the result. DCNL Parameters DCNL result : str DCNL The string to search. DCNL expected : str or compiled regex DCNL The pattern to search for in ``result``. DCNL msg : str, optional DCNL An extra assertion message to print if this fails.'
def scatter_plot(): DCNL 'scatter plot'
@webob.dec.wsgify DCNL @util.check_accept('application/json') DCNL def get_resource_provider(req): DCNL 'Get a single resource provider. DCNL On success return a 200 with an application/json body representing DCNL the resource provider.'
@require_admin_context DCNL def purge_deleted_rows(context, age_in_days): DCNL 'Purge deleted rows older than age from cinder tables.'
def has_module(module_name, members=[]): DCNL 'Return whether or not a given module can be imported.'
def create_realign_flow(name=u'realign'): DCNL 'Realign a time series to the middle volume using spline interpolation DCNL Uses MCFLIRT to realign the time series and ApplyWarp to apply the rigid DCNL body transformations using spline interpolation (unknown order). DCNL Example DCNL >>> wf = create_realign_flow() DCNL >>> wf.inputs.inputspec.func = \'f3.nii\' DCNL >>> wf.run() # doctest: +SKIP'
def dmp_rem(f, g, u, K): DCNL 'Returns polynomial remainder in ``K[X]``. DCNL Examples DCNL >>> from sympy.polys import ring, ZZ, QQ DCNL >>> R, x,y = ring("x,y", ZZ) DCNL >>> R.dmp_rem(x**2 + x*y, 2*x + 2) DCNL x**2 + x*y DCNL >>> R, x,y = ring("x,y", QQ) DCNL >>> R.dmp_rem(x**2 + x*y, 2*x + 2) DCNL -y + 1'
def get_request_location(request, context): DCNL 'Determine country of origin of the `request` for the given `context` DCNL This is done by: DCNL * checking the CDN headers for country of origin if set DCNL * falling back on geocoding request.ip address against the geocoder service DCNL The resulting location is memoized on context on `context.location` DCNL request, context: Should be pylons.request & pylons.c respectively;'
def service_get_all_by_host(context, host): DCNL 'Get all services for a given host.'
def _quote_domain(domain): DCNL 'Special quoting rule for placing domain names on a url line. DCNL Domain names tend to have .\'s in them.  Urllib doesn\'t quote dots, DCNL but Routes tends to choke on them, so we need an extra level of DCNL by-hand quoting here.'
def cache_key_prefix(request): DCNL 'Cache key for Mezzanine\'s cache middleware. Adds the current DCNL device and site ID.'
def forward(data, impulse_response=None, filter_params={}, predefined_filter=None): DCNL 'Apply the given filter to data. DCNL Parameters DCNL data : (M,N) ndarray DCNL Input data. DCNL impulse_response : callable `f(r, c, **filter_params)` DCNL Impulse response of the filter.  See LPIFilter2D.__init__. DCNL filter_params : dict DCNL Additional keyword parameters to the impulse_response function. DCNL Other Parameters DCNL predefined_filter : LPIFilter2D DCNL If you need to apply the same filter multiple times over different DCNL images, construct the LPIFilter2D and specify it here. DCNL Examples DCNL Gaussian filter: DCNL >>> def filt_func(r, c): DCNL ...     return np.exp(-np.hypot(r, c)/1) DCNL >>> from skimage import data DCNL >>> filtered = forward(data.coins(), filt_func)'
def import_key(extern_key, passphrase=None): DCNL 'Import an RSA key (public or private half), encoded in standard DCNL form. DCNL :Parameter extern_key: DCNL The RSA key to import, encoded as a byte string. DCNL An RSA public key can be in any of the following formats: DCNL - X.509 certificate (binary or PEM format) DCNL - X.509 ``subjectPublicKeyInfo`` DER SEQUENCE (binary or PEM DCNL encoding) DCNL - `PKCS#1`_ ``RSAPublicKey`` DER SEQUENCE (binary or PEM encoding) DCNL - OpenSSH (textual public key only) DCNL An RSA private key can be in any of the following formats: DCNL - PKCS#1 ``RSAPrivateKey`` DER SEQUENCE (binary or PEM encoding) DCNL - `PKCS#8`_ ``PrivateKeyInfo`` or ``EncryptedPrivateKeyInfo`` DCNL DER SEQUENCE (binary or PEM encoding) DCNL - OpenSSH (textual public key only) DCNL For details about the PEM encoding, see `RFC1421`_/`RFC1423`_. DCNL The private key may be encrypted by means of a certain pass phrase DCNL either at the PEM level or at the PKCS#8 level. DCNL :Type extern_key: string DCNL :Parameter passphrase: DCNL In case of an encrypted private key, this is the pass phrase from DCNL which the decryption key is derived. DCNL :Type passphrase: string DCNL :Return: An RSA key object (`RsaKey`). DCNL :Raise ValueError/IndexError/TypeError: DCNL When the given key cannot be parsed (possibly because the pass DCNL phrase is wrong). DCNL .. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt DCNL .. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt DCNL .. _`PKCS#1`: http://www.ietf.org/rfc/rfc3447.txt DCNL .. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt'
def computeComprRate(meta, compr_size): DCNL 'Compute image compression rate. Skip size of color palette, focus on DCNL image pixels. Original size is width x height x bpp. Compressed size DCNL is an argument (in bits). DCNL Set "compr_data" with a string like "1.52x".'
def buildAllTarballs(checkout, destination): DCNL 'Build complete tarballs (including documentation) for Twisted and all DCNL subprojects. DCNL This should be called after the version numbers have been updated and DCNL NEWS files created. DCNL @type checkout: L{FilePath} DCNL @param checkout: The SVN working copy from which a pristine source tree DCNL will be exported. DCNL @type destination: L{FilePath} DCNL @param destination: The directory in which tarballs will be placed. DCNL @raise UncleanWorkingDirectory: if there are modifications to the DCNL working directory of C{checkout}. DCNL @raise NotWorkingDirectory: if the checkout path is not an SVN checkout.'
def sp_sum(x, axis=None, sparse_grad=False): DCNL 'Calculate the sum of a sparse matrix along the specified axis. DCNL It operates a reduction along the specified axis. When `axis` is `None`, DCNL it is applied along all axes. DCNL Parameters DCNL x DCNL Sparse matrix. DCNL axis DCNL Axis along which the sum is applied. Integer or `None`. DCNL sparse_grad : bool DCNL `True` to have a structured grad. DCNL Returns DCNL object DCNL The sum of `x` in a dense format. DCNL Notes DCNL The grad implementation is controlled with the `sparse_grad` parameter. DCNL `True` will provide a structured grad and `False` will provide a regular DCNL grad. For both choices, the grad returns a sparse matrix having the same DCNL format as `x`. DCNL This op does not return a sparse matrix, but a dense tensor matrix.'
def start_debugger(rpchandler, gui_adap_oid): DCNL 'Start the debugger and its RPC link in the Python subprocess DCNL Start the subprocess side of the split debugger and set up that side of the DCNL RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter DCNL objects and linking them together.  Register the IdbAdapter with the DCNL RPCServer to handle RPC requests from the split debugger GUI via the DCNL IdbProxy.'
def console(): DCNL 'Defines the behavior of the console web2py execution'
def check_valid_abd_naming(pattern=None): DCNL 'Checks if the name is can be parsed back to its original form for an air-by-date format. DCNL :return: true if the naming is valid, false if not.'
def prepare_to_notify(doc, print_html=None, print_format=None, attachments=None): DCNL 'Prepare to make multipart MIME Email DCNL :param print_html: Send given value as HTML attachment. DCNL :param print_format: Attach print format of parent document.'
@register.simple_tag(takes_context=True) DCNL def admin_widget(context, widget): DCNL 'Render a widget with the given information. DCNL The widget will be created and returned as HTML. Any states in the DCNL database will be loaded into the rendered widget.'
def ego_graph(G, n, radius=1, center=True, undirected=False, distance=None): DCNL 'Returns induced subgraph of neighbors centered at node n within DCNL a given radius. DCNL Parameters DCNL G : graph DCNL A NetworkX Graph or DiGraph DCNL n : node DCNL A single node DCNL radius : number, optional DCNL Include all neighbors of distance<=radius from n. DCNL center : bool, optional DCNL If False, do not include center node in graph DCNL undirected : bool, optional DCNL If True use both in- and out-neighbors of directed graphs. DCNL distance : key, optional DCNL Use specified edge data key as distance.  For example, setting DCNL distance=\'weight\' will use the edge weight to measure the DCNL distance from the node n. DCNL Notes DCNL For directed graphs D this produces the "out" neighborhood DCNL or successors.  If you want the neighborhood of predecessors DCNL first reverse the graph with D.reverse().  If you want both DCNL directions use the keyword argument undirected=True. DCNL Node, edge, and graph attributes are copied to the returned subgraph.'
def delete_pool_member(hostname, username, password, name, member): DCNL 'Delete an existing pool member. DCNL hostname DCNL The host/address of the bigip device DCNL username DCNL The iControl REST username DCNL password DCNL The iControl REST password DCNL name DCNL The name of the pool to be modified DCNL member DCNL The name of the member to delete from the pool'
def _app_path(dirname, entry): DCNL 'Construct (dirname, [glob-expanded-entries relative to dirname])'
def commit_on_success(using=None, read_committed=False): DCNL 'This function implements the commit_on_success() API that was available till Django 1.5. DCNL It can be used either as a decorator or as a context manager. However, it DCNL cannot be nested inside an atomic block. DCNL If the wrapped function or block returns a response the transaction is committed DCNL and if it raises an exception the transaction is rolled back. DCNL Arguments: DCNL using (str): the name of the database. DCNL read_committed (bool): Whether to use read committed isolation level. DCNL Raises: DCNL TransactionManagementError: if already inside an atomic block.'
def ttost_paired(x1, x2, low, upp, transform=None, weights=None): DCNL 'test of (non-)equivalence for two dependent, paired sample DCNL TOST: two one-sided t tests DCNL null hypothesis:  md < low or md > upp DCNL alternative hypothesis:  low < md < upp DCNL where md is the mean, expected value of the difference x1 - x2 DCNL If the pvalue is smaller than a threshold,say 0.05, then we reject the DCNL hypothesis that the difference between the two samples is larger than the DCNL the thresholds given by low and upp. DCNL Parameters DCNL x1, x2 : array_like DCNL two dependent samples DCNL low, upp : float DCNL equivalence interval low < mean of difference < upp DCNL weights : None or ndarray DCNL case weights for the two samples. For details on weights see DCNL ``DescrStatsW`` DCNL transform : None or function DCNL If None (default), then the data is not transformed. Given a function DCNL sample data and thresholds are transformed. If transform is log the DCNL the equivalence interval is in ratio: low < x1 / x2 < upp DCNL Returns DCNL pvalue : float DCNL pvalue of the non-equivalence test DCNL t1, pv1, df1 : tuple DCNL test statistic, pvalue and degrees of freedom for lower threshold test DCNL t2, pv2, df2 : tuple DCNL test statistic, pvalue and degrees of freedom for upper threshold test'
def s3_addrow(form, label, widget, comment, formstyle, row_id, position=(-1)): DCNL 'Add a row to a form, applying formstyle DCNL @param form: the FORM DCNL @param label: the label DCNL @param widget: the widget DCNL @param comment: the comment DCNL @param formstyle: the formstyle DCNL @param row_id: the form row HTML id DCNL @param position: position where to insert the row'
def eq_(result, expected, msg=None): DCNL 'Shadow of the Nose builtin which presents easier to read multiline output.'
def maven_metadata_param(registry, xml_parent, data): DCNL 'yaml: maven-metadata DCNL This parameter allows the resolution of maven artifact versions DCNL by contacting the repository and reading the maven-metadata.xml. DCNL Requires the Jenkins :jenkins-wiki:`Maven Metadata Plugin DCNL <Maven+Metadata+Plugin>`. DCNL :arg str name: Name of the parameter DCNL :arg str description: Description of the parameter (optional) DCNL :arg str repository-base-url: URL from where you retrieve your artifacts DCNL (default \'\') DCNL :arg str repository-username: Repository\'s username if authentication is DCNL required. (default \'\') DCNL :arg str repository-password: Repository\'s password if authentication is DCNL required. (default \'\') DCNL :arg str artifact-group-id: Unique project identifier (default \'\') DCNL :arg str artifact-id: Name of the artifact without version (default \'\') DCNL :arg str packaging: Artifact packaging option. Could be something such as DCNL jar, zip, pom.... (default \'\') DCNL :arg str versions-filter: Specify a regular expression which will be used DCNL to filter the versions which are actually displayed when triggering a DCNL new build. (default \'\') DCNL :arg str default-value: For features such as SVN polling a default value DCNL is required. If job will only be started manually, this field is not DCNL necessary. (default \'\') DCNL :arg str maximum-versions-to-display: The maximum number of versions to DCNL display in the drop-down. Any non-number value as well as 0 or negative DCNL values will default to all. (default 10) DCNL :arg str sorting-order: ascending or descending DCNL (default descending) DCNL Example: DCNL .. literalinclude:: DCNL /../../tests/parameters/fixtures/maven-metadata-param001.yaml DCNL :language: yaml'
def modularity(G, communities, weight='weight'): DCNL 'Returns the modularity of the given partition of the graph. DCNL Modularity is defined in [1]_ as DCNL .. math:: DCNL Q = \frac{1}{2m} \sum_{ij} \left( A_{ij} - \frac{k_ik_j}{2m}\right) DCNL \delta(c_i,c_j) DCNL where *m* is the number of edges, *A* is the adjacency matrix of DCNL `G`, :math:`k_i` is the degree of *i* and :math:`\delta(c_i, c_j)` DCNL is 1 if *i* and *j* are in the same community and 0 otherwise. DCNL Parameters DCNL G : NetworkX Graph DCNL communities : list DCNL List of sets of nodes of `G` representing a partition of the DCNL nodes. DCNL Returns DCNL Q : float DCNL The modularity of the paritition. DCNL Raises DCNL NotAPartition DCNL If `communities` is not a partition of the nodes of `G`. DCNL Examples DCNL >>> G = nx.barbell_graph(3, 0) DCNL >>> nx.modularity(G, [{0, 1, 2}, {3, 4, 5}]) DCNL 0.35714285714285704 DCNL References DCNL .. [1] M. E. J. Newman *Networks: An Introduction*, page 224. DCNL Oxford University Press, 2011.'
def load_object(path): DCNL 'Load an object given its absolute object path, and return it. DCNL object can be a class, function, variable or an instance. DCNL path ie: \'scrapy.downloadermiddlewares.redirect.RedirectMiddleware\''
def GetResources(filename, types=None, names=None, languages=None): DCNL 'Get resources from dll/exe file. DCNL types = a list of resource types to search for (None = all) DCNL names = a list of resource names to search for (None = all) DCNL languages = a list of resource languages to search for (None = all) DCNL Return a dict of the form {type_: {name: {language: data}}} which DCNL might also be empty if no matching resources were found.'
def template(): DCNL 'RESTful CRUD controller'
def sync_output(saltenv=None, refresh=True): DCNL 'Sync outputters from ``salt://_output`` to the minion DCNL saltenv : base DCNL The fileserver environment from which to sync. To sync from more than DCNL one environment, pass a comma-separated list. DCNL refresh : True DCNL If ``True``, refresh the available execution modules on the minion. DCNL This refresh will be performed even if no new outputters are synced. DCNL Set to ``False`` to prevent this refresh. DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt \'*\' saltutil.sync_output DCNL salt \'*\' saltutil.sync_output saltenv=dev DCNL salt \'*\' saltutil.sync_output saltenv=base,dev'
def _list_items(queue): DCNL 'Private function to list contents of a queue'
def test_duplicate_output(): DCNL 'An error is raised if within a single bundle, two jobs override DCNL each other.'
def closeness_centrality(G, nodes, normalized=True): DCNL 'Compute the closeness centrality for nodes in a bipartite network. DCNL The closeness of a node is the distance to all other nodes in the DCNL graph or in the case that the graph is not connected to all other nodes DCNL in the connected component containing that node. DCNL Parameters DCNL G : graph DCNL A bipartite network DCNL nodes : list or container DCNL Container with all nodes in one bipartite node set. DCNL normalized : bool, optional DCNL If True (default) normalize by connected component size. DCNL Returns DCNL closeness : dictionary DCNL Dictionary keyed by node with bipartite closeness centrality DCNL as the value. DCNL See Also DCNL betweenness_centrality, DCNL degree_centrality DCNL sets, DCNL is_bipartite DCNL Notes DCNL The nodes input parameter must conatin all nodes in one bipartite node set, DCNL but the dictionary returned contains all nodes from both node sets. DCNL Closeness centrality is normalized by the minimum distance possible. DCNL In the bipartite case the minimum distance for a node in one bipartite DCNL node set is 1 from all nodes in the other node set and 2 from all DCNL other nodes in its own set [1]_. Thus the closeness centrality DCNL for node `v`  in the two bipartite sets `U` with DCNL `n` nodes and `V` with `m` nodes is DCNL .. math:: DCNL c_{v} = \frac{m + 2(n - 1)}{d}, \mbox{for} v \in U, DCNL c_{v} = \frac{n + 2(m - 1)}{d}, \mbox{for} v \in V, DCNL where `d` is the sum of the distances from `v` to all DCNL other nodes. DCNL Higher values of closeness  indicate higher centrality. DCNL As in the unipartite case, setting normalized=True causes the DCNL values to normalized further to n-1 / size(G)-1 where n is the DCNL number of nodes in the connected part of graph containing the DCNL node.  If the graph is not completely connected, this algorithm DCNL computes the closeness centrality for each connected part DCNL separately. DCNL References DCNL .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation DCNL Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook DCNL of Social Network Analysis. Sage Publications. DCNL http://www.steveborgatti.com/papers/bhaffiliations.pdf'
def test_unicode_labels_python3(Chart): DCNL 'Test unicode labels in python 3'
def newton_cg(grad_hess, func, grad, x0, args=(), tol=0.0001, maxiter=100, maxinner=200, line_search=True, warn=True): DCNL 'Minimization of scalar function of one or more variables using the DCNL Newton-CG algorithm. DCNL Parameters DCNL grad_hess : callable DCNL Should return the gradient and a callable returning the matvec product DCNL of the Hessian. DCNL func : callable DCNL Should return the value of the function. DCNL grad : callable DCNL Should return the function value and the gradient. This is used DCNL by the linesearch functions. DCNL x0 : array of float DCNL Initial guess. DCNL args : tuple, optional DCNL Arguments passed to func_grad_hess, func and grad. DCNL tol : float DCNL Stopping criterion. The iteration will stop when DCNL ``max{|g_i | i = 1, ..., n} <= tol`` DCNL where ``g_i`` is the i-th component of the gradient. DCNL maxiter : int DCNL Number of Newton iterations. DCNL maxinner : int DCNL Number of CG iterations. DCNL line_search : boolean DCNL Whether to use a line search or not. DCNL warn : boolean DCNL Whether to warn when didn\'t converge. DCNL Returns DCNL xk : ndarray of float DCNL Estimated minimum.'
def classof(A, B): DCNL 'Get the type of the result when combining matrices of different types. DCNL Currently the strategy is that immutability is contagious. DCNL Examples DCNL >>> from sympy import Matrix, ImmutableMatrix DCNL >>> from sympy.matrices.matrices import classof DCNL >>> M = Matrix([[1, 2], [3, 4]]) # a Mutable Matrix DCNL >>> IM = ImmutableMatrix([[1, 2], [3, 4]]) DCNL >>> classof(M, IM) DCNL <class \'sympy.matrices.immutable.ImmutableMatrix\'>'
def _sparse_blockify(tuples, dtype=None): DCNL 'return an array of blocks that potentially have different dtypes (and DCNL are sparse)'
def chunks(l, n): DCNL 'Yield successive n-sized chunks from l.'
def compose_all(stream, Loader=Loader): DCNL 'Parse all YAML documents in a stream DCNL and produce corresponding representation trees.'
def send_commit(): DCNL 'Send a Shipment containing all items in a Commitment DCNL @ToDo: Rewrite as S3Method DCNL - means that permissions are better-controlled'
def getRandomInteger(N, randfunc=None): DCNL 'getRandomInteger(N:int, randfunc:callable):long DCNL Return a random number with at most N bits. DCNL If randfunc is omitted, then Random.new().read is used. DCNL This function is for internal use only and may be renamed or removed in DCNL the future.'
def get_item_inventory_size(): DCNL 'Access to the Item inventory size. DCNL :return: Item inventory size. DCNL :rtype: int'
def test_private_browsing(qtbot, tmpdir, fake_save_manager, config_stub): DCNL 'Make sure no data is saved at all with private browsing.'
def uptodate(name, bin_env=None, user=None, cwd=None, use_vt=False): DCNL '.. versionadded:: 2015.5.0 DCNL Verify that the system is completely up to date. DCNL name DCNL The name has no functional value and is only used as a tracking DCNL reference DCNL user DCNL The user under which to run pip DCNL bin_env DCNL the pip executable or virtualenenv to use DCNL use_vt DCNL Use VT terminal emulation (see output while installing)'
def objString(obj): DCNL 'Return a short but descriptive string for any object'
def human_bytes(size): DCNL 'Formats size, a number of bytes, in a human-readable way.'
@bdd.given(bdd.parsers.parse('I DCSP set DCSP {sect} DCSP -> DCSP {opt} DCSP to DCSP {value}')) DCNL def set_setting_given(quteproc, httpbin, sect, opt, value): DCNL 'Set a qutebrowser setting. DCNL This is available as "Given:" step so it can be used as "Background:".'
def metric_cleanup(): DCNL 'Clean up the metric module.'
@register.filter(is_safe=True) DCNL def stringformat(value, arg): DCNL 'Formats the variable according to the arg, a string formatting specifier. DCNL This specifier uses Python string formating syntax, with the exception that DCNL the leading "%" is dropped. DCNL See http://docs.python.org/lib/typesseq-strings.html for documentation DCNL of Python string formatting'
def is_nvcc_available(): DCNL 'Return True iff the nvcc compiler is found.'
def list_quota_volume(name): DCNL 'List quotas of glusterfs volume. DCNL name DCNL Name of the gluster volume'
def get_cache_slug(): DCNL 'Returns cache slug depending whether dev or prod.'
def _copy_py_state(r, ptr): DCNL 'Copy state of Python random *r* to Numba state *ptr*.'
def parse_xreply(xreply): DCNL 'Parse the reply from xqueue. Messages are JSON-serialized dict: DCNL { \'return_code\': 0 (success), 1 (fail) DCNL \'content\': Message from xqueue (string)'
@protocol.commands.add(u'next') DCNL def next_(context): DCNL '*musicpd.org, playback section:* DCNL ``next`` DCNL Plays next song in the playlist. DCNL *MPD\'s behaviour when affected by repeat/random/single/consume:* DCNL Given a playlist of three tracks numbered 1, 2, 3, and a currently DCNL playing track ``c``. ``next_track`` is defined at the track that DCNL will be played upon calls to ``next``. DCNL Tests performed on MPD 0.15.4-1ubuntu3. DCNL Inputs                    next_track DCNL repeat  random  single  consume  c = 1  c = 2  c = 3  Notes DCNL T       T       T       T        2      3      EOPL DCNL T       T       T       .        Rand   Rand   Rand   [1] DCNL T       T       .       T        Rand   Rand   Rand   [4] DCNL T       T       .       .        Rand   Rand   Rand   [4] DCNL T       .       T       T        2      3      EOPL DCNL T       .       T       .        2      3      1 DCNL T       .       .       T        3      3      EOPL DCNL T       .       .       .        2      3      1 DCNL .       T       T       T        Rand   Rand   Rand   [3] DCNL .       T       T       .        Rand   Rand   Rand   [3] DCNL .       T       .       T        Rand   Rand   Rand   [2] DCNL .       T       .       .        Rand   Rand   Rand   [2] DCNL .       .       T       T        2      3      EOPL DCNL .       .       T       .        2      3      EOPL DCNL .       .       .       T        2      3      EOPL DCNL .       .       .       .        2      3      EOPL DCNL - When end of playlist (EOPL) is reached, the current track is DCNL unset. DCNL - [1] When *random* and *single* is combined, ``next`` selects DCNL a track randomly at each invocation, and not just the next track DCNL in an internal prerandomized playlist. DCNL - [2] When *random* is active, ``next`` will skip through DCNL all tracks in the playlist in random order, and finally EOPL is DCNL reached. DCNL - [3] *single* has no effect in combination with *random* DCNL alone, or *random* and *consume*. DCNL - [4] When *random* and *repeat* is active, EOPL is never DCNL reached, but the playlist is played again, in the same random DCNL order as the first time.'
def collect_driver_info(driver): DCNL 'Build the dictionary that describes this driver.'
def rand_text_alphanumeric(length, bad=''): DCNL 'generate a random string with alpha and numerals chars'
@app.route('/raise-500', methods=['GET']) DCNL @requires_auth DCNL def raise_500(): DCNL 'This exists for testing error_500_handler'
def getGammaRamp(pygletWindow): DCNL 'Ramp will be returned as 3x256 array in range 0:1'
def _unary_int_input_wrapper_impl(wrapped_impl): DCNL 'Return an implementation factory to convert the single integral input DCNL argument to a float64, then defer to the *wrapped_impl*.'
def OAuthTokenFromHttpBody(http_body): DCNL 'Parses the HTTP response body and returns an OAuth token. DCNL The returned OAuth token will just have key and secret parameters set. DCNL It won\'t have any knowledge about the scopes or oauth_input_params. It is DCNL your responsibility to make it aware of the remaining parameters. DCNL Returns: DCNL OAuthToken OAuth token.'
def unintegrate_levels(x, d): DCNL 'Returns the successive differences needed to unintegrate the series. DCNL Parameters DCNL x : array-like DCNL The original series DCNL d : int DCNL The number of differences of the differenced series. DCNL Returns DCNL y : array-like DCNL The increasing differences from 0 to d-1 of the first d elements DCNL of x. DCNL See Also DCNL unintegrate'
def render_git_describe(pieces): DCNL 'TAG[-DISTANCE-gHEX][-dirty]. DCNL Like \'git describe --tags --dirty --always\'. DCNL Exceptions: DCNL 1: no tags. HEX[-dirty]  (note: no \'g\' prefix)'
def dtlz5(ind, n_objs): DCNL 'DTLZ5 multiobjective function. It returns a tuple of *obj* values. The DCNL individual must have at least *obj* elements. DCNL From: K. Deb, L. Thiele, M. Laumanns and E. Zitzler. Scalable Multi-Objective DCNL Optimization Test Problems. CEC 2002, p. 825-830, IEEE Press, 2002.'
def _safe_getattr(obj, attr, default=None): DCNL 'Safe version of getattr. DCNL Same as getattr, but will return ``default`` on any Exception, DCNL rather than raising.'
def _fileobj_normalize_mode(f): DCNL 'Takes care of some corner cases in Python where the mode string DCNL is either oddly formatted or does not truly represent the file mode.'
def nC(n, k=None, replacement=False): DCNL 'Return the number of combinations of ``n`` items taken ``k`` at a time. DCNL Possible values for ``n``:: DCNL integer - set of length ``n`` DCNL sequence - converted to a multiset internally DCNL multiset - {element: multiplicity} DCNL If ``k`` is None then the total of all combinations of length 0 DCNL through the number of items represented in ``n`` will be returned. DCNL If ``replacement`` is True then a given item can appear more than once DCNL in the ``k`` items. (For example, for \'ab\' sets of 2 would include \'aa\', DCNL \'ab\', and \'bb\'.) The multiplicity of elements in ``n`` is ignored when DCNL ``replacement`` is True but the total number of elements is considered DCNL since no element can appear more times than the number of elements in DCNL ``n``. DCNL Examples DCNL >>> from sympy.functions.combinatorial.numbers import nC DCNL >>> from sympy.utilities.iterables import multiset_combinations DCNL >>> nC(3, 2) DCNL 3 DCNL >>> nC(\'abc\', 2) DCNL 3 DCNL >>> nC(\'aab\', 2) DCNL 2 DCNL When ``replacement`` is True, each item can have multiplicity DCNL equal to the length represented by ``n``: DCNL >>> nC(\'aabc\', replacement=True) DCNL 35 DCNL >>> [len(list(multiset_combinations(\'aaaabbbbcccc\', i))) for i in range(5)] DCNL [1, 3, 6, 10, 15] DCNL >>> sum(_) DCNL 35 DCNL If there are ``k`` items with multiplicities ``m_1, m_2, ..., m_k`` DCNL then the total of all combinations of length 0 hrough ``k`` is the DCNL product, ``(m_1 + 1)*(m_2 + 1)*...*(m_k + 1)``. When the multiplicity DCNL of each item is 1 (i.e., k unique items) then there are 2**k DCNL combinations. For example, if there are 4 unique items, the total number DCNL of combinations is 16: DCNL >>> sum(nC(4, i) for i in range(5)) DCNL 16 DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Combination DCNL .. [2] http://tinyurl.com/cep849r DCNL See Also DCNL sympy.utilities.iterables.multiset_combinations'
def DESL(K, D): DCNL 'References: DCNL - http://ubiqx.org/cifs/SMB.html (2.8.3.4) DCNL - [MS-NLMP]: Section 6'
def rol(value, count): DCNL 'A rotate-left instruction in Python'
def _pop_header_name(row, index_col): DCNL '(header, new_data) for header rows in MultiIndex parsing'
def remux_audio(filename, title): DCNL 'Remux audio file. Insert limited metadata tags.'
def make_history_query(cls, interval): DCNL 'Build a generic query showing the history of a given aggregate.'
def makeBasicResponseCycles(cycles=10, nCorrect=4, nIncorrect=4, length=None): DCNL 'Helper function to create a basic set of responses. DCNL :Parameters: DCNL cycles : int, optional DCNL The number of response cycles to generate. One cycle consists of a DCNL number of correct and incorrect responses. DCNL Defaults to 10. DCNL nCorrect, nIncorrect : int, optional DCNL The number of correct and incorrect responses per cycle. DCNL Defaults to 4. DCNL length : int or None, optional DCNL :Returns: DCNL responses : list DCNL A list of simulated responses with length DCNL `cycles * (nCorrect + nIncorrect)`.'
def time2int(t): DCNL 'datetime转化为unix毫秒时间。'
def GenerateAndroid9Patch(referenced_images): DCNL 'Iterate over all referenced images with insets and check against the android 9-patch images.'
def is_cached(path, saltenv='base'): DCNL 'Return a boolean if the given path on the master has been cached on the DCNL minion DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' cp.is_cached salt://path/to/file'
def getWindowAnalyzeFileGivenText(fileName, gcodeText, repository=None): DCNL 'Write statistics for a gcode file.'
def rs_LambertW(p, x, prec): DCNL 'Calculate the series expansion of the principal branch of the Lambert W DCNL function. DCNL Examples DCNL >>> from sympy.polys.domains import QQ DCNL >>> from sympy.polys.rings import ring DCNL >>> from sympy.polys.ring_series import rs_LambertW DCNL >>> R, x, y = ring(\'x, y\', QQ) DCNL >>> rs_LambertW(x + x*y, x, 3) DCNL -x**2*y**2 - 2*x**2*y - x**2 + x*y + x DCNL See Also DCNL LambertW'
def _writen(fd, data): DCNL 'Write all the data to a descriptor.'
def checkGoogle(words): DCNL 'Check google for a match. DCNL @returns: a Deferred which will callback with a URL or errback with a DCNL Failure.'
def pretty_try_use_unicode(): DCNL 'See if unicode output is available and leverage it if possible'
def visitors(start_date, end_date): DCNL 'Return the number of daily unique visitors for a given date range. DCNL Returns a dict with daily numbers: DCNL {u\'2012-01-22\': 404971, DCNL u\'2012-01-23\': 434618, DCNL u\'2012-01-24\': 501687,...}'
def require_driver_initialized(driver): DCNL 'Verifies if `driver` is initialized DCNL If the driver is not initialized, an exception will be raised. DCNL :params driver: The driver instance. DCNL :raises: `exception.DriverNotInitialized`'
def copy_asset_file(source, destination, context=None, renderer=None): DCNL 'Copy an asset file to destination. DCNL On copying, it expands the template variables if context argument is given and DCNL the asset is a template file. DCNL :param source: The path to source file DCNL :param destination: The path to destination file or directory DCNL :param context: The template variables.  If not given, template files are simply copied DCNL :param renderer: The template engine.  If not given, SphinxRenderer is used by default'
def test_invalid_config(): DCNL 'An invalid config file should raise an `InvalidConfiguration` exception.'
def sample_role(name, rawtext, text, lineno, inliner, options={}, content=[]): DCNL 'Custom role. DCNL Parameters DCNL name : str DCNL The name of the role, as used in the document. DCNL rawtext : str DCNL The markup, including the role declaration. DCNL text : str DCNL The text to be marked up by the role. DCNL lineno : int DCNL The line number where `rawtext` appears. DCNL inliner : Inliner DCNL The instance that called the role. DCNL options : dict DCNL Directive options for customizatoin. DCNL content : list DCNL The directive content for customization. DCNL Returns DCNL nodes : list DCNL The list of nodes to insert into the document. DCNL msgs : list DCNL The list of system messages, perhaps an error message.'
def update_session_plot_options(**kwargs): DCNL 'Update the _session plot_options DCNL :param (str|optional) filename: What the file will be named in Plotly DCNL :param (str|optional) fileopt: \'overwrite\', \'append\', \'new\', or \'extend\' DCNL :param (bool|optional) world_readable: Make public or private. DCNL :param (dict|optional) sharing: \'public\', \'private\', \'secret\' DCNL :param (bool|optional) auto_open: For `plot`, open in new browser tab? DCNL :param (bool|optional) validate: Error locally if data doesn\'t pass?'
def automodel(doctype): DCNL 'return doctype template'
def layers(name): DCNL 'Returns a list of the IDs of layers belonging to the specified image, with DCNL the top-most layer (the one correspnding to the passed name) appearing DCNL last. DCNL name DCNL Image name or ID DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion dockerng.layers centos:7'
@pytest.mark.not_frozen DCNL def test_python2(): DCNL 'Run checkpyver with python 2.'
def item(*args, **kwargs): DCNL 'Return one or more grains DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' grains.item os DCNL salt \'*\' grains.item os osrelease oscodename DCNL Sanitized CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' grains.item host sanitize=True'
def candidates(items, artist, album, va_likely): DCNL 'Gets MusicBrainz candidates for an album from each plugin.'
def p_statement_assign(p): DCNL 'statement : NAME "=" expression'
@depends(HAS_PYVMOMI) DCNL def service_restart(host, username, password, service_name, protocol=None, port=None, host_names=None): DCNL 'Restart the named service for the given host or list of hosts. DCNL host DCNL The location of the host. DCNL username DCNL The username used to login to the host, such as ``root``. DCNL password DCNL The password used to login to the host. DCNL service_name DCNL The name of the service for which to set the policy. Supported service names are: DCNL - DCUI DCNL - TSM DCNL - SSH DCNL - lbtd DCNL - lsassd DCNL - lwiod DCNL - netlogond DCNL - ntpd DCNL - sfcbd-watchdog DCNL - snmpd DCNL - vprobed DCNL - vpxa DCNL - xorg DCNL protocol DCNL Optionally set to alternate protocol if the host is not using the default DCNL protocol. Default protocol is ``https``. DCNL port DCNL Optionally set to alternate port if the host is not using the default DCNL port. Default port is ``443``. DCNL host_names DCNL List of ESXi host names. When the host, username, and password credentials DCNL are provided for a vCenter Server, the host_names argument is required to tell DCNL vCenter the hosts for which to restart the service. DCNL If host_names is not provided, the service will be restarted for the ``host`` DCNL location instead. This is useful for when service instance connection information DCNL is used for a single ESXi host. DCNL CLI Example: DCNL .. code-block:: bash DCNL # Used for single ESXi host connection information DCNL salt \'*\' vsphere.service_restart my.esxi.host root bad-password \'ntpd\' DCNL # Used for connecting to a vCenter Server DCNL salt \'*\' vsphere.service_restart my.vcenter.location root bad-password \'ntpd\'         host_names=\'[esxi-1.host.com, esxi-2.host.com]\''
def file_list_emptydirs(load): DCNL 'Return a list of all empty directories on the master'
def string_to_timedelta(s): DCNL 'Parse a string s and return a standard datetime.timedelta object. DCNL Handles days, hours, minutes, seconds, and microseconds. DCNL Accepts strings in these formats: DCNL 2 days DCNL 14 days DCNL 4:35:00 (hours, minutes and seconds) DCNL 4:35:12.087465 (hours, minutes, seconds and microseconds) DCNL 7 days, 3:23:34 DCNL 7 days, 3:23:34.087465 DCNL .087465 (microseconds only) DCNL :raises ckan.logic.ValidationError: if the given string does not match any DCNL of the recognised formats'
def connect_user(request, access_token=None, facebook_graph=None, connect_facebook=False): DCNL 'Given a request either DCNL - (if authenticated) connect the user DCNL - login DCNL - register'
def hasDependency(module, fake_module=None): DCNL 'Use this function in your test class setUp to DCNL mock modules into your namespace DCNL :param module: The module name DCNL :type  module: ``str`` DCNL :param fake_module: The module to inject into sys.modules DCNL if not provided, a mock will be injected. If ``False`` DCNL is passed explicitly, the module injection does not DCNL occur. DCNL :type  fake_module: ``object`` DCNL hasDependency(\'super_module\')'
def _partial_regression(endog, exog_i, exog_others): DCNL 'Partial regression. DCNL regress endog on exog_i conditional on exog_others DCNL uses OLS DCNL Parameters DCNL endog : array_like DCNL exog : array_like DCNL exog_others : array_like DCNL Returns DCNL res1c : OLS results instance DCNL (res1a, res1b) : tuple of OLS results instances DCNL results from regression of endog on exog_others and of exog_i on DCNL exog_others'
def update_nested_dict(main_dict, new_dict): DCNL 'Update nested dict (only level of nesting) with new values. DCNL Unlike dict.update, this assumes that the values of the parent dict are DCNL dicts (or dict-like), so you shouldn\'t replace the nested dict if it DCNL already exists. Instead you should update the sub-dict.'
def cast(value): DCNL 'Cast value to float or int, if possible'
def get_lti_consumer(): DCNL 'Helper method for all Signature Validator tests to get an LtiConsumer object.'
def make_line_plot(dir_path, data_file_link, background_color, label_color, xy_coords, props, x_len=8, y_len=4, draw_axes=False, generate_eps=True): DCNL 'Write a line plot DCNL xy_coords: a dict of form DCNL {series_label:([x data], [y data], point_marker, color)} DCNL (code adapted from Micah Hamady\'s code)'
def pid_exists(pid): DCNL 'Check whether pid exists in the current process table.'
def get_all_credentials(tenant_id): DCNL 'Lists all the creds for a tenant'
def catch_exception_and_warn(warning=Warning, return_on_exception=None, excepts=Exception): DCNL '.. function:: warn_on_exception(func, [warning_class, return_on_failure, DCNL excepts]) DCNL attempts to call func. catches exception or exception tuple and issues DCNL a warning instead. returns value of return_on_failure when the DCNL specified exception is raised. DCNL :param func: a callable to be wrapped DCNL :param warning: the warning class to issue if an exception is DCNL raised DCNL :param return_on_exception: the default return value of the function DCNL if an exception is raised DCNL :param excepts: an exception class (or tuple of exception classes) to DCNL catch during the execution of func DCNL :type excepts: Exception or tuple of Exception classes DCNL :type warning: Warning DCNL :rtype: a callable'
def get_service(hass, config, discovery_info=None): DCNL 'Get the Command Line notification service.'
def oneOf(strs, caseless=False, useRegex=True): DCNL 'Helper to quickly define a set of alternative Literals, and makes sure to do DCNL longest-first testing when there is a conflict, regardless of the input order, DCNL but returns a C{L{MatchFirst}} for best performance. DCNL Parameters: DCNL - strs - a string of space-delimited literals, or a list of string literals DCNL - caseless - (default=False) - treat all literals as caseless DCNL - useRegex - (default=True) - as an optimization, will generate a Regex DCNL object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or DCNL if creating a C{Regex} raises an exception)'
def CanonicalPathToLocalPath(path): DCNL 'Converts the canonical paths as used by GRR to OS specific paths. DCNL Due to the inconsistencies between handling paths in windows we need to DCNL convert a path to an OS specific version prior to using it. This function DCNL should be called just before any OS specific functions. DCNL Canonical paths on windows have: DCNL - / instead of \. DCNL - Begin with /X:// where X is the drive letter. DCNL Args: DCNL path: A canonical path specification. DCNL Returns: DCNL A windows specific path.'
def const(result): DCNL 'Return a function that ignores any arguments and just returns DCNL the specified result'
def fast_denoiser(sff_fps, fasta_fp, tmp_outdir, num_cpus, primer, verbose=True, titanium=False): DCNL 'wrapper function calling methods from the Denoiser package.'
def get_path(*args): DCNL 'Returns API base path with passed arguments appended as path DCNL parameters. DCNL \'/api/v1/events\' + \'/arg1/arg2/arg3\' DCNL e.g. create_url(2, \'tracks\', 7) -> \'/api/v1/events/2/tracks/7\''
def str_translate(arr, table, deletechars=None): DCNL 'Map all characters in the string through the given mapping table. DCNL Equivalent to standard :meth:`str.translate`. Note that the optional DCNL argument deletechars is only valid if you are using python 2. For python 3, DCNL character deletion should be specified via the table argument. DCNL Parameters DCNL table : dict (python 3), str or None (python 2) DCNL In python 3, table is a mapping of Unicode ordinals to Unicode DCNL ordinals, strings, or None. Unmapped characters are left untouched. DCNL Characters mapped to None are deleted. :meth:`str.maketrans` is a DCNL helper function for making translation tables. DCNL In python 2, table is either a string of length 256 or None. If the DCNL table argument is None, no translation is applied and the operation DCNL simply removes the characters in deletechars. :func:`string.maketrans` DCNL is a helper function for making translation tables. DCNL deletechars : str, optional (python 2) DCNL A string of characters to delete. This argument is only valid DCNL in python 2. DCNL Returns DCNL translated : Series/Index of objects'
def _mobius_from_interval(I, field): DCNL 'Convert an open interval to a Mobius transform.'
def get_course_cohorts(course, assignment_type=None): DCNL 'Get a list of all the cohorts in the given course. This will include auto cohorts, DCNL regardless of whether or not the auto cohorts include any users. DCNL Arguments: DCNL course: the course for which cohorts should be returned DCNL assignment_type: cohort assignment type DCNL Returns: DCNL A list of CourseUserGroup objects. Empty if there are no cohorts. Does DCNL not check whether the course is cohorted.'
def assert_any_equal(output, alternatives): DCNL 'Assert `output` is equal to at least one element in `alternatives`'
def s3_URLise(text): DCNL 'Convert all URLs in a text into an HTML <A> tag. DCNL @param text: the text'
def runSubprocess(command, return_code=False, **kwargs): DCNL 'Run command using subprocess.Popen DCNL Similar to subprocess.check_output(), which is not available in 2.6. DCNL Run command and wait for command to complete. If the return code was zero DCNL then return, otherwise raise CalledProcessError. DCNL By default, this will also add stdout= and stderr=subproces.PIPE DCNL to the call to Popen to suppress printing to the terminal. DCNL Parameters DCNL command : list of str DCNL Command to run as subprocess (see subprocess.Popen documentation). DCNL **kwargs : dict DCNL Additional kwargs to pass to ``subprocess.Popen``. DCNL Returns DCNL stdout : str DCNL Stdout returned by the process.'
def _ls_emr_step_stderr_logs(fs, log_dir_stream, step_id=None): DCNL 'Yield matching step logs, optionally filtering by *step_id*. DCNL Yields dicts with the keys: DCNL path: path/URI of step file DCNL step_id: step_id in *path* (must match *step_id* if set)'
def cellname(rowx, colx): DCNL '(5, 7) => \'H6\''
def _translate_conductor_detail_view(context, vol, image_id=None): DCNL 'Maps keys for conductors details view.'
def xmlsec(): DCNL 'xmlsec path'
@csrf_protect DCNL def render_flatpage(request, f): DCNL 'Internal interface to the flat page view.'
def create_network_interface(name, subnet_id=None, subnet_name=None, private_ip_address=None, description=None, groups=None, region=None, key=None, keyid=None, profile=None): DCNL 'Create an Elastic Network Interface. DCNL .. versionadded:: 2016.3.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_ec2.create_network_interface my_eni subnet-12345 description=my_eni groups=[\'my_group\']'
def network_disassociate(context, network_id, disassociate_host=True, disassociate_project=True): DCNL 'Disassociate the network from project or host and raise if it does DCNL not exist.'
def prod(F, E): DCNL 'Check that the factorization of P-1 is correct. F is the list of DCNL factors of P-1, E lists the number of occurrences of each factor.'
def get_public_certificates(deadline=None): DCNL 'Get public certificates. DCNL Args: DCNL deadline: Optional deadline in seconds for the operation; the default DCNL is a system-specific deadline (typically 5 seconds). DCNL Returns: DCNL A list of PublicCertificate object.'
def _maybe_encrypt_password(role, password, encrypted=_DEFAULT_PASSWORDS_ENCRYPTION): DCNL 'pgsql passwords are md5 hashes of the string: \'md5{password}{rolename}\''
def get_pr_info(num): DCNL 'Returns the info from the GitHub API'
def _is_ignorable_404(uri): DCNL 'Returns True if a 404 at the given URL *shouldn\'t* notify the site managers.'
def qt4(): DCNL 'PyOS_InputHook python hook for Qt4. DCNL Process pending Qt events and if there\'s no pending keyboard DCNL input, spend a short slice of time (50ms) running the Qt event DCNL loop. DCNL As a Python ctypes callback can\'t raise an exception, we catch DCNL the KeyboardInterrupt and temporarily deactivate the hook, DCNL which will let a *second* CTRL+C be processed normally and go DCNL back to a clean prompt line.'
def str_to_list(s): DCNL 'Convert string to list.'
@contextlib.contextmanager DCNL def capture_output(stream, loglevel=None): DCNL 'Context manager which captures all log and console output to given `stream` while in scope.'
def build_feed(instruments, fromYear, toYear, storage, frequency=bar.Frequency.DAY, timezone=None, skipErrors=False): DCNL 'Build and load a :class:`pyalgotrade.barfeed.yahoofeed.Feed` using CSV files downloaded from Yahoo! Finance. DCNL CSV files are downloaded if they haven\'t been downloaded before. DCNL :param instruments: Instrument identifiers. DCNL :type instruments: list. DCNL :param fromYear: The first year. DCNL :type fromYear: int. DCNL :param toYear: The last year. DCNL :type toYear: int. DCNL :param storage: The path were the files will be loaded from, or downloaded to. DCNL :type storage: string. DCNL :param frequency: The frequency of the bars. Only **pyalgotrade.bar.Frequency.DAY** or **pyalgotrade.bar.Frequency.WEEK** DCNL are supported. DCNL :param timezone: The default timezone to use to localize bars. Check :mod:`pyalgotrade.marketsession`. DCNL :type timezone: A pytz timezone. DCNL :param skipErrors: True to keep on loading/downloading files in case of errors. DCNL :type skipErrors: boolean. DCNL :rtype: :class:`pyalgotrade.barfeed.yahoofeed.Feed`.'
def valid_doc_types(): DCNL 'Return a comma-separated string of valid doc types.'
def issues_closed_since(period=timedelta(days=365), project='statsmodels/statsmodels', pulls=False): DCNL 'Get all issues closed since a particular point in time. period DCNL can either be a datetime object, or a timedelta object. In the DCNL latter case, it is used as a time before the present.'
@contextmanager DCNL def expected_warnings(matching): DCNL 'Context for use in testing to catch known warnings matching regexes DCNL Parameters DCNL matching : list of strings or compiled regexes DCNL Regexes for the desired warning to catch DCNL Examples DCNL >>> from skimage import data, img_as_ubyte, img_as_float DCNL >>> with expected_warnings([\'precision loss\']): DCNL ...     d = img_as_ubyte(img_as_float(data.coins())) DCNL Notes DCNL Uses `all_warnings` to ensure all warnings are raised. DCNL Upon exiting, it checks the recorded warnings for the desired matching DCNL pattern(s). DCNL Raises a ValueError if any match was not found or an unexpected DCNL warning was raised. DCNL Allows for three types of behaviors: `and`, `or`, and `optional` matches. DCNL This is done to accomodate different build enviroments or loop conditions DCNL that may produce different warnings.  The behaviors can be combined. DCNL If you pass multiple patterns, you get an orderless `and`, where all of the DCNL warnings must be raised. DCNL If you use the `|` operator in a pattern, you can catch one of several DCNL warnings. DCNL Finally, you can use `|\A\Z` in a pattern to signify it as optional.'
def pending_deprecation(version, message=None, add_deprecation_to_docstring=True): DCNL 'Decorates a function and issues a pending deprecation warning on use. DCNL :param version: DCNL An approximate future version at which point the pending deprecation DCNL will become deprecated.  Not used in messaging. DCNL :param message: DCNL If provided, issue message in the warning.  A sensible default DCNL is used if not provided. DCNL :param add_deprecation_to_docstring: DCNL Default True.  If False, the wrapped function\'s __doc__ is left DCNL as-is.  If True, the \'message\' is prepended to the docs if DCNL provided, or sensible default if message is omitted.'
def capture_exceptions(async_result): DCNL 'Return a new decorated function that propagates the exceptions of the DCNL wrapped function to an async_result. DCNL :param async_result: An async result implementing :class:`IAsyncResult`'
def guess_filename(obj): DCNL 'Tries to guess the filename of the given object.'
def get_catalog_by_name(name): DCNL 'Grabs a catalog by name, if its there on the api key. DCNL Otherwise, an error is thrown (mirroring the API)'
def run_epoch(sess, cost_op, ops, reset, num_unrolls): DCNL 'Runs one optimization epoch.'
def _update_usage_plan_apis(plan_id, apis, op, region=None, key=None, keyid=None, profile=None): DCNL 'Helper function that updates the usage plan identified by plan_id by adding or removing it to each of the stages, specified by apis parameter. DCNL apis DCNL a list of dictionaries, where each dictionary contains the following: DCNL apiId DCNL a string, which is the id of the created API in AWS ApiGateway DCNL stage DCNL a string, which is the stage that the created API is deployed to. DCNL op DCNL \'add\' or \'remove\''
def store_media_files(document, resource, original=None): DCNL 'Store any media file in the underlying media store and update the DCNL document with unique ids of stored files. DCNL :param document: the document eventually containing the media files. DCNL :param resource: the resource being consumed by the request. DCNL :param original: original document being replaced or edited. DCNL .. versionchanged:: 0.4 DCNL Renamed to store_media_files to deconflict with new resolve_media_files. DCNL .. versionadded:: 0.3'
def init(name, cpu, mem, image, hypervisor='kvm', host=None, seed=True, nic='default', install=True, start=True, disk='default', saltenv='base', enable_vnc=False): DCNL 'This routine is used to create a new virtual machine. This routines takes DCNL a number of options to determine what the newly created virtual machine DCNL will look like. DCNL name DCNL The mandatory name of the new virtual machine. The name option is DCNL also the minion id, all minions must have an id. DCNL cpu DCNL The number of cpus to allocate to this new virtual machine. DCNL mem DCNL The amount of memory to allocate tot his virtual machine. The number DCNL is interpreted in megabytes. DCNL image DCNL The network location of the virtual machine image, commonly a location DCNL on the salt fileserver, but http, https and ftp can also be used. DCNL hypervisor DCNL The hypervisor to use for the new virtual machine. Default is \'kvm\'. DCNL host DCNL The host to use for the new virtual machine, if this is omitted DCNL Salt will automatically detect what host to use. DCNL seed DCNL Set to False to prevent Salt from seeding the new virtual machine. DCNL nic DCNL The nic profile to use, defaults to the "default" nic profile which DCNL assumes a single network interface per VM associated with the "br0" DCNL bridge on the master. DCNL install DCNL Set to False to prevent Salt from installing a minion on the new VM DCNL before it spins up. DCNL disk DCNL The disk profile to use DCNL saltenv DCNL The Salt environment to use'
def GetSingleListItem(list, default=None): DCNL 'Return the first item in the list, or "default" if the list is None DCNL or empty. Assert that the list contains at most one item.'
def try_alt_nzb(nzo): DCNL 'Try to get a new NZB if available'
def log_1_plus_exp(mat, target=None, exact=False): DCNL 'Apply log(1+exp(x)) to each element of the matrix mat. If exact is True, use DCNL slow and accurate log and exp.'
@connect_on_app_finalize DCNL def add_backend_cleanup_task(app): DCNL 'Task used to clean up expired results. DCNL If the configured backend requires periodic cleanup this task is also DCNL automatically configured to run every day at 4am (requires DCNL :program:`celery beat` to be running).'
def _morph_sparse(stc, subject_from, subject_to, subjects_dir=None): DCNL 'Morph sparse source estimates to an other subject. DCNL Parameters DCNL stc : SourceEstimate DCNL The sparse STC. DCNL subject_from : str DCNL The subject on which stc is defined. DCNL subject_to : str DCNL The target subject. DCNL subjects_dir : str DCNL Path to SUBJECTS_DIR if it is not set in the environment. DCNL Returns DCNL stc_morph : SourceEstimate DCNL The morphed source estimates.'
def getDocumentationPath(subName=''): DCNL 'Get the documentation file path.'
def fix_accounts_alt_src_langs(apps, schema_editor): DCNL 'Remove pootleprofile_id column from accounts_user_alt_src_langs DCNL After migration from 2.5.x the pootleprofile_id column is left on DCNL the m2m table accounts_user_alt_src_langs causing uniqueness issues DCNL (#3856). This migration removes the problem column on mysql.'
def get_delta(name): DCNL 'Return change over time for the requested metric'
def description(): DCNL 'Get description of brainstorm (bst_auditory) dataset.'
def register(mgr): DCNL 'Register language support with the Manager.'
def remove_comments(string): DCNL 'Remove comments in powershell script'
def test_install_from_local_directory_with_no_setup_py(script, data): DCNL 'Test installing from a local directory with no \'setup.py\'.'
def autolink_role(typ, rawtext, etext, lineno, inliner, options={}, content=[]): DCNL 'Smart linking role. DCNL Expands to \':obj:`text`\' if `text` is an object that can be imported; DCNL otherwise expands to \'*text*\'.'
def mkdirs(newdir, mode=511): DCNL 'make directory *newdir* recursively, and set *mode*.  Equivalent to :: DCNL > mkdir -p NEWDIR DCNL > chmod MODE NEWDIR'
def repeat(a, repeats, axis=None): DCNL 'Repeat arrays along an axis. DCNL Args: DCNL a (cupy.ndarray): Array to transform. DCNL repeats (int, list or tuple): The number of repeats. DCNL axis (int): The axis to repeat. DCNL Returns: DCNL cupy.ndarray: Transformed array with repeats. DCNL .. seealso:: :func:`numpy.repeat`'
def test_format(method, prec, exp_range, restricted_range, itr, stat): DCNL 'Iterate the __format__ method through many test cases.'
def runLengthEncode(stream): DCNL 'Method to encode streams using the Run-Length algorithm (NOT IMPLEMENTED YET) DCNL @param stream: A PDF stream DCNL @return: A tuple (status,statusContent), where statusContent is the encoded PDF stream in case status = 0 or an error in case status = -1'
def split_keyword(keyword): DCNL 'Split a keyword in multiple ones on any non-alphanumeric character DCNL :param string keyword: keyword DCNL :return: keywords DCNL :rtype: set'
def get_subscribers_query(stream, requesting_user): DCNL 'Build a query to get the subscribers list for a stream, raising a JsonableError if: DCNL \'realm\' is optional in stream. DCNL The caller can refine this query with select_related(), values(), etc. depending DCNL on whether it wants objects or just certain fields'
def setup_platform(hass, config, add_devices, discovery_info=None): DCNL 'Setup Hikvision camera.'
def get_parent_xblock(xblock): DCNL 'Returns the xblock that is the parent of the specified xblock, or None if it has no parent.'
def getCraftedText(fileName, text='', repository=None): DCNL 'Multiply the fill file or text.'
def multicall(conf, context, topic, msg, timeout, connection_pool): DCNL 'Make a call that returns multiple times.'
def test_install_from_wheel_installs_deps(script, data): DCNL 'Test can install dependencies of wheels'
@utils.arg('secgroup', metavar='<secgroup>', help=_('ID DCSP or DCSP name DCSP of DCSP security DCSP group.')) DCNL @deprecated_network DCNL def do_secgroup_delete(cs, args): DCNL 'Delete a security group.'
def _save_attachment(attachment, filepath): DCNL 'Saves an attachment and returns the filename.'
def downgrade_wsgi_ux_to_1x(environ): DCNL 'Return a new environ dict for WSGI 1.x from the given WSGI u.x environ.'
def restoreConfigZip(archive, targetDir): DCNL 'Restores a Config ZIP file back in place DCNL :param archive: ZIP filename DCNL :param targetDir: Directory to restore to DCNL :return: True on success, False on failure'