data_ps.descriptions.test

'Calls hooks for `setup_wizard_complete`, sets home page as `desktop` DCNL and clears cache. If wizard breaks, calls `setup_wizard_exception` hook'
'The main function.  Instantiates the module and calls process_request. DCNL :return: none'
'Return a guessed dataset by filename'
'If any node is a pending_xref, attempt to resolve it. If it cannot be DCNL resolved, replace it with its children.'
'Prepare to run system tests. DCNL If on Travis during a PR, exit the entire program; there is DCNL no need to run the system tests. DCNL If on Travis during a build for a non-PR merge to master, DCNL decrypts stored keyfile.'
'Test download exit status code when no requirements specified'
'Obtain the OS version from the show version output DCNL Print output to STDOUT'
'Output a string'
'<query> - returns the first bing image search result for <query>'
'Create a fake OptionValueContainer with appropriate defaults for the given `Optionable` type." DCNL :param type optionable_type: An :class:`pants.option.optionable.Optionable` subclass. DCNL :param **options: Keyword args representing option values explicitly set via the command line. DCNL :returns: A fake `OptionValueContainer`, ie: the value returned from `get_options()`.'
'Log likelihood for the probit'
'From github issue #1463'
'Plot of influence in regression. Plots studentized resids vs. leverage. DCNL Parameters DCNL results : results instance DCNL A fitted model. DCNL external : bool DCNL Whether to use externally or internally studentized residuals. It is DCNL recommended to leave external as True. DCNL alpha : float DCNL The alpha value to identify large studentized residuals. Large means DCNL abs(resid_studentized) > t.ppf(1-alpha/2, dof=results.df_resid) DCNL criterion : str {\'DFFITS\', \'Cooks\'} DCNL Which criterion to base the size of the points on. Options are DCNL DFFITS or Cook\'s D. DCNL size : float DCNL The range of `criterion` is mapped to 10**2 - size**2 in points. DCNL plot_alpha : float DCNL The `alpha` of the plotted points. DCNL ax : matplotlib Axes instance DCNL An instance of a matplotlib Axes. DCNL Returns DCNL fig : matplotlib figure DCNL The matplotlib figure that contains the Axes. DCNL Notes DCNL Row labels for the observations in which the leverage, measured by the DCNL diagonal of the hat matrix, is high or the residuals are large, as the DCNL combination of large residuals and a high influence value indicates an DCNL influence point. The value of large residuals can be controlled using the DCNL `alpha` parameter. Large leverage points are identified as DCNL hat_i > 2 * (df_model + 1)/nobs.'
'Send file to result server'
'In the edX wiki, we don\'t show the root_create view. Instead, we DCNL just create the root automatically if it doesn\'t exist.'
'Update an entry of block device mapping. DCNL If not existed, create a new entry'
'Get the list of available instance sizes (flavors).'
'Appends character encoding to the provided format if not already present.'
'Assign a random category to a resource'
'Temporarily set the attr on a particular object to a given value then DCNL revert when finished. DCNL One use of this is to temporarily set the read_deleted flag on a context DCNL object: DCNL with temporary_mutation(context, read_deleted="yes"): DCNL do_something_that_needed_deleted_objects()'
'Returns True if Harvard Annotation Tool is enabled for the course, DCNL False otherwise. DCNL Checks for \'textannotation\', \'imageannotation\', \'videoannotation\' in the list DCNL of advanced modules of the course.'
'Extract labels and seqs from file'
'Sørensen–Dice coefficient for comparing the similarity of two distributions, DCNL usually be used for binary image segmentation i.e. labels are binary. DCNL The coefficient = [0, 1], 1 if totally match. DCNL Parameters DCNL output : tensor DCNL A distribution with shape: [batch_size, ....], (any dimensions). DCNL target : tensor DCNL A distribution with shape: [batch_size, ....], (any dimensions). DCNL epsilon : float DCNL An optional name to attach to this layer. DCNL Examples DCNL >>> outputs = tl.act.pixel_wise_softmax(network.outputs) DCNL >>> dice_loss = 1 - tl.cost.dice_coe(outputs, y_, epsilon=1e-5) DCNL References DCNL - `wiki-dice <https://en.wikipedia.org/wiki/Sørensen–Dice_coefficient>`_'
'``create_test_db`` implementation that skips both creation and flushing DCNL The idea is to re-use the perfectly good test DB already created by an DCNL earlier test run, cutting the time spent before any tests run from 5-13s DCNL (depending on your I/O luck) down to 3.'
'Upload a mission from a file.'
'Evaluate an expression; that is, take a string of math and return a float. DCNL -Variables are passed as a dictionary from string to value. They must be DCNL python numbers. DCNL -Unary functions are passed as a dictionary from string to function.'
'Write interactive piechart DCNL data: [fraction:label,...] DCNL trunc_len: truncates labels after this many chars'
'Test whether a path is a mount point. This will catch any DCNL exceptions and translate them into a False return value DCNL Use ismount_raw to have the exceptions raised instead.'
'Get vlm_media instance title number by name or instance id. DCNL @param p_instance: a libvlc instance. DCNL @param psz_name: name of vlm media instance. DCNL @param i_instance: instance id. DCNL @return: title as number or -1 on error. DCNL @bug: will always return 0.'
'Choose the correct Information Element class.'
'Concatenate the given sequences into a list. Ignore None values. DCNL Resolve ``~`` (home dir) and environment variables, and expand globs DCNL that refer to the local filesystem. DCNL .. versionchanged:: 0.4.6 DCNL Can take single strings as well as lists.'
'Return the first IPv4 address in network DCNL Args: DCNL network (str): network in CIDR format DCNL Returns: DCNL str: first IPv4 address'
'Load the train,valid,test data for the dataset `name` and return it in DCNL sparse format. DCNL We suppose the data was created with ift6266h11/pretraitement/to_npy.py DCNL that shuffle the train. So the train should already be shuffled. DCNL name : \'avicenna\', \'harry\', \'rita\', \'sylvester\' or \'ule\' DCNL Which dataset to load DCNL normalize : bool DCNL If True, we normalize the train dataset before returning it DCNL transfer : DCNL If True also return the transfer label DCNL randomize_valid : bool DCNL Do we randomize the order of the valid set?  We always use the same DCNL random order If False, return in the same order as downloaded on the DCNL web DCNL randomize_test : bool DCNL Do we randomize the order of the test set?  We always use the same DCNL random order If False, return in the same order as downloaded on the DCNL web DCNL Returns DCNL train, valid, test : ndarrays DCNL Datasets returned if transfer = False DCNL train, valid, test, transfer : ndarrays DCNL Datasets returned if transfer = False'
'Get the description of available video subtitles. DCNL @param p_mi: the media player. DCNL @return: list containing description of available video subtitles. It must be freed with L{libvlc_track_description_list_release}().'
'Driver for ``gpu_single_block_sum`` kernel'
'Test to ensure hug\'s contains_one_of validation function works as expected to ensure presence of a field'
'Get and transfer the closest remaining nested ring.'
'@param required: Whether the selection is optional or mandatory DCNL @param realms: Whether the list should be filtered to just those DCNL belonging to a list of realm entities DCNL @param updateable: Whether the list should be filtered to just those DCNL which the user has Write access to DCNL @ToDo: Option to remove Branches DCNL @ToDo: Option to only include Branches'
'Return unique identifier for feed / sensor.'
'Configure Network DCNL CLI Example: DCNL .. code-block:: bash DCNL salt dell drac.set_network [DRAC IP] [NETMASK] [GATEWAY] DCNL salt dell drac.set_network 192.168.0.2 255.255.255.0 192.168.0.1'
'Pickle object `obj` to file `fname`. DCNL `protocol` defaults to 2 so pickled objects are compatible across DCNL Python 2.x and 3.x.'
'Split the repository-relative filename into a tuple of (branchname, DCNL branch_relative_filename). If you have no branches, this should just DCNL return (None, changed_file).'
'Merge the entries of two trees. DCNL :param path: A path to prepend to all tree entry names. DCNL :param tree1: The first Tree object to iterate, or None. DCNL :param tree2: The second Tree object to iterate, or None. DCNL :return: A list of pairs of TreeEntry objects for each pair of entries in DCNL the trees. If an entry exists in one tree but not the other, the other DCNL entry will have all attributes set to None. If neither entry\'s path is DCNL None, they are guaranteed to match.'
'Tasks to be performed after a new user registers'
'Compute ``f * a`` where ``f`` in ``GF(p)[x]`` and ``a`` in ``GF(p)``. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.galoistools import gf_mul_ground DCNL >>> gf_mul_ground([3, 2, 4], 2, 5, ZZ) DCNL [1, 4, 3]'
'Closes all review requests for the Google Code repository.'
'Verfies the encoding argument by lookup. DCNL (Directive option conversion function.) DCNL Raises ValueError for unknown encodings.'
'Set global configuration options. DCNL Each keyword argument sets one global option.'
'Get a specific item by name out of the results dict. DCNL The format of itemName is a string of dictionary keys separated by colons, DCNL each key being one level deeper into the results dict. For example, DCNL \'key1:key2\' would fetch results[\'key1\'][\'key2\']. DCNL If itemName is not found in results, then None is returned'
'Get all the inner text of a DOM node (recursively).'
'Resolve a ROS name to its global, canonical form. Private ~names DCNL are resolved relative to the node name. DCNL @param name: name to resolve. DCNL @type  name: str DCNL @param namespace_: node name to resolve relative to. DCNL @type  namespace_: str DCNL @param remappings: Map of resolved remappings. Use None to indicate no remapping. DCNL @return: Resolved name. If name is empty/None, resolve_name DCNL returns parent namespace_. If namespace_ is empty/None, DCNL @rtype: str'
'Parse the content of a wordpress post or page and separate qtranslate languages. DCNL qtranslate tags: <!--:LL-->blabla<!--:-->'
'Get item from value (value[item]). DCNL If the item is not found, return the default. DCNL Handles XML elements, regex matches and anything that has __getitem__.'
'Tries to determine the paragraph type of the document. DCNL block: Paragraphs are separated by a blank line. DCNL single: Each line is a paragraph. DCNL print: Each paragraph starts with a 2+ spaces or a tab DCNL and ends when a new paragraph is reached. DCNL unformatted: most lines have hard line breaks, few/no blank lines or indents DCNL returns block, single, print, unformatted'
'Creates a unique file name based on the specified base name. DCNL @base_name - The base name to use for the unique file name. DCNL @extension - The file extension to use for the unique file name. DCNL Returns a unique file string.'
'Takes an iterator and returns an iterator that returns only the DCNL first occurence of each entry'
'Return a new block, try to preserve dtype if possible. DCNL Parameters DCNL v : `values`, updated in-place (array like) DCNL m : `mask`, applies to both sides (array like) DCNL n : `new values` either scalar or an array like aligned with `values`'
'Helper function to avoid duplicating functionality between DCNL traverse_depth_first and traverse_topologically. DCNL If get_parents is None, do a pre-order traversal. DCNL Else, do a topological traversal. DCNL The topological traversal has a worse time complexity than DCNL pre-order does, as it needs to check whether each node\'s DCNL parents have been visited. DCNL Arguments: DCNL See description in traverse_topologically.'
'Get the quadratic path.'
'Detect Log(Softmax(x)) and replace it with LogSoftmax(x) DCNL Note: only forward pass is affected'
'This function initializes the chroma matrices used in the calculation of the chroma features'
'Annotate corresponding NXM header'
'See :meth:`I18n.gettext`.'
'Modified Weiszfeld step. DCNL This function defines one iteration step in order to approximate the DCNL spatial median (L1 median). It is a form of an iteratively re-weighted DCNL least squares method. DCNL Parameters DCNL X : array, shape = [n_samples, n_features] DCNL Training vector, where n_samples is the number of samples and DCNL n_features is the number of features. DCNL x_old : array, shape = [n_features] DCNL Current start vector. DCNL Returns DCNL x_new : array, shape = [n_features] DCNL New iteration step. DCNL References DCNL - On Computation of Spatial Median for Robust Data Mining, 2005 DCNL T. Kärkkäinen and S. Äyrämö DCNL http://users.jyu.fi/~samiayr/pdf/ayramo_eurogen05.pdf'
'Translates all translatable elements of the given exception.'
'Generate a random UUID hex string DCNL :return: a random UUID (e.g. \'0b98cf96d90447bda4b46f31aeb1508c\') DCNL :rtype: string'
'Retrieve the current time, this function is mocked out in unit testing.'
'Returns change status of command'
'Send summary to everyone'
'Sets a driver. DCNL :param drivers: Dictionary to store providers. DCNL :param provider: Id of provider to set driver for DCNL :type provider: :class:`libcloud.types.Provider` DCNL :param module: The module which contains the driver DCNL :type module: L DCNL :param klass: The driver class name DCNL :type klass:'
'Return the class name that should be used, given the name DCNL of a table. DCNL The default implementation is:: DCNL return str(tablename) DCNL Alternate implementations can be specified using the DCNL :paramref:`.AutomapBase.prepare.classname_for_table` DCNL parameter. DCNL :param base: the :class:`.AutomapBase` class doing the prepare. DCNL :param tablename: string name of the :class:`.Table`. DCNL :param table: the :class:`.Table` object itself. DCNL :return: a string class name. DCNL .. note:: DCNL In Python 2, the string used for the class name **must** be a non-Unicode DCNL object, e.g. a ``str()`` object.  The ``.name`` attribute of DCNL :class:`.Table` is typically a Python unicode subclass, so the ``str()`` DCNL function should be applied to this name, after accounting for any non-ASCII DCNL characters.'
'Get vertex given obj vertex line.'
'filter packets by there tcp-state and DCNL returns codes for specific states'
'Pretty-format a memcache.set() request. DCNL Arguments: DCNL request - The memcache.set() request object, e.g., DCNL {\'item\': [{\'Item\': {\'flags\': \'0L\', \'key\': \'memcache_key\' ... DCNL Returns: DCNL The keys of the memcache.get() response as a string. If there are DCNL multiple keys, they are separated by newline characters.'
'Compute the spline for the antiderivative (integral) of a given spline. DCNL Parameters DCNL tck : BSpline instance or a tuple of (t, c, k) DCNL Spline whose antiderivative to compute DCNL n : int, optional DCNL Order of antiderivative to evaluate. Default: 1 DCNL Returns DCNL BSpline instance or a tuple of (t2, c2, k2) DCNL Spline of order k2=k+n representing the antiderivative of the input DCNL spline. DCNL A tuple is returned iff the input argument `tck` is a tuple, otherwise DCNL a BSpline object is constructed and returned. DCNL See Also DCNL splder, splev, spalde DCNL BSpline DCNL Notes DCNL The `splder` function is the inverse operation of this function. DCNL Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo DCNL rounding error. DCNL .. versionadded:: 0.13.0 DCNL Examples DCNL >>> from scipy.interpolate import splrep, splder, splantider, splev DCNL >>> x = np.linspace(0, np.pi/2, 70) DCNL >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2) DCNL >>> spl = splrep(x, y) DCNL The derivative is the inverse operation of the antiderivative, DCNL although some floating point error accumulates: DCNL >>> splev(1.7, spl), splev(1.7, splder(splantider(spl))) DCNL (array(2.1565429877197317), array(2.1565429877201865)) DCNL Antiderivative can be used to evaluate definite integrals: DCNL >>> ispl = splantider(spl) DCNL >>> splev(np.pi/2, ispl) - splev(0, ispl) DCNL 2.2572053588768486 DCNL This is indeed an approximation to the complete elliptic integral DCNL :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`: DCNL >>> from scipy.special import ellipk DCNL >>> ellipk(0.8) DCNL 2.2572053268208538'
'Print a list of objects'
'Get the sysfs path based on the PCI address of the device. DCNL Assumes a networking device - will not check for the existence of the path.'
'Unpack an AE descriptor to a python object'
'Convert between strings and numbers.'
'Verifies that the specified incron job is absent for the specified user; only DCNL the name is matched when removing a incron job. DCNL name DCNL Unique comment describing the entry DCNL path DCNL The path that should be watched DCNL user DCNL The name of the user who\'s crontab needs to be modified, defaults to DCNL the root user DCNL mask DCNL The mask of events that should be monitored for DCNL cmd DCNL The cmd that should be executed'
'Return a list of all known user names.'
'Get a frame class from the input `frame`, which could be a frame name DCNL string, or frame class.'
'Return the ground trailing coefficient. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.densebasic import dmp_ground_TC DCNL >>> f = ZZ.map([[[1], [2, 3]]]) DCNL >>> dmp_ground_TC(f, 2, ZZ) DCNL 3'
'Generate a chromosome with random information about it.'
'Return an imdb that uses the top k proposals from the selective search DCNL IJCV code.'
'If file_ignore_regex or file_ignore_glob were given in config, DCNL compare the given file path against all of them and return True DCNL on the first match.'
'Generate a warning for an IERSRangeerror DCNL Parameters DCNL ierserr : An `~astropy.utils.iers.IERSRangeError`'
'Mean of a tensor, alongside the specified axis. DCNL # Arguments DCNL x: A tensor or variable. DCNL axis: A list of integer. Axes to compute the mean. DCNL keepdims: A boolean, whether to keep the dimensions or not. DCNL If `keepdims` is `False`, the rank of the tensor is reduced DCNL by 1 for each entry in `axis`. If `keep_dims` is `True`, DCNL the reduced dimensions are retained with length 1. DCNL # Returns DCNL A tensor with the mean of elements of `x`.'
'Morph an existing source space to a different subject. DCNL .. warning:: This can be used in place of morphing source estimates for DCNL multiple subjects, but there may be consequences in terms DCNL of dipole topology. DCNL Parameters DCNL src_from : instance of SourceSpaces DCNL Surface source spaces to morph. DCNL subject_to : str DCNL The destination subject. DCNL surf : str DCNL The brain surface to use for the new source space. DCNL subject_from : str | None DCNL The "from" subject. For most source spaces this shouldn\'t need DCNL to be provided, since it is stored in the source space itself. DCNL subjects_dir : string, or None DCNL Path to SUBJECTS_DIR if it is not set in the environment. 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 src : instance of SourceSpaces DCNL The morphed source spaces. DCNL Notes DCNL .. versionadded:: 0.10.0'
'Generic reader of line files.'
'Get the stack address for a specific ETag from the configuration file.'
'Set up the libcloud functions and check for dimensiondata configurations.'
'Return partial derivative of ``p`` with respect to ``x``. DCNL Parameters DCNL x : :class:`PolyElement` with respect to which ``p`` is differentiated. DCNL Examples DCNL >>> from sympy.polys.domains import QQ DCNL >>> from sympy.polys.rings import ring DCNL >>> from sympy.polys.ring_series import rs_diff DCNL >>> R, x, y = ring(\'x, y\', QQ) DCNL >>> p = x + x**2*y**3 DCNL >>> rs_diff(p, x) DCNL 2*x*y**3 + 1'
'Recursive subroutine for building dependency list and python path DCNL :raises: :exc:`rospkg.ResourceNotFound` If an error occurs while attempting to load package or dependencies'
'Launch tail on a set of files and merge their output into outstream. DCNL Args: DCNL follow_paths: list; Local paths to launch tail on. DCNL outstream: file; Output stream to write aggregated lines to. DCNL lastlines_dirpath: Local dirpath to record last lines seen in. DCNL waitsecs: int; Timeout for poll_tail_pipes.'
'This returns a list, which contains the value portions for the keys DCNL Ex: data = { \'a\':1, \'b\':2, \'c\':3 } DCNL keys = [\'a\', \'c\'] DCNL returns [1, 3]'
'Checks to see if the given user has access to user a particular API. DCNL Args: DCNL user: The current user email DCNL api_name: The API we\'re checking to see if the user has permission DCNL Returns: DCNL True is capable, False otherwise'
'Wrapper around c_extract that initializes py_name from storage.'
'Internal function.'
'Produce messages'
'Add to threads from the last location from loop.'
'Used to format an error message which differs DCNL slightly in 4 places.'
'train(xs, ys[, update_fn]) -> LogisticRegression DCNL Train a logistic regression classifier on a training set.  xs is a DCNL list of observations and ys is a list of the class assignments, DCNL which should be 0 or 1.  xs and ys should contain the same number DCNL of elements.  update_fn is an optional callback function that DCNL takes as parameters that iteration number and log likelihood.'
'Create a new volume DCNL .. versionadded:: 2015.8.4 DCNL name DCNL name of volume DCNL driver DCNL Driver of the volume DCNL driver_opts DCNL Options for the driver volume DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion dockerng.create_volume my_volume driver=local'
'Register the reporter classes with the linter.'
'Vertical Scharr on an edge should be a vertical line.'
'Returns context_lines before and after lineno from file. DCNL Returns (pre_context_lineno, pre_context, context_line, post_context).'
'Parses the options and stores them in the global options variable.'
'Downloads libxml2, returning the filename where the library was downloaded'
'Enqueues a task for push notification for the given update for the given course if DCNL (1) the feature is enabled and DCNL (2) push_notification is selected for the update'
'Helper function for mocking os.walk() where must test that manipulation DCNL of the returned dirs variable works as expected'
'Get all children of an object recursively as a string.'
'Construct the email using templates and then send it. DCNL `student` is the student\'s email address (a `str`), DCNL `param_dict` is a `dict` with keys DCNL `site_name`: name given to edX instance (a `str`) DCNL `registration_url`: url for registration (a `str`) DCNL `display_name` : display name of a course (a `str`) DCNL `course_id`: id of course (a `str`) DCNL `auto_enroll`: user input option (a `str`) DCNL `course_url`: url of course (a `str`) DCNL `email_address`: email of student (a `str`) DCNL `full_name`: student full name (a `str`) DCNL `message`: type of email to send and template to use (a `str`) DCNL `is_shib_course`: (a `boolean`) DCNL `language` is the language used to render the email. If None the language DCNL of the currently-logged in user (that is, the user sending the email) will DCNL be used. DCNL Returns a boolean indicating whether the email was sent successfully.'
'Given the directory of a profiler client, find the client log path.'
'Execute command in a subshell, return status code.'
'Raises a webob.exc.HTTPConflict instance containing a message DCNL appropriate to return via the API based on the original DCNL InstanceInvalidState exception.'
'returns the ith order statistic DCNL in the array a in linear time DCNL >>> from random import sample DCNL >>> test_cases = [sample(range(20), 10) for i in range(10)] DCNL >>> orders = [randint(0, 9) for i in range(10)] DCNL >>> results = [sorted(test_cases[i])[orders[i]] == random_selection(test_cases[i], 0, len(test_cases[i])-1, orders[i]) for i in range(10)] DCNL >>> print sum(results) DCNL 10'
'Script to deprecate any repositories that are older than n days, and have been empty since creation.'
'This routine produces a list of (source, dest) non-Python (i.e. data) DCNL files which reside in package. Its results can be directly assigned to DCNL ``datas`` in a hook script; see, for example, hook-sphinx.py. The DCNL package parameter must be a string which names the package. DCNL By default, all Python executable files (those ending in .py, .pyc, DCNL and so on) will NOT be collected; setting the include_py_files DCNL argument to True collects these files as well. This is typically used DCNL with Python routines (such as those in pkgutil) that search a given DCNL directory for Python executable files then load them as extensions or DCNL plugins. The optional subdir give a subdirectory relative to package to DCNL search, which is helpful when submodules are imported at run-time from a DCNL directory lacking __init__.py DCNL This function does not work on zipped Python eggs. DCNL This function is used only for hook scripts, but not by the body of DCNL PyInstaller.'
'Return the message `plaintext` encrypted. DCNL The encrypted message will have its salt prepended and will be URL encoded DCNL to make it suitable for use in URLs and Cookies. DCNL NOTE: this function is here for backwards compatibility. Please do not DCNL use it for new code.'
'Parses a standard Swift ACL string into a referrers list and groups list. DCNL See :func:`clean_acl` for documentation of the standard Swift ACL format. DCNL :param acl_string: The standard Swift ACL string to parse. DCNL :returns: A tuple of (referrers, groups) where referrers is a list of DCNL referrer designations (without the leading .r:) and groups is a DCNL list of groups to allow access.'
'Create a process in the same way as popen_sp, but patch the file DCNL descriptors so they can be accessed from Python/gevent DCNL in a non-blocking manner.'
'Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``. DCNL Examples DCNL >>> from sympy.polys import ring, ZZ DCNL >>> R, x = ring("x", ZZ) DCNL >>> R.dup_transform(x**2 - 2*x + 1, x**2 + 1, x - 1) DCNL x**4 - 2*x**3 + 5*x**2 - 4*x + 4'
'Save a collection item to database DCNL @param Collection collection collection DCNL @param Item item collection item'
'Creates and returns the Serato script'
'REST Controller DCNL @ToDo: Filter out fulfilled Items?'
'Check status of a particular service on a host on it in Nagios. DCNL By default statuses are returned in a numeric format. DCNL Parameters: DCNL hostname DCNL The hostname to check the status of the service in Nagios. DCNL service DCNL The service to check the status of in Nagios. DCNL numeric DCNL Turn to false in order to return status in text format DCNL (\'OK\' instead of 0, \'Warning\' instead of 1 etc) DCNL :return: status:     \'OK\', \'Warning\', \'Critical\' or \'Unknown\' DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nagios_rpc.service_status hostname=webserver.domain.com service=\'HTTP\' DCNL salt \'*\' nagios_rpc.service_status hostname=webserver.domain.com service=\'HTTP\' numeric=False'
'Display the text for this problem'
'This is a backwards compatibility function.  Its result is the same as DCNL calling:: DCNL request.current_route_url(*elements, **kw) DCNL See :meth:`pyramid.request.Request.current_route_url` for more DCNL information.'
'Try to clean powershell script (perhaps in the future \'obfuscation\'...). DCNL Comments are deteleted and some strings are replaced in some powershell functions to bypass AV detection'
'Rewrite metadata since llvm3.6 dropped the "metadata" type prefix.'
'Returns an :class:`.ArrowFactory` for the specified :class:`Arrow <arrow.arrow.Arrow>` DCNL or derived type. DCNL :param type: the type, :class:`Arrow <arrow.arrow.Arrow>` or derived.'
'Get filesize and metadata for all streams, return dict.'
'Return a (tsig_rdata, mac, ctx) tuple containing the HMAC TSIG rdata DCNL for the input parameters, the HMAC MAC calculated by applying the DCNL TSIG signature algorithm, and the TSIG digest context. DCNL @rtype: (string, string, hmac.HMAC object) DCNL @raises ValueError: I{other_data} is too long DCNL @raises NotImplementedError: I{algorithm} is not supported'
'Return an error response with multiple errors. DCNL `status` is an integer representing an HTTP status code corresponding to an DCNL error response. DCNL `errors` is a list of error dictionaries, each of which must satisfy the DCNL requirements of the JSON API specification. DCNL This function returns a two-tuple whose left element is a dictionary DCNL representing a JSON API response document and whose right element is DCNL simply `status`. DCNL The keys within each error object are described in the `Errors`_ DCNL section of the JSON API specification. DCNL .. _Errors: http://jsonapi.org/format/#errors'
'Computes the indefinite integral of ``f`` in ``x_j`` in ``K[X]``. DCNL Examples DCNL >>> from sympy.polys import ring, QQ DCNL >>> R, x,y = ring("x,y", QQ) DCNL >>> R.dmp_integrate_in(x + 2*y, 1, 0) DCNL 1/2*x**2 + 2*x*y DCNL >>> R.dmp_integrate_in(x + 2*y, 1, 1) DCNL x*y + y**2'
'Dumps all thread stacks to a file'
'Return the metadata for the books as a JSON dictionary. DCNL Query parameters: ?ids=all&category_urls=true&id_is_uuid=false&device_for_template=None DCNL If category_urls is true the returned dictionary also contains a DCNL mapping of category (field) names to URLs that return the list of books in the DCNL given category. DCNL If id_is_uuid is true then the book_id is assumed to be a book uuid instead.'
'return a rendered network template for the given network_info DCNL :param network_info: DCNL :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info` DCNL Note: this code actually depends on the legacy network_info, but will DCNL convert the type itself if necessary.'
'Clean up standarddir arguments before and after each test.'
'Updates the remote repos database. DCNL full : False DCNL Set to ``True`` to force a refresh of the pkg DB from all publishers, DCNL regardless of the last refresh time. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.refresh_db DCNL salt \'*\' pkg.refresh_db full=True'
'When time zone support is enabled, convert naive datetimes DCNL entered in the current time zone to aware datetimes.'
'A helper for defining boolean options.'
'Load language setting from language config file if it exists, otherwise DCNL try to use the local settings if Spyder provides a translation, or DCNL return the default if no translation provided.'
'Decorate a function without preserving the name of the original function. DCNL Always return a function with the same name.'
'Search the environment for the relative path.'
'Load the China smoking/lung cancer data and return a Dataset class. DCNL Returns DCNL Dataset instance: DCNL See DATASET_PROPOSAL.txt for more information.'
'Returns a generator of flattened nested containers DCNL For example: DCNL >>> from matplotlib.cbook import flatten DCNL >>> l = ((\'John\', [\'Hunter\']), (1, 23), [[([42, (5, 23)], )]]) DCNL >>> print(list(flatten(l))) DCNL [\'John\', \'Hunter\', 1, 23, 42, 5, 23] DCNL By: Composite of Holger Krekel and Luther Blissett DCNL From: https://code.activestate.com/recipes/121294/ DCNL and Recipe 1.12 in cookbook'
'Determine if the line is intersecting loops.'
'Takes the output of compare_expected, and returns a string DCNL description of the differences.'
'View a tax'
'Run some function, and return (RunTimeInSeconds,Result)'
'Converts an HTTP date string to a datetime instance. DCNL Args: DCNL http_date (str): An RFC 1123 date string, e.g.: DCNL "Tue, 15 Nov 1994 12:45:26 GMT". DCNL obs_date (bool, optional): Support obs-date formats according to DCNL RFC 7231, e.g.: DCNL "Sunday, 06-Nov-94 08:49:37 GMT" (default ``False``). DCNL Returns: DCNL datetime: A UTC datetime instance corresponding to the given DCNL HTTP date. DCNL Raises: DCNL ValueError: http_date doesn\'t match any of the available time formats'
'Setup the USPS platform.'
'Enable flocker-control service. We need to be able to indicate whether DCNL we want to start the service, when we are deploying a new cluster, DCNL or if we want to restart it, when we are using an existent cluster in DCNL managed mode. DCNL :param bytes distribution: name of the distribution where the flocker DCNL controls currently runs. The supported distros are: DCNL - ubuntu-14.04 DCNL - ubuntu-16.04 DCNL - centos-<centos version> DCNL :param bytes action: action to perform with the flocker control service. DCNL Currently, we support: DCNL -start DCNL -stop DCNL :raises ``DistributionNotSupported`` if the ``distribution`` is not DCNL currently supported DCNL ``UnknownAction`` if the action passed is not a valid one'
'Return a conn object for the passed VM data'
'Returns the autocorrelation of signal s at all lags. Adheres to the DCNL definition r(k) = E{s(n)s*(n-k)} where E{} is the expectation operator.'
'Check if user has access to a course. DCNL Arguments: DCNL user (User): the user whose course access we are checking. DCNL action (string): The action that is being checked. DCNL courselike (CourseDescriptor or CourseOverview): The object DCNL representing the course that the user wants to access. DCNL Valid actions: DCNL \'load\' -- load the courseware, see inside the course DCNL \'load_forum\' -- can load and contribute to the forums (one access level for now) DCNL \'load_mobile\' -- can load from a mobile context DCNL \'enroll\' -- enroll.  Checks for enrollment window. DCNL \'see_exists\' -- can see that the course exists. DCNL \'staff\' -- staff access to course. DCNL \'see_in_catalog\' -- user is able to see the course listed in the course catalog. DCNL \'see_about_page\' -- user is able to see the course about page.'
'Add special start token(id) in the beginning of each sequence. DCNL Examples DCNL >>> sentences_ids = [[4,3,5,3,2,2,2,2], [5,3,9,4,9,2,2,3]] DCNL >>> sentences_ids = sequences_add_start_id(sentences_ids, start_id=2) DCNL ... [[2, 4, 3, 5, 3, 2, 2, 2, 2], [2, 5, 3, 9, 4, 9, 2, 2, 3]] DCNL >>> sentences_ids = sequences_add_start_id(sentences_ids, start_id=2, remove_last=True) DCNL ... [[2, 4, 3, 5, 3, 2, 2, 2], [2, 5, 3, 9, 4, 9, 2, 2]] DCNL - For Seq2seq DCNL >>> input = [a, b, c] DCNL >>> target = [x, y, z] DCNL >>> decode_seq = [start_id, a, b] <-- sequences_add_start_id(input, start_id, True)'
'Test either if an error is raised when sample is called before DCNL fitting'
'Proxy for either true_div or int_div, depending on types of x, y.'
'Set effective user id.'
'Create a Python list from a native set\'s items.'
'Get the one-line summary out of a module file.'
'Function for deleting Autoscale Groups'
'Get system default Download directory, append mps dir.'
'List all floating IP pools DCNL .. versionadded:: 2016.3.0'
'Delete a DynamoDB table. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_dynamodb.delete table_name region=us-east-1'
'Given a Python qualified name, this function yields a 2-tuple of the most DCNL specific qualified name first, followed by the next-most-specific qualified DCNL name, and so on, paired with the remainder of the qualified name. DCNL @param qualName: A Python qualified name. DCNL @type qualName: L{str}'
'Tests special characters are unique.'
'Ensure the SQS queue exists. DCNL name DCNL Name of the SQS queue. DCNL attributes DCNL A dict of key/value SQS attributes. 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.'
'Return [a, b, r] for p.match(a + b*sqrt(r)) where, in addition to DCNL matching, sqrt(r) also has then maximal sqrt_depth among addends of p. DCNL Examples DCNL >>> from sympy.functions.elementary.miscellaneous import sqrt DCNL >>> from sympy.simplify.sqrtdenest import _sqrt_match DCNL >>> _sqrt_match(1 + sqrt(2) + sqrt(2)*sqrt(3) +  2*sqrt(1+sqrt(5))) DCNL [1 + sqrt(2) + sqrt(6), 2, 1 + sqrt(5)]'
'Event edit'
'Check if a request is a media request.'
'Finds a list of subnets, each identified either by a raw ID, a unique DCNL \'Name\' tag, or a CIDR such as 10.0.0.0/8. DCNL Note that this function is duplicated in other ec2 modules, and should DCNL potentially be moved into potentially be moved into a shared module_utils'
'Test list data with input mask or mask_value (#3268).'
'Read data from a lush file with uint8 data (scalar). DCNL Note: When you write a scalar from Koray\'s matlab code it always makes DCNL everything 3D. Writing it straight from lush you might be able to get DCNL a true scalar'
'If path is relative, return the given path inside the project data dir, DCNL otherwise return the path unmodified'
'Bind an interface to a zone DCNL .. versionadded:: 2016.3.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' firewalld.add_interface zone eth0'
'A dylib name can take one of the following four forms: DCNL Location/Name.SomeVersion_Suffix.dylib DCNL Location/Name.SomeVersion.dylib DCNL Location/Name_Suffix.dylib DCNL Location/Name.dylib DCNL returns None if not found or a mapping equivalent to: DCNL dict( DCNL location=\'Location\', DCNL name=\'Name.SomeVersion_Suffix.dylib\', DCNL shortname=\'Name\', DCNL version=\'SomeVersion\', DCNL suffix=\'Suffix\', DCNL Note that SomeVersion and Suffix are optional and may be None DCNL if not present.'
'Takes as input a Sum instance and returns the difference between the sum DCNL with the upper index incremented by 1 and the original sum. For example, DCNL if S(n) is a sum, then finite_diff_kauers will return S(n + 1) - S(n). DCNL Examples DCNL >>> from sympy.series.kauers import finite_diff_kauers DCNL >>> from sympy import Sum DCNL >>> from sympy.abc import x, y, m, n, k DCNL >>> finite_diff_kauers(Sum(k, (k, 1, n))) DCNL n + 1 DCNL >>> finite_diff_kauers(Sum(1/k, (k, 1, n))) DCNL 1/(n + 1) DCNL >>> finite_diff_kauers(Sum((x*y**2), (x, 1, n), (y, 1, m))) DCNL (m + 1)**2*(n + 1) DCNL >>> finite_diff_kauers(Sum((x*y), (x, 1, m), (y, 1, n))) DCNL (m + 1)*(n + 1)'
'Get a list of dictionaries with information about disks on this system. DCNL :param std_mounts_only: Whether the function should return only disks that DCNL have a mount point defined (True) or even devices that doesn\'t DCNL (False). DCNL :param get_all_disks: Whether the function should return only partitioned DCNL disks (False) or return every disk, regardless of being partitioned DCNL or not (True). DCNL :return: List of dictionaries with disk information (see more below). DCNL The \'disk_list\' array returned by get_disk_list() has an entry for each DCNL disk drive we find on the box. Each of these entries is a map with the DCNL following 3 string values: DCNL \'device\'      disk device name (i.e. the part after /dev/) DCNL \'mountpt\'     disk mount path DCNL \'tunable\'     disk name for setting scheduler tunables (/sys/block/sd??) DCNL The last value is an integer that indicates the current mount status DCNL of the drive: DCNL \'mounted\'     0 = not currently mounted DCNL 1 = mounted r/w on the expected path DCNL -1 = mounted readonly or at an unexpected path DCNL When the \'std_mounts_only\' argument is True we don\'t include drives DCNL mounted on \'unusual\' mount points in the result. If a given device is DCNL partitioned, it will return all partitions that exist on it. If it\'s not, DCNL it will return the device itself (ie, if there are /dev/sdb1 and /dev/sdb2, DCNL those will be returned but not /dev/sdb. if there is only a /dev/sdc, that DCNL one will be returned).'
'Checks if AFNI is available'
'The entry point for CodeDeploy high level commands.'
'Resets the state of the random number generator with a seed. DCNL This function resets the state of the global random number generator for DCNL the current device. Be careful that generators for other devices are not DCNL affected. DCNL Args: DCNL seed (None or int): Seed for the random number generator. If ``None``, DCNL it uses :func:`os.urandom` if available or :func:`time.clock` DCNL otherwise. Note that this function does not support seeding by an DCNL integer array.'
'Checks to ensure our PEP_REPO_PATH is setup correctly'
'Display a confirmation prompt.'
'Returns a key whose value in `dictionary` is `element` DCNL or, if none exists, None. DCNL >>> d = {1:2, 3:4} DCNL >>> dictfind(d, 4) DCNL 3 DCNL >>> dictfind(d, 5)'
'The main loop of the program that runs when we\'re not in stdin mode.'
'Remove the root Tk widget from the reactor. DCNL Call this before destroy()ing the root widget.'
'Compute mutual information between two variables. DCNL This is a simple wrapper which selects a proper function to call based on DCNL whether `x` and `y` are discrete or not.'
'Helper for checking bem surface sizes.'
'Given a block, returns the block\'s URL name. DCNL Arguments: DCNL block (XModuleMixin|CourseOverview|BlockStructureBlockData): DCNL Block that is being accessed'
'Creates a `storage` object from dictionary d, raising `KeyError` if DCNL d doesn\'t have all of the keys in `requireds` and using the default DCNL values for keys found in `defaults`. DCNL For example, `storify({\'a\':1, \'c\':3}, b=2, c=0)` will return the equivalent of DCNL `storage({\'a\':1, \'b\':2, \'c\':3})`.'
'Peform a login. This only works if session is currently not logged DCNL in. This will also automatically throttle too quick attempts. DCNL Kwargs: DCNL name (str): Player name DCNL password (str): Plain-text password'
'Butler-Portugal algorithm for tensor canonicalization with dummy indices DCNL dummies DCNL list of lists of dummy indices, DCNL one list for each type of index; DCNL the dummy indices are put in order contravariant, covariant DCNL [d0, -d0, d1, -d1, ...]. DCNL sym DCNL list of the symmetries of the index metric for each type. DCNL possible symmetries of the metrics DCNL * 0     symmetric DCNL * 1     antisymmetric DCNL * None  no symmetry DCNL b_S DCNL base of a minimal slot symmetry BSGS. DCNL sgens DCNL generators of the slot symmetry BSGS. DCNL S_transversals DCNL transversals for the slot BSGS. DCNL g DCNL permutation representing the tensor. DCNL Return 0 if the tensor is zero, else return the array form of DCNL the permutation representing the canonical form of the tensor. DCNL A tensor with dummy indices can be represented in a number DCNL of equivalent ways which typically grows exponentially with DCNL the number of indices. To be able to establish if two tensors DCNL with many indices are equal becomes computationally very slow DCNL in absence of an efficient algorithm. DCNL The Butler-Portugal algorithm [3] is an efficient algorithm to DCNL put tensors in canonical form, solving the above problem. DCNL Portugal observed that a tensor can be represented by a permutation, DCNL and that the class of tensors equivalent to it under slot and dummy DCNL symmetries is equivalent to the double coset `D*g*S` DCNL (Note: in this documentation we use the conventions for multiplication DCNL of permutations p, q with (p*q)(i) = p[q[i]] which is opposite DCNL to the one used in the Permutation class) DCNL Using the algorithm by Butler to find a representative of the DCNL double coset one can find a canonical form for the tensor. DCNL To see this correspondence, DCNL let `g` be a permutation in array form; a tensor with indices `ind` DCNL (the indices including both the contravariant and the covariant ones) DCNL can be written as DCNL `t = T(ind[g[0],..., ind[g[n-1]])`, DCNL where `n= len(ind)`; DCNL `g` has size `n + 2`, the last two indices for the sign of the tensor DCNL (trick introduced in [4]). DCNL A slot symmetry transformation `s` is a permutation acting on the slots DCNL `t -> T(ind[(g*s)[0]],..., ind[(g*s)[n-1]])` DCNL A dummy symmetry transformation acts on `ind` DCNL `t -> T(ind[(d*g)[0]],..., ind[(d*g)[n-1]])` DCNL Being interested only in the transformations of the tensor under DCNL these symmetries, one can represent the tensor by `g`, which transforms DCNL as DCNL `g -> d*g*s`, so it belongs to the coset `D*g*S`. DCNL Let us explain the conventions by an example. DCNL Given a tensor `T^{d3 d2 d1}{}_{d1 d2 d3}` with the slot symmetries DCNL `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}` DCNL `T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5}` DCNL and symmetric metric, find the tensor equivalent to it which DCNL is the lowest under the ordering of indices: DCNL lexicographic ordering `d1, d2, d3` then and contravariant index DCNL before covariant index; that is the canonical form of the tensor. DCNL The canonical form is `-T^{d1 d2 d3}{}_{d1 d2 d3}` DCNL obtained using `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}`. DCNL To convert this problem in the input for this function, DCNL use the following labelling of the index names DCNL (- for covariant for short) `d1, -d1, d2, -d2, d3, -d3` DCNL `T^{d3 d2 d1}{}_{d1 d2 d3}` corresponds to `g = [4, 2, 0, 1, 3, 5, 6, 7]` DCNL where the last two indices are for the sign DCNL `sgens = [Permutation(0, 2)(6, 7), Permutation(0, 4)(6, 7)]` DCNL sgens[0] is the slot symmetry `-(0, 2)` DCNL `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}` DCNL sgens[1] is the slot symmetry `-(0, 4)` DCNL `T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5}` DCNL The dummy symmetry group D is generated by the strong base generators DCNL `[(0, 1), (2, 3), (4, 5), (0, 1)(2, 3),(2, 3)(4, 5)]` DCNL The dummy symmetry acts from the left DCNL `d = [1, 0, 2, 3, 4, 5, 6, 7]`  exchange `d1 -> -d1` DCNL `T^{d3 d2 d1}{}_{d1 d2 d3} == T^{d3 d2}{}_{d1}{}^{d1}{}_{d2 d3}` DCNL `g=[4, 2, 0, 1, 3, 5, 6, 7]  -> [4, 2, 1, 0, 3, 5, 6, 7] = _af_rmul(d, g)` DCNL which differs from `_af_rmul(g, d)`. DCNL The slot symmetry acts from the right DCNL `s = [2, 1, 0, 3, 4, 5, 7, 6]`  exchanges slots 0 and 2 and changes sign DCNL `T^{d3 d2 d1}{}_{d1 d2 d3} == -T^{d1 d2 d3}{}_{d1 d2 d3}` DCNL `g=[4,2,0,1,3,5,6,7]  -> [0, 2, 4, 1, 3, 5, 7, 6] = _af_rmul(g, s)` DCNL Example in which the tensor is zero, same slot symmetries as above: DCNL `T^{d3}{}_{d1,d2}{}^{d1}{}_{d3}{}^{d2}` DCNL `= -T^{d3}{}_{d1,d3}{}^{d1}{}_{d2}{}^{d2}`   under slot symmetry `-(2,4)`; DCNL `= T_{d3 d1}{}^{d3}{}^{d1}{}_{d2}{}^{d2}`    under slot symmetry `-(0,2)`; DCNL `= T^{d3}{}_{d1 d3}{}^{d1}{}_{d2}{}^{d2}`    symmetric metric; DCNL `= 0`  since two of these lines have tensors differ only for the sign. DCNL The double coset D*g*S consists of permutations `h = d*g*s` corresponding DCNL to equivalent tensors; if there are two `h` which are the same apart DCNL from the sign, return zero; otherwise DCNL choose as representative the tensor with indices DCNL ordered lexicographically according to `[d1, -d1, d2, -d2, d3, -d3]` DCNL that is `rep = min(D*g*S) = min([d*g*s for d in D for s in S])` DCNL The indices are fixed one by one; first choose the lowest index DCNL for slot 0, then the lowest remaining index for slot 1, etc. DCNL Doing this one obtains a chain of stabilizers DCNL `S -> S_{b0} -> S_{b0,b1} -> ...` and DCNL `D -> D_{p0} -> D_{p0,p1} -> ...` DCNL where `[b0, b1, ...] = range(b)` is a base of the symmetric group; DCNL the strong base `b_S` of S is an ordered sublist of it; DCNL therefore it is sufficient to compute once the DCNL strong base generators of S using the Schreier-Sims algorithm; DCNL the stabilizers of the strong base generators are the DCNL strong base generators of the stabilizer subgroup. DCNL `dbase = [p0, p1, ...]` is not in general in lexicographic order, DCNL so that one must recompute the strong base generators each time; DCNL however this is trivial, there is no need to use the Schreier-Sims DCNL algorithm for D. DCNL The algorithm keeps a TAB of elements `(s_i, d_i, h_i)` DCNL where `h_i = d_i*g*s_i` satisfying `h_i[j] = p_j` for `0 <= j < i` DCNL starting from `s_0 = id, d_0 = id, h_0 = g`. DCNL The equations `h_0[0] = p_0, h_1[1] = p_1,...` are solved in this order, DCNL choosing each time the lowest possible value of p_i DCNL For `j < i` DCNL `d_i*g*s_i*S_{b_0,...,b_{i-1}}*b_j = D_{p_0,...,p_{i-1}}*p_j` DCNL so that for dx in `D_{p_0,...,p_{i-1}}` and sx in DCNL `S_{base[0],...,base[i-1]}` one has `dx*d_i*g*s_i*sx*b_j = p_j` DCNL Search for dx, sx such that this equation holds for `j = i`; DCNL it can be written as `s_i*sx*b_j = J, dx*d_i*g*J = p_j` DCNL `sx*b_j = s_i**-1*J; sx = trace(s_i**-1, S_{b_0,...,b_{i-1}})` DCNL `dx**-1*p_j = d_i*g*J; dx = trace(d_i*g*J, D_{p_0,...,p_{i-1}})` DCNL `s_{i+1} = s_i*trace(s_i**-1*J, S_{b_0,...,b_{i-1}})` DCNL `d_{i+1} = trace(d_i*g*J, D_{p_0,...,p_{i-1}})**-1*d_i` DCNL `h_{i+1}*b_i = d_{i+1}*g*s_{i+1}*b_i = p_i` DCNL `h_n*b_j = p_j` for all j, so that `h_n` is the solution. DCNL Add the found `(s, d, h)` to TAB1. DCNL At the end of the iteration sort TAB1 with respect to the `h`; DCNL if there are two consecutive `h` in TAB1 which differ only for the DCNL sign, the tensor is zero, so return 0; DCNL if there are two consecutive `h` which are equal, keep only one. DCNL Then stabilize the slot generators under `i` and the dummy generators DCNL under `p_i`. DCNL Assign `TAB = TAB1` at the end of the iteration step. DCNL At the end `TAB` contains a unique `(s, d, h)`, since all the slots DCNL of the tensor `h` have been fixed to have the minimum value according DCNL to the symmetries. The algorithm returns `h`. DCNL It is important that the slot BSGS has lexicographic minimal base, DCNL otherwise there is an `i` which does not belong to the slot base DCNL for which `p_i` is fixed by the dummy symmetry only, while `i` DCNL is not invariant from the slot stabilizer, so `p_i` is not in DCNL general the minimal value. DCNL This algorithm differs slightly from the original algorithm [3]: DCNL the canonical form is minimal lexicographically, and DCNL the BSGS has minimal base under lexicographic order. DCNL Equal tensors `h` are eliminated from TAB. DCNL Examples DCNL >>> from sympy.combinatorics.permutations import Permutation DCNL >>> from sympy.combinatorics.perm_groups import PermutationGroup DCNL >>> from sympy.combinatorics.tensor_can import double_coset_can_rep, get_transversals DCNL >>> gens = [Permutation(x) for x in [[2, 1, 0, 3, 4, 5, 7, 6], [4, 1, 2, 3, 0, 5, 7, 6]]] DCNL >>> base = [0, 2] DCNL >>> g = Permutation([4, 2, 0, 1, 3, 5, 6, 7]) DCNL >>> transversals = get_transversals(base, gens) DCNL >>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g) DCNL [0, 1, 2, 3, 4, 5, 7, 6] DCNL >>> g = Permutation([4, 1, 3, 0, 5, 2, 6, 7]) DCNL >>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g) DCNL 0'
'Setup root logger for Sphinx'
'Task to move built documentation to web servers DCNL :param version_pk: Version id to sync files for DCNL :param hostname: Hostname to sync to DCNL :param html: Sync HTML DCNL :type html: bool DCNL :param localmedia: Sync local media files DCNL :type localmedia: bool DCNL :param search: Sync search files DCNL :type search: bool DCNL :param pdf: Sync PDF files DCNL :type pdf: bool DCNL :param epub: Sync ePub files DCNL :type epub: bool'
'Generates a unique reset password token for the specified user. DCNL :param user: The user to work with'
'Converts a #rrggbb color to the tuple (red, green, blue).'
'Suggest terms starting with given input'
'Assign `assignee_id` to the given role and subscribes the assignee DCNL to future exploration updates. DCNL The caller should ensure that assignee_id corresponds to a valid user in DCNL the system. DCNL Args: DCNL - committer_id: str. The user_id of the user who is performing the action. DCNL - exploration_id: str. The exploration id. DCNL - assignee_id: str. The user_id of the user whose role is being changed. DCNL - new_role: str. The name of the new role: either \'owner\', \'editor\' or DCNL \'viewer\'.'
'Manages the communication between this process and the worker processes. DCNL This function is run in a local thread. DCNL Args: DCNL executor_reference: A weakref.ref to the ProcessPoolExecutor that owns DCNL this thread. Used to determine if the ProcessPoolExecutor has been DCNL garbage collected and that this function can exit. DCNL process: A list of the multiprocessing.Process instances used as DCNL workers. DCNL pending_work_items: A dict mapping work ids to _WorkItems e.g. DCNL {5: <_WorkItem...>, 6: <_WorkItem...>, ...} DCNL work_ids_queue: A queue.Queue of work ids e.g. Queue([5, 6, ...]). DCNL call_queue: A multiprocessing.Queue that will be filled with _CallItems DCNL derived from _WorkItems for processing by the process workers. DCNL result_queue: A multiprocessing.Queue of _ResultItems generated by the DCNL process workers.'
'Benchmark *func* and print out its runtime.'
'A demonstration showing how Trees and Trees can be DCNL used.  This demonstration creates a Tree, and loads a DCNL Tree from the Treebank corpus, DCNL and shows the results of calling several of their methods.'
'This optimization makes the folowing changes in the graph: DCNL T.mul(A,T.switch(cond,0,iff),B) -->  T.switch(cond,0,T.mul(A,B,iff)) DCNL T.mul(A,T.switch(cond,ift,0),B) -->  T.switch(cond,T.mul(A,B,ift),0) DCNL A and B being several (or none) symbolic variables. DCNL This is useful because A and B may not be numerically stable and give DCNL NaN or inf values for cases where the switch returns 0. DCNL With this optimization T.grad(T.switch(...)) has the right behavior. DCNL Examples DCNL x -> f(x) DCNL x -> g(x) DCNL y = T.switch(cond,f(x),g(x)) DCNL **without the optimization DCNL T.grad(y,x) -> grad(f(x),x) * grad(y,f(x)) +  grad(g(x),x) * grad(y,g(x)) DCNL **with the optimization DCNL T.grad(y,x) -> switch(cond,grad(f(x),x), 0) + switch(cond,0,grad(g(x),x)) DCNL This will be particularly useful for the lazyif because we skip DCNL an entire part of the graph.'
'Number of due follow-ups'
'removes the string `remove` from the right of `text`'
'Craft a file, display dialog.'
'Recursively move a file or directory to another location. This is DCNL similar to the Unix "mv" command. DCNL If the destination is a directory or a symlink to a directory, the source DCNL is moved inside the directory. The destination path must not already DCNL exist. DCNL If the destination already exists but is not a directory, it may be DCNL overwritten depending on os.rename() semantics. DCNL If the destination is on our current filesystem, then rename() is used. DCNL Otherwise, src is copied to the destination and then removed. DCNL A lot more could be done here...  A look at a mv.c shows a lot of DCNL the issues this implementation glosses over.'
'Convert an Internationalized Resource Identifier (IRI) portion to a URI DCNL portion that is suitable for inclusion in a URL. DCNL This is the algorithm from section 3.1 of RFC 3987.  However, since we are DCNL assuming input is either UTF-8 or unicode already, we can simplify things a DCNL little from the full method. DCNL Returns an ASCII string containing the encoded result.'
'Perform the update check, and report to the user. DCNL Arguments: DCNL prerelease(bool): Whether or not to include pre-release versions. DCNL Returns: DCNL A list of arguments to the update command. DCNL >>> from packaging.version import Version DCNL >>> pwnlib.update.current_version = Version("999.0.0") DCNL >>> print perform_check() DCNL None DCNL >>> pwnlib.update.current_version = Version("0.0.0") DCNL >>> perform_check() # doctest: +ELLIPSIS DCNL [\'pip\', \'install\', \'-U\', ...] DCNL >>> def bail(*a): raise Exception() DCNL >>> pypi   = pwnlib.update.available_on_pypi DCNL >>> perform_check(prerelease=False) DCNL [\'pip\', \'install\', \'-U\', \'pwntools\'] DCNL >>> perform_check(prerelease=True)  # doctest: +ELLIPSIS DCNL [\'pip\', \'install\', \'-U\', \'pwntools...\']'
'Provided any :term:`resource` and a :term:`request` object, return DCNL the resource object representing the :term:`virtual root` of the DCNL current :term:`request`.  Using a virtual root in a DCNL :term:`traversal` -based :app:`Pyramid` application permits DCNL rooting. For example, the resource at the traversal path ``/cms`` will DCNL be found at ``http://example.com/`` instead of rooting it at DCNL ``http://example.com/cms/``. DCNL If the ``resource`` passed in is a context obtained via DCNL :term:`traversal`, and if the ``HTTP_X_VHM_ROOT`` key is in the DCNL WSGI environment, the value of this key will be treated as a DCNL \'virtual root path\': the :func:`pyramid.traversal.find_resource` DCNL API will be used to find the virtual root resource using this path; DCNL if the resource is found, it will be returned.  If the DCNL ``HTTP_X_VHM_ROOT`` key is not present in the WSGI environment, DCNL the physical :term:`root` of the resource tree will be returned instead. DCNL Virtual roots are not useful at all in applications that use DCNL :term:`URL dispatch`. Contexts obtained via URL dispatch don\'t DCNL really support being virtually rooted (each URL dispatch context DCNL is both its own physical and virtual root).  However if this API DCNL is called with a ``resource`` argument which is a context obtained DCNL via URL dispatch, the resource passed in will be returned DCNL unconditionally.'
'.. versionchanged:: 2016.3.0 DCNL Return data now contains just the contents of the rsyncd.conf as a DCNL string, instead of a dictionary as returned from :py:func:`cmd.run_all DCNL <salt.modules.cmdmod.run_all>`. DCNL Returns the contents of the rsync config file DCNL conf_path : /etc/rsyncd.conf DCNL Path to the config file DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' rsync.config'
'The time in integer seconds. Pass scale=1000 to get milliseconds.'
'Returns a list of columns from `column_key` for `table` representing DCNL potentially a compound key. The `column_key` can be a name of a single DCNL column or list of column names.'
'Resolve a service name discovered via DNSServiceBrowse() to a DCNL target host name, port number, and txt record. DCNL Note: Applications should NOT use DNSServiceResolve() solely for DCNL txt record monitoring; use DNSServiceQueryRecord() instead, as it DCNL is more efficient for this task. DCNL Note: When the desired results have been returned, the client MUST DCNL terminate the resolve by closing the returned DNSServiceRef. DCNL Note: DNSServiceResolve() behaves correctly for typical services DCNL that have a single SRV record and a single TXT record.  To resolve DCNL non-standard services with multiple SRV or TXT records, DCNL DNSServiceQueryRecord() should be used. DCNL flags: DCNL Currently ignored, reserved for future use. DCNL interfaceIndex: DCNL The interface on which to resolve the service.  If this DCNL resolve call is as a result of a currently active DCNL DNSServiceBrowse() operation, then the interfaceIndex should DCNL be the index reported in the browse callback.  If this resolve DCNL call is using information previously saved (e.g. in a DCNL preference file) for later use, then use DCNL kDNSServiceInterfaceIndexAny (0), because the desired service DCNL may now be reachable via a different physical interface. DCNL name: DCNL The name of the service instance to be resolved, as reported DCNL to the DNSServiceBrowse() callback. DCNL regtype: DCNL The type of the service instance to be resolved, as reported DCNL to the DNSServiceBrowse() callback. DCNL domain: DCNL The domain of the service instance to be resolved, as reported DCNL to the DNSServiceBrowse() callback. DCNL callBack: DCNL The function to be called when a result is found, or if the DCNL call asynchronously fails.  Its signature should be DCNL callBack(sdRef, flags, interfaceIndex, errorCode, fullname, DCNL hosttarget, port, txtRecord). DCNL return value: DCNL A DNSServiceRef instance.  The resolve operation will run DCNL indefinitely until the client terminates it by closing the DCNL DNSServiceRef. DCNL Callback Parameters: DCNL sdRef: DCNL The DNSServiceRef returned by DNSServiceResolve(). DCNL flags: DCNL Currently unused, reserved for future use. DCNL interfaceIndex: DCNL The interface on which the service was resolved. DCNL errorCode: DCNL Will be kDNSServiceErr_NoError (0) on success, otherwise will DCNL indicate the failure that occurred.  Other parameters are DCNL undefined if an error occurred. DCNL fullname: DCNL The full service domain name, in the form DCNL <servicename>.<protocol>.<domain>. DCNL hosttarget: DCNL The target hostname of the machine providing the service. DCNL port: DCNL The port, in host (not network) byte order, on which DCNL connections are accepted for this service. DCNL txtRecord: DCNL A string containing the service\'s primary txt record, in DCNL standard txt record format.'
'Find and Register a package. DCNL Assumes the core registry setup correctly. DCNL In addition, if the location located by the package is already DCNL in the **core** path, then an entry is registered, but no path. DCNL (no other paths are checked, as the application whose path was used DCNL may later be uninstalled.  This should not happen with the core)'
'Return kernel_info information from osquery DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' osquery.kernel_info'
'geometry is string. DCNL atoms is dict of atoms with proper positions. DCNL Example: DCNL correct_answer = vsepr_build_correct_answer(geometry="AX4E0", atoms={"c0": "N", "p0": "H", "p1": "(ep)", "p2": "H", "p3": "H"}) DCNL returns a dictionary composed from input values: DCNL {\'geometry\': geometry, \'atoms\': atoms}'
'Get enabled tax rules from the db for given parameters. DCNL Returned rules are ordered desceding by override group and then DCNL ascending by priority (as required by `_filter_and_group_rules`). DCNL :type taxing_context: shuup.core.taxing.TaxingContext DCNL :type tax_class: shuup.core.models.TaxClass'
'Create a Hilbert matrix of order `n`. DCNL Returns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`. DCNL Parameters DCNL n : int DCNL The size of the array to create. DCNL Returns DCNL h : (n, n) ndarray DCNL The Hilbert matrix. DCNL See Also DCNL invhilbert : Compute the inverse of a Hilbert matrix. DCNL Notes DCNL .. versionadded:: 0.10.0 DCNL Examples DCNL >>> from scipy.linalg import hilbert DCNL >>> hilbert(3) DCNL array([[ 1.        ,  0.5       ,  0.33333333], DCNL [ 0.5       ,  0.33333333,  0.25      ], DCNL [ 0.33333333,  0.25      ,  0.2       ]])'
'Sum the elements of the iterable, and return the result as a float.'
'Extract selected fields from a file of line-separated JSON tweets and DCNL write to a file in CSV format. DCNL This utility function allows a file of full Tweets to be easily converted DCNL to a CSV file for easier processing of Twitter entities. For example, the DCNL hashtags or media elements of a tweet can be extracted. DCNL It returns one line per entity of a Tweet, e.g. if a tweet has two hashtags DCNL there will be two lines in the output file, one per hashtag DCNL :param tweets_file: the file-like object containing full Tweets DCNL :param str outfile: The path of the text file where results should be    written DCNL :param list main_fields: The list of fields to be extracted from the main    object, usually the tweet. Useful examples: \'id_str\' for the tweetID. See    <https://dev.twitter.com/overview/api/tweets> for a full list of fields. DCNL e. g.: [\'id_str\'], [\'id\', \'text\', \'favorite_count\', \'retweet_count\'] DCNL If `entity_type` is expressed with hierarchy, then it is the list of    fields of the object that corresponds to the key of the entity_type,    (e.g., for entity_type=\'user.urls\', the fields in the main_fields list    belong to the user object; for entity_type=\'place.bounding_box\', the    files in the main_field list belong to the place object of the tweet). DCNL :param list entity_type: The name of the entity: \'hashtags\', \'media\',    \'urls\' and \'user_mentions\' for the tweet object. For a user object,    this needs to be expressed with a hierarchy: `\'user.urls\'`. For the    bounding box of the Tweet location, use `\'place.bounding_box\'`. DCNL :param list entity_fields: The list of fields to be extracted from the    entity. E.g. `[\'text\']` (of the Tweet) DCNL :param error: Behaviour for encoding errors, see    https://docs.python.org/3/library/codecs.html#codec-base-classes DCNL :param gzip_compress: if `True`, ouput files are compressed with gzip'
'Update allocated quota to subprojects or raise if it does not exist. DCNL :raises: cinder.exception.ProjectQuotaNotFound'
'Asynchronously allocates a range of IDs. DCNL Identical to datastore.AllocateIds() except returns an asynchronous object. DCNL Call get_result() on the return value to block on the call and get the DCNL results.'
'Unpacks P.A.C.K.E.R. packed js code.'
'Encode the message\'s payload in quoted-printable. DCNL Also, add an appropriate Content-Transfer-Encoding header.'
'Dump metadata about the parquet object with the given filename. DCNL Dump human-readable metadata to specified `out`. Optionally dump the row group metadata as well.'
'Return a query dictionary based on the settings in the filter. DCNL :param sample_filter: SampleFilter instance DCNL :param require_meter: If true and the filter does not have a meter, DCNL raise an error.'
'Pauses test execution and asks user to input a value. DCNL Value typed by the user, or the possible default value, is returned. DCNL Returning an empty value is fine, but pressing ``Cancel`` fails the keyword. DCNL ``message`` is the instruction shown in the dialog and ``default_value`` is DCNL the possible default value shown in the input field. DCNL If ``hidden`` is given a true value, the value typed by the user is hidden. DCNL ``hidden`` is considered true if it is a non-empty string not equal to DCNL ``false`` or ``no``, case-insensitively. If it is not a string, its truth DCNL value is got directly using same DCNL [http://docs.python.org/2/library/stdtypes.html#truth-value-testing|rules DCNL as in Python]. DCNL Example: DCNL | ${username} = | Get Value From User | Input user name | default    | DCNL | ${password} = | Get Value From User | Input password  | hidden=yes | DCNL Possibility to hide the typed in value is new in Robot Framework 2.8.4. DCNL Considering strings ``false`` and ``no`` to be false is new in 2.9.'
'Utility function to check if an IP address is inside a private subnet. DCNL :type ip: ``str`` DCNL :param ip: IP address to check DCNL :return: ``bool`` if the specified IP address is private.'
'Emits certificate event.'
'write intermediate results to checkpoint file DCNL current_key: the identifier of the current denoiser round DCNL ctr: a uniq counter to label the checkpoint DCNL cluster_mapping: an intermediate cluster mapping as dict DCNL ids: the dict of active ids DCNL order:  a list of ids, which defines the order of which flowgrams are clustered DCNL bestscores: a dict of'
'Lists a nexusport binding'
'Filter out private items in a user dict. DCNL \'password\', \'tenants\' and \'groups\' are never returned. DCNL :returns: user_ref'
'Exception hook which handles `BdbQuit` exceptions. DCNL All other exceptions are processed using the `excepthook` DCNL parameter.'
'Load current redirect to context.'
'Returns the User model that is active in this project.'
'Removes useless (for database) attributes from the table\'s meta.'
'Bidirectional RNN. DCNL Build a bidirectional recurrent neural network, it requires 2 RNN Cells DCNL to process sequence in forward and backward order. Any RNN Cell can be DCNL used i.e. SimpleRNN, LSTM, GRU... with its own parameters. But the two DCNL cells number of units must match. DCNL Input: DCNL 3-D Tensor Layer [samples, timesteps, input dim]. DCNL Output: DCNL if `return_seq`: 3-D Tensor [samples, timesteps, output dim]. DCNL else: 2-D Tensor Layer [samples, output dim]. DCNL Arguments: DCNL incoming: `Tensor`. The incoming Tensor. DCNL rnncell_fw: `RNNCell`. The RNN Cell to use for foward computation. DCNL rnncell_bw: `RNNCell`. The RNN Cell to use for backward computation. DCNL return_seq: `bool`. If True, returns the full sequence instead of DCNL last sequence output only. DCNL return_states: `bool`. If True, returns a tuple with output and DCNL states: (output, states). DCNL initial_state_fw: `Tensor`. An initial state for the forward RNN. DCNL This must be a tensor of appropriate type and shape [batch_size DCNL x cell.state_size]. DCNL initial_state_bw: `Tensor`. An initial state for the backward RNN. DCNL This must be a tensor of appropriate type and shape [batch_size DCNL x cell.state_size]. DCNL dynamic: `bool`. If True, dynamic computation is performed. It will not DCNL compute RNN steps above the sequence length. Note that because TF DCNL requires to feed sequences of same length, 0 is used as a mask. DCNL So a sequence padded with 0 at the end must be provided. When DCNL computation is performed, it will stop when it meets a step with DCNL a value of 0. DCNL scope: `str`. Define this layer scope (optional). A scope can be DCNL used to share variables between layers. Note that scope will DCNL override name. DCNL name: `str`. A name for this layer (optional).'
'A scenario may own outlines'
'Returns the string with special characters decoded.'
'Create a continuous random variable with a non-central Chi distribution. DCNL The density of the non-central Chi distribution is given by DCNL .. math:: DCNL f(x) := \frac{e^{-(x^2+\lambda^2)/2} x^k\lambda} DCNL {(\lambda x)^{k/2}} I_{k/2-1}(\lambda x) DCNL with `x \geq 0`. Here, `I_\nu (x)` is the DCNL :ref:`modified Bessel function of the first kind <besseli>`. DCNL Parameters DCNL k : A positive Integer, `k > 0`, the number of degrees of freedom DCNL l : Shift parameter DCNL Returns DCNL A RandomSymbol. DCNL Examples DCNL >>> from sympy.stats import ChiNoncentral, density, E, std DCNL >>> from sympy import Symbol, simplify DCNL >>> k = Symbol("k", integer=True) DCNL >>> l = Symbol("l") DCNL >>> z = Symbol("z") DCNL >>> X = ChiNoncentral("x", k, l) DCNL >>> density(X)(z) DCNL l*z**k*(l*z)**(-k/2)*exp(-l**2/2 - z**2/2)*besseli(k/2 - 1, l*z) DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Noncentral_chi_distribution'
'Return the attribute name that should be used to refer from one DCNL class to another, for a collection reference. DCNL The default implementation is:: DCNL return referred_cls.__name__.lower() + "_collection" DCNL Alternate implementations DCNL can be specified using the DCNL :paramref:`.AutomapBase.prepare.name_for_collection_relationship` DCNL parameter. DCNL :param base: the :class:`.AutomapBase` class doing the prepare. DCNL :param local_cls: the class to be mapped on the local side. DCNL :param referred_cls: the class to be mapped on the referring side. DCNL :param constraint: the :class:`.ForeignKeyConstraint` that is being DCNL inspected to produce this relationship.'
'Exemplify repr(Rule) (see also str(Rule) and Rule.format("verbose"))'
'Return the EC2 region to use, in this order: DCNL - CLI parameter DCNL - VM parameter DCNL - Cloud profile setting'
'Test that a column of unicode strings is still written as one DCNL byte-per-character in the FITS table (so long as the column can be ASCII DCNL encoded). DCNL Regression test for one of the issues fixed in DCNL https://github.com/astropy/astropy/pull/4228'
'Testcase for py2exe logic, un-compressed lib'
'Converts a given value to a percentage if specified as "x%", DCNL otherwise converts the given value to an integer.'
'Zip timeseries data while gracefully handling gaps in the data. DCNL Timeseries data is expected to be a sequence of two-tuples (date, values). DCNL Values is expected itself to be a tuple. The width of the values tuples DCNL should be the same across all elements in a timeseries sequence. The result DCNL will be a single sequence in timeseries format. DCNL Gaps in sequences are filled with an appropriate number of zeros based on DCNL the size of the first value-tuple of that sequence.'
'Given an input string, returns an HTML fragment as a string. DCNL The return value is the contents of the <body> element. DCNL Parameters (see `html_parts()` for the remainder): DCNL - `output_encoding`: The desired encoding of the output.  If a Unicode DCNL string is desired, use the default value of "unicode" .'
'Return a pen representing the given wavelength'
'defrag(plist) -> plist defragmented as much as possible'
'Validate that \'value\' is a positive integer or None.'
'yield tuples of hex and ASCII display in multiples of 16. Includes a DCNL space after 8 bytes and (None, None) after 16 bytes and at the end.'
'Demonstrate how a transform would work.'
'Helper for getting the text of an element'
'Conditional.get_vae returns its VAE'
'Create a task object'
'Get the evaluated value as an int.'
'Translate an application error to a datastore Error, if possible. DCNL Args: DCNL error: An ApplicationError to translate.'
'Solutions of f(x) congruent 0 mod(p**e). DCNL Examples DCNL >>> from sympy.polys.galoistools import csolve_prime DCNL >>> csolve_prime([1, 1, 7], 3, 1) DCNL [1] DCNL >>> csolve_prime([1, 1, 7], 3, 2) DCNL [1, 4, 7] DCNL Solutions [7, 4, 1] (mod 3**2) are generated by ``_raise_mod_power()`` DCNL from solution [1] (mod 3).'
'Get networks for the given VIF and subnet DCNL :param vif: Neutron VIF DCNL :param subnet: Neutron subnet DCNL :param version: IP version as an int, either \'4\' or \'6\' DCNL :param net_num: Network index for generating name of each network DCNL :param link_id: Arbitrary identifier for the link the networks are DCNL attached to'
'Access via the .json representation to avoid work rendering menus, etc'
'Return a boto connection for the service. DCNL .. code-block:: python DCNL conn = __utils__[\'boto.get_connection\'](\'ec2\', profile=\'custom_profile\')'
'yaml: trigger DCNL Trigger non-parametrised builds of other jobs. DCNL :arg str project: name of the job to trigger DCNL :arg str threshold: when to trigger the other job (default \'SUCCESS\'), DCNL alternatives: SUCCESS, UNSTABLE, FAILURE DCNL Example: DCNL .. literalinclude:: /../../tests/publishers/fixtures/trigger_success.yaml DCNL :language: yaml'
'Supress all output from pySerial and gsmmodem'
'Read 64bit float from bti file.'
'Get profile for one tooth of a cylindrical gear.'
'Start a WSGI application. Optional features include a reloader, DCNL multithreading and fork support. DCNL This function has a command-line interface too:: DCNL python -m werkzeug.serving --help DCNL .. versionadded:: 0.5 DCNL `static_files` was added to simplify serving of static files as well DCNL as `passthrough_errors`. DCNL .. versionadded:: 0.6 DCNL support for SSL was added. DCNL .. versionadded:: 0.8 DCNL Added support for automatically loading a SSL context from certificate DCNL file and private key. DCNL .. versionadded:: 0.9 DCNL Added command-line interface. DCNL .. versionadded:: 0.10 DCNL Improved the reloader and added support for changing the backend DCNL through the `reloader_type` parameter.  See :ref:`reloader` DCNL for more information. DCNL :param hostname: The host for the application.  eg: ``\'localhost\'`` DCNL :param port: The port for the server.  eg: ``8080`` DCNL :param application: the WSGI application to execute DCNL :param use_reloader: should the server automatically restart the python DCNL process if modules were changed? DCNL :param use_debugger: should the werkzeug debugging system be used? DCNL :param use_evalex: should the exception evaluation feature be enabled? DCNL :param extra_files: a list of files the reloader should watch DCNL additionally to the modules.  For example configuration DCNL files. DCNL :param reloader_interval: the interval for the reloader in seconds. DCNL :param reloader_type: the type of reloader to use.  The default is DCNL auto detection.  Valid values are ``\'stat\'`` and DCNL ``\'watchdog\'``. See :ref:`reloader` for more DCNL information. DCNL :param threaded: should the process handle each request in a separate DCNL thread? DCNL :param processes: if greater than 1 then handle each request in a new process DCNL up to this maximum number of concurrent processes. DCNL :param request_handler: optional parameter that can be used to replace DCNL the default one.  You can use this to replace it DCNL with a different DCNL :class:`~BaseHTTPServer.BaseHTTPRequestHandler` DCNL subclass. DCNL :param static_files: a dict of paths for static files.  This works exactly DCNL like :class:`SharedDataMiddleware`, it\'s actually DCNL just wrapping the application in that middleware before DCNL serving. DCNL :param passthrough_errors: set this to `True` to disable the error catching. DCNL This means that the server will die on errors but DCNL it can be useful to hook debuggers in (pdb etc.) DCNL :param ssl_context: an SSL context for the connection. Either an DCNL :class:`ssl.SSLContext`, a tuple in the form DCNL ``(cert_file, pkey_file)``, the string ``\'adhoc\'`` if DCNL the server should automatically create one, or ``None`` DCNL to disable SSL (which is the default).'
'generate summary table of outlier and influence similar to SAS DCNL Parameters DCNL alpha : float DCNL significance level for confidence interval DCNL Returns DCNL st : SimpleTable instance DCNL table with results that can be printed DCNL data : ndarray DCNL calculated measures and statistics for the table DCNL ss2 : list of strings DCNL column_names for table (Note: rows of table are observations)'
'Get the real filter sizes of each layer involved in DCNL convoluation. See Xudong Cao: DCNL https://www.kaggle.com/c/datasciencebowl/forums/t/13166/happy-lantern-festival-report-and-code DCNL This does not yet take into consideration feature pooling, DCNL padding, striding and similar gimmicks.'
'Clear all registered actions. DCNL This method is really only intended to be used by unit tests. We might be DCNL able to remove this hack once we convert to djblets.registries. DCNL Warning: DCNL This will clear **all** actions, even if they were registered in DCNL separate extensions.'
'Takes two datetime objects and returns the time between d and now DCNL as a nicely formatted string, e.g. "10 minutes".  If d occurs after now, DCNL then "0 seconds" is returned. If abbreviate is True, it truncates values to, DCNL for example, "10m" or "4m 30s". Alternately it can take a second value DCNL and return the proper count. DCNL Units used are years, months, weeks, days, hours, minutes, and seconds. DCNL Microseconds are ignored.  Up to two adjacent units will be DCNL displayed.  For example, "2 weeks, 3 days" and "1 year, 3 months" are DCNL possible outputs, but "2 weeks, 3 hours" and "1 year, 5 days" are not. DCNL Adapted from the timesince filter in Django: DCNL http://docs.djangoproject.com/en/dev/ref/templates/builtins/#timesince'
'Add struct pack/unpack functions'
'Setup federated username. DCNL Function covers all the cases for properly setting user id, a primary DCNL identifier for identity objects. Initial version of the mapping engine DCNL assumed user is identified by ``name`` and his ``id`` is built from the DCNL name. We, however need to be able to accept local rules that identify user DCNL by either id or name/domain. DCNL The following use-cases are covered: DCNL 1) If neither user_name nor user_id is set raise exception.Unauthorized DCNL 2) If user_id is set and user_name not, set user_name equal to user_id DCNL 3) If user_id is not set and user_name is, set user_id as url safe version DCNL of user_name. DCNL :param request: current request object DCNL :param mapped_properties: Properties issued by a RuleProcessor. DCNL :type: dictionary DCNL :raises keystone.exception.Unauthorized: If neither `user_name` nor DCNL `user_id` is set. DCNL :returns: tuple with user identification DCNL :rtype: tuple'
'.. versionchanged:: Nitrogen DCNL The ``expr_form`` argument has been renamed to ``tgt_type``, earlier DCNL releases must use ``expr_form``. DCNL Disable the named worker from the lbn load balancers at the targeted DCNL minions. The worker will get traffic only for current sessions and won\'t DCNL get new ones. DCNL Example: DCNL .. code-block:: yaml DCNL disable-before-deploy: DCNL modjk_worker.disable: DCNL - name: {{ grains[\'id\'] }} DCNL - lbn: application DCNL - target: \'roles:balancer\' DCNL - tgt_type: grain'
'This takes an arbitrary object and preps it for jsonifying safely, templating Inf/NaN.'
'Returns the number of comlpeted, running, and failed jobs for a user.'
'Create a filer.models.filemodels.File from an upload (UploadedFile or such). DCNL If the `sha1` parameter is passed and a file with said SHA1 is found, it will be returned instead. DCNL :param request: Request, to figure out the owner for this file DCNL :type request: django.http.request.HttpRequest|None DCNL :param path: Pathname string (see `filer_folder_from_path`) or a Filer Folder. DCNL :type path: basestring|filer.models.Folder DCNL :param upload_data: Upload data DCNL :type upload_data: django.core.files.base.File DCNL :param sha1: SHA1 checksum. If given and a matching `model` with the SHA1 is found, it is returned instead. DCNL :type sha1: basestring DCNL :rtype: filer.models.filemodels.File'
'Fixes document\'s LAST_UPDATED field value. Flask-PyMongo returns DCNL timezone-aware values while stdlib datetime values are timezone-naive. DCNL Comparisons between the two would fail. DCNL If LAST_UPDATE is missing we assume that it has been created outside of the DCNL API context and inject a default value, to allow for proper computing of DCNL Last-Modified header tag. By design all documents return a LAST_UPDATED DCNL (and we don\'t want to break existing clients). DCNL :param document: the document to be processed. DCNL .. versionchanged:: 0.1.0 DCNL Moved to common.py and renamed as public, so it can also be used by edit DCNL methods (via get_document()). DCNL .. versionadded:: 0.0.5'
'Stubs an image update on the registry. DCNL :param stubs: Set of stubout stubs'
'Deletes the flag definitions done by the above DefineFlags().'
'Retrieves all volumes associated with the group_id. DCNL :param context: context to query under DCNL :param group_id: consistency group ID for all volumes being retrieved DCNL :param filters: dictionary of filters; values that are in lists, tuples, DCNL or sets cause an \'IN\' operation, while exact matching DCNL is used for other values, see _process_volume_filters DCNL function for more information DCNL :returns: list of matching volumes'
'Writes the XML content to disk, touching the file only if it has changed. DCNL Visual Studio files have a lot of pre-defined structures.  This function makes DCNL it easy to represent these structures as Python data structures, instead of DCNL having to create a lot of function calls. DCNL Each XML element of the content is represented as a list composed of: DCNL 1. The name of the element, a string, DCNL 2. The attributes of the element, a dictionary (optional), and DCNL 3+. The content of the element, if any.  Strings are simple text nodes and DCNL lists are child elements. DCNL Example 1: DCNL <test/> DCNL becomes DCNL [\'test\'] DCNL Example 2: DCNL <myelement a=\'value1\' b=\'value2\'> DCNL <childtype>This is</childtype> DCNL <childtype>it!</childtype> DCNL </myelement> DCNL becomes DCNL [\'myelement\', {\'a\':\'value1\', \'b\':\'value2\'}, DCNL [\'childtype\', \'This is\'], DCNL [\'childtype\', \'it!\'], DCNL Args: DCNL content:  The structured content to be converted. DCNL encoding: The encoding to report on the first XML line. DCNL pretty: True if we want pretty printing with indents and new lines. DCNL Returns: DCNL The XML content as a string.'
'Add email to the exit survey campaign.'
'Test LDA on empty document (all-zero rows).'
'helper method to compare salt state info with the PagerDuty API json structure, DCNL and determine if we need to update. DCNL returns the dict to pass to the PD API to perform the update, or empty dict if no update.'
'Confirm a previous resize.'
'Applies the linear operator |A.T| to the arguments. DCNL Parameters DCNL lin_op : LinOp DCNL A linear operator. DCNL value : NumPy matrix DCNL A numeric value to apply the operator\'s transpose to. DCNL Returns DCNL NumPy matrix or SciPy sparse matrix. DCNL The result of applying the linear operator.'
'Convert the given html document for the annotation UI DCNL This adds tags, removes scripts and optionally adds a base url'
'Run the given function under the given contextmanager, DCNL simulating the behavior of \'with\' to support older DCNL Python versions. DCNL This is not necessary anymore as we have placed 2.6 DCNL as minimum Python version, however some tests are still using DCNL this structure.'
'Continuation lines indentation. DCNL Continuation lines should align wrapped elements either vertically DCNL using Python\'s implicit line joining inside parentheses, brackets DCNL and braces, or using a hanging indent. DCNL When using a hanging indent these considerations should be applied: DCNL - there should be no arguments on the first line, and DCNL - further indentation should be used to clearly distinguish itself as a DCNL continuation line. DCNL Okay: a = (\n) DCNL E123: a = (\n    ) DCNL Okay: a = (\n    42) DCNL E121: a = (\n   42) DCNL E122: a = (\n42) DCNL E123: a = (\n    42\n    ) DCNL E124: a = (24,\n     42\n) DCNL E125: if (\n    b):\n    pass DCNL E126: a = (\n        42) DCNL E127: a = (24,\n      42) DCNL E128: a = (24,\n    42) DCNL E129: if (a or\n    b):\n    pass DCNL E131: a = (\n    42\n 24)'
'In `prompt_and_delete_repo()`, if the user agrees to delete/reclone the DCNL repo, the repo should be deleted.'
'Return integer part of given number.'
'Uses non-local means to denoise 4D datasets'
'Print predefined zones DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' firewalld.get_zones'
'test : comparison'
'Returns the current size of the terminal as tuple in the form DCNL ``(width, height)`` in columns and rows.'
'Returns an `OrderedDict` of field names to `RelationInfo`.'
'Lists the qos given a tenant_id and qos_id'
'Find destinations for resources files'
'Tell whether an alert entry is a template'
'Adds close action and shortcuts to a widget.'
'Check that memcache is running'
'A decorator indicating abstract methods. DCNL Requires that the metaclass is ABCMeta or derived from it.  A DCNL class that has a metaclass derived from ABCMeta cannot be DCNL instantiated unless all of its abstract methods are overridden. DCNL The abstract methods can be called using any of the normal DCNL \'super\' call mechanisms. DCNL Usage: DCNL class C: DCNL __metaclass__ = ABCMeta DCNL @abstractmethod DCNL def my_abstract_method(self, ...):'
'Report any filter which is not allowed by  `allowed_filters` DCNL :param where: the where clause, as a dict. DCNL :param resource: the resource being inspected. DCNL .. versionchanged: 0.5 DCNL If the data layer supports a list of allowed operators, take them DCNL into consideration when validating the query string (#388). DCNL Recursively validate the whole query string. DCNL .. versionadded: 0.0.9'
'test the behavior of --editable --uptodate flag in the list command'
'Get total size of file or files in dir (recursive).'
'get the api url for a pull request from the web one. DCNL :param unicode url: the web URL of the pull request. DCNL :return unicode: the API URL of the same pull request.'
'Factory function to create a new identity service client. DCNL The returned client will be either a V3 or V2 client. Check the version DCNL using the :py:attr:`~keystoneclient.v3.client.Client.version` property or DCNL the instance\'s class (with instanceof). DCNL :param tuple version: The required version of the identity API. If DCNL specified the client will be selected such that the DCNL major version is equivalent and an endpoint provides DCNL at least the specified minor version. For example to DCNL specify the 3.1 API use ``(3, 1)``. (optional) DCNL :param bool unstable: Accept endpoints not marked as \'stable\'. (optional) DCNL :param session: A session object to be used for communication. If one is DCNL not provided it will be constructed from the provided DCNL kwargs. (optional) DCNL :type session: keystoneclient.session.Session DCNL :param kwargs: Additional arguments are passed through to the client DCNL that is being created. DCNL :returns: New keystone client object. DCNL :rtype: :py:class:`keystoneclient.v3.client.Client` or DCNL :py:class:`keystoneclient.v2_0.client.Client` DCNL :raises keystoneclient.exceptions.DiscoveryFailure: if the server\'s DCNL response is invalid. DCNL :raises keystoneclient.exceptions.VersionNotAvailable: if a suitable client DCNL cannot be found.'
'Nonexistent controller - simply returns None'
'Test that social media plugin ordering works as expected'
'Helper function to parse the backend configuration DCNL that doesn\'t use the URI notation.'
'Run shell commands with `shell_process` and wait.'
'Format a timestamp (string or numeric) into a standardized DCNL xxxxxxxxxx.xxxxx (10.5) format. DCNL Note that timestamps using values greater than or equal to November 20th, DCNL 2286 at 17:46 UTC will use 11 digits to represent the number of DCNL seconds. DCNL :param timestamp: unix timestamp DCNL :returns: normalized timestamp as a string'
'send formatted chat message DCNL legacy notice: identical function in kludgy_html_parser DCNL the older function is "overridden" here for compatibility reasons'
'Write a projection operator to a file. DCNL Parameters DCNL fid : file DCNL The file descriptor of the open file. DCNL projs : dict DCNL The projection operator.'
'Drop all temporary tables created by prepare_data().'
'Saves globally the value of SITEURL configuration parameter'
'Returns a list of paths to socket files to monitor.'
'Non-local plugin decorator using local directories for the extra_dirs (job_work and temp).'
'Topological sort of graph\'s vertices. DCNL Parameters DCNL ``graph`` : ``tuple[list, list[tuple[T, T]]`` DCNL A tuple consisting of a list of vertices and a list of edges of DCNL a graph to be sorted topologically. DCNL ``key`` : ``callable[T]`` (optional) DCNL Ordering key for vertices on the same level. By default the natural DCNL (e.g. lexicographic) ordering is used (in this case the base type DCNL must implement ordering relations). DCNL Examples DCNL Consider a graph:: DCNL | 7 |\    | 5 |     | 3 | DCNL V  V           V V   | DCNL | 11 |         | 8 |  | DCNL V  \     V V   /  V  V DCNL | 2 |  |  | 9 | |  | 10 | DCNL where vertices are integers. This graph can be encoded using DCNL elementary Python\'s data structures as follows:: DCNL >>> V = [2, 3, 5, 7, 8, 9, 10, 11] DCNL >>> E = [(7, 11), (7, 8), (5, 11), (3, 8), (3, 10), DCNL ...      (11, 2), (11, 9), (11, 10), (8, 9)] DCNL To compute a topological sort for graph ``(V, E)`` issue:: DCNL >>> from sympy.utilities.iterables import topological_sort DCNL >>> topological_sort((V, E)) DCNL [3, 5, 7, 8, 11, 2, 9, 10] DCNL If specific tie breaking approach is needed, use ``key`` parameter:: DCNL >>> topological_sort((V, E), key=lambda v: -v) DCNL [7, 5, 11, 3, 10, 8, 9, 2] DCNL Only acyclic graphs can be sorted. If the input graph has a cycle, DCNL then :py:exc:`ValueError` will be raised:: DCNL >>> topological_sort((V, E + [(10, 7)])) DCNL Traceback (most recent call last): DCNL ValueError: cycle detected DCNL .. seealso:: http://en.wikipedia.org/wiki/Topological_sorting'
'Gets transcripts from youtube for youtube_id. DCNL Parses only utf-8 encoded transcripts. DCNL Other encodings are not supported at the moment. DCNL Returns (status, transcripts): bool, dict.'
'Create core properties (common document properties referred to in the DCNL \'Dublin Core\' specification). See appproperties() for other stuff.'
'Attach custom data on request object, and share it with parent DCNL requests during batch.'
'Returns True if the given object is an ``adatetime`` where ``hour``, DCNL ``minute``, ``second`` and ``microsecond`` are all None.'
'Band Stop Objective Function for order minimization. DCNL Returns the non-integer order for an analog band stop filter. DCNL Parameters DCNL wp : scalar DCNL Edge of passband `passb`. DCNL ind : int, {0, 1} DCNL Index specifying which `passb` edge to vary (0 or 1). DCNL passb : ndarray DCNL Two element sequence of fixed passband edges. DCNL stopb : ndarray DCNL Two element sequence of fixed stopband edges. DCNL gstop : float DCNL Amount of attenuation in stopband in dB. DCNL gpass : float DCNL Amount of ripple in the passband in dB. DCNL type : {\'butter\', \'cheby\', \'ellip\'} DCNL Type of filter. DCNL Returns DCNL n : scalar DCNL Filter order (possibly non-integer).'
'Decorator: renders a template for a handler. DCNL The handler can control its behavior like that: DCNL - return a dict of template vars to fill out the template DCNL - return something other than a dict and the view decorator will not DCNL process the template, but return the handler result as is. DCNL This includes returning a HTTPResponse(dict) to get, DCNL for instance, JSON with autojson or other castfilters.'
'Simple test function DCNL Taken from http://www.huyng.com/posts/python-performance-analysis/'
'The subjunctive mood is a classical mood used to express a wish, judgment or opinion. DCNL It is marked by the verb wish/were, or infinitive form of a verb DCNL preceded by an "it is"-statement: DCNL "It is recommended that he bring his own computer."'
'Create multiple locator with 0.7 base, and change it to something else. DCNL See if change was successful. DCNL Should not exception.'
'A context manager which disables field overrides inside the context of a DCNL `with` statement, allowing code to get at the `original` value of a field.'
'Collects and dumps stats from a MySQL server.'
'Concatenate variables along a new axis. DCNL Args: DCNL xs (list of chainer.Variable): Variables to be concatenated. DCNL axis (int): Axis of result along which variables are stacked. DCNL Returns: DCNL ~chainer.Variable: Output variable.'
'Wrapper around utils._execute for fake_network.'
'Locate a file in a path supplied as a part of the file name, DCNL or the user\'s path, or a supplied path. DCNL The function yields full paths (not necessarily absolute paths), DCNL in which the given file name matches an existing file in a directory on the path. DCNL >>> def test_which(expected, *args, **argd): DCNL ...     result = list(which_files(*args, **argd)) DCNL ...     assert result == expected, \'which_files: %s != %s\' % (result, expected) DCNL ...     try: DCNL ...         result = [ which(*args, **argd) ] DCNL ...     except IOError: DCNL ...         result = [] DCNL ...     assert result[:1] == expected[:1], \'which: %s != %s\' % (result[:1], expected[:1]) DCNL >>> if windows: cmd = environ[\'COMSPEC\'] DCNL >>> if windows: test_which([cmd], \'cmd\') DCNL >>> if windows: test_which([cmd], \'cmd.exe\') DCNL >>> if windows: test_which([cmd], \'cmd\', path=dirname(cmd)) DCNL >>> if windows: test_which([cmd], \'cmd\', pathext=\'.exe\') DCNL >>> if windows: test_which([cmd], cmd) DCNL >>> if windows: test_which([cmd], cmd, path=\'<nonexistent>\') DCNL >>> if windows: test_which([cmd], cmd, pathext=\'<nonexistent>\') DCNL >>> if windows: test_which([cmd], cmd[:-4]) DCNL >>> if windows: test_which([cmd], cmd[:-4], path=\'<nonexistent>\') DCNL >>> if windows: test_which([], \'cmd\', path=\'<nonexistent>\') DCNL >>> if windows: test_which([], \'cmd\', pathext=\'<nonexistent>\') DCNL >>> if windows: test_which([], \'<nonexistent>/cmd\') DCNL >>> if windows: test_which([], cmd[:-4], pathext=\'<nonexistent>\') DCNL >>> if not windows: sh = \'/bin/sh\' DCNL >>> if not windows: test_which([sh], \'sh\') DCNL >>> if not windows: test_which([sh], \'sh\', path=dirname(sh)) DCNL >>> if not windows: test_which([sh], \'sh\', pathext=\'<nonexistent>\') DCNL >>> if not windows: test_which([sh], sh) DCNL >>> if not windows: test_which([sh], sh, path=\'<nonexistent>\') DCNL >>> if not windows: test_which([sh], sh, pathext=\'<nonexistent>\') DCNL >>> if not windows: test_which([], \'sh\', mode=W_OK)  # not running as root, are you? DCNL >>> if not windows: test_which([], \'sh\', path=\'<nonexistent>\') DCNL >>> if not windows: test_which([], \'<nonexistent>/sh\')'
'Return all inline documentation for runner modules DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-run doc.runner'
'Tokenization/string cleaning for a datasets.'
'Return label of variable node.'
'Test if this is an valid android zip.'
'Used as a validator within a wtforms.Form DCNL This implements a conditional DataRequired DCNL Each of the kwargs is a condition that must be met in the form DCNL Otherwise, no validation is done'
'Tests the creation of a file extension'
'Check virt drivers\' modules aren\'t imported by other drivers DCNL Modules under each virt driver\'s directory are DCNL considered private to that virt driver. Other drivers DCNL in Nova must not access those drivers. Any code that DCNL is to be shared should be refactored into a common DCNL module DCNL N311'
'Trim the text to `max_width`, append dots when the text is too long. DCNL Returns (text, width) tuple.'
'Compute labels and inertia using a full distance matrix. DCNL This will overwrite the \'distances\' array in-place. DCNL Parameters DCNL X : numpy array, shape (n_sample, n_features) DCNL Input data. DCNL x_squared_norms : numpy array, shape (n_samples,) DCNL Precomputed squared norms of X. DCNL centers : numpy array, shape (n_clusters, n_features) DCNL Cluster centers which data is assigned to. DCNL distances : numpy array, shape (n_samples,) DCNL Pre-allocated array in which distances are stored. DCNL Returns DCNL labels : numpy array, dtype=np.int, shape (n_samples,) DCNL Indices of clusters that samples are assigned to. DCNL inertia : float DCNL Sum of distances of samples to their closest cluster center.'
'Get aggregate statistics over all compute nodes. DCNL :param context: The security context DCNL :returns: Dictionary containing compute node characteristics summed up DCNL over all the compute nodes, e.g. \'vcpus\', \'free_ram_mb\' etc.'
'Do some necessary and/or useful substitutions for texts to be included in DCNL LaTeX documents.'
'str to list'
'Generate a CSV containing all students\' problem grades within a given DCNL `course_id`.'
'Translate a string ip address to a packed number. DCNL @param ipstr: the ip address to transform DCNL @type ipstr: a string "x.x.x.x" DCNL @return: an int32 number representing the ip address'
'Checks that all of the required keys, and possibly some of the optional DCNL keys, are in the given dict. DCNL Raises: DCNL AssertionError: if the validation fails.'
'Wraps the given array into a DataObject.'
'Create a new image volume cache entry.'
'Check that Astropy gives consistent results with an IDL hor2eq example. DCNL See : http://idlastro.gsfc.nasa.gov/ftp/pro/astro/hor2eq.pro DCNL Test is against these run outputs, run at 2000-01-01T12:00:00: DCNL # NORMAL ATMOSPHERE CASE DCNL IDL> hor2eq, ten(37,54,41), ten(264,55,06), 2451545.0d, ra, dec, /verb, obs=\'kpno\', pres=781.0, temp=273.0 DCNL Latitude = +31 57 48.0   Longitude = *** 36 00.0 DCNL Julian Date =  2451545.000000 DCNL Az, El =  17 39 40.4  +37 54 41   (Observer Coords) DCNL Az, El =  17 39 40.4  +37 53 40   (Apparent Coords) DCNL LMST = +11 15 26.5 DCNL LAST = +11 15 25.7 DCNL Hour Angle = +03 38 30.1  (hh:mm:ss) DCNL Ra, Dec:  07 36 55.6  +15 25 02   (Apparent Coords) DCNL Ra, Dec:  07 36 55.2  +15 25 08   (J2000.0000) DCNL Ra, Dec:  07 36 55.2  +15 25 08   (J2000) DCNL IDL> print, ra, dec DCNL 114.23004       15.418818 DCNL # NO PRESSURE CASE DCNL IDL> hor2eq, ten(37,54,41), ten(264,55,06), 2451545.0d, ra, dec, /verb, obs=\'kpno\', pres=0.0, temp=273.0 DCNL Latitude = +31 57 48.0   Longitude = *** 36 00.0 DCNL Julian Date =  2451545.000000 DCNL Az, El =  17 39 40.4  +37 54 41   (Observer Coords) DCNL Az, El =  17 39 40.4  +37 54 41   (Apparent Coords) DCNL LMST = +11 15 26.5 DCNL LAST = +11 15 25.7 DCNL Hour Angle = +03 38 26.4  (hh:mm:ss) DCNL Ra, Dec:  07 36 59.3  +15 25 31   (Apparent Coords) DCNL Ra, Dec:  07 36 58.9  +15 25 37   (J2000.0000) DCNL Ra, Dec:  07 36 58.9  +15 25 37   (J2000) DCNL IDL> print, ra, dec DCNL 114.24554       15.427022'
'Tests that the format_as methods between Conv2DSpace DCNL and VectorSpace are invertible for the (\'c\', 0, 1, \'b\') DCNL axis format.'
'Send connect to database.'
'Translate the user/group info into uid/gid.'
'Creates a copy of the constraint modified according to func. DCNL Parameters DCNL constr : LinConstraint DCNL The constraint to modify. DCNL func : function DCNL Function to modify the constraint expression. DCNL Returns DCNL LinConstraint DCNL A copy of the constraint with the specified changes.'
'Only load if the postgres module is present and is new enough (has ts funcs)'
'Multiply two linear operators elementwise. DCNL Parameters DCNL lh_op : LinOp DCNL The left-hand operator in the product. DCNL rh_op : LinOp DCNL The right-hand operator in the product. DCNL Returns DCNL LinOp DCNL A linear operator representing the product.'
'list all headers for a given category'
'Map vera  classes to HA types.'
'Authenticate against yubico server'
'Main program function for checking mapping file DCNL Checks mapping file for errors, warnings, writes log file, html file, DCNL and corrected mapping file. DCNL mapping_fp:  path to metadata mapping file DCNL output_dir:  output directory for log, html, corrected mapping file. DCNL has_barcodes:  If True, will test for perform barcodes test (presence, DCNL uniqueness, valid IUPAC DNA chars). DCNL char_replace:  Character used to replace invalid characters in data DCNL fields.  SampleIDs always use periods to be MIENS compliant. DCNL verbose: If True, a message about warnings and/or errors will be printed DCNL to stdout. DCNL variable_len_barcodes:  If True, suppresses warnings about barcodes of DCNL varying length. DCNL disable_primer_check:  If True, disables tests for valid primer sequences. DCNL added_demultiplex_field:  If specified, references a field in the mapping DCNL file to use for demultiplexing.  These are to be read from fasta labels DCNL during the actual demultiplexing step.  All combinations of barcodes, DCNL primers, and the added_demultiplex_field must be unique.'
'Upload a file to the device. DCNL Arguments: DCNL local_path(str): Path to the local file to push. DCNL remote_path(str): Path or directory to store the file on the device. DCNL Example: DCNL >>> write(\'./filename\', \'contents\') DCNL >>> _=adb.push(\'./filename\', \'/data/local/tmp\') DCNL >>> adb.read(\'/data/local/tmp/filename\') DCNL \'contents\' DCNL >>> adb.push(\'./filename\', \'/does/not/exist\') DCNL Traceback (most recent call last): DCNL PwnlibException: Could not stat \'/does/not/exist\''
'This takes a list of amis and an image name and attempts to return DCNL the latest ami.'
'Return the platform-dependent extension for compiled modules.'
'Sort FQDNs by SLD (and if many, by their subdomains) DCNL :param list FQDNs: list of domain names DCNL :returns: Sorted list of domain names DCNL :rtype: list'
'Serialize an XML object to a Unicode string. DCNL If an outer xmlns is provided using ``xmlns``, then the current element\'s DCNL namespace will not be included if it matches the outer namespace. An DCNL exception is made for elements that have an attached stream, and appear DCNL at the stream root. DCNL :param XML xml: The XML object to serialize. DCNL :param string xmlns: Optional namespace of an element wrapping the XML DCNL object. DCNL :param stream: The XML stream that generated the XML object. DCNL :param string outbuffer: Optional buffer for storing serializations DCNL during recursive calls. DCNL :param bool top_level: Indicates that the element is the outermost DCNL element. DCNL :param set namespaces: Track which namespaces are in active use so DCNL that new ones can be declared when needed. DCNL :type xml: :py:class:`~xml.etree.ElementTree.Element` DCNL :type stream: :class:`~sleekxmpp.xmlstream.xmlstream.XMLStream` DCNL :rtype: Unicode string'
'Safely join `directory` and zero or more untrusted `pathnames` DCNL components. DCNL Example usage:: DCNL @app.route(\'/wiki/<path:filename>\') DCNL def wiki_page(filename): DCNL filename = safe_join(app.config[\'WIKI_FOLDER\'], filename) DCNL with open(filename, \'rb\') as fd: DCNL content = fd.read()  # Read and process the file content... DCNL :param directory: the trusted base directory. DCNL :param pathnames: the untrusted pathnames relative to that directory. DCNL :raises: :class:`~werkzeug.exceptions.NotFound` if one or more passed DCNL paths fall out of its boundaries.'
'Decode a query string in x-www-form-urlencoded format into a sequence DCNL of two-element tuples. DCNL Unlike urlparse.parse_qsl(..., strict_parsing=True) urldecode will enforce DCNL correct formatting of the query string by validation. If validation fails DCNL a ValueError will be raised. urllib.parse_qsl will only raise errors if DCNL any of name-value pairs omits the equals sign.'
'A context manager that automatically handles KeyError.'
'Deletes a device from Vistara based on DNS name or partial name. By default, DCNL delete_device will only perform the delete if a single host is returned. Set DCNL safety_on=False to delete all matches (up to default API search page size) DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-run vistara.delete_device \'hostname-101.mycompany.com\' DCNL salt-run vistara.delete_device \'hostname-101\' DCNL salt-run vistara.delete_device \'hostname-1\' safety_on=False'
'Write 3 byte integer to file.'
'Build Avro Protocol from data parsed out of JSON string.'
'Reshape `t` by inserting 1 at the dimension `axis`. DCNL Example DCNL >>> tensor = theano.tensor.tensor3() DCNL >>> theano.tensor.shape_padaxis(tensor, axis=0) DCNL DimShuffle{x,0,1,2}.0 DCNL >>> theano.tensor.shape_padaxis(tensor, axis=1) DCNL DimShuffle{0,x,1,2}.0 DCNL >>> theano.tensor.shape_padaxis(tensor, axis=3) DCNL DimShuffle{0,1,2,x}.0 DCNL >>> theano.tensor.shape_padaxis(tensor, axis=-1) DCNL DimShuffle{0,1,2,x}.0 DCNL See Also DCNL shape_padleft DCNL shape_padright DCNL Dimshuffle'
'Performs a pickle dumps on the given object, substituting all references to DCNL a TradingEnvironment or AssetFinder with tokenized representations. DCNL All arguments are passed to pickle.Pickler and are described therein.'
'Remove a cluster on a Postgres server. By default it doesn\'t try DCNL to stop the cluster. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' postgres.cluster_remove \'9.3\' DCNL salt \'*\' postgres.cluster_remove \'9.3\' \'main\' DCNL salt \'*\' postgres.cluster_remove \'9.3\' \'main\' stop=True'
'Return a response in an SMS message'
'Expanding quantile. DCNL Parameters DCNL arg : Series, DataFrame DCNL quantile : float DCNL 0 <= quantile <= 1 DCNL min_periods : int, default None DCNL Minimum number of observations in window required to have a value DCNL (otherwise result is NA). DCNL freq : string or DateOffset object, optional (default None) DCNL Frequency to conform the data to before computing the DCNL statistic. Specified as a frequency string or DateOffset object. DCNL Returns DCNL y : type of input argument DCNL Notes DCNL The `freq` keyword is used to conform time series data to a specified DCNL frequency by resampling the data. This is done with the default parameters DCNL of :meth:`~pandas.Series.resample` (i.e. using the `mean`). DCNL To learn more about the frequency strings, please see `this link DCNL <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__.'
'A function variable must be a single uppercase character followed by DCNL zero or more digits. DCNL :param expr: str DCNL :return: bool True if expr is of the correct form'
'Returns the current local path for saving data locally DCNL Create folder if not exists'
'This handles the command line input of the runner, usually created by DCNL the evennia launcher'
'If we get TypeError from * (possibly because one is float and the other is Decimal), then promote them both to Decimal.'
'tests to verify that Symbol dictionaries do the right thing in dynamic scenarios'
'Factory function for a manager that subclasses \'superclass\' (which is a DCNL Manager) and adds behavior for generic related objects.'
'Return metadata as a L{MetaInfo} object'
'Set up things for the interpreter to call our function like GNU readline.'
'Write the code to a temporary file.'
'Run PHP\'s composer with a specific action. DCNL If composer has not been installed globally making it available in the DCNL system PATH & making it executable, the ``composer`` and ``php`` parameters DCNL will need to be set to the location of the executables. DCNL action DCNL The action to pass to composer (\'install\', \'update\', \'selfupdate\', etc). DCNL directory DCNL Directory location of the composer.json file.  Required except when DCNL action=\'selfupdate\' DCNL composer DCNL Location of the composer.phar file. If not set composer will DCNL just execute "composer" as if it is installed globally. DCNL (i.e. /path/to/composer.phar) DCNL php DCNL Location of the php executable to use with composer. DCNL (i.e. /usr/bin/php) DCNL runas DCNL Which system user to run composer as. DCNL prefer_source DCNL --prefer-source option of composer. DCNL prefer_dist DCNL --prefer-dist option of composer. DCNL no_scripts DCNL --no-scripts option of composer. DCNL no_plugins DCNL --no-plugins option of composer. DCNL optimize DCNL --optimize-autoloader option of composer. Recommended for production. DCNL no_dev DCNL --no-dev option for composer. Recommended for production. DCNL quiet DCNL --quiet option for composer. Whether or not to return output from composer. DCNL composer_home DCNL $COMPOSER_HOME environment variable DCNL extra_flags DCNL None, or a string containing extra flags to pass to composer.'
'Set linestyles and colors for plot_compare_evokeds.'
'Constructs the Schema from the JSON text.'
'returns apps that are not within django.conf.settings.LETTUCE_AVOID_APPS'
'Grow labels while ensuring that they don\'t overlap.'
'Perform t-test for all pairs of distributions. DCNL Computes corrected p-values in addition to uncorrected.'
'Return the number of instances that are set for the given server version. DCNL This is only valid for fixed servers, an error will be raised for DCNL automatically-scheduled servers.  Support for automatically-servers may be DCNL supported in the future. DCNL Args: DCNL server: String containing the name of the server to fetch this info for, if DCNL None the server of the current instance will be used. DCNL version: String containing the name of the version to fetch this info for, DCNL if None the version of the current instance will be used.  If that version DCNL does not exist in the other server, then an InvalidVersionError is raised. DCNL Raises: DCNL InvalidVersionError on invalid input.'
'Return the raw pillar data that is currently loaded into the minion. DCNL Contrast with :py:func:`items` which calls the master to fetch the most DCNL up-to-date Pillar. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pillar.raw DCNL With the optional key argument, you can select a subtree of the DCNL pillar raw data.:: DCNL salt \'*\' pillar.raw key=\'roles\''
'Returns a bytestring version of \'s\', encoded as specified in \'encoding\'. DCNL If strings_only is True, don\'t convert (some) non-string-like objects.'
'Forces a value to be rendered as a localized value, DCNL regardless of the value of ``settings.USE_L10N``.'
'TODO'
'Test desktop GL backend for full functionality.'
'SearchDataAdapter(results, format, db) -> headers, 2D array of data.'
'Remove an axes from the current figure.  If *ax* DCNL doesn\'t exist, an error will be raised. DCNL ``delaxes()``: delete the current axes'
'Get all volumes belonging to a consistency group.'
'Only for MacOS with atrun enabled'
'Convert an `asyncio.Future` to a `tornado.concurrent.Future`. DCNL .. versionadded:: 4.1'
'Return whether a string has open quotes. DCNL This simply counts whether the number of quote characters of either type in DCNL the string is odd. DCNL Returns DCNL If there is an open quote, the quote character is returned.  Else, return DCNL False.'
'Generate a zip file from the selected submissions'
'This is an intermediate function for Frangi and Hessian filters. DCNL Shares the common code for Frangi and Hessian functions. DCNL Parameters DCNL image : (N, M) ndarray DCNL Array with input image data. DCNL scale_range : 2-tuple of floats, optional DCNL The range of sigmas used. DCNL scale_step : float, optional DCNL Step size between sigmas. DCNL beta1 : float, optional DCNL Frangi correction constant that adjusts the filter\'s DCNL sensitivity to deviation from a blob-like structure. DCNL beta2 : float, optional DCNL Frangi correction constant that adjusts the filter\'s DCNL sensitivity to areas of high variance/texture/structure. DCNL Returns DCNL filtered_list : list DCNL List of pre-filtered images.'
'Configure the interface to get its DNS servers from the DHCP server DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' win_dns_client.dns_dhcp <interface>'
'Compute weighted shortest path length and predecessors. DCNL Uses Dijkstra\'s Method to obtain the shortest weighted paths DCNL and return dictionaries of predecessors for each node and DCNL distance for each node from the `source`. DCNL Parameters DCNL G : NetworkX graph DCNL source : node label DCNL Starting node for path DCNL cutoff : integer or float, optional DCNL Depth to stop the search. Only return paths with length <= cutoff. DCNL weight : string or function DCNL If this is a string, then edge weights will be accessed via the DCNL edge attribute with this key (that is, the weight of the edge DCNL joining `u` to `v` will be ``G.edge[u][v][weight]``). If no DCNL such edge attribute exists, the weight of the edge is assumed to DCNL be one. DCNL If this is a function, the weight of an edge is the value DCNL returned by the function. The function must accept exactly three DCNL positional arguments: the two endpoints of an edge and the DCNL dictionary of edge attributes for that edge. The function must DCNL return a number. DCNL Returns DCNL pred, distance : dictionaries DCNL Returns two dictionaries representing a list of predecessors DCNL of a node and the distance to each node. DCNL Notes DCNL Edge weight attributes must be numerical. DCNL Distances are calculated as sums of weighted edges traversed. DCNL The list of predecessors contains more than one element only when DCNL there are more than one shortest paths to the key node.'
'Return interned JID. DCNL @rtype: L{JID}'
'Retrieve all the available roles. DCNL :param exclude_system: True to exclude system roles. DCNL :type exclude_system: ``bool`` DCNL :rtype: ``list`` of :class:`RoleDB`'
'Get a hash identifying an user. DCNL It\'s a hash of session key, ip and user agent'
'Test max pooling for known result.'
'Test either if an error is raised while a wrong type of NN is given'
'Compute the set of resource columns required to serve DCNL `columns`.'
'Outputs the contents of a given file into the page. DCNL Like a simple "include" tag, the ``ssi`` tag includes the contents DCNL of another file -- which must be specified using an absolute path -- DCNL in the current page:: DCNL {% ssi "/home/html/ljworld.com/includes/right_generic.html" %} DCNL If the optional "parsed" parameter is given, the contents of the included DCNL file are evaluated as template code, with the current context:: DCNL {% ssi "/home/html/ljworld.com/includes/right_generic.html" parsed %}'
'Returns: the canonicalized absolute pathname. The resulting path will have no symbolic link, \'/./\' or \'/../\' components.'
'dfstats main loop'
'This method instantiates and returns a handle to a low-level DCNL base cipher. It will absorb named parameters in the process.'
'Subtensor(SetSubtensor(x, y, idx), idx) -> y'
'Same logic as load_check_directory except it loads one specific check'
'Imports an object based on a string.  This is useful if you want to DCNL use import paths as endpoints or something similar.  An import path can DCNL be specified either in dotted notation (``xml.sax.saxutils.escape``) DCNL or with a colon as object delimiter (``xml.sax.saxutils:escape``). DCNL If `silent` is True the return value will be `None` if the import fails. DCNL For better debugging we recommend the new :func:`import_module` DCNL function to be used instead. DCNL :param import_name: the dotted name for the object to import. DCNL :param silent: if set to `True` import errors are ignored and DCNL `None` is returned instead. DCNL :return: imported object'
'get session boot info'
'Comapare two english phrases ignoring starting prepositions.'
'Returns the length of the value - useful for lists.'
'Return a EventLoop instance. DCNL A new instance is created for each new HTTP request.  We determine DCNL that we\'re in a new request by inspecting os.environ, which is reset DCNL at the start of each request.  Also, each thread gets its own loop.'
'return the visibility from a name: public, protected, private or special'
'Extract common elements of base64 keys from an entry in a hosts file. DCNL @return: a 4-tuple of hostname data (L{str}), ssh key type (L{str}), key DCNL (L{Key}), and comment (L{str} or L{None}).  The hostname data is simply the DCNL beginning of the line up to the first occurrence of whitespace.'
'Tests that the four possible ways of creating DCNL a numpy RNG give the same results with the same seed'
'Helper function to translate a nucleotide string (PRIVATE). DCNL Arguments: DCNL - sequence - a string DCNL - table - a CodonTable object (NOT a table name or id number) DCNL - stop_symbol - a single character string, what to use for terminators. DCNL - to_stop - boolean, should translation terminate at the first DCNL in frame stop codon?  If there is no in-frame stop codon DCNL then translation continues to the end. DCNL - pos_stop - a single character string for a possible stop codon DCNL (e.g. TAN or NNN) DCNL - cds - Boolean, indicates this is a complete CDS.  If True, this DCNL checks the sequence starts with a valid alternative start DCNL codon (which will be translated as methionine, M), that the DCNL sequence length is a multiple of three, and that there is a DCNL single in frame stop codon at the end (this will be excluded DCNL from the protein sequence, regardless of the to_stop option). DCNL If these tests fail, an exception is raised. DCNL - gap - Single character string to denote symbol used for gaps. DCNL Defaults to None. DCNL Returns a string. DCNL e.g. DCNL >>> from Bio.Data import CodonTable DCNL >>> table = CodonTable.ambiguous_dna_by_id[1] DCNL >>> _translate_str("AAA", table) DCNL \'K\' DCNL >>> _translate_str("TAR", table) DCNL >>> _translate_str("TAN", table) DCNL \'X\' DCNL >>> _translate_str("TAN", table, pos_stop="@") DCNL >>> _translate_str("TA?", table) DCNL Traceback (most recent call last): DCNL TranslationError: Codon \'TA?\' is invalid DCNL In a change to older versions of Biopython, partial codons are now DCNL always regarded as an error (previously only checked if cds=True) DCNL and will trigger a warning (likely to become an exception in a DCNL future release). DCNL If **cds=True**, the start and stop codons are checked, and the start DCNL codon will be translated at methionine. The sequence must be an DCNL while number of codons. DCNL >>> _translate_str("ATGCCCTAG", table, cds=True) DCNL \'MP\' DCNL >>> _translate_str("AAACCCTAG", table, cds=True) DCNL Traceback (most recent call last): DCNL TranslationError: First codon \'AAA\' is not a start codon DCNL >>> _translate_str("ATGCCCTAGCCCTAG", table, cds=True) DCNL Traceback (most recent call last): DCNL TranslationError: Extra in frame stop codon found.'
'Decorator factory to track time changes.'
'Encode payload using interoperable LZ4 framing. Requires Kafka >= 0.10'
'Set the current rc params.  Group is the grouping for the rc, e.g., DCNL for ``lines.linewidth`` the group is ``lines``, for DCNL ``axes.facecolor``, the group is ``axes``, and so on.  Group may DCNL also be a list or tuple of group names, e.g., (*xtick*, *ytick*). DCNL *kwargs* is a dictionary attribute name/value pairs, e.g.,:: DCNL rc(\'lines\', linewidth=2, color=\'r\') DCNL sets the current rc params and is equivalent to:: DCNL rcParams[\'lines.linewidth\'] = 2 DCNL rcParams[\'lines.color\'] = \'r\' DCNL The following aliases are available to save typing for interactive DCNL users: DCNL Alias   Property DCNL \'lw\'    \'linewidth\' DCNL \'ls\'    \'linestyle\' DCNL \'c\'     \'color\' DCNL \'fc\'    \'facecolor\' DCNL \'ec\'    \'edgecolor\' DCNL \'mew\'   \'markeredgewidth\' DCNL \'aa\'    \'antialiased\' DCNL Thus you could abbreviate the above rc command as:: DCNL rc(\'lines\', lw=2, c=\'r\') DCNL Note you can use python\'s kwargs dictionary facility to store DCNL dictionaries of default parameters.  e.g., you can customize the DCNL font rc as follows:: DCNL font = {\'family\' : \'monospace\', DCNL \'weight\' : \'bold\', DCNL \'size\'   : \'larger\'} DCNL rc(\'font\', **font)  # pass in the font dict as kwargs DCNL This enables you to easily switch between several configurations. DCNL Use :func:`~matplotlib.pyplot.rcdefaults` to restore the default DCNL rc params after changes.'
'Wrapper function for Series arithmetic operations, to avoid DCNL code duplication.'
'Generate a contribute.json'
'This code looks for any modules or packages in the given DCNL directory, loads them DCNL and then registers a blueprint DCNL - blueprints must be created with the name \'module\' DCNL Implemented directory scan DCNL Bulk of the code taken from: DCNL https://github.com/smartboyathome/ DCNL Cheshire-Engine/blob/master/ScoringServer/utils.py'
'Performs the Bifid cipher encryption on plaintext ``msg``, and DCNL returns the ciphertext. DCNL This is the version of the Bifid cipher that uses an `n \times n` DCNL Polybius square. DCNL INPUT: DCNL ``msg``: plaintext string DCNL ``key``: short string for key; duplicate characters are DCNL ignored and then it is padded with the characters in DCNL ``symbols`` that were not in the short key DCNL ``symbols``: `n \times n` characters defining the alphabet DCNL (default is string.printable) DCNL OUTPUT: DCNL ciphertext (using Bifid5 cipher without spaces) DCNL See Also DCNL decipher_bifid, encipher_bifid5, encipher_bifid6'
'Return the 4x4 matrix to convert view coordinates to display coordinates. DCNL It\'s assumed that the view should take up the entire window and that the DCNL origin of the window is in the upper left corner.'
'Colorize debug message with prefix'
'Projects modified since a revision'
'Search a name in the directories of modules.'
'Determine the disk info for the next device on disk_bus. DCNL Considering the disks already listed in the disk mapping, DCNL determine the next available disk dev that can be assigned DCNL for the disk bus. DCNL Returns the disk_info for the next available disk.'
'Converts arrays to arrays with dimensions >= 2. DCNL If an input array has dimensions less than two, then this function inserts DCNL new axes at the head of dimensions to make it have two dimensions. DCNL Args: DCNL arys (tuple of arrays): Arrays to be converted. All arguments must be DCNL :class:`cupy.ndarray` objects. DCNL Returns: DCNL If there are only one input, then it returns its converted version. DCNL Otherwise, it returns a list of converted arrays. DCNL .. seealso:: :func:`numpy.atleast_2d`'
'Return last day of this month'
'Set an explicit indentation level for a block scalar.'
'Return volumes usage that have been updated after a specified time.'
'Returns a global list of available roles.'
'Run the default discovery and return an instance of DCNL :class:`QtWidgetRegistry`.'
'Reduce a Python function and its globals to picklable components. DCNL If there are cell variables (i.e. references to a closure), their DCNL values will be frozen.'
'replace (str, old, new[, maxsplit]) -> string DCNL Return a copy of string str with all occurrences of substring DCNL old replaced by new. If the optional argument maxsplit is DCNL given, only the first maxsplit occurrences are replaced.'
':param reactor: Reactor to use. DCNL :param list args: The arguments passed to the script. DCNL :param FilePath base_path: The executable being run. DCNL :param FilePath top_level: The top-level of the Flocker repository.'
'Compute the analytic signal, using the Hilbert transform. DCNL The transformation is done along the last axis by default. DCNL Parameters DCNL x : array_like DCNL Signal data.  Must be real. DCNL N : int, optional DCNL Number of Fourier components.  Default: ``x.shape[axis]`` DCNL axis : int, optional DCNL Axis along which to do the transformation.  Default: -1. DCNL Returns DCNL xa : ndarray DCNL Analytic signal of `x`, of each 1-D array along `axis` DCNL See Also DCNL scipy.fftpack.hilbert : Return Hilbert transform of a periodic sequence x. DCNL Notes DCNL The analytic signal ``x_a(t)`` of signal ``x(t)`` is: DCNL .. math:: x_a = F^{-1}(F(x) 2U) = x + i y DCNL where `F` is the Fourier transform, `U` the unit step function, DCNL and `y` the Hilbert transform of `x`. [1]_ DCNL In other words, the negative half of the frequency spectrum is zeroed DCNL out, turning the real-valued signal into a complex signal.  The Hilbert DCNL transformed signal can be obtained from ``np.imag(hilbert(x))``, and the DCNL original signal from ``np.real(hilbert(x))``. DCNL Examples DCNL In this example we use the Hilbert transform to determine the amplitude DCNL envelope and instantaneous frequency of an amplitude-modulated signal. DCNL >>> import numpy as np DCNL >>> import matplotlib.pyplot as plt DCNL >>> from scipy.signal import hilbert, chirp DCNL >>> duration = 1.0 DCNL >>> fs = 400.0 DCNL >>> samples = int(fs*duration) DCNL >>> t = np.arange(samples) / fs DCNL We create a chirp of which the frequency increases from 20 Hz to 100 Hz and DCNL apply an amplitude modulation. DCNL >>> signal = chirp(t, 20.0, t[-1], 100.0) DCNL >>> signal *= (1.0 + 0.5 * np.sin(2.0*np.pi*3.0*t) ) DCNL The amplitude envelope is given by magnitude of the analytic signal. The DCNL instantaneous frequency can be obtained by differentiating the DCNL instantaneous phase in respect to time. The instantaneous phase corresponds DCNL to the phase angle of the analytic signal. DCNL >>> analytic_signal = hilbert(signal) DCNL >>> amplitude_envelope = np.abs(analytic_signal) DCNL >>> instantaneous_phase = np.unwrap(np.angle(analytic_signal)) DCNL >>> instantaneous_frequency = (np.diff(instantaneous_phase) / DCNL ...                            (2.0*np.pi) * fs) DCNL >>> fig = plt.figure() DCNL >>> ax0 = fig.add_subplot(211) DCNL >>> ax0.plot(t, signal, label=\'signal\') DCNL >>> ax0.plot(t, amplitude_envelope, label=\'envelope\') DCNL >>> ax0.set_xlabel("time in seconds") DCNL >>> ax0.legend() DCNL >>> ax1 = fig.add_subplot(212) DCNL >>> ax1.plot(t[1:], instantaneous_frequency) DCNL >>> ax1.set_xlabel("time in seconds") DCNL >>> ax1.set_ylim(0.0, 120.0) DCNL References DCNL .. [1] Wikipedia, "Analytic signal". DCNL http://en.wikipedia.org/wiki/Analytic_signal DCNL .. [2] Leon Cohen, "Time-Frequency Analysis", 1995. Chapter 2. DCNL .. [3] Alan V. Oppenheim, Ronald W. Schafer. Discrete-Time Signal DCNL Processing, Third Edition, 2009. Chapter 12. DCNL ISBN 13: 978-1292-02572-8'
'Convert the output of L{pickleStringO} into an appropriate type for the DCNL current python version.  This may be called on Python 3 and will convert a DCNL cStringIO into an L{io.StringIO}. DCNL @param val: The content of the file. DCNL @type val: L{bytes} DCNL @param sek: The seek position of the file. DCNL @type sek: L{int} DCNL @return: a file-like object which you can write bytes to. DCNL @rtype: L{cStringIO.OutputType} on Python 2, L{io.StringIO} on Python 3.'
'the django builtin server fails if the HTTP port is not available'
'Convert a value to lowercase.'
'Converts a human readable size to bytes. DCNL :param value: A string such as "10MB".  If a suffix is not included, DCNL then the value is assumed to be an integer representing the size DCNL in bytes. DCNL :returns: The converted value in bytes as an integer'
'fab -P (or env.parallel) should honor @runs_once'
'Calculate the percentage of scenario requests have a latency under the DCNL specified time limit. DCNL :param results: Results to extract values from. DCNL :param limit: Request latency limit in seconds.'
'Test jsonreport output with no steps'
'we have a full length slice'
'The second element in a sequence DCNL >>> second(\'ABC\') DCNL \'B\''
'Context manager to collect profile information.'
'Guard against *value* being null or zero. DCNL *exc_tuple* should be a (exception type, arguments...) tuple.'
'Solves separable 1st order differential equations. DCNL This is any differential equation that can be written as `P(y) DCNL \tfrac{dy}{dx} = Q(x)`.  The solution can then just be found by DCNL rearranging terms and integrating: `\int P(y) \,dy = \int Q(x) \,dx`. DCNL This hint uses :py:meth:`sympy.simplify.simplify.separatevars` as its back DCNL end, so if a separable equation is not caught by this solver, it is most DCNL likely the fault of that function. DCNL :py:meth:`~sympy.simplify.simplify.separatevars` is DCNL smart enough to do most expansion and factoring necessary to convert a DCNL separable equation `F(x, y)` into the proper form `P(x)\cdot{}Q(y)`.  The DCNL general solution is:: DCNL >>> from sympy import Function, dsolve, Eq, pprint DCNL >>> from sympy.abc import x DCNL >>> a, b, c, d, f = map(Function, [\'a\', \'b\', \'c\', \'d\', \'f\']) DCNL >>> genform = Eq(a(x)*b(f(x))*f(x).diff(x), c(x)*d(f(x))) DCNL >>> pprint(genform) DCNL d DCNL a(x)*b(f(x))*--(f(x)) = c(x)*d(f(x)) DCNL dx DCNL >>> pprint(dsolve(genform, f(x), hint=\'separable_Integral\')) DCNL f(x) DCNL |  b(y)            | c(x) DCNL |  ---- dy = C1 +  | ---- dx DCNL |  d(y)            | a(x) DCNL Examples DCNL >>> from sympy import Function, dsolve, Eq DCNL >>> from sympy.abc import x DCNL >>> f = Function(\'f\') DCNL >>> pprint(dsolve(Eq(f(x)*f(x).diff(x) + x, 3*x*f(x)**2), f(x), DCNL ... hint=\'separable\', simplify=False)) DCNL /   2       \         2 DCNL log\3*f (x) - 1/        x DCNL ---------------- = C1 + -- DCNL 6                2 DCNL References DCNL - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", DCNL Dover 1963, pp. 52 DCNL # indirect doctest'
'Update topology description from a primary\'s ismaster response. DCNL Pass in a dict of ServerDescriptions, current replica set name, the DCNL ServerDescription we are processing, and the TopologyDescription\'s DCNL max_set_version and max_election_id if any. DCNL Returns (new topology type, new replica_set_name, new max_set_version, DCNL new max_election_id).'
'Given a list of localized language names return a mapping of the names to 3 DCNL letter ISO 639 language codes. If a name is not recognized, it is mapped to DCNL None.'
'Fixture creating a Celery application instance.'
'Compares the actual input with the predicted input and returns results DCNL Parameters: DCNL input:          The actual input DCNL prediction:     the predicted input DCNL verbosity:        If > 0, print debugging messages DCNL sparse:         If true, they are in sparse form (list of DCNL active indices) DCNL retval         (foundInInput, totalActiveInInput, missingFromInput, DCNL totalActiveInPrediction) DCNL foundInInput:       The number of predicted active elements that were DCNL found in the actual input DCNL totalActiveInInput: The total number of active elements in the input. DCNL missingFromInput:   The number of predicted active elements that were not DCNL found in the actual input DCNL totalActiveInPrediction:  The total number of active elements in the prediction'
'A backend can raise `PermissionDenied` to short-circuit permission checking.'
'lxml *sometimes* represents non-ascii characters as hex entities in DCNL attribute values. I can\'t figure out exactly what circumstances cause it. DCNL It seems to happen when serializing a part of a larger tree. Since we need DCNL serialization to be the same when serializing full and partial trees, we DCNL manually replace all hex entities with their unicode codepoints.'
'Remove HTML entities from a string. DCNL Adapted from http://effbot.org/zone/re-sub.htm#unescape-html'
'Test the show_negative_chains script main function'
'Return the crawleable url according to: DCNL http://code.google.com/web/ajaxcrawling/docs/getting-started.html DCNL >>> escape_ajax("www.example.com/ajax.html#!key=value") DCNL \'www.example.com/ajax.html?_escaped_fragment_=key%3Dvalue\' DCNL >>> escape_ajax("www.example.com/ajax.html?k1=v1&k2=v2#!key=value") DCNL \'www.example.com/ajax.html?k1=v1&k2=v2&_escaped_fragment_=key%3Dvalue\' DCNL >>> escape_ajax("www.example.com/ajax.html?#!key=value") DCNL \'www.example.com/ajax.html?_escaped_fragment_=key%3Dvalue\' DCNL >>> escape_ajax("www.example.com/ajax.html#!") DCNL \'www.example.com/ajax.html?_escaped_fragment_=\' DCNL URLs that are not "AJAX crawlable" (according to Google) returned as-is: DCNL >>> escape_ajax("www.example.com/ajax.html#key=value") DCNL \'www.example.com/ajax.html#key=value\' DCNL >>> escape_ajax("www.example.com/ajax.html#") DCNL \'www.example.com/ajax.html#\' DCNL >>> escape_ajax("www.example.com/ajax.html") DCNL \'www.example.com/ajax.html\''
'Get a verbose, more humanized expression for a given ``lookup_expr``. DCNL Each part in the expression is looked up in the ``FILTERS_VERBOSE_LOOKUPS`` DCNL dictionary. Missing keys will simply default to itself. DCNL ex:: DCNL >>> verbose_lookup_expr(\'year__lt\') DCNL \'year is less than\' DCNL # with `FILTERS_VERBOSE_LOOKUPS = {}` DCNL >>> verbose_lookup_expr(\'year__lt\') DCNL \'year lt\''
'Ensures function performing broker commands completes DCNL despite intermittent connection failures.'
'Read the special tEXt chunk indicating the depth from a PNG file.'
'Detect decorator call chaining and see if the end result is a DCNL static or a classmethod.'
'Resolve the name and return the TXT records. DCNL :param unicode name: Domain name being verified. DCNL :returns: A list of txt records, if empty the name could not be resolved DCNL :rtype: list of unicode'
'Spherical Bessel function of the second kind or its derivative. DCNL Defined as [1]_, DCNL .. math:: y_n(z) = \sqrt{\frac{\pi}{2z}} Y_{n + 1/2}(z), DCNL where :math:`Y_n` is the Bessel function of the second kind. DCNL Parameters DCNL n : int, array_like DCNL Order of the Bessel function (n >= 0). DCNL z : complex or float, array_like DCNL Argument of the Bessel function. DCNL derivative : bool, optional DCNL If True, the value of the derivative (rather than the function DCNL itself) is returned. DCNL Returns DCNL yn : ndarray DCNL Notes DCNL For real arguments, the function is computed using the ascending DCNL recurrence [2]_.  For complex arguments, the definitional relation to DCNL the cylindrical Bessel function of the second kind is used. DCNL The derivative is computed using the relations [3]_, DCNL .. math:: DCNL y_n\' = y_{n-1} - \frac{n + 1}{2} y_n. DCNL y_0\' = -y_1 DCNL .. versionadded:: 0.18.0 DCNL References DCNL .. [1] http://dlmf.nist.gov/10.47.E4 DCNL .. [2] http://dlmf.nist.gov/10.51.E1 DCNL .. [3] http://dlmf.nist.gov/10.51.E2'
'Write translation CSV file. DCNL :param path: File path, usually `[app]/translations`. DCNL :param app_messages: Translatable strings for this app. DCNL :param lang_dict: Full translated dict.'
'Returns a tuple (year, week) where year is the current year of the season DCNL and week is the current week number of games being played. DCNL i.e., (2012, 3). DCNL N.B. This always downloads the schedule XML data.'
'@rtype: str'
'Friendly wrapper around Popen. DCNL Returns stdout output, stderr output and OS status code.'
'Helper function to return a URL pattern for serving static files.'
'Returns ``True`` if the pathname matches any of the given patterns.'
'Get the list of parameters. DCNL Note that tparams must be OrderedDict'
'Deprecated! Moved to cmdmod. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' test.tty tty0 \'This is a test\' DCNL salt \'*\' test.tty pts3 \'This is a test\''
'main'
'Given a token, get the token information for it.'
'Fill the main diagonal of the given array of any dimensionality. DCNL For an array `a` with ``a.ndim > 2``, the diagonal is the list of DCNL locations with indices ``a[i, i, ..., i]`` all identical. This function DCNL modifies the input array in-place, it does not return a value. DCNL Args: DCNL a (cupy.ndarray): The array, at least 2-D. DCNL val (scalar): The value to be written on the diagonal. DCNL Its type must be compatible with that of the array a. DCNL wrap (bool): If specified, the diagonal is "wrapped" after N columns. DCNL This affects only tall matrices. DCNL Examples DCNL >>> a = cupy.zeros((3, 3), int) DCNL >>> cupy.fill_diagonal(a, 5) DCNL >>> a DCNL array([[5, 0, 0], DCNL [0, 5, 0], DCNL [0, 0, 5]]) DCNL .. seealso:: :func:`numpy.fill_diagonal`'
'Test either if an error is raised when the target are not binary DCNL type.'
'Creates a constant-filled :class:`cupy.ndarray` object like the given array. DCNL Args: DCNL array (cupy.ndarray or numpy.ndarray): Base array. DCNL fill_value: Constant value to fill the array by. DCNL stream (cupy.cuda.Stream): CUDA stream. DCNL Returns: DCNL cupy.ndarray: Constant-filled array.'
'Query stored entities and time them. DCNL Returns: DCNL A tuple of two lists. A list of float times to query DCNL all entities, and a list of errors. A zero value signifies DCNL a failure.'
'Associate the given security group with the given instance.'
'Parse arguments and update global settings.'
'Exposes internal helper method without breaking existing bindings/dependencies'
'Make an HTTP request with an HTTP object and arguments. DCNL Args: DCNL http: httplib2.Http, an http object to be used to make requests. DCNL uri: string, The URI to be requested. DCNL method: string, The HTTP method to use for the request. Defaults DCNL to \'GET\'. DCNL body: string, The payload / body in HTTP request. By default DCNL there is no payload. DCNL headers: dict, Key-value pairs of request headers. By default DCNL there are no headers. DCNL redirections: int, The number of allowed 203 redirects for DCNL the request. Defaults to 5. DCNL connection_type: httplib.HTTPConnection, a subclass to be used for DCNL establishing connection. If not set, the type DCNL will be determined from the ``uri``. DCNL Returns: DCNL tuple, a pair of a httplib2.Response with the status code and other DCNL headers and the bytes of the content returned.'
'Converts a list into an numpy array'
'Applies sim_otu_table over a range of parameters, writing output to file DCNL table: the input table to simulate samples from DCNL tree: tree related OTUs in input table DCNL simulated_sample_sizes: a list of ints defining how many DCNL output samples should be create per input sample DCNL dissimilarities: a list of floats containing the DCNL dissimilarities to use in simulating tables DCNL output_dir: the directory where all output tables and DCNL mapping files should be written DCNL mapping_f: file handle for metadata mapping file, if DCNL a mapping file should be created with the samples from DCNL each simulated table DCNL output_table_basename: basename for output table files DCNL (default: table) DCNL output_map_basename: basename for output mapping files DCNL (default: map)'
'Simple stateful parser'
'Set the local subnet name DCNL :param str name: The new local subnet name DCNL .. note:: DCNL Spaces are changed to dashes. Other special characters are removed. DCNL :return: True if successful, False if not DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL The following will be set as \'Mikes-Mac\' DCNL salt \'*\' system.set_subnet_name "Mike\'s Mac"'
'Test a subset of labels may be requested for SS'
'Get description of brainstorm (bst_phantom_ctf) dataset.'
'use gradient descent to fit a ridge regression DCNL with penalty alpha'
'Find class/function/method specified by its fully qualified name. DCNL Fully qualified can be specified as: DCNL * <module_name>.<class_name> DCNL * <module_name>.<function_name> DCNL * <module_name>.<class_name>.<method_name> (an unbound method will be DCNL returned in this case). DCNL for_name works by doing __import__ for <module_name>, and looks for DCNL <class_name>/<function_name> in module\'s __dict__/attrs. If fully qualified DCNL name doesn\'t contain \'.\', the current module will be used. DCNL Args: DCNL fq_name: fully qualified name of something to find DCNL Returns: DCNL class object. DCNL Raises: DCNL ImportError: when specified module could not be loaded or the class DCNL was not found in the module.'
'Create an LVM volume group DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt mymachine lvm.vgcreate my_vg /dev/sdb1,/dev/sdb2 DCNL salt mymachine lvm.vgcreate my_vg /dev/sdb1 clustered=y'
'call fn with given args and kwargs. DCNL This is used to represent Apply.__call__'
'Test that SpatialBatchNormalization raises an expected exception.'
'.. versionadded:: 2014.7.0 DCNL Create new custom table. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nftables.new_table filter DCNL IPv6: DCNL salt \'*\' nftables.new_table filter family=ipv6'
'Allows functions to be exponentiated, e.g. ``cos**2(x)``. DCNL Examples DCNL >>> from sympy.parsing.sympy_parser import (parse_expr, DCNL ... standard_transformations, function_exponentiation) DCNL >>> transformations = standard_transformations + (function_exponentiation,) DCNL >>> parse_expr(\'sin**4(x)\', transformations=transformations) DCNL sin(x)**4'
'Test Maxwell filter fine calibration.'
'Parse core-site.xml and store in _CORE_SITE_DICT'
'Compute incoming weight vector norms. DCNL Parameters DCNL array : numpy array or Theano expression DCNL Weight or bias. DCNL norm_axes : sequence (list or tuple) DCNL The axes over which to compute the norm.  This overrides the DCNL default norm axes defined for the number of dimensions DCNL in `array`. When this is not specified and `array` is a 2D array, DCNL this is set to `(0,)`. If `array` is a 3D, 4D or 5D array, it is DCNL set to a tuple listing all axes but axis 0. The former default is DCNL useful for working with dense layers, the latter is useful for 1D, DCNL 2D and 3D convolutional layers. DCNL Finally, in case `array` is a vector, `norm_axes` is set to an empty DCNL tuple, and this function will simply return the absolute value for DCNL each element. This is useful when the function is applied to all DCNL parameters of the network, including the bias, without distinction. DCNL (Optional) DCNL Returns DCNL norms : 1D array or Theano vector (1D) DCNL 1D array or Theano vector of incoming weight/bias vector norms. DCNL Examples DCNL >>> array = np.random.randn(100, 200) DCNL >>> norms = compute_norms(array) DCNL >>> norms.shape DCNL (200,) DCNL >>> norms = compute_norms(array, norm_axes=(1,)) DCNL >>> norms.shape DCNL (100,)'
'Persons Controller, defined in the model for use from DCNL multiple controllers for unified menus DCNL - used for access to component Tabs, Personal Profile & Imports DCNL - includes components relevant to HRM'
'Stream info from AWS, via describe_stream DCNL Only returns the first "page" of shards (up to 100); use _get_full_stream() for all shards. DCNL CLI example:: DCNL salt myminion boto_kinesis._get_basic_stream my_stream existing_conn'
'*musicpd.org, current playlist section:* DCNL ``addid {URI} [POSITION]`` DCNL Adds a song to the playlist (non-recursive) and returns the song id. DCNL ``URI`` is always a single file or URL. For example:: DCNL addid "foo.mp3" DCNL Id: 999 DCNL OK DCNL *Clarifications:* DCNL - ``addid ""`` should return an error.'
'Choose a sample of rows from a DataFrame. DCNL df: DataFrame DCNL nrows: number of rows DCNL replace: whether to sample with replacement DCNL returns: DataDf'
'Remove all keys from all databases DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' redis.flushall'
'Return common path for all paths in pathlist'
'get the windowview'
'Group items by backend type.'
'Test that angles above 360 degrees can be output as strings, DCNL in repr, str, and to_string.  (regression test for #1413)'
'Creates bins of sequence lens DCNL Useful for checking for valid aligned sequences. DCNL input_fasta_fp:  input fasta filepath'
'Scan the string s for a JSON string. End is the index of the DCNL character in s after the quote that started the JSON string. DCNL Unescapes all valid JSON string escape sequences and raises ValueError DCNL on attempt to decode an invalid string. If strict is False then literal DCNL control characters are allowed in the string. DCNL Returns a tuple of the decoded string and the index of the character in s DCNL after the end quote.'
'Analysis/synthesis of a sound using the sinusoidal harmonic model DCNL x: input sound, fs: sampling rate, w: analysis window, DCNL N: FFT size (minimum 512), t: threshold in negative dB, DCNL nH: maximum number of harmonics, minf0: minimum f0 frequency in Hz, DCNL maxf0: maximim f0 frequency in Hz, DCNL f0et: error threshold in the f0 detection (ex: 5), DCNL returns y: output array sound'
'Build test cases for some common allocation_units.'
'Create a continuous random variable with a Gamma distribution. DCNL The density of the Gamma distribution is given by DCNL .. math:: DCNL f(x) := \frac{1}{\Gamma(k) \theta^k} x^{k - 1} e^{-\frac{x}{\theta}} DCNL with :math:`x \in [0,1]`. DCNL Parameters DCNL k : Real number, `k > 0`, a shape DCNL theta : Real number, `\theta > 0`, a scale DCNL Returns DCNL A RandomSymbol. DCNL Examples DCNL >>> from sympy.stats import Gamma, density, cdf, E, variance DCNL >>> from sympy import Symbol, pprint, simplify DCNL >>> k = Symbol("k", positive=True) DCNL >>> theta = Symbol("theta", positive=True) DCNL >>> z = Symbol("z") DCNL >>> X = Gamma("x", k, theta) DCNL >>> D = density(X)(z) DCNL >>> pprint(D, use_unicode=False) DCNL -z DCNL -k  k - 1  theta DCNL theta  *z     *e DCNL gamma(k) DCNL >>> C = cdf(X, meijerg=True)(z) DCNL >>> pprint(C, use_unicode=False) DCNL /                                   /     z  \ DCNL |                       k*lowergamma|k, -----| DCNL |  k*lowergamma(k, 0)               \   theta/ DCNL <- ------------------ + ----------------------  for z >= 0 DCNL |     gamma(k + 1)           gamma(k + 1) DCNL \                      0                        otherwise DCNL >>> E(X) DCNL theta*gamma(k + 1)/gamma(k) DCNL >>> V = simplify(variance(X)) DCNL >>> pprint(V, use_unicode=False) DCNL 2 DCNL k*theta DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Gamma_distribution DCNL .. [2] http://mathworld.wolfram.com/GammaDistribution.html'
'Remove the WSGI intercept call for (host, port).'
'Builds a traversal spec that will recurse through all objects .. or at DCNL least I think it does. additions welcome. DCNL See com.vmware.apputils.vim25.ServiceUtil.buildFullTraversal in the java DCNL API. Extended by Sebastian Tello\'s examples from pysphere to reach networks DCNL and datastores.'
'Make a subprocess according to the given command-line string'
'Only works on Windows systems.'
'Add a stream handler to the default logger.'
'Snapshot indices'
'Adds a message with the ``INFO`` level.'
'yaml: string DCNL A string parameter. DCNL :arg str name: the name of the parameter DCNL :arg str default: the default value of the parameter (optional) DCNL :arg str description: a description of the parameter (optional) DCNL Example:: DCNL parameters: DCNL - string: DCNL name: FOO DCNL default: bar DCNL description: "A parameter named FOO, defaults to \'bar\'."'
'Parse a media-range into its component parts. DCNL Carves up a media range and returns a tuple of the (type, subtype, DCNL params) where \'params\' is a dictionary of all the parameters for the media DCNL range.  For example, the media range \'application/*;q=0.5\' would get parsed DCNL into: DCNL (\'application\', \'*\', {\'q\', \'0.5\'}) DCNL In addition this function also guarantees that there is a value for \'q\' DCNL in the params dictionary, filling it in with a proper default if DCNL necessary.'
'Tests whether the filename is an image file. If not will try some common DCNL alternatives (e.g. extensions .jpg .tif...)'
'Discrete Fourier transform of a real sequence. DCNL Parameters DCNL x : array_like, real-valued DCNL The data to transform. DCNL n : int, optional DCNL Defines the length of the Fourier transform.  If `n` is not specified DCNL (the default) then ``n = x.shape[axis]``.  If ``n < x.shape[axis]``, DCNL `x` is truncated, if ``n > x.shape[axis]``, `x` is zero-padded. DCNL axis : int, optional DCNL The axis along which the transform is applied.  The default is the DCNL last axis. DCNL overwrite_x : bool, optional DCNL If set to true, the contents of `x` can be overwritten. Default is DCNL False. DCNL Returns DCNL z : real ndarray DCNL The returned real array contains:: DCNL [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even DCNL [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd DCNL where:: DCNL y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n) DCNL j = 0..n-1 DCNL Note that ``y(-j) == y(n-j).conjugate()``. DCNL See Also DCNL fft, irfft, scipy.fftpack.basic DCNL Notes DCNL Within numerical accuracy, ``y == rfft(irfft(y))``. DCNL Both single and double precision routines are implemented.  Half precision DCNL inputs will be converted to single precision.  Non floating-point inputs DCNL will be converted to double precision.  Long-double precision inputs are DCNL not supported. DCNL Examples DCNL >>> from scipy.fftpack import fft, rfft DCNL >>> a = [9, -9, 1, 3] DCNL >>> fft(a) DCNL array([  4. +0.j,   8.+12.j,  16. +0.j,   8.-12.j]) DCNL >>> rfft(a) DCNL array([  4.,   8.,  12.,  16.])'
'A decorator to require that a user be logged in to access a handler. DCNL To use it, decorate your get() method like this:: DCNL @login_required DCNL def get(self): DCNL user = users.get_current_user(self) DCNL self.response.out.write(\'Hello, \' + user.nickname()) DCNL We will redirect to a login page if the user is not logged in. We always DCNL redirect to the request URI, and Google Accounts only redirects back as DCNL a GET request, so this should not be used for POSTs.'
'Returns None if no writer is found for extension.'
'Returns a dictionary of variable length solution trajectories.'
'String concatenation aggregator for sqlite, sorted by supplied index'
'Shortcuts for generating request headers. DCNL :param keep_alive: DCNL If ``True``, adds \'connection: keep-alive\' header. DCNL :param accept_encoding: DCNL Can be a boolean, list, or string. DCNL ``True`` translates to \'gzip,deflate\'. DCNL List will get joined by comma. DCNL String will be used as provided. DCNL :param user_agent: DCNL String representing the user-agent you want, such as DCNL "python-urllib3/0.6" DCNL :param basic_auth: DCNL Colon-separated username:password string for \'authorization: basic ...\' DCNL auth header. DCNL :param proxy_basic_auth: DCNL Colon-separated username:password string for \'proxy-authorization: basic ...\' DCNL auth header. DCNL Example: :: DCNL >>> make_headers(keep_alive=True, user_agent="Batman/1.0") DCNL {\'connection\': \'keep-alive\', \'user-agent\': \'Batman/1.0\'} DCNL >>> make_headers(accept_encoding=True) DCNL {\'accept-encoding\': \'gzip,deflate\'}'
'Returns an iterator over a series of lists of length size from iterable. DCNL >>> list(group([1,2,3,4], 2)) DCNL [[1, 2], [3, 4]] DCNL >>> list(group([1,2,3,4,5], 2)) DCNL [[1, 2], [3, 4], [5]]'
'Only show up to logger_settings[\'reveal_sensitive_prefix\'] characters DCNL from a sensitive header. DCNL :param name: Header name DCNL :param value: Header value DCNL :return: Safe header value'
'Like urllib2.quote but handles unicode properly.'
'Delete an ElastiCache subnet group. DCNL CLI example:: DCNL salt myminion boto_elasticache.delete_subnet_group my-subnet-group                 region=us-east-1'
'Detect if the code is running in the Compute Engine environment. DCNL Returns: DCNL True if running in the GCE environment, False otherwise.'
'Use VM interactively - exit by pressing control-]'
'Given b number of a\'s how big is our dimension? DCNL >>> dimension_mul(2, 5) DCNL 10 DCNL We round up DCNL >>> dimension_mul(9, 3) DCNL 27 DCNL In the case of datashape.var, we resort to var DCNL >>> from datashape import var DCNL >>> dimension_mul(datashape.var, 5) DCNL Var() DCNL >>> dimension_mul(10, datashape.var) DCNL Var()'
'Return a mask of all of the datetimes in ``dts`` that are between DCNL ``start`` and ``end``. DCNL Parameters DCNL dts : pd.DatetimeIndex DCNL The index to mask. DCNL start : time DCNL Mask away times less than the start. DCNL end : time DCNL Mask away times greater than the end. DCNL include_start : bool, optional DCNL Inclusive on ``start``. DCNL include_end : bool, optional DCNL Inclusive on ``end``. DCNL Returns DCNL mask : np.ndarray[bool] DCNL A bool array masking ``dts``. DCNL See Also DCNL :meth:`pandas.DatetimeIndex.indexer_between_time`'
'Minimize over alpha, the function ``f(xk+alpha pk)``. DCNL Parameters DCNL f : callable DCNL Function to be minimized. DCNL xk : array_like DCNL Current point. DCNL pk : array_like DCNL Search direction. DCNL gfk : array_like DCNL Gradient of `f` at point `xk`. DCNL old_fval : float DCNL Value of `f` at point `xk`. DCNL args : tuple, optional DCNL Optional arguments. DCNL c1 : float, optional DCNL Value to control stopping criterion. DCNL alpha0 : scalar, optional DCNL Value of `alpha` at start of the optimization. DCNL Returns DCNL alpha DCNL f_count DCNL f_val_at_alpha DCNL Notes DCNL Uses the interpolation algorithm (Armijo backtracking) as suggested by DCNL Wright and Nocedal in \'Numerical Optimization\', 1999, pg. 56-57'
'Compile the client into a temporary directory, if successful DCNL call install_completed_client to install the new client. DCNL :param project_client: project.client pair e.g. autotest.AfeClient DCNL :param install_client: Boolean, if True install the clients DCNL :return: True if install and compile was successful False if it failed'
'PRIVATE METHOD DCNL Performs the requested replication command and returns a dictionary with DCNL success, errors and data as keys. The data object will contain the JSON DCNL response. DCNL command : str DCNL The replication command to execute. DCNL host : str (None) DCNL The solr host to query. __opts__[\'host\'] is default DCNL core_name: str (None) DCNL The name of the solr core if using cores. Leave this blank if you are DCNL not using cores or if you want to check all cores. DCNL params : list<str> ([]) DCNL Any additional parameters you want to send. Should be a lsit of DCNL strings in name=value format. e.g. [\'name=value\'] DCNL Return: dict<str, obj>:: DCNL {\'success\':boolean, \'data\':dict, \'errors\':list, \'warnings\':list}'
'Return the current configuration value for the given option'
'Make all methods listed in each class\' synchronized attribute synchronized. DCNL The synchronized attribute should be a list of strings, consisting of the DCNL names of methods that must be synchronized. If we are running in threaded DCNL mode these methods will be wrapped with a lock.'
'Set the system module of the kernel is Windows'
'Return the request fingerprint. DCNL The request fingerprint is a hash that uniquely identifies the resource the DCNL request points to. For example, take the following two urls: DCNL http://www.example.com/query?id=111&cat=222 DCNL http://www.example.com/query?cat=222&id=111 DCNL Even though those are two different URLs both point to the same resource DCNL and are equivalent (ie. they should return the same response). DCNL Another example are cookies used to store session ids. Suppose the DCNL following page is only accesible to authenticated users: DCNL http://www.example.com/members/offers.html DCNL Lot of sites use a cookie to store the session id, which adds a random DCNL component to the HTTP Request and thus should be ignored when calculating DCNL the fingerprint. DCNL For this reason, request headers are ignored by default when calculating DCNL the fingeprint. If you want to include specific headers use the DCNL include_headers argument, which is a list of Request headers to include.'
'Parse command-line argument vector. DCNL If options_first: DCNL argv ::= [ long | shorts ]* [ argument ]* [ \'--\' [ argument ]* ] ; DCNL else: DCNL argv ::= [ long | shorts | argument ]* [ \'--\' [ argument ]* ] ;'
'Create a fully-qualified xattr-key by including the intended namespace. DCNL Namespacing differs among OSes[1]: DCNL FreeBSD: user, system DCNL Linux: user, system, trusted, security DCNL MacOS X: not needed DCNL Mac OS X won\'t break if we include a namespace qualifier, so, for DCNL simplicity, we always include it. DCNL [1] http://en.wikipedia.org/wiki/Extended_file_attributes'
'Top-level function.'
'Test time generalization decoding'
'Transform a lowpass filter prototype to a highpass filter. DCNL Return an analog high-pass filter with cutoff frequency `wo` DCNL from an analog low-pass filter prototype with unity cutoff frequency, DCNL using zeros, poles, and gain (\'zpk\') representation. DCNL Parameters DCNL z : array_like DCNL Zeros of the analog IIR filter transfer function. DCNL p : array_like DCNL Poles of the analog IIR filter transfer function. DCNL k : float DCNL System gain of the analog IIR filter transfer function. DCNL wo : float DCNL Desired cutoff, as angular frequency (e.g. rad/s). DCNL Defaults to no change. DCNL Returns DCNL z : ndarray DCNL Zeros of the transformed high-pass filter transfer function. DCNL p : ndarray DCNL Poles of the transformed high-pass filter transfer function. DCNL k : float DCNL System gain of the transformed high-pass filter. DCNL Notes DCNL This is derived from the s-plane substitution DCNL .. math:: s \rightarrow \frac{\omega_0}{s} DCNL This maintains symmetry of the lowpass and highpass responses on a DCNL logarithmic scale.'
'label: Get the label for the object.'
'Returns all snipMate files we need to look at for \'ft\'.'
'Return the number of keys in the selected database DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' redis.dbsize'
':param edesc: EntityDescriptor instance DCNL :param ident: EntityDescriptor identifier DCNL :param secc: Security context DCNL :return: Tuple with EntityDescriptor instance and Signed XML document'
'Wait for multiple asynchronous futures in parallel. DCNL This function is similar to `multi`, but does not support DCNL `YieldPoints <YieldPoint>`. DCNL .. versionadded:: 4.0 DCNL .. versionchanged:: 4.2 DCNL If multiple ``Futures`` fail, any exceptions after the first (which is DCNL raised) will be logged. Added the ``quiet_exceptions`` DCNL argument to suppress this logging for selected exception types. DCNL .. deprecated:: 4.3 DCNL Use `multi` instead.'
'Serve static files below a given point in the directory structure or DCNL from locations inferred from the staticfiles finders. DCNL To use, put a URL pattern such as:: DCNL (r\'^(?P<path>.*)$\', \'django.contrib.staticfiles.views.serve\') DCNL in your URLconf. DCNL It uses the django.views.static view to serve the found files.'
'yaml: ant DCNL Execute an ant target. Requires the Jenkins :jenkins-wiki:`Ant Plugin DCNL <Ant+Plugin>`. DCNL To setup this builder you can either reference the list of targets DCNL or use named parameters. Below is a description of both forms: DCNL *1) Listing targets:* DCNL After the ant directive, simply pass as argument a space separated list DCNL of targets to build. DCNL :Parameter: space separated list of Ant targets DCNL Example to call two Ant targets: DCNL .. literalinclude:: ../../tests/builders/fixtures/ant001.yaml DCNL :language: yaml DCNL The build file would be whatever the Jenkins Ant Plugin is set to use DCNL per default (i.e build.xml in the workspace root). DCNL *2) Using named parameters:* DCNL :arg str targets: the space separated list of ANT targets. DCNL :arg str buildfile: the path to the ANT build file. DCNL :arg list properties: Passed to ant script using -Dkey=value (optional) DCNL :arg str ant-name: the name of the ant installation, DCNL (default \'default\') (optional) DCNL :arg str java-opts: java options for ant, can have multiples, DCNL must be in quotes (optional) DCNL Example specifying the build file too and several targets: DCNL .. literalinclude:: ../../tests/builders/fixtures/ant002.yaml DCNL :language: yaml'
'Convert x,y coordinates to w,x,y,z Quaternion parameters DCNL Adapted from: DCNL linalg library DCNL Copyright (c) 2010-2015, Renaud Blanch <rndblnch at gmail dot com> DCNL Licence at your convenience: DCNL GPLv3 or higher <http://www.gnu.org/licenses/gpl.html> DCNL BSD new <http://opensource.org/licenses/BSD-3-Clause>'
'Tests the coordinate variables functionality with respect to DCNL reorientation of coordinate systems.'
'Looks for misplaced braces (e.g. at the end of line). 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 error: The function to call with any errors found.'
'Calls s6.restart() function DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' s6.full_restart <service name>'
'Validate optional authentication parameters.'
'Convert iterator to an object that can be consumed multiple times. DCNL ``Regen`` takes any iterable, and if the object is an DCNL generator it will cache the evaluated list on first access, DCNL so that the generator can be "consumed" multiple times.'
'round_mode(a) with mode in [half_away_from_zero, half_to_even]'
'Does a function have only n positional arguments? DCNL This function relies on introspection and does not call the function. DCNL Returns None if validity can\'t be determined. DCNL >>> def f(x): DCNL ...     return x DCNL >>> is_arity(1, f) DCNL True DCNL >>> def g(x, y=1): DCNL ...     return x + y DCNL >>> is_arity(1, g) DCNL False'
'Converts a value that matches \d+ into an integer.'
'Takes a single JSON drive entry (data) and converts it to a list DCNL of Play objects. This includes trying to resolve duplicate play DCNL conflicts by only taking the first instance of a play.'
'If path does not end with /, add it and return.'
'Trigger crash dump in an instance.'
'Set new video subtitle. DCNL @param p_mi: the media player. DCNL @param i_spu: video subtitle track to select (i_id from track description). DCNL @return: 0 on success, -1 if out of range.'
'Evaluate ``f(a)`` in ``GF(p)`` using Horner scheme. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.galoistools import gf_eval DCNL >>> gf_eval([3, 2, 4], 2, 5, ZZ) DCNL 0'
'Returns ``True`` if the specified service is available, otherwise returns DCNL ``False``. DCNL name DCNL the service\'s name DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' runit.available <service name>'
'Still need to test: DCNL Two overlapping sequences. OK to get new segments but check that we can DCNL get correct high order prediction after multiple reps.'
'Lists documents directly under /docs/'
'Find user-specified instrumentation management for a class.'
'Add faces from a polygon which is concave.'
'initialise module'
'Cache projects. DCNL :return func:'
'The aggregated (all locales) kb metrics dashboard.'
'Allows final rewrite of dev_appserver response. DCNL This function receives the unparsed HTTP response from the application DCNL or internal handler, parses out the basic structure and feeds that structure DCNL in to a chain of response rewriters. DCNL It also makes sure the final HTTP headers are properly terminated. DCNL For more about response rewriters, please see documentation for DCNL CreateResponeRewritersChain. DCNL Args: DCNL response_file: File-like object containing the full HTTP response including DCNL the response code, all headers, and the request body. DCNL response_rewriters: A list of response rewriters.  If none is provided it DCNL will create a new chain using CreateResponseRewritersChain. DCNL request_headers: Original request headers. DCNL env_dict: Environment dictionary. DCNL Returns: DCNL An AppServerResponse instance configured with the rewritten response.'
'Get extrude output for a cylinder gear.'
''
'Copy a file into a cache and link it into place. DCNL Use this with caution, otherwise you could end up DCNL copying data twice if the cache is not on the same device DCNL as the destination'
'Retrieve the relevant course_info updates and unpack into the model which the client expects: DCNL [{id : index, date : string, content : html string}]'
'Return True if url returns 200 and is served by Perl.'
'made up example with sin, square'
''
'Rewrite a base64 string: DCNL - Remove LF and = characters DCNL - Replace slashes by underscores DCNL >>> b64c("abc123456def") DCNL \'abc123456def\' DCNL >>> b64c("\na/=b=c/") DCNL \'a_bc_\' DCNL >>> b64c("a+b+c+123+") DCNL \'a+b+c+123+\''
'Return the common neighbors of two nodes in a graph. DCNL Parameters DCNL G : graph DCNL A NetworkX undirected graph. DCNL u, v : nodes DCNL Nodes in the graph. DCNL Returns DCNL cnbors : iterator DCNL Iterator of common neighbors of u and v in the graph. DCNL Raises DCNL NetworkXError DCNL If u or v is not a node in the graph. DCNL Examples DCNL >>> G = nx.complete_graph(5) DCNL >>> sorted(nx.common_neighbors(G, 0, 1)) DCNL [2, 3, 4]'
'Check if patterns contains a pattern that matches filename. DCNL If patterns is unspecified, this always returns True.'
'Connect to AWS Config DCNL :type aws_access_key_id: string DCNL :param aws_access_key_id: Your AWS Access Key ID DCNL :type aws_secret_access_key: string DCNL :param aws_secret_access_key: Your AWS Secret Access Key DCNL rtype: :class:`boto.kms.layer1.ConfigServiceConnection` DCNL :return: A connection to the AWS Config service'
'Bulk create floating IPs by range (nova-network only).'
'Decode the supplied byte string using the preferred encoding DCNL for the locale (`locale.getpreferredencoding`) or, if the default encoding DCNL is invalid, fall back first on utf-8, then on latin-1 if the message cannot DCNL be decoded with utf-8.'
'Run migrations in \'offline\' mode. DCNL This configures the context with either a URL DCNL or an Engine. DCNL Calls to context.execute() here emit the given string to the DCNL script output.'
'Task resource factory method'
'Return a list of the conjuncts in the expr s. DCNL Examples DCNL >>> from sympy.logic.boolalg import conjuncts DCNL >>> from sympy.abc import A, B DCNL >>> conjuncts(A & B) DCNL frozenset({A, B}) DCNL >>> conjuncts(A | B) DCNL frozenset({Or(A, B)})'
'Helps skip integration tests without live credentials. DCNL Phrased in the negative to make it read better with \'skipif\'.'
'The docs links map is in this format: DCNL "doc_path": [ DCNL "file_path", DCNL This transforms it to: DCNL "file_path": [ DCNL "doc_path",'
'Start generating a set of example certificates. DCNL Example certificates are used to verify that certificates have DCNL been configured correctly for the course. DCNL Redirects back to the intructor dashboard once certificate DCNL generation has begun.'
'Start the saltnado!'
'Create a submission file given a configuration dictionary and a DCNL computation function. DCNL Note that it always reload the datasets to ensure valid & test DCNL are not permuted. DCNL Parameters DCNL conf : WRITEME DCNL transform_valid : WRITEME DCNL transform_test : WRITEME DCNL features : WRITEME'
'Return ``s`` where characters have been replaced or deleted. DCNL SYNTAX DCNL translate(s, None, deletechars): DCNL all characters in ``deletechars`` are deleted DCNL translate(s, map [,deletechars]): DCNL all characters in ``deletechars`` (if provided) are deleted DCNL then the replacements defined by map are made; if the keys DCNL of map are strings then the longer ones are handled first. DCNL Multicharacter deletions should have a value of \'\'. DCNL translate(s, oldchars, newchars, deletechars) DCNL all characters in ``deletechars`` are deleted DCNL then each character in ``oldchars`` is replaced with the DCNL corresponding character in ``newchars`` DCNL Examples DCNL >>> from sympy.utilities.misc import translate DCNL >>> from sympy.core.compatibility import unichr DCNL >>> abc = \'abc\' DCNL >>> translate(abc, None, \'a\') DCNL \'bc\' DCNL >>> translate(abc, {\'a\': \'x\'}, \'c\') DCNL \'xb\' DCNL >>> translate(abc, {\'abc\': \'x\', \'a\': \'y\'}) DCNL \'x\' DCNL >>> translate(\'abcd\', \'ac\', \'AC\', \'d\') DCNL \'AbC\' DCNL There is no guarantee that a unique answer will be DCNL obtained if keys in a mapping overlap are the same DCNL length and have some identical sequences at the DCNL beginning/end: DCNL >>> translate(abc, {\'ab\': \'x\', \'bc\': \'y\'}) in (\'xc\', \'ay\') DCNL True'
'ServiceLevelAgreement view'
'Takes a string and replace words that match a key in a dictionary with the associated value, DCNL then returns the changed text DCNL :rtype str'
'Returns the angle in degrees represented by a azimuth label int. DCNL Parameters DCNL label: int DCNL Azimuth label.'
'Check for installation with easy_install or pip.'
'Test that activate\'s setting of echo to off does not disrupt later echo calls'
'Factor a square-free ``f`` in ``GF(p)[x]`` for small ``p``. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.galoistools import gf_berlekamp DCNL >>> gf_berlekamp([1, 0, 0, 0, 1], 5, ZZ) DCNL [[1, 0, 2], [1, 0, 3]]'
'Notify status to customer, supplier'
'Convenience function: Assign the return value of this method to a variable DCNL of your ModelAdmin class and put the variable name into list_display. DCNL Example:: DCNL class MyTreeEditor(TreeEditor): DCNL list_display = (\'__str__\', \'active_toggle\') DCNL active_toggle = ajax_editable_boolean(\'active\', _(\'is active\'))'
'Convert a dictionary containing (textual DNS name, base64 secret) pairs DCNL into a binary keyring which has (dns.name.Name, binary secret) pairs. DCNL @rtype: dict'
'This method instantiates and returns a handle to a low-level DCNL base cipher. It will absorb named parameters in the process.'
'Compares two strings in a cryptographically safe way: DCNL Runtime is not affected by length of common prefix.'
'Return a list of minions'
'Get the registered writer names'
'Install packages with pip DCNL Install packages individually or from a pip requirements file. Install DCNL packages globally or to a virtualenv. DCNL pkgs DCNL Comma separated list of packages to install DCNL requirements DCNL Path to requirements DCNL bin_env DCNL Path to pip bin or path to virtualenv. If doing a system install, DCNL and want to use a specific pip bin (pip-2.7, pip-2.6, etc..) just DCNL specify the pip bin you want. DCNL .. note:: DCNL If installing into a virtualenv, just use the path to the DCNL virtualenv (e.g. ``/home/code/path/to/virtualenv/``) DCNL use_wheel DCNL Prefer wheel archives (requires pip>=1.4) DCNL no_use_wheel DCNL Force to not use wheel archives (requires pip>=1.4) DCNL log DCNL Log file where a complete (maximum verbosity) record will be kept DCNL proxy DCNL Specify a proxy in the form ``user:passwd@proxy.server:port``. Note DCNL that the ``user:password@`` is optional and required only if you are DCNL behind an authenticated proxy. If you provide DCNL ``user@proxy.server:port`` then you will be prompted for a password. DCNL timeout DCNL Set the socket timeout (default 15 seconds) DCNL editable DCNL install something editable (e.g. DCNL ``git+https://github.com/worldcompany/djangoembed.git#egg=djangoembed``) DCNL find_links DCNL URL to search for packages DCNL index_url DCNL Base URL of Python Package Index DCNL extra_index_url DCNL Extra URLs of package indexes to use in addition to ``index_url`` DCNL no_index DCNL Ignore package index DCNL mirrors DCNL Specific mirror URL(s) to query (automatically adds --use-mirrors) DCNL .. warning:: DCNL This option has been deprecated and removed in pip version 7.0.0. DCNL Please use ``index_url`` and/or ``extra_index_url`` instead. DCNL build DCNL Unpack packages into ``build`` dir DCNL target DCNL Install packages into ``target`` dir DCNL download DCNL Download packages into ``download`` instead of installing them DCNL download_cache DCNL Cache downloaded packages in ``download_cache`` dir DCNL source DCNL Check out ``editable`` packages into ``source`` dir DCNL upgrade DCNL Upgrade all packages to the newest available version DCNL force_reinstall DCNL When upgrading, reinstall all packages even if they are already DCNL up-to-date. DCNL ignore_installed DCNL Ignore the installed packages (reinstalling instead) DCNL exists_action DCNL Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, DCNL (b)ackup DCNL no_deps DCNL Ignore package dependencies DCNL no_install DCNL Download and unpack all packages, but don\'t actually install them DCNL no_download DCNL Don\'t download any packages, just install the ones already downloaded DCNL (completes an install run with ``--no-install``) DCNL install_options DCNL Extra arguments to be supplied to the setup.py install command (e.g. DCNL like ``--install-option=\'--install-scripts=/usr/local/bin\'``).  Use DCNL multiple --install-option options to pass multiple options to setup.py DCNL install. If you are using an option with a directory path, be sure to DCNL use absolute path. DCNL global_options DCNL Extra global options to be supplied to the setup.py call before the DCNL install command. DCNL user DCNL The user under which to run pip DCNL no_chown DCNL When user is given, do not attempt to copy and chown a requirements DCNL file DCNL cwd DCNL Current working directory to run pip from DCNL pre_releases DCNL Include pre-releases in the available versions DCNL cert DCNL Provide a path to an alternate CA bundle DCNL allow_all_external DCNL Allow the installation of all externally hosted files DCNL allow_external DCNL Allow the installation of externally hosted files (comma separated DCNL list) DCNL allow_unverified DCNL Allow the installation of insecure and unverifiable files (comma DCNL separated list) DCNL process_dependency_links DCNL Enable the processing of dependency links DCNL env_vars DCNL Set environment variables that some builds will depend on. For example, DCNL a Python C-module may have a Makefile that needs INCLUDE_PATH set to DCNL pick up a header file while compiling.  This must be in the form of a DCNL dictionary or a mapping. DCNL Example: DCNL .. code-block:: bash DCNL salt \'*\' pip.install django_app env_vars="{\'CUSTOM_PATH\': \'/opt/django_app\'}" DCNL trusted_host DCNL Mark this host as trusted, even though it does not have valid or any DCNL HTTPS. DCNL use_vt DCNL Use VT terminal emulation (see output while installing) DCNL no_cache_dir DCNL Disable the cache. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pip.install <package name>,<package2 name> DCNL salt \'*\' pip.install requirements=/path/to/requirements.txt DCNL salt \'*\' pip.install <package name> bin_env=/path/to/virtualenv DCNL salt \'*\' pip.install <package name> bin_env=/path/to/pip_bin DCNL Complicated CLI example:: DCNL salt \'*\' pip.install markdown,django                 editable=git+https://github.com/worldcompany/djangoembed.git#egg=djangoembed upgrade=True no_deps=True'
'handler for on_text pyglet events, or call directly to emulate a text DCNL event. DCNL S Mathot 2012: This function only acts when the key that is pressed DCNL corresponds to a non-ASCII text character (Greek, Arabic, Hebrew, etc.). DCNL In that case the symbol that is passed to _onPygletKey() is translated DCNL into a useless \'user_key()\' string. If this happens, _onPygletText takes DCNL over the role of capturing the key. Unfortunately, _onPygletText() DCNL cannot solely handle all input, because it does not respond to spacebar DCNL presses, etc.'
'Uploads a set of photos that will be used in the new user welcome conversation. These DCNL photos are uploaded to the given user account. "upload_request" is in the UPLOAD_EPISODE_REQUEST DCNL format in json_schema.py, except: DCNL 1. Activity, episode, and photo ids are added by this method. DCNL 2. Each photo dict must contain an additional "name" field which gives the start of the DCNL filename of a jpg file in the backend/resources/welcome directory. Three files must DCNL exist there, in this format: <name>_full.jpg, <name>_med.jpg, <name>_tn.jpg.'
'Helper: Get the next or the previous valid date. The idea is to allow DCNL links on month/day views to never be 404s by never providing a date DCNL that\'ll be invalid for the given view. DCNL This is a bit complicated since it handles different intervals of time, DCNL hence the coupling to generic_view. DCNL However in essence the logic comes down to: DCNL * If allow_empty and allow_future are both true, this is easy: just DCNL return the naive result (just the next/previous day/week/month, DCNL reguardless of object existence.) DCNL * If allow_empty is true, allow_future is false, and the naive result DCNL isn\'t in the future, then return it; otherwise return None. DCNL * If allow_empty is false and allow_future is true, return the next DCNL date *that contains a valid object*, even if it\'s in the future. If DCNL there are no next objects, return None. DCNL * If allow_empty is false and allow_future is false, return the next DCNL date that contains a valid object. If that date is in the future, or DCNL if there are no next objects, return None.'
'Generates antichains from a DAG. DCNL An antichain is a subset of a partially ordered set such that any DCNL two elements in the subset are incomparable. DCNL Parameters DCNL G : NetworkX DiGraph DCNL Graph DCNL Returns DCNL antichain : generator object DCNL Raises DCNL NetworkXNotImplemented DCNL If G is not directed DCNL NetworkXUnfeasible DCNL If G contains a cycle DCNL Notes DCNL This function was originally developed by Peter Jipsen and Franco Saliola DCNL for the SAGE project. It\'s included in NetworkX with permission from the DCNL authors. Original SAGE code at: DCNL https://sage.informatik.uni-goettingen.de/src/combinat/posets/hasse_diagram.py DCNL References DCNL .. [1] Free Lattices, by R. Freese, J. Jezek and J. B. Nation, DCNL AMS, Vol 42, 1995, p. 226.'
'Return the version of MSVC that was used to build Python. DCNL For Python 2.3 and up, the version number is included in DCNL sys.version.  For earlier versions, assume the compiler is MSVC 6.'
'更新 local_cache 中缓存的资源, 追加content DCNL 在stream模式中使用'
'daemonize a Unix process. Set paranoid umask by default. DCNL Return 1 in the original process, 2 in the first fork, and None for the DCNL second fork (eg daemon process).'
'Computes a dataset_id from a blockdevice_id. DCNL :param unicode blockdevice_id: The blockdevice_id to get the dataset_id DCNL for. DCNL :returns UUID: The corresponding dataset_id.'
'Converts a string to a valid filename.'
'Method to decrypt streams using a PDF security handler (NOT IMPLEMENTED YET) DCNL @param stream: A PDF stream DCNL @return: A tuple (status,statusContent), where statusContent is the decrypted PDF stream in case status = 0 or an error in case status = -1'
'Uploads a separate patch for each file in the diff output. DCNL Returns a list of [patch_key, filename] for each file.'
'Returns the HTML of a css_selector'
'Delete blobs from Blobstore. DCNL Args: DCNL blob_keys: A list of blob keys. DCNL **options: Options for create_rpc().'
'Details about failing check.'
'Install a previously obtained cert in a server.'
'Return the path of a base URL if it contains one. DCNL >>> get_base_path(\'http://some.site\') == \'/\' DCNL True DCNL >>> get_base_path(\'http://some.site/\') == \'/\' DCNL True DCNL >>> get_base_path(\'http://some.site/some/sub-path\') == \'/some/sub-path/\' DCNL True DCNL >>> get_base_path(\'http://some.site/some/sub-path/\') == \'/some/sub-path/\' DCNL True'
'Returns True if the two strings are equal, False otherwise. DCNL The time taken is independent of the number of characters that match.'
'helper to calculate port and bus number from locationID'
''
'Format sys.version_info to produce the Sphinx version string used to install the chm docs'
'Returns users queryset, containing all subordinate users to given user DCNL including users created by given user and not assigned to any page. DCNL Not assigned users must be returned, because they shouldn\'t get lost, and DCNL user should still have possibility to see them. DCNL Only users created_by given user which are on the same, or lover level are DCNL returned. DCNL If user haves global permissions or is a superuser, then he can see all the DCNL users. DCNL This function is currently used in PagePermissionInlineAdminForm for limit DCNL users in permission combobox. DCNL Example: DCNL A,W                    level 0 DCNL /                              user    B,GroupE           level 1 DCNL Z       /                           C,X     D,Y,W                  level 2 DCNL Rules: W was created by user, Z was created by user, but is not assigned DCNL to any page. DCNL Will return [user, C, X, D, Y, Z]. W was created by user, but is also DCNL assigned to higher level.'
'Returns a dictionary containing a boolean specifying whether NumPy DCNL is up-to-date, along with the version string (empty string if DCNL not installed).'
'Point pair triangulation from DCNL least squares solution.'
'Check if a Portage package is installed.'
'Make function raise KnownFailureTest exception if given condition is true. DCNL If the condition is a callable, it is used at runtime to dynamically DCNL make the decision. This is useful for tests that may require costly DCNL imports, to delay the cost until the test suite is actually executed. DCNL Parameters DCNL fail_condition : bool or callable DCNL Flag to determine whether to mark the decorated test as a known DCNL failure (if True) or not (if False). DCNL msg : str, optional DCNL Message to give on raising a KnownFailureTest exception. DCNL Default is None. DCNL Returns DCNL decorator : function DCNL Decorator, which, when applied to a function, causes SkipTest DCNL to be raised when `skip_condition` is True, and the function DCNL to be called normally otherwise. DCNL Notes DCNL The decorator itself is decorated with the ``nose.tools.make_decorator`` DCNL function in order to transmit function name, and various other metadata.'
'Delete keypair given by its name.'
'Parse RFC 822 dates and times DCNL http://tools.ietf.org/html/rfc822#section-5 DCNL There are some formatting differences that are accounted for: DCNL 1. Years may be two or four digits. DCNL 2. The month and day can be swapped. DCNL 3. Additional timezone names are supported. DCNL 4. A default time and timezone are assumed if only a date is present.'
'Returns initializer that initializes array with the all-zero array. DCNL Args: DCNL dtype: Data type specifier. DCNL Returns: DCNL numpy.ndarray or cupy.ndarray: An initialized array.'
'Interpolate unstructured D-dimensional data. DCNL Parameters DCNL points : ndarray of floats, shape (n, D) DCNL Data point coordinates. Can either be an array of DCNL shape (n, D), or a tuple of `ndim` arrays. DCNL values : ndarray of float or complex, shape (n,) DCNL Data values. DCNL xi : ndarray of float, shape (M, D) DCNL Points at which to interpolate data. DCNL method : {\'linear\', \'nearest\', \'cubic\'}, optional DCNL Method of interpolation. One of DCNL ``nearest`` DCNL return the value at the data point closest to DCNL the point of interpolation.  See `NearestNDInterpolator` for DCNL more details. DCNL ``linear`` DCNL tesselate the input point set to n-dimensional DCNL simplices, and interpolate linearly on each simplex.  See DCNL `LinearNDInterpolator` for more details. DCNL ``cubic`` (1-D) DCNL return the value determined from a cubic DCNL spline. DCNL ``cubic`` (2-D) DCNL return the value determined from a DCNL piecewise cubic, continuously differentiable (C1), and DCNL approximately curvature-minimizing polynomial surface. See DCNL `CloughTocher2DInterpolator` for more details. DCNL fill_value : float, optional DCNL Value used to fill in for requested points outside of the DCNL convex hull of the input points.  If not provided, then the DCNL default is ``nan``. This option has no effect for the DCNL \'nearest\' method. DCNL rescale : bool, optional DCNL Rescale points to unit cube before performing interpolation. DCNL This is useful if some of the input dimensions have DCNL incommensurable units and differ by many orders of magnitude. DCNL .. versionadded:: 0.14.0 DCNL Notes DCNL .. versionadded:: 0.9 DCNL Examples DCNL Suppose we want to interpolate the 2-D function DCNL >>> def func(x, y): DCNL ...     return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2 DCNL on a grid in [0, 1]x[0, 1] DCNL >>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j] DCNL but we only know its values at 1000 data points: DCNL >>> points = np.random.rand(1000, 2) DCNL >>> values = func(points[:,0], points[:,1]) DCNL This can be done with `griddata` -- below we try out all of the DCNL interpolation methods: DCNL >>> from scipy.interpolate import griddata DCNL >>> grid_z0 = griddata(points, values, (grid_x, grid_y), method=\'nearest\') DCNL >>> grid_z1 = griddata(points, values, (grid_x, grid_y), method=\'linear\') DCNL >>> grid_z2 = griddata(points, values, (grid_x, grid_y), method=\'cubic\') DCNL One can see that the exact result is reproduced by all of the DCNL methods to some degree, but for this smooth function the piecewise DCNL cubic interpolant gives the best results: DCNL >>> import matplotlib.pyplot as plt DCNL >>> plt.subplot(221) DCNL >>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin=\'lower\') DCNL >>> plt.plot(points[:,0], points[:,1], \'k.\', ms=1) DCNL >>> plt.title(\'Original\') DCNL >>> plt.subplot(222) DCNL >>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin=\'lower\') DCNL >>> plt.title(\'Nearest\') DCNL >>> plt.subplot(223) DCNL >>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin=\'lower\') DCNL >>> plt.title(\'Linear\') DCNL >>> plt.subplot(224) DCNL >>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin=\'lower\') DCNL >>> plt.title(\'Cubic\') DCNL >>> plt.gcf().set_size_inches(6, 6) DCNL >>> plt.show()'
'match(string, trie) -> longest key or None DCNL Find the longest key in the trie that matches the beginning of the DCNL string.'
'Attempt to remove a file, returning whether the file existed at DCNL the time of the call. DCNL str -> bool'
'If \'key\' is present in dict \'kw\', coerce its value to type \'type\_\' if DCNL necessary.  If \'flexi_bool\' is True, the string \'0\' is considered false DCNL when coercing to boolean.'
'Test right processing while passing no object as initialization'
'Like string.split(), but keeps empty words as empty words.'
'Test that setting mean_only on a BatchNormalizedMLP works.'
'Wrap a given boto Connection object so that it can retry when DCNL throttled.'
'Test that a table round trips from QTable => Table => QTable'
'Compute the transformation matrix from Galactic spherical to DCNL heliocentric Sgr coordinates.'
'Return a constructor for a decoder for a fixed-width field. DCNL Args: DCNL wire_type:  The field\'s wire type. DCNL format:  The format string to pass to struct.unpack().'
'return the rows that are being displayed and the total rows in the dataTable'
'Calculate the pagerank vector of a given adjacency matrix (using DCNL the power method). DCNL :param matrix: an adjacency matrix DCNL :param d_factor: the damping factor'
'登录获取 cookie'
'This function returns a Pyramid WSGI application.'
'Determine if a point is inside another loop.'
'Creates a Student Record and returns a Program Enrollment. DCNL :param source_name: Student Applicant.'
'Listify the generator returned by fill_gaps_generator for `memoize`.'
'Use the REST API to search for past tweets by a given user.'
'This op do a view in the forward, but clip the gradient. DCNL This is an elemwise operation. DCNL :param x: the variable we want its gradient inputs clipped DCNL :param lower_bound: The lower bound of the gradient value DCNL :param upper_bound: The upper bound of the gradient value. DCNL :examples: DCNL x = theano.tensor.scalar() DCNL z = theano.tensor.grad(grad_clip(x, -1, 1)**2, x) DCNL z2 = theano.tensor.grad(x**2, x) DCNL f = theano.function([x], outputs = [z, z2]) DCNL print(f(2.0))  # output (1.0, 4.0) DCNL :note: We register an opt in tensor/opt.py that remove the GradClip. DCNL So it have 0 cost in the forward and only do work in the grad.'
'Retrieve a list of TopoJSON tile responses and merge them into one. DCNL get_tiles() retrieves data and performs basic integrity checks.'
'Return the script deployment object'
'Helper for parallelization. DCNL Parameters DCNL refl : array | None DCNL If ch_type is \'eeg\', the magnitude of position vector of the DCNL virtual reference (never used). DCNL lsurf : array DCNL Magnitude of position vector of the surface points. DCNL rlens : list of arrays of length n_coils DCNL Magnitude of position vector. DCNL this_nn : array, shape (n_vertices, 3) DCNL Surface normals. DCNL cosmags : list of array. DCNL Direction of the integration points in the coils. DCNL ws : list of array DCNL Integration weights of the coils. DCNL volume : bool DCNL If True, compute volume integral. DCNL lut : callable DCNL Look-up table for evaluating Legendre polynomials. DCNL n_fact : array DCNL Coefficients in the integration sum. DCNL ch_type : str DCNL \'meg\' or \'eeg\' DCNL idx : array, shape (n_coils x 1) DCNL Index of coil. DCNL Returns DCNL products : array, shape (n_coils, n_coils) DCNL The integration products.'
'Compute ``f**n`` in ``GF(p)[x]/(g)`` using repeated squaring. DCNL Given polynomials ``f`` and ``g`` in ``GF(p)[x]`` and a non-negative DCNL integer ``n``, efficiently computes ``f**n (mod g)`` i.e. the remainder DCNL of ``f**n`` from division by ``g``, using the repeated squaring algorithm. DCNL Examples DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.galoistools import gf_pow_mod DCNL >>> gf_pow_mod(ZZ.map([3, 2, 4]), 3, ZZ.map([1, 1]), 5, ZZ) DCNL References DCNL 1. [Gathen99]_'
'Given two binary arrays, compute their overlap. The overlap is the number DCNL of bits where x[i] and y[i] are both 1'
'List a specific job given by its jid DCNL ext_source DCNL If provided, specifies which external job cache to use. DCNL display_progress : False DCNL If ``True``, fire progress events. DCNL .. versionadded:: 2015.8.8 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-run jobs.list_job 20130916125524463507 DCNL salt-run jobs.list_job 20130916125524463507 --out=pprint'
'A helper for defining choice string options.'
'Returns True if any of the installed versions match the specified version, DCNL otherwise returns False'
'List configured exports DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nfs.list_exports'
'Ensure that the directory is available and permissions are set. DCNL Args: DCNL path (str): The full path to the directory. DCNL owner (str): The owner of the directory. If not passed, it will be the DCNL account that created the directory, likely SYSTEM DCNL grant_perms (dict): A dictionary containing the user/group and the basic DCNL permissions to grant, ie: ``{\'user\': {\'perms\': \'basic_permission\'}}``. DCNL You can also set the ``applies_to`` setting here. The default is DCNL ``this_folder_subfolders_files``. Specify another ``applies_to`` setting DCNL like this: DCNL .. code-block:: yaml DCNL {\'user\': {\'perms\': \'full_control\', \'applies_to\': \'this_folder\'}} DCNL To set advanced permissions use a list for the ``perms`` parameter, ie: DCNL .. code-block:: yaml DCNL {\'user\': {\'perms\': [\'read_attributes\', \'read_ea\'], \'applies_to\': \'this_folder\'}} DCNL deny_perms (dict): A dictionary containing the user/group and DCNL permissions to deny along with the ``applies_to`` setting. Use the same DCNL format used for the ``grant_perms`` parameter. Remember, deny DCNL permissions supersede grant permissions. DCNL inheritance (bool): If True the object will inherit permissions from the DCNL parent, if False, inheritance will be disabled. Inheritance setting will DCNL not apply to parent directories if they must be created DCNL Returns: DCNL bool: True if successful, otherwise raise an error DCNL CLI Example: DCNL .. code-block:: bash DCNL # To grant the \'Users\' group \'read & execute\' permissions. DCNL salt \'*\' file.mkdir C:\Temp\ Administrators "{\'Users\': {\'perms\': \'read_execute\'}}" DCNL # Locally using salt call DCNL salt-call file.mkdir C:\Temp\ Administrators "{\'Users\': {\'perms\': \'read_execute\', \'applies_to\': \'this_folder_only\'}}" DCNL # Specify advanced attributes with a list DCNL salt \'*\' file.mkdir C:\Temp\ Administrators "{\'jsnuffy\': {\'perms\': [\'read_attributes\', \'read_ea\'], \'applies_to\': \'this_folder_only\'}}"'
'List all subscriptions for a project.'
'Returns the indefinite or definite article for the given word.'
'Handler for notify_url for asynchronous updating billing information. DCNL Logging the information.'
'Convert b to a boolean or raise'
'Different ways of providing the frame.'
'Returns n bytes of strong random data.'
'Only returns true if accessing_obj has_player is true, that is, DCNL this is a player-controlled object. It fails on actual players! DCNL This is a useful lock for traverse-locking Exits to restrain NPC DCNL mobiles from moving outside their areas.'
'Called by __init__ to initialize generator values based on params.'
'Test adding a reference.'
'non-strided'
'Return a list of mocked presets.'
'Unittest runner'
'toggle data register D5 bit'
'Checks a file is executable'
'Ensure the state of a particular option/setting in csf. DCNL name DCNL The option name in csf.conf DCNL value DCNL The value it should be set to. DCNL reload DCNL Boolean. If set to true, csf will be reloaded after.'
'Simplest possible application object'
'Attach total of point values to each object of the queryset. DCNL :param queryset: A Django milestones queryset object. DCNL :param as_field: Attach the points as an attribute with this name. DCNL :return: Queryset object with the additional `as_field` field.'
'Create an IIS virtual directory. DCNL .. note: DCNL This function only validates against the virtual directory name, and will return DCNL True even if the virtual directory already exists with a different configuration. DCNL It will not modify the configuration of an existing virtual directory. DCNL :param str name: The virtual directory name. DCNL :param str site: The IIS site name. DCNL :param str sourcepath: The physical path. DCNL :param str app: The IIS application. DCNL Example of usage with only the required arguments: DCNL .. code-block:: yaml DCNL site0-foo-vdir: DCNL win_iis.create_vdir: DCNL - name: foo DCNL - site: site0 DCNL - sourcepath: C:\inetpub\vdirs\foo DCNL Example of usage specifying all available arguments: DCNL .. code-block:: yaml DCNL site0-foo-vdir: DCNL win_iis.create_vdir: DCNL - name: foo DCNL - site: site0 DCNL - sourcepath: C:\inetpub\vdirs\foo DCNL - app: v1'
'Extra arguments to use when zipline\'s automated tests run this example.'
'Spawn an emulator instance and run the system tests. DCNL :type package: str DCNL :param package: The package to run system tests against.'
'Test hsl to rgb color function'
'Return a NetworkX Graph or DiGraph from a PyGraphviz graph. DCNL Parameters DCNL A : PyGraphviz AGraph DCNL A graph created with PyGraphviz DCNL create_using : NetworkX graph class instance DCNL The output is created using the given graph class instance DCNL Examples DCNL >>> K5 = nx.complete_graph(5) DCNL >>> A = nx.nx_agraph.to_agraph(K5) DCNL >>> G = nx.nx_agraph.from_agraph(A) DCNL >>> G = nx.nx_agraph.from_agraph(A) DCNL Notes DCNL The Graph G will have a dictionary G.graph_attr containing DCNL the default graphviz attributes for graphs, nodes and edges. DCNL Default node attributes will be in the dictionary G.node_attr DCNL which is keyed by node. DCNL Edge attributes will be returned as edge data in G.  With DCNL edge_attr=False the edge data will be the Graphviz edge weight DCNL attribute or the value 1 if no edge weight attribute is found.'
'Test Filter Tool'
'Toggle the state of <flag> on <partition>. Valid flags are the same as DCNL the set command. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' partition.toggle /dev/sda 1 boot'
'Parses svn+http://blahblah@rev#egg=Foobar into a requirement DCNL (Foobar) and a URL'
'Process the xml element by derivation.'
'Applies a filter on a sequence of objects or looks up an attribute. DCNL This is useful when dealing with lists of objects but you are really DCNL only interested in a certain value of it. DCNL The basic usage is mapping on an attribute.  Imagine you have a list DCNL of users but you are only interested in a list of usernames: DCNL .. sourcecode:: jinja DCNL Users on this page: {{ users|map(attribute=\'username\')|join(\', \') }} DCNL Alternatively you can let it invoke a filter by passing the name of the DCNL filter and the arguments afterwards.  A good example would be applying a DCNL text conversion filter on a sequence: DCNL .. sourcecode:: jinja DCNL Users on this page: {{ titles|map(\'lower\')|join(\', \') }} DCNL .. versionadded:: 2.7'
'Non-subparser setups should receive a default root key called \'primary\''
'Test that an input file which is completely empty fails in the expected way. DCNL Test that an input file with one line but no newline succeeds.'
'Flood Gauges, RESTful controller'
'Deletes image data from the location of backend store. DCNL :param req: The WSGI/Webob Request object DCNL :param location_data: Location to the image data in a data store DCNL :param id: Opaque image identifier'
'Convert a pd.Timedelta to a number of minutes as an int.'
'.. versionchanged:: 2015.8.12,2016.3.3,2016.11.0 DCNL On minions running systemd>=205, `systemd-run(1)`_ is now used to DCNL isolate commands which modify installed packages from the DCNL ``salt-minion`` daemon\'s control group. This is done to keep systemd DCNL from killing any apt-get/dpkg commands spawned by Salt when the DCNL ``salt-minion`` service is restarted. (see ``KillMode`` in the DCNL `systemd.kill(5)`_ manpage for more information). If desired, usage of DCNL `systemd-run(1)`_ can be suppressed by setting a :mod:`config option DCNL <salt.modules.config.get>` called ``systemd.scope``, with a value of DCNL ``False`` (no quotes). DCNL .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html DCNL .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html DCNL Remove packages via ``apt-get purge`` along with all configuration files. DCNL name DCNL The name of the package to be deleted. DCNL Multiple Package Options: DCNL pkgs DCNL A list of packages to delete. Must be passed as a python list. The DCNL ``name`` parameter will be ignored if this option is passed. DCNL .. versionadded:: 0.16.0 DCNL Returns a dict containing the changes. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.purge <package name> DCNL salt \'*\' pkg.purge <package1>,<package2>,<package3> DCNL salt \'*\' pkg.purge pkgs=\'["foo", "bar"]\''
'Helper method for defining parse actions that require matching at a specific DCNL column in the input text.'
'Return true if the variable is odd.'
'List the keys available'
'Returns a dictionary indexed by node id1\'s, DCNL in which each value is a dictionary of connected node id2\'s linking to the edge weight. DCNL If directed=True, edges go from id1 to id2, but not the other way. DCNL If stochastic=True, all the weights for the neighbors of a given node sum to 1. DCNL A heuristic function can be given that takes two node id\'s and returns DCNL an additional cost for movement between the two nodes.'
'Return a list of ``(name, level)`` tuples for assigned names DCNL The `level` is `None` for simple assignments and is a list of DCNL numbers for tuple assignments for example in:: DCNL a, (b, c) = x DCNL The levels for for `a` is ``[0]``, for `b` is ``[1, 0]`` and for DCNL `c` is ``[1, 1]``.'
'Return the conditional entropy of X given Y. DCNL Parameters DCNL px : array-like DCNL py : array-like DCNL pxpy : array-like, optional DCNL If pxpy is None, the distributions are assumed to be independent DCNL and conendtropy(px,py) = shannonentropy(px) DCNL logbase : int or np.e DCNL Returns DCNL sum_{kj}log(q_{j}/w_{kj} DCNL where q_{j} = Y[j] DCNL and w_kj = X[k,j]'
'Decorator to create a task class out of any callable. DCNL **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(max_retries=10) DCNL def refresh_feed(url): DCNL try: DCNL return Feed.objects.get(url=url).refresh() DCNL except socket.error, exc: DCNL refresh_feed.retry(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>'
'Check image availability. DCNL This check is needed in case Nova and Glance are deployed DCNL without authentication turned on.'
'Publishes the exploration with publish_exploration() function in DCNL rights_manager.py, as well as updates first_contribution_msec. DCNL It is the responsibility of the caller to check that the exploration is DCNL valid prior to publication.'
'Subsamples the input along the spatial dimensions. DCNL Args: DCNL inputs: A `Tensor` of size [batch, height_in, width_in, channels]. DCNL factor: The subsampling factor. DCNL scope: Optional variable_scope. DCNL Returns: DCNL output: A `Tensor` of size [batch, height_out, width_out, channels] with the DCNL input, either intact (if factor == 1) or subsampled (if factor > 1).'
'Returns an invite form. DCNL Templates: ``groups/group_invite.html`` DCNL Context: DCNL form DCNL GroupInviteForm object'
'Strip a list of files'
'replace each Riemann tensor with an equivalent expression DCNL satisfying the cyclic identity. DCNL This trick is discussed in the reference guide to Cadabra. DCNL Examples DCNL >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead, riemann_cyclic DCNL >>> Lorentz = TensorIndexType(\'Lorentz\', dummy_fmt=\'L\') DCNL >>> i, j, k, l = tensor_indices(\'i,j,k,l\', Lorentz) DCNL >>> R = tensorhead(\'R\', [Lorentz]*4, [[2, 2]]) DCNL >>> t = R(i,j,k,l)*(R(-i,-j,-k,-l) - 2*R(-i,-k,-j,-l)) DCNL >>> riemann_cyclic(t) DCNL 0'
'Sanitize html_code for safe embed on LMS pages. DCNL Used to sanitize XQueue responses from Matlab.'
'Reads the object from the local cache using pickle. DCNL The local cache is per tex document and the path will extracted DCNL from the tex root DCNL Arguments: DCNL tex_root -- the root of the tex file (for the folder of the cache) DCNL name -- the relative file name to read the object DCNL Returns: DCNL The object at the location with the name'
'Combine regions separated by weight less than threshold. DCNL Given an image\'s labels and its RAG, output new labels by DCNL combining regions whose nodes are separated by a weight less DCNL than the given threshold. DCNL Parameters DCNL labels : ndarray DCNL The array of labels. DCNL rag : RAG DCNL The region adjacency graph. DCNL thresh : float DCNL The threshold. Regions connected by edges with smaller weights are DCNL combined. DCNL in_place : bool DCNL If set, modifies `rag` in place. The function will remove the edges DCNL with weights less that `thresh`. If set to `False` the function DCNL makes a copy of `rag` before proceeding. DCNL Returns DCNL out : ndarray DCNL The new labelled array. DCNL Examples DCNL >>> from skimage import data, segmentation DCNL >>> from skimage.future import graph DCNL >>> img = data.astronaut() DCNL >>> labels = segmentation.slic(img) DCNL >>> rag = graph.rag_mean_color(img, labels) DCNL >>> new_labels = graph.cut_threshold(labels, rag, 10) DCNL References DCNL .. [1] Alain Tremeau and Philippe Colantoni DCNL "Regions Adjacency Graph Applied To Color Image Segmentation" DCNL http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.11.5274'
'Add a leader to the group.'
'Show a contribution box. DCNL Parameters: DCNL addon DCNL text: The begging text at the top of the box. DCNL src: The page where the contribution link is coming from. DCNL show_install: Whether or not to show the install button. DCNL show_help: Show "What\'s this?" link? DCNL contribution_src: The source for the contribution src, DCNL will use src if not provided.'
'Returns the kinetic energy associated with the given velocity DCNL and mass of 1. DCNL Parameters DCNL vel: theano matrix DCNL Symbolic matrix whose rows are velocity vectors. DCNL Returns DCNL return: theano vector DCNL Vector whose i-th entry is the kinetic entry associated with vel[i].'
'Return JSON of location hierarchy suitable for use by S3LocationSelector DCNL \'/eden/gis/ldata/\' + id DCNL n = {id : {\'n\' : name, DCNL \'l\' : level, DCNL \'f\' : parent, DCNL \'b\' : [lon_min, lat_min, lon_max, lat_max]'
'Delete an instance type.'
'Converts a url into a made-up module name by doing the following: DCNL * Extract just the path name ignoring querystrings DCNL * Trimming off the initial / DCNL * Trimming off the file extension DCNL * Removes off useless folder prefixes DCNL e.g. http://google.com/js/v1.0/foo/bar/baz.js -> foo/bar/baz'
'Contextmanager that installs the trap app. DCNL The trap means that anything trying to use the current or default app DCNL will raise an exception.'
'Cache of settings.LANGUAGES in an OrderedDict for easy lookups by key.'
'>>> is_clean_uri("ABC!") DCNL True DCNL >>> is_clean_uri(u"ABC!") DCNL True DCNL >>> is_clean_uri("ABC|") DCNL False DCNL >>> is_clean_uri(u"ABC|") DCNL False DCNL >>> is_clean_uri("http://example.com/0") DCNL True DCNL >>> is_clean_uri(u"http://example.com/0") DCNL True'
'Builds C3D model DCNL Returns DCNL dict DCNL A dictionary containing the network layers, where the output layer is at key \'prob\''
'Return the ssh_interface type to connect to. Either \'public_ips\' (default) DCNL or \'private_ips\'.'
'Returns the Tenancy to use. DCNL Can be "dedicated" or "default". Cannot be present for spot instances.'
'Operation for efficiently calculating the dot product when DCNL one or all operands are sparse. Supported formats are CSC and CSR. DCNL The output of the operation is sparse. DCNL Parameters DCNL x DCNL Sparse matrix. DCNL y DCNL Sparse matrix or 2d tensor variable. DCNL grad_preserves_dense : bool DCNL If True (default), makes the grad of dense inputs dense. DCNL Otherwise the grad is always sparse. DCNL Returns DCNL The dot product `x`.`y` in a sparse format. DCNL Notex DCNL The grad implemented is regular, i.e. not structured.'
'Traverse the options and parse all --map-TYPEs, or call Option.fatal().'
'The user should call these functions: parse_xmlrpc and build_xmlrpc. DCNL :param xml_string: The original XML string that we got from the browser. DCNL :return: A handler that can then be used to access the result information DCNL from: DCNL - handler.fuzzable_parameters DCNL - handler.all_parameters DCNL - handler.get_data_container'
'Get the release number of the distribution. DCNL Example:: DCNL from fabtools.system import distrib_id, distrib_release DCNL if distrib_id() == \'CentOS\' and distrib_release() == \'6.1\': DCNL print(u"CentOS 6.2 has been released. Please upgrade.")'
'Return tha total of memberships of a project (members and unaccepted invitations). DCNL :param project: A project object. DCNL :return: a number.'
'Fit the provided functrion to the x and y values. DCNL The function parameters and the parameters covariance.'
'Make arrays indexable for cross-validation. DCNL Checks consistent length, passes through None, and ensures that everything DCNL can be indexed by converting sparse matrices to csr and converting DCNL non-interable objects to arrays. DCNL Parameters DCNL *iterables : lists, dataframes, arrays, sparse matrices DCNL List of objects to ensure sliceability.'
'Section search DCNL Queries with query ``q`` across all documents and projects. Queries can be DCNL limited to a single project or version by using the ``project`` and DCNL ``version`` GET arguments in your request. DCNL When you search, you will have a ``project`` facet, which includes the DCNL number of matching sections per project. When you search inside a project, DCNL the ``path`` facet will show the number of matching sections per page. DCNL Possible GET args DCNL q **(required)** DCNL The query string **Required** DCNL project DCNL A project slug DCNL version DCNL A version slug DCNL path DCNL A file path slug DCNL Example:: DCNL GET /api/v2/search/section/?q=virtualenv&project=django'
'Remove non release groups from name'
'Filename or file object?'
'Returns the Requests tuple auth for a given url from netrc.'
'Create a temporary file name which should not already exist.  Use the DCNL directory of the input file as the base name of the mkstemp() output.'
'Displays text with line numbers.'
'Return the name of the current Linux distribution, as a human-readable DCNL string. DCNL If *pretty* is false, the name is returned without version or codename. DCNL (e.g. "CentOS Linux") DCNL If *pretty* is true, the version and codename are appended. DCNL (e.g. "CentOS Linux 7.1.1503 (Core)") DCNL **Lookup hierarchy:** DCNL The name is obtained from the following sources, in the specified order. DCNL The first available and non-empty value is used: DCNL * If *pretty* is false: DCNL - the value of the "NAME" attribute of the os-release file, DCNL - the value of the "Distributor ID" attribute returned by the lsb_release DCNL command, DCNL - the value of the "<name>" field of the distro release file. DCNL * If *pretty* is true: DCNL - the value of the "PRETTY_NAME" attribute of the os-release file, DCNL - the value of the "Description" attribute returned by the lsb_release DCNL command, DCNL - the value of the "<name>" field of the distro release file, appended DCNL with the value of the pretty version ("<version_id>" and "<codename>" DCNL fields) of the distro release file, if available.'
'Always use logging.Logger class. DCNL The user code may change the loggerClass (e.g. pyinotify), DCNL and will cause exception when format log message.'
''
'Get this matrix multiplied by the otherColumn.'
'Get the fabmetheus utilities directory path.'
'Simple view to echo back info about uploaded files for tests.'
'Makes a pre-connect version of socket.connect'
'A version of Python\'s urllib.quote_plus() function that can operate on DCNL unicode strings. The url is first UTF-8 encoded before quoting. The DCNL returned string can safely be used as part of an argument to a subsequent DCNL iri_to_uri() call without double-quoting occurring.'
'A helper function to create a mock to replace the use of `open`. It works DCNL for `open` called directly or used as a context manager. DCNL The `mock` argument is the mock object to configure. If `None` (the DCNL default) then a `MagicMock` will be created for you, with the API limited DCNL to methods or attributes available on standard file handles. DCNL `read_data` is a string for the `read` methoddline`, and `readlines` of the DCNL file handle to return.  This is an empty string by default.'
'Parse a date string that contains no time information in a manner that DCNL guarantees that the month and year are always correct in all timezones, and DCNL the day is at most one day wrong.'
'From `tableaux` and `bases`, extract non-slack basic variables and DCNL return a tuple of the corresponding, normalized mixed actions. DCNL Parameters DCNL tableaux : tuple(ndarray(float, ndim=2)) DCNL Tuple of two arrays containing the tableaux, of shape (n, m+n+1) DCNL and (m, m+n+1), respectively. DCNL bases : tuple(ndarray(int, ndim=1)) DCNL Tuple of two arrays containing the bases, of shape (n,) and DCNL (m,), respectively. DCNL Returns DCNL tuple(ndarray(float, ndim=1)) DCNL Tuple of mixed actions as given by the non-slack basic variables DCNL in the tableaux.'
'Make jail ``jname`` pkgng aware DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' poudriere.make_pkgng_aware <jail name>'
'This device is having its own devices downloaded'
'Reads a dictionary of the current user\'s tokens from the datastore. DCNL If there is no current user (a user is not signed in to the app) or the user DCNL does not have any tokens, an empty dictionary is returned.'
'Modify an existing monitor.  If it does exists, only DCNL the parameters specified will be enforced. 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 monitor_type DCNL The type of monitor to create DCNL name DCNL The name of the monitor to create DCNL kwargs DCNL [ arg=val ] ... DCNL Consult F5 BIGIP user guide for specific options for each monitor type. DCNL Typically, tmsh arg names are used.'
'Sampling.'
'Read RDB data with inconstent data type (except failure)'
'Get a string describing the arguments for the given object'
'Wrapper for allowing delivery of .reload command via PM'
'Try to format the string C{fmtString} using C{fmtDict} arguments, DCNL swallowing all errors to always return a string.'
'Get the inset loops, which might overlap.'
'Tests whether the algorithm is properly implementing the DCNL correct Blackbox-optimization interface.'
'Build an error dict corresponding to edX API conventions. DCNL Args: DCNL message (string): The string to use for developer and user messages. DCNL The user message will be translated, but for this to work message DCNL must have already been scraped. ugettext_noop is useful for this. DCNL **kwargs: format parameters for message'
'definition : toktype opttype idlist optsemi'
'Get the current clipboard\'s text on Windows. DCNL Requires Mark Hammond\'s pywin32 extensions.'
'Used by DoctestTextfile and DoctestItem to setup fixture information.'
'uniq_stable(elems) -> list DCNL Return from an iterable, a list of all the unique elements in the input, DCNL but maintaining the order in which they first appear. DCNL Note: All elements in the input must be hashable for this routine DCNL to work, as it internally uses a set for efficiency reasons.'
'Migrate all the cohort settings associated with this course from modulestore to mysql. DCNL After that we will never touch modulestore for any cohort related settings.'
'Returns an absolute URL for applications integrated with ApplicationContent DCNL The tag mostly works the same way as Django\'s own {% url %} tag:: DCNL {% load applicationcontent_tags %} DCNL {% app_reverse "mymodel_detail" "myapp.urls" arg1 arg2 %} DCNL or DCNL {% load applicationcontent_tags %} DCNL {% app_reverse "mymodel_detail" "myapp.urls" name1=value1 %} DCNL The first argument is a path to a view. The second argument is the URLconf DCNL under which this app is known to the ApplicationContent. The second DCNL argument may also be a request object if you want to reverse an URL DCNL belonging to the current application content. DCNL Other arguments are space-separated values that will be filled in place of DCNL positional and keyword arguments in the URL. Don\'t mix positional and DCNL keyword arguments. DCNL If you want to store the URL in a variable instead of showing it right away DCNL you can do so too:: DCNL {% app_reverse "mymodel_detail" "myapp.urls" arg1 arg2 as url %}'
'Breaks headers longer than 160 characters (~page length) DCNL when possible (are comma separated)'
'Raise an exception if the container does not exist'
'Convert a replacement pattern from the Java-style `$5` to the Python-style `\5`.'
'convert linkage ped/map to fbat'
'Formats correlation information to be suitable for writing to a file. DCNL Returns a string containing a header and a single line (with a newline at DCNL the end) that has the input correlation information in tab-separated DCNL format, with nonparametric p-value formatted according to the number of DCNL permutations. DCNL If the confidence interval is not valid for this dataset (i.e. the DCNL input CI is (None, None)), the confidence interval will be formatted as DCNL \'N/A\' for both lower and upper endpoints. DCNL Arguments: DCNL corr_coeff - the correlation coefficient (a float) DCNL param_p_val - the parametric p-value (a float) DCNL nonparam_p_val - the nonparametric p-value (a float) DCNL conf_interval - a tuple containing the lower and upper bounds of the DCNL confidence interval DCNL num_permutations - the number of permutations that were used to DCNL calculate the nonparametric p-value. Will be used to format the DCNL correct number of digits for this p-value. If less than 1, the DCNL p-value will be \'N/A\' DCNL header - if provided, this string will be inserted at the beginning of DCNL the returned string. For example, might be useful to add a comment DCNL describing what correlation coefficient was used. This string does DCNL not need to contain a newline at the end'
'Check non-explicit segments can be .mark_done\'d.'
'Return union of a sequence of disjoint dictionaries. DCNL Parameters DCNL dicts : dicts DCNL A set of dictionaries with no keys in common. If the first DCNL dictionary in the sequence is an instance of `OrderedDict`, the DCNL result will be OrderedDict. DCNL \*\*kwargs DCNL Keywords and values to add to the resulting dictionary. DCNL Raises DCNL ValueError DCNL If a key appears twice in the dictionaries or keyword arguments.'
'Return True if the named service is enabled, false otherwise DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' service.disabled <service name>'
'Universal search function generator using lazy evaluation. DCNL Generate a function that will iterate over all the paths from path_generator using DCNL target_predicate to filter matching paths.  Each matching path is then noramlized by target_predicate. DCNL Only the first match is returned. DCNL :param path_generator: all paths to test with target_predicate DCNL :type path_generator: iterator DCNL :param target_predicate: boolean function that tests a given path DCNL :type target_predicate: function DCNL :param target_normalizer: function that transforms a matching path to some noramlized form DCNL :type target_normalizer: function DCNL :param extra_paths: extra paths to pass to the path_generator DCNL :type extra_paths: iterator DCNL :return: the path searching function DCNL :rtype:  function'
'.. versionadded:: 2016.3.0 DCNL Check all services DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' monit.validate'
'Update transferability status of all cases, to be called either DCNL from scheduler task or manually through custom controller. DCNL @param site_id: the site to check for transferability of cases'
'@ToDo: Display the Progress of a Project'
'Just like \'imp.find_module()\', but with package support'
'Builds a hierarchical layout object from the fields list to be rendered DCNL by `standard.html` DCNL :param doc: Document to be rendered. DCNL :param meta: Document meta object (doctype). DCNL :param format_data: Fields sequence and properties defined by Print Format Builder.'
'Creates an RPC object for use with the urlfetch API. DCNL Args: DCNL deadline: Optional deadline in seconds for the operation; the default DCNL is a system-specific deadline (typically 5 seconds). DCNL callback: Optional callable to invoke on completion. DCNL Returns: DCNL An apiproxy_stub_map.UserRPC object specialized for this service.'
'Attempt to set AWS access key ID from script, else core-site, else None'
'Adds utility methods to a model to obtain related DCNL model instances via a cache.'
'Turn all nested sequences to tuples in given sequence.'
'Sniff packets and print them calling pkt.show(), a bit like text wireshark'
'.. todo:: DCNL WRITEME properly DCNL Creates a Conv2D with random kernels, where the randomly initialized DCNL values are sparse'
'Helper method for constructing grammars of expressions made up of DCNL operators working in a precedence hierarchy.  Operators may be unary or DCNL binary, left- or right-associative.  Parse actions can also be attached DCNL to operator expressions. DCNL Parameters: DCNL - baseExpr - expression representing the most basic element for the nested DCNL - opList - list of tuples, one for each operator precedence level in the DCNL expression grammar; each tuple is of the form DCNL (opExpr, numTerms, rightLeftAssoc, parseAction), where: DCNL - opExpr is the pyparsing expression for the operator; DCNL may also be a string, which will be converted to a Literal; DCNL if numTerms is 3, opExpr is a tuple of two expressions, for the DCNL two operators separating the 3 terms DCNL - numTerms is the number of terms for this operator (must DCNL be 1, 2, or 3) DCNL - rightLeftAssoc is the indicator whether the operator is DCNL right or left associative, using the pyparsing-defined DCNL constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}. DCNL - parseAction is the parse action to be associated with DCNL expressions matching this operator expression (the DCNL parse action tuple member may be omitted) DCNL - lpar - expression for matching left-parentheses (default=Suppress(\'(\')) DCNL - rpar - expression for matching right-parentheses (default=Suppress(\')\'))'
'Get the date/time the account was created DCNL :param str name: the username of the account DCNL :return: the date/time the account was created (yyyy-mm-dd hh:mm:ss) DCNL :rtype: str DCNL :raises: CommandExecutionError on user not found or any other unknown error DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' shadow.get_account_created admin'
'IP Lookup tool'
'RESTful CRUD controller'
'Always return \'false\' if the operating system does not support symlinks. DCNL @param path: a path string. DCNL @type path: L{str} DCNL @return: false'
'generate(bits:int, randfunc:callable, progress_func:callable, e:int) DCNL Generate an RSA key of length \'bits\', public exponent \'e\'(which must be DCNL odd), using \'randfunc\' to get random data and \'progress_func\', DCNL if present, to display the progress of the key generation.'
'Filters the contents of the block through variable filters. DCNL Filters can also be piped through each other, and they can have DCNL arguments -- just like in variable syntax. DCNL Sample usage:: DCNL {% filter force_escape|lower %} DCNL This text will be HTML-escaped, and will appear in lowercase. DCNL {% endfilter %} DCNL Note that the ``escape`` and ``safe`` filters are not acceptable arguments. DCNL Instead, use the ``autoescape`` tag to manage autoescaping for blocks of DCNL template code.'
'Reformat text, taking the width into account. DCNL `to_row` is included. DCNL (Vi \'gq\' operator.)'
'Given data x, construct the knot vector w/ not-a-knot BC. DCNL cf de Boor, XIII(12).'
'uses GoogleAppEngine (GAE) DCNL fetch(url, payload=None, method=GET, headers={}, allow_truncated=False) DCNL Response DCNL content DCNL The body content of the response. DCNL content_was_truncated DCNL True if the allow_truncated parameter to fetch() was True and DCNL the response exceeded the maximum response size. In this case, DCNL the content attribute contains the truncated response. DCNL status_code DCNL The HTTP status code. DCNL headers DCNL The HTTP response headers, as a mapping of names to values. DCNL Exceptions DCNL exception InvalidURLError() DCNL The URL of the request was not a valid URL, or it used an DCNL unsupported method. Only http and https URLs are supported. DCNL exception DownloadError() DCNL There was an error retrieving the data. DCNL This exception is not raised if the server returns an HTTP DCNL error code: In that case, the response data comes back intact, DCNL including the error code. DCNL exception ResponseTooLargeError() DCNL The response data exceeded the maximum allowed size, and the DCNL allow_truncated parameter passed to fetch() was False.'
'Return true if \'source\' exists and is more recently modified than DCNL \'target\', or if \'source\' exists and \'target\' doesn\'t.  Return false if DCNL both exist and \'target\' is the same age or younger than \'source\'. DCNL Raise DistutilsFileError if \'source\' does not exist.'
'This method will restore an asset which got soft deleted and put back in the original course'
'Convert "dict" to a canonical JSON string. Sort keys so that output DCNL ordering is always the same.'
'Works like :func:`url_decode` but decodes a stream.  The behavior DCNL of stream and limit follows functions like DCNL :func:`~werkzeug.wsgi.make_line_iter`.  The generator of pairs is DCNL directly fed to the `cls` so you can consume the data while it\'s DCNL parsed. DCNL .. versionadded:: 0.8 DCNL :param stream: a stream with the encoded querystring DCNL :param charset: the charset of the query string.  If set to `None` DCNL no unicode decoding will take place. DCNL :param decode_keys: Used on Python 2.x to control whether keys should DCNL be forced to be unicode objects.  If set to `True`, DCNL keys will be unicode in all cases. Otherwise, they DCNL remain `str` if they fit into ASCII. DCNL :param include_empty: Set to `False` if you don\'t want empty values to DCNL appear in the dict. DCNL :param errors: the decoding error behavior. DCNL :param separator: the pair separator to be used, defaults to ``&`` DCNL :param cls: an optional dict class to use.  If this is not specified DCNL or `None` the default :class:`MultiDict` is used. DCNL :param limit: the content length of the URL data.  Not necessary if DCNL a limited stream is provided. DCNL :param return_iterator: if set to `True` the `cls` argument is ignored DCNL and an iterator over all decoded pairs is DCNL returned'
'Deletes the specified subnet DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' neutron.delete_subnet subnet-name DCNL salt \'*\' neutron.delete_subnet subnet-name profile=openstack1 DCNL :param subnet: ID or name of subnet to delete DCNL :param profile: Profile to build on (Optional) DCNL :return: True(Succeed) or False'
'Returns the PID of a container DCNL name DCNL Container name DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion nspawn.pid arch1'
'Returns used LUN IDs with count as a dictionary.'
'If ``original`` doesn\'t already store ``matchee`` then return a new DCNL one that has it stored.'
'Run the command configured'
'Required attributes for a column can be set.'
'Monkeypatch the original version from distutils. DCNL It\'s supposed to match the behavior of Distribution.get_command_obj() DCNL This fixes issues with \'pip install -e\' and \'./setup.py test\' not DCNL respecting the setup.cfg configuration directives for the build_ext DCNL command.'
'Return a digital filter from an analog one using a bilinear transform. DCNL Transform a set of poles and zeros from the analog s-plane to the digital DCNL z-plane using Tustin\'s method, which substitutes ``(z-1) / (z+1)`` for DCNL ``s``, maintaining the shape of the frequency response. DCNL Parameters DCNL z : array_like DCNL Zeros of the analog IIR filter transfer function. DCNL p : array_like DCNL Poles of the analog IIR filter transfer function. DCNL k : float DCNL System gain of the analog IIR filter transfer function. DCNL fs : float DCNL Sample rate, as ordinary frequency (e.g. hertz). No prewarping is DCNL done in this function. DCNL Returns DCNL z : ndarray DCNL Zeros of the transformed digital filter transfer function. DCNL p : ndarray DCNL Poles of the transformed digital filter transfer function. DCNL k : float DCNL System gain of the transformed digital filter.'
'Configures the App Engine SDK imports on py.test startup.'
'Extract release date and year from database row'
'Find the position just after the matching endchar. DCNL Args: DCNL line: a CleansedLines line. DCNL startpos: start searching at this position. DCNL depth: nesting level at startpos. DCNL startchar: expression opening character. DCNL endchar: expression closing character. DCNL Returns: DCNL On finding matching endchar: (index just after matching endchar, 0) DCNL Otherwise: (-1, new depth at end of this line)'
'Returns the url for the login view, expanding the view name to a url if DCNL needed. DCNL :param login_view: The name of the login view or a URL for the login view. DCNL :type login_view: str'
'Part of an evolutionary algorithm applying only the variation part DCNL (crossover, mutation **or** reproduction). The modified individuals have DCNL their fitness invalidated. The individuals are cloned so returned DCNL population is independent of the input population. DCNL :param population: A list of individuals to vary. DCNL :param toolbox: A :class:`~deap.base.Toolbox` that contains the evolution DCNL operators. DCNL :param lambda\_: The number of children to produce DCNL :param cxpb: The probability of mating two individuals. DCNL :param mutpb: The probability of mutating an individual. DCNL :returns: The final population DCNL :returns: A class:`~deap.tools.Logbook` with the statistics of the DCNL evolution DCNL The variation goes as follow. On each of the *lambda_* iteration, it DCNL selects one of the three operations; crossover, mutation or reproduction. DCNL In the case of a crossover, two individuals are selected at random from DCNL the parental population :math:`P_\mathrm{p}`, those individuals are cloned DCNL using the :meth:`toolbox.clone` method and then mated using the DCNL :meth:`toolbox.mate` method. Only the first child is appended to the DCNL offspring population :math:`P_\mathrm{o}`, the second child is discarded. DCNL In the case of a mutation, one individual is selected at random from DCNL :math:`P_\mathrm{p}`, it is cloned and then mutated using using the DCNL :meth:`toolbox.mutate` method. The resulting mutant is appended to DCNL :math:`P_\mathrm{o}`. In the case of a reproduction, one individual is DCNL selected at random from :math:`P_\mathrm{p}`, cloned and appended to DCNL :math:`P_\mathrm{o}`. DCNL This variation is named *Or* beceause an offspring will never result from DCNL both operations crossover and mutation. The sum of both probabilities DCNL shall be in :math:`[0, 1]`, the reproduction probability is DCNL 1 - *cxpb* - *mutpb*.'
'Escape a single value of a URL string or a query parameter. If it is a list DCNL or tuple, turn it into a comma-separated string first.'
'Factory for making validators for API calls, since API calls come DCNL in two flavors: responsive and unresponsive.  The machinary DCNL associated with both is similar, and the error handling identical, DCNL so this function abstracts away the kw validation and creation of DCNL a Json-y responder object.'
'Link error here on x64'
'Parse RFC 822 dates and times, with one minor DCNL difference: years may be 4DIGIT or 2DIGIT. DCNL http://tools.ietf.org/html/rfc822#section-5'
'Given instance properties that define exactly one instance, create AMI and return AMI-id. DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt myminion boto_ec2.create_instance ami_name instance_name=myinstance DCNL salt myminion boto_ec2.create_instance another_ami_name tags=\'{"mytag": "value"}\' description=\'this is my ami\''
'Calculates the sentence level CHRF (Character n-gram F-score) described in DCNL - Maja Popovic. 2015. CHRF: Character n-gram F-score for Automatic MT Evaluation. DCNL In Proceedings of the 10th Workshop on Machine Translation. DCNL http://www.statmt.org/wmt15/pdf/WMT49.pdf DCNL - Maja Popovic. 2016. CHRF Deconstructed: β Parameters and n-gram Weights. DCNL In Proceedings of the 1st Conference on Machine Translation. DCNL http://www.statmt.org/wmt16/pdf/W16-2341.pdf DCNL Unlike multi-reference BLEU, CHRF only supports a single reference. DCNL An example from the original BLEU paper DCNL http://www.aclweb.org/anthology/P02-1040.pdf DCNL >>> ref1 = str(\'It is a guide to action that ensures that the military \' DCNL ...            \'will forever heed Party commands\').split() DCNL >>> hyp1 = str(\'It is a guide to action which ensures that the military \' DCNL ...            \'always obeys the commands of the party\').split() DCNL >>> hyp2 = str(\'It is to insure the troops forever hearing the activity \' DCNL ...            \'guidebook that party direct\').split() DCNL >>> sentence_chrf(ref1, hyp1) # doctest: +ELLIPSIS DCNL 0.6768... DCNL >>> sentence_chrf(ref1, hyp2) # doctest: +ELLIPSIS DCNL 0.4201... DCNL The infamous "the the the ... " example DCNL >>> ref = \'the cat is on the mat\'.split() DCNL >>> hyp = \'the the the the the the the\'.split() DCNL >>> sentence_chrf(ref, hyp)  # doctest: +ELLIPSIS DCNL 0.2530... DCNL An example to show that this function allows users to use strings instead of DCNL tokens, i.e. list(str) as inputs. DCNL >>> ref1 = str(\'It is a guide to action that ensures that the military \' DCNL ...            \'will forever heed Party commands\') DCNL >>> hyp1 = str(\'It is a guide to action which ensures that the military \' DCNL ...            \'always obeys the commands of the party\') DCNL >>> sentence_chrf(ref1, hyp1) # doctest: +ELLIPSIS DCNL 0.6768... DCNL >>> type(ref1) == type(hyp1) == str DCNL True DCNL >>> sentence_chrf(ref1.split(), hyp1.split()) # doctest: +ELLIPSIS DCNL 0.6768... DCNL To skip the unigrams and only use 2- to 3-grams: DCNL >>> sentence_chrf(ref1, hyp1, min_len=2, max_len=3) # doctest: +ELLIPSIS DCNL 0.7018... DCNL :param references: reference sentence DCNL :type references: list(str) / str DCNL :param hypothesis: a hypothesis sentence DCNL :type hypothesis: list(str) / str DCNL :param min_len: The minimum order of n-gram this function should extract. DCNL :type min_len: int DCNL :param max_len: The maximum order of n-gram this function should extract. DCNL :type max_len: int DCNL :param beta: the parameter to assign more importance to recall over precision DCNL :type beta: float DCNL :return: the sentence level CHRF score. DCNL :rtype: float'
'Check if printing should work in the given Qt version.'
'run a script file'
'Add a cohort to a course.  Raises ValueError if a cohort of the same name already DCNL exists.'
'.. versionadded:: 2015.8.0 DCNL Delete a specific affinity group associated with the account DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt-cloud -f delete_affinity_group my-azure name=my_affinity_group'
'Helper that denests the square root of three or more surds. DCNL It returns the denested expression; if it cannot be denested it DCNL throws SqrtdenestStopIteration DCNL Algorithm: expr.base is in the extension Q_m = Q(sqrt(r_1),..,sqrt(r_k)); DCNL split expr.base = a + b*sqrt(r_k), where `a` and `b` are on DCNL Q_(m-1) = Q(sqrt(r_1),..,sqrt(r_(k-1))); then a**2 - b**2*r_k is DCNL on Q_(m-1); denest sqrt(a**2 - b**2*r_k) and so on. DCNL See [1], section 6. DCNL Examples DCNL >>> from sympy import sqrt DCNL >>> from sympy.simplify.sqrtdenest import _sqrtdenest_rec DCNL >>> _sqrtdenest_rec(sqrt(-72*sqrt(2) + 158*sqrt(5) + 498)) DCNL -sqrt(10) + sqrt(2) + 9 + 9*sqrt(5) DCNL >>> w=-6*sqrt(55)-6*sqrt(35)-2*sqrt(22)-2*sqrt(14)+2*sqrt(77)+6*sqrt(10)+65 DCNL >>> _sqrtdenest_rec(sqrt(w)) DCNL -sqrt(11) - sqrt(7) + sqrt(2) + 3*sqrt(5)'
'When a user\'s username is changed, we must reindex the questions DCNL they participated in.'
'Detect spectral peak locations DCNL mX: magnitude spectrum, t: threshold DCNL returns ploc: peak locations'
'Deduce the encoding of a source file from magic comment. DCNL It does this in the same way as the `Python interpreter`__ DCNL .. __: http://docs.python.org/ref/encodings.html DCNL The ``fp`` argument should be a seekable file object. DCNL (From Jeff Dairiki)'
'Take CTRL+C into account (SIGINT).'
'Create a temporary directory DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' temp.dir DCNL salt \'*\' temp.dir prefix=\'mytemp-\' parent=\'/var/run/\''
'Figure out the name of a directory to back up the given dir to DCNL (adding .bak, .bak2, etc)'
'Generate a cyclic pattern DCNL Args: DCNL - size: size of generated pattern (Int) DCNL - start: the start offset of the generated pattern (Int) DCNL - charset_type: charset type DCNL 0: basic (0-9A-za-z) DCNL 1: extended (default) DCNL 2: maximum (almost printable chars) DCNL Returns: DCNL - pattern text (byte string) (str in Python 2; bytes in Python 3)'
'Plots a line. DCNL Args: DCNL xs: sequence of x values DCNL ys: sequence of y values DCNL options: keyword args passed to pyplot.bar'
'Serialize ``obj`` as a JSON formatted stream to ``fp`` (a DCNL ``.write()``-supporting file-like object). DCNL If *skipkeys* is true then ``dict`` keys that are not basic types DCNL (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) DCNL will be skipped instead of raising a ``TypeError``. DCNL If *ensure_ascii* is false, then the some chunks written to ``fp`` DCNL may be ``unicode`` instances, subject to normal Python ``str`` to DCNL ``unicode`` coercion rules. Unless ``fp.write()`` explicitly DCNL understands ``unicode`` (as in ``codecs.getwriter()``) this is likely DCNL to cause an error. DCNL If *check_circular* is false, then the circular reference check DCNL for container types will be skipped and a circular reference will DCNL result in an ``OverflowError`` (or worse). DCNL If *allow_nan* is false, then it will be a ``ValueError`` to DCNL serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) DCNL in strict compliance of the original JSON specification, instead of using DCNL the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). See DCNL *ignore_nan* for ECMA-262 compliant behavior. DCNL If *indent* is a string, then JSON array elements and object members DCNL will be pretty-printed with a newline followed by that string repeated DCNL for each level of nesting. ``None`` (the default) selects the most compact DCNL representation without any newlines. For backwards compatibility with DCNL versions of simplejson earlier than 2.1.0, an integer is also accepted DCNL and is converted to a string with that many spaces. DCNL If specified, *separators* should be an DCNL ``(item_separator, key_separator)`` tuple.  The default is ``(\', \', \': \')`` DCNL if *indent* is ``None`` and ``(\',\', \': \')`` otherwise.  To get the most DCNL compact JSON representation, you should specify ``(\',\', \':\')`` to eliminate DCNL whitespace. DCNL *encoding* is the character encoding for str instances, default is UTF-8. DCNL *default(obj)* is a function that should return a serializable version DCNL of obj or raise ``TypeError``. The default simply raises ``TypeError``. DCNL If *use_decimal* is true (default: ``True``) then decimal.Decimal DCNL will be natively serialized to JSON with full precision. DCNL If *namedtuple_as_object* is true (default: ``True``), DCNL :class:`tuple` subclasses with ``_asdict()`` methods will be encoded DCNL as JSON objects. DCNL If *tuple_as_array* is true (default: ``True``), DCNL :class:`tuple` (and subclasses) will be encoded as JSON arrays. DCNL If *iterable_as_array* is true (default: ``False``), DCNL any object not in the above table that implements ``__iter__()`` DCNL will be encoded as a JSON array. DCNL If *bigint_as_string* is true (default: ``False``), ints 2**53 and higher DCNL or lower than -2**53 will be encoded as strings. This is to avoid the DCNL rounding that happens in Javascript otherwise. Note that this is still a DCNL lossy operation that will not round-trip correctly and should be used DCNL sparingly. DCNL If *int_as_string_bitcount* is a positive number (n), then int of size DCNL greater than or equal to 2**n or lower than or equal to -2**n will be DCNL encoded as strings. DCNL If specified, *item_sort_key* is a callable used to sort the items in DCNL each dictionary. This is useful if you want to sort items other than DCNL in alphabetical order by key. This option takes precedence over DCNL *sort_keys*. DCNL If *sort_keys* is true (default: ``False``), the output of dictionaries DCNL will be sorted by item. DCNL If *for_json* is true (default: ``False``), objects with a ``for_json()`` DCNL method will use the return value of that method for encoding as JSON DCNL instead of the object. DCNL If *ignore_nan* is true (default: ``False``), then out of range DCNL :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as DCNL ``null`` in compliance with the ECMA-262 specification. If true, this will DCNL override *allow_nan*. DCNL To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the DCNL ``.default()`` method to serialize additional types), specify it with DCNL the ``cls`` kwarg. NOTE: You should use *default* or *for_json* instead DCNL of subclassing whenever possible.'
'Custom slugify (percent encoded).'
'Returns a list of e-mail addresses parsed from the string.'
'Record usage of a ratelimit for the specified time slice. DCNL The total usage (including this one) of the ratelimit is returned or DCNL RatelimitError is raised if something went wrong during the process.'
'Set up the Bbox sensor.'
'Watch/unwatch a forum (based on \'watch\' POST param).'
'Checks to see whether overrides are disabled in the current context. DCNL Returns a boolean value.  See `disable_overrides`.'
'Robust estimation of homography H from point DCNL correspondences using RANSAC (ransac.py from DCNL http://www.scipy.org/Cookbook/RANSAC). DCNL input: fp,tp (3*n arrays) points in hom. coordinates.'
'make limited length string in form: DCNL "the string is very lo...(and 15 more)"'
'Test mouse and key events'
'Initialize and return the `Native` subsystem.'
'Run supervised learning (random forests here) DCNL predictor_fp: path to otu table DCNL response_fp: path to metadata table DCNL response_name: Column header for gradient variable in metadata table DCNL ntree: Number of trees in forest DCNL errortype: method for estimating generalization error DCNL output_dir: output directory DCNL verbose: print verbose output DCNL output_dir: directory where output should be written (default \'.\') DCNL HALT_EXEC: halt just before running the formatdb command and'
'Regression test for https://github.com/astropy/astropy/issues/4612 DCNL This one uses WCS.wcs.compare and some slightly different values'
'Attempt to synthesize a controller base on existing controllers. DCNL This is useful to create a controller when a user specifies a path to DCNL an entry in the BROWSER environment variable -- we can copy a general DCNL controller to operate using a specific installation of the desired DCNL browser in this way. DCNL If we can\'t create a controller in this way, or if there is no DCNL executable for the requested browser, return [None, None].'
'Adds a timeout to an existing deferred.  If the timeout expires before the DCNL deferred expires, then the deferred is cancelled. DCNL :param IReactorTime reactor: The reactor implementation to schedule the DCNL timeout. DCNL :param Deferred deferred: The deferred to cancel at a later point in time. DCNL :param float timeout_sec: The number of seconds to wait before the deferred DCNL should time out. DCNL :param Exception reason: An exception used to create a Failure with which DCNL to fire the Deferred if the timeout is encountered.  If not given, DCNL ``deferred`` retains its original failure behavior. DCNL :return: The updated deferred.'
'Convert JSON row data to row with appropriate types. DCNL :type row: dict DCNL :param row: A JSON response row to be converted. DCNL :type schema: tuple DCNL :param schema: A tuple of DCNL :class:`~google.cloud.bigquery.schema.SchemaField`. DCNL :rtype: tuple DCNL :returns: A tuple of data converted to native types.'
'Return a (ci)tree for the given CIX content. DCNL Raises pyexpat.ExpatError if the CIX content could not be parsed.'
'Return an icon name for the issue status. DCNL Args: DCNL status (unicode): DCNL The stored issue status for the comment. DCNL Returns: DCNL unicode: The icon name for the issue status.'
'Test a sequence generator with integer outputs. DCNL Such sequence generators can be used to e.g. model language.'
'Strip trailing component `trailing` from `content` if it exists. DCNL Used when generating names from view classes.'
'>> exit_if_empty DCNL Exit the script currently running, if there are no deferred messages DCNL on the current page.'
'Return the list of objects that exactly match the given DCNL name_filter.'
'Generates sequences of xs and ps for a Pareto CDF. DCNL xmin: parameter DCNL alpha: parameter DCNL low: float DCNL high: float DCNL n: number of points to render DCNL returns: numpy arrays (xs, ps)'
'Abort if python-apt is not installed'
'Updates the cached list of loaders from a zipfile. The loader_lock MUST DCNL be held when calling this function. DCNL :param z: DCNL The zipfile.ZipFile object to list the files in'
'Given a context (ids) in list format and the vocabulary, DCNL Returns a list of words to represent the context. DCNL Parameters DCNL data : a list of integer DCNL the context in list format DCNL id_to_word : a dictionary DCNL mapping id to unique word. DCNL Returns DCNL A list of string or byte to represent the context. DCNL Examples DCNL >>> see words_to_word_ids'
'Computes the O\'Brien transform on input data (any number of arrays). DCNL Used to test for homogeneity of variance prior to running one-way stats. DCNL Each array in ``*args`` is one level of a factor. DCNL If `f_oneway` is run on the transformed data and found significant, DCNL the variances are unequal.  From Maxwell and Delaney [1]_, p.112. DCNL Parameters DCNL args : tuple of array_like DCNL Any number of arrays. DCNL Returns DCNL obrientransform : ndarray DCNL Transformed data for use in an ANOVA.  The first dimension DCNL of the result corresponds to the sequence of transformed DCNL arrays.  If the arrays given are all 1-D of the same length, DCNL the return value is a 2-D array; otherwise it is a 1-D array DCNL of type object, with each element being an ndarray. DCNL References DCNL .. [1] S. E. Maxwell and H. D. Delaney, "Designing Experiments and DCNL Analyzing Data: A Model Comparison Perspective", Wadsworth, 1990. DCNL Examples DCNL We\'ll test the following data sets for differences in their variance. DCNL >>> x = [10, 11, 13, 9, 7, 12, 12, 9, 10] DCNL >>> y = [13, 21, 5, 10, 8, 14, 10, 12, 7, 15] DCNL Apply the O\'Brien transform to the data. DCNL >>> from scipy.stats import obrientransform DCNL >>> tx, ty = obrientransform(x, y) DCNL Use `scipy.stats.f_oneway` to apply a one-way ANOVA test to the DCNL transformed data. DCNL >>> from scipy.stats import f_oneway DCNL >>> F, p = f_oneway(tx, ty) DCNL >>> p DCNL 0.1314139477040335 DCNL If we require that ``p < 0.05`` for significance, we cannot conclude DCNL that the variances are different.'
'Test installing a package using pip install --target'
'var occurs in subtree owned by x?'
'Returns dictionary of predecessors for the path from source to all nodes in G. DCNL Parameters DCNL G : NetworkX graph DCNL source : node label DCNL Starting node for path DCNL target : node label, optional DCNL Ending node for path. If provided only predecessors between DCNL source and target are returned DCNL cutoff : integer, optional DCNL Depth to stop the search. Only paths of length <= cutoff are returned. DCNL Returns DCNL pred : dictionary DCNL Dictionary, keyed by node, of predecessors in the shortest path. DCNL Examples DCNL >>> G = nx.path_graph(4) DCNL >>> list(G) DCNL [0, 1, 2, 3] DCNL >>> nx.predecessor(G, 0) DCNL {0: [], 1: [0], 2: [1], 3: [2]}'
'Return a public key fingerprint based on its base64-encoded representation DCNL The fingerprint string is formatted according to RFC 4716 (ch.4), that is, DCNL in the form "xx:xx:...:xx" DCNL If the key is invalid (incorrect base64 string), return None'
'Get response for when transport=cli.  This is kind of a hack and mainly DCNL needed because these modules were originally written for NX-API.  And DCNL not every command supports "| json" when using cli/ssh.'
'Return hash information from osquery DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' osquery.hash'
'Load the strikes data and return a Dataset class instance. DCNL Returns DCNL Dataset instance: DCNL See DATASET_PROPOSAL.txt for more information.'
'URL decode a single string with the given decoding and decode DCNL a "+" to whitespace. DCNL Per default encoding errors are ignored.  If you want a different behavior DCNL you can set `errors` to ``\'replace\'`` or ``\'strict\'``.  In strict mode a DCNL `HTTPUnicodeError` is raised. DCNL :param s: the string to unquote. DCNL :param charset: the charset to be used. DCNL :param errors: the error handling for the charset decoding.'
'Create an L{IWorker} that does nothing but defer work, to be performed DCNL later. DCNL @return: a worker that will enqueue work to perform later, and a callable DCNL that will perform one element of that work. DCNL @rtype: 2-L{tuple} of (L{IWorker}, L{callable})'
'Return `True` if the connected client node is the elected master node in DCNL the Elasticsearch cluster, otherwise return `False`. DCNL :arg client: An :class:`elasticsearch.Elasticsearch` client object DCNL :rtype: bool'
'With no arguments, return a dictionary of all configuration DCNL variables relevant for the current platform.  Generally this includes DCNL everything needed to build extensions and install both pure modules and DCNL extensions.  On Unix, this means every variable defined in Python\'s DCNL installed Makefile; on Windows and Mac OS it\'s a much smaller set. DCNL With arguments, return a list of values that result from looking up DCNL each argument in the configuration variable dictionary.'
'remove from todo'
'Create an IIS application pool. DCNL .. note: DCNL This function only validates against the application pool name, and will return DCNL True even if the application pool already exists with a different configuration. DCNL It will not modify the configuration of an existing application pool. DCNL :param str name: The name of the IIS application pool. DCNL :return: A boolean representing whether all changes succeeded. DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' win_iis.create_apppool name=\'MyTestPool\''
'DEPRECATED: Print list of available baremetal nodes.'
'Bounded minimization for scalar functions. DCNL Parameters DCNL func : callable f(x,*args) DCNL Objective function to be minimized (must accept and return scalars). DCNL x1, x2 : float or array scalar DCNL The optimization bounds. DCNL args : tuple, optional DCNL Extra arguments passed to function. DCNL xtol : float, optional DCNL The convergence tolerance. DCNL maxfun : int, optional DCNL Maximum number of function evaluations allowed. DCNL full_output : bool, optional DCNL If True, return optional outputs. DCNL disp : int, optional DCNL If non-zero, print messages. DCNL 0 : no message printing. DCNL 1 : non-convergence notification messages only. DCNL 2 : print a message on convergence too. DCNL 3 : print iteration results. DCNL Returns DCNL xopt : ndarray DCNL Parameters (over given interval) which minimize the DCNL objective function. DCNL fval : number DCNL The function value at the minimum point. DCNL ierr : int DCNL An error flag (0 if converged, 1 if maximum number of DCNL function calls reached). DCNL numfunc : int DCNL The number of function calls made. DCNL See also DCNL minimize_scalar: Interface to minimization algorithms for scalar DCNL univariate functions. See the \'Bounded\' `method` in particular. DCNL Notes DCNL Finds a local minimizer of the scalar function `func` in the DCNL interval x1 < xopt < x2 using Brent\'s method.  (See `brent` DCNL for auto-bracketing).'
'Returns the value of the primary key field of the specified `instance` DCNL of a SQLAlchemy model. DCNL This essentially a convenience function for:: DCNL getattr(instance, primary_key_for(instance)) DCNL If `as_string` is ``True``, try to coerce the return value to a string.'
'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 lower DCNL 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 .. seealso:: DCNL :meth:`.ColumnElement.between`'
'Return the common appdata path, using ctypes DCNL From http://stackoverflow.com/questions/626796/    how-do-i-find-the-windows-common-application-data-folder-using-python'
'Fetch and return all Launch Configuration with details. DCNL CLI example:: DCNL salt myminion boto_asg.get_all_launch_configurations'
'Ensure default cluster info path is never overwritten DCNL by launching successive clusters'
'lettuce.STEP_REGISTRY.load(step, func) should raise an error if step is not a regex'
'Some distros have a specific location for config files'
'Convenience function to apply parametric rectify to a given layer\'s output. DCNL Will set the layer\'s nonlinearity to identity if there is one and will DCNL apply the parametric rectifier instead. DCNL Parameters DCNL layer: a :class:`Layer` instance DCNL The `Layer` instance to apply the parametric rectifier layer to; DCNL note that it will be irreversibly modified as specified above DCNL **kwargs DCNL Any additional keyword arguments are passed to the DCNL :class:`ParametericRectifierLayer` DCNL Examples DCNL Note that this function modifies an existing layer, like this: DCNL >>> from lasagne.layers import InputLayer, DenseLayer, prelu DCNL >>> layer = InputLayer((32, 100)) DCNL >>> layer = DenseLayer(layer, num_units=200) DCNL >>> layer = prelu(layer) DCNL In particular, :func:`prelu` can *not* be passed as a nonlinearity.'
'Runs test method multiple times in the following order: DCNL debug       cached      string_if_invalid DCNL False       False DCNL False       True DCNL False       False       INVALID DCNL False       True        INVALID DCNL True        False DCNL True        True'
'Returns a list of standard base directories on this platform.'
'Return a percentile range from an array of values.'
'Return second-order sections from zeros, poles, and gain of a system DCNL Parameters DCNL z : array_like DCNL Zeros of the transfer function. DCNL p : array_like DCNL Poles of the transfer function. DCNL k : float DCNL System gain. DCNL pairing : {\'nearest\', \'keep_odd\'}, optional DCNL The method to use to combine pairs of poles and zeros into sections. DCNL See Notes below. DCNL Returns DCNL sos : ndarray DCNL Array of second-order filter coefficients, with shape DCNL ``(n_sections, 6)``. See `sosfilt` for the SOS filter format DCNL specification. DCNL See Also DCNL sosfilt DCNL Notes DCNL The algorithm used to convert ZPK to SOS format is designed to DCNL minimize errors due to numerical precision issues. The pairing DCNL algorithm attempts to minimize the peak gain of each biquadratic DCNL section. This is done by pairing poles with the nearest zeros, starting DCNL with the poles closest to the unit circle. DCNL *Algorithms* DCNL The current algorithms are designed specifically for use with digital DCNL filters. (The output coefficents are not correct for analog filters.) DCNL The steps in the ``pairing=\'nearest\'`` and ``pairing=\'keep_odd\'`` DCNL algorithms are mostly shared. The ``nearest`` algorithm attempts to DCNL minimize the peak gain, while ``\'keep_odd\'`` minimizes peak gain under DCNL the constraint that odd-order systems should retain one section DCNL as first order. The algorithm steps and are as follows: DCNL As a pre-processing step, add poles or zeros to the origin as DCNL necessary to obtain the same number of poles and zeros for pairing. DCNL If ``pairing == \'nearest\'`` and there are an odd number of poles, DCNL add an additional pole and a zero at the origin. DCNL The following steps are then iterated over until no more poles or DCNL zeros remain: DCNL 1. Take the (next remaining) pole (complex or real) closest to the DCNL unit circle to begin a new filter section. DCNL 2. If the pole is real and there are no other remaining real poles [#]_, DCNL add the closest real zero to the section and leave it as a first DCNL order section. Note that after this step we are guaranteed to be DCNL left with an even number of real poles, complex poles, real zeros, DCNL and complex zeros for subsequent pairing iterations. DCNL 3. Else: DCNL 1. If the pole is complex and the zero is the only remaining real DCNL zero*, then pair the pole with the *next* closest zero DCNL (guaranteed to be complex). This is necessary to ensure that DCNL there will be a real zero remaining to eventually create a DCNL first-order section (thus keeping the odd order). DCNL 2. Else pair the pole with the closest remaining zero (complex or DCNL real). DCNL 3. Proceed to complete the second-order section by adding another DCNL pole and zero to the current pole and zero in the section: DCNL 1. If the current pole and zero are both complex, add their DCNL conjugates. DCNL 2. Else if the pole is complex and the zero is real, add the DCNL conjugate pole and the next closest real zero. DCNL 3. Else if the pole is real and the zero is complex, add the DCNL conjugate zero and the real pole closest to those zeros. DCNL 4. Else (we must have a real pole and real zero) add the next DCNL real pole closest to the unit circle, and then add the real DCNL zero closest to that pole. DCNL .. [#] This conditional can only be met for specific odd-order inputs DCNL with the ``pairing == \'keep_odd\'`` method. DCNL .. versionadded:: 0.16.0 DCNL Examples DCNL Design a 6th order low-pass elliptic digital filter for a system with a DCNL sampling rate of 8000 Hz that has a pass-band corner frequency of DCNL 1000 Hz.  The ripple in the pass-band should not exceed 0.087 dB, and DCNL the attenuation in the stop-band should be at least 90 dB. DCNL In the following call to `signal.ellip`, we could use ``output=\'sos\'``, DCNL but for this example, we\'ll use ``output=\'zpk\'``, and then convert to SOS DCNL format with `zpk2sos`: DCNL >>> from scipy import signal DCNL >>> z, p, k = signal.ellip(6, 0.087, 90, 1000/(0.5*8000), output=\'zpk\') DCNL Now convert to SOS format. DCNL >>> sos = signal.zpk2sos(z, p, k) DCNL The coefficients of the numerators of the sections: DCNL >>> sos[:, :3] DCNL array([[ 0.0014154 ,  0.00248707,  0.0014154 ], DCNL [ 1.        ,  0.72965193,  1.        ], DCNL [ 1.        ,  0.17594966,  1.        ]]) DCNL The symmetry in the coefficients occurs because all the zeros are on the DCNL unit circle. DCNL The coefficients of the denominators of the sections: DCNL >>> sos[:, 3:] DCNL array([[ 1.        , -1.32543251,  0.46989499], DCNL [ 1.        , -1.26117915,  0.6262586 ], DCNL [ 1.        , -1.25707217,  0.86199667]]) DCNL The next example shows the effect of the `pairing` option.  We have a DCNL system with three poles and three zeros, so the SOS array will have DCNL shape (2, 6).  The means there is, in effect, an extra pole and an extra DCNL zero at the origin in the SOS representation. DCNL >>> z1 = np.array([-1, -0.5-0.5j, -0.5+0.5j]) DCNL >>> p1 = np.array([0.75, 0.8+0.1j, 0.8-0.1j]) DCNL With ``pairing=\'nearest\'`` (the default), we obtain DCNL >>> signal.zpk2sos(z1, p1, 1) DCNL array([[ 1.  ,  1.  ,  0.5 ,  1.  , -0.75,  0.  ], DCNL [ 1.  ,  1.  ,  0.  ,  1.  , -1.6 ,  0.65]]) DCNL The first section has the zeros {-0.5-0.05j, -0.5+0.5j} and the poles DCNL {0, 0.75}, and the second section has the zeros {-1, 0} and poles DCNL {0.8+0.1j, 0.8-0.1j}.  Note that the extra pole and zero at the origin DCNL have been assigned to different sections. DCNL With ``pairing=\'keep_odd\'``, we obtain: DCNL >>> signal.zpk2sos(z1, p1, 1, pairing=\'keep_odd\') DCNL array([[ 1.  ,  1.  ,  0.  ,  1.  , -0.75,  0.  ], DCNL [ 1.  ,  1.  ,  0.5 ,  1.  , -1.6 ,  0.65]]) DCNL The extra pole and zero at the origin are in the same section. DCNL The first section is, in effect, a first-order section.'
'Test that the base redirect to function works as expected'
'Return the load data that marks a specified jid'
'Parse feature files and return list of Feature model objects. DCNL Handles: DCNL * feature file names, ala "alice.feature" DCNL * feature file locations, ala: "alice.feature:10" DCNL :param feature_files: List of feature file names to parse. DCNL :param language:      Default language to use. DCNL :return: List of feature objects.'
'Lists the creds for given a cred_id and tenant_id'
'Find all CCX derived from this course, and send course published event for them.'
'Compute the inverse Hankel transform of `F` defined as DCNL .. math:: f(r) = \int_{0}^\infty F_\nu(k) J_\nu(k r) k \mathrm{d} k. DCNL If the transform cannot be computed in closed form, this DCNL function returns an unevaluated :class:`InverseHankelTransform` object. DCNL For a description of possible hints, refer to the docstring of DCNL :func:`sympy.integrals.transforms.IntegralTransform.doit`. DCNL Note that for this transform, by default ``noconds=True``. DCNL >>> from sympy import hankel_transform, inverse_hankel_transform, gamma DCNL >>> from sympy import gamma, exp, sinh, cosh DCNL >>> from sympy.abc import r, k, m, nu, a DCNL >>> ht = hankel_transform(1/r**m, r, k, nu) DCNL >>> ht DCNL 2*2**(-m)*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/gamma(m/2 + nu/2) DCNL >>> inverse_hankel_transform(ht, k, r, nu) DCNL r**(-m) DCNL >>> ht = hankel_transform(exp(-a*r), r, k, 0) DCNL >>> ht DCNL a/(k**3*(a**2/k**2 + 1)**(3/2)) DCNL >>> inverse_hankel_transform(ht, k, r, 0) DCNL exp(-a*r) DCNL See Also DCNL fourier_transform, inverse_fourier_transform DCNL sine_transform, inverse_sine_transform DCNL cosine_transform, inverse_cosine_transform DCNL hankel_transform DCNL mellin_transform, laplace_transform'
'return true if *obj* is iterable'
'Normalizes the input array so that it sums to 1. DCNL Parameters DCNL a : array DCNL Non-normalized input data. DCNL axis : int DCNL Dimension along which normalization is performed. DCNL Notes DCNL Modifies the input **inplace**.'
'Return the Krackhardt Kite Social Network. DCNL A 10 actor social network introduced by David Krackhardt DCNL to illustrate: degree, betweenness, centrality, closeness, etc. DCNL The traditional labeling is: DCNL Andre=1, Beverley=2, Carol=3, Diane=4, DCNL Ed=5, Fernando=6, Garth=7, Heather=8, Ike=9, Jane=10.'
'Save the load to the specified jid'
'Returns True if user_id_or_name is effective user (id/name).'
'_match_abbrev(s : string, wordmap : {string : Option}) -> string DCNL Return the string key in \'wordmap\' for which \'s\' is an unambiguous DCNL abbreviation.  If \'s\' is found to be ambiguous or doesn\'t match any of DCNL \'words\', raise BadOptionError.'
'Function to decide which key function to use. DCNL Defaults to ``default_key_func``.'
'Handle merging of nodes of a region boundary region adjacency graph. DCNL This function computes the `"weight"` and the count `"count"` DCNL attributes of the edge between `n` and the node formed after DCNL merging `src` and `dst`. DCNL Parameters DCNL graph : RAG DCNL The graph under consideration. DCNL src, dst : int DCNL The vertices in `graph` to be merged. DCNL n : int DCNL A neighbor of `src` or `dst` or both. DCNL Returns DCNL data : dict DCNL A dictionary with the "weight" and "count" attributes to be DCNL assigned for the merged node.'
'call str or unicode depending on current mode'
'Mark the specified HTML file as the titlepage of the EPUB. DCNL :param move_to_start: If True the HTML file is moved to the start of the spine'
'Install a trace hook which writes incredibly detailed logs DCNL about what code is being executed to stdout.'
'Computes the determinant of a batch of square matrices. DCNL Args: DCNL a (Variable): Input array to compute the determinant for. DCNL The first dimension should iterate over each matrix and be DCNL of the batchsize. DCNL Returns: DCNL ~chainer.Variable: vector of determinants for every matrix DCNL in the batch.'
'Add CSRF to dictionary and wrap in a RequestContext (needed for context processor!).'
'Returns a suitable Content-Range header: DCNL >>> print(_get_content_range(None, 1, 4)) DCNL bytes 0-0/4 DCNL >>> print(_get_content_range(1, 3, 4)) DCNL bytes 1-2/4 DCNL >>> print(_get_content_range(None, None, 4)) DCNL bytes 0-3/4'
'Sets the main_css.  The css_file must be of the form file.css'
'Determine if a point in the point table is in the loop.'
'Get the linear fitting data.'
'Test IO for evoked data (fif + gz) with integer and str args.'
'Defines the conversion between Jy/beam and "brightness temperature", DCNL :math:`T_B`, in Kelvins.  The brightness temperature is a unit very DCNL commonly used in radio astronomy.  See, e.g., "Tools of Radio Astronomy" DCNL (Wilson 2009) eqn 8.16 and eqn 8.19 (these pages are available on `google DCNL books DCNL <http://books.google.com/books?id=9KHw6R8rQEMC&pg=PA179&source=gbs_toc_r&cad=4#v=onepage&q&f=false>`__). DCNL :math:`T_B \equiv S_\nu / \left(2 k \nu^2 / c^2 \right)` DCNL However, the beam area is essential for this computation: the brightness DCNL temperature is inversely proportional to the beam area DCNL Parameters DCNL beam_area : Beam Area equivalent DCNL Beam area in angular units, i.e. steradian equivalent DCNL disp : `~astropy.units.Quantity` with spectral units DCNL The observed `spectral` equivalent `~astropy.units.Unit` (e.g., DCNL frequency or wavelength) DCNL Examples DCNL Arecibo C-band beam:: DCNL >>> import numpy as np DCNL >>> from astropy import units as u DCNL >>> beam_sigma = 50*u.arcsec DCNL >>> beam_area = 2*np.pi*(beam_sigma)**2 DCNL >>> freq = 5*u.GHz DCNL >>> equiv = u.brightness_temperature(beam_area, freq) DCNL >>> u.Jy.to(u.K, equivalencies=equiv)  # doctest: +FLOAT_CMP DCNL 3.526294429423223 DCNL >>> (1*u.Jy).to(u.K, equivalencies=equiv)  # doctest: +FLOAT_CMP DCNL <Quantity 3.526294429423223 K> DCNL VLA synthetic beam:: DCNL >>> bmaj = 15*u.arcsec DCNL >>> bmin = 15*u.arcsec DCNL >>> fwhm_to_sigma = 1./(8*np.log(2))**0.5 DCNL >>> beam_area = 2.*np.pi*(bmaj*bmin*fwhm_to_sigma**2) DCNL >>> freq = 5*u.GHz DCNL >>> equiv = u.brightness_temperature(beam_area, freq) DCNL >>> u.Jy.to(u.K, equivalencies=equiv)  # doctest: +FLOAT_CMP DCNL 217.2658703625732'
'Helper to convert a data type into a string.'
'Gets the (yaml, assets) from the contents of an exploration data dir. DCNL Args: DCNL dir_path: a full path to the exploration root directory. DCNL Returns: DCNL a 2-tuple, the first element of which is a yaml string, and the second DCNL element of which is a list of (filepath, content) 2-tuples. The filepath DCNL does not include the assets/ prefix. DCNL Raises: DCNL Exception: if the following condition doesn\'t hold: "There is exactly one DCNL file not in assets/, and this file has a .yaml suffix".'
'Fit a single dipole to the given whitened, projected data.'
'Copy a snapshot'
'Check that scenario tests have service tags DCNL T104: Scenario tests require a services decorator'
'Return true if the object is a class. DCNL Class objects provide these attributes: DCNL __doc__         documentation string DCNL __module__      name of module in which this class was defined'
'Listen in to see when videos become available.'
'Generates (name, contents) pairs for the given jar. DCNL Each generated tuple consists of the relative name within the jar of an entry, DCNL for example \'java/lang/Object.class\', and a str that is the corresponding DCNL contents. DCNL Args: DCNL jar_path: a str that is the path to the jar. DCNL Yields: DCNL A (name, contents) pair.'
'Produces a ColorAttr specification for coloring groups of data based on columns. DCNL Args: DCNL columns (str or list(str), optional): a column or list of columns for coloring DCNL palette (list(str), optional): a list of colors to use for assigning to unique DCNL values in `columns`. DCNL **kwargs: any keyword, arg supported by :class:`AttrSpec` DCNL Returns: DCNL a `ColorAttr` object'
'Import module, temporarily including modules in the current directory. DCNL Modules located in the current directory has DCNL precedence over modules located in `sys.path`.'
'Display the administration dashboard. DCNL This is the entry point to the admin site, containing news updates and DCNL useful administration tasks.'
'Serialize a sequence of Python objects into a YAML stream. DCNL If stream is None, return the produced string instead.'
'Returns the current/latest learned path. DCNL Checks if given paths are from same source/peer and then compares their DCNL version number to determine which path is received later. If paths are from DCNL different source/peer return None.'
'Create node positions for G using Graphviz. DCNL Parameters DCNL G : NetworkX graph DCNL A graph created with NetworkX DCNL prog : string DCNL Name of Graphviz layout program DCNL root : string, optional DCNL Root node for twopi layout DCNL args : string, optional DCNL Extra arguments to Graphviz layout program DCNL Returns : dictionary DCNL Dictionary of x,y, positions keyed by node. DCNL Examples DCNL >>> G = nx.petersen_graph() DCNL >>> pos = nx.nx_agraph.graphviz_layout(G) DCNL >>> pos = nx.nx_agraph.graphviz_layout(G, prog=\'dot\') DCNL Notes DCNL This is a wrapper for pygraphviz_layout.'
'Returns the message level tags.'
'Prints rows in the given table. DCNL Will print 25 rows at most for brevity as tables can contain large amounts DCNL of rows. DCNL If no project is specified, then the currently active project is used.'
'Return the first item of a sequence.'
'Display the feed dialog.'
'<user> - flirts with <user>'
'Parse a URL into 5 components: DCNL <scheme>://<netloc>/<path>?<query>#<fragment> DCNL Return a 5-tuple: (scheme, netloc, path, query, fragment). DCNL Note that we don\'t break the components up in smaller bits DCNL (e.g. netloc is a single string) and we don\'t expand % escapes.'
'Callback that yields multiple actions for each group in the match.'
'Given a policy name describe its properties. DCNL Returns a dictionary of interesting properties. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_iot.describe_policy mypolicy'
'Take Autoscaler params and generate GCE-compatible policy. DCNL :param as_params: Dictionary in Ansible-playbook format DCNL containing policy arguments. DCNL :type as_params: ``dict`` DCNL :return: GCE-compatible policy dictionary DCNL :rtype: ``dict``'
'atom ::= \'(\' expr \')\' | \'[\' expr \']\' | \'options\' DCNL | long | shorts | argument | command ;'
'HTML generation test only used when called from the command line: DCNL python ./highstate.py DCNL Typical options for generating the report file: DCNL highstate: DCNL report_format: yaml DCNL report_delivery: file DCNL file_output: \'/srv/salt/_returners/test.rpt\''
'Convert binary string to binary numbers. DCNL If classic_mode  is true (default value), reverse bits. DCNL >>> str2bin("\x03\xFF") DCNL \'00000011 11111111\' DCNL >>> str2bin("\x03\xFF", False) DCNL \'11000000 11111111\''
'Add tasks for creating a dataset by reading textfiles'
'Log a message with severity \'DEBUG\' on the root logger.'
'A strategy that yields floats greater than zero.'
'Wrapper for inserting an int64 FeatureList into a SequenceExample proto.'
'Returns a string identifying the Python implementation. DCNL Currently, the following implementations are identified: DCNL \'CPython\' (C implementation of Python), DCNL \'IronPython\' (.NET implementation of Python), DCNL \'Jython\' (Java implementation of Python), DCNL \'PyPy\' (Python implementation of Python).'
'Create a `Sort` from a single string criterion. DCNL `model_cls` is the `Model` being queried. `part` is a single string DCNL ending in ``+`` or ``-`` indicating the sort.'
'Add a resource DCNL zone : string DCNL name of zone DCNL resource_type : string DCNL type of resource DCNL **kwargs : string|int|... DCNL resource properties DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' zonecfg.add_resource tallgeese rctl name=zone.max-locked-memory value=\'(priv=privileged,limit=33554432,action=deny)\''
'bits_str(s, endian = \'big\', zero = \'0\', one = \'1\') -> str DCNL A wrapper around :func:`bits`, which converts the output into a string. DCNL Examples: DCNL >>> bits_str(511) DCNL \'0000000111111111\' DCNL >>> bits_str("bits_str", endian = "little") DCNL \'0100011010010110001011101100111011111010110011100010111001001110\''
'Creates a GRR VFS temp file. DCNL This function is analogous to CreateGRRTempFile but returns an open VFS handle DCNL to the newly created file. Arguments are the same as for CreateGRRTempFile: DCNL Args: DCNL directory: string representing absolute directory where file should be DCNL written. If None, use \'tmp\' under the directory we\'re running DCNL from. DCNL filename: The name of the file to use. Note that setting both filename and DCNL directory name is not allowed. DCNL lifetime: time in seconds before we should delete this tempfile. DCNL mode: The mode to open the file. DCNL suffix: optional suffix to use for the temp file DCNL Returns: DCNL An open file handle to the new file and the corresponding pathspec.'
'return new_figure_manager, draw_if_interactive and show for pylab'
'Display the course\'s about page. DCNL Assumes the course_id is in a valid format.'
'Check if the given IP address is a private address DCNL .. versionadded:: 2014.7.0 DCNL .. versionchanged:: 2015.8.0 DCNL IPv6 support DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' network.is_private 10.0.0.3'
'Compute Hessenberg form of a matrix. DCNL The Hessenberg decomposition is:: DCNL A = Q H Q^H DCNL where `Q` is unitary/orthogonal and `H` has only zero elements below DCNL the first sub-diagonal. DCNL Parameters DCNL a : (M, M) array_like DCNL Matrix to bring into Hessenberg form. DCNL calc_q : bool, optional DCNL Whether to compute the transformation matrix.  Default is False. DCNL overwrite_a : bool, optional DCNL Whether to overwrite `a`; may improve performance. DCNL Default is False. DCNL check_finite : bool, optional DCNL Whether to check that the input matrix contains only finite numbers. DCNL Disabling may give a performance gain, but may result in problems DCNL (crashes, non-termination) if the inputs do contain infinities or NaNs. DCNL Returns DCNL H : (M, M) ndarray DCNL Hessenberg form of `a`. DCNL Q : (M, M) ndarray DCNL Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``. DCNL Only returned if ``calc_q=True``.'
'Raises ValueError is is_cuda_ndarray(obj) evaluates False'
'Get rotationMatrix.'
'colapse outer dimensions into one and preserve inner dimension DCNL this allows for easy cpu convolution in numpy DCNL Arguments: DCNL dim (tuple): dimensions list in a tuple DCNL pad (int):  how many pixel paddings'
'Adds \'prefix\' to the beginning of selected lines in \'text\'. DCNL If \'predicate\' is provided, \'prefix\' will only be added to the lines DCNL where \'predicate(line)\' is True. If \'predicate\' is not provided, DCNL it will default to adding \'prefix\' to all non-empty lines that do not DCNL consist solely of whitespace characters.'
'Return the first value DCNL Parameters DCNL obj: dict-like object'
'Returns whether or not a URL represents an SSH connection.'
'(INTERNAL) New instance from ctypes.'
'Convert between lengths (to be interpreted as lengths in the focal plane) DCNL and angular units with a specified ``platescale``. DCNL Parameters DCNL platescale : `~astropy.units.Quantity` DCNL The pixel scale either in units of distance/pixel or distance/angle.'
'View that checks the hash in a password reset link and presents a DCNL form for entering a new password.'
'Return a list of random items for structure \'t\' with format DCNL \'fmtchar\'.'
'Format track for output to MPD client. DCNL :param track: the track DCNL :type track: :class:`mopidy.models.Track` or :class:`mopidy.models.TlTrack` DCNL :param position: track\'s position in playlist DCNL :type position: integer DCNL :param stream_title: the current streams title DCNL :type position: string DCNL :rtype: list of two-tuples'
'Read and return settings from a file.'
'Finds fist parent of element of the given type DCNL @param object element: etree element DCNL @param string the tag parent to search for DCNL @return object element: the found parent or None when not found'
'Write commit logs. DCNL :param repo: Path to repository DCNL :param paths: Optional set of specific paths to print entries for DCNL :param outstream: Stream to write log output to DCNL :param reverse: Reverse order in which entries are printed DCNL :param name_status: Print name status DCNL :param max_entries: Optional maximum number of entries to display'
'Get the handle for a particular rule DCNL This function accepts a rule in a standard nftables command format, DCNL starting with the chain. Trying to force users to adapt to a new DCNL method of creating rules would be irritating at best, and we DCNL already have a parser that can handle it. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' nftables.get_rule_handle filter input \ DCNL rule=\'input tcp dport 22 log accept\' DCNL IPv6: DCNL salt \'*\' nftables.get_rule_handle filter input \ DCNL rule=\'input tcp dport 22 log accept\' \ DCNL family=ipv6'
'Takes a list of domain objects and returns a corresponding list DCNL of their names.'
'Checks if file exists. Returns {} if something fails.'
'helper method for present.  ensure that cloudwatch_alarms are set'
'Stream n JSON messages'
'Returns a list of partial velocities with respect to the provided DCNL generalized speeds in the given reference frame for each of the supplied DCNL velocity vectors. DCNL The output is a list of lists. The outer list has a number of elements DCNL equal to the number of supplied velocity vectors. The inner lists are, for DCNL each velocity vector, the partial derivatives of that velocity vector with DCNL respect to the generalized speeds supplied. DCNL Parameters DCNL vel_vecs : iterable DCNL An iterable of velocity vectors (angular or linear). DCNL gen_speeds : iterable DCNL An iterable of generalized speeds. DCNL frame : ReferenceFrame DCNL The reference frame that the partial derivatives are going to be taken DCNL in. DCNL Examples DCNL >>> from sympy.physics.vector import Point, ReferenceFrame DCNL >>> from sympy.physics.vector import dynamicsymbols DCNL >>> from sympy.physics.vector import partial_velocity DCNL >>> u = dynamicsymbols(\'u\') DCNL >>> N = ReferenceFrame(\'N\') DCNL >>> P = Point(\'P\') DCNL >>> P.set_vel(N, u * N.x) DCNL >>> vel_vecs = [P.vel(N)] DCNL >>> gen_speeds = [u] DCNL >>> partial_velocity(vel_vecs, gen_speeds, N) DCNL [[N.x]]'
'Return whether a string is in ascii.'
'Run a Python file, parse the docstrings of all the classes DCNL and functions it declares, and return them. DCNL Parameters DCNL filename : str DCNL Filename of the module to run. DCNL global_dict : dict, optional DCNL Globals dictionary to pass along to `execfile()`. DCNL Returns DCNL all_errors : list DCNL Each entry of the list is a tuple, of length 2 or 3, with DCNL format either DCNL (func_or_class_name, docstring_error_description) DCNL or DCNL (class_name, method_name, docstring_error_description)'
'Runs doctest for the importing module.'
'Get triangles for ico surface.'
'Returns the modification time of the most recently modified DCNL file provided DCNL :param list(str) files: names of files to check DCNL :return: most recent modification time amongst the fileset DCNL :rtype: datetime.datetime'
'Query remote object about info that it publishes. Returns identities and features lists.'
'Test if the sun is currently up based on the statemachine.'
'postfix_expression : postfix_expression LBRACKET expression RBRACKET'
'Returns a dict with OFICIAL availables plugins in NINJA-IDE web page'
'Returns True if we are allowed to introspect this field, False otherwise. DCNL (\'allowed\' means \'in core\'. Custom fields can declare they are introspectable DCNL by the default South rules by adding the attribute _south_introspects = True.)'
'Decorator for views that checks that the user passes the given test, DCNL redirecting to the log-in page if necessary. The test should be a callable DCNL that takes the user object and returns True if the user passes.'
'Single task view page'
'Decode the given PDF string DCNL @param string: A PDFString to decode DCNL @return A tuple (status,statusContent), where statusContent is the decoded PDF string in case status = 0 or an error in case status = -1'
'Recursively check all source files in C{paths}. DCNL @param paths: A list of paths to Python source files and directories DCNL containing Python source files. DCNL @param reporter: A L{Reporter} where all of the warnings and errors DCNL will be reported to. DCNL @return: The number of warnings found.'
'Setup the vlc platform.'
'Test hsl to rgb color function'
'Accept a drop event and return a list of paths that can be read from DCNL and represent files with extensions.'
'a damped exponential'
'Control function using Numpy.'
'Reads a range of the document_file containing some number of entry_class DCNL instances. We deliminate the entry_class entries by the keyword on their DCNL first line (entry_keyword). When finished the document is left at the DCNL end_position. DCNL Either an end_position or section_end_keywords must be provided. DCNL :param file document_file: file with network status document content DCNL :param bool validate: checks the validity of the document\'s contents if DCNL **True**, skips these checks otherwise DCNL :param class entry_class: class to construct instance for DCNL :param str entry_keyword: first keyword for the entry instances DCNL :param int start_position: start of the section, default is the current position DCNL :param int end_position: end of the section DCNL :param tuple section_end_keywords: keyword(s) that deliminate the end of the DCNL section if no end_position was provided DCNL :param tuple extra_args: extra arguments for the entry_class (after the DCNL content and validate flag) DCNL :returns: iterator over entry_class instances DCNL :raises: DCNL * **ValueError** if the contents is malformed and validate is **True** DCNL * **IOError** if the file can\'t be read'
'Get the list of available instance sizes (flavors).'
'Helper function to construct a string from a base and the policy. DCNL Used to encode the policy index into either a file name or a DCNL directory name by various modules. DCNL :param base: the base string DCNL :param policy_or_index: StoragePolicy instance, or an index DCNL (string or int), if None the legacy DCNL storage Policy-0 is assumed. DCNL :returns: base name with policy index added DCNL :raises: PolicyError if no policy exists with the given policy_index'
'Upgrade outdated, unpinned brews. DCNL refresh DCNL Fetch the newest version of Homebrew and all formulae from GitHub before installing. DCNL Returns a dictionary containing the changes: DCNL .. code-block:: python DCNL {\'<package>\':  {\'old\': \'<old-version>\', DCNL \'new\': \'<new-version>\'}} DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.upgrade'
''
'Gets a mode descriptor for the given mode.'
'Saves and restart the plugin, returning True if no errors occurred'
'Return the det(``M``) by using permutations to select factors. DCNL For size larger than 8 the number of permutations becomes prohibitively DCNL large, or if there are no symbols in the matrix, it is better to use the DCNL standard determinant routines, e.g. `M.det()`. DCNL See Also DCNL det_minor DCNL det_quick'
'config_validator() -> [ (config_variable, error_message) ] DCNL Called by core check_config() view.'
'return a blank string if the match group is None'
'Returns the HMAC-SHA1 of \'value\', using a key generated from key_salt and a DCNL secret (which defaults to settings.SECRET_KEY). DCNL A different key_salt should be passed in for every application of HMAC.'
'Return etc_hosts information from osquery DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' osquery.etc_hosts'
'Raise a skipException if a config exists and is True DCNL :param str group: The first arg, the option group to check DCNL :param str name: The second arg, the option name to check DCNL :param str msg: Optional third arg, the skip msg to use if a skip is raised DCNL :raises testtools.TestCase.skipException: If the specified config option DCNL exists and evaluates to True'
'Compute Lasso path with coordinate descent DCNL The Lasso optimization function varies for mono and multi-outputs. DCNL For mono-output tasks it is:: DCNL (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 DCNL For multi-output tasks it is:: DCNL (1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21 DCNL Where:: DCNL ||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2} DCNL i.e. the sum of norm of each row. DCNL Read more in the :ref:`User Guide <lasso>`. DCNL Parameters DCNL X : {array-like, sparse matrix}, shape (n_samples, n_features) DCNL Training data. Pass directly as Fortran-contiguous data to avoid DCNL unnecessary memory duplication. If ``y`` is mono-output then ``X`` DCNL can be sparse. DCNL y : ndarray, shape (n_samples,), or (n_samples, n_outputs) DCNL Target values DCNL eps : float, optional DCNL Length of the path. ``eps=1e-3`` means that DCNL ``alpha_min / alpha_max = 1e-3`` DCNL n_alphas : int, optional DCNL Number of alphas along the regularization path DCNL alphas : ndarray, optional DCNL List of alphas where to compute the models. DCNL If ``None`` alphas are set automatically DCNL precompute : True | False | \'auto\' | array-like DCNL Whether to use a precomputed Gram matrix to speed up DCNL calculations. If set to ``\'auto\'`` let us decide. The Gram DCNL matrix can also be passed as argument. DCNL Xy : array-like, optional DCNL Xy = np.dot(X.T, y) that can be precomputed. It is useful DCNL only when the Gram matrix is precomputed. DCNL copy_X : boolean, optional, default True DCNL If ``True``, X will be copied; else, it may be overwritten. DCNL coef_init : array, shape (n_features, ) | None DCNL The initial values of the coefficients. DCNL verbose : bool or integer DCNL Amount of verbosity. DCNL params : kwargs DCNL keyword arguments passed to the coordinate descent solver. DCNL positive : bool, default False DCNL If set to True, forces coefficients to be positive. DCNL return_n_iter : bool DCNL whether to return the number of iterations or not. DCNL Returns DCNL alphas : array, shape (n_alphas,) DCNL The alphas along the path where models are computed. DCNL coefs : array, shape (n_features, n_alphas) or             (n_outputs, n_features, n_alphas) DCNL Coefficients along the path. DCNL dual_gaps : array, shape (n_alphas,) DCNL The dual gaps at the end of the optimization for each alpha. DCNL n_iters : array-like, shape (n_alphas,) DCNL The number of iterations taken by the coordinate descent optimizer to DCNL reach the specified tolerance for each alpha. DCNL Notes DCNL See examples/linear_model/plot_lasso_coordinate_descent_path.py DCNL for an example. DCNL To avoid unnecessary memory duplication the X argument of the fit method DCNL should be directly passed as a Fortran-contiguous numpy array. DCNL Note that in certain cases, the Lars solver may be significantly DCNL faster to implement this functionality. In particular, linear DCNL interpolation can be used to retrieve model coefficients between the DCNL values output by lars_path DCNL Examples DCNL Comparing lasso_path and lars_path with interpolation: DCNL >>> X = np.array([[1, 2, 3.1], [2.3, 5.4, 4.3]]).T DCNL >>> y = np.array([1, 2, 3.1]) DCNL >>> # Use lasso_path to compute a coefficient path DCNL >>> _, coef_path, _ = lasso_path(X, y, alphas=[5., 1., .5]) DCNL >>> print(coef_path) DCNL [[ 0.          0.          0.46874778] DCNL [ 0.2159048   0.4425765   0.23689075]] DCNL >>> # Now use lars_path and 1D linear interpolation to compute the DCNL >>> # same path DCNL >>> from sklearn.linear_model import lars_path DCNL >>> alphas, active, coef_path_lars = lars_path(X, y, method=\'lasso\') DCNL >>> from scipy import interpolate DCNL >>> coef_path_continuous = interpolate.interp1d(alphas[::-1], DCNL ...                                             coef_path_lars[:, ::-1]) DCNL >>> print(coef_path_continuous([5., 1., .5])) DCNL [[ 0.          0.          0.46915237] DCNL [ 0.2159048   0.4425765   0.23668876]] DCNL See also DCNL lars_path DCNL Lasso DCNL LassoLars DCNL LassoCV DCNL LassoLarsCV DCNL sklearn.decomposition.sparse_encode'
'Set of service client modules available in Tempest and plugins DCNL Set of stable service clients from Tempest and service clients exposed DCNL by plugins. This set of available modules can be used for automatic DCNL configuration. DCNL :raise PluginRegistrationException: if a plugin exposes a service_version DCNL already defined by Tempest or another plugin. DCNL Examples: DCNL >>> from tempest import config DCNL >>> params = {} DCNL >>> for service_version in available_modules(): DCNL >>>     service = service_version.split(\'.\')[0] DCNL >>>     params[service] = config.service_client_config(service) DCNL >>> service_clients = ServiceClients(creds, identity_uri, DCNL >>>                                  client_parameters=params)'
'Shorthand for \'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)\'. DCNL (In fact, it uses sys.exc_info() to retrieve the same information DCNL in a thread-safe way.)'
'Lomb-Scargle Periodogram DCNL This implements a fast chi-squared periodogram using the algorithm DCNL outlined in [4]_. The result is identical to the standard Lomb-Scargle DCNL periodogram. The advantage of this algorithm is the DCNL ability to compute multiterm periodograms relatively quickly. DCNL Parameters DCNL t, y, dy : array_like  (NOT astropy.Quantities) DCNL times, values, and errors of the data points. These should be DCNL broadcastable to the same shape. DCNL f0, df, Nf : (float, float, int) DCNL parameters describing the frequency grid, f = f0 + df * arange(Nf). DCNL normalization : string (optional, default=\'standard\') DCNL Normalization to use for the periodogram. DCNL Options are \'standard\', \'model\', \'log\', or \'psd\'. DCNL fit_mean : bool (optional, default=True) DCNL if True, include a constant offset as part of the model at each DCNL frequency. This can lead to more accurate results, especially in the DCNL case of incomplete phase coverage. DCNL center_data : bool (optional, default=True) DCNL if True, pre-center the data by subtracting the weighted mean DCNL of the input data. This is especially important if ``fit_mean = False`` DCNL nterms : int (optional, default=1) DCNL Number of Fourier terms in the fit DCNL Returns DCNL power : array_like DCNL Lomb-Scargle power associated with each frequency. DCNL Units of the result depend on the normalization. DCNL References DCNL .. [1] M. Zechmeister and M. Kurster, A&A 496, 577-584 (2009) DCNL .. [2] W. Press et al, Numerical Recipies in C (2002) DCNL .. [3] Scargle, J.D. ApJ 263:835-853 (1982) DCNL .. [4] Palmer, J. ApJ 695:496-502 (2009)'
'Github issue #1258: interpolation was failing with numpy DCNL 1.7 pre-release.'
'Create a new Instance record in the database. DCNL context - request context object DCNL values - dict containing column values.'
'Validate an update document.'
'The input is a list of [token, tag, chunk]-items. DCNL The output is a list of [token, tag, chunk, preposition]-items. DCNL PP-chunks followed by NP-chunks make up a PNP-chunk.'
'Evaluates an image expression. DCNL :param expression: A string containing a Python-style expression. DCNL :param options: Values to add to the evaluation context.  You DCNL can either use a dictionary, or one or more keyword DCNL arguments. DCNL :return: The evaluated expression. This is usually an image object, but can DCNL also be an integer, a floating point value, or a pixel tuple, DCNL depending on the expression.'
'evaluate and return the expression of the op on a and b DCNL Parameters DCNL op :    the actual operand DCNL op_str: the string version of the op DCNL a :     left operand DCNL b :     right operand DCNL raise_on_error : pass the error to the higher level if indicated DCNL (default is False), otherwise evaluate the op with and DCNL return the results DCNL use_numexpr : whether to try to use numexpr (default True)'
'Create a gzip compressed archive of ``source_path`` at ``archive_path``. DCNL An empty archive file will be created if the source file does not exist. DCNL This gives the diagnostic archive a consistent set of files which can DCNL easily be tested.'
'Compute the boolean mask X == missing_values.'
'Benchmark the speed of different relu implementations. DCNL Both fprop and grad are tested.'
'Load parser result store from specified scenario package. DCNL Args: DCNL package_dirpath: str; Path to scenario package directory. DCNL open_for_write: bool; Open store for writing. DCNL Returns: DCNL shelve.DbfilenameShelf; Looks and acts like a dict'
'Utility function: ``7`` => ``\'H\'``, ``27`` => ``\'AB\'``'
'Convert b to a boolean or raise'
'Return a copy of response that supports seekable response interface. DCNL Accepts responses from both mechanize and urllib2 handlers. DCNL Copes with both oridinary response instances and HTTPError instances (which DCNL can\'t be simply wrapped due to the requirement of preserving the exception DCNL base class).'
'**DEPRECATED** DCNL Load a module, given information returned by find_module(). DCNL The module name must include the full package name, if any.'
'Runs the tests.'
'Invite users to new ccx'
'Convert a numeric socket type value to an IntEnum member. DCNL If it\'s not a known member, return the numeric value itself.'
'Determine if a token appears to be PKI-based. DCNL thx to ayoung for sorting this out. DCNL base64 decoded hex representation of MII is 3082:: DCNL In [3]: binascii.hexlify(base64.b64decode(\'MII=\')) DCNL Out[3]: \'3082\' DCNL re: http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf DCNL pg4:  For tags from 0 to 30 the first octet is the identfier DCNL pg10: Hex 30 means sequence, followed by the length of that sequence. DCNL pg5:  Second octet is the length octet DCNL first bit indicates short or long form, next 7 bits encode the DCNL number of subsequent octets that make up the content length octets DCNL as an unsigned binary int DCNL 82 = 10000010 (first bit indicates long form) DCNL 0000010 = 2 octets of content length DCNL so read the next 2 octets to get the length of the content. DCNL In the case of a very large content length there could be a requirement to DCNL have more than 2 octets to designate the content length, therefore DCNL requiring us to check for MIM, MIQ, etc. DCNL In [4]: base64.b64encode(binascii.a2b_hex(\'3083\')) DCNL Out[4]: \'MIM=\' DCNL In [5]: base64.b64encode(binascii.a2b_hex(\'3084\')) DCNL Out[5]: \'MIQ=\' DCNL Checking for MI would become invalid at 16 octets of content length DCNL 10010000 = 90 DCNL In [6]: base64.b64encode(binascii.a2b_hex(\'3090\')) DCNL Out[6]: \'MJA=\' DCNL Checking for just M is insufficient DCNL But we will only check for MII: DCNL Max length of the content using 2 octets is 3FFF or 16383. DCNL It\'s not practical to support a token of this length or greater in http DCNL therefore, we will check for MII only and ignore the case of larger tokens'
'Read an IDL .sav file. DCNL Parameters DCNL file_name : str DCNL Name of the IDL save file. DCNL idict : dict, optional DCNL Dictionary in which to insert .sav file variables. DCNL python_dict : bool, optional DCNL By default, the object return is not a Python dictionary, but a DCNL case-insensitive dictionary with item, attribute, and call access DCNL to variables. To get a standard Python dictionary, set this option DCNL to True. DCNL uncompressed_file_name : str, optional DCNL This option only has an effect for .sav files written with the DCNL /compress option. If a file name is specified, compressed .sav DCNL files are uncompressed to this file. Otherwise, readsav will use DCNL the `tempfile` module to determine a temporary filename DCNL automatically, and will remove the temporary file upon successfully DCNL reading it in. DCNL verbose : bool, optional DCNL Whether to print out information about the save file, including DCNL the records read, and available variables. DCNL Returns DCNL idl_dict : AttrDict or dict DCNL If `python_dict` is set to False (default), this function returns a DCNL case-insensitive dictionary with item, attribute, and call access DCNL to variables. If `python_dict` is set to True, this function DCNL returns a Python dictionary with all variable names in lowercase. DCNL If `idict` was specified, then variables are written to the DCNL dictionary specified, and the updated dictionary is returned.'
'Bash has problems dealing with certain paths so we\'re surrounding all DCNL path outputs with quotes.'
'`add_redaction_filter` injects the redaction filter into all of the `logger` DCNL handlers. This must be called after all of the handlers have been added to DCNL `logger`, otherwise those handlers may expose unredacted strings.'
'Returns the cache key for this (model, instance) pair.'
'Encode a dict of values (either strings or file descriptors or DCNL :class:`FileStorage` objects.) into a multipart encoded string stored DCNL in a file descriptor.'
'Set up CUDA FFT resampling. DCNL Parameters DCNL n_jobs : int | str DCNL If n_jobs == \'cuda\', the function will attempt to set up for CUDA DCNL FFT resampling. DCNL W : array DCNL The filtering function to be used during resampling. DCNL If n_jobs=\'cuda\', this function will be shortened (since CUDA DCNL assumes FFTs of real signals are half the length of the signal) DCNL and turned into a gpuarray. DCNL new_len : int DCNL The size of the array following resampling. DCNL Returns DCNL n_jobs : int DCNL Sets n_jobs = 1 if n_jobs == \'cuda\' was passed in, otherwise DCNL original n_jobs is passed. DCNL cuda_dict : dict DCNL Dictionary with the following CUDA-related variables: DCNL use_cuda : bool DCNL Whether CUDA should be used. DCNL fft_plan : instance of FFTPlan DCNL FFT plan to use in calculating the FFT. DCNL ifft_plan : instance of FFTPlan DCNL FFT plan to use in calculating the IFFT. DCNL x_fft : instance of gpuarray DCNL Empty allocated GPU space for storing the result of the DCNL frequency-domain multiplication. DCNL x : instance of gpuarray DCNL Empty allocated GPU space for the data to resample. DCNL W : array | instance of gpuarray DCNL This will either be a gpuarray (if CUDA enabled) or np.ndarray. DCNL If CUDA is enabled, W will be modified appropriately for use DCNL with filter.fft_multiply(). DCNL Notes DCNL This function is designed to be used with fft_resample().'
'Generate batches of distorted versions of ImageNet images. DCNL Use this function as the inputs for training a network. DCNL Distorting images provides a useful technique for augmenting the data DCNL set during training in order to make the network invariant to aspects DCNL of the image that do not effect the label. DCNL Args: DCNL dataset: instance of Dataset class specifying the dataset. DCNL batch_size: integer, number of examples in batch DCNL num_preprocess_threads: integer, total number of preprocessing threads but DCNL None defaults to FLAGS.num_preprocess_threads. DCNL Returns: DCNL images: Images. 4D tensor of size [batch_size, FLAGS.image_size, DCNL FLAGS.image_size, 3]. DCNL labels: 1-D integer Tensor of [batch_size].'
'Let Vispy use the target OpenGL ES 2.0 implementation DCNL Also see ``vispy.use()``. DCNL Parameters DCNL target : str DCNL The target GL backend to use. DCNL Available backends: DCNL * gl2 - Use ES 2.0 subset of desktop (i.e. normal) OpenGL DCNL * gl+ - Use the desktop ES 2.0 subset plus all non-deprecated GL DCNL functions on your system (requires PyOpenGL) DCNL * es2 - Use the ES2 library (Angle/DirectX on Windows) DCNL * pyopengl2 - Use ES 2.0 subset of pyopengl (for fallback and testing) DCNL * dummy - Prevent usage of gloo.gl (for when rendering occurs elsewhere) DCNL You can use vispy\'s config option "gl_debug" to check for errors DCNL on each API call. Or, one can specify it as the target, e.g. "gl2 DCNL debug". (Debug does not apply to \'gl+\', since PyOpenGL has its own DCNL debug mechanism)'
'Generate kernel_arg_base_type metadata'
'Makes a request to the Telegram API. DCNL :param token: The bot\'s API token. (Created with @BotFather) DCNL :param method_name: Name of the API method to be called. (E.g. \'getUpdates\') DCNL :param method: HTTP method to be used. Defaults to \'get\'. DCNL :param params: Optional parameters. Should be a dictionary with key-value pairs. DCNL :param files: Optional files. DCNL :return: The result parsed to a JSON dictionary.'
'Parses from a string. DCNL :param str souce: The string to parse DCNL :returns: The parsed tree DCNL :rtype: list'
'Calculate a greyscale dilation, using either a structuring element, DCNL or a footprint corresponding to a flat structuring element. DCNL Grayscale dilation is a mathematical morphology operation. For the DCNL simple case of a full and flat structuring element, it can be viewed DCNL as a maximum filter over a sliding window. DCNL Parameters DCNL input : array_like DCNL Array over which the grayscale dilation is to be computed. DCNL size : tuple of ints DCNL Shape of a flat and full structuring element used for the grayscale DCNL dilation. 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 dilation. Non-zero values give the set of DCNL neighbors of the center over which the maximum is chosen. DCNL structure : array of ints, optional DCNL Structuring element used for the grayscale dilation. `structure` DCNL may be a non-flat structuring element. DCNL output : array, optional DCNL An array used for storing the ouput of the dilation 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_dilation : ndarray DCNL Grayscale dilation of `input`. DCNL See also DCNL binary_dilation, grey_erosion, grey_closing, grey_opening DCNL generate_binary_structure, ndimage.maximum_filter DCNL Notes DCNL The grayscale dilation of an image input by a structuring element s defined DCNL over a domain E is given by: DCNL (input+s)(x) = max {input(y) + s(x-y), for y in E} DCNL In particular, for structuring elements defined as DCNL s(y) = 0 for y in E, the grayscale dilation computes the maximum of the DCNL input image inside a sliding window defined by E. DCNL Grayscale dilation [1]_ is a *mathematical morphology* operation [2]_. DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Dilation_%28morphology%29 DCNL .. [2] http://en.wikipedia.org/wiki/Mathematical_morphology DCNL Examples DCNL >>> from scipy import ndimage DCNL >>> a = np.zeros((7,7), dtype=int) DCNL >>> a[2:5, 2:5] = 1 DCNL >>> a[4,4] = 2; a[2,3] = 3 DCNL >>> a DCNL array([[0, 0, 0, 0, 0, 0, 0], DCNL [0, 0, 0, 0, 0, 0, 0], DCNL [0, 0, 1, 3, 1, 0, 0], DCNL [0, 0, 1, 1, 1, 0, 0], DCNL [0, 0, 1, 1, 2, 0, 0], DCNL [0, 0, 0, 0, 0, 0, 0], DCNL [0, 0, 0, 0, 0, 0, 0]]) DCNL >>> ndimage.grey_dilation(a, size=(3,3)) DCNL array([[0, 0, 0, 0, 0, 0, 0], DCNL [0, 1, 3, 3, 3, 1, 0], DCNL [0, 1, 3, 3, 3, 1, 0], DCNL [0, 1, 3, 3, 3, 2, 0], DCNL [0, 1, 1, 2, 2, 2, 0], DCNL [0, 1, 1, 2, 2, 2, 0], DCNL [0, 0, 0, 0, 0, 0, 0]]) DCNL >>> ndimage.grey_dilation(a, footprint=np.ones((3,3))) DCNL array([[0, 0, 0, 0, 0, 0, 0], DCNL [0, 1, 3, 3, 3, 1, 0], DCNL [0, 1, 3, 3, 3, 1, 0], DCNL [0, 1, 3, 3, 3, 2, 0], DCNL [0, 1, 1, 2, 2, 2, 0], DCNL [0, 1, 1, 2, 2, 2, 0], DCNL [0, 0, 0, 0, 0, 0, 0]]) DCNL >>> s = ndimage.generate_binary_structure(2,1) DCNL >>> s DCNL array([[False,  True, False], DCNL [ True,  True,  True], DCNL [False,  True, False]], dtype=bool) DCNL >>> ndimage.grey_dilation(a, footprint=s) DCNL array([[0, 0, 0, 0, 0, 0, 0], DCNL [0, 0, 1, 3, 1, 0, 0], DCNL [0, 1, 3, 3, 3, 1, 0], DCNL [0, 1, 1, 3, 2, 1, 0], DCNL [0, 1, 1, 2, 2, 2, 0], DCNL [0, 0, 1, 1, 2, 0, 0], DCNL [0, 0, 0, 0, 0, 0, 0]]) DCNL >>> ndimage.grey_dilation(a, size=(3,3), structure=np.ones((3,3))) DCNL array([[1, 1, 1, 1, 1, 1, 1], DCNL [1, 2, 4, 4, 4, 2, 1], DCNL [1, 2, 4, 4, 4, 2, 1], DCNL [1, 2, 4, 4, 4, 3, 1], DCNL [1, 2, 2, 3, 3, 3, 1], DCNL [1, 2, 2, 3, 3, 3, 1], DCNL [1, 1, 1, 1, 1, 1, 1]])'
'Return a "fake" table, with foreign keys where needed.'
'Get port and port binding records for update within transaction.'
'- Always surround these binary operators with a single space on DCNL either side: assignment (=), augmented assignment (+=, -= etc.), DCNL comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not), DCNL Booleans (and, or, not). DCNL - Use spaces around arithmetic operators. DCNL Okay: i = i + 1 DCNL Okay: submitted += 1 DCNL Okay: x = x * 2 - 1 DCNL Okay: hypot2 = x * x + y * y DCNL Okay: c = (a + b) * (a - b) DCNL Okay: foo(bar, key=\'word\', *args, **kwargs) DCNL Okay: alpha[:-i] DCNL E225: i=i+1 DCNL E225: submitted +=1 DCNL E225: x = x /2 - 1 DCNL E225: z = x **y DCNL E226: c = (a+b) * (a-b) DCNL E226: hypot2 = x*x + y*y DCNL E227: c = a|b DCNL E228: msg = fmt%(errno, errmsg)'
'Assume LDEV status has changed as desired.'
'DiagonalGaussian.sample_from_epsilon doesn\'t crash'
'Convert a space-separated list of EDNS flag text values into a EDNS DCNL flags value. DCNL @rtype: int'
'Convert a date to a datetime for datastore storage. DCNL Args: DCNL value: A datetime.date object. DCNL Returns: DCNL A datetime object with time set to 0:00.'
'Find registrations with unexpected numbers of template keys or DCNL outdated templates.'
'Asserts the specified output has exactly n elements matching the DCNL path specified.'
'Test we warn when non-default port is used for Google Home.'
'Computes the area under the receiver-operater characteristic (AUC) DCNL This function computes the AUC error metric for binary classification. DCNL Parameters DCNL actual : list of binary numbers, numpy array DCNL The ground truth value DCNL posterior : same type as actual DCNL Defines a ranking on the binary numbers, from most likely to DCNL be positive to least likely to be positive. DCNL Returns DCNL score : double DCNL The mean squared error between actual and posterior'
'Add y groove'
'Gets the ChannelServiceStub instance from the API proxy stub map. DCNL Returns: DCNL The ChannelServiceStub instance as registered in the API stub map.'
'.. code-block:: gherkin DCNL Given the model elements with name and tags: DCNL | name | tags   | DCNL | S1   | @foo   | DCNL Then the tag expression select model elements with: DCNL | tag expression | selected?    | DCNL |  @foo          | S1, S3       | DCNL | -@foo          | S0, S2, S3   |'
'Check mapping file and extract list of valid barcodes, primers'
'Uploads a template only if it has changed, and if so, reload the DCNL related service.'
'Test that conftest files are detected only up to a ini file, unless DCNL an explicit --confcutdir option is given.'
'Tests whether a phone number is valid for a certain region. DCNL Note this doesn\'t verify the number is actually in use, which is DCNL impossible to tell by just looking at a number itself. If the country DCNL calling code is not the same as the country calling code for the region, DCNL this immediately exits with false. After this, the specific number pattern DCNL rules for the region are examined. This is useful for determining for DCNL example whether a particular number is valid for Canada, rather than just DCNL a valid NANPA number. DCNL Warning: In most cases, you want to use is_valid_number instead. For DCNL example, this method will mark numbers from British Crown dependencies DCNL such as the Isle of Man as invalid for the region "GB" (United Kingdom), DCNL since it has its own region code, "IM", which may be undesirable. DCNL Arguments: DCNL numobj -- The phone number object that we want to validate. DCNL region_code -- The region that we want to validate the phone number for. DCNL Returns a boolean that indicates whether the number is of a valid pattern.'
'Test when only one inputs have one broadcastable dimension'
'Determine whether the text seems to be valid lyrics.'
'Compute virtual evoked using interpolated fields in mag/grad channels. DCNL Parameters DCNL evoked : instance of mne.Evoked DCNL The evoked object. DCNL ch_type : str DCNL The destination channel type. It can be \'mag\' or \'grad\'. DCNL mode : str DCNL Either `\'accurate\'` or `\'fast\'`, determines the quality of the DCNL Legendre polynomial expansion used. `\'fast\'` should be sufficient DCNL for most applications. DCNL Returns DCNL evoked : instance of mne.Evoked DCNL The transformed evoked object containing only virtual channels.'
'Get the functions with the search string in the files.'
'Get the description of available titles. DCNL @param p_mi: the media player. DCNL @return: list containing description of available titles.'
'Return whether or not given value is a valid domain. DCNL If the value is valid domain name this function returns ``True``, otherwise DCNL :class:`~validators.utils.ValidationFailure`. DCNL Examples:: DCNL >>> domain(\'example.com\') DCNL True DCNL >>> domain(\'example.com/\') DCNL ValidationFailure(func=domain, ...) DCNL Supports IDN domains as well:: DCNL >>> domain(\'xn----gtbspbbmkef.xn--p1ai\') DCNL True DCNL .. versionadded:: 0.9 DCNL .. versionchanged:: 0.10 DCNL Added support for internationalized domain name (IDN) validation. DCNL :param value: domain string to validate'
'Course settings configuration DCNL GET DCNL html: get the page DCNL json: get the model DCNL PUT, POST DCNL json: update the Course\'s settings. The payload is a json rep of the DCNL metadata dicts.'
'Returns True if the MacOS X urllib fakes should be installed.'
'Utility function; generates UUIDs'
'Register event to function with a decorator'
'Show HaProxy frontends DCNL socket DCNL haproxy stats socket DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' haproxy.show_frontends'
'Copy a file, including finder info, resource fork, etc'
'Assert actual and desired arrays are within some SNR tolerance'
'Returns a set of all available widgets'
'Get WMT data into data_dir, create vocabularies and tokenize data. DCNL Args: DCNL data_dir: directory in which the data sets will be stored. DCNL en_vocabulary_size: size of the English vocabulary to create and use. DCNL fr_vocabulary_size: size of the French vocabulary to create and use. DCNL tokenizer: a function to use to tokenize each data sentence; DCNL if None, basic_tokenizer will be used. DCNL Returns: DCNL A tuple of 6 elements: DCNL (1) path to the token-ids for English training data-set, DCNL (2) path to the token-ids for French training data-set, DCNL (3) path to the token-ids for English development data-set, DCNL (4) path to the token-ids for French development data-set, DCNL (5) path to the English vocabulary file, DCNL (6) path to the French vocabulary file.'
'Remove unused images DCNL verbose : boolean (False) DCNL toggle verbose output DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' imgadm.vacuum [verbose=True]'
'Compares the content and mode of blobs found via two tree objects. DCNL :param repo: Path to repository DCNL :param old_tree: Id of old tree DCNL :param new_tree: Id of new tree DCNL :param outstream: Stream to write to'
'Test the methods of MarkovChain, as well as mc_compute_stationary, DCNL with P matrix and known solutions'
'Returns a list of words (alphanumeric character sequences) from the given string. DCNL Common punctuation marks are stripped from words.'
'Returns an error template. DCNL Template: ``invitations/invitation_error.html`` DCNL Context: DCNL error_message DCNL String containing the error message.'
'Returns the Type object for prog_id.'
'Resolves host name to IP address.'
'Returns the grade distribution for the problems in the `section` section in a format for the d3 code. DCNL `course_id` a string that is the course\'s ID. DCNL `section` an int that is a zero-based index into the course\'s list of sections. DCNL Navigates to the section specified to find all the problems associated with that section and then finds the grade DCNL distribution for those problems. Finally returns an object formated the way the d3_stacked_bar_graph.js expects its DCNL data object to be in. DCNL If this is requested multiple times quickly for the same course, it is better to call DCNL get_d3_problem_grade_distrib and pick out the sections of interest. DCNL Returns an array of dicts with the following keys (taken from d3_stacked_bar_graph.js\'s documentation) DCNL \'xValue\' - Corresponding value for the x-axis DCNL \'stackData\' - Array of objects with key, value pairs that represent a bar: DCNL \'color\' - Defines what "color" the bar will map to DCNL \'value\' - Maps to the height of the bar, along the y-axis DCNL \'tooltip\' - (Optional) Text to display on mouse hover'
'Options DCNL maxiter : int DCNL Maximum number of iterations to perform. DCNL xtol : float DCNL Relative error in solution `xopt` acceptable for convergence.'
'Award the specific badge to the user if they\'ve earned it.'
'.. versionchanged:: 2015.8.12,2016.3.3,2016.11.0 DCNL On minions running systemd>=205, `systemd-run(1)`_ is now used to DCNL isolate commands which modify installed packages from the DCNL ``salt-minion`` daemon\'s control group. This is done to keep systemd DCNL from killing any yum/dnf commands spawned by Salt when the DCNL ``salt-minion`` service is restarted. (see ``KillMode`` in the DCNL `systemd.kill(5)`_ manpage for more information). If desired, usage of DCNL `systemd-run(1)`_ can be suppressed by setting a :mod:`config option DCNL <salt.modules.config.get>` called ``systemd.scope``, with a value of DCNL ``False`` (no quotes). DCNL .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html DCNL .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html DCNL Package purges are not supported by yum, this function is identical to DCNL :mod:`pkg.remove <salt.modules.yumpkg.remove>`. DCNL name DCNL The name of the package to be purged DCNL Multiple Package Options: DCNL pkgs DCNL A list of packages to delete. Must be passed as a python list. The DCNL ``name`` parameter will be ignored if this option is passed. DCNL .. versionadded:: 0.16.0 DCNL Returns a dict containing the changes. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.purge <package name> DCNL salt \'*\' pkg.purge <package1>,<package2>,<package3> DCNL salt \'*\' pkg.purge pkgs=\'["foo", "bar"]\''
'Provides the byte sequence for a collection of HTTP/2 frames representing DCNL the provided request. DCNL @param headers: The HTTP/2 headers to send. DCNL @type headers: L{list} of L{tuple} of L{bytes} DCNL @param data: The HTTP data to send. Each list entry will be sent in its own DCNL frame. DCNL @type data: L{list} of L{bytes} DCNL @param frameFactory: The L{FrameFactory} that will be used to construct the DCNL frames. DCNL @type frameFactory: L{FrameFactory} DCNL @param streamID: The ID of the stream on which to send the request. DCNL @type streamID: L{int}'
'Return the request fingerprint. DCNL The request fingerprint is a hash that uniquely identifies the resource the DCNL request points to. For example, take the following two urls: DCNL http://www.example.com/query?id=111&cat=222 DCNL http://www.example.com/query?cat=222&id=111 DCNL Even though those are two different URLs both point to the same resource DCNL and are equivalent (ie. they should return the same response). DCNL Another example are cookies used to store session ids. Suppose the DCNL following page is only accesible to authenticated users: DCNL http://www.example.com/members/offers.html DCNL Lot of sites use a cookie to store the session id, which adds a random DCNL component to the HTTP Request and thus should be ignored when calculating DCNL the fingerprint. DCNL For this reason, request headers are ignored by default when calculating DCNL the fingeprint. If you want to include specific headers use the DCNL include_headers argument, which is a list of Request headers to include.'
'warn() should print \'Warning\' plus given text'
'Put terminal into a raw mode.'
'Does basic ModelAdmin option validation. Calls custom validation DCNL classmethod in the end if it is provided in cls. The signature of the DCNL custom validation classmethod should be: def validate(cls, model).'
'Foos!'
'Replaces all occurances of Posix slashes (/) in provided DCNL filepath with NT ones (\) DCNL >>> posixToNtSlashes(\'C:/Windows\') DCNL \'C:\\Windows\''
'yield lines with hexdump of data'
'Internal function used by mask_dssp_dict (PRIVATE). DCNL Return a DSSP dictionary that maps (chainid, resid) to an amino acid, DCNL secondary structure symbol, solvent accessibility value, and hydrogen bond DCNL information (relative dssp indices and hydrogen bond energies) from an open DCNL DSSP file object. :: DCNL Parameters DCNL handle : file DCNL the open DSSP output file handle'
'Return original expr if rule returns None'
'Return display of results from a full-text lucene search of data libraries.'
'Sequentially read the file containing the edge list data for the DCNL graphs in the atlas and generate the graphs one at a time. DCNL This function reads the file given in :data:`.ATLAS_FILE`.'
'Return the localized representation of an integer or decimal. DCNL For None, print nothing.'
'Split an expression into Expr and noncommutative QExpr parts.'
'strings.column_width'
'Decorator to time a function or method. DCNL Parameters DCNL num_tries : int, optional DCNL Number of calls to make. Timer will take the DCNL average run time. DCNL verbose : bool, optional DCNL Extra log information. DCNL Returns DCNL tt : float DCNL Average run time in seconds. DCNL result DCNL Output(s) from the function. DCNL Examples DCNL To add timer to time `numpy.log` for 100 times with DCNL verbose output:: DCNL import numpy as np DCNL from astropy.utils.timer import timefunc DCNL @timefunc(100) DCNL def timed_log(x): DCNL return np.log(x) DCNL To run the decorated function above: DCNL >>> t, y = timed_log(100) DCNL INFO: timed_log took 9.29832458496e-06 s on AVERAGE for 100 call(s). [...] DCNL >>> t DCNL 9.298324584960938e-06 DCNL >>> y DCNL 4.6051701859880918'
'Create a checked ``PMap`` field. DCNL :param key: The required type for the keys of the map. DCNL :param value: The required type for the values of the map. DCNL :param bool optional: If true, ``None`` can be used as a value for this DCNL field. DCNL :param invariant: Pass-through to ``field``. DCNL :param initial: An initial value for the field.  This will first be coerced DCNL using the field\'s factory.  If not given, the initial value is an empty DCNL map. DCNL :param factory: A factory used to convert input arguments to the stored DCNL value whenever it is set. Note that this will be composed with the DCNL constructor for the ``CheckedPMap`` class constructed for this field. DCNL :return: A ``field`` containing a ``CheckedPMap``.'
'Check if path is a single component of a path. DCNL Check that the path is safe to join too.'
'push a copy to the site'
'Send an email from the OSF. DCNL Example: :: DCNL from website import mails DCNL mails.send_email(\'foo@bar.com\', mails.TEST, name="Foo") DCNL :param str to_addr: The recipient\'s email address DCNL :param Mail mail: The mail object DCNL :param str mimetype: Either \'plain\' or \'html\' DCNL :param function callback: celery task to execute after send_mail completes DCNL :param **context: Context vars for the message template DCNL .. note: DCNL Uses celery if available'
'Turns a Django template into something that is understood by xgettext. It DCNL does so by translating the Django translation tags into standard gettext DCNL function invocations.'
'Process xmlElement by svgReader.'
'Record usage of multiple rate limits. DCNL If any of the of the rate limits expire during the processing of the DCNL function, the usage counts may be inaccurate and it is not defined DCNL which, if any, of the keys have been updated in the underlying cache. DCNL Arguments: DCNL prefix_slices: A list of (prefix, timeslice) DCNL Returns: DCNL A list of the usage counts in the same order as prefix_slices. DCNL Raises: DCNL RateLimitError if anything goes wrong. DCNL It is not defined which, if any, of the keys have been updated if this DCNL happens.'
'lx hash --sha1 file... DCNL lx hash --md5 file... DCNL lx hash --md4 file... DCNL lx hash --dcid file... DCNL lx hash --ed2k file... DCNL lx hash --info-hash xxx.torrent... DCNL lx hash --verify-sha1 file hash DCNL lx hash --verify-md5 file hash DCNL lx hash --verify-md4 file hash DCNL lx hash --verify-dcid file hash DCNL lx hash --verify-ed2k file ed2k://... DCNL lx hash --verify-bt file xxx.torrent'
'Dump the shell environment as HTML.'
'Decorator for parameterized test w.r.t. the product set of signed dtypes. DCNL Args: DCNL names(list of str): Argument names to which dtypes are passed. DCNL full(bool): If ``True``, then all combinations of dtypes DCNL will be tested. DCNL Otherwise, the subset of combinations will be tested DCNL (see description in :func:`cupy.testing.for_dtypes_combination`). DCNL .. seealso:: :func:`cupy.testing.for_dtypes_combination`'
'Decode a query string in x-www-form-urlencoded format into a sequence DCNL of two-element tuples. DCNL Unlike urlparse.parse_qsl(..., strict_parsing=True) urldecode will enforce DCNL correct formatting of the query string by validation. If validation fails DCNL a ValueError will be raised. urllib.parse_qsl will only raise errors if DCNL any of name-value pairs omits the equals sign.'
'Test cursor movements with Emacs key bindings.'
'Recurses over a nested structure to look for changes in Suds objects. DCNL Args: DCNL obj: A parameter for a SOAP request field which is to be inspected and DCNL will be packed for Suds if an xsi_type is specified, otherwise will be DCNL left unaltered. DCNL factory: The suds.client.Factory object which can create instances of the DCNL classes generated from the WSDL. DCNL parent: The parent object that contains the obj parameter to be inspected.'
'Push a byte onto the current block stack. DCNL @see: Aliases: s_char() DCNL @type  value:      Integer DCNL @param value:      Default integer value DCNL @type  endian:     Character DCNL @param endian:     (Optional, def=LITTLE_ENDIAN) Endianess of the bit field (LITTLE_ENDIAN: <, BIG_ENDIAN: >) DCNL @type  format:     String DCNL @param format:     (Optional, def=binary) Output format, "binary" or "ascii" DCNL @type  signed:     Boolean DCNL @param signed:     (Optional, def=False) Make size signed vs. unsigned (applicable only with format="ascii") DCNL @type  full_range: Boolean DCNL @param full_range: (Optional, def=False) If enabled the field mutates through *all* possible values. DCNL @type  fuzzable:   Boolean DCNL @param fuzzable:   (Optional, def=True) Enable/disable fuzzing of this primitive DCNL @type  name:       String DCNL @param name:       (Optional, def=None) Specifying a name gives you direct access to a primitive'
'This is called by the publish_collection_and_update_user_profiles DCNL function in collection_services.py. It publishes an collection and commits DCNL changes. DCNL It is the responsibility of the caller to check that the collection is DCNL valid prior to publication.'
'Get the hardware address on Windows by running ipconfig.exe.'
'Find all Twisted-style projects beneath a base directory. DCNL @param baseDirectory: A L{twisted.python.filepath.FilePath} to look inside. DCNL @return: A list of L{Project}.'
'Encrypt one block with aes DCNL @param {int[]} data          16-Byte state DCNL @param {int[]} expanded_key  176/208/240-Byte expanded key DCNL @returns {int[]}             16-Byte cipher'
'Breaks \'seq\' into a generator of lists with length \'size\'.'
'Tests the compatibility replacement for functools.wraps which supports DCNL argument preservation across all supported Python versions.'
'Manage the SNMP sysContact, sysLocation, and sysServices settings. DCNL :param str contact: The SNMP contact. DCNL :param str location: The SNMP location. DCNL :param str services: A list of selected services. DCNL Example of usage: DCNL .. code-block:: yaml DCNL snmp-agent-settings: DCNL win_snmp.agent_settings: DCNL - contact: Test Contact DCNL - location: Test Location DCNL - services: DCNL - Physical DCNL - Internet'
'Parse a gcode file and display the commands.'
'integer is at bin center'
'Transform list into a maxheap, in-place, in O(len(x)) time.'
'Generate the vertices for a third order Bezier curve. DCNL The vertices returned by this function can be passed to a LineVisual or DCNL ArrowVisual. DCNL Parameters DCNL p1 : array DCNL 2D coordinates of the start point DCNL p2 : array DCNL 2D coordinates of the first curve point DCNL p3 : array DCNL 2D coordinates of the second curve point DCNL p4 : array DCNL 2D coordinates of the end point DCNL Returns DCNL coords : list DCNL Vertices for the Bezier curve. DCNL See Also DCNL curve3_bezier DCNL Notes DCNL For more information about Bezier curves please refer to the `Wikipedia`_ DCNL page. DCNL .. _Wikipedia: https://en.wikipedia.org/wiki/B%C3%A9zier_curve'
'For a window of length M rolling over a buffer of length N, DCNL there are (N - M) + 1 legal windows. DCNL Example: DCNL If my array has N=4 rows, and I want windows of length M=2, there are DCNL 3 legal windows: data[0:2], data[1:3], and data[2:4].'
'Remove flavor access for project.'
'Omit part of a string if needed to make it fit in a maximum length.'
'Update a quota usage or raise if it does not exist.'
'Builds provider_location for volume or snapshot. DCNL :param system: VNX serial number DCNL :param lun_id: LUN ID in VNX DCNL :param lun_type: \'lun\' or \'smp\' DCNL :param base_lun_name: primary LUN name, DCNL it will be used when creating snap lun DCNL :param version: driver version'
'Send a notification.'
'Format a member ref for consumption outside of this module.'
'return a random value with probability p, else 0'
'helper function to take a ADMX policy string for registry.pol file data and DCNL update existing string or append the string to the data'
'Mark a test as emitting a warning on a specific dialect. DCNL With no arguments, squelches all SAWarning failures.  Or pass one or more DCNL strings; these will be matched to the root of the warning description by DCNL warnings.filterwarnings().'
'Return a configured univention uldap object'
'Return the html tags in the \'s\' string containing the \'cont\' DCNL string; if toClosure is True, everything between the opening DCNL tag and the closing tag is returned.'
'A CherryPy tool which hooks at before_handler to perform DCNL HTTP Digest Access Authentication, as specified in :rfc:`2617`. DCNL If the request has an \'authorization\' header with a \'Digest\' scheme, DCNL this tool authenticates the credentials supplied in that header. DCNL If the request has no \'authorization\' header, or if it does but the DCNL scheme is not "Digest", or if authentication fails, the tool sends DCNL a 401 response with a \'WWW-Authenticate\' Digest header. DCNL realm DCNL A string containing the authentication realm. DCNL get_ha1 DCNL A callable which looks up a username in a credentials store DCNL and returns the HA1 string, which is defined in the RFC to be DCNL MD5(username : realm : password).  The function\'s signature is: DCNL ``get_ha1(realm, username)`` DCNL where username is obtained from the request\'s \'authorization\' header. DCNL If username is not found in the credentials store, get_ha1() returns DCNL None. DCNL key DCNL A secret string known only to the server, used in the synthesis DCNL of nonces.'
'Create a (possibly compressed) tar file from all the files under DCNL \'base_dir\'.  \'compress\' must be "gzip" (the default), "compress", DCNL "bzip2", or None.  Both "tar" and the compression utility named by DCNL \'compress\' must be on the default program search path, so this is DCNL probably Unix-specific.  The output tar file will be named \'base_dir\' + DCNL ".tar", possibly plus the appropriate compression extension (".gz", DCNL ".bz2" or ".Z").  Return the output filename.'
'1-day Rate-Of-Change (ROC) of a Triple Smooth EMA'
'Uses the lock directory method.  This is good because `mkdir` is DCNL atomic at the system call level, so it\'s thread-safe.'
'Returns all the options for the given select.'
'Wrap multiple paragraphs to fit a specified width. DCNL This is equivalent to textwrap.wrap, but with support for multiple DCNL paragraphs, as separated by empty lines. DCNL Returns DCNL list of complete paragraphs, wrapped to fill `ncols` columns.'
':type path: str'
'Prepare the text of the html file. DCNL Returns the body text of a document'
'This will translate a block of text with parameters. DCNL Usage:: DCNL {% blocktrans with bar=foo|filter boo=baz|filter %} DCNL This is {{ bar }} and {{ boo }}. DCNL {% endblocktrans %} DCNL Additionally, this supports pluralization:: DCNL {% blocktrans count count=var|length %} DCNL There is {{ count }} object. DCNL {% plural %} DCNL There are {{ count }} objects. DCNL {% endblocktrans %} DCNL This is much like ngettext, only in template syntax. DCNL The "var as value" legacy format is still supported:: DCNL {% blocktrans with foo|filter as bar and baz|filter as boo %} DCNL {% blocktrans count var|length as count %} DCNL Contextual translations are supported:: DCNL {% blocktrans with bar=foo|filter context "greeting" %} DCNL This is {{ bar }}. DCNL {% endblocktrans %} DCNL This is equivalent to calling pgettext/npgettext instead of DCNL (u)gettext/(u)ngettext.'
'Set the entry text.'
'Perform Levene test for equal variances. DCNL The Levene test tests the null hypothesis that all input samples DCNL are from populations with equal variances.  Levene\'s test is an DCNL alternative to Bartlett\'s test `bartlett` in the case where DCNL there are significant deviations from normality. DCNL Parameters DCNL sample1, sample2, ... : array_like DCNL The sample data, possibly with different lengths DCNL center : {\'mean\', \'median\', \'trimmed\'}, optional DCNL Which function of the data to use in the test.  The default DCNL is \'median\'. DCNL proportiontocut : float, optional DCNL When `center` is \'trimmed\', this gives the proportion of data points DCNL to cut from each end. (See `scipy.stats.trim_mean`.) DCNL Default is 0.05. DCNL Returns DCNL statistic : float DCNL The test statistic. DCNL pvalue : float DCNL The p-value for the test. DCNL Notes DCNL Three variations of Levene\'s test are possible.  The possibilities DCNL and their recommended usages are: DCNL * \'median\' : Recommended for skewed (non-normal) distributions> DCNL * \'mean\' : Recommended for symmetric, moderate-tailed distributions. DCNL * \'trimmed\' : Recommended for heavy-tailed distributions. DCNL References DCNL .. [1]  http://www.itl.nist.gov/div898/handbook/eda/section3/eda35a.htm DCNL .. [2]   Levene, H. (1960). In Contributions to Probability and Statistics: DCNL Essays in Honor of Harold Hotelling, I. Olkin et al. eds., DCNL Stanford University Press, pp. 278-292. DCNL .. [3]  Brown, M. B. and Forsythe, A. B. (1974), Journal of the American DCNL Statistical Association, 69, 364-367'
'Create extra fill loops.'
'Converts a phone number with letters into its numeric equivalent.'
'unary_expression : unary_operator cast_expression'
'Make sure the directories exist for `filename`.'
'ARGUMENTS: DCNL features:     numpy matrices of features [numOfSamples x numOfDimensions] DCNL labels:       list of sample labels DCNL nExp:         number of cross-validation experiments DCNL MethodName:   "svm" or "randomforest" DCNL Params:       list of classifier params to be evaluated DCNL RETURNS: DCNL bestParam:   the value of the input parameter that optimizes the selected performance measure'
'Get record information for the given zone_id on the given profile DCNL :param zone_id: Zone to export. DCNL :type  zone_id: ``str`` DCNL :param record_id: Record to delete. DCNL :type  record_id: ``str`` DCNL :param profile: The profile key DCNL :type  profile: ``str`` DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion libcloud_dns.get_record google.com www profile1'
'Displays whether \'restart on power failure\' is on or off if supported DCNL :return: A string value representing the "restart on power failure" settings DCNL :rtype: string DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' power.get_restart_power_failure'
'Plot error bars at each data point.'
'Computes the fraction of host queue entries matching the given filter data DCNL that are complete.'
'Encrypts a stream of bytes from in_stream to out_stream using mode.'
'Build a string representation of a query, without metadata types'
'Return the parent of a directory.'
'Returns a dictionary of all the MetaSources DCNL E.g., {\'itunes\': Itunes} with isinstance(Itunes, MetaSource) true'
'Get a list of resources for an alias. There could be more than one alias DCNL in a resource_dict.'
'Called on shell initialization.  Adds useful stuff to the namespace.'
'Download the data from Yann\'s website, unless it\'s already here.'
'Set the "range" metadata on a load instruction. DCNL Note the interval is in the form [lower_bound, upper_bound).'
'Fetches the logs from the debug log file for a given StarCluster run by PID'
'Function for setting figure layout. Shared with raw and epoch plots.'
'Test file downloading over http.'
'Implements hadoop fs -ls.'
'Add the given number of space characters to the beginning every DCNL non-blank line in `s`, and return the result.'
'we do a simple two pass fitting to a pair of bi-variate polynomials DCNL return the function to map vector'
'Test IIR filter stability check.'
'Convert an arbitrary string to a standard \'extra\' name DCNL Any runs of non-alphanumeric characters are replaced with a single \'_\', DCNL and the result is always lowercased.'
'Read settings from a text.'
'Returns versions of components used by salt DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' test.versions_report'
'Function to run the external calibrate.exe program. DCNL Returns a new instance of _stEgControl (probably not \'necessary\').'
'Runs a Mantel correlogram analysis on all pairs of distance matrices. DCNL Returns a string suitable for writing out to a file containing the results DCNL of the test, a list of correlogram filepath names, and a list of matplotlib DCNL Figure objects representing each correlogram. DCNL The correlogram filepaths can have an extension string appended to the end DCNL of them and then be used to save each of the correlogram Figures to a file. DCNL Each correlogram filepath will be a combination of the two distance matrix DCNL filepaths that were used to create it. DCNL WARNING: Only symmetric, hollow distance matrices may be used as input. DCNL Asymmetric distance matrices, such as those obtained by the UniFrac Gain DCNL metric (i.e. beta_diversity.py -m unifrac_g), should not be used as input. DCNL Arguments: DCNL fps - list of filepaths of the distance matrices DCNL distmats - list of tuples containing dm labels and dm data (i.e. the DCNL output of parse_distmat) DCNL num_perms - the number of permutations to use to calculate the DCNL p-value(s) DCNL comment - comment string to add to the beginning of the results string DCNL alpha - the alpha value to use to determine significance in the DCNL correlogram plots DCNL sample_id_map - dict mapping sample IDs (i.e. what is expected by DCNL make_compatible_distance_matrices) DCNL variable_size_distance_classes - create distance classes that vary in DCNL size (i.e. width) but have the same number of distances in each DCNL class'
'Launch DCNL port_eth unspecified: "DPID MAC" DCNL port_eth enabled: Port MAC DCNL port_eth specified: Use that'
'Validate the beacon configuration'
'Plot rectangular data as a color-encoded matrix. DCNL This function tries to infer a good colormap to use from the data, but DCNL this is not guaranteed to work, so take care to make sure the kind of DCNL colormap (sequential or diverging) and its limits are appropriate. DCNL This is an Axes-level function and will draw the heatmap into the DCNL currently-active Axes if none is provided to the ``ax`` argument.  Part of DCNL this Axes space will be taken and used to plot a colormap, unless ``cbar`` DCNL is False or a separate Axes is provided to ``cbar_ax``. DCNL Parameters DCNL data : rectangular dataset DCNL 2D dataset that can be coerced into an ndarray. If a Pandas DataFrame DCNL is provided, the index/column information will be used to label the DCNL columns and rows. DCNL vmin, vmax : floats, optional DCNL Values to anchor the colormap, otherwise they are inferred from the DCNL data and other keyword arguments. When a diverging dataset is inferred, DCNL one of these values may be ignored. DCNL cmap : matplotlib colormap name or object, optional DCNL The mapping from data values to color space. If not provided, this DCNL will be either a cubehelix map (if the function infers a sequential DCNL dataset) or ``RdBu_r`` (if the function infers a diverging dataset). DCNL center : float, optional DCNL The value at which to center the colormap. Passing this value implies DCNL use of a diverging colormap. DCNL robust : bool, optional DCNL If True and ``vmin`` or ``vmax`` are absent, the colormap range is DCNL computed with robust quantiles instead of the extreme values. DCNL annot : bool or rectangular dataset, optional DCNL If True, write the data value in each cell. If an array-like with the DCNL same shape as ``data``, then use this to annotate the heatmap instead DCNL of the raw data. DCNL fmt : string, optional DCNL String formatting code to use when adding annotations. DCNL annot_kws : dict of key, value mappings, optional DCNL Keyword arguments for ``ax.text`` when ``annot`` is True. DCNL linewidths : float, optional DCNL Width of the lines that will divide each cell. DCNL linecolor : color, optional DCNL Color of the lines that will divide each cell. DCNL cbar : boolean, optional DCNL Whether to draw a colorbar. DCNL cbar_kws : dict of key, value mappings, optional DCNL Keyword arguments for `fig.colorbar`. DCNL cbar_ax : matplotlib Axes, optional DCNL Axes in which to draw the colorbar, otherwise take space from the DCNL main Axes. DCNL square : boolean, optional DCNL If True, set the Axes aspect to "equal" so each cell will be DCNL square-shaped. DCNL ax : matplotlib Axes, optional DCNL Axes in which to draw the plot, otherwise use the currently-active DCNL Axes. DCNL xticklabels : list-like, int, or bool, optional DCNL If True, plot the column names of the dataframe. If False, don\'t plot DCNL the column names. If list-like, plot these alternate labels as the DCNL xticklabels. If an integer, use the column names but plot only every DCNL n label. DCNL yticklabels : list-like, int, or bool, optional DCNL If True, plot the row names of the dataframe. If False, don\'t plot DCNL the row names. If list-like, plot these alternate labels as the DCNL yticklabels. If an integer, use the index names but plot only every DCNL n label. DCNL mask : boolean array or DataFrame, optional DCNL If passed, data will not be shown in cells where ``mask`` is True. DCNL Cells with missing values are automatically masked. DCNL kwargs : other keyword arguments DCNL All other keyword arguments are passed to ``ax.pcolormesh``. DCNL Returns DCNL ax : matplotlib Axes DCNL Axes object with the heatmap. DCNL Examples DCNL Plot a heatmap for a numpy array: DCNL .. plot:: DCNL :context: close-figs DCNL >>> import numpy as np; np.random.seed(0) DCNL >>> import seaborn as sns; sns.set() DCNL >>> uniform_data = np.random.rand(10, 12) DCNL >>> ax = sns.heatmap(uniform_data) DCNL Change the limits of the colormap: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(uniform_data, vmin=0, vmax=1) DCNL Plot a heatmap for data centered on 0: DCNL .. plot:: DCNL :context: close-figs DCNL >>> normal_data = np.random.randn(10, 12) DCNL >>> ax = sns.heatmap(normal_data) DCNL Plot a dataframe with meaningful row and column labels: DCNL .. plot:: DCNL :context: close-figs DCNL >>> flights = sns.load_dataset("flights") DCNL >>> flights = flights.pivot("month", "year", "passengers") DCNL >>> ax = sns.heatmap(flights) DCNL Annotate each cell with the numeric value using integer formatting: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(flights, annot=True, fmt="d") DCNL Add lines between each cell: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(flights, linewidths=.5) DCNL Use a different colormap: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(flights, cmap="YlGnBu") DCNL Center the colormap at a specific value: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(flights, center=flights.loc["January", 1955]) DCNL Plot every other column label and don\'t plot row labels: DCNL .. plot:: DCNL :context: close-figs DCNL >>> data = np.random.randn(50, 20) DCNL >>> ax = sns.heatmap(data, xticklabels=2, yticklabels=False) DCNL Don\'t draw a colorbar: DCNL .. plot:: DCNL :context: close-figs DCNL >>> ax = sns.heatmap(flights, cbar=False) DCNL Use different axes for the colorbar: DCNL .. plot:: DCNL :context: close-figs DCNL >>> grid_kws = {"height_ratios": (.9, .05), "hspace": .3} DCNL >>> f, (ax, cbar_ax) = plt.subplots(2, gridspec_kw=grid_kws) DCNL >>> ax = sns.heatmap(flights, ax=ax, DCNL ...                  cbar_ax=cbar_ax, DCNL ...                  cbar_kws={"orientation": "horizontal"}) DCNL Use a mask to plot only part of a matrix DCNL .. plot:: DCNL :context: close-figs DCNL >>> corr = np.corrcoef(np.random.randn(10, 200)) DCNL >>> mask = np.zeros_like(corr) DCNL >>> mask[np.triu_indices_from(mask)] = True DCNL >>> with sns.axes_style("white"): DCNL ...     ax = sns.heatmap(corr, mask=mask, vmax=.3, square=True)'
'A memoize decorator for class properties.'
'Decorator for tests that make calls to SVD and intermittently fail.'
'Checks the results of all tasks.'
'Look up the value for an option.'
'Establish and return a pair of network sockets connected to each other.'
'Run deployment tasks.'
'Split statements at semicolons ignoring the ones inside quotes and comments. DCNL The comment symbols that come inside quotes should be ignored.'
'Changes an XML data stream on the fly to specify a new encoding DCNL data is a raw sequence of bytes (not Unicode) that is presumed to be in %encoding already DCNL encoding is a string recognized by encodings.aliases'
'Initial callback - invoked after the server sends us its greet message.'
'same as Q, but returns a list, not a generator'
'Return the textual representation of logging level \'level\'. DCNL If the level is one of the predefined levels (CRITICAL, ERROR, WARNING, DCNL INFO, DEBUG) then you get the corresponding string. If you have DCNL associated levels with names using addLevelName then the name you have DCNL associated with \'level\' is returned. DCNL If a numeric value corresponding to one of the defined levels is passed DCNL in, the corresponding string representation is returned. DCNL Otherwise, the string "Level %s" % level is returned.'
'Calls the Salt module "probes" to delete probes from the device.'
'view used to dissociate an openid from an account'
'Checks if task is complete, puts the result to out_queue.'
'Remove specified package. Accepts full or partial FMRI. DCNL In case of multiple match, the command fails and won\'t modify the OS. DCNL name DCNL The name of the package to be deleted. DCNL Multiple Package Options: DCNL pkgs DCNL A list of packages to delete. Must be passed as a python list. The DCNL ``name`` parameter will be ignored if this option is passed. DCNL Returns a list containing the removed packages. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pkg.remove <package name> DCNL salt \'*\' pkg.remove tcsh DCNL salt \'*\' pkg.remove pkg://solaris/shell/tcsh DCNL salt \'*\' pkg.remove pkgs=\'["foo", "bar"]\''
'Creates new, empty test databases.'
'Builds customer encryption key headers DCNL :type key: bytes DCNL :param key: 32 byte key to build request key and hash. DCNL :type source: bool DCNL :param source: If true, return headers for the "source" blob; otherwise, DCNL return headers for the "destination" blob. DCNL :rtype: dict DCNL :returns: dict of HTTP headers being sent in request.'
'Unpickle app.'
'Returns whether the given course is mobile_available for the given user. DCNL Checks: DCNL mobile_available flag on the course DCNL Beta User and staff access overrides the mobile_available flag DCNL Arguments: DCNL descriptor (CourseDescriptor|CourseOverview): course or overview of course in question'
'Send packets at layer 3 and return only the first answer DCNL nofilter: put 1 to avoid use of BPF filters DCNL retry:    if positive, how many times to resend unanswered packets DCNL if negative, how many times to retry when no more packets are answered DCNL timeout:  how much time to wait after the last packet has been sent DCNL verbose:  set verbosity level DCNL multi:    whether to accept multiple answers for the same stimulus DCNL filter:   provide a BPF filter DCNL iface:    listen answers only on the given interface'
'Clears cluster\'s internal caches.  Returns DCNL something that can be given back to restore_caches.'
'Returns a boolean of whether the value\'s length is the argument'
'Returns the search modules DCNL :param dict opts: The Salt options dictionary DCNL :param returners: Undocumented DCNL :param whitelist: Undocumented'
'Encode a string as base64 using the "modern" Python interface. DCNL Among other possible differences, the "modern" encoder does not include DCNL newline (\'\n\') characters in the encoded output. DCNL .. versionadded:: 2016.3.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' hashutil.base64_b64encode \'get salted\''
'Return an iterator over the (key, value) pairs of a dictionary.'
'Encodes incoming str/unicode using `encoding`. If DCNL incoming is not specified, text is expected to DCNL be encoded with current python\'s default encoding. DCNL (`sys.getdefaultencoding`) DCNL :param incoming: Text\'s current encoding DCNL :param encoding: Expected encoding for text (Default UTF-8) DCNL :param errors: Errors handling policy. See here for valid DCNL values http://docs.python.org/2/library/codecs.html DCNL :returns: text or a bytestring `encoding` encoded DCNL representation of it. DCNL :raises TypeError: If text is not an isntance of basestring'
'Return a hex string hash for a storage object (or string containing DCNL \'full.path.ClassName\' referring to a storage object).'
'get_debug_values should return [] when debugger is off'
'Does option have the default value? DCNL If the default value of option is not known, False is returned. DCNL :param str option: configuration variable being considered DCNL :param value: value of the configuration variable named option DCNL :returns: True if option has the default value, otherwise, False DCNL :rtype: bool'
'Enter a star rating given the id of the container DCNL :param context: behave context DCNL :param id: id of the container element'
'Obtains a connection to a docker API (socket or URL) based on config.get DCNL mechanism (pillar -> grains) DCNL By default it will use the base docker-py defaults which DCNL at the time of writing are using the local socket and DCNL the 1.4 API DCNL Set those keys in your configuration tree somehow: DCNL - docker.url: URL to the docker service DCNL - docker.version: API version to use (default: "auto")'
'Multiplies each element of a triplet by 255 DCNL Each coordinate of the color tuple is rounded to the nearest float and DCNL then is turned into an integer. If a number is of the form x.5, then DCNL if x is odd, the number rounds up to (x+1). Otherwise, it rounds down DCNL to just x. This is the way rounding works in Python 3 and in current DCNL statistical analysis to avoid rounding bias DCNL :param (list) rgb_components: grabs the three R, G and B values to be DCNL returned as computed in the function'
'exprlist : expression'
'relational_expression : relational_expression GE shift_expression'
'Tries a series of functions and prints their results. DCNL `context` is a dictionary mapping names to values; DCNL the value will only be tried if it\'s callable. DCNL For example, you might have a file `test/stuff.py` DCNL with a series of functions testing various things in it. DCNL At the bottom, have a line: DCNL if __name__ == "__main__": tryall(globals()) DCNL Then you can run `python test/stuff.py` and get the results of DCNL all the tests.'
'Get the profile directory.'
'Compute nt zeros of the Kelvin function ber\'(x). DCNL References DCNL .. [1] Zhang, Shanjie and Jin, Jianming. "Computation of Special DCNL Functions", John Wiley and Sons, 1996. DCNL http://jin.ece.illinois.edu/specfunc.html'
'Returns a string with the article + the word.'
'Returns a nagios-appropriate string and return code obtained by DCNL parsing the desired file on disk. The file on disk should be of format DCNL %s|%s % (timestamp, nagios_string) DCNL This file is created by various nagios checking cron jobs such as DCNL check-rabbitmq-queues and check-rabbitmq-consumers'
'Tests `max_revision()` gets the latest revision.'
'Return an HttpResponse with the data json-serialized and the right content DCNL type header.'
'calculate expected value of function by Monte Carlo integration DCNL Parameters DCNL dist : distribution instance DCNL needs to have rvs defined as a method for drawing random numbers DCNL func : callable DCNL function for which expectation is calculated, this function needs to DCNL be vectorized, integration is over axis=0 DCNL size : int DCNL number of random samples to use in the Monte Carlo integration, DCNL Notes DCNL this doesn\'t batch DCNL Returns DCNL expected value : ndarray DCNL return of function func integrated over axis=0 by MonteCarlo, this will DCNL have the same shape as the return of func without axis=0 DCNL Examples DCNL integrate probability that both observations are negative DCNL >>> mvn = mve.MVNormal([0,0],2.) DCNL >>> mve.expect_mc(mvn, lambda x: (x<np.array([0,0])).all(-1), size=100000) DCNL 0.25306000000000001 DCNL get tail probabilities of marginal distribution (should be 0.1) DCNL >>> c = stats.norm.isf(0.05, scale=np.sqrt(2.)) DCNL >>> expect_mc(mvn, lambda x: (np.abs(x)>np.array([c, c])), size=100000) DCNL array([ 0.09969,  0.0986 ]) DCNL or calling the method DCNL >>> mvn.expect_mc(lambda x: (np.abs(x)>np.array([c, c])), size=100000) DCNL array([ 0.09937,  0.10075])'
'Replace the Tk root menu by something that is more appropriate for DCNL IDLE with an Aqua Tk.'
'Call func(*args, **kw) with a timeout of second seconds.'
'Adds ops for a recurrent neural network layer. DCNL This function calls an actual implementation of a recurrent neural network DCNL based on `cell_type`. DCNL There are three modes depending on the value of `direction`: DCNL forward: Adds a forward RNN. DCNL backward: Adds a backward RNN. DCNL bidirectional: Adds both forward and backward RNNs and creates a DCNL bidirectional RNN. DCNL Args: DCNL inp: A 3-D tensor of shape [`batch_size`, `max_length`, `feature_dim`]. DCNL length: A 1-D tensor of shape [`batch_size`] and type int64. Each element DCNL represents the length of the corresponding sequence in `inp`. DCNL cell_type: Cell type of RNN. Currently can only be "lstm". DCNL direction: One of "forward", "backward", "bidirectional". DCNL name: Name of the op. DCNL *args: Other arguments to the layer. DCNL **kwargs: Keyword arugments to the layer. DCNL Returns: DCNL A 3-D tensor of shape [`batch_size`, `max_length`, `num_nodes`].'
'Creates a random alphanumeric string of specified length.'
'Create a SchemeNode from an `Element` instance.'
'Takes in a string and an email alias mapping and replaces all DCNL instances of the aliases in the string with their real email.'
'Return dict of element counts, in the order they were first seen'
'Execute a ``machinectl pull-dkr`` to download a docker image and add it to DCNL /var/lib/machines as a new container. DCNL .. note:: DCNL **Requires systemd >= 219** DCNL url DCNL URL from which to download the container DCNL name DCNL Name for the new container DCNL index DCNL URL of the Docker index server from which to pull (must be an DCNL ``http://`` or ``https://`` URL). DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt myminion nspawn.pull_dkr centos/centos6 cent6 index=https://get.docker.com DCNL salt myminion nspawn.pull_docker centos/centos6 cent6 index=https://get.docker.com'
'Determine if we should wait for the managed cloud automation before DCNL running. Either \'False\' (default) or \'True\'.'
'Fail unless an exception of class exception_class and with message that DCNL matches expected_regexp is thrown by callable when invoked with arguments DCNL args and keyword arguments kwargs. DCNL Name of this function adheres to Python 3.2+ reference, but should work in DCNL all versions down to 2.6. DCNL Notes DCNL .. versionadded:: 1.8.0'
'Remove files from filesystem DCNL :param processPath: path to process DCNL :param notwantedFiles: files we do not want DCNL :param result: Processor results DCNL :param force: Boolean, force deletion, defaults to false'
'Shortcut for confirmation prompts that can be ignored by passing DCNL ``--yes`` as parameter. DCNL This is equivalent to decorating a function with :func:`option` with DCNL the following parameters:: DCNL def callback(ctx, param, value): DCNL if not value: DCNL ctx.abort() DCNL @click.command() DCNL @click.option(\'--yes\', is_flag=True, callback=callback, DCNL expose_value=False, prompt=\'Do you want to continue?\') DCNL def dropdb(): DCNL pass'
'List of currently scheduled ETA/countdown tasks.'
'Test routine for a layer with a single input tensor DCNL and single output tensor.'
'Fires post processing hooks for a group.'
'Returns True if the given AS number is Two or Four Octet.'
'Adapted from http://code.activestate.com/recipes/576847/ DCNL :codeauthor: Vishal Sapre DCNL :license: MIT DCNL A foolishly simple look-up method of getting binary string from an integer DCNL This happens to be faster than all other ways!!!'
'Parse target dbms and set some attributes into the configuration singleton.'
'Create access key id for a user. DCNL .. versionadded:: 2015.8.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_iam.create_access_key myuser'
'restart a system call interrupted by EINTR'
'return a valid color arg'
'Return a list of all applicable test modules.'
'Get a list of all the users of this storage path.'
'Convert anything to bytes'
'Check whether the specified table exists in the current schema. DCNL This method cannot be executed in offline mode.'
'Prepare our list of parsing plugins and default parsers.'
'Parse one entry in a mailcap file and return a dictionary. DCNL The viewing command is stored as the value with the key "view", DCNL and the rest of the fields produce key-value pairs in the dict.'
'scalar version of qsturng'
'Delete a blob from Blobstore. DCNL Args: DCNL blob_key: A blob key.  This may be a str, unicode or BlobKey instance. DCNL **options: Options for create_rpc().'
'True Range'
'Check if number is a valid year'
'Execute a single state orchestration routine DCNL .. versionadded:: 2015.5.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-run state.orchestrate_high \'{ DCNL stage_one: DCNL {salt.state: [{tgt: "db*"}, {sls: postgres_setup}]}, DCNL stage_two: DCNL {salt.state: [{tgt: "web*"}, {sls: apache_setup}, { DCNL require: [{salt: stage_one}],'
'Recursively flatten tuple, list and set in a list.'
'We reorganized our categories: DCNL https://bugzilla.mozilla.org/show_bug.cgi?id=854499 DCNL Usage:: DCNL python -B manage.py runscript migrations.575-reorganize-cats'
'Loads and returns a class definition provided a dotted path DCNL specification the last part of the dotted path is the class name DCNL and there is at least one module name preceding the class name. DCNL Notes: DCNL You will need to ensure that the module you are trying to load DCNL exists in the Python path. DCNL Examples: DCNL - module.name.ClassName    # Provided module.name is in the Python path. DCNL - module.ClassName         # Provided module is in the Python path. DCNL What won\'t work: DCNL - ClassName DCNL - modle.name.ClassName     # Typo in module name. DCNL - module.name.ClasNam      # Typo in classname.'
'Passes through the projected Files/Dirs for link resolution.'
'sets up dummy convolutional forward pass and uses its grad as deconv DCNL currently only tested/working with same padding'
':type cmd: collections.Iterable[str] DCNL :type capture: bool DCNL :type env: dict[str, str] | None DCNL :type data: str | None DCNL :type cwd: str | None DCNL :type explain: bool DCNL :type stdin: file | None DCNL :type stdout: file | None DCNL :rtype: str | None, str | None'
'Get the text lines from the fileName in the alterations directories.'
'Checks to see if a file is locked. Performs three checks DCNL 1. Checks if the file even exists DCNL 2. Attempts to open the file for reading. This will determine if the file has a write lock. DCNL Write locks occur when the file is being edited or copied to, e.g. a file copy destination DCNL 3. If the readLockCheck parameter is True, attempts to rename the file. If this fails the DCNL file is open by some other process for reading. The file can be read, but not written to DCNL or deleted. DCNL :param file: the file being checked DCNL :param writeLockCheck: when true will check if the file is locked for writing (prevents move operations)'
':return UUID: A node- and boot-specific globally unique id.'
'Changes into new_branch_dir and builds the docs using sphinx in the DCNL BUILDENV virtualenv'
'Attempt to topologically order steps and attach to workflow. If this DCNL fails - the workflow contains cycles so it mark it as such.'
'Checks an exception for given keywords and raises a new ``ActionError`` DCNL with the desired message if the keywords are found. This allows selective DCNL control over API error messages.'
'Fix the global_ids after reordering in _render_toc().'
'It should extract the name of the scenario'
'Decorator for concrete volume driver implementations.'
'Some functions, such as C{os.path.join}, operate on string arguments which DCNL may be bytes or text, and wish to return a value of the same type.  In DCNL those cases you may wish to have a string constant (in the case of DCNL C{os.path.join}, that constant would be C{os.path.sep}) involved in the DCNL parsing or processing, that must be of a matching type in order to use DCNL string operations on it.  L{_matchingString} will take a constant string DCNL (either L{bytes} or L{unicode}) and convert it to the same type as the DCNL input string.  C{constantString} should contain only characters from ASCII; DCNL to ensure this, it will be encoded or decoded regardless. DCNL @param constantString: A string literal used in processing. DCNL @type constantString: L{unicode} or L{bytes} DCNL @param inputString: A byte string or text string provided by the user. DCNL @type inputString: L{unicode} or L{bytes} DCNL @return: C{constantString} converted into the same type as C{inputString} DCNL @rtype: the type of C{inputString}'
'Create a (possibly compressed) tar file from all the files under DCNL \'base_dir\'. DCNL \'compress\' must be "gzip" (the default), "compress", "bzip2", or None. DCNL (compress will be deprecated in Python 3.2) DCNL \'owner\' and \'group\' can be used to define an owner and a group for the DCNL archive that is being built. If not provided, the current owner and group DCNL will be used. DCNL The output tar file will be named \'base_dir\' +  ".tar", possibly plus DCNL the appropriate compression extension (".gz", ".bz2" or ".Z"). DCNL Returns the output filename.'
'An implementation of :meth:`select.select` that blocks only the current greenlet. DCNL Note: *xlist* is ignored.'
'Quote non-ascii characters'
'Grade students and generate certificates.'
'Serves the frontend single-page apps.'
'Build a list of all images files and labels in the data set. DCNL Args: DCNL data_dir: string, path to the root directory of images. DCNL Assumes that the ImageNet data set resides in JPEG files located in DCNL the following directory structure. DCNL data_dir/n01440764/ILSVRC2012_val_00000293.JPEG DCNL data_dir/n01440764/ILSVRC2012_val_00000543.JPEG DCNL where \'n01440764\' is the unique synset label associated with these images. DCNL labels_file: string, path to the labels file. DCNL The list of valid labels are held in this file. Assumes that the file DCNL contains entries as such: DCNL n01440764 DCNL n01443537 DCNL n01484850 DCNL where each line corresponds to a label expressed as a synset. We map DCNL each synset contained in the file to an integer (based on the alphabetical DCNL ordering) starting with the integer 1 corresponding to the synset DCNL contained in the first line. DCNL The reason we start the integer labels at 1 is to reserve label 0 as an DCNL unused background class. DCNL Returns: DCNL filenames: list of strings; each string is a path to an image file. DCNL synsets: list of strings; each string is a unique WordNet ID. DCNL labels: list of integer; each integer identifies the ground truth.'
'Returns a list of sets of media type strings, ordered by precedence. DCNL Precedence is determined by how specific a media type is: DCNL 3. \'type/subtype; param=val\' DCNL 2. \'type/subtype\' DCNL 1. \'type/*\' DCNL 0. \'*/*\''
'Test Filter Label 1'
'Collect and run tests, returning success or failure. DCNL The arguments to `run()` are the same as to `main()`: DCNL * module: All tests are in this module (default: None) DCNL * defaultTest: Tests to load (default: \'.\') DCNL * argv: Command line arguments (default: None; sys.argv is read) DCNL * testRunner: Test runner instance (default: None) DCNL * testLoader: Test loader instance (default: None) DCNL * env: Environment; ignored if config is provided (default: None; DCNL os.environ is read) DCNL * config: :class:`nose.config.Config` instance (default: None) DCNL * suite: Suite or list of tests to run (default: None). Passing a DCNL suite or lists of tests will bypass all test discovery and DCNL loading. *ALSO NOTE* that if you pass a unittest.TestSuite DCNL instance as the suite, context fixtures at the class, module and DCNL package level will not be used, and many plugin hooks will not DCNL be called. If you want normal nose behavior, either pass a list DCNL of tests, or a fully-configured :class:`nose.suite.ContextSuite`. DCNL * plugins: List of plugins to use; ignored if config is provided DCNL (default: load plugins with DefaultPluginManager) DCNL * addplugins: List of **extra** plugins to use. Pass a list of plugin DCNL instances in this argument to make custom plugins available while DCNL still using the DefaultPluginManager. DCNL With the exception that the ``exit`` argument is always set DCNL to False.'
'Asserts text1 and text2 have the same lines, ignoring differences in DCNL line endings between platforms'
'Main program, when run as a script: produce grammar pickle files. DCNL Calls load_grammar for each argument, a path to a grammar text file.'
'Spawn a process and return its output as a deferred returning a string. DCNL @param executable: The file name to run and get the output of - the DCNL full path should be used. DCNL @param args: the command line arguments to pass to the process; a DCNL sequence of strings. The first string should *NOT* be the DCNL executable\'s name. DCNL @param env: the environment variables to pass to the processs; a DCNL dictionary of strings. DCNL @param path: the path to run the subprocess in - defaults to the DCNL current directory. DCNL @param reactor: the reactor to use - defaults to the default reactor DCNL @param errortoo: If true, include stderr in the result.  If false, if DCNL stderr is received the returned L{Deferred} will errback with an DCNL L{IOError} instance with a C{processEnded} attribute.  The DCNL C{processEnded} attribute refers to a L{Deferred} which fires when the DCNL executed process ends.'
'Does `exp` contain a `Reduced` node.'
'Generate a SQL WHERE clause for job status filtering, and return it in DCNL a dict of keyword args to pass to query.extra().  No more than one of DCNL the parameters should be passed as True. DCNL * not_yet_run: all HQEs are Queued DCNL * finished: all HQEs are complete DCNL * running: everything else'
'Context manager to ensure sys.modules has certain white-listed modules, DCNL most especially latextools_plugins. This exposes some of the modules in DCNL LaTeXTools to plugins. It is intended primarily to expose library-esque DCNL functionality, such as the getTeXRoot module, but can be configured by DCNL the user as-needed.'
'other_user is not a friend if he\'s not in user["friends"]; DCNL that is, if he\'s not_the_same as all the people in user["friends"]'
'Splodge a gcode linear move file.'
'Ansible Main module.'
'Compute the leading coefficient of a multivariate polynomial DCNL `f \in K[x_0, \ldots, x_{k-2}, y] \cong K[y][x_0, \ldots, x_{k-2}]`. DCNL Parameters DCNL f : PolyElement DCNL polynomial in `K[x_0, \ldots, x_{k-2}, y]` DCNL Returns DCNL lcf : PolyElement DCNL polynomial in `K[y]`, leading coefficient of `f` DCNL Examples DCNL >>> from sympy.polys.modulargcd import _LC DCNL >>> from sympy.polys import ring, ZZ DCNL >>> R, x, y = ring("x, y", ZZ) DCNL >>> f = x**2*y**2 + x**2*y - 1 DCNL >>> _LC(f) DCNL y**2 + y DCNL >>> R, x, y, z = ring("x, y, z", ZZ) DCNL >>> f = x**2*y**2 + x**2*y - 1 DCNL >>> _LC(f) DCNL 1 DCNL >>> f = x*y*z - y**2*z**2 DCNL >>> _LC(f) DCNL z'
'Initialize plugin variables and Pelican settings'
'Top level function for bringing down Cassandra. DCNL Returns: DCNL True on success, False otherwise.'
'Annotates the tokens with lemmata for plural nouns and conjugated verbs, DCNL where each token is a [word, part-of-speech] list.'
'Test with non symmetric input'
'Return true if the given class node is subclass of DCNL exceptions.Exception.'
'given a fn and and environment the builds a keyword argument list DCNL for fn'
'Determines whether parameter is a Python Proxy, i.e., it has a Java DCNL internal class with an `implements` member. DCNL :param parameter: the object to check. DCNL :rtype: True if the parameter is a Python Proxy'
'>>> interpret_size(10) DCNL 10 DCNL >>> interpret_size(\'10\') DCNL 10 DCNL >>> interpret_size(\'10b\') DCNL 10 DCNL >>> interpret_size(\'10k\') DCNL 10240 DCNL >>> interpret_size(\'10K\') DCNL 10240 DCNL >>> interpret_size(\'10kb\') DCNL 10240 DCNL >>> interpret_size(\'10kB\') DCNL 10240 DCNL >>> interpret_size(\'a10\') DCNL Traceback (most recent call last): DCNL ValueError DCNL >>> interpret_size(\'10a\') DCNL Traceback (most recent call last): DCNL KeyError: \'A\''
'The main entry point'
'Generate node degree-degree pairs for edges in G. DCNL Parameters DCNL G: NetworkX graph DCNL x: string (\'in\',\'out\') DCNL The degree type for source node (directed graphs only). DCNL y: string (\'in\',\'out\') DCNL The degree type for target node (directed graphs only). DCNL weight: string or None, optional (default=None) DCNL The edge attribute that holds the numerical value used DCNL as a weight.  If None, then each edge has weight 1. DCNL The degree is the sum of the edge weights adjacent to the node. DCNL nodes: list or iterable (optional) DCNL Use only edges that are adjacency to specified nodes. DCNL The default is all nodes. DCNL Returns DCNL (x,y): 2-tuple DCNL Generates 2-tuple of (degree,degree) values. DCNL Examples DCNL >>> G = nx.DiGraph() DCNL >>> G.add_edge(1,2) DCNL >>> list(nx.node_degree_xy(G,x=\'out\',y=\'in\')) DCNL [(1, 1)] DCNL >>> list(nx.node_degree_xy(G,x=\'in\',y=\'out\')) DCNL [(0, 0)] DCNL Notes DCNL For undirected graphs each edge is produced twice, once for each edge DCNL representation (u,v) and (v,u), with the exception of self-loop edges DCNL which only appear once.'
'Add switched from the main Qwikswitch component.'
'Returns prefix for asset directory depending whether dev or prod. DCNL It is used as a prefix in urls for images, css and script files.'
'Used as decorator to simplify datamodel registration. DCNL Returns the object being decorated so that chaining is possible.'
'Return the install meta-data for a linked package in a prefix, or None DCNL if the package is not linked in the prefix.'
'Convert columns back to the larger String(43) defined in version 149.'
'Replace `0(px, em, %, etc)` with `0`.'
'Returns file in an svn transaction. DCNL Helper function for hook scripts in the svn commit mission. DCNL This function may be mocked in the tests.'
'Maps report plugin names to report objects. DCNL Args: DCNL name: The name of a plugin class. Also the name field of DCNL ApiGetReportArgs and ApiReportDescriptor. DCNL Returns: DCNL Report plugin object of class corresponding to the given name.'
'Save the load to the specified jid DCNL minions argument is to provide a pre-computed list of matched minions for DCNL the job, for cases when this function can\'t compute that list itself (such DCNL as for salt-ssh)'
'Retrieve and return the Catalog Integration Service User Object DCNL if the passed user is None or anonymous'
'Given sequences `X` and `Y` of ndarrays, initialize the tableau and DCNL basis arrays in place for the "geometric" imitation game as defined DCNL in McLennan and Tourky (2006), to be passed to `lemke_howson_tbl`. DCNL Parameters DCNL X, Y : ndarray(float) DCNL Arrays of the same shape (m, n). DCNL tableaux : tuple(ndarray(float, ndim=2)) DCNL Tuple of two arrays to be used to store the tableaux, of shape DCNL (2m, 2m). Modified in place. DCNL bases : tuple(ndarray(int, ndim=1)) DCNL Tuple of two arrays to be used to store the bases, of shape DCNL (m,). Modified in place. DCNL Returns DCNL tableaux : tuple(ndarray(float, ndim=2)) DCNL View to `tableaux`. DCNL bases : tuple(ndarray(int, ndim=1)) DCNL View to `bases`.'
'Find the vertical edges of an image using the Sobel transform. DCNL Parameters DCNL image : 2-D array DCNL Image to process. DCNL mask : 2-D array, optional DCNL An optional mask to limit the application to a certain area. DCNL Note that pixels surrounding masked regions are also masked to DCNL prevent masked regions from affecting the result. DCNL Returns DCNL output : 2-D array DCNL The Sobel edge map. DCNL Notes DCNL We use the following kernel:: DCNL 1   0  -1 DCNL 2   0  -2 DCNL 1   0  -1'
'Estimate the log Gaussian probability. DCNL Parameters DCNL X : array-like, shape (n_samples, n_features) DCNL means : array-like, shape (n_components, n_features) DCNL precisions_chol : array-like, DCNL Cholesky decompositions of the precision matrices. DCNL \'full\' : shape of (n_components, n_features, n_features) DCNL \'tied\' : shape of (n_features, n_features) DCNL \'diag\' : shape of (n_components, n_features) DCNL \'spherical\' : shape of (n_components,) DCNL covariance_type : {\'full\', \'tied\', \'diag\', \'spherical\'} DCNL Returns DCNL log_prob : array, shape (n_samples, n_components)'
'ob为用户或资产列表或资产queryset, 如果同时输入用户和{\'role\': role1, \'asset\': []}，则获取用户在这些资产上的信息 DCNL 生成MyInventory需要的 resource文件'
'Returns a _dict like DCNL "doctype": DCNL "fieldname": DCNL "operator": DCNL "value":'
'Quick utility to make comparing template output easier.'
'Returns a neighbor attribute_map for given ip address if exists.'
'Return a MSSQL connection.'
'Validate a tax number. DCNL :param tax_number: Tax number to validate DCNL :type tax_number: str DCNL :return: DCNL Type identifier of the tax number, if detected.  Possible DCNL values for now are either "vat" or "unknown". DCNL :rtype: str DCNL :raise: DCNL `ValidationError` if tax number type was detected, but it is DCNL somehow malformed.'
'Get tab title without ambiguation.'
'query chooser. DCNL this also returns a list of shard ids, which can DCNL just be all of them.  but here we\'ll search into the Query in order DCNL to try to narrow down the list of shards to query.'
'Remove insignificant whitespace from XML nodes DCNL It should only remove whitespace in between elements and sub elements. DCNL This should be safe for Jenkins due to how it\'s XML serialization works DCNL but may not be valid for other XML documents. So use this method with DCNL caution outside of this specific library.'
'Require several opkg packages to be uninstalled. DCNL Example:: DCNL from fabtools import require DCNL require.opkg.nopackages([ DCNL \'perl\', DCNL \'php5\', DCNL \'ruby\','
'Get a dict mapping funcs to colors from palette. DCNL Parameters DCNL palette : string DCNL Name of the bokeh palette to use, must be a member of DCNL bokeh.palettes.all_palettes. DCNL funcs : iterable DCNL Iterable of function names'
'Return the time formatting patterns used by the locale for the specified DCNL format. DCNL >>> get_time_format(locale=\'en_US\') DCNL <DateTimePattern u\'h:mm:ss a\'> DCNL >>> get_time_format(\'full\', locale=\'de_DE\') DCNL <DateTimePattern u\'HH:mm:ss v\'> 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 DCNL :return: the time format pattern DCNL :rtype: `DateTimePattern`'
'Return an :class:`.Alias` object. DCNL An :class:`.Alias` represents any :class:`.FromClause` DCNL with an alternate name assigned within SQL, typically using the ``AS`` DCNL clause when generated, e.g. ``SELECT * FROM table AS aliasname``. DCNL Similar functionality is available via the DCNL :meth:`~.FromClause.alias` method DCNL available on all :class:`.FromClause` subclasses. DCNL When an :class:`.Alias` is created from a :class:`.Table` object, DCNL this has the effect of the table being rendered DCNL as ``tablename AS aliasname`` in a SELECT statement. DCNL For :func:`.select` objects, the effect is that of creating a named DCNL subquery, i.e. ``(select ...) AS aliasname``. DCNL The ``name`` parameter is optional, and provides the name DCNL to use in the rendered SQL.  If blank, an "anonymous" name DCNL will be deterministically generated at compile time. DCNL Deterministic means the name is guaranteed to be unique against DCNL other constructs used in the same statement, and will also be the DCNL same name for each successive compilation of the same statement DCNL object. DCNL :param selectable: any :class:`.FromClause` subclass, DCNL such as a table, select statement, etc. DCNL :param name: string name to be assigned as the alias. DCNL If ``None``, a name will be deterministically generated DCNL at compile time. DCNL :param flat: Will be passed through to if the given selectable DCNL is an instance of :class:`.Join` - see :meth:`.Join.alias` DCNL for details. DCNL .. versionadded:: 0.9.0'
'Cleans HTML of dangerous tags and content.'
'Display the repository dialog.'
'A wrapper around django.views.static.serve that adds CORS headers.'
'Get number rounded to three places as a string.'
'Create an RDS read replica DCNL CLI example to create an RDS  read replica:: DCNL salt myminion boto_rds.create_read_replica replicaname source_name'
'Email user that their group membership status has changed. DCNL old_status and new_status can either be a valid value for GroupMembership.status, DCNL or None if we\'re going from or to a state where there is no GroupMembership DCNL record (e.g. if they\'re being removed from a group). DCNL This is queued from Group.add_member() and Group.remove_member().'
'cyclic(length = None, alphabet = string.ascii_lowercase, n = 4) -> list/str DCNL A simple wrapper over :func:`de_bruijn`. This function returns at most DCNL `length` elements. DCNL If the given alphabet is a string, a string is returned from this function. Otherwise DCNL a list is returned. DCNL Arguments: DCNL length: The desired length of the list or None if the entire sequence is desired. DCNL alphabet: List or string to generate the sequence over. DCNL n(int): The length of subsequences that should be unique. DCNL Example: DCNL >>> cyclic(alphabet = "ABC", n = 3) DCNL \'AAABAACABBABCACBACCBBBCBCCC\' DCNL >>> cyclic(20) DCNL \'aaaabaaacaaadaaaeaaa\' DCNL >>> alphabet, n = range(30), 3 DCNL >>> len(alphabet)**n, len(cyclic(alphabet = alphabet, n = n)) DCNL (27000, 27000)'
'Processes a complete data set and saves it as a TFRecord. DCNL Args: DCNL name: Unique identifier specifying the dataset. DCNL images: List of ImageMetadata. DCNL vocab: A Vocabulary object. DCNL num_shards: Integer number of shards for the output files.'
'Detach a managed policy to a user. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_iam.detach_user_policy mypolicy myuser'
'Scan for bluetooth devices in the area DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' bluetooth.scan'
'Load a dask Bag from a Castra. DCNL Parameters DCNL x : filename or Castra DCNL columns: list or string, optional DCNL The columns to load. Default is all columns. DCNL index: bool, optional DCNL If True, the index is included as the first element in each tuple. DCNL Default is False.'
'Like execute_from_command_line(), but for use by manage.py, a DCNL project-specific django-admin.py utility.'
'Returns a function which returns a default value for a field. DCNL Args: DCNL field: FieldDescriptor object for this field. DCNL The returned function has one argument: DCNL message: Message instance containing this field, or a weakref proxy DCNL of same. DCNL That function in turn returns a default value for this field.  The default DCNL value may refer back to |message| via a weak reference.'
'Create a new figure manager instance for the given figure.'
'Return the 3-regular Platonic Tetrahedral graph.'
'Return the path of a data file, these are relative to the current test DCNL directory.'
'STATUS ENQUIRY Section 9.3.28'
'>>> encryptMessage(\'LFWOAYUISVKMNXPBDCRJTQEGHZ\', \'Harshil Darji\') DCNL \'Ilcrism Olcvs\''
'Returns the Python version as string \'major.minor.patchlevel\' DCNL Note that unlike the Python sys.version, the returned value DCNL will always include the patchlevel (it defaults to 0).'
'Helper function for integer factorization. Trial factors ``n` DCNL against all integers given in the sequence ``candidates`` DCNL and updates the dict ``factors`` in-place. Returns the reduced DCNL value of ``n`` and a flag indicating whether any factors were found.'
'Tokenizes a string suppressing significant whitespace.'
'http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/as-scale-based-on-demand.html DCNL If PercentChangeInCapacity returns a value between 0 and 1, DCNL Auto Scaling will round it off to 1.'
'compute prediction results DCNL Parameters DCNL exog : array-like, optional DCNL The values for which you want to predict. DCNL transform : bool, optional DCNL If the model was fit via a formula, do you want to pass DCNL exog through the formula. Default is True. E.g., if you fit DCNL a model y ~ log(x1) + log(x2), and transform is True, then DCNL you can pass a data structure that contains x1 and x2 in DCNL their original form. Otherwise, you\'d need to log the data DCNL first. DCNL weights : array_like, optional DCNL Weights interpreted as in WLS, used for the variance of the predicted DCNL residual. DCNL args, kwargs : DCNL Some models can take additional arguments or keywords, see the DCNL predict method of the model for the details. DCNL Returns DCNL prediction_results : instance DCNL The prediction results instance contains prediction and prediction DCNL variance and can on demand calculate confidence intervals and summary DCNL tables for the prediction of the mean and of new observations.'
'Lists all the files that are in the designated GCS bucket. DCNL Args: DCNL bucket_name: A str, the name of the GCS bucket to look up. DCNL Returns: DCNL A list of str, the names of the files in the bucket.'
'Check whether obj and other are not equal, properly handling lost weakrefs. DCNL Use this whenever you cache a Live API object in some variable, and want to check DCNL whether you need to update the cached object.'
'Require an Apache site to be enabled. DCNL This will cause Apache to reload its configuration. DCNL from fabtools import require DCNL require.apache.site_enabled(\'mysite\')'
'Read a graph as list of edges with numeric weights. DCNL Parameters DCNL path : file or string DCNL File or filename to read. If a file is provided, it must be DCNL opened in \'rb\' mode. DCNL Filenames ending in .gz or .bz2 will be uncompressed. DCNL comments : string, optional DCNL The character used to indicate the start of a comment. DCNL delimiter : string, optional DCNL The string used to separate values.  The default is whitespace. DCNL create_using : Graph container, optional, DCNL Use specified container to build graph.  The default is networkx.Graph, DCNL an undirected graph. DCNL nodetype : int, float, str, Python type, optional DCNL Convert node data from strings to specified type DCNL encoding: string, optional DCNL Specify which encoding to use when reading file. DCNL Returns DCNL G : graph DCNL A networkx Graph or other type specified with create_using DCNL Notes DCNL Since nodes must be hashable, the function nodetype must return hashable DCNL types (e.g. int, float, str, frozenset - or tuples of those, etc.) DCNL Example edgelist file format. DCNL With numeric edge data:: DCNL # read with DCNL # >>> G=nx.read_weighted_edgelist(fh) DCNL # source target data DCNL a b 1 DCNL a c 3.14159 DCNL d e 42'
'Compute the sinh term in the outer sum of the HRR formula. DCNL The constants sqrt(2/3*pi) and sqrt(8) must be precomputed.'
'\btrue\b|\bfalse\b'
'%       Rewind and Stop DCNL X#Y#    Move and Drill DCNL T#      Tool Selection DCNL M30     End of Program DCNL M00     End of Program DCNL R#X#Y#  Repeat Hole DCNL G05, G81        Select Drill Mode DCNL G90     Absolute Mode DCNL G91     Incremental Mode DCNL G92 X#Y#        Set Zero DCNL G93 X#Y#        Set Zero DCNL M48     Program Header to first "%" DCNL M72     English-Imperial Mode'
'Estimate covariance with the Oracle Approximating Shrinkage algorithm. DCNL Parameters DCNL X : array-like, shape (n_samples, n_features) DCNL Data from which to compute the covariance estimate. DCNL assume_centered : boolean DCNL If True, data are not centered before computation. DCNL Useful to work with data whose mean is significantly equal to DCNL zero but is not exactly zero. DCNL If False, data are centered before computation. DCNL Returns DCNL shrunk_cov : array-like, shape (n_features, n_features) DCNL Shrunk covariance. DCNL shrinkage : float DCNL Coefficient in the convex combination used for the computation DCNL of the shrunk estimate. DCNL Notes DCNL The regularised (shrunk) covariance is: DCNL (1 - shrinkage)*cov DCNL + shrinkage * mu * np.identity(n_features) DCNL where mu = trace(cov) / n_features DCNL The formula we used to implement the OAS DCNL does not correspond to the one given in the article. It has been taken DCNL from the MATLAB program available from the author\'s webpage DCNL (http://tbayes.eecs.umich.edu/yilun/covestimation).'
'Return True if in a venv and no system site packages.'
'Wrap data in a pkt-line. DCNL :param data: The data to wrap, as a str or None. DCNL :return: The data prefixed with its length in pkt-line format; if data was DCNL None, returns the flush-pkt (\'0000\').'
'Like assertRaisesRegexp in unittest'
'List private networks'
'Monkeypatch syncback functions that actually talk to Gmail so that the DCNL tests can run faster.'
'like `mkdir -p`'
'Separate `filename` content between docstring and the rest DCNL Strongly inspired from ast.get_docstring. DCNL Returns DCNL docstring: str DCNL docstring of `filename` DCNL rest: str DCNL `filename` content without the docstring'
'Test get_repr().'
'OrderedProduct delete'
'Extract snmp parameters from NetworkDevice object DCNL Only supports SNMPv3'
'Return True if n can be written as the sum of k squares, DCNL False if it can\'t, or 1 if k == 2 and n is prime (in which DCNL case it *can* be written as a sum of two squares). A False DCNL is returned only if it can\'t be written as k-squares, even DCNL if 0s are allowed.'
'Update the Glance metadata for a volume by adding a new key:value pair. DCNL This API does not support changing the value of a key once it has been DCNL created.'
'Get the width in projected coordinates of the coordinate tile polygon. DCNL Uses _tile_perimeter().'
'Update the global connection pool manager parameters. DCNL maxsize: Number of connections to save that can be reused (default=1). DCNL More than 1 is useful in multithreaded situations.'
'alphanumeric(raw_bytes) -> str DCNL Encode the shellcode ``raw_bytes`` such that it does not DCNL contain any bytes except for [A-Za-z0-9]. DCNL Accepts the same arguments as :func:`encode`.'
'Associate media instance with this media list instance. DCNL If another media instance was present it will be released. DCNL The L{libvlc_media_list_lock} should NOT be held upon entering this function. DCNL @param p_ml: a media list instance. DCNL @param p_md: media instance to add.'
'Returns the path to the PDB file that will be generated by a given DCNL configuration. DCNL The lookup proceeds as follows: DCNL - Look for an explicit path in the VCLinkerTool configuration block. DCNL - Look for an \'msvs_large_pdb_path\' variable. DCNL - Use \'<(PRODUCT_DIR)/<(product_name).(exe|dll).pdb\' if \'product_name\' is DCNL specified. DCNL - Use \'<(PRODUCT_DIR)/<(target_name).(exe|dll).pdb\'. DCNL Arguments: DCNL target_dict: The target dictionary to be searched. DCNL config_name: The name of the configuration of interest. DCNL vars: A dictionary of common GYP variables with generator-specific values. DCNL Returns: DCNL The path of the corresponding PDB file.'
'Returns maximum elements obtained by iterating over given axis. DCNL When axis is None (the default value), the max is performed DCNL over the flattened tensor. DCNL Parameters DCNL keepdims: bool DCNL If this is set to True, the axes which are reduced are left in DCNL the result as dimensions with size one. With this option, the result DCNL will broadcast correctly against the original tensor. DCNL Notes DCNL We return an error as numpy when we reduce a dim with a shape of 0.'
'Decorator for views that checks that the user is logged in and is a staff DCNL member, displaying the login page if necessary.'
'Determine if the coil is axial.'
'Tries to "guess" a rational generating function for a sequence of rational DCNL numbers v. DCNL Examples DCNL >>> from sympy.concrete.guess import guess_generating_function_rational DCNL >>> from sympy import fibonacci DCNL >>> l = [fibonacci(k) for k in range(5,15)] DCNL >>> guess_generating_function_rational(l) DCNL (3*x + 5)/(-x**2 - x + 1) DCNL See also DCNL See function sympy.series.approximants and mpmath.pade'
'Generate a list of random strings.'
'Yield ``Requirement`` objects for each specification in `strs` DCNL `strs` must be a string, or a (possibly-nested) iterable thereof.'
'Take a scalar Python value and return a dict consisting DCNL of the Amazon DynamoDB type specification and the value that DCNL needs to be sent to Amazon DynamoDB.  If the type of the value DCNL is not supported, raise a TypeError'
'Add simple completion to a widget'
'subroutine of compute_md5_v1() DCNL @param get_deps_dict: dictionary returned by get_dependencies call DCNL @type  get_deps_dict: dict DCNL @param hash: hash instance DCNL @type  hash: hash instance'
'Negative sampling loss function. DCNL In natural language processing, especially language modeling, the number of DCNL words in a vocabulary can be very large. DCNL Therefore, you need to spend a lot of time calculating the gradient of the DCNL embedding matrix. DCNL By using the negative sampling trick you only need to calculate the DCNL gradient for a few sampled negative examples. DCNL The objective function is below: DCNL .. math:: DCNL f(x, p) = \log \sigma(x^\top w_p) + \ DCNL k E_{i \sim P(i)}[\log \sigma(- x^\top w_i)], DCNL where :math:`\sigma(\cdot)` is a sigmoid function, :math:`w_i` is the DCNL weight vector for the word :math:`i`, and :math:`p` is a positive example. DCNL It is approximeted with :math:`k` examples :math:`N` sampled from DCNL probability :math:`P(i)`, like this: DCNL .. math:: DCNL f(x, p) \approx \log \sigma(x^\top w_p) + \ DCNL \sum_{n \in N} \log \sigma(-x^\top w_n). DCNL Each sample of :math:`N` is drawn from the word distribution :math:`P(w)`. DCNL This is calculated as :math:`P(w) = \frac{1}{Z} c(w)^\alpha`, where DCNL :math:`c(w)` is the unigram count of the word :math:`w`, :math:`\alpha` is DCNL a hyper-parameter, and :math:`Z` is the normalization constant. DCNL Args: DCNL x (~chainer.Variable): Batch of input vectors. DCNL t (~chainer.Variable): Vector of groundtruth labels. DCNL W (~chainer.Variable): Weight matrix. DCNL sampler (function): Sampling function. It takes a shape and returns an DCNL integer array of the shape. Each element of this array is a sample DCNL from the word distribution. A :class:`~chainer.utils.WalkerAlias` DCNL object built with the power distribution of word frequency is DCNL recommended. DCNL sample_size (int): Number of samples. DCNL See: `Distributed Representations of Words and Phrases and their         Compositionality <http://arxiv.org/abs/1310.4546>`_ DCNL .. seealso:: :class:`~chainer.links.NegativeSampling`.'
'Displays the login form and handles the login action.'
'Split a string for a specified width and font size'
'Synthesis of a sound using the harmonic plus stochastic model DCNL hfreq, hmag: harmonic frequencies and amplitudes; stocEnv: stochastic envelope DCNL Ns: synthesis FFT size; H: hop size, fs: sampling rate DCNL returns y: output sound, yh: harmonic component, yst: stochastic component'
'Converts expr to Negation Normal Form. DCNL A logical expression is in Negation Normal Form (NNF) if it DCNL contains only And, Or and Not, and Not is applied only to literals. DCNL If simpify is True, the result contains no redundant clauses. DCNL Examples DCNL >>> from sympy.abc import A, B, C, D DCNL >>> from sympy.logic.boolalg import Not, Equivalent, to_nnf DCNL >>> to_nnf(Not((~A & ~B) | (C & D))) DCNL And(Or(A, B), Or(Not(C), Not(D))) DCNL >>> to_nnf(Equivalent(A >> B, B >> A)) DCNL And(Or(A, And(A, Not(B)), Not(B)), Or(And(B, Not(A)), B, Not(A)))'
'Helper func to provide easy access to the (possibly) moving target that is DCNL C{ET}.'
'Tests translation can be applied after suggestion is accepted.'
'Returns a WSGI application configured for the given services. DCNL Parameters are the same as :func:`service_mapping`, plus: DCNL :param debug: DCNL WSGI application debug flag: True to enable debug mode. DCNL :param config: DCNL WSGI application configuration dictionary.'
'Get the matrix Tetragrid from the xmlElement matrix value.'
'Check if a feature-specific field can be displayed. DCNL This method check a permission for a feature-specific field. DCNL Such field is usually provided through Neutron extension. DCNL :param request: Request Object DCNL :param feature: feature name defined in FEATURE_MAP DCNL :param operation (optional): Operation type. The valid value should be DCNL defined in FEATURE_MAP[feature][\'policies\'] DCNL It must be specified if FEATURE_MAP[feature] has \'policies\'.'
'Converts a timezone string to a pytz timezone object. DCNL Arguments: DCNL timezone_string: a string representing a timezone, or None DCNL Returns: DCNL a pytz timezone object, or None DCNL Raises: DCNL ValueError: if timezone_string is specified, but pytz module could not be DCNL loaded'
'Compare two version strings (eg 0.0.1.10 > 0.0.1.9).'
'Map counter value v to the scattered ID space. DCNL Translate to scattered ID space, then reverse bits. DCNL Args: DCNL v: Counter value from which to produce ID. DCNL Returns: DCNL Integer ID. DCNL Raises: DCNL datastore_errors.BadArgumentError if counter value exceeds the range of DCNL the scattered ID space.'
'Single knowledge item view page'
'Get the first word of a split line.'
'Ensure directory exists and is writable by us'
'Validates the user input, before execution.'
'See :meth:`I18n.parse_date`'
'Warn the user for each extra that doesn\'t exist.'
'Returns a dictionary keyed to the defined LXC groups. All DCNL containers, including the ones not in any group, are included in the DCNL "all" group.'
'Version 4 pubkeys are encrypted. This function is run when we already have the DCNL address to which we want to try to send a message. The \'data\' may come either DCNL off of the wire or we might have had it already in our inventory when we tried DCNL to send a msg to this particular address.'
'Return the mac address interpretation of num, DCNL in the form eg \'00:11:22:33:AA:BB\'. DCNL :param num: a 48-bit integer (eg from uuid.getnode) DCNL :param spliiter: a string to join the hex pairs with'
'Get links that are rising right now.'
'List all datasources in an organisation. DCNL orgname DCNL Name of the organization. DCNL profile DCNL Configuration profile used to connect to the Grafana instance. DCNL Default is \'grafana\'. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' grafana4.get_datasources <orgname>'
'Returns a path to the directory where stub data can be stored.'
'Generates a URL to the given endpoint with the method provided. DCNL Variable arguments that are unknown to the target endpoint are appended DCNL to the generated URL as query arguments.  If the value of a query argument DCNL is `None`, the whole pair is skipped.  In case blueprints are active DCNL you can shortcut references to the same blueprint by prefixing the DCNL local endpoint with a dot (``.``). DCNL This will reference the index function local to the current blueprint:: DCNL url_for(\'.index\') DCNL For more information, head over to the :ref:`Quickstart <url-building>`. DCNL To integrate applications, :class:`Flask` has a hook to intercept URL build DCNL errors through :attr:`Flask.build_error_handler`.  The `url_for` function DCNL results in a :exc:`~werkzeug.routing.BuildError` when the current app does DCNL not have a URL for the given endpoint and values.  When it does, the DCNL :data:`~flask.current_app` calls its :attr:`~Flask.build_error_handler` if DCNL it is not `None`, which can return a string to use as the result of DCNL `url_for` (instead of `url_for`\'s default to raise the DCNL :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception. DCNL An example:: DCNL def external_url_handler(error, endpoint, **values): DCNL "Looks up an external URL when `url_for` cannot build a URL." DCNL # This is an example of hooking the build_error_handler. DCNL # Here, lookup_url is some utility function you\'ve built DCNL # which looks up the endpoint in some external URL registry. DCNL url = lookup_url(endpoint, **values) DCNL if url is None: DCNL # External lookup did not have a URL. DCNL # Re-raise the BuildError, in context of original traceback. DCNL exc_type, exc_value, tb = sys.exc_info() DCNL if exc_value is error: DCNL raise exc_type, exc_value, tb DCNL else: DCNL raise error DCNL # url_for will use this result, instead of raising BuildError. DCNL return url DCNL app.build_error_handler = external_url_handler DCNL Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and DCNL `endpoint` and `**values` are the arguments passed into `url_for`.  Note DCNL that this is for building URLs outside the current application, and not for DCNL handling 404 NotFound errors. DCNL .. versionadded:: 0.10 DCNL The `_scheme` parameter was added. DCNL .. versionadded:: 0.9 DCNL The `_anchor` and `_method` parameters were added. DCNL .. versionadded:: 0.9 DCNL Calls :meth:`Flask.handle_build_error` on DCNL :exc:`~werkzeug.routing.BuildError`. DCNL :param endpoint: the endpoint of the URL (name of the function) DCNL :param values: the variable arguments of the URL rule DCNL :param _external: if set to `True`, an absolute URL is generated. Server DCNL address can be changed via `SERVER_NAME` configuration variable which DCNL defaults to `localhost`. DCNL :param _scheme: a string specifying the desired URL scheme. The `_external` DCNL parameter must be set to `True` or a `ValueError` is raised. DCNL :param _anchor: if provided this is added as anchor to the URL. DCNL :param _method: if provided this explicitly specifies an HTTP method.'
'Test delayed projection on Epochs.'
'Return a string listing all changes to the working tree in a git DCNL repository.'
'The generic script can be customised by using parameters (see config.py).'
'source_path - BT种子的绝对路径.'
'build bidirectional encoder, given pre-computed word embeddings'
'Minimization of scalar function of one or more variables using the DCNL BFGS algorithm. DCNL Options DCNL disp : bool DCNL Set to True to print convergence messages. DCNL maxiter : int DCNL Maximum number of iterations to perform. DCNL gtol : float DCNL Gradient norm must be less than `gtol` before successful DCNL termination. DCNL norm : float DCNL Order of norm (Inf is max, -Inf is min). DCNL eps : float or ndarray DCNL If `jac` is approximated, use this value for the step size.'
'Launch a terminal -> QAction'
'Ensure domain exists. DCNL name DCNL The name of the state definition DCNL DomainName DCNL Name of the domain. DCNL ElasticsearchClusterConfig DCNL Configuration options for an Elasticsearch domain. Specifies the DCNL instance type and number of instances in the domain cluster. DCNL InstanceType (string) -- DCNL The instance type for an Elasticsearch cluster. DCNL InstanceCount (integer) -- DCNL The number of instances in the specified domain cluster. DCNL DedicatedMasterEnabled (boolean) -- DCNL A boolean value to indicate whether a dedicated master node is enabled. DCNL See About Dedicated Master Nodes for more information. DCNL ZoneAwarenessEnabled (boolean) -- DCNL A boolean value to indicate whether zone awareness is enabled. See About DCNL Zone Awareness for more information. DCNL DedicatedMasterType (string) -- DCNL The instance type for a dedicated master node. DCNL DedicatedMasterCount (integer) -- DCNL Total number of dedicated master nodes, active and on standby, for the DCNL cluster. DCNL EBSOptions DCNL Options to enable, disable and specify the type and size of EBS storage DCNL volumes. DCNL EBSEnabled (boolean) -- DCNL Specifies whether EBS-based storage is enabled. DCNL VolumeType (string) -- DCNL Specifies the volume type for EBS-based storage. DCNL VolumeSize (integer) -- DCNL Integer to specify the size of an EBS volume. DCNL Iops (integer) -- DCNL Specifies the IOPD for a Provisioned IOPS EBS volume (SSD). DCNL AccessPolicies DCNL IAM access policy DCNL SnapshotOptions DCNL Option to set time, in UTC format, of the daily automated snapshot. DCNL Default value is 0 hours. DCNL AutomatedSnapshotStartHour (integer) -- DCNL Specifies the time, in UTC format, when the service takes a daily DCNL automated snapshot of the specified Elasticsearch domain. Default value DCNL is 0 hours. DCNL AdvancedOptions DCNL Option to allow references to indices in an HTTP request body. Must be DCNL false when configuring access to individual sub-resources. By default, DCNL the value is true . 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) that DCNL contains a dict with region, key and keyid. DCNL ElasticsearchVersion DCNL String of format X.Y to specify version for the Elasticsearch domain eg. DCNL "1.5" or "2.3".'
'Find the location of a prefix given a conda env name. DCNL Args: DCNL ctx (Context): the context object DCNL name (str): the name of prefix to find DCNL Returns: DCNL str: the location of the prefix found, or CondaValueError will raise if not found DCNL Raises: DCNL CondaValueError: when no prefix is found'
'Splits a line into tokens using same rules as MPD. DCNL - Lines may not start with whitespace DCNL - Tokens are split by arbitrary amount of spaces or tabs DCNL - First token must match `[a-z][a-z0-9_]*` DCNL - Remaining tokens can be unquoted or quoted tokens. DCNL - Unquoted tokens consist of all printable characters except double quotes, DCNL single quotes, spaces and tabs. DCNL - Quoted tokens are surrounded by a matching pair of double quotes. DCNL - The closing quote must be followed by space, tab or end of line. DCNL - Any value is allowed inside a quoted token. Including double quotes, DCNL assuming it is correctly escaped. DCNL - Backslash inside a quoted token is used to escape the following DCNL character. DCNL For examples see the tests for this function.'
'cmp function for sorting a list of strings by alphabetical DCNL order, but with numbers sorted numerically, i.e. `foo1, DCNL foo2, foo10, foo11` instead of `foo1, foo10, foo11, foo2`. DCNL Parameters DCNL str1 : str DCNL WRITEME DCNL str2 : str DCNL WRITEME DCNL Returns DCNL WRITEME'
'Returns a generator of all available collections.'
'After one parse, seqToKV and kvToSeq are inverses, with no warnings:: DCNL seq = kvToSeq(s) DCNL seqToKV(kvToSeq(seq)) == seq'
'Detects MyObfuscate.com packer.'
'TODO'
'Ensure that the # of rows in the input_file DCNL is greater than the row_limit.'
':param id: The resource collection type. DCNL :type id: str DCNL :rtype: KeyVaultId'
'Parse job id from qsub output string. DCNL Assume format: DCNL "Your job <job_id> ("<job_name>") has been submitted"'
'Redirects request handling to the not found render'
'Replace ESC (ASCII 27/Oct 33) to prevent unsafe strings DCNL from writing their own terminal manipulation commands'
'Find variable use/def per block.'
'View that checks the hash in a password reset link and presents a DCNL form for entering a new password.'
'helper function to remove an account right from a user'
'Return the attributes from data which are model columns. DCNL Return a new dict with items from data that whose keys are columns in DCNL the model or are association proxies of the model.'
'Shares photos from existing episodes with the followers of an existing viewpoint.'
'Create a metadef resource type'
'Check for aliyun configurations'
'Set up & run a `Publisher` for programmatic use with string I/O.  Return DCNL the encoded string or Unicode string output. DCNL For encoded string output, be sure to set the \'output_encoding\' setting to DCNL the desired encoding.  Set it to \'unicode\' for unencoded Unicode string DCNL output.  Here\'s one way:: DCNL publish_string(..., settings_overrides={\'output_encoding\': \'unicode\'}) DCNL Similarly for Unicode string input (`source`):: DCNL publish_string(..., settings_overrides={\'input_encoding\': \'unicode\'}) DCNL Parameters: see `publish_programmatically`.'
'Synchronization decorator.'
'Guess the id of the minion. DCNL If CONFIG_DIR/minion_id exists, use the cached minion ID from that file. DCNL If no minion id is configured, use multiple sources to find a FQDN. DCNL If no FQDN is found you may get an ip address. DCNL Returns two values: the detected ID, and a boolean value noting whether or DCNL not an IP address is being used for the ID.'
'Return the degree value for the given radians (pi = 180 degrees).'
'Returns the path from a response to a PWD command. DCNL Responses typically look like:: DCNL 257 "/home/andrew" is current directory. DCNL For this example, I will return C{\'/home/andrew\'}. DCNL If I can\'t find the path, I return C{None}.'
'Returns the expression of cross-entropy of two sequences, implement DCNL softmax internally. Normally be used for Fixed Length RNN outputs. DCNL Parameters DCNL logits : Tensorflow variable DCNL 2D tensor, ``network.outputs``, [batch_size*n_steps (n_examples), number of output units] DCNL target_seqs : Tensorflow variable DCNL target : 2D tensor [batch_size, n_steps], if the number of step is dynamic, please use ``cross_entropy_seq_with_mask`` instead. DCNL batch_size : a int, default is 1 DCNL RNN batch_size, number of concurrent processes, divide the loss by batch_size. DCNL num_steps : a int DCNL sequence length DCNL Examples DCNL >>> see PTB tutorial for more details DCNL >>> input_data = tf.placeholder(tf.int32, [batch_size, num_steps]) DCNL >>> targets = tf.placeholder(tf.int32, [batch_size, num_steps]) DCNL >>> cost = tf.cost.cross_entropy_seq(network.outputs, targets, batch_size, num_steps)'
'Ensure Crypto module is available.'
'Basic tests for ColorArray class'
'All arguments have the same meaning as ``ssl_wrap_socket``. DCNL By default, this function does a lot of the same work that DCNL ``ssl.create_default_context`` does on Python 3.4+. It: DCNL - Disables SSLv2, SSLv3, and compression DCNL - Sets a restricted set of server ciphers DCNL If you wish to enable SSLv3, you can do:: DCNL from urllib3.util import ssl_ DCNL context = ssl_.create_urllib3_context() DCNL context.options &= ~ssl_.OP_NO_SSLv3 DCNL You can do the same to enable compression (substituting ``COMPRESSION`` DCNL for ``SSLv3`` in the last line above). DCNL :param ssl_version: DCNL The desired protocol version to use. This will default to DCNL PROTOCOL_SSLv23 which will negotiate the highest protocol that both DCNL the server and your installation of OpenSSL support. DCNL :param cert_reqs: DCNL Whether to require the certificate verification. This defaults to DCNL ``ssl.CERT_REQUIRED``. DCNL :param options: DCNL Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``, DCNL ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``. DCNL :param ciphers: DCNL Which cipher suites to allow the server to select. DCNL :returns: DCNL Constructed SSLContext object with specified options DCNL :rtype: SSLContext'
'Merge multiple measurement info dictionaries. DCNL - Fields that are present in only one info object will be used in the DCNL merged info. DCNL - Fields that are present in multiple info objects and are the same DCNL will be used in the merged info. DCNL - Fields that are present in multiple info objects and are different DCNL will result in a None value in the merged info. DCNL - Channels will be concatenated. If multiple info objects contain DCNL channels with the same name, an exception is raised. DCNL Parameters DCNL infos | list of instance of Info DCNL Info objects to merge into one info object. DCNL force_update_to_first : bool DCNL If True, force the fields for objects in `info` will be updated DCNL to match those in the first item. Use at your own risk, as this DCNL may overwrite important metadata. DCNL verbose : bool, str, int, or NonIe DCNL If not None, override default verbose level (see :func:`mne.verbose` DCNL and :ref:`Logging documentation <tut_logging>` for more). DCNL Returns DCNL info : instance of Info DCNL The merged info object.'
'Build the string from the xBlock type set to append to the Block url for block_count types DCNL Arguments: DCNL xblock_type_set (set): A set of strings for all the block types DCNL Returns: DCNL str: The portion to append to the block url'
'create two default territories, one for home country and one named Rest of the World'
'Generate text to put in the GitHub release Markdown box'
'take parameters defined and build ifupdown2 compatible hash'
'Extract the JSON payload from a JWT. DCNL Does the extraction w/o checking the signature. DCNL Args: DCNL id_token: string or bytestring, OAuth 2.0 id_token. DCNL Returns: DCNL object, The deserialized JSON payload.'
'Replace WatchedFileHandler handlers by FileHandler ones. DCNL Neutron logging uses WatchedFileHandler handlers but they do not DCNL support privileges drop, this method replaces them by FileHandler DCNL handlers supporting privileges drop.'
'Compress \'body\' at the given compress_level.'
'Returns a concise summary of an Alignment object as a string.'
'Throw an exception if imbalanced-learn dependencies are not installed. DCNL Parameters DCNL is_imbalanced_dataset_installing: boolean DCNL if True, only error on missing packages that cannot be auto-installed. DCNL if False, error on any missing package. DCNL Throws DCNL ImportError'
'Setup the OpenWeatherMap weather platform.'
'Restart the named service DCNL .. versionchanged:: 2016.3.4 DCNL jail: optional jid or jail name DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' service.restart <service name>'
'Test the fix for #4350 where byte strings were output with a DCNL leading `b` on Py3.'
'Encode a single name, value pair.'
'Get triangle mesh from attribute dictionary.'
'getRandomRange(a:int, b:int, randfunc:callable):long DCNL Return a random number n so that a <= n < b. 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.'
'Convert a BeautifulSoup tree to a list of Element trees. DCNL Returns a list instead of a single root Element to support DCNL HTML-like soup with more than one root element. DCNL You can pass a different Element factory through the `makeelement` DCNL keyword.'
'Adds options specific to the \'update\' command on Java apps to \'parser\'. DCNL Args: DCNL parser: An instance of OptionsParser.'
'BigIP can\'t make up its mind if it likes yes / no or true or false. DCNL Figure out what it likes to hear without confusing the user.'
'Helper function for when multiple plot axes are needed. DCNL Those axes should be created in the functions they are used in, with DCNL ``fig.add_subplot()``. DCNL Parameters DCNL fig : Matplotlib figure instance, optional DCNL If given, this figure is simply returned.  Otherwise a new figure is DCNL created. DCNL Returns DCNL fig : Matplotlib figure instance DCNL If `fig` is None, the created figure.  Otherwise the input `fig` is DCNL returned. DCNL See Also DCNL create_mpl_ax'
'Serialize revision for use in revisions table. DCNL :param Node node: Root node DCNL :param FileRecord record: Root file record DCNL :param FileVersion version: The version to serialize DCNL :param int index: One-based index of version'
'Displays the date, formatted according to the given string. DCNL Uses the same format as PHP\'s ``date()`` function; see http://php.net/date DCNL for all the possible values. DCNL Sample usage:: DCNL It is {% now "jS F Y H:i" %}'
'Validates a list to be included as document fields. The key is just DCNL passed in to make better error messages.'
'Test either if an error is raised when the target are continuous DCNL type'
'Convert integer in \'n\' from network-byte order to host-byte order.'
'mbruteforce(func, alphabet, length, method = \'upto\', start = None, threads = None) DCNL Same functionality as bruteforce(), but multithreaded. DCNL Arguments: DCNL func, alphabet, length, method, start: same as for bruteforce() DCNL threads: Amount of threads to spawn, default is the amount of cores.'
'Look for it as if it was a full path, if not, try local file, DCNL if not try in the data directory. DCNL Download dataset if it is not present'
'Test epoch hashing.'
'Read `count` 32-bit ints using the plain encoding.'
'Load `item` stored at `path` in `cache`.'
'Make a copy of some of the current global CONF\'s settings. DCNL Allows determining if any of these values have changed DCNL when the config is reloaded.'
'strxfrm(string) -> string. DCNL Returns a string that behaves for cmp locale-aware.'
'rjust(s, width) -> string DCNL Return a right-justified version of s, in a field of the DCNL specified width, padded with spaces as needed.  The string is DCNL never truncated.'
'Return a measure of the sequences\' similarity between 0 and 100, using different algorithms. DCNL **Steps in the order they occur** DCNL #. Run full_process from utils on both strings DCNL #. Short circuit if this makes either string empty DCNL #. Take the ratio of the two processed strings (fuzz.ratio) DCNL #. Run checks to compare the length of the strings DCNL * If one of the strings is more than 1.5 times as long as the other DCNL use partial_ratio comparisons - scale partial results by 0.9 DCNL (this makes sure only full results can return 100) DCNL * If one of the strings is over 8 times as long as the other DCNL instead scale by 0.6 DCNL #. Run the other ratio functions DCNL * if using partial ratio functions call partial_ratio, DCNL partial_token_sort_ratio and partial_token_set_ratio DCNL scale all of these by the ratio based on length DCNL * otherwise call token_sort_ratio and token_set_ratio DCNL * all token based comparisons are scaled by 0.95 DCNL (on top of any partial scalars) DCNL #. Take the highest value from these results DCNL round it and return it as an integer. DCNL :param s1: DCNL :param s2: DCNL :param force_ascii: Allow only ascii characters DCNL :type force_ascii: bool DCNL :return:'
'Creates or overwrites tags associated with a file system. DCNL Each tag is a key-value pair. If a tag key specified in the request DCNL already exists on the file system, this operation overwrites DCNL its value with the value provided in the request. DCNL filesystemid DCNL (string) - ID of the file system for whose tags will be modified. DCNL tags DCNL (dict) - The tags to add to the file system DCNL CLI Example: DCNL .. code-block:: DCNL salt \'my-minion\' boto_efs.create_tags'
'Verify if the given package or DEPEND atom has the given flag. DCNL Warning: This only works if the configuration files tree is in the correct DCNL format (the one enforced by enforce_nice_config) DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' portage_config.has_flag license salt Apache-2.0'
'Read resource template from egg installation, or fallback on rospkg otherwise. DCNL :returns: text of template file'
'Make the copy request to the WaterBulter API and handle DCNL successful and failed responses DCNL :param job_pk: primary key of ArchiveJob DCNL :param url: URL to send request to DCNL :param data: <dict> of setting to send in POST to WaterBulter API DCNL :return: None'
'Finds a free id, locks it and returns integer id, or -1 if none free. DCNL * Lock must be freed manually *'
'Creates new GCE VM instance for development.'
'Create or verify existance of config, work, or logs directories'
'Return the given value if it\'s a valid name, otherwise raise Invalid. DCNL If it\'s a valid name, the given value will be returned unmodified. DCNL This function applies general validation rules for names of packages, DCNL groups, users, etc. DCNL Most schemas also have their own custom name validator function to apply DCNL custom validation rules after this function, for example a DCNL ``package_name_validator()`` to check that no package with the given name DCNL already exists. DCNL :raises ckan.lib.navl.dictization_functions.Invalid: if ``value`` is not DCNL a valid name'
'Repeat elements of an array. DCNL It returns an array which has the same shape as `x`, except DCNL along the given axis. The axis is used to speficy along which DCNL axis to repeat values. By default, use the flattened input DCNL array, and return a flat output array. DCNL The number of repetitions for each element is `repeat`. DCNL `repeats` is broadcasted to fit the length of the given `axis`. DCNL Parameters DCNL x DCNL Input data, tensor variable. DCNL repeats DCNL int, scalar or tensor variable DCNL axis : int, optional DCNL See Also DCNL tensor.tile DCNL .. versionadded:: 0.6'
'Compare the nervanagpu and nervanacpu hist implementation to the reference DCNL implementation above. DCNL Parameterized test case, uses pytest_generate_test to enumerate dim_dtype_inp DCNL tuples that drive the test.'
'Estimate rank of M/EEG covariance data, given the covariance. DCNL Parameters DCNL data : np.ndarray of float, shape (n_channels, n_channels) DCNL The M/EEG covariance. DCNL info : Info DCNL The measurment info. DCNL scalings : dict | \'norm\' | np.ndarray | None DCNL The rescaling method to be applied. If dict, it will override the DCNL following default dict: DCNL dict(mag=1e12, grad=1e11, eeg=1e5) DCNL If \'norm\' data will be scaled by channel-wise norms. If array, DCNL pre-specified norms will be used. If None, no scaling will be applied. DCNL tol : float | str DCNL Tolerance. See ``estimate_rank``. DCNL return_singular : bool DCNL If True, also return the singular values that were used DCNL to determine the rank. DCNL Returns DCNL rank : int DCNL Estimated rank of the data. DCNL s : array DCNL If return_singular is True, the singular values that were DCNL thresholded to determine the rank are also returned.'
'Return a matrix as a Matrix, otherwise return x.'
'Return the environment changes'
'Test that INDEF is correctly interpreted as a missing value'
'name DCNL Name of the state DCNL conn_id DCNL ID of the peering connection to delete.  Exlusive with conn_name. DCNL conn_name DCNL The name of the peering connection to delete.  Exlusive with conn_id. 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) that DCNL contains a dict with region, key and keyid. DCNL .. versionadded:: 2016.11.0 DCNL Example: DCNL .. code-block:: yaml DCNL delete a vpc peering connection: DCNL boto_vpc.delete_vpc_peering_connection: DCNL - region: us-west-2 DCNL - conn_id: pcx-4613b12e DCNL Connection name can be specified (instead of ID). DCNL Specifying both conn_name and conn_id will result in an DCNL error. DCNL .. code-block:: yaml DCNL delete a vpc peering connection: DCNL boto_vpc.delete_vpc_peering_connection: DCNL - conn_name: salt_vpc_peering'
'Check that the argument is a type, and return it (internal helper). DCNL As a special case, accept None and return type(None) instead. DCNL Also, _TypeAlias instances (e.g. Match, Pattern) are acceptable. DCNL The msg argument is a human-readable error message, e.g. DCNL "Union[arg, ...]: arg should be a type." DCNL We append the repr() of the actual value (truncated to 100 chars).'
'Test either if an error is raised when the target are not binary DCNL type.'
'Append password switch to commandline.'
'Get new derivation.'
'Dummy implementation of _thread._set_sentinel().'
'Return a FormSet for the given form class.'
'KBEngine method. DCNL 这个logger被关闭前的回调函数'
'Return the network associated with the project. DCNL If associate is true, it will attempt to associate a new DCNL network if one is not found, otherwise it returns None.'
'Make an instance of a client, login, and return it. DCNL kwargs are passed through to cls.login().'
'Get relative path from siteurl of lang to siteurl of base_lang DCNL the output is cached in _SITES_RELPATH_DB'
':param si: Service Instance DCNL :param vm: Virtual Machine Object DCNL :param network: Virtual Network'
'Provide a TestSuite to the discovery process.'
'Wrapper around _format_value().'
'Return the currently-implemented formats. DCNL These are not classes, but maybe should be: would they survive pickling? DCNL - exporter: DCNL an Exporter subclass. DCNL if not defined, and key is in nbconvert.export.exporter_map, it will be added DCNL automatically DCNL - nbconvert_template: DCNL the name of the nbconvert template to add to config.ExporterClass DCNL - test: DCNL a function(notebook_object, notebook_json) DCNL conditionally offer a format based on content if truthy. see DCNL `RenderingHandler.filter_exporters` DCNL - postprocess: DCNL a function(html, resources) DCNL perform any modifications to html and resources after nbconvert DCNL - content_Type: DCNL a string specifying the Content-Type of the response from this format. DCNL Defaults to  text/html; charset=UTF-8'
'Return latest Flexget version from http://download.flexget.com/latestversion'
'Edit the virtual service. DCNL protocol DCNL The service protocol(only support tcp, udp and fwmark service). DCNL service_address DCNL The LVS service address. DCNL scheduler DCNL Algorithm for allocating TCP connections and UDP datagrams to real servers. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' lvs.edit_service tcp 1.1.1.1:80 rr'
'Get version information from git keywords.'
'Ensure a specific value exists at a given path DCNL :param name: The name for this rule DCNL :type  name: ``str`` DCNL :param datastore: The datastore, e.g. running, operational. DCNL One of the NETCONF store IETF types DCNL :type  datastore: :class:`DatastoreType` (``str`` enum). DCNL :param path: The device path to set the value at, DCNL a list of element names in order, / seperated DCNL :type  path: ``list``, ``str`` OR ``tuple`` DCNL :param config: The new value at the given path DCNL :type  config: ``dict`` DCNL Examples: DCNL .. code-block:: yaml DCNL enable pap auth: DCNL cisconso.config_present: DCNL - name: enable_pap_auth DCNL - datastore: running DCNL - path: devices/device/ex0/config/sys/interfaces/serial/ppp0/authentication DCNL - config: DCNL authentication: DCNL method: pap DCNL "list-name": foobar'
'Query some data from a deactivated cache.'
'<word> -- Returns an example sentence showing the usage of <word>.'
'Attempts to open the given files using the preferred desktop viewer or editor. DCNL :raises :class:`OpenError`: if there is a problem opening any of the files.'
'Checks whether a graph is purely elementwise and containing only DCNL inputs from a given list. DCNL Parameters DCNL graph : TensorVariable object DCNL Graph to perform checks against. DCNL inputs : list DCNL List of acceptable inputs to the graph. DCNL Returns DCNL elemwise_or_not : bool DCNL Returns `True` if DCNL a) everything in the graph is an Elemwise or a DimShuffle DCNL (DimShuffles are only acceptable to broadcast up constants) DCNL and DCNL b) all nodes without an owner appear in `inputs` or are DCNL constants. DCNL Returns `False` otherwise.'
'Builder for rebulk object. DCNL :return: Created Rebulk object DCNL :rtype: Rebulk'
'Get a bucket from an s3 connection DCNL :param conn: The ``boto.s3.connection.S3Connection`` DCNL :param bucket_id: ID of the bucket to fetch DCNL :raises ``glance.exception.NotFound`` if bucket is not found.'
'build the error message for the number range validators'
'Get the first floating ip address of an instance.'
'Authenticate using MONGODB-CR.'
'Check whether the given expr_set entail an expr. DCNL If formula_set is empty then it returns the validity of expr. DCNL Examples DCNL >>> from sympy.abc import A, B, C DCNL >>> from sympy.logic.inference import entails DCNL >>> entails(A, [A >> B, B >> C]) DCNL False DCNL >>> entails(C, [A >> B, B >> C, A]) DCNL True DCNL >>> entails(A >> B) DCNL False DCNL >>> entails(A >> (B >> A)) DCNL True DCNL References DCNL .. [1] http://en.wikipedia.org/wiki/Logical_consequence'
'Create a new :class:`greenlet.greenlet` object and schedule it to DCNL run ``function(*args, **kwargs)``. DCNL This returns a raw :class:`~greenlet.greenlet` which does not have all the useful DCNL methods that :class:`gevent.Greenlet` has. Typically, applications DCNL should prefer :func:`~gevent.spawn`, but this method may DCNL occasionally be useful as an optimization if there are many DCNL greenlets involved. DCNL .. versionchanged:: 1.1b1 DCNL If *function* is not callable, immediately raise a :exc:`TypeError` DCNL instead of spawning a greenlet that will raise an uncaught TypeError. DCNL .. versionchanged:: 1.1rc2 DCNL Accept keyword arguments for ``function`` as previously (incorrectly) DCNL documented. Note that this may incur an additional expense. DCNL .. versionchanged:: 1.1a3 DCNL Verify that ``function`` is callable, raising a TypeError if not. Previously, DCNL the spawned greenlet would have failed the first time it was switched to.'
'indicates whether the given object is a NetProxy'
'Translate an application error to an external Error, if possible. DCNL Args: DCNL error: An ApplicationError to translate. DCNL Returns: DCNL error: app identity API specific error message.'
'Returns the specified argument from a function call. DCNL :param callfunc_node: Node representing a function call to check. DCNL :param int position: position of the argument. DCNL :param str keyword: the keyword of the argument. DCNL :returns: The node representing the argument, None if the argument is not found. DCNL :raises ValueError: if both position and keyword are None. DCNL :raises NoSuchArgumentError: if no argument at the provided position or with DCNL the provided keyword.'
'Will dynamically import a class from a string path DCNL :param class_path: string with class path DCNL :return: class'
'Compute a matrix decomposition. DCNL Compute sgn, scale, M such that P = sgn * scale * dot(M, M.T). DCNL The strategy of determination of eigenvalue negligibility follows DCNL the pinvh contributions from the scikit-learn project to scipy. DCNL Parameters DCNL P : matrix or ndarray DCNL A real symmetric positive or negative (semi)definite input matrix DCNL cond, rcond : float, optional DCNL Cutoff for small eigenvalues. DCNL Singular values smaller than rcond * largest_eigenvalue DCNL are considered negligible. DCNL If None or -1, suitable machine precision is used (default). DCNL lower : bool, optional DCNL Whether the array data is taken from the lower or upper triangle of P. DCNL The default is to take it from the lower triangle. DCNL check_finite : bool, optional DCNL Whether to check that the input matrix contains only finite numbers. DCNL The default is True; disabling may give a performance gain DCNL but may result in problems (crashes, non-termination) if the inputs DCNL contain infinities or NaNs. DCNL Returns DCNL scale : float DCNL induced matrix 2-norm of P DCNL M1, M2 : 2d ndarray DCNL A rectangular ndarray such that P = scale * (dot(M1, M1.T) - dot(M2, M2.T))'
'Unpause a gcode linear move file.'
'Run a function and give results to a Deferred.'
'Return discrete Fourier transform of real or complex sequence. DCNL The returned complex array contains ``y(0), y(1),..., y(n-1)`` where DCNL ``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``. DCNL Parameters DCNL x : array_like DCNL Array to Fourier transform. DCNL n : int, optional DCNL Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is DCNL truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The DCNL default results in ``n = x.shape[axis]``. DCNL axis : int, optional DCNL Axis along which the fft\'s are computed; the default is over the DCNL last axis (i.e., ``axis=-1``). DCNL overwrite_x : bool, optional DCNL If True, the contents of `x` can be destroyed; the default is False. DCNL Returns DCNL z : complex ndarray DCNL with the elements:: DCNL [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even DCNL [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd DCNL where:: DCNL y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1 DCNL Note that ``y(-j) = y(n-j).conjugate()``. DCNL See Also DCNL ifft : Inverse FFT DCNL rfft : FFT of a real sequence DCNL Notes DCNL The packing of the result is "standard": If ``A = fft(a, n)``, then DCNL ``A[0]`` contains the zero-frequency term, ``A[1:n/2]`` contains the DCNL positive-frequency terms, and ``A[n/2:]`` contains the negative-frequency DCNL terms, in order of decreasingly negative frequency. So for an 8-point DCNL transform, the frequencies of the result are [0, 1, 2, 3, -4, -3, -2, -1]. DCNL To rearrange the fft output so that the zero-frequency component is DCNL centered, like [-4, -3, -2, -1,  0,  1,  2,  3], use `fftshift`. DCNL For `n` even, ``A[n/2]`` contains the sum of the positive and DCNL negative-frequency terms.  For `n` even and `x` real, ``A[n/2]`` will DCNL always be real. DCNL Both single and double precision routines are implemented.  Half precision DCNL inputs will be converted to single precision.  Non floating-point inputs DCNL will be converted to double precision.  Long-double precision inputs are DCNL not supported. DCNL This function is most efficient when `n` is a power of two, and least DCNL efficient when `n` is prime. DCNL If the data type of `x` is real, a "real FFT" algorithm is automatically DCNL used, which roughly halves the computation time.  To increase efficiency DCNL a little further, use `rfft`, which does the same calculation, but only DCNL outputs half of the symmetrical spectrum.  If the data is both real and DCNL symmetrical, the `dct` can again double the efficiency, by generating DCNL half of the spectrum from half of the signal. DCNL Examples DCNL >>> from scipy.fftpack import fft, ifft DCNL >>> x = np.arange(5) DCNL >>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy. DCNL True'
'Setup testenvironment for the module: DCNL - Adds dummy home dir tree'
'Create a client with a user already logged in. DCNL Sometimes we recreate the user, because some tests like to DCNL mess with is_active and such.'
'Test sigma_clip of data containing invalid values.'
'Create a gzip cache file for every file that a webserver would DCNL reasonably want to cache (e.g., text type files). DCNL :param pelican: The Pelican instance'
'Make a request. DCNL This function is deprecated as of the 1.7.0 release in favor of DCNL :func:`keystoneclient.session.request` and may be removed in the DCNL 2.0.0 release.'
'.. todo:: DCNL WRITEME'
'Ensure event source mapping exists. DCNL name DCNL The name of the state definition. DCNL EventSourceArn DCNL The Amazon Resource Name (ARN) of the Amazon Kinesis or the Amazon DCNL DynamoDB stream that is the event source. DCNL FunctionName DCNL The Lambda function to invoke when AWS Lambda detects an event on the DCNL stream. DCNL You can specify an unqualified function name (for example, "Thumbnail") DCNL or you can specify Amazon Resource Name (ARN) of the function (for DCNL example, "arn:aws:lambda:us-west-2:account-id:function:ThumbNail"). AWS DCNL Lambda also allows you to specify only the account ID qualifier (for DCNL example, "account-id:Thumbnail"). Note that the length constraint DCNL applies only to the ARN. If you specify only the function name, it is DCNL limited to 64 character in length. DCNL StartingPosition DCNL The position in the stream where AWS Lambda should start reading. DCNL (TRIM_HORIZON | LATEST) DCNL Enabled DCNL Indicates whether AWS Lambda should begin polling the event source. By DCNL default, Enabled is true. DCNL BatchSize DCNL The largest number of records that AWS Lambda will retrieve from your DCNL event source at the time of invoking your function. Your function DCNL receives an event with all the retrieved records. The default is 100 DCNL records. 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) that DCNL contains a dict with region, key and keyid.'
'Export a gcode linear move text.'
'Test whether an error is raised when the number of feature changes DCNL between two partial fit'
'Handle key codes'
'internet gateway fetch by id'
'This function executes the rpc provided as arguments on the junos device. DCNL The returned data can be stored in a file whose destination can be DCNL specified with \'dest\' keyword in the arguments. DCNL Usage: DCNL .. code-block:: bash DCNL salt \'device\' junos.rpc \'get_config\' \'text\' filter=\'<configuration><system/></configuration>\' DCNL salt \'device\' junos.rpc \'get-interface-information\' \'/home/user/interface.log\' interface_name=\'lo0\' terse=True DCNL Options: DCNL * cmd: the rpc to be executed DCNL * dest: destination file where the rpc ouput is dumped DCNL * format: the format in which the rpc reply must be stored in file specified in the dest (used only when dest is specified) DCNL * args: other arguments as taken by rpc call of PyEZ DCNL * kwargs: keyworded arguments taken by rpc call of PyEZ'
'Parse a BASEML results file.'
'Exports stats in JSON format.'
'Nodes pages.'
'Strips all [X]HTML tags.'
'Delete a specific image resource by name.'
'Write processing history to file.'
'Test PackageFinder finds pre-releases if asked to.'
'Get the status of all the firewall profiles DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' firewall.get_config'
'Fast Solexa FASTQ to Solexa FASTQ conversion (PRIVATE). DCNL Useful for removing line wrapping and the redundant second identifier DCNL on the plus lines. Will check also check the quality string is valid. DCNL Avoids creating SeqRecord and Seq objects in order to speed up this DCNL conversion.'
'Check whether the ``item`` matches the comp ``filter_``. DCNL If ``scope`` is ``"collection"``, the filter is applied on the DCNL item\'s collection. Otherwise, it\'s applied on the item. DCNL See rfc4791-9.7.1.'
'Efficient subpixel image translation registration by cross-correlation. DCNL This code gives the same precision as the FFT upsampled cross-correlation DCNL in a fraction of the computation time and with reduced memory requirements. DCNL It obtains an initial estimate of the cross-correlation peak by an FFT and DCNL then refines the shift estimation by upsampling the DFT only in a small DCNL neighborhood of that estimate by means of a matrix-multiply DFT. DCNL Parameters DCNL src_image : ndarray DCNL Reference image. DCNL target_image : ndarray DCNL Image to register.  Must be same dimensionality as ``src_image``. DCNL upsample_factor : int, optional DCNL Upsampling factor. Images will be registered to within DCNL ``1 / upsample_factor`` of a pixel. For example DCNL ``upsample_factor == 20`` means the images will be registered DCNL within 1/20th of a pixel.  Default is 1 (no upsampling) DCNL space : string, one of "real" or "fourier", optional DCNL Defines how the algorithm interprets input data.  "real" means data DCNL will be FFT\'d to compute the correlation, while "fourier" data will DCNL bypass FFT of input data.  Case insensitive. DCNL Returns DCNL shifts : ndarray DCNL Shift vector (in pixels) required to register ``target_image`` with DCNL ``src_image``.  Axis ordering is consistent with numpy (e.g. Z, Y, X) DCNL error : float DCNL Translation invariant normalized RMS error between ``src_image`` and DCNL ``target_image``. DCNL phasediff : float DCNL Global phase difference between the two images (should be DCNL zero if images are non-negative). DCNL References DCNL .. [1] Manuel Guizar-Sicairos, Samuel T. Thurman, and James R. Fienup, DCNL "Efficient subpixel image registration algorithms," DCNL Optics Letters 33, 156-158 (2008). DOI:10.1364/OL.33.000156 DCNL .. [2] James R. Fienup, "Invariant error metrics for image reconstruction" DCNL Optics Letters 36, 8352-8357 (1997). DOI:10.1364/AO.36.008352'
'Award the specific badge to the user if they\'ve earned it.'
'Get a registered .exe'
'JSON decoder that does ugly first-level datetime handling'
'Validate and convert hex color to XY space.'
'If the value of the kodi setting is zero, then remove the DCNL entry from the config.txt. This should be used where zero is DCNL the default (pi natural) value.'
'Construct a ring deriving generators and domain from options and input expressions. DCNL Parameters DCNL exprs : :class:`Expr` or sequence of :class:`Expr` (sympifiable) DCNL symbols : sequence of :class:`Symbol`/:class:`Expr` DCNL options : keyword arguments understood by :class:`Options` DCNL Examples DCNL >>> from sympy.core import symbols DCNL >>> from sympy.polys.rings import sring DCNL >>> from sympy.polys.domains import ZZ DCNL >>> from sympy.polys.orderings import lex DCNL >>> x, y, z = symbols("x,y,z") DCNL >>> R, f = sring(x + 2*y + 3*z) DCNL >>> R DCNL Polynomial ring in x, y, z over ZZ with lex order DCNL >>> f DCNL x + 2*y + 3*z DCNL >>> type(_) DCNL <class \'sympy.polys.rings.PolyElement\'>'
'Get the inset loops, which might overlap.'
'Setup logging for the script'
'Maximum size for TCP send buffers DCNL See guess_kern_ipc_maxsockbuf().'
'get opt'
'Generate a zip archive containing all of the source files.'
'Get the repository constructor.'
'Parse a querystring and return it as :class:`MultiDict`.  There is a DCNL difference in key decoding on different Python versions.  On Python 3 DCNL keys will always be fully decoded whereas on Python 2, keys will DCNL remain bytestrings if they fit into ASCII.  On 2.x keys can be forced DCNL to be unicode by setting `decode_keys` to `True`. DCNL If the charset is set to `None` no unicode decoding will happen and DCNL raw bytes will be returned. DCNL Per default a missing value for a key will default to an empty key.  If DCNL you don\'t want that behavior you can set `include_empty` to `False`. DCNL Per default encoding errors are ignored.  If you want a different behavior DCNL you can set `errors` to ``\'replace\'`` or ``\'strict\'``.  In strict mode a DCNL `HTTPUnicodeError` is raised. DCNL .. versionchanged:: 0.5 DCNL In previous versions ";" and "&" could be used for url decoding. DCNL This changed in 0.5 where only "&" is supported.  If you want to DCNL use ";" instead a different `separator` can be provided. DCNL The `cls` parameter was added. DCNL :param s: a string with the query string to decode. DCNL :param charset: the charset of the query string.  If set to `None` DCNL no unicode decoding will take place. DCNL :param decode_keys: Used on Python 2.x to control whether keys should DCNL be forced to be unicode objects.  If set to `True` DCNL then keys will be unicode in all cases. Otherwise, DCNL they remain `str` if they fit into ASCII. DCNL :param include_empty: Set to `False` if you don\'t want empty values to DCNL appear in the dict. DCNL :param errors: the decoding error behavior. DCNL :param separator: the pair separator to be used, defaults to ``&`` DCNL :param cls: an optional dict class to use.  If this is not specified DCNL or `None` the default :class:`MultiDict` is used.'
'Return a tuple with a tag name and a (possibly empty) attribute, DCNL applying the conversions specified in TAGS_TO_MODIFY and checking DCNL that the tag is safe for a XML document.'
'Load and return the boston house-prices dataset (regression). DCNL Samples total                 506 DCNL Dimensionality                 13 DCNL Features           real, positive DCNL Targets             real 5. - 50. DCNL Parameters DCNL return_X_y : boolean, default=False. DCNL If True, returns ``(data, target)`` instead of a Bunch object. DCNL See below for more information about the `data` and `target` object. DCNL .. versionadded:: 0.18 DCNL Returns DCNL data : Bunch DCNL Dictionary-like object, the interesting attributes are: DCNL \'data\', the data to learn, \'target\', the regression targets, DCNL and \'DESCR\', the full description of the dataset. DCNL (data, target) : tuple if ``return_X_y`` is True DCNL .. versionadded:: 0.18 DCNL Examples DCNL >>> from sklearn.datasets import load_boston DCNL >>> boston = load_boston() DCNL >>> print(boston.data.shape) DCNL (506, 13)'
'Ensure an object is not inheriting ACLs from its parent'
'Return the load data that marks a specified jid'
'Translate a column number to name (e.g. 1->\'A\', etc.).'
'Updates global state when a task has been reserved.'
'Pretty print the CSS represented as a string in raw'
'Accept CSP reports and log them.'
'Convert any true/false string to its corresponding boolean value. DCNL Value is case insensitive.'
'Format the version.'
'Decorator that ensures that the file instance isn\'t closed when the DCNL function is run.'
'Evaluation.'
'Ignores everything between ``{% comment %}`` and ``{% endcomment %}``.'
'Make sure we can find the full path to ls.'
'Get the area under the curve'
'Return an ASCII-only JSON representation of a Python string'
'.. versionadded:: 2016.11.0 DCNL This function is used to remember that DCNL an event indicating that a reboot is required was witnessed. DCNL This function relies on the salt-minion\'s ability to create the following DCNL volatile registry key in the *HKLM* hive: DCNL *SYSTEM\\CurrentControlSet\\Services\\salt-minion\\Volatile-Data* DCNL Because this registry key is volatile, it will not persist DCNL beyond the current boot session. DCNL Also, in the scope of this key, the name *\'Reboot required\'* will be DCNL assigned the value of *1*. DCNL (For the time being, this this function is being used DCNL whenever an install completes with exit code 3010 and DCNL this usage can be extended where appropriate in the future.) DCNL :return: A boolean indicating whether or not the salt minion was DCNL able to perform the necessary registry operations. DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' system.set_reboot_required_witnessed'
'Prepare one image for evaluation. DCNL If height and width are specified it would output an image with that size by DCNL applying resize_bilinear. DCNL If central_fraction is specified it would cropt the central fraction of the DCNL input image. DCNL Args: DCNL image: 3-D Tensor of image. If dtype is tf.float32 then the range should be DCNL [0, 1], otherwise it would converted to tf.float32 assuming that the range DCNL is [0, MAX], where MAX is largest positive representable number for DCNL int(8/16/32) data type (see `tf.image.convert_image_dtype` for details) DCNL height: integer DCNL width: integer DCNL central_fraction: Optional Float, fraction of the image to crop. DCNL scope: Optional scope for name_scope. DCNL Returns: DCNL 3-D float Tensor of prepared image.'
'Send e-mail when a user is registered. DCNL Listens for new user registrations and sends a new user registration DCNL e-mail to administrators, if this type of notification is enabled (through DCNL ``mail_send_new_user_mail`` site configuration).'
'Returns whether the source for this module is directly in an astropy DCNL source distribution or checkout.'
'Save data into TFRecord'
'Saves an object to a disk file. DCNL Args: DCNL obj: saved object DCNL f: a file-like object (has to implement fileno that returns a file descriptor) DCNL or a string containing a file name DCNL pickle_module: module used for pickling metadata and objects DCNL pickle_protocol: can be specified to override the default protocol'
'Compute the Pearson\' score between 2 lists of vectors.'
'Display a PROMPT string and a text entry field with a DEFAULT string. DCNL Return the contents of the text entry field when the user clicks the DCNL OK button or presses Return. DCNL Return None when the user clicks the Cancel button. DCNL If omitted, DEFAULT is empty. DCNL The PROMPT and DEFAULT strings, as well as the return value, DCNL can be at most 255 characters long.'
'Return (format, stream) of given stream.'
'N320 - Log messages require translation.'
'Join and joinable files in \'workdir\' to \'workdir_complete\' and DCNL when successful, delete originals'
'Validates a client id. DCNL Args: DCNL client_id: The client id provided by the application. DCNL Returns: DCNL If the client id is of type str, returns the original client id. DCNL If the client id is of type unicode, returns the id encoded to utf-8. DCNL Raises: DCNL InvalidChannelClientIdError: if client id is not an instance of str or DCNL unicode, or if the (utf-8 encoded) string is longer than 64 characters.'
'This function has been moved to matplotlib.mlab -- please import DCNL it from there'
'0 / x -> 0'
'>>> obj = test_nested(1, 2, 3) DCNL >>> [i() for i in obj] DCNL [1, 2, 3, 4]'
'Makes fna file from sff file.'
'Perform E-step for each (chunk_no, chunk, model) 3-tuple from the DCNL input queue, placing the resulting state into the result queue.'
'Aux. function to fit _SearchLight in parallel. DCNL Fit a clone estimator to each slice of data. DCNL Parameters DCNL base_estimator : object DCNL The base estimator to iteratively fit on a subset of the dataset. DCNL X : array, shape (n_samples, nd_features, n_estimators) DCNL The target data. The feature dimension can be multidimensional e.g. DCNL X.shape = (n_samples, n_features_1, n_features_2, n_estimators) DCNL y : array, shape (n_sample, ) DCNL The target values. DCNL Returns DCNL estimators_ : list of estimators DCNL The fitted estimators.'
'Returns the tensor corresponding to the permutation ``g`` DCNL For further details, see the method in ``TIDS`` with the same name.'
'Returns a df with the results of the VBENCH job associated with the travis build'
'Gets hexadmecimal md5 hash of a string'
'Test _SearchLight'
'Parse the return value of IPMI command into dict DCNL :param output: output of the execution of IPMI command DCNL :param template: a dict that contains the expected items of DCNL IPMI command and its length.'
'Get a timestamp from a date in python 3 and python 2'
'Get last metadata defined for a specified repository from the database.'
'Test string validation.'
'Recursively list all files matching \'pattern\'. This does not return directories.'
'Delegates depending on the given markers to the right extraction method. DCNL :param content: Presplitted lines of the source-code-string. DCNL :param line:    Line where the documentation comment starts (behind the DCNL start marker). Zero-based. DCNL :param column:  Column where the documentation comment starts (behind the DCNL start marker). Zero-based. DCNL :param markers: The documentation identifying markers. DCNL :return:        If the comment matched layout a triple with end-of-comment DCNL line, column and the extracted documentation. If not DCNL matched, returns None.'
'Convert \'date_time\' to IMAP4 INTERNALDATE representation. DCNL Return string in form: \'"DD-Mmm-YYYY HH:MM:SS +HHMM"\''
'Parses a string containing only 0\'s and 1\'s and return a Python list object.'
'This code is based on os.path.relpath in the Python 2.6 distribution, DCNL included here for compatibility with Python 2.5'
'Require several Arch Linux packages to be installed. DCNL Example:: DCNL from fabtools import require DCNL require.arch.packages([ DCNL \'foo\', DCNL \'bar\', DCNL \'baz\','
'Constructs MirrorView name for volume.'
'Allocate a floating IP DCNL .. versionadded:: 2016.3.0'
'Get the top l10n contributors for the KB.'
'Check that all items of arrays differ in at most N Units in the Last Place. DCNL Args: DCNL a(numpy.ndarray or cupy.ndarray): The actual object to check. DCNL b(numpy.ndarray or cupy.ndarray): The desired, expected object. DCNL maxulp(int): The maximum number of units in the last place DCNL that elements of ``a`` and ``b`` can differ. DCNL dtype(numpy.dtype): Data-type to convert ``a`` and ``b`` to if given. DCNL .. seealso:: :func:`numpy.testing.assert_array_max_ulp`'
'The restful handler for assets. DCNL It allows retrieval of all the assets (as an HTML page), as well as uploading new assets, DCNL deleting assets, and changing the "locked" state of an asset. DCNL GET DCNL html: return an html page which will show all course assets. Note that only the asset container DCNL is returned and that the actual assets are filled in with a client-side request. DCNL json: returns a page of assets. The following parameters are supported: DCNL page: the desired page of results (defaults to 0) DCNL page_size: the number of items per page (defaults to 50) DCNL sort: the asset field to sort by (defaults to "date_added") DCNL direction: the sort direction (defaults to "descending") DCNL POST DCNL json: create (or update?) an asset. The only updating that can be done is changing the lock state. DCNL PUT DCNL json: update the locked state of an asset DCNL DELETE DCNL json: delete an asset'
'Compute the coefficients for a 1-d Savitzky-Golay FIR filter. DCNL Parameters DCNL window_length : int DCNL The length of the filter window (i.e. the number of coefficients). DCNL `window_length` must be an odd positive integer. DCNL polyorder : int DCNL The order of the polynomial used to fit the samples. DCNL `polyorder` must be less than `window_length`. DCNL deriv : int, optional DCNL The order of the derivative to compute.  This must be a DCNL nonnegative integer.  The default is 0, which means to filter DCNL the data without differentiating. DCNL delta : float, optional DCNL The spacing of the samples to which the filter will be applied. DCNL This is only used if deriv > 0. DCNL pos : int or None, optional DCNL If pos is not None, it specifies evaluation position within the DCNL window.  The default is the middle of the window. DCNL use : str, optional DCNL Either \'conv\' or \'dot\'.  This argument chooses the order of the DCNL coefficients.  The default is \'conv\', which means that the DCNL coefficients are ordered to be used in a convolution.  With DCNL use=\'dot\', the order is reversed, so the filter is applied by DCNL dotting the coefficients with the data set. DCNL Returns DCNL coeffs : 1-d ndarray DCNL The filter coefficients. DCNL References DCNL A. Savitzky, M. J. E. Golay, Smoothing and Differentiation of Data by DCNL Simplified Least Squares Procedures. Analytical Chemistry, 1964, 36 (8), DCNL pp 1627-1639. DCNL See Also DCNL savgol_filter DCNL Notes DCNL .. versionadded:: 0.14.0 DCNL Examples DCNL >>> from scipy.signal import savgol_coeffs DCNL >>> savgol_coeffs(5, 2) DCNL array([-0.08571429,  0.34285714,  0.48571429,  0.34285714, -0.08571429]) DCNL >>> savgol_coeffs(5, 2, deriv=1) DCNL array([  2.00000000e-01,   1.00000000e-01,   2.00607895e-16, DCNL -1.00000000e-01,  -2.00000000e-01]) DCNL Note that use=\'dot\' simply reverses the coefficients. DCNL >>> savgol_coeffs(5, 2, pos=3) DCNL array([ 0.25714286,  0.37142857,  0.34285714,  0.17142857, -0.14285714]) DCNL >>> savgol_coeffs(5, 2, pos=3, use=\'dot\') DCNL array([-0.14285714,  0.17142857,  0.34285714,  0.37142857,  0.25714286]) DCNL `x` contains data from the parabola x = t**2, sampled at DCNL t = -1, 0, 1, 2, 3.  `c` holds the coefficients that will compute the DCNL derivative at the last position.  When dotted with `x` the result should DCNL be 6. DCNL >>> x = np.array([1, 0, 1, 4, 9]) DCNL >>> c = savgol_coeffs(5, 2, pos=4, deriv=1, use=\'dot\') DCNL >>> c.dot(x) DCNL 6.0000000000000018'
'yaml: clamav DCNL Check files with ClamAV, an open source antivirus engine. DCNL Requires the Jenkins :jenkins-wiki:`ClamAV Plugin <ClamAV+Plugin>`. DCNL :arg str includes: Comma seperated list of files that should be scanned. DCNL Must be set for ClamAV to check for artifacts. (default \'\') DCNL :arg str excludes: Comma seperated list of files that should be ignored DCNL (default \'\') DCNL Full Example: DCNL .. literalinclude:: /../../tests/publishers/fixtures/clamav-full.yaml DCNL :language: yaml DCNL Minimal Example: DCNL .. literalinclude:: /../../tests/publishers/fixtures/clamav-minimal.yaml DCNL :language: yaml'
'Only load the module if nftables is installed'
'compares master tree to subsampled_tree, modifies master in place DCNL this calculates bootstrap support of each nontip node in the master tree DCNL a given master_tree_node is supported if there exists a node in subsampled DCNL tree where sub_tree_node.tips == master_tree_node.tips (by name) DCNL each subsampled tree is first modified to remove tips and branches leading DCNL to them if the tip isn\'t in the master tree DCNL not specific to bootstrap, does node support for trees generated in any DCNL manner (e.g.: jackknifing) DCNL master is modified to have node.bootstrap_support incremented by 1 if DCNL subsampled tree has support for that node'
'Returns the WSGI filter for use with paste.deploy.'
'Retrieve/query a path within the del.icio.us API. DCNL This implements a minimum interval between calls to avoid DCNL throttling. [#]_ Use param \'throttle\' to turn this behaviour off. DCNL @todo: back off on 503\'s (HTTPError, URLError? @todo: testing). DCNL Returned XML does not always correspond with given del.icio.us examples DCNL @todo: (cf. help/api/... and post\'s attributes) DCNL .. [#] http://del.icio.us/help/api/'
'After the function finishes, resets the value of mpmath.mp.dps to DCNL the value it had before the function was run.'
'Check existence of given path against list of path patterns DCNL The pattern definition is the as fnmatch.fnmatch.'
'Minimization of scalar function of one or more variables. DCNL In general, the optimization problems are of the form:: DCNL minimize f(x) subject to DCNL g_i(x) >= 0,  i = 1,...,m DCNL h_j(x)  = 0,  j = 1,...,p DCNL where x is a vector of one or more variables. DCNL ``g_i(x)`` are the inequality constraints. DCNL ``h_j(x)`` are the equality constrains. DCNL Optionally, the lower and upper bounds for each element in x can also be DCNL specified using the `bounds` argument. DCNL Parameters DCNL fun : callable DCNL Objective function. DCNL x0 : ndarray DCNL Initial guess. DCNL args : tuple, optional DCNL Extra arguments passed to the objective function and its DCNL derivatives (Jacobian, Hessian). DCNL method : str or callable, optional DCNL Type of solver.  Should be one of DCNL - \'Nelder-Mead\' :ref:`(see here) <optimize.minimize-neldermead>` DCNL - \'Powell\'      :ref:`(see here) <optimize.minimize-powell>` DCNL - \'CG\'          :ref:`(see here) <optimize.minimize-cg>` DCNL - \'BFGS\'        :ref:`(see here) <optimize.minimize-bfgs>` DCNL - \'Newton-CG\'   :ref:`(see here) <optimize.minimize-newtoncg>` DCNL - \'L-BFGS-B\'    :ref:`(see here) <optimize.minimize-lbfgsb>` DCNL - \'TNC\'         :ref:`(see here) <optimize.minimize-tnc>` DCNL - \'COBYLA\'      :ref:`(see here) <optimize.minimize-cobyla>` DCNL - \'SLSQP\'       :ref:`(see here) <optimize.minimize-slsqp>` DCNL - \'dogleg\'      :ref:`(see here) <optimize.minimize-dogleg>` DCNL - \'trust-ncg\'   :ref:`(see here) <optimize.minimize-trustncg>` DCNL - custom - a callable object (added in version 0.14.0), DCNL see below for description. DCNL If not given, chosen to be one of ``BFGS``, ``L-BFGS-B``, ``SLSQP``, DCNL depending if the problem has constraints or bounds. DCNL jac : bool or callable, optional DCNL Jacobian (gradient) of objective function. Only for CG, BFGS, DCNL Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg. DCNL If `jac` is a Boolean and is True, `fun` is assumed to return the DCNL gradient along with the objective function. If False, the DCNL gradient will be estimated numerically. DCNL `jac` can also be a callable returning the gradient of the DCNL objective. In this case, it must accept the same arguments as `fun`. DCNL hess, hessp : callable, optional DCNL Hessian (matrix of second-order derivatives) of objective function or DCNL Hessian of objective function times an arbitrary vector p.  Only for DCNL Newton-CG, dogleg, trust-ncg. DCNL Only one of `hessp` or `hess` needs to be given.  If `hess` is DCNL provided, then `hessp` will be ignored.  If neither `hess` nor DCNL `hessp` is provided, then the Hessian product will be approximated DCNL using finite differences on `jac`. `hessp` must compute the Hessian DCNL times an arbitrary vector. DCNL bounds : sequence, optional DCNL Bounds for variables (only for L-BFGS-B, TNC and SLSQP). DCNL ``(min, max)`` pairs for each element in ``x``, defining DCNL the bounds on that parameter. Use None for one of ``min`` or DCNL ``max`` when there is no bound in that direction. DCNL constraints : dict or sequence of dict, optional DCNL Constraints definition (only for COBYLA and SLSQP). DCNL Each constraint is defined in a dictionary with fields: DCNL type : str DCNL Constraint type: \'eq\' for equality, \'ineq\' for inequality. DCNL fun : callable DCNL The function defining the constraint. DCNL jac : callable, optional DCNL The Jacobian of `fun` (only for SLSQP). DCNL args : sequence, optional DCNL Extra arguments to be passed to the function and Jacobian. DCNL Equality constraint means that the constraint function result is to DCNL be zero whereas inequality means that it is to be non-negative. DCNL Note that COBYLA only supports inequality constraints. DCNL tol : float, optional DCNL Tolerance for termination. For detailed control, use solver-specific DCNL options. DCNL options : dict, optional DCNL A dictionary of solver options. All methods accept the following DCNL generic options: DCNL maxiter : int DCNL Maximum number of iterations to perform. DCNL disp : bool DCNL Set to True to print convergence messages. DCNL For method-specific options, see :func:`show_options()`. DCNL callback : callable, optional DCNL Called after each iteration, as ``callback(xk)``, where ``xk`` is the DCNL current parameter vector. DCNL Returns DCNL res : OptimizeResult DCNL The optimization result represented as a ``OptimizeResult`` object. DCNL Important attributes are: ``x`` the solution array, ``success`` a DCNL Boolean flag indicating if the optimizer exited successfully and DCNL ``message`` which describes the cause of the termination. See DCNL `OptimizeResult` for a description of other attributes. DCNL See also DCNL minimize_scalar : Interface to minimization algorithms for scalar DCNL univariate functions DCNL show_options : Additional options accepted by the solvers DCNL Notes DCNL This section describes the available solvers that can be selected by the DCNL \'method\' parameter. The default method is *BFGS*. DCNL **Unconstrained minimization** DCNL Method :ref:`Nelder-Mead <optimize.minimize-neldermead>` uses the DCNL Simplex algorithm [1]_, [2]_. This algorithm is robust in many DCNL applications. However, if numerical computation of derivative can be DCNL trusted, other algorithms using the first and/or second derivatives DCNL information might be preferred for their better performance in DCNL general. DCNL Method :ref:`Powell <optimize.minimize-powell>` is a modification DCNL of Powell\'s method [3]_, [4]_ which is a conjugate direction DCNL method. It performs sequential one-dimensional minimizations along DCNL each vector of the directions set (`direc` field in `options` and DCNL `info`), which is updated at each iteration of the main DCNL minimization loop. The function need not be differentiable, and no DCNL derivatives are taken. DCNL Method :ref:`CG <optimize.minimize-cg>` uses a nonlinear conjugate DCNL gradient algorithm by Polak and Ribiere, a variant of the DCNL Fletcher-Reeves method described in [5]_ pp.  120-122. Only the DCNL first derivatives are used. DCNL Method :ref:`BFGS <optimize.minimize-bfgs>` uses the quasi-Newton DCNL method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS) [5]_ DCNL pp. 136. It uses the first derivatives only. BFGS has proven good DCNL performance even for non-smooth optimizations. This method also DCNL returns an approximation of the Hessian inverse, stored as DCNL `hess_inv` in the OptimizeResult object. DCNL Method :ref:`Newton-CG <optimize.minimize-newtoncg>` uses a DCNL Newton-CG algorithm [5]_ pp. 168 (also known as the truncated DCNL Newton method). It uses a CG method to the compute the search DCNL direction. See also *TNC* method for a box-constrained DCNL minimization with a similar algorithm. DCNL Method :ref:`dogleg <optimize.minimize-dogleg>` uses the dog-leg DCNL trust-region algorithm [5]_ for unconstrained minimization. This DCNL algorithm requires the gradient and Hessian; furthermore the DCNL Hessian is required to be positive definite. DCNL Method :ref:`trust-ncg <optimize.minimize-trustncg>` uses the DCNL Newton conjugate gradient trust-region algorithm [5]_ for DCNL unconstrained minimization. This algorithm requires the gradient DCNL and either the Hessian or a function that computes the product of DCNL the Hessian with a given vector. DCNL **Constrained minimization** DCNL Method :ref:`L-BFGS-B <optimize.minimize-lbfgsb>` uses the L-BFGS-B DCNL algorithm [6]_, [7]_ for bound constrained minimization. DCNL Method :ref:`TNC <optimize.minimize-tnc>` uses a truncated Newton DCNL algorithm [5]_, [8]_ to minimize a function with variables subject DCNL to bounds. This algorithm uses gradient information; it is also DCNL called Newton Conjugate-Gradient. It differs from the *Newton-CG* DCNL method described above as it wraps a C implementation and allows DCNL each variable to be given upper and lower bounds. DCNL Method :ref:`COBYLA <optimize.minimize-cobyla>` uses the DCNL Constrained Optimization BY Linear Approximation (COBYLA) method DCNL [9]_, [10]_, [11]_. The algorithm is based on linear DCNL approximations to the objective function and each constraint. The DCNL method wraps a FORTRAN implementation of the algorithm. The DCNL constraints functions \'fun\' may return either a single number DCNL or an array or list of numbers. DCNL Method :ref:`SLSQP <optimize.minimize-slsqp>` uses Sequential DCNL Least SQuares Programming to minimize a function of several DCNL variables with any combination of bounds, equality and inequality DCNL constraints. The method wraps the SLSQP Optimization subroutine DCNL originally implemented by Dieter Kraft [12]_. Note that the DCNL wrapper handles infinite values in bounds by converting them into DCNL large floating values. DCNL **Custom minimizers** DCNL It may be useful to pass a custom minimization method, for example DCNL when using a frontend to this method such as `scipy.optimize.basinhopping` DCNL or a different library.  You can simply pass a callable as the ``method`` DCNL parameter. DCNL The callable is called as ``method(fun, x0, args, **kwargs, **options)`` DCNL where ``kwargs`` corresponds to any other parameters passed to `minimize` DCNL (such as `callback`, `hess`, etc.), except the `options` dict, which has DCNL its contents also passed as `method` parameters pair by pair.  Also, if DCNL `jac` has been passed as a bool type, `jac` and `fun` are mangled so that DCNL `fun` returns just the function values and `jac` is converted to a function DCNL returning the Jacobian.  The method shall return an ``OptimizeResult`` DCNL object. DCNL The provided `method` callable must be able to accept (and possibly ignore) DCNL arbitrary parameters; the set of parameters accepted by `minimize` may DCNL expand in future versions and then these parameters will be passed to DCNL the method.  You can find an example in the scipy.optimize tutorial. DCNL .. versionadded:: 0.11.0 DCNL References DCNL .. [1] Nelder, J A, and R Mead. 1965. A Simplex Method for Function DCNL Minimization. The Computer Journal 7: 308-13. DCNL .. [2] Wright M H. 1996. Direct search methods: Once scorned, now DCNL respectable, in Numerical Analysis 1995: Proceedings of the 1995 DCNL Dundee Biennial Conference in Numerical Analysis (Eds. D F DCNL Griffiths and G A Watson). Addison Wesley Longman, Harlow, UK. DCNL 191-208. DCNL .. [3] Powell, M J D. 1964. An efficient method for finding the minimum of DCNL a function of several variables without calculating derivatives. The DCNL Computer Journal 7: 155-162. DCNL .. [4] Press W, S A Teukolsky, W T Vetterling and B P Flannery. DCNL Numerical Recipes (any edition), Cambridge University Press. DCNL .. [5] Nocedal, J, and S J Wright. 2006. Numerical Optimization. DCNL Springer New York. DCNL .. [6] Byrd, R H and P Lu and J. Nocedal. 1995. A Limited Memory DCNL Algorithm for Bound Constrained Optimization. SIAM Journal on DCNL Scientific and Statistical Computing 16 (5): 1190-1208. DCNL .. [7] Zhu, C and R H Byrd and J Nocedal. 1997. L-BFGS-B: Algorithm DCNL 778: L-BFGS-B, FORTRAN routines for large scale bound constrained DCNL optimization. ACM Transactions on Mathematical Software 23 (4): DCNL 550-560. DCNL .. [8] Nash, S G. Newton-Type Minimization Via the Lanczos Method. DCNL 1984. SIAM Journal of Numerical Analysis 21: 770-778. DCNL .. [9] Powell, M J D. A direct search optimization method that models DCNL the objective and constraint functions by linear interpolation. DCNL 1994. Advances in Optimization and Numerical Analysis, eds. S. Gomez DCNL and J-P Hennart, Kluwer Academic (Dordrecht), 51-67. DCNL .. [10] Powell M J D. Direct search algorithms for optimization DCNL calculations. 1998. Acta Numerica 7: 287-336. DCNL .. [11] Powell M J D. A view of algorithms for optimization without DCNL derivatives. 2007.Cambridge University Technical Report DAMTP DCNL 2007/NA03 DCNL .. [12] Kraft, D. A software package for sequential quadratic DCNL programming. 1988. Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace DCNL Center -- Institute for Flight Mechanics, Koln, Germany. DCNL Examples DCNL Let us consider the problem of minimizing the Rosenbrock function. This DCNL function (and its respective derivatives) is implemented in `rosen` DCNL (resp. `rosen_der`, `rosen_hess`) in the `scipy.optimize`. DCNL >>> from scipy.optimize import minimize, rosen, rosen_der DCNL A simple application of the *Nelder-Mead* method is: DCNL >>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2] DCNL >>> res = minimize(rosen, x0, method=\'Nelder-Mead\', tol=1e-6) DCNL >>> res.x DCNL array([ 1.,  1.,  1.,  1.,  1.]) DCNL Now using the *BFGS* algorithm, using the first derivative and a few DCNL options: DCNL >>> res = minimize(rosen, x0, method=\'BFGS\', jac=rosen_der, DCNL ...                options={\'gtol\': 1e-6, \'disp\': True}) DCNL Optimization terminated successfully. DCNL Current function value: 0.000000 DCNL Iterations: 26 DCNL Function evaluations: 31 DCNL Gradient evaluations: 31 DCNL >>> res.x DCNL array([ 1.,  1.,  1.,  1.,  1.]) DCNL >>> print(res.message) DCNL Optimization terminated successfully. DCNL >>> res.hess_inv DCNL array([[ 0.00749589,  0.01255155,  0.02396251,  0.04750988,  0.09495377],  # may vary DCNL [ 0.01255155,  0.02510441,  0.04794055,  0.09502834,  0.18996269], DCNL [ 0.02396251,  0.04794055,  0.09631614,  0.19092151,  0.38165151], DCNL [ 0.04750988,  0.09502834,  0.19092151,  0.38341252,  0.7664427 ], DCNL [ 0.09495377,  0.18996269,  0.38165151,  0.7664427,   1.53713523]]) DCNL Next, consider a minimization problem with several constraints (namely DCNL Example 16.4 from [5]_). The objective function is: DCNL >>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 DCNL There are three constraints defined as: DCNL >>> cons = ({\'type\': \'ineq\', \'fun\': lambda x:  x[0] - 2 * x[1] + 2}, DCNL ...         {\'type\': \'ineq\', \'fun\': lambda x: -x[0] - 2 * x[1] + 6}, DCNL ...         {\'type\': \'ineq\', \'fun\': lambda x: -x[0] + 2 * x[1] + 2}) DCNL And variables must be positive, hence the following bounds: DCNL >>> bnds = ((0, None), (0, None)) DCNL The optimization problem is solved using the SLSQP method as: DCNL >>> res = minimize(fun, (2, 0), method=\'SLSQP\', bounds=bnds, DCNL ...                constraints=cons) DCNL It should converge to the theoretical solution (1.4 ,1.7).'
'This is a nasty function: it has a max in a spike near -10, and a long DCNL asymptote that is easy to find, but guides hill-climbing approaches away DCNL from the true max. DCNL The second peak is at x=-10. DCNL The prior mean is 0.'
'Returns true if node is inside the name of an except handler.'
'Serialize ``obj`` as a JSON formatted stream to ``fp`` (a DCNL ``.write()``-supporting file-like object). DCNL If ``skipkeys`` is true then ``dict`` keys that are not basic types DCNL (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) DCNL will be skipped instead of raising a ``TypeError``. DCNL If ``ensure_ascii`` is false, then the some chunks written to ``fp`` DCNL may be ``unicode`` instances, subject to normal Python ``str`` to DCNL ``unicode`` coercion rules. Unless ``fp.write()`` explicitly DCNL understands ``unicode`` (as in ``codecs.getwriter()``) this is likely DCNL to cause an error. DCNL If ``check_circular`` is false, then the circular reference check DCNL for container types will be skipped and a circular reference will DCNL result in an ``OverflowError`` (or worse). DCNL If ``allow_nan`` is false, then it will be a ``ValueError`` to DCNL serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) DCNL in strict compliance of the JSON specification, instead of using the DCNL JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). DCNL If *indent* is a string, then JSON array elements and object members DCNL will be pretty-printed with a newline followed by that string repeated DCNL for each level of nesting. ``None`` (the default) selects the most compact DCNL representation without any newlines. For backwards compatibility with DCNL versions of simplejson earlier than 2.1.0, an integer is also accepted DCNL and is converted to a string with that many spaces. DCNL If ``separators`` is an ``(item_separator, dict_separator)`` tuple DCNL then it will be used instead of the default ``(\', \', \': \')`` separators. DCNL ``(\',\', \':\')`` is the most compact JSON representation. DCNL ``encoding`` is the character encoding for str instances, default is UTF-8. DCNL ``default(obj)`` is a function that should return a serializable version DCNL of obj or raise TypeError. The default simply raises TypeError. DCNL If *use_decimal* is true (default: ``True``) then decimal.Decimal DCNL will be natively serialized to JSON with full precision. DCNL To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the DCNL ``.default()`` method to serialize additional types), specify it with DCNL the ``cls`` kwarg.'
'Load macros from `source_module` in the namespace of DCNL `target_module`. `assignments` maps old names to new names, but is DCNL ignored if `all_macros` is true. If `prefix` is nonempty, it is DCNL prepended to the name of each imported macro. (This means you get DCNL macros named things like "mymacromodule.mymacro", which looks like DCNL an attribute of a module, although it\'s actually just a symbol DCNL with a period in its name.) DCNL This function is called from the `require` special form in the compiler.'
'Get current libvlc_state of media list player. DCNL @param p_mlp: media list player instance. DCNL @return: libvlc_state_t for media list player.'
'Wrapper around c_init that initializes py_name to Py_None.'
'evaluates the exponential of an interval'
'Extract (for now) the usernames and passwords from Basic DCNL authorization headers'
'Setup a library namespace, with the appropriate top root module name. DCNL Perform all the necessary setup so that all the packages at DCNL \'base_path\' can be imported via "import root_module_name.package". DCNL :param base_path: Base path for the module. DCNL :param root_module_name: Top level name for the module.'
'Returns the message storage on the request if it exists, otherwise returns DCNL an empty list.'
'Configure ssh to log to a file for debug'
'Get fixed IPs by compute host.'
'Check if there is any negative value in an array. DCNL Parameters DCNL X : array-like or sparse matrix DCNL Input data. DCNL whom : string DCNL Who passed X to this function.'
'Run according to options in sys.argv and diff classifiers.'
'Set scores to zero for given users.'
'Synchronous cover download. Returns the "best" cover as per user DCNL prefs/cover resolution. DCNL Returned cover is a tuple: (plugin, width, height, fmt, data) DCNL Returns None if no cover is found.'
'Splits multi line map string into list of rows, treats for UTF-8 encoding. DCNL Args: DCNL game_map (str): An ASCII map DCNL Returns: DCNL list (list): The map split into rows'
'Add line breaks and indentation to ElementTree in-place. DCNL Sources: DCNL - http://effbot.org/zone/element-lib.htm#prettyprint DCNL - http://infix.se/2007/02/06/gentlemen-indent-your-xml'
'Set a global mysql variable to a given value DCNL The DB driver will handle quoting of the given value based on its DCNL type, thus numeric strings like \'3.0\' or \'8\' are illegal, they DCNL should be passed as numeric literals.'
'Membership controller DCNL - uses the group_membership table from PR'
'Checks to see if an interface is part of portchannel bundle DCNL Args: DCNL interface (str): full name of interface, i.e. Ethernet1/1 DCNL Returns: DCNL True/False based on if interface is a member of a portchannel bundle'
'sum up the counts for a word'
'Wrap methods into commands for a journalled service. DCNL The resulting callable will have signature identical to wrapped DCNL function, except that it expects journal as first argument, and DCNL returns a Deferred.'
':return: The ``bytes`` name of the native package format for this platform.'
'Return a callable corresponding to lookup_view. DCNL * If lookup_view is already a callable, return it. DCNL * If lookup_view is a string import path that can be resolved to a callable, DCNL import that callable and return it, otherwise raise an exception DCNL (ImportError or ViewDoesNotExist).'
'Process validation results into the format expected by the web DCNL frontend, including transforming certain fields into HTML,  mangling DCNL compatibility messages, and limiting the number of messages displayed.'
'This view shows cart items.'
'Enable or disable deinterlace filter. DCNL @param p_mi: libvlc media player. DCNL @param psz_mode: type of deinterlace filter, NULL to disable.'
'Display a message on the Vim status line. By default, the message is DCNL highlighted and logged to Vim command-line history (see :h history). DCNL Unset the |warning| parameter to disable this behavior. Set the |truncate| DCNL parameter to avoid hit-enter prompts (see :h hit-enter) when the message is DCNL longer than the window width.'
'Get radius by prefix.'
'Add the value to the lists.'
'Update group type by id.'
'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\')'
'Deletes a comment. Confirmation on GET, action on POST. Requires the "can DCNL moderate comments" permission. DCNL Templates: `comments/delete.html`, DCNL Context: DCNL comment DCNL the flagged `comments.comment` object'
'Apply needed filtering/annotating operations to a Document\'s HTML.'
'Helper function to build x axis for data captured per minibatch. DCNL Arguments: DCNL minibatches (int): how many total minibatches DCNL minibatch_markers (int array): cumulative number of minibatches complete at a given epoch DCNL epoch_axis (bool): whether to render epoch or minibatch as the integer step in the x axis'
'Morning Doji Star'
'Calculates the Gaussian Convolution Kernel'
'Load the register from msgpack files'
'Maps plays to the roles they use. DCNL Input: DCNL graph: A networkx digraph that is used to map Ansible dependencies. DCNL dirs: A list of relative paths to directories in which Ansible playbooks reside. DCNL git_dir: A path to the top-most directory in the local git repository tool is to be run in. DCNL key: The key in a playbook yaml file in dirs that maps to relevant playbook data. In this case, key is DCNL "roles", because the roles used by a playbook is of interest. DCNL type_1: Given edges A-B, the type of node A. DCNL type_2: Given edges A-B, the type of node B. DCNL Since this function maps plays to the roles they use, both type_1 is a type of playbook and type_2 is "role".'
'Install a signal handler which will write a byte to C{fd} when DCNL I{SIGCHLD} is received. DCNL This is implemented by installing an instance of L{_Handler} wrapped DCNL around C{None}, setting the I{SIGCHLD} handler as not allowed to DCNL interrupt system calls, and using L{signal.set_wakeup_fd} to do the DCNL actual writing. DCNL @param fd: The file descriptor to which to write when I{SIGCHLD} is DCNL received. DCNL @type fd: C{int}'
'Return the User model. Doesn\'t require the app cache to be fully DCNL initialised. DCNL This used to live in compat to support both Django 1.4\'s fixed User model DCNL and custom user models introduced thereafter. DCNL Support for Django 1.4 has since been dropped in Oscar, but our DCNL get_user_model remains because code relies on us annotating the _meta class DCNL with the additional fields, and other code might rely on it as well.'
'This method matches the signature for `xblock.runtime:Runtime.handler_url()` DCNL See :method:`xblock.runtime:Runtime.handler_url`'
'Query helper that accounts for context\'s `read_deleted` field. DCNL :param context: context to query under DCNL :param session: if present, the session to use DCNL :param read_deleted: if present, overrides context\'s read_deleted field. DCNL :param project_only: if present and context is user-type, then restrict DCNL query to match the context\'s project_id. If set to \'allow_none\', DCNL restriction includes project_id = None. DCNL :param base_model: Where model_query is passed a "model" parameter which is DCNL not a subclass of NovaBase, we should pass an extra base_model DCNL parameter that is a subclass of NovaBase and corresponds to the DCNL model parameter.'
'Returns a SciPy sparse matrix using attributes from G. DCNL If only `G` is passed in, then the adjacency matrix is constructed. DCNL Let A be a discrete set of values for the node attribute `node_attr`. Then DCNL the elements of A represent the rows and columns of the constructed matrix. DCNL Now, iterate through every edge e=(u,v) in `G` and consider the value DCNL of the edge attribute `edge_attr`.  If ua and va are the values of the DCNL node attribute `node_attr` for u and v, respectively, then the value of DCNL the edge attribute is added to the matrix element at (ua, va). DCNL Parameters DCNL G : graph DCNL The NetworkX graph used to construct the NumPy matrix. DCNL edge_attr : str, optional DCNL Each element of the matrix represents a running total of the DCNL specified edge attribute for edges whose node attributes correspond DCNL to the rows/cols of the matirx. The attribute must be present for DCNL all edges in the graph. If no attribute is specified, then we DCNL just count the number of edges whose node attributes correspond DCNL to the matrix element. DCNL node_attr : str, optional DCNL Each row and column in the matrix represents a particular value DCNL of the node attribute.  The attribute must be present for all nodes DCNL in the graph. Note, the values of this attribute should be reliably DCNL hashable. So, float values are not recommended. If no attribute is DCNL specified, then the rows and columns will be the nodes of the graph. DCNL normalized : bool, optional DCNL If True, then each row is normalized by the summation of its values. DCNL rc_order : list, optional DCNL A list of the node attribute values. This list specifies the ordering DCNL of rows and columns of the array. If no ordering is provided, then DCNL the ordering will be random (and also, a return value). DCNL Other Parameters DCNL dtype : NumPy data-type, optional DCNL A valid NumPy dtype used to initialize the array. Keep in mind certain DCNL dtypes can yield unexpected results if the array is to be normalized. DCNL The parameter is passed to numpy.zeros(). If unspecified, the NumPy DCNL default is used. DCNL Returns DCNL M : SciPy sparse matrix DCNL The attribute matrix. DCNL ordering : list DCNL If `rc_order` was specified, then only the matrix is returned. DCNL However, if `rc_order` was None, then the ordering used to construct DCNL the matrix is returned as well. DCNL Examples DCNL Construct an adjacency matrix: DCNL >>> G = nx.Graph() DCNL >>> G.add_edge(0,1,thickness=1,weight=3) DCNL >>> G.add_edge(0,2,thickness=2) DCNL >>> G.add_edge(1,2,thickness=3) DCNL >>> M = nx.attr_sparse_matrix(G, rc_order=[0,1,2]) DCNL >>> M.todense() DCNL matrix([[ 0.,  1.,  1.], DCNL [ 1.,  0.,  1.], DCNL [ 1.,  1.,  0.]]) DCNL Alternatively, we can obtain the matrix describing edge thickness. DCNL >>> M = nx.attr_sparse_matrix(G, edge_attr=\'thickness\', rc_order=[0,1,2]) DCNL >>> M.todense() DCNL matrix([[ 0.,  1.,  2.], DCNL [ 1.,  0.,  3.], DCNL [ 2.,  3.,  0.]]) DCNL We can also color the nodes and ask for the probability distribution over DCNL all edges (u,v) describing: DCNL Pr(v has color Y | u has color X) DCNL >>> G.node[0][\'color\'] = \'red\' DCNL >>> G.node[1][\'color\'] = \'red\' DCNL >>> G.node[2][\'color\'] = \'blue\' DCNL >>> rc = [\'red\', \'blue\'] DCNL >>> M = nx.attr_sparse_matrix(G, node_attr=\'color\',                                   normalized=True, rc_order=rc) DCNL >>> M.todense() DCNL matrix([[ 0.33333333,  0.66666667], DCNL [ 1.        ,  0.        ]]) DCNL For example, the above tells us that for all edges (u,v): DCNL Pr( v is red  | u is red)  = 1/3 DCNL Pr( v is blue | u is red)  = 2/3 DCNL Pr( v is red  | u is blue) = 1 DCNL Pr( v is blue | u is blue) = 0 DCNL Finally, we can obtain the total weights listed by the node colors. DCNL >>> M = nx.attr_sparse_matrix(G, edge_attr=\'weight\',                                  node_attr=\'color\', rc_order=rc) DCNL >>> M.todense() DCNL matrix([[ 3.,  2.], DCNL [ 2.,  0.]]) DCNL Thus, the total weight over all edges (u,v) with u and v having colors: DCNL (red, red)   is 3   # the sole contribution is from edge (0,1) DCNL (red, blue)  is 2   # contributions from edges (0,2) and (1,2) DCNL (blue, red)  is 2   # same as (red, blue) since graph is undirected DCNL (blue, blue) is 0   # there are no edges with blue endpoints'
'See :meth:`command_list_begin()`.'
'helper function to convert an ace to a textual representation'
'Builds the offset argument for event rules.'
'Pickles an object, optionally saving its parameters separately. 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 pickle_object : bool DCNL If False, `object_` will not be serialized, only its parameters. DCNL This flag can be used when `object_` is not serializable, but one DCNL still want to save its parameters. Default: True 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`.'
'Returns True iff xblock has the proper attributes for generating metadata DCNL with get_discussion_id_map_entry()'
'Filter examples of train for which we have labels DCNL Parameters DCNL train : WRITEME DCNL label : WRITEME DCNL classes : WRITEME DCNL Returns DCNL WRITEME'
'Resets all lists and makes only the given one standard, DCNL if the desktop icon does not exist and the name is a DocType, then will create DCNL an icon for the doctype'
'Return the nth prime, with the primes indexed as prime(1) = 2, DCNL prime(2) = 3, etc.... The nth prime is approximately n*log(n). DCNL Logarithmic integral of x is a pretty nice approximation for number of DCNL primes <= x, i.e. DCNL li(x) ~ pi(x) DCNL In fact, for the numbers we are concerned about( x<1e11 ), DCNL li(x) - pi(x) < 50000 DCNL Also, DCNL li(x) > pi(x) can be safely assumed for the numbers which DCNL can be evaluated by this function. DCNL Here, we find the least integer m such that li(m) > n using binary search. DCNL Now pi(m-1) < li(m-1) <= n, DCNL We find pi(m - 1) using primepi function. DCNL Starting from m, we have to find n - pi(m-1) more primes. DCNL For the inputs this implementation can handle, we will have to test DCNL primality for at max about 10**5 numbers, to get our answer. DCNL References DCNL - https://en.wikipedia.org/wiki/Prime_number_theorem#Table_of_.CF.80.28x.29.2C_x_.2F_log_x.2C_and_li.28x.29 DCNL - https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number DCNL - https://en.wikipedia.org/wiki/Skewes%27_number DCNL Examples DCNL >>> from sympy import prime DCNL >>> prime(10) DCNL 29 DCNL >>> prime(1) DCNL 2 DCNL >>> prime(100000) DCNL 1299709 DCNL See Also DCNL sympy.ntheory.primetest.isprime : Test if n is prime DCNL primerange : Generate all primes in a given range DCNL primepi : Return the number of primes less than or equal to n'
'Displays \'Add to Favorites\' widget.'
'Opens the given ``filename`` and yields the fully-qualified names DCNL of TestCases found inside (one per line).'
'Sanitizes a value according to the current decimal and DCNL thousand separator setting. Used with form field input.'
'Introspecs the arguments of a callable. DCNL Args: DCNL func: The callable to introspect DCNL Returns: DCNL A list of argument names, excluding *arg and **kwargs DCNL arguments.'
'Get the current list of indices from the cluster. DCNL :arg client: An :class:`elasticsearch.Elasticsearch` client object DCNL :rtype: list'
'Messages should be hidden after the timer times out.'
'Update fancy-dmg Makefile. DCNL See https://el-tramo.be/blog/fancy-dmg/'
'Creates a copy of the headers. DCNL Args: DCNL headers: dict, request headers to copy. DCNL Returns: DCNL dict, the copied headers or a new dictionary if the headers DCNL were None.'
'A context manager that yields a Secret model defined at runtime. DCNL All EncryptedField init logic occurs at model class definition time, not at DCNL object instantiation time. This means that in order to test different keys DCNL and modes, we must generate a new class definition at runtime, after DCNL establishing the correct KeyCzar settings. This context manager handles DCNL that process. DCNL See http://dynamic-models.readthedocs.org/en/latest/ and DCNL https://docs.djangoproject.com/en/dev/topics/db/models/ DCNL #differences-between-proxy-inheritance-and-unmanaged-models'
'Return a dict containing information about currently loaded modules DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' kmod.lsmod'
'Mark the specified image as the cover image.'
'Create read-only fields and backref from VM and VDI to VBD when VBD DCNL is created.'
'Returns true if the specified xblock is a vertical that is treated as a unit. DCNL A unit is a vertical that is a direct child of a sequential (aka a subsection).'
''
'Loop through identifiers to see which formats match. DCNL Parameters DCNL origin : str DCNL A string ``"read`` or ``"write"`` identifying whether the file is to be DCNL opened for reading or writing. DCNL data_class_required : object DCNL The specified class for the result of `read` or the class that is to be DCNL written. DCNL path : str, other path object or None DCNL The path to the file or None. DCNL fileobj : File object or None. DCNL An open file object to read the file\'s contents, or ``None`` if the DCNL file could not be opened. DCNL args : sequence DCNL Positional arguments for the `read` or `write` function. Note that DCNL these must be provided as sequence. DCNL kwargs : dict-like DCNL Keyword arguments for the `read` or `write` function. Note that this DCNL parameter must be `dict`-like. DCNL Returns DCNL valid_formats : list DCNL List of matching formats.'
'Returns all translatable strings from a :class:`frappe.core.doctype.Page`'
'Render the given template and pass the given arguments to it.'
'Assert that no element is found. Use a wait in case the element currently exists DCNL on the page, and we want to wait for it to disappear before doing the assert. DCNL Finds the element using an id.'
'Reduce the height of `original_size` by `padding`, maintaining the aspect DCNL ratio.'
'It\'s not sufficient to have the absolute path to the compiler, linker, DCNL etc. on Windows, as those tools rely on .dlls being in the PATH. We also DCNL need to support both x86 and x64 compilers within the same build (to support DCNL msvs_target_platform hackery). Different architectures require a different DCNL compiler binary, and different supporting environment variables (INCLUDE, DCNL LIB, LIBPATH). So, we extract the environment here, wrap all invocations DCNL of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which DCNL sets up the environment, and then we do not prefix the compiler with DCNL an absolute path, instead preferring something like "cl.exe" in the rule DCNL which will then run whichever the environment setup has put in the path. DCNL When the following procedure to generate environment files does not DCNL meet your requirement (e.g. for custom toolchains), you can pass DCNL "-G ninja_use_custom_environment_files" to the gyp to suppress file DCNL generation and use custom environment files prepared by yourself.'
'This is a helper function that determines the destination path and compare DCNL key given parameters received from the ``FileFormat`` class.'
':return: The description for the plugin type.'
'N321 - Use jsonutils instead of json.'
'Gets all the vlanids'
'Return the latest version of config_filename from the repository manifest.'
'供master调用的接口：关闭服务器'
'Read a length prefix from an RLP string. DCNL :param rlp: the rlp string to read from DCNL :param start: the position at which to start reading DCNL :returns: a tuple ``(type, length, end)``, where ``type`` is either ``str`` DCNL or ``list`` depending on the type of the following payload, DCNL ``length`` is the length of the payload in bytes, and ``end`` is DCNL the position of the first payload byte in the rlp string'
'Add assembly linear bearing cage.'
'Order view as Invoice'
'Get the repository constructor.'
'Converts JSON formatted date to native Python objects. DCNL The keys in any JSON dict are transformed from camelcase to underscore separated words.'
'Run pylama after git commit.'
'Construct BlockManager from string description. DCNL String description syntax looks similar to np.matrix initializer.  It looks DCNL like this:: DCNL a,b,c: f8; d,e,f: i8 DCNL Rules are rather simple: DCNL * see list of supported datatypes in `create_block` method DCNL * components are semicolon-separated DCNL * each component is `NAME,NAME,NAME: DTYPE_ID` DCNL * whitespace around colons & semicolons are removed DCNL * components with same DTYPE_ID are combined into single block DCNL * to force multiple blocks with same dtype, use \'-SUFFIX\':: DCNL \'a:f8-1; b:f8-2; c:f8-foobar\''
'Delete a role (keystone role-delete) DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt \'*\' keystone.role_delete c965f79c4f864eaaa9c3b41904e67082 DCNL salt \'*\' keystone.role_delete role_id=c965f79c4f864eaaa9c3b41904e67082 DCNL salt \'*\' keystone.role_delete name=admin'
'Determine if the EEG needs an averge EEG reference. DCNL This returns True if no custom reference has been applied and no average DCNL reference projection is present in the list of projections.'
'adds a new tag to a record, and creates the Tag master'
'Creates a budget and returns its budgetId. DCNL Args: DCNL client: An AdWordsClient instance. DCNL Returns: DCNL An int budgetId for the created Budget.'
'Flatten a dict from cls -> [fields, ...] and yields values of the form (cls, fields) DCNL for each entry in the dictionary value.'
'Convert Nova network object into os_vif object DCNL :param network: nova.network.model.Network instance DCNL :returns: os_vif.objects.network.Network instance'
'Max weight norm constraints and gradient clipping DCNL This takes a TensorVariable and rescales it so that incoming weight DCNL norms are below a specified constraint value. Vectors violating the DCNL constraint are rescaled so that they are within the allowed range. DCNL Parameters DCNL tensor_var : TensorVariable DCNL Theano expression for update, gradient, or other quantity. DCNL max_norm : scalar DCNL This value sets the maximum allowed value of any norm in DCNL `tensor_var`. DCNL norm_axes : sequence (list or tuple) DCNL The axes over which to compute the norm.  This overrides the DCNL default norm axes defined for the number of dimensions DCNL in `tensor_var`. When this is not specified and `tensor_var` is a DCNL matrix (2D), this is set to `(0,)`. If `tensor_var` is a 3D, 4D or DCNL 5D tensor, it is set to a tuple listing all axes but axis 0. The DCNL former default is useful for working with dense layers, the latter DCNL is useful for 1D, 2D and 3D convolutional layers. DCNL (Optional) DCNL epsilon : scalar, optional DCNL Value used to prevent numerical instability when dividing by DCNL very small or zero norms. DCNL Returns DCNL TensorVariable DCNL Input `tensor_var` with rescaling applied to weight vectors DCNL that violate the specified constraints. DCNL Examples DCNL >>> param = theano.shared( DCNL ...     np.random.randn(100, 200).astype(theano.config.floatX)) DCNL >>> update = param + 100 DCNL >>> update = norm_constraint(update, 10) DCNL >>> func = theano.function([], [], updates=[(param, update)]) DCNL >>> # Apply constrained update DCNL >>> _ = func() DCNL >>> from lasagne.utils import compute_norms DCNL >>> norms = compute_norms(param.get_value()) DCNL >>> np.isclose(np.max(norms), 10) DCNL True DCNL Notes DCNL When `norm_axes` is not specified, the axes over which the norm is DCNL computed depend on the dimensionality of the input variable. If it is DCNL 2D, it is assumed to come from a dense layer, and the norm is computed DCNL over axis 0. If it is 3D, 4D or 5D, it is assumed to come from a DCNL convolutional layer and the norm is computed over all trailing axes DCNL beyond axis 0. For other uses, you should explicitly specify the axes DCNL over which to compute the norm using `norm_axes`.'
'Permanently delete a persistent disk. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-cloud -f delete_disk gce disk_name=pd'
'Creates a wx.PySimpleApp instance if a wx.App has not been created.'
'Find any \'svn:externals\' directories'
'Quietly closes a closable object without throwing an exception. DCNL :param closable: Object with a ``close`` method.'
'Add information needed to train bounding-box regressors.'
'Check if a package is installed.'
'Use Preconditioned Conjugate Gradient iteration to solve A x = b DCNL A simple Jacobi (diagonal) preconditionner is used. DCNL Parameters DCNL A: _Sparse_Matrix_coo DCNL *A* must have been compressed before by compress_csc or DCNL compress_csr method. DCNL b: array DCNL Right hand side of the linear system. DCNL Returns DCNL x: array. DCNL The converged solution. DCNL err: float DCNL The absolute error np.linalg.norm(A.dot(x) - b) DCNL Other parameters DCNL x0: array. DCNL Starting guess for the solution. DCNL tol: float. DCNL Tolerance to achieve. The algorithm terminates when the relative DCNL residual is below tol. DCNL maxiter: integer. DCNL Maximum number of iterations. Iteration will stop DCNL after maxiter steps even if the specified tolerance has not DCNL been achieved.'
'Returns the graph that results from contracting the specified edge. DCNL Edge contraction identifies the two endpoints of the edge as a single node DCNL incident to any edge that was incident to the original two nodes. A graph DCNL that results from edge contraction is called a *minor* of the original DCNL graph. DCNL Parameters DCNL G : NetworkX graph DCNL The graph whose edge will be contracted. DCNL edge : tuple DCNL Must be a pair of nodes in `G`. DCNL self_loops : Boolean DCNL If this is True, any edges (including `edge`) joining the DCNL endpoints of `edge` in `G` become self-loops on the new node in the DCNL returned graph. DCNL Returns DCNL Networkx graph DCNL A new graph object of the same type as `G` (leaving `G` unmodified) DCNL with endpoints of `edge` identified in a single node. The right node DCNL of `edge` will be merged into the left one, so only the left one will DCNL appear in the returned graph. DCNL Raises DCNL ValueError DCNL If `edge` is not an edge in `G`. DCNL Examples DCNL Attempting to contract two nonadjacent nodes yields an error:: DCNL >>> import networkx as nx DCNL >>> G = nx.cycle_graph(4) DCNL >>> nx.contracted_edge(G, (1, 3)) DCNL Traceback (most recent call last): DCNL ValueError: Edge (1, 3) does not exist in graph G; cannot contract it DCNL Contracting two adjacent nodes in the cycle graph on *n* nodes yields the DCNL cycle graph on *n - 1* nodes:: DCNL >>> import networkx as nx DCNL >>> C5 = nx.cycle_graph(5) DCNL >>> C4 = nx.cycle_graph(4) DCNL >>> M = nx.contracted_edge(C5, (0, 1), self_loops=False) DCNL >>> nx.is_isomorphic(M, C4) DCNL True DCNL See also DCNL contracted_nodes DCNL quotient_graph'
'Test installing from wheel with --compile on'
'Returns 3 orthognal base vectors, the first one colinear to n.'
'Construct an object holding a date value from the given ticks value DCNL (number of seconds since the epoch). DCNL This function is part of the `DBAPI 2.0 specification DCNL <http://www.python.org/dev/peps/pep-0249/>`_. DCNL :rtype: :class:`datetime.date`'
'Delete all tags from the instance.'
'On success returns True.'
'Mark `fn` for line coverage analysis. DCNL Results will be printed to sys.stdout on program termination. DCNL Usage:: DCNL def fn(...): DCNL fn = coverage(fn) DCNL If you are using Python 2.4, you should be able to use the decorator DCNL syntax:: DCNL @coverage DCNL def fn(...):'
'Downgrade 012 -> 011 with special SQLite-compatible logic.'
'http://msdn.microsoft.com/en-us/library/system.dynamic(VS.100).aspx DCNL Only a sanity check here.  Exhaustive testing of \'dynamic\' will exist DCNL elsewhere.  Piggyback off of CSharp/VB\'s work.'
'Convert datetime into a human natural date string.'
'Creates a module dictionary for the hardened part of the process. DCNL Module dictionary will contain modules that should be shared between the DCNL hardened and unhardened parts of the process. DCNL Args: DCNL module_dict: Module dictionary from which existing modules should be DCNL pulled (usually sys.modules). DCNL Returns: DCNL A new module dictionary.'
'Cleans build directories'
'Test either if an error is raised when the balancing ratio to fit is DCNL smaller than the one of the data'
'Test that custom models can be subclassed.'
'Simple method to return the non printable characters found in an string DCNL @param string: A string DCNL @return: Number of non printable characters in the string'
'Get the scores dict for the given `video`. DCNL This will return either :data:`episode_scores` or :data:`movie_scores` based on the type of the `video`. DCNL :param video: the video to compute the score against. DCNL :type video: :class:`~subliminal.video.Video` DCNL :return: the scores dict. DCNL :rtype: dict'
'Kill a process by PID. DCNL .. code-block:: bash DCNL salt \'minion\' ps.kill_pid pid [signal=signal_number] DCNL pid DCNL PID of process to kill. DCNL signal DCNL Signal to send to the process. See manpage entry for kill DCNL for possible values. Default: 15 (SIGTERM). DCNL **Example:** DCNL Send SIGKILL to process with PID 2000: DCNL .. code-block:: bash DCNL salt \'minion\' ps.kill_pid 2000 signal=9'
'Return `text` in triple-double-quoted Python string form.'
'Converts integer to string eg 3 to "03"'
'Validate payload against an api_model. Aborts in case of failure DCNL - This function is for custom fields as they can\'t be validated by DCNL flask restplus automatically. DCNL - This is to be called at the start of a post or put method'
'Save a collection item to file system DCNL @param Collection collection collection DCNL @param Item item collection item'
'Return the file and line number of the statement that raised the tb. DCNL Returns: (filename, lineno) tuple'
'Minimization of scalar function of one or more variables using the DCNL conjugate gradient algorithm. DCNL Options DCNL disp : bool DCNL Set to True to print convergence messages. DCNL maxiter : int DCNL Maximum number of iterations to perform. DCNL gtol : float DCNL Gradient norm must be less than `gtol` before successful DCNL termination. DCNL norm : float DCNL Order of norm (Inf is max, -Inf is min). DCNL eps : float or ndarray DCNL If `jac` is approximated, use this value for the step size.'
'Return recurring jobs. DCNL :param filter_data: Filters out which recurring jobs to get. DCNL :return: Sequence of recurring jobs.'
'Ensure that the named group is absent DCNL name DCNL The name of the group to remove'
'Quit all windows.'
'Get a value from the REST interface'
'Decorator that checks the fixture with all dtypes. DCNL Args: DCNL name(str): Argument name to which specified dtypes are passed. DCNL no_float16(bool): If, True, ``numpy.float16`` is DCNL omitted from candidate dtypes. DCNL no_bool(bool): If, True, ``numpy.bool_`` is DCNL omitted from candidate dtypes. DCNL dtypes to be tested: ``numpy.float16`` (optional), ``numpy.float32``, DCNL ``numpy.float64``, ``numpy.dtype(\'b\')``, ``numpy.dtype(\'h\')``, DCNL ``numpy.dtype(\'i\')``, ``numpy.dtype(\'l\')``, ``numpy.dtype(\'q\')``, DCNL ``numpy.dtype(\'B\')``, ``numpy.dtype(\'H\')``, ``numpy.dtype(\'I\')``, DCNL ``numpy.dtype(\'L\')``, ``numpy.dtype(\'Q\')``, and ``numpy.bool_`` (optional). DCNL The usage is as follows. DCNL This test fixture checks if ``cPickle`` successfully reconstructs DCNL :class:`cupy.ndarray` for various dtypes. DCNL ``dtype`` is an argument inserted by the decorator. DCNL >>> import unittest DCNL >>> from cupy import testing DCNL >>> @testing.gpu DCNL ... class TestNpz(unittest.TestCase): DCNL ...     @testing.for_all_dtypes() DCNL ...     def test_pickle(self, dtype): DCNL ...         a = testing.shaped_arange((2, 3, 4), dtype=dtype) DCNL ...         s = six.moves.cPickle.dumps(a) DCNL ...         b = six.moves.cPickle.loads(s) DCNL ...         testing.assert_array_equal(a, b) DCNL Typically, we use this decorator in combination with DCNL decorators that check consistency between NumPy and CuPy like DCNL :func:`cupy.testing.numpy_cupy_allclose`. DCNL The following is such an example. DCNL >>> import unittest DCNL >>> from cupy import testing DCNL >>> @testing.gpu DCNL ... class TestMean(unittest.TestCase): DCNL ...     @testing.for_all_dtypes() DCNL ...     @testing.numpy_cupy_allclose() DCNL ...     def test_mean_all(self, xp, dtype): DCNL ...         a = testing.shaped_arange((2, 3), xp, dtype) DCNL ...         return a.mean() DCNL .. seealso:: :func:`cupy.testing.for_dtypes`'
'processes mapping data in list of lists format into a 2 deep dict'
'Outputs the first variable passed that is not False, without escaping. DCNL Outputs nothing if all the passed variables are False. DCNL Sample usage:: DCNL {% firstof var1 var2 var3 %} DCNL This is equivalent to:: DCNL {% if var1 %} DCNL {{ var1|safe }} DCNL {% else %}{% if var2 %} DCNL {{ var2|safe }} DCNL {% else %}{% if var3 %} DCNL {{ var3|safe }} DCNL {% endif %}{% endif %}{% endif %} DCNL but obviously much cleaner! DCNL You can also use a literal string as a fallback value in case all DCNL passed variables are False:: DCNL {% firstof var1 var2 var3 "fallback value" %} DCNL If you want to escape the output, use a filter tag:: DCNL {% filter force_escape %} DCNL {% firstof var1 var2 var3 "fallback value" %} DCNL {% endfilter %}'
'List all exceptions found during a scan DCNL :return: A JSON containing a list of: DCNL - Exception resource URL (eg. /scans/0/exceptions/3) DCNL - The exceptions id (eg. 3) DCNL - Exception string DCNL - Exception file name DCNL - Exception line number'
'Checks that the expr has been rewritten using f(-x) -> f(x) DCNL arg : -x'
'Returns True if the passed in value is a job id'
'Encode `arg` as `typ`. DCNL `arg` will be encoded in a best effort manner, were necessary the function DCNL will try to correctly define the underlying binary representation (ie. DCNL decoding a hex-encoded address/hash). DCNL Args: DCNL typ (Tuple[(str, int, list)]): A 3-tuple defining the `arg` type. DCNL The first element defines the type name. DCNL The second element defines the type length in bits. DCNL The third element defines if it\'s an array type. DCNL Together the first and second defines the elementary type, the third DCNL element must be present but is ignored. DCNL Valid type names are: DCNL - uint DCNL - int DCNL - bool DCNL - ufixed DCNL - fixed DCNL - string DCNL - bytes DCNL - hash DCNL - address DCNL arg (object): The object to be encoded, it must be a python object DCNL compatible with the `typ`. DCNL Raises: DCNL ValueError: when an invalid `typ` is supplied. DCNL ValueOutOfBounds: when `arg` cannot be encoded as `typ` because of the DCNL binary contraints. DCNL Note: DCNL This function don\'t work with array types, for that use the `enc` DCNL function.'
''
'Test hsl to rgb color function'
'Tests that cx_Oracle (external dependency) is built correctly.'
'Return a channel object based on ``env.host_string``.'
'1 pixel = 9525 EMUs'
'Yield multiple (code, function) tuples.'
'Return basic meta-data about the LRF file in C{stream} as a DCNL L{MetaInformation} object. DCNL @param stream: A file like object or an instance of L{LRFMetaFile}'
'Selects a valid amino acid sequence given a 3-letter code input. DCNL This function takes a single three-letter amino acid sequence and the phase DCNL of the sequence to return the longest intact amino acid sequence possible. DCNL Parts of the input sequence before and after the selected sequence are also DCNL returned. DCNL This is an internal private function and is meant for parsing Exonerate\'s DCNL three-letter amino acid output. DCNL >>> from Bio.SearchIO.ExonerateIO._base import _make_triplets DCNL >>> _make_triplets(\'GlyThrSerAlaPro\') DCNL (\'\', [\'Gly\', \'Thr\', \'Ser\', \'Ala\', \'Pro\'], \'\') DCNL >>> _make_triplets(\'yThSerAla\', phase=1) DCNL (\'y\', [\'Thr\', \'Ser\', \'Ala\'], \'\') DCNL >>> _make_triplets(\'yThSerAlaPr\', phase=1) DCNL (\'y\', [\'Thr\', \'Ser\', \'Ala\'], \'Pr\')'
'Load external class based on a path. DCNL Example classpath: "Module.Submodule:Classname". DCNL Equivalent soon-to-be-deprecated classpath: "Module.Submodule.Classname".'
'Implements memoized cache lookups'
'Git Pull handler'
'Return all assets that are referenced in the given CSS document. DCNL The returned URLs are relative to the stylesheet\'s URL. DCNL Args: DCNL data: The content of the stylesheet to scan as string. DCNL inline: True if the argument is an inline HTML style attribute.'
'Return full script path, if any valid script exists, else None'
'Follow a user'
'Given a list of template names, returns the first that can be loaded.'
'Update/Create the SAMLProviderData for the given entity ID. DCNL Return value: DCNL False if nothing has changed and existing data\'s "fetched at" timestamp is just updated. DCNL True if a new record was created. (Either this is a new provider or something changed.)'
'Calls into the IOKit to load a kext by file-system path. DCNL Apple kext API doco here: DCNL http://developer.apple.com/library/mac/#documentation/IOKit/Reference/ DCNL KextManager_header_reference/Reference/reference.html DCNL Args: DCNL kext_path: Absolute or relative POSIX path to the kext. DCNL Raises: DCNL OSError: On failure to load the kext.'
'Returns a list of hosts for the the specified VMware environment. 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 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 .. code-block:: bash DCNL salt \'*\' vsphere.list_hosts 1.2.3.4 root bad-password'
'Obtain a cluster from the command line options and environment. DCNL :param BenchmarkOption options: Parsed command line options. DCNL :param dict env: Dictionary of environment variables. DCNL :return BenchmarkCluster: Cluster to benchmark.'
'Runs a simple HTTP server hosting WSGI app `func`. The directory `static/` DCNL is hosted statically. DCNL Based on [WsgiServer](http://www.owlfish.com/software/wsgiutils/documentation/wsgi-server-api.html) DCNL from [Colin Stewart](http://www.owlfish.com/).'
'Mimic as_view and with forms to skip some of the context'
'Returns value safe for CSV dumping DCNL Reference: http://tools.ietf.org/html/rfc4180 DCNL >>> safeCSValue(u\'foo, bar\') DCNL u\'"foo, bar"\' DCNL >>> safeCSValue(u\'foobar\') DCNL u\'foobar\''
'Returns an SQL WHERE comparison string using =, i=, !=, >, <, >=, <= or BETWEEN. DCNL Strings may contain wildcards (*) at the start or at the end. DCNL A list or tuple of values can be given when using =, != or BETWEEN.'
'Return (base,pyversion) or (None,None) for possible .exe name'
'run pylint-gui'
'Processes a caption string into a list of tonenized words. DCNL Args: DCNL caption: A string caption. DCNL Returns: DCNL A list of strings; the tokenized caption.'
'Worksheet Class'
'Returns True if x and y are sufficiently close, elementwise. DCNL Parameters DCNL rtol : float DCNL The relative error tolerance. DCNL atol : float DCNL The absolute error tolerance.'
'Prompts before aborting a merge in progress'
'Wrapper for :py:meth:`boto.emr.EmrConnection.list_steps()` DCNL that works around around `boto\'s startdatetime bug DCNL <https://github.com/boto/boto/issues/3268>`__.'
'Return true if this field has errors that were not accounted for by render_with_errors, because DCNL the widget does not support the render_with_errors method'
'Cleans up text. DCNL Escapes newlines and tabs. DCNL Parameters DCNL text : str DCNL Text to clean up.'
'Format a list of message sizes into a STAT response. DCNL This generator function is intended to be used with DCNL L{Cooperator <twisted.internet.task.Cooperator>}. DCNL @type msgs: L{list} of L{int} DCNL @param msgs: A list of message sizes. DCNL @rtype: L{None} or L{bytes} DCNL @return: Yields none until a result is available, then a string that is DCNL suitable for use in a STAT response. The string consists of the number DCNL of messages and the total size of the messages in octets.'
'Filter a list of tracks where ``field`` is ``values``. DCNL :param list tracks: a list of :class:`~mopidy.models.Track` DCNL :param dict query: one or more field/value pairs to search for DCNL :param int limit: maximum number of results to return DCNL :param int offset: offset into result set to use. DCNL :param uris: zero or more URI roots to limit the search to DCNL :type uris: list of strings or :class:`None` DCNL :rtype: :class:`~mopidy.models.SearchResult`'
'Download grades as CSV.'
'Remove reduction over broadcastable dimensions.'
'return an attribute of the class that is either present directly DCNL on the class, e.g. not on a superclass, or is from a superclass but DCNL this superclass is a mixin, that is, not a descendant of DCNL the declarative base. DCNL This is used to detect attributes that indicate something about DCNL a mapped class independently from any mapped classes that it may DCNL inherit from.'
'Detect WikiSyntax (i.e. InterCaps, a.k.a. CamelCase) and escape it.'
'Return a list of (REALNAME, EMAIL) for each fieldvalue.'
'Processes command line parameters into options and files,  then checks DCNL or update FITS DATASUM and CHECKSUM keywords for the specified files.'
'Add is_default field to \'show\' response.'
'Demonstrate conjugate gradient optimization of a log-linear model DCNL This is demonstrated on MNIST. DCNL :type n_epochs: int DCNL :param n_epochs: number of epochs to run the optimizer DCNL :type mnist_pkl_gz: string DCNL :param mnist_pkl_gz: the path of the mnist training file from DCNL http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
'A function to connect to a bigip device and modify an existing node. 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 node to modify DCNL connection_limit DCNL [integer] DCNL description DCNL [string] DCNL dynamic_ratio DCNL [integer] DCNL logging DCNL [enabled | disabled] DCNL monitor DCNL [[name] | none | default] DCNL rate_limit DCNL [integer] DCNL ratio DCNL [integer] DCNL session DCNL [user-enabled | user-disabled] DCNL state DCNL [user-down | user-up ] DCNL trans_label DCNL The label of the transaction stored within the grain: DCNL ``bigip_f5_trans:<label>`` DCNL CLI Example:: DCNL salt \'*\' bigip.modify_node bigip admin admin 10.1.1.2 ratio=2 logging=enabled'
'Returns the appropriate Manager class for a given Model class.  It DCNL does this by looking in the boto config for a section like this:: DCNL [DB] DCNL db_type = SimpleDB DCNL db_user = <aws access key id> DCNL db_passwd = <aws secret access key> DCNL db_name = my_domain DCNL [DB_TestBasic] DCNL db_type = SimpleDB DCNL db_user = <another aws access key id> DCNL db_passwd = <another aws secret access key> DCNL db_name = basic_domain DCNL db_port = 1111 DCNL The values in the DB section are "generic values" that will be used DCNL if nothing more specific is found.  You can also create a section for DCNL a specific Model class that gives the db info for that class. DCNL In the example above, TestBasic is a Model subclass.'
'Unsigned Long'
'Enable or disable edit mode for the request. DCNL :param request: HTTP request DCNL :type request: django.http.HttpRequest DCNL :param flag: Enable flag DCNL :type flag: bool'
'Register handler to RAW if msg_type not given. DCNL :type func: callable DCNL :type msg_type: str or unicode'
'Make a web call to QingCloud IaaS API.'
'Return True if list is a list of ints.'
'Return Pade approximation to a polynomial as the ratio of two polynomials. DCNL Parameters DCNL an : (N,) array_like DCNL Taylor series coefficients. DCNL m : int DCNL The order of the returned approximating polynomials. DCNL Returns DCNL p, q : Polynomial class DCNL The Pade approximation of the polynomial defined by `an` is DCNL ``p(x)/q(x)``. DCNL Examples DCNL >>> from scipy.interpolate import pade DCNL >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0] DCNL >>> p, q = pade(e_exp, 2) DCNL >>> e_exp.reverse() DCNL >>> e_poly = np.poly1d(e_exp) DCNL Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)`` DCNL >>> e_poly(1) DCNL 2.7166666666666668 DCNL >>> p(1)/q(1) DCNL 2.7179487179487181'
'Returns the count of the specified `query`. DCNL This function employs an optimization that bypasses the DCNL :meth:`sqlalchemy.orm.Query.count` method, which can be very slow DCNL for large queries.'
'Tests creating and accessing Angle objects'
'Get vector3 from prefix and xml element, then remove prefix attributes from dictionary.'
'Do proper formatting of the jid'
'Parses a string and return a datetime.time. DCNL This function doesn\'t support time zone offsets. DCNL Raises ValueError if the input is well formatted but not a valid time. DCNL Returns None if the input isn\'t well formatted, in particular if it DCNL contains an offset.'
'version list to string'
'Check value is of or can be converted to expected type.'
'Minify XML files (strip whitespace and use minimal separators).'
'QZ decomposition for generalized eigenvalues of a pair of matrices. DCNL The QZ, or generalized Schur, decomposition for a pair of N x N DCNL nonsymmetric matrices (A,B) is:: DCNL (A,B) = (Q*AA*Z\', Q*BB*Z\') DCNL where AA, BB is in generalized Schur form if BB is upper-triangular DCNL with non-negative diagonal and AA is upper-triangular, or for real QZ DCNL decomposition (``output=\'real\'``) block upper triangular with 1x1 DCNL and 2x2 blocks.  In this case, the 1x1 blocks correspond to real DCNL generalized eigenvalues and 2x2 blocks are \'standardized\' by making DCNL the corresponding elements of BB have the form:: DCNL [ a 0 ] DCNL [ 0 b ] DCNL and the pair of corresponding 2x2 blocks in AA and BB will have a complex DCNL conjugate pair of generalized eigenvalues.  If (``output=\'complex\'``) or DCNL A and B are complex matrices, Z\' denotes the conjugate-transpose of Z. DCNL Q and Z are unitary matrices. DCNL Parameters DCNL A : (N, N) array_like DCNL 2d array to decompose DCNL B : (N, N) array_like DCNL 2d array to decompose DCNL output : {\'real\', \'complex\'}, optional DCNL Construct the real or complex QZ decomposition for real matrices. DCNL Default is \'real\'. DCNL lwork : int, optional DCNL Work array size.  If None or -1, it is automatically computed. DCNL sort : {None, callable, \'lhp\', \'rhp\', \'iuc\', \'ouc\'}, optional DCNL NOTE: THIS INPUT IS DISABLED FOR NOW. Use ordqd instead. DCNL Specifies whether the upper eigenvalues should be sorted.  A callable DCNL may be passed that, given a eigenvalue, returns a boolean denoting DCNL whether the eigenvalue should be sorted to the top-left (True). For DCNL real matrix pairs, the sort function takes three real arguments DCNL (alphar, alphai, beta). The eigenvalue DCNL ``x = (alphar + alphai*1j)/beta``.  For complex matrix pairs or DCNL output=\'complex\', the sort function takes two complex arguments DCNL (alpha, beta). The eigenvalue ``x = (alpha/beta)``.  Alternatively, DCNL string parameters may be used: DCNL - \'lhp\'   Left-hand plane (x.real < 0.0) DCNL - \'rhp\'   Right-hand plane (x.real > 0.0) DCNL - \'iuc\'   Inside the unit circle (x*x.conjugate() < 1.0) DCNL - \'ouc\'   Outside the unit circle (x*x.conjugate() > 1.0) DCNL Defaults to None (no sorting). DCNL overwrite_a : bool, optional DCNL Whether to overwrite data in a (may improve performance) DCNL overwrite_b : bool, optional DCNL Whether to overwrite data in b (may improve performance) DCNL check_finite : bool, optional DCNL If true checks the elements of `A` and `B` are finite numbers. If DCNL false does no checking and passes matrix through to DCNL underlying algorithm. DCNL Returns DCNL AA : (N, N) ndarray DCNL Generalized Schur form of A. DCNL BB : (N, N) ndarray DCNL Generalized Schur form of B. DCNL Q : (N, N) ndarray DCNL The left Schur vectors. DCNL Z : (N, N) ndarray DCNL The right Schur vectors. DCNL Notes DCNL Q is transposed versus the equivalent function in Matlab. DCNL .. versionadded:: 0.11.0 DCNL Examples DCNL >>> from scipy import linalg DCNL >>> np.random.seed(1234) DCNL >>> A = np.arange(9).reshape((3, 3)) DCNL >>> B = np.random.randn(3, 3) DCNL >>> AA, BB, Q, Z = linalg.qd(A, B) DCNL >>> AA DCNL array([[-13.40928183,  -4.62471562,   1.09215523], DCNL [  0.        ,   0.        ,   1.22805978], DCNL [  0.        ,   0.        ,   0.31973817]]) DCNL >>> BB DCNL array([[ 0.33362547, -1.37393632,  0.02179805], DCNL [ 0.        ,  1.68144922,  0.74683866], DCNL [ 0.        ,  0.        ,  0.9258294 ]]) DCNL >>> Q DCNL array([[ 0.14134727, -0.97562773,  0.16784365], DCNL [ 0.49835904, -0.07636948, -0.86360059], DCNL [ 0.85537081,  0.20571399,  0.47541828]]) DCNL >>> Z DCNL array([[-0.24900855, -0.51772687,  0.81850696], DCNL [-0.79813178,  0.58842606,  0.12938478], DCNL [-0.54861681, -0.6210585 , -0.55973739]]) DCNL See also DCNL ordqd'
'Return most recent client from list of clients.'
'Fit the Berg-Scherg equivalent spherical model dipole parameters.'
'When a process fails, its output should be logged.'
'A factory for creating Move objects DCNL Based on `resource` and `offset`, return one of `MoveModule`, DCNL `MoveGlobal` or `MoveMethod` for performing move refactoring.'
'Return True if provided address (in printable format) is a 6to4 DCNL address (being in 2002::/16).'
'NAPALM library must be installed for this module to work. DCNL Also, the key proxymodule must be set in the __opts___ dictionary.'
'Extract messages from Python source code. DCNL :param fileobj: the seekable, file-like object the messages should be DCNL extracted from DCNL :param keywords: a list of keywords (i.e. function names) that should be DCNL recognized as translation functions DCNL :param comment_tags: a list of translator tags to search for and include DCNL in the results DCNL :param options: a dictionary of additional options (optional) DCNL :return: an iterator over ``(lineno, funcname, message, comments)`` tuples DCNL :rtype: ``iterator``'
'Create the XML document that contains the new score to be sent to the LTI DCNL consumer. The format of this message is defined in the LTI 1.1 spec.'
'Obtain input reader parameters. DCNL Utility function for input readers implementation. Fetches parameters DCNL from mapreduce specification giving appropriate usage warnings. DCNL Args: DCNL mapper_spec: The MapperSpec for the job DCNL allowed_keys: set of all allowed keys in parameters as strings. If it is not DCNL None, then parameters are expected to be in a separate "input_reader" DCNL subdictionary of mapper_spec parameters. DCNL Returns: DCNL mapper parameters as dict DCNL Raises: DCNL BadReaderParamsError: if parameters are invalid/missing or not allowed.'
'Return a list of all directories on the master'
'Find existing certs that duplicate the request.'
'Assemble a block into multi-line sub-blocks.'
'Get new derivation.'
'Creates a function that colorizes text with the given color. DCNL For example: DCNL green = make_colorizer(\'darkgreen\') DCNL red = make_colorizer(\'red\') DCNL Then, you can use: DCNL print "It\'s either " + green(\'OK\') + \' or \' + red(\'Oops\')'
'Is `exp` a `Var` node.'
'``httpexceptions`` middleware; this catches any DCNL ``paste.httpexceptions.HTTPException`` exceptions (exceptions like DCNL ``HTTPNotFound``, ``HTTPMovedPermanently``, etc) and turns them DCNL into proper HTTP responses. DCNL ``warning_level`` can be an integer corresponding to an HTTP code. DCNL Any code over that value will be passed \'up\' the chain, potentially DCNL reported on by another piece of middleware.'
'convert Roman numeral to integer'
'Create a new figure manager instance for the given figure.'
'Convert the region of the agg buffer bounded by bbox to a wx.Bitmap.  If DCNL bbox is None, the entire buffer is converted. DCNL Note: agg must be a backend_agg.RendererAgg instance.'
'Generate a presigned url given a client, its method, and arguments DCNL :type ClientMethod: string DCNL :param ClientMethod: The client method to presign for DCNL :type Params: dict DCNL :param Params: The parameters normally passed to DCNL ``ClientMethod``. DCNL :type ExpiresIn: int DCNL :param ExpiresIn: The number of seconds the presigned url is valid DCNL for. By default it expires in an hour (3600 seconds) DCNL :type HttpMethod: string DCNL :param HttpMethod: The http method to use on the generated url. By DCNL default, the http method is whatever is used in the method\'s model. DCNL :returns: The presigned url'
'Returns a dict of (season, episode) : (sceneSeason, sceneEpisode) mappings DCNL for an entire show.  Both the keys and values of the dict are tuples. DCNL Will be empty if there are no scene numbers set'
'Generates a random string of given length from a set of alphanumeric characters. DCNL The default source uses [a-z][A-Z][0-9] DCNL Ex: DCNL - oo_random_word(3)                => aB9 DCNL - oo_random_word(4, source=\'012\')  => 0123'
'Make sure that a package is not installed. DCNL name DCNL The name of the package to uninstall DCNL user DCNL The user under which to run pip DCNL bin_env : None DCNL the pip executable or virtualenenv to use DCNL use_vt DCNL Use VT terminal emulation (see output while installing)'
'Enqueue longjob for taking backup to dropbox'
'Runs Celery workers, Studio, and LMS.'
'Slice the info axis of `obj` with `indexer`.'
'Check the memory size of the device memory. DCNL The result is cached in the device memory object. DCNL It may query the driver for the memory size of the device memory allocation.'
'Filters the contents of the block through variable filters. DCNL Filters can also be piped through each other, and they can have DCNL arguments -- just like in variable syntax. DCNL Sample usage:: DCNL {% filter force_escape|lower %} DCNL This text will be HTML-escaped, and will appear in lowercase. DCNL {% endfilter %} DCNL Note that the ``escape`` and ``safe`` filters are not acceptable arguments. DCNL Instead, use the ``autoescape`` tag to manage autoescaping for blocks of DCNL template code.'
'Returns a list with all non-special queue names for app_id.'
'Redirects the user to the requests URL with the given key appended to the query parameters.'
'Checks if a route exists. DCNL .. versionadded:: 2015.8.0 DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_vpc.route_exists destination_cidr_block=\'10.0.0.0/20\' gateway_id=\'local\' route_table_name=\'test\''
'Wrap API calls with role based access controls (RBAC). DCNL This handles both the protection of the API parameters as well as any DCNL target entities for single-entity API calls. DCNL More complex API calls (for example that deal with several different DCNL entities) should pass in a callback function, that will be subsequently DCNL called to check protection for these multiple entities. This callback DCNL function should gather the appropriate entities needed and then call DCNL check_protection() in the V3Controller class.'
'>>> list(_domain_variants("foo.bar.example.com")) DCNL [\'foo.bar.example.com\', \'bar.example.com\', \'example.com\']'
'Returns elapsed time from start till now'
'Recursively collects a list of dirs that contain a file matching the DCNL given suffix. DCNL This works by listing the contents of directories and finding DCNL directories that have `*_test.py` files.'
'monkey patch OptionParser.expand_default since we have a particular DCNL way to handle defaults to avoid overriding values in the configuration DCNL file'
'Shortcut for password prompts. DCNL This is equivalent to decorating a function with :func:`option` with DCNL the following parameters:: DCNL @click.command() DCNL @click.option(\'--password\', prompt=True, confirmation_prompt=True, DCNL hide_input=True) DCNL def changeadmin(password): DCNL pass'
'Stop the specified service DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' service.stop <service name>'
'Validation. DCNL This example validates parameters in different ways.  It does it DCNL through callbacks, through a custom type as well as by validating DCNL manually in the function.'
'Call C{f} with C{args} positional arguments and C{kwargs} keyword arguments DCNL and collect all warnings which are emitted as a result in a list. DCNL @param observeWarning: A callable which will be invoked with a L{_Warning} DCNL instance each time a warning is emitted. DCNL @return: The return value of C{f(*args, **kwargs)}.'
'Returns an array of current comments for a filediff, sorted by line number. DCNL Each entry in the array has a dictionary containing the following keys: DCNL Key                Description DCNL comment_id         The ID of the comment DCNL text               The plain or rich text of the comment DCNL rich_text          The rich text flag for the comment DCNL line               The first line number DCNL num_lines          The number of lines this comment spans DCNL user               A dictionary containing "username" and "name" keys DCNL for the user DCNL url                The URL to the comment DCNL localdraft         True if this is the current user\'s draft comment DCNL review_id          The ID of the review this comment is associated with'
'Match Requests for Sites'
'Get TV (PRIVATE). DCNL Arguments: DCNL - T - proportions of transitional differences DCNL - V - proportions of transversional differences'
'Returns a list of failing checks.'
'This helper function computes a batch start and end index DCNL :param batch_nb: the batch number DCNL :param data_length: the total length of the data being parsed by batches DCNL :param batch_size: the number of inputs in each batch DCNL :return: pair of (start, end) indices'
'import main (non child) document'
'fmtstr_payload(offset, writes, numbwritten=0, write_size=\'byte\') -> str DCNL Makes payload with given parameter. DCNL It can generate payload for 32 or 64 bits architectures. DCNL The size of the addr is taken from ``context.bits`` DCNL Arguments: DCNL offset(int): the first formatter\'s offset you control DCNL writes(dict): dict with addr, value ``{addr: value, addr2: value2}`` DCNL numbwritten(int): number of byte already written by the printf function DCNL write_size(str): must be ``byte``, ``short`` or ``int``. Tells if you want to write byte by byte, short by short or int by int (hhn, hn or n) DCNL Returns: DCNL The payload in order to do needed writes DCNL Examples: DCNL >>> context.clear(arch = \'amd64\') DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'int\')) DCNL \'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00%322419374c%1$n%3972547906c%2$n\' DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'short\')) DCNL \'\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00%47774c%1$hn%22649c%2$hn%60617c%3$hn%4$hn\' DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'byte\')) DCNL \'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00%126c%1$hhn%252c%2$hhn%125c%3$hhn%220c%4$hhn%237c%5$hhn%6$hhn%7$hhn%8$hhn\' DCNL >>> context.clear(arch = \'i386\') DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'int\')) DCNL \'\x00\x00\x00\x00%322419386c%1$n\' DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'short\')) DCNL \'\x00\x00\x00\x00\x02\x00\x00\x00%47798c%1$hn%22649c%2$hn\' DCNL >>> print repr(fmtstr_payload(1, {0x0: 0x1337babe}, write_size=\'byte\')) DCNL \'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00%174c%1$hhn%252c%2$hhn%125c%3$hhn%220c%4$hhn\''
'Create terminals. DCNL nodes: list of Node objects DCNL title: base title for each DCNL returns: list of created tunnel/terminal processes'
'Set whether network time is on or off. DCNL :param enable: True to enable, False to disable. Can also use \'on\' or \'off\' DCNL :type: str bool DCNL :return: True if successful, False if not DCNL :rtype: bool DCNL :raises: CommandExecutionError on failure DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' timezone.set_using_network_time True'
'Read a cache file from the given stream DCNL :return: tuple(version, entries_dict, extension_data, content_sha) DCNL * version is the integer version number DCNL * entries dict is a dictionary which maps IndexEntry instances to a path at a stage DCNL * extension_data is \'\' or 4 bytes of type + 4 bytes of size + size bytes DCNL * content_sha is a 20 byte sha on all cache file contents'
'The constructor basically works.'
'Get vector3 vertexes from attribute dictionary.'
'Download the data from Yann\'s website, unless it\'s already here.'
'Calls the Salt module "probes" to configure the probes on the device.'
'Return a list of subsections for the given ``section``.'
'Recreate tags from a list of tuples into the Amazon Tag format. DCNL Args: DCNL list_of_tags (list): List of tuples. DCNL Basic Usage: DCNL >>> list_of_tags = [(\'Env\', \'Development\')] DCNL >>> recreate_tags_from_list(list_of_tags) DCNL "Value": "Development", DCNL "Key": "Env" DCNL Returns: DCNL List'
'Parse a Sphinx search index DCNL Parameters DCNL searchindex : str DCNL The Sphinx search index (contents of searchindex.js) DCNL Returns DCNL filenames : list of str DCNL The file names parsed from the search index. DCNL objects : dict DCNL The objects parsed from the search index.'
'Attempts access nested data structures and not blow up on a gross key DCNL error DCNL "hello": { DCNL "hi": 5'
'Remove buckets that are unnecessary in achieving the spend amount'
'Convenient interface to check_output'
'Returns a list of matching objects'
'Look up the index of ``scope`` and raise a descriptive value error DCNL if not defined.'
'generate rss feed'
'Set up & run a `Publisher` for command-line-based file I/O (input and DCNL output file paths taken automatically from the command line).  Return the DCNL encoded string output also. DCNL Parameters: see `publish_programmatically` for the remainder. DCNL - `argv`: Command-line argument list to use instead of ``sys.argv[1:]``. DCNL - `usage`: Usage string, output if there\'s a problem parsing the command DCNL line. DCNL - `description`: Program description, output for the "--help" option DCNL (along with command-line option descriptions).'
'Remove a cluster admin or a database user. DCNL If a database is specified: it will remove the database user. DCNL If a database is not specified: it will remove the cluster admin. DCNL name DCNL User name to remove DCNL database DCNL The database to remove the user from DCNL user DCNL User name for the new user to delete DCNL user DCNL The user to connect as DCNL password DCNL The password of the user DCNL host DCNL The host to connect to DCNL port DCNL The port to connect to DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' influxdb08.user_remove <name> DCNL salt \'*\' influxdb08.user_remove <name> <database> DCNL salt \'*\' influxdb08.user_remove <name> <database> <user> <password> <host> <port>'
'For example, the base url of uk.reuters.com => reuters.com'
'Convert into classpath relative to a directory. DCNL This is eventually used by a jar file located in this directory as its manifest DCNL attribute Class-Path. See DCNL https://docs.oracle.com/javase/7/docs/technotes/guides/extensions/spec.html#bundled DCNL :param list classpath: Classpath to be relativized. DCNL :param string root_dir: directory to relativize urls in the classpath, does not DCNL have to exist yet. DCNL :param bool followlinks: whether to follow symlinks to calculate relative path. DCNL :returns: Converted classpath of the same size as input classpath. DCNL :rtype: list of strings'
'Byte-compile a collection of Python source files to either .pyc DCNL or .pyo files in the same directory.  \'py_files\' is a list of files DCNL to compile; any files that don\'t end in ".py" are silently skipped. DCNL \'optimize\' must be one of the following: DCNL 0 - don\'t optimize (generate .pyc) DCNL 1 - normal optimization (like "python -O") DCNL 2 - extra optimization (like "python -OO") DCNL If \'force\' is true, all files are recompiled regardless of DCNL timestamps. DCNL The source filename encoded in each bytecode file defaults to the DCNL filenames listed in \'py_files\'; you can modify these with \'prefix\' and DCNL \'basedir\'.  \'prefix\' is a string that will be stripped off of each DCNL source filename, and \'base_dir\' is a directory name that will be DCNL prepended (after \'prefix\' is stripped).  You can supply either or both DCNL (or neither) of \'prefix\' and \'base_dir\', as you wish. DCNL If \'dry_run\' is true, doesn\'t actually do anything that would DCNL affect the filesystem. DCNL Byte-compilation is either done directly in this interpreter process DCNL with the standard py_compile module, or indirectly by writing a DCNL temporary script and executing it.  Normally, you should let DCNL \'byte_compile()\' figure out to use direct compilation or not (see DCNL the source for details).  The \'direct\' flag is used by the script DCNL generated in indirect mode; unless you know what you\'re doing, leave DCNL it set to None.'
'Hours since a given timestamp. Floating point.'
'ensure volume exists and has properties set DCNL name : string DCNL name of volume DCNL volume_size : string DCNL size of volume DCNL sparse : boolean DCNL create sparse volume DCNL create_parent : boolean DCNL creates all the non-existing parent datasets. DCNL any property specified on the command line using the -o option is ignored. DCNL cloned_from : string DCNL name of snapshot to clone DCNL properties : dict DCNL additional zfs properties (-o) DCNL .. note:: DCNL ``cloned_from`` is only use if the volume does not exist yet, DCNL when ``cloned_from`` is set after the volume exists it will be ignored. DCNL .. note:: DCNL Properties do not get cloned, if you specify the properties in the state file DCNL they will be applied on a subsequent run. DCNL ``volume_size`` is considered a property, so the volume\'s size will be DCNL corrected when the properties get updated if it differs from the DCNL original volume. DCNL The sparse parameter is ignored when using ``cloned_from``.'
'Prepare the authorization grant request URI. DCNL The client constructs the request URI by adding the following DCNL parameters to the query component of the authorization endpoint URI DCNL using the ``application/x-www-form-urlencoded`` format as defined by DCNL [`W3C.REC-html401-19991224`_]: DCNL :param response_type: To indicate which OAuth 2 grant/flow is required, DCNL "code" and "token". DCNL :param client_id: The client identifier as described in `Section 2.2`_. DCNL :param redirect_uri: The client provided URI to redirect back to after DCNL authorization as described in `Section 3.1.2`_. DCNL :param scope: The scope of the access request as described by DCNL `Section 3.3`_. DCNL :param state: An opaque value used by the client to maintain DCNL state between the request and callback.  The authorization DCNL server includes this value when redirecting the user-agent DCNL back to the client.  The parameter SHOULD be used for DCNL preventing cross-site request forgery as described in DCNL `Section 10.12`_. DCNL :param kwargs: Extra arguments to embed in the grant/authorization URL. DCNL An example of an authorization code grant authorization URL: DCNL .. code-block:: http DCNL GET /authorize?response_type=code&client_id=s6BhdRkqt3&state=xyz DCNL &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb HTTP/1.1 DCNL Host: server.example.com DCNL .. _`W3C.REC-html401-19991224`: http://tools.ietf.org/html/rfc6749#ref-W3C.REC-html401-19991224 DCNL .. _`Section 2.2`: http://tools.ietf.org/html/rfc6749#section-2.2 DCNL .. _`Section 3.1.2`: http://tools.ietf.org/html/rfc6749#section-3.1.2 DCNL .. _`Section 3.3`: http://tools.ietf.org/html/rfc6749#section-3.3 DCNL .. _`section 10.12`: http://tools.ietf.org/html/rfc6749#section-10.12'
'@type messages: a list of extended messages.  An extended DCNL message is a (tag, data) tuple, where \'data\' may be L{None}, a DCNL string, or a list of strings to be joined with whitespace. DCNL @returns: String'
'Broadcast values via zeroconf DCNL If the announced values are static, it is adviced to set run_once: True DCNL (do not poll) on the beacon configuration. DCNL The following are required configuration settings: DCNL \'servicetype\': The service type to announce. DCNL \'port\': The port of the service to announce. DCNL \'txt\': The TXT record of the service being announced as a dict. DCNL Grains can be used to define TXT values using the syntax: DCNL grains.<grain_name> DCNL or: DCNL grains.<grain_name>[i] DCNL where i is an integer representing the index of the grain to DCNL use. If the grain is not a list, the index is ignored. DCNL The following are optional configuration settings: DCNL \'servicename\': Set the name of the service. Will use the hostname from DCNL __grains__[\'host\'] if not set. DCNL \'reset_on_change\': If true and there is a change in TXT records DCNL detected, it will stop announcing the service and DCNL then restart announcing the service. This DCNL interruption in service announcement may be DCNL desirable if the client relies on changes in the DCNL browse records to update its cache of the TXT DCNL records. DCNL Defaults to False. DCNL \'reset_wait\': The number of seconds to wait after announcement stops DCNL announcing and before it restarts announcing in the DCNL case where there is a change in TXT records detected DCNL and \'reset_on_change\' is True. DCNL Defaults to 0. DCNL \'copy_grains\': If set to True, it will copy the grains passed into DCNL the beacon when it backs them up to check for changes DCNL on the next iteration. Normally, instead of copy, it DCNL would use straight value assignment. This will allow DCNL detection of changes to grains where the grains are DCNL modified in-place instead of completely replaced. DCNL In-place grains changes are not currently done in the DCNL main Salt code but may be done due to a custom DCNL plug-in. DCNL Defaults to False. DCNL Example Config DCNL .. code-block:: yaml DCNL beacons: DCNL avahi_announce: DCNL run_once: True DCNL servicetype: _demo._tcp DCNL port: 1234 DCNL txt: DCNL ProdName: grains.productname DCNL SerialNo: grains.serialnumber DCNL Comments: \'this is a test\''
'Indicate that the given relationship attribute should remain unloaded. DCNL This function is part of the :class:`.Load` interface and supports DCNL both method-chained and standalone operation. DCNL :func:`.orm.noload` applies to :func:`.relationship` attributes; for DCNL column-based attributes, see :func:`.orm.defer`.'
''
'Loader for species distribution dataset from Phillips et. al. (2006) DCNL Read more in the :ref:`User Guide <datasets>`. DCNL Parameters DCNL data_home : optional, default: None DCNL Specify another download and cache folder for the datasets. By default DCNL all scikit learn data is stored in \'~/scikit_learn_data\' subfolders. DCNL download_if_missing : optional, True by default DCNL If False, raise a IOError if the data is not locally available DCNL instead of trying to download the data from the source site. DCNL Returns DCNL The data is returned as a Bunch object with the following attributes: DCNL coverages : array, shape = [14, 1592, 1212] DCNL These represent the 14 features measured at each point of the map grid. DCNL The latitude/longitude values for the grid are discussed below. DCNL Missing data is represented by the value -9999. DCNL train : record array, shape = (1623,) DCNL The training points for the data.  Each point has three fields: DCNL - train[\'species\'] is the species name DCNL - train[\'dd long\'] is the longitude, in degrees DCNL - train[\'dd lat\'] is the latitude, in degrees DCNL test : record array, shape = (619,) DCNL The test points for the data.  Same format as the training data. DCNL Nx, Ny : integers DCNL The number of longitudes (x) and latitudes (y) in the grid DCNL x_left_lower_corner, y_left_lower_corner : floats DCNL The (x,y) position of the lower-left corner, in degrees DCNL grid_size : float DCNL The spacing between points of the grid, in degrees DCNL Notes DCNL This dataset represents the geographic distribution of species. DCNL The dataset is provided by Phillips et. al. (2006). DCNL The two species are: DCNL - `"Bradypus variegatus" DCNL <http://www.iucnredlist.org/details/3038/0>`_ , DCNL the Brown-throated Sloth. DCNL - `"Microryzomys minutus" DCNL <http://www.iucnredlist.org/details/13408/0>`_ , DCNL also known as the Forest Small Rice Rat, a rodent that lives in Peru, DCNL Colombia, Ecuador, Peru, and Venezuela. DCNL References DCNL * `"Maximum entropy modeling of species geographic distributions" DCNL <http://www.cs.princeton.edu/~schapire/papers/ecolmod.pdf>`_ DCNL S. J. Phillips, R. P. Anderson, R. E. Schapire - Ecological Modelling, DCNL 190:231-259, 2006. DCNL Notes DCNL * See examples/applications/plot_species_distribution_modeling.py DCNL for an example of using this dataset with scikit-learn'
'List the contents of the auto master DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' mount.automaster'
'Test ICA data raw buffer rejection.'
'Checks if the name is can be parsed back to its original form for both single and multi episodes. DCNL :return: true if the naming is valid, false if not.'
'If the requested RGB shade contains a negative weight for DCNL one of the primaries, it lies outside the colour gamut DCNL accessible from the given triple of primaries.  Desaturate DCNL it by adding white, equal quantities of R, G, and B, enough DCNL to make RGB all positive.  The function returns 1 if the DCNL components were modified, zero otherwise.'
'Parse the test data set into a namedtuple to use in tests. DCNL Returns: DCNL A list of namedtuples with str attributes: input, keep, no_keep'
'Parse the network line'
'Generates a permission class that grants access if a particular profile field is DCNL shared with the requesting user.'
'Fix value of `epoch` to be epoch, which should be 10 or fewer digits long. DCNL :arg epoch: An epoch timestamp, in epoch + milliseconds, or microsecond, or DCNL even nanoseconds. DCNL :rtype: int'
'Uninstall one or several pecl extensions. DCNL pecls DCNL The pecl extensions to uninstall. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' pecl.uninstall fuse'
'Makes an user coach on the master course. DCNL This function is needed because an user cannot become a coach of the CCX if s/he is not DCNL coach on the master course. DCNL Args: DCNL user (User): User object DCNL master_course_key (CourseKey): Key locator object for the course'
'uniform weights for HAC DCNL this will be moved to another module DCNL Parameters DCNL nlags : int DCNL highest lag in the kernel window, this does not include the zero lag DCNL Returns DCNL kernel : ndarray, (nlags+1,) DCNL weights for uniform kernel'
'Generate an SQL expression string with bound parameters rendered inline DCNL for the given SQLAlchemy statement. DCNL WARNING: This method of escaping is insecure, incomplete, and for debugging DCNL purposes only. Executing SQL statements with inline-rendered user values is DCNL extremely insecure.'
'Return a list of all available kernel modules DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' kmod.available'
'return clonespec only if values are valid'
'lettuce should be able to receive emails sent from django server'
'Execute a chef client run and return a dict with the stderr, stdout, DCNL return code, and pid. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' chef.client server=https://localhost DCNL server DCNL The chef server URL DCNL client_key DCNL Set the client key file location DCNL config DCNL The configuration file to use DCNL config-file-jail DCNL Directory under which config files are allowed to be loaded DCNL (no client.rb or knife.rb outside this path will be loaded). DCNL environment DCNL Set the Chef Environment on the node DCNL group DCNL Group to set privilege to DCNL json-attributes DCNL Load attributes from a JSON file or URL DCNL localmode DCNL Point chef-client at local repository if True DCNL log_level DCNL Set the log level (debug, info, warn, error, fatal) DCNL logfile DCNL Set the log file location DCNL node-name DCNL The node name for this client DCNL override-runlist DCNL Replace current run list with specified items for a single run DCNL pid DCNL Set the PID file location, defaults to /tmp/chef-client.pid DCNL run-lock-timeout DCNL Set maximum duration to wait for another client run to finish, DCNL default is indefinitely. DCNL runlist DCNL Permanently replace current run list with specified items DCNL user DCNL User to set privilege to DCNL validation_key DCNL Set the validation key file location, used for registering new clients DCNL whyrun DCNL Enable whyrun mode when set to True'
'Use source field to set repository account'
'Set whether or not the computer will wake from sleep when network activity DCNL is detected. DCNL :param bool enabled: True to enable, False to disable. "On" and "Off" are DCNL also acceptable values. Additionally you can pass 1 and 0 to represent True DCNL and False respectively DCNL :return: True if successful, False if not DCNL :rtype: bool DCNL CLI Example: DCNL .. code-block:: bash DCNL salt \'*\' power.set_wake_on_network True'
'Checks all files with the file_check function provided, skipping files DCNL that contain any of the strings in the set provided by exclusions.'
'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!'
'Uninstalls one or more packages if installed.'
'Get the returner options from salt.'
'Replacement for os.listdir that works in frozen environments.'
'Return the object_id of the device value. DCNL The object_id contains node_id and value instance id DCNL to not collide with other entity_ids.'
'Computes the alpha confidence interval for the selected quantiles of the DCNL data, with Maritz-Jarrett estimators. DCNL Parameters DCNL data : ndarray DCNL Data array. DCNL prob : sequence, optional DCNL Sequence of quantiles to compute. DCNL alpha : float, optional DCNL Confidence level of the intervals. DCNL axis : int or None, optional DCNL Axis along which to compute the quantiles. DCNL If None, use a flattened array.'
'Get all pools.'
'Get a list of cpus to build metric definitions with'
'Test append outside private mode.'
'Return a signature scheme object `PKCS115_SigScheme` that DCNL can create or verify PKCS#1 v1.5 signatures. DCNL :Parameters: DCNL rsa_key : RSA key object DCNL The RSA key to use to sign or verify the message. DCNL This is a `Cryptodome.PublicKey.RSA` object. DCNL Signing is only possible if ``rsa_key`` is a private RSA key.'
'Load an email backend and return an instance of it. DCNL If backend is None (default) settings.EMAIL_BACKEND is used. DCNL Both fail_silently and other keyword arguments are used in the DCNL constructor of the backend.'
'Detect supported CUDA hardware and print a summary of the detected hardware. DCNL Returns a boolean indicating whether any supported devices were detected.'
'Collect SHA1s of files and directories for specified tree. DCNL :param obj_store: Object store to get objects by SHA from DCNL :param tree_sha: tree reference to walk DCNL :param kset: set to fill with references to files and directories'
'Destroy a VM instance. Assumes VM is powered off.'
'Calculate the log likelihood of the observed topic proportions. DCNL A negative likelihood is more likely than a negative likelihood. DCNL Args: DCNL weights (chainer.Variable): Unnormalized weight vector. The vector DCNL will be passed through a softmax function that will map the input DCNL onto a probability simplex. DCNL alpha (float): The Dirichlet concentration parameter. Alpha DCNL greater than 1.0 results in very dense topic weights such DCNL that each document belongs to many topics. Alpha < 1.0 results DCNL in sparser topic weights. The default is to set alpha to DCNL 1.0 / n_topics, effectively enforcing the prior belief that a DCNL document belong to very topics at once. DCNL Returns: DCNL ~chainer.Variable: Output loss variable.'
'Tries to load data from cache location otherwise downloads it. If it DCNL downloads the data and cache is not None then it will put the downloaded DCNL data in the cache path.'
'Creates a network acl entry. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt myminion boto_vpc.create_network_acl_entry \'acl-5fb85d36\' \'32767\' \ DCNL \'all\' \'deny\' \'0.0.0.0/0\' egress=true'
'A ``PClass`` field which checks that the assigned value provides all the DCNL ``interfaces``. DCNL :param tuple interfaces: The ``Interface`` that a value must provide.'
'Delete a resource from a dataset. DCNL You must be a sysadmin or the owner of the resource to delete it. DCNL :param id: the id of the resource DCNL :type id: string'
'Split the specified file at multiple locations (all tags that match the specified XPath expression. See also: :func:`split`. DCNL Splitting automatically migrates all links and references to the affected DCNL files. DCNL :param before: If True the splits occur before the identified element otherwise after it.'
'Create a pool on the F5 load balancer DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt-run f5.create_pool load_balancer pool_name loadbalance_method DCNL salt-run f5.create_pool load_balancer my_pool ROUND_ROBIN'
'View all the threads in a discussion forum.'
'Read an unsigned 64-bit integer'
'Helper function to get an object. DCNL Args: DCNL default: A default to return if the object does not exist.'
'usage: lx extend-links http://kuai.xunlei.com/d/... http://www.verycd.com/topics/... DCNL parse and print links from pages DCNL lx extend-links urls... DCNL lx extend-links --name urls...'
'Creates an outgoing message and passes it to the router to be processed DCNL and sent via the respective backend. DCNL Arbitrary arguments are passed along to DCNL :py:meth:`~rapidsms.router.blocking.BlockingRouter.new_outgoing_message`. DCNL :param text: text message DCNL :param connections: list or QuerySet of RapidSMS DCNL :py:class:`~rapidsms.models.Connection` objects DCNL :param kwargs: Extra kwargs to pass to DCNL :py:class:`~rapidsms.messages.outgoing.OutgoingMessage` constructor DCNL :returns: message constructed by router. A returned DCNL message object does not indicate that router processing has DCNL finished or even started, as this depends on the router defined DCNL in :setting:`RAPIDSMS_ROUTER`. DCNL :rtype: :py:class:`~rapidsms.messages.outgoing.OutgoingMessage`'
'Renders a configuration template (default: Jinja) and loads the result on the device. DCNL By default this function will commit the changes. If there are no changes, DCNL it does not commit, discards he config and the flag ``already_configured`` DCNL will be set as ``True`` to point this out. DCNL To avoid committing the configuration, set the argument ``test`` to ``True`` DCNL and will discard (dry run). DCNL To preserve the chnages, set ``commit`` to ``False``. DCNL However, this is recommended to be used only in exceptional cases DCNL when there are applied few consecutive states DCNL and/or configuration changes. DCNL Otherwise the user might forget that the config DB is locked DCNL and the candidate config buffer is not cleared/merged in the running config. DCNL To replace the config, set ``replace`` to ``True``. DCNL template_name DCNL Identifies path to the template source. DCNL The template can be either stored on the local machine, either remotely. DCNL The recommended location is under the ``file_roots`` DCNL as specified in the master config file. DCNL For example, let\'s suppose the ``file_roots`` is configured as: DCNL .. code-block:: yaml DCNL file_roots: DCNL base: DCNL - /etc/salt/states DCNL Placing the template under ``/etc/salt/states/templates/example.jinja``, DCNL it can be used as ``salt://templates/example.jinja``. DCNL Alternatively, for local files, the user can specify the abolute path. DCNL If remotely, the source can be retrieved via ``http``, ``https`` or ``ftp``. DCNL Examples: DCNL - ``salt://my_template.jinja`` DCNL - ``/absolute/path/to/my_template.jinja`` DCNL - ``http://example.com/template.cheetah`` DCNL - ``https:/example.com/template.mako`` DCNL - ``ftp://example.com/template.py`` DCNL template_source: None DCNL Inline config template to be rendered and loaded on the device. DCNL template_path: None DCNL Required only in case the argument ``template_name`` provides only the file basename DCNL when referencing a local template using the absolute path. DCNL E.g.: if ``template_name`` is specified as ``my_template.jinja``, DCNL in order to find the template, this argument must be provided: DCNL ``template_path: /absolute/path/to/``. DCNL template_hash: None DCNL Hash of the template file. Format: ``{hash_type: \'md5\', \'hsum\': <md5sum>}`` DCNL .. versionadded:: 2016.11.2 DCNL template_hash_name: None DCNL When ``template_hash`` refers to a remote file, DCNL this specifies the filename to look for in that file. DCNL .. versionadded:: 2016.11.2 DCNL template_group: root DCNL Owner of file. DCNL .. versionadded:: 2016.11.2 DCNL template_user: root DCNL Group owner of file. DCNL .. versionadded:: 2016.11.2 DCNL template_user: 755 DCNL Permissions of file. DCNL .. versionadded:: 2016.11.2 DCNL saltenv: base DCNL Specifies the template environment. DCNL This will influence the relative imports inside the templates. DCNL .. versionadded:: 2016.11.2 DCNL template_engine: jinja DCNL The following templates engines are supported: DCNL - :mod:`cheetah<salt.renderers.cheetah>` DCNL - :mod:`genshi<salt.renderers.genshi>` DCNL - :mod:`jinja<salt.renderers.jinja>` DCNL - :mod:`mako<salt.renderers.mako>` DCNL - :mod:`py<salt.renderers.py>` DCNL - :mod:`wempy<salt.renderers.wempy>` DCNL .. versionadded:: 2016.11.2 DCNL skip_verify: True DCNL If ``True``, hash verification of remote file sources DCNL (``http://``, ``https://``, ``ftp://``) will be skipped, DCNL and the ``source_hash`` argument will be ignored. DCNL .. versionadded:: 2016.11.2 DCNL test: False DCNL Dry run? If set to ``True``, will apply the config, DCNL discard and return the changes. DCNL Default: ``False`` and will commit the changes on the device. DCNL commit: True DCNL Commit? (default: ``True``) DCNL debug: False DCNL Debug mode. Will insert a new key under the output dictionary, DCNL as ``loaded_config`` contaning the raw result after the template was rendered. DCNL .. versionadded:: 2016.11.2 DCNL replace: False DCNL Load and replace the configuration. DCNL .. versionadded:: 2016.11.2 DCNL defaults: None DCNL Default variables/context passed to the template. DCNL .. versionadded:: 2016.11.2 DCNL **template_vars DCNL Dictionary with the arguments/context to be used when the template is rendered. DCNL .. note:: DCNL Do not explicitely specify this argument. DCNL This represents any other variable that will be sent DCNL to the template rendering system. DCNL Please see the examples below! DCNL :return: a dictionary having the following keys: DCNL * result (bool): if the config was applied successfully. It is ``False`` only in case of failure. In case     there are no changes to be applied and successfully performs all operations it is still ``True`` and so will be     the ``already_configured`` flag (example below) DCNL * comment (str): a message for the user DCNL * already_configured (bool): flag to check if there were no changes applied DCNL * loaded_config (str): the configuration loaded on the device, after rendering the template. Requires ``debug``     to be set as ``True`` DCNL * diff (str): returns the config changes applied DCNL The template can use variables from the ``grains``, ``pillar`` or ``opts``, for example: DCNL .. code-block:: jinja DCNL {% set router_model = grains.get(\'model\') -%} DCNL {% set router_vendor = grains.get(\'vendor\') -%} DCNL {% set os_version = grains.get(\'version\') -%} DCNL {% set hostname = pillar.get(\'proxy\', {}).get(\'host\') -%} DCNL {% if router_vendor|lower == \'juniper\' %} DCNL system { DCNL host-name {{hostname}}; DCNL {% elif router_vendor|lower == \'cisco\' %} DCNL hostname {{hostname}} DCNL {% endif %} DCNL CLI Examples: DCNL .. code-block:: bash DCNL salt \'*\' net.load_template set_ntp_peers peers=[192.168.0.1]  # uses NAPALM default templates DCNL # inline template: DCNL salt -G \'os:junos\' net.load_template set_hostname template_source=\'system { host-name {{host_name}}; }\'         host_name=\'MX480.lab\' DCNL # inline template using grains info: DCNL salt -G \'os:junos\' net.load_template set_hostname         template_source=\'system { host-name {{grains.model}}.lab; }\' DCNL # if the device is a MX480, the command above will set the hostname as: MX480.lab DCNL # inline template using pillar data: DCNL salt -G \'os:junos\' net.load_template set_hostname template_source=\'system { host-name {{pillar.proxy.host}}; }\' DCNL salt \'*\' net.load_template my_template template_path=\'/tmp/tpl/\' my_param=\'aaa\'  # will commit DCNL salt \'*\' net.load_template my_template template_path=\'/tmp/tpl/\' my_param=\'aaa\' test=True  # dry run DCNL salt \'*\' net.load_template salt://templates/my_stuff.jinja debug=True  # equivalent of the next command DCNL salt \'*\' net.load_template my_stuff.jinja template_path=salt://templates/ debug=True DCNL # in case the template needs to include files that are not under the same path (e.g. http://), DCNL # to help the templating engine find it, you will need to specify the `saltenv` argument: DCNL salt \'*\' net.load_template my_stuff.jinja template_path=salt://templates saltenv=/path/to/includes debug=True DCNL # render a mako template: DCNL salt \'*\' net.load_template salt://templates/my_stuff.mako template_engine=mako debug=True DCNL # render remote template DCNL salt -G \'os:junos\' net.load_template http://bit.ly/2fReJg7 test=True debug=True peers=[\'192.168.0.1\'] DCNL salt -G \'os:ios\' net.load_template http://bit.ly/2gKOj20 test=True debug=True peers=[\'192.168.0.1\'] DCNL Example output: DCNL .. code-block:: python DCNL \'comment\': \'\', DCNL \'already_configured\': False, DCNL \'result\': True, DCNL \'diff\': \'[edit system]+  host-name edge01.bjm01\', DCNL \'loaded_config\': \'system { host-name edge01.bjm01; }\'\''
'Create a caffe Datum from a numpy.ndarray'
'Test the translation model.'
'Get row and column cals.'
'Opportunity view'
'Start a droplet in DigitalOcean. DCNL .. versionadded:: 2015.8.8 DCNL name DCNL The name of the droplet to start. DCNL CLI Example: DCNL .. code-block:: bash DCNL salt-cloud -a start droplet_name'
'Inpaint masked points in image with biharmonic equations. DCNL Parameters DCNL img : (M[, N[, ..., P]][, C]) ndarray DCNL Input image. DCNL mask : (M[, N[, ..., P]]) ndarray DCNL Array of pixels to be inpainted. Have to be the same shape as one DCNL of the \'img\' channels. Unknown pixels have to be represented with 1, DCNL known pixels - with 0. DCNL multichannel : boolean, optional DCNL If True, the last `img` dimension is considered as a color channel, DCNL otherwise as spatial. DCNL Returns DCNL out : (M[, N[, ..., P]][, C]) ndarray DCNL Input image with masked pixels inpainted. DCNL References DCNL .. [1]  N.S.Hoang, S.B.Damelin, "On surface completion and image inpainting DCNL by biharmonic functions: numerical aspects", DCNL http://www.ima.umn.edu/~damelin/biharmonic DCNL Examples DCNL >>> img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1)) DCNL >>> mask = np.zeros_like(img) DCNL >>> mask[2, 2:] = 1 DCNL >>> mask[1, 3:] = 1 DCNL >>> mask[0, 4:] = 1 DCNL >>> out = inpaint_biharmonic(img, mask)'
'get test result and reset test_results'
'Apply a Savitzky-Golay filter to an array. DCNL This is a 1-d filter.  If `x`  has dimension greater than 1, `axis` DCNL determines the axis along which the filter is applied. DCNL Parameters DCNL x : array_like DCNL The data to be filtered.  If `x` is not a single or double precision DCNL floating point array, it will be converted to type `numpy.float64` DCNL before filtering. DCNL window_length : int DCNL The length of the filter window (i.e. the number of coefficients). DCNL `window_length` must be a positive odd integer. DCNL polyorder : int DCNL The order of the polynomial used to fit the samples. DCNL `polyorder` must be less than `window_length`. DCNL deriv : int, optional DCNL The order of the derivative to compute.  This must be a DCNL nonnegative integer.  The default is 0, which means to filter DCNL the data without differentiating. DCNL delta : float, optional DCNL The spacing of the samples to which the filter will be applied. DCNL This is only used if deriv > 0.  Default is 1.0. DCNL axis : int, optional DCNL The axis of the array `x` along which the filter is to be applied. DCNL Default is -1. DCNL mode : str, optional DCNL Must be \'mirror\', \'constant\', \'nearest\', \'wrap\' or \'interp\'.  This DCNL determines the type of extension to use for the padded signal to DCNL which the filter is applied.  When `mode` is \'constant\', the padding DCNL value is given by `cval`.  See the Notes for more details on \'mirror\', DCNL \'constant\', \'wrap\', and \'nearest\'. DCNL When the \'interp\' mode is selected (the default), no extension DCNL is used.  Instead, a degree `polyorder` polynomial is fit to the DCNL last `window_length` values of the edges, and this polynomial is DCNL used to evaluate the last `window_length // 2` output values. DCNL cval : scalar, optional DCNL Value to fill past the edges of the input if `mode` is \'constant\'. DCNL Default is 0.0. DCNL Returns DCNL y : ndarray, same shape as `x` DCNL The filtered data. DCNL See Also DCNL savgol_coeffs DCNL Notes DCNL Details on the `mode` options: DCNL \'mirror\': DCNL Repeats the values at the edges in reverse order.  The value DCNL closest to the edge is not included. DCNL \'nearest\': DCNL The extension contains the nearest input value. DCNL \'constant\': DCNL The extension contains the value given by the `cval` argument. DCNL \'wrap\': DCNL The extension contains the values from the other end of the array. DCNL For example, if the input is [1, 2, 3, 4, 5, 6, 7, 8], and DCNL `window_length` is 7, the following shows the extended data for DCNL the various `mode` options (assuming `cval` is 0):: DCNL mode       |   Ext   |         Input          |   Ext DCNL \'mirror\'   | 4  3  2 | 1  2  3  4  5  6  7  8 | 7  6  5 DCNL \'nearest\'  | 1  1  1 | 1  2  3  4  5  6  7  8 | 8  8  8 DCNL \'constant\' | 0  0  0 | 1  2  3  4  5  6  7  8 | 0  0  0 DCNL \'wrap\'     | 6  7  8 | 1  2  3  4  5  6  7  8 | 1  2  3 DCNL .. versionadded:: 0.14.0 DCNL Examples DCNL >>> from scipy.signal import savgol_filter DCNL >>> np.set_printoptions(precision=2)  # For compact display. DCNL >>> x = np.array([2, 2, 5, 2, 1, 0, 1, 4, 9]) DCNL Filter with a window length of 5 and a degree 2 polynomial.  Use DCNL the defaults for all other parameters. DCNL >>> savgol_filter(x, 5, 2) DCNL array([ 1.66,  3.17,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.  ,  9.  ]) DCNL Note that the last five values in x are samples of a parabola, so DCNL when mode=\'interp\' (the default) is used with polyorder=2, the last DCNL three values are unchanged.  Compare that to, for example, DCNL `mode=\'nearest\'`: DCNL >>> savgol_filter(x, 5, 2, mode=\'nearest\') DCNL array([ 1.74,  3.03,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.6 ,  7.97])'
'Test to ensure hug introspection can correctly identify when a function takes kwargs'
'Load a bottle application from a module and make sure that the import DCNL does not affect the current default application, but returns a separate DCNL application object. See :func:`load` for the target parameter.'
'Computes the f1 score for the binary classification. DCNL Computed as, DCNL f1 = 2 * precision * recall / (precision + recall) DCNL Parameters DCNL precision : Variable DCNL Precision score of the binary decisions. DCNL recall : Variable DCNL Recall score of the binary decisions. DCNL Returns DCNL f1 : Variable DCNL f1 score for the binary decisions.'
'Print \'lead\' = \'num\' in \'color\''
'Stacks arrays horizontally. DCNL If an input array has one dimension, then the array is treated as a DCNL horizontal vector and stacked along the first axis. Otherwise, the array is DCNL stacked along the second axis. DCNL Args: DCNL tup (sequence of arrays): Arrays to be stacked. DCNL Returns: DCNL cupy.ndarray: Stacked array. DCNL .. seealso:: :func:`numpy.hstack`'
'Dumps operating system information to file'
'Construct input for CIFAR evaluation using the Reader ops. DCNL Args: DCNL eval_data: bool, indicating if one should use the train or eval data set. DCNL data_dir: Path to the CIFAR-10 data directory. DCNL batch_size: Number of images per batch. DCNL Returns: DCNL images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size. DCNL labels: Labels. 1D tensor of [batch_size] size.'
'Convert a space separated string to a list of scopes.'
'permutations(range(3), 2) --> (0,1) (0,2) (1,0) (1,2) (2,0) (2,1)'
'Given input in this form:: DCNL u\'{"status":"Pulling repository foo/ubuntubox"}: DCNL "image (latest) from foo/  ... DCNL rogress":"complete","id":"2c80228370c9"}\' DCNL construct something like that (load json data is possible):: DCNL [u\'{"status":"Pulling repository foo/ubuntubox"\', DCNL {"status":"Download","progress":"complete","id":"2c80228370c9"}]'
'Get the path for a page in the Cactus build. DCNL We\'ll need this because paths can be rewritten with prettifying.'
'histograms plot'
'TODO'
'Add a `Linker` which can be referred to by `name` in `Mode`.'
'Implements generic MGF1 Mask Generation function as described in DCNL Appendix B.2.1 of RFC 3447. The hash function is passed by name. DCNL valid values are \'md2\', \'md4\', \'md5\', \'sha1\', \'tls, \'sha256\', DCNL \'sha384\' and \'sha512\'. Returns None on error. DCNL Input: DCNL mgfSeed: seed from which mask is generated, an octet string DCNL maskLen: intended length in octets of the mask, at most 2^32 * hLen DCNL hLen (see below) DCNL h      : hash function name (in \'md2\', \'md4\', \'md5\', \'sha1\', \'tls\', DCNL \'sha256\', \'sha384\'). hLen denotes the length in octets of DCNL the hash function output. DCNL Output: DCNL an octet string of length maskLen'
'Helper function to convert an ``Image`` to a gRPC ``Image``. DCNL :type image: :class:`~google.cloud.vision.image.Image` DCNL :param image: Local ``Image`` class to be converted to gRPC ``Image``. DCNL :rtype: :class:`~google.cloud.grpc.vision.v1.image_annotator_pb2.Image` DCNL :returns: gRPC ``Image`` converted from DCNL :class:`~google.cloud.vision.image.Image`.'
'Initialize the cachedir needed for Salt Cloud to keep track of minions'
'Find all installed extensions. DCNL :returns: list of installed extensions'
'Return a list of methods which, when called with a check name, will each return a check path to inspect'
'Remove given tenant from the group type access list.'
'Plot concatenated epochs.'
'>>> from sympy import MatrixSymbol, Q, assuming, refine, det DCNL >>> X = MatrixSymbol(\'X\', 2, 2) DCNL >>> det(X) DCNL Determinant(X) DCNL >>> with assuming(Q.orthogonal(X)): DCNL ...     print(refine(det(X))) DCNL 1'
'If available, returns a RateLimit instance which is valid for the DCNL current request-response. DCNL .. versionadded:: 0.0.7'
'Language: zh-TW -> sucess outlines colorful'
'Upload archive'