Datasets:

semeru

/

text-code-galeras-code-generation-from-docstring-3k-deduped

like 0

Follow

Semeru Lab 7

{ "docstring": "Ensure that caching works properly between different users.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Assign default kwargs for call_func using values from source_func.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n <User Model>.is_anonymous/is_authenticated must not be methods.\n ", "language": "en", "n_whitespaces": 21, "n_words": 6, "vocab_size": 6 }

{ "docstring": "\n Symbol object. Could be a class or a function.\n ``get_hybrid_cls_or_func_name`` and ``import_cls_or_func_from_hybrid_name`` is a pair to\n convert the symbol into a string and convert the string back to symbol.\n ", "language": "en", "n_whitespaces": 58, "n_words": 29, "vocab_size": 21 }

{ "docstring": " Print colored text\n This might not work on windows,\n although travis runs windows stuff in git bash, so it might ?\n ", "language": "en", "n_whitespaces": 31, "n_words": 21, "vocab_size": 20 }

{ "docstring": "Return the color mode of the light with backwards compatibility.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 9 }

{ "docstring": "\\\nbackend: Vulkan\ncpp_namespace: torch_vulkan\nsupported:\n- add\nautograd:\n- subFound an invalid operator name: add", "language": "en", "n_whitespaces": 9, "n_words": 16, "vocab_size": 14 }

{ "docstring": "\n ValidationError(UnionSchema):\n Could not validate union\n Context(dict):\n Unable to validate union 'foo'\n Context(type):\n Type of 'value' should be int, but is str\n ", "language": "en", "n_whitespaces": 113, "n_words": 21, "vocab_size": 19 }

{ "docstring": "\n Tests that events submitted to a trigger re-wake their dependent\n task instances.\n ", "language": "en", "n_whitespaces": 22, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Same as `test_parquet_write` but using a custom, fsspec filesystem.\n\n TODO (Alex): We should write a similar test with a mock PyArrow fs, but\n unfortunately pa.fs._MockFileSystem isn't serializable, so this may require\n some effort.\n ", "language": "en", "n_whitespaces": 45, "n_words": 33, "vocab_size": 30 }

{ "docstring": "Return the dtype object for a value or type, optionally canonicalized based on X64 mode.", "language": "en", "n_whitespaces": 14, "n_words": 15, "vocab_size": 15 }

{ "docstring": "\n Calc `y` position for given `x`.\n\n if `x` is outside the data point's `x` range, return None.\n\n Returns\n -------\n y : float\n y position for given x.\n ", "language": "en", "n_whitespaces": 81, "n_words": 27, "vocab_size": 22 }

{ "docstring": "Enables OCSP Stapling\n\n In OCSP, each client (e.g. browser) would have to query the\n OCSP Responder to validate that the site certificate was not revoked.\n\n Enabling OCSP Stapling, would allow the web-server to query the OCSP\n Responder, and staple its response to the offered certificate during\n TLS. i.e. clients would not have to query the OCSP responder.\n\n OCSP Stapling enablement on Apache implicitly depends on\n SSLCertificateChainFile being set by other code.\n\n .. note:: This function saves the configuration\n\n :param ssl_vhost: Destination of traffic, an ssl enabled vhost\n :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost`\n\n :param unused_options: Not currently used\n :type unused_options: Not Available\n\n :returns: Success, general_vhost (HTTP vhost)\n :rtype: (bool, :class:`~certbot_apache._internal.obj.VirtualHost`)\n\n ", "language": "en", "n_whitespaces": 212, "n_words": 107, "vocab_size": 78 }

{ "docstring": "Test a HTTP -> WebSocket upgrade with different protocols enabled", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Create a shallow copy of this execution plan.\n\n This copy can be executed without mutating the original, but clearing the copy\n will also clear the original.\n\n Returns:\n A shallow copy of this execution plan.\n ", "language": "en", "n_whitespaces": 73, "n_words": 34, "vocab_size": 24 }

{ "docstring": "\n select_on_save works correctly if the database doesn't return correct\n information about matched rows from UPDATE.\n ", "language": "en", "n_whitespaces": 37, "n_words": 15, "vocab_size": 15 }

{ "docstring": "\n Generate the config file if it doesn't exist\n This is done before the argument parser so it doesn't requires `operation`\n and `query` to be passed.\n ", "language": "en", "n_whitespaces": 38, "n_words": 25, "vocab_size": 22 }

{ "docstring": "\n Return a tzinfo of the database connection time zone.\n\n This is only used when time zone support is enabled. When a datetime is\n read from the database, it is always returned in this time zone.\n\n When the database backend supports time zones, it doesn't matter which\n time zone Django uses, as long as aware datetimes are used everywhere.\n Other users connecting to the database can choose their own time zone.\n\n When the database backend doesn't support time zones, the time zone\n Django uses may be constrained by the requirements of other users of\n the database.\n ", "language": "en", "n_whitespaces": 166, "n_words": 95, "vocab_size": 57 }

{ "docstring": "Compare control data with generated output.\n Used abbreviations:\n exp -> expected\n gen -> generated\n sec -> section\n meta -> metadata\n ", "language": "en", "n_whitespaces": 57, "n_words": 20, "vocab_size": 16 }

{ "docstring": "\n Remove the specified categories.\n\n `removals` must be included in the old categories. Values which were in\n the removed categories will be set to NaN\n\n Parameters\n ----------\n removals : category or list of categories\n The categories which should be removed.\n inplace : bool, default False\n Whether or not to remove the categories inplace or return a copy of\n this categorical with removed categories.\n\n .. deprecated:: 1.3.0\n\n Returns\n -------\n cat : Categorical or None\n Categorical with removed categories or None if ``inplace=True``.\n\n Raises\n ------\n ValueError\n If the removals are not contained in the categories\n\n See Also\n --------\n rename_categories : Rename categories.\n reorder_categories : Reorder categories.\n add_categories : Add new categories.\n remove_unused_categories : Remove categories which are not used.\n set_categories : Set the categories to the specified ones.\n\n Examples\n --------\n >>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])\n >>> c\n ['a', 'c', 'b', 'c', 'd']\n Categories (4, object): ['a', 'b', 'c', 'd']\n\n >>> c.remove_categories(['d', 'a'])\n [NaN, 'c', 'b', 'c', NaN]\n Categories (2, object): ['b', 'c']\n ", "language": "en", "n_whitespaces": 435, "n_words": 162, "vocab_size": 94 }

{ "docstring": "\n Enters into sub meta data at the specified path. This always returns a\n new ``Meta`` object, regardless whether the path already exists.\n ", "language": "en", "n_whitespaces": 44, "n_words": 22, "vocab_size": 21 }

{ "docstring": "\n Data for factorization, grouping, and unique tests.\n\n Expected to be like [B, B, NA, NA, A, A, B, C]\n\n Where A < B < C and NA is missing\n ", "language": "en", "n_whitespaces": 42, "n_words": 29, "vocab_size": 24 }

{ "docstring": "Go to the location of the first blank on the given line,\n returning the index of the last non-blank character.", "language": "en", "n_whitespaces": 26, "n_words": 20, "vocab_size": 15 }

{ "docstring": "Return the firmware version of the UPS, if available.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "Print help\n[param]Ticker: [/param]{self.ticker or None}\n[param]Expiry: [/param]{self.selected_date or None}\n[cmds]\n add add an expected price to the list\n rmv remove an expected price from the list\n\n show show the listed of expected prices\n rnval risk neutral valuation for an option[/cmds]\n ", "language": "en", "n_whitespaces": 94, "n_words": 41, "vocab_size": 29 }

{ "docstring": "\n Return the version of the OS distribution, as a tuple of version\n numbers.\n\n For details, see :func:`distro.version_parts`.\n ", "language": "en", "n_whitespaces": 46, "n_words": 17, "vocab_size": 14 }

{ "docstring": "Overload the method of `_BaseHeterogeneousEnsemble` to be more\n lenient towards the type of `estimators`.\n\n Regressors can be accepted for some cases such as ordinal regression.\n ", "language": "en", "n_whitespaces": 46, "n_words": 25, "vocab_size": 22 }

{ "docstring": "Sends a HEAD request. Returns :class:`Response` object.\n\n :param url: URL for the new :class:`Request` object.\n :param \\*\\*kwargs: Optional arguments that ``request`` takes.\n :rtype: requests.Response\n ", "language": "en", "n_whitespaces": 52, "n_words": 24, "vocab_size": 22 }

{ "docstring": "Test that sending a message is not subject to the privacy policies.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Perform a dry run of migrations.\n\n This will create the sql statements without actually running them against the\n database and output them to stdout.\n ", "language": "en", "n_whitespaces": 37, "n_words": 24, "vocab_size": 22 }

{ "docstring": "\n A filter on a FK respects the FK's to_field attribute (#17972).\n ", "language": "en", "n_whitespaces": 26, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Use the AutoCastVariable value itself as a placeholder.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Save the Triton config.\n\n Return the appropriate artifact.\n ", "language": "en", "n_whitespaces": 22, "n_words": 8, "vocab_size": 7 }

{ "docstring": "Close the transport immediately.\n\n Buffered data will be lost. No more data will be received.\n The protocol's connection_lost() method will (eventually) be\n called with None as its argument.\n ", "language": "en", "n_whitespaces": 57, "n_words": 28, "vocab_size": 23 }

{ "docstring": "\n Return a dictionary of attributes suitable for creating a copy of the current instance. This is used for pre-\n populating an object creation form in the UI.\n ", "language": "en", "n_whitespaces": 49, "n_words": 27, "vocab_size": 23 }

{ "docstring": "Called during fit() to preprocess dataset attributes with preprocessor.\n\n .. note:: This method is run on a remote process.\n\n This method is called prior to entering the training_loop.\n\n If the ``Trainer`` has both a datasets dict and\n a preprocessor, the datasets dict contains a training dataset (denoted by\n the \"train\" key), and the preprocessor has not yet\n been fit, then it will be fit on the train dataset.\n\n Then, all Trainer's datasets will be transformed by the preprocessor.\n\n The transformed datasets will be set back in the ``self.datasets`` attribute\n of the Trainer to be used when overriding ``training_loop``.\n ", "language": "en", "n_whitespaces": 168, "n_words": 98, "vocab_size": 66 }

{ "docstring": "Inspects the options to load the requested patterns and handlers.\n\n Returns:\n (pre_order, post_order), where pre_order is the list of fixers that\n want a pre-order AST traversal, and post_order is the list that want\n post-order traversal.\n ", "language": "en", "n_whitespaces": 76, "n_words": 35, "vocab_size": 27 }

{ "docstring": "\n Apply a function to all coloraxis objects that satisfy the\n specified selection criteria\n\n Parameters\n ----------\n fn:\n Function that inputs a single coloraxis object.\n selector: dict, function, or None (default None)\n Dict to use as selection criteria.\n coloraxis objects will be selected if they contain\n properties corresponding to all of the dictionary's keys, with\n values that exactly match the supplied values. If None\n (the default), all coloraxis objects are selected. If a\n function, it must be a function accepting a single argument and\n returning a boolean. The function will be called on each\n coloraxis and those for which the function returned True will\n be in the selection.\n row, col: int or None (default None)\n Subplot row and column index of coloraxis objects to select.\n To select coloraxis objects by row and column, the Figure\n must have been created using plotly.subplots.make_subplots.\n If None (the default), all coloraxis objects are selected.\n Returns\n -------\n self\n Returns the Figure object that the method was called on\n ", "language": "en", "n_whitespaces": 404, "n_words": 161, "vocab_size": 95 }

{ "docstring": "But if the null value is in the first entity, it won't show up in the groupby values, which means the\n transaction will be missing", "language": "en", "n_whitespaces": 31, "n_words": 25, "vocab_size": 21 }

{ "docstring": "query {{\n repository(name: foo, owner: Test-Organization) {{\n ref(qualifiedName: {ref}) {{\n target {{\n ... on Commit {{\n blame(path: {path}) {{\n ranges {{\n commit {{\n oid\n author {{\n name\n email\n }}\n message\n committedDate\n }}\n startingLine\n endingLine\n age\n }}\n }}\n }}\n }}\n }}\n }}\n }}", "language": "en", "n_whitespaces": 792, "n_words": 42, "vocab_size": 26 }

{ "docstring": "Cast iterable x to a Sequence, avoiding a copy if possible.\n\n Parameters\n ----------\n x : iterable\n The iterable to be converted.\n\n Returns\n -------\n x : Sequence\n If `x` is a NumPy array, it returns it as a `ndarray`. If `x`\n is a `Sequence`, `x` is returned as-is. If `x` is from any other\n type, `x` is returned casted as a list.\n ", "language": "en", "n_whitespaces": 110, "n_words": 61, "vocab_size": 37 }

{ "docstring": "\n Determines the rule used to generate the error bars. If\n *constant`, the bar lengths are of a constant value. Set this\n constant in `value`. If \"percent\", the bar lengths correspond\n to a percentage of underlying data. Set this percentage in\n `value`. If \"sqrt\", the bar lengths correspond to the square of\n the underlying data. If \"data\", the bar lengths are set with\n data set `array`.\n\n The 'type' property is an enumeration that may be specified as:\n - One of the following enumeration values:\n ['percent', 'constant', 'sqrt', 'data']\n\n Returns\n -------\n Any\n ", "language": "en", "n_whitespaces": 199, "n_words": 90, "vocab_size": 55 }

{ "docstring": "Fit a multi-class classifier by combining binary classifiers\n\n Each binary classifier predicts one class versus all others. This\n strategy is called OvA (One versus All) or OvR (One versus Rest).\n ", "language": "en", "n_whitespaces": 51, "n_words": 30, "vocab_size": 25 }

{ "docstring": "\n Return a generator for consecutive Pade approximants for a series.\n It can also be used for computing the rational generating function of a\n series when possible, since the last approximant returned by the generator\n will be the generating function (if any).\n\n Explanation\n ===========\n\n The input list can contain more complex expressions than integer or rational\n numbers; symbols may also be involved in the computation. An example below\n show how to compute the generating function of the whole Pascal triangle.\n\n The generator can be asked to apply the sympy.simplify function on each\n generated term, which will make the computation slower; however it may be\n useful when symbols are involved in the expressions.\n\n Examples\n ========\n\n >>> from sympy.series import approximants\n >>> from sympy import lucas, fibonacci, symbols, binomial\n >>> g = [lucas(k) for k in range(16)]\n >>> [e for e in approximants(g)]\n [2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)]\n\n >>> h = [fibonacci(k) for k in range(16)]\n >>> [e for e in approximants(h)]\n [x, -x/(x - 1), (x**2 - x)/(2*x - 1), -x/(x**2 + x - 1)]\n\n >>> x, t = symbols(\"x,t\")\n >>> p=[sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]\n >>> y = approximants(p, t)\n >>> for k in range(3): print(next(y))\n 1\n (x + 1)/((-x - 1)*(t*(x + 1) + (x + 1)/(-x - 1)))\n nan\n\n >>> y = approximants(p, t, simplify=True)\n >>> for k in range(3): print(next(y))\n 1\n -1/(t*(x + 1) - 1)\n nan\n\n See Also\n ========\n\n See function sympy.concrete.guess.guess_generating_function_rational and\n function mpmath.pade\n\n ", "language": "en", "n_whitespaces": 371, "n_words": 253, "vocab_size": 139 }

{ "docstring": "\n Deserialize a Ray object.\n\n Parameters\n ----------\n obj : ObjectIDType, iterable of ObjectIDType, or mapping of keys to ObjectIDTypes\n Object(s) to deserialize.\n\n Returns\n -------\n obj\n The deserialized object.\n ", "language": "en", "n_whitespaces": 66, "n_words": 27, "vocab_size": 22 }

{ "docstring": "Wait for start so origin and destination entities can be resolved.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n GIVEN:\n - File with text in an RTL language\n WHEN:\n - Document is parsed\n THEN:\n - Text from the document is extracted\n ", "language": "en", "n_whitespaces": 84, "n_words": 22, "vocab_size": 19 }

{ "docstring": "\n Determine which side(s) of the conversation to use.\n ", "language": "en", "n_whitespaces": 23, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Generate ground truth target on each level.\n\n Args:\n img_size (list[int]): Shape of input image.\n text_polys (list[list[ndarray]]): A list of ground truth polygons.\n ignore_polys (list[list[ndarray]]): A list of ignored polygons.\n Returns:\n level_maps (list(ndarray)): A list of ground target on each level.\n ", "language": "en", "n_whitespaces": 105, "n_words": 40, "vocab_size": 24 }

{ "docstring": "Assert that the tpot_driver() in TPOT driver outputs normal result with verbosity = 2.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 14 }

{ "docstring": "Check whether the current scope supports NCHW ops.\n\n TensorFlow does not support NCHW on CPU. Therefore we check if we are not\n explicitly put on\n CPU, and have GPUs available. In this case there will be soft-placing on the\n GPU device.\n\n Returns:\n bool: if the current scope device placement would support nchw\n ", "language": "en", "n_whitespaces": 77, "n_words": 52, "vocab_size": 41 }

{ "docstring": "Run search of a resources on the remote Airbyte instance.\n\n Returns:\n Union[SourceReadList, DestinationReadList, ConnectionReadList]: Search results\n ", "language": "en", "n_whitespaces": 41, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Test that ensures that if we basically know the next release when clicking on Resolved\n In Next Release because that release exists, then we can short circuit setting\n GroupResolution to type \"inNextRelease\", and then having `clear_exrired_resolutions` run\n once a new release is created to convert GroupResolution to in_release and set Activity.\n Basically we treat \"ResolvedInNextRelease\" as \"ResolvedInRelease\" when there is a release\n that was created after the last release associated with the group being resolved\n ", "language": "en", "n_whitespaces": 125, "n_words": 75, "vocab_size": 55 }

{ "docstring": "Computes the schreier vector for ``alpha``.\n\n Explanation\n ===========\n\n The Schreier vector efficiently stores information\n about the orbit of ``alpha``. It can later be used to quickly obtain\n elements of the group that send ``alpha`` to a particular element\n in the orbit. Notice that the Schreier vector depends on the order\n in which the group generators are listed. For a definition, see [3].\n Since list indices start from zero, we adopt the convention to use\n \"None\" instead of 0 to signify that an element doesn't belong\n to the orbit.\n For the algorithm and its correctness, see [2], pp.78-80.\n\n Examples\n ========\n\n >>> from sympy.combinatorics import Permutation, PermutationGroup\n >>> a = Permutation([2, 4, 6, 3, 1, 5, 0])\n >>> b = Permutation([0, 1, 3, 5, 4, 6, 2])\n >>> G = PermutationGroup([a, b])\n >>> G.schreier_vector(0)\n [-1, None, 0, 1, None, 1, 0]\n\n See Also\n ========\n\n orbit\n\n ", "language": "en", "n_whitespaces": 304, "n_words": 143, "vocab_size": 97 }

{ "docstring": "\n GIVEN:\n - Certain CPU counts\n WHEN:\n - Threads per worker is calculated\n THEN:\n - Threads per worker less than or equal to CPU count\n - At least 1 thread per worker\n ", "language": "en", "n_whitespaces": 104, "n_words": 31, "vocab_size": 22 }

{ "docstring": "\n query GetProductTypeInFederation($representations: [_Any]) {\n _entities(representations: $representations) {\n __typename\n ... on ProductType {\n id\n name\n }\n }\n }\n ", "language": "en", "n_whitespaces": 94, "n_words": 17, "vocab_size": 13 }

{ "docstring": " Remove the highlighting and stealing of focus that the combobox annoyingly\n implements. ", "language": "en", "n_whitespaces": 20, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n This tests the value set in `self.workspace` in a remote Flow.\n It should always be `/workspace/ExecutorName/...\n ", "language": "en", "n_whitespaces": 26, "n_words": 16, "vocab_size": 15 }

{ "docstring": "\n Test _yes when Chocolatey version is less than 0.9.9\n ", "language": "en", "n_whitespaces": 16, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Called from ImageFile to set the core output image for the codec\n\n :param im: A core image object\n :param extents: a 4 tuple of (x0, y0, x1, y1) defining the rectangle\n for this tile\n :returns: None\n ", "language": "en", "n_whitespaces": 83, "n_words": 36, "vocab_size": 30 }

{ "docstring": "select name from `tabCustomer Group`\n\t\twhere lft <= %s and rgt >= %s\n\t\torder by lft asc", "language": "en", "n_whitespaces": 14, "n_words": 17, "vocab_size": 15 }

{ "docstring": "\n Test that a Slack message is sent with the expected payload when an issue is unassigned\n ", "language": "en", "n_whitespaces": 31, "n_words": 16, "vocab_size": 15 }

{ "docstring": "Converts lists to tuples.\n\n .. deprecated:: 2.8\n\n to_tuple is deprecated and will be removed in NetworkX 3.0.\n\n Examples\n --------\n >>> from networkx.utils import to_tuple\n >>> a_list = [1, 2, [1, 4]]\n >>> to_tuple(a_list)\n (1, 2, (1, 4))\n ", "language": "en", "n_whitespaces": 67, "n_words": 37, "vocab_size": 31 }

{ "docstring": "compute deviance scores on ``X_test`` and ``y_test``.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Return the battery level of the device.\n\n Percentage from 0-100.\n ", "language": "en", "n_whitespaces": 24, "n_words": 10, "vocab_size": 9 }

{ "docstring": "\n Splitting a q object to parts for where/having doesn't alter\n the original q-object.\n ", "language": "en", "n_whitespaces": 35, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Runs validation and Checkpointing if necessary.\n\n Raises:\n StopIteration: if :attr:`done` evaluates to ``True`` to finish this epoch\n ", "language": "en", "n_whitespaces": 42, "n_words": 17, "vocab_size": 15 }

{ "docstring": "Get feature names errors when the feature names have mixed dtypes", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 9 }

{ "docstring": "\n Singular Value Decomposition.\n\n When `a` is a 2D array, and when `full_matrices` is `False`,\n it is factorized as ``u @ np.diag(s) @ vh = (u * s) @ vh``,\n where `u` and `vh` are 2D unitary arrays and `s` is a 1D\n array of `a`'s singular values. When `a` is higher-dimensional, SVD is\n applied in stacked mode as explained below.\n\n Parameters\n ----------\n a : (..., M, N) array_like\n A real or complex array with ``a.ndim >= 2``.\n full_matrices : bool, optional\n If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and\n ``(..., N, N)``, respectively. Otherwise, the shapes are\n ``(..., M, K)`` and ``(..., K, N)``, respectively, where\n ``K = min(M, N)``.\n compute_uv : bool, optional\n Whether or not to compute `u` and `vh` in addition to `s`. True\n by default.\n hermitian : bool, optional\n If True, `a` is assumed to be Hermitian (symmetric if real-valued),\n enabling a more efficient method for finding singular values.\n Defaults to False.\n\n .. versionadded:: 1.17.0\n\n Returns\n -------\n u : { (..., M, M), (..., M, K) } array\n Unitary array(s). The first ``a.ndim - 2`` dimensions have the same\n size as those of the input `a`. The size of the last two dimensions\n depends on the value of `full_matrices`. Only returned when\n `compute_uv` is True.\n s : (..., K) array\n Vector(s) with the singular values, within each vector sorted in\n descending order. The first ``a.ndim - 2`` dimensions have the same\n size as those of the input `a`.\n vh : { (..., N, N), (..., K, N) } array\n Unitary array(s). The first ``a.ndim - 2`` dimensions have the same\n size as those of the input `a`. The size of the last two dimensions\n depends on the value of `full_matrices`. Only returned when\n `compute_uv` is True.\n\n Raises\n ------\n LinAlgError\n If SVD computation does not converge.\n\n See Also\n --------\n scipy.linalg.svd : Similar function in SciPy.\n scipy.linalg.svdvals : Compute singular values of a matrix.\n\n Notes\n -----\n\n .. versionchanged:: 1.8.0\n Broadcasting rules apply, see the `numpy.linalg` documentation for\n details.\n\n The decomposition is performed using LAPACK routine ``_gesdd``.\n\n SVD is usually described for the factorization of a 2D matrix :math:`A`.\n The higher-dimensional case will be discussed below. In the 2D case, SVD is\n written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,\n :math:`S= \\\\mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`\n contains the singular values of `a` and `u` and `vh` are unitary. The rows\n of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are\n the eigenvectors of :math:`A A^H`. In both cases the corresponding\n (possibly non-zero) eigenvalues are given by ``s**2``.\n\n If `a` has more than two dimensions, then broadcasting rules apply, as\n explained in :ref:`routines.linalg-broadcasting`. This means that SVD is\n working in \"stacked\" mode: it iterates over all indices of the first\n ``a.ndim - 2`` dimensions and for each combination SVD is applied to the\n last two indices. The matrix `a` can be reconstructed from the\n decomposition with either ``(u * s[..., None, :]) @ vh`` or\n ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the\n function ``np.matmul`` for python versions below 3.5.)\n\n If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are\n all the return values.\n\n Examples\n --------\n >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)\n >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)\n\n Reconstruction based on full SVD, 2D case:\n\n >>> u, s, vh = np.linalg.svd(a, full_matrices=True)\n >>> u.shape, s.shape, vh.shape\n ((9, 9), (6,), (6, 6))\n >>> np.allclose(a, np.dot(u[:, :6] * s, vh))\n True\n >>> smat = np.zeros((9, 6), dtype=complex)\n >>> smat[:6, :6] = np.diag(s)\n >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n True\n\n Reconstruction based on reduced SVD, 2D case:\n\n >>> u, s, vh = np.linalg.svd(a, full_matrices=False)\n >>> u.shape, s.shape, vh.shape\n ((9, 6), (6,), (6, 6))\n >>> np.allclose(a, np.dot(u * s, vh))\n True\n >>> smat = np.diag(s)\n >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n True\n\n Reconstruction based on full SVD, 4D case:\n\n >>> u, s, vh = np.linalg.svd(b, full_matrices=True)\n >>> u.shape, s.shape, vh.shape\n ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))\n >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))\n True\n >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))\n True\n\n Reconstruction based on reduced SVD, 4D case:\n\n >>> u, s, vh = np.linalg.svd(b, full_matrices=False)\n >>> u.shape, s.shape, vh.shape\n ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))\n >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))\n True\n >>> np.allclose(b, np.matmul(u, s[..., None] * vh))\n True\n\n ", "language": "en", "n_whitespaces": 1180, "n_words": 746, "vocab_size": 328 }

{ "docstring": "Trace with the layer/models inferred input signature if possible.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Check that we can fit a line where all samples are inliers.\n Non-regression test for:\n https://github.com/scikit-learn/scikit-learn/issues/19497\n ", "language": "en", "n_whitespaces": 25, "n_words": 16, "vocab_size": 16 }

{ "docstring": "Sync transactions based on the last integration date as the start date, after sync is completed\n\tadd the transaction date of the oldest transaction as the last integration date.", "language": "en", "n_whitespaces": 27, "n_words": 29, "vocab_size": 20 }

{ "docstring": "\n Return True if this field should be used to descend deeper for\n select_related() purposes. Used by both the query construction code\n (sql.query.fill_related_selections()) and the model instance creation code\n (query.get_klass_info()).\n\n Arguments:\n * field - the field to be checked\n * restricted - a boolean field, indicating if the field list has been\n manually restricted using a requested clause)\n * requested - The select_related() dictionary.\n * load_fields - the set of fields to be loaded on this model\n * reverse - boolean, True if we are checking a reverse select related\n ", "language": "en", "n_whitespaces": 134, "n_words": 89, "vocab_size": 58 }

{ "docstring": "Make sure the value for QWebEnginePage::Notifications is correct.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n Check that the {% get_settings use_default_site=True %} option\n overrides a request in the context.\n ", "language": "en", "n_whitespaces": 36, "n_words": 14, "vocab_size": 13 }

{ "docstring": "Graph adjacency object holding the neighbors of each node.\n\n This object is a read-only dict-like structure with node keys\n and neighbor-dict values. The neighbor-dict is keyed by neighbor\n to the edgekey-data-dict. So `G.adj[3][2][0]['color'] = 'blue'` sets\n the color of the edge `(3, 2, 0)` to `\"blue\"`.\n\n Iterating over G.adj behaves like a dict. Useful idioms include\n `for nbr, edgesdict in G.adj[n].items():`.\n\n The neighbor information is also provided by subscripting the graph.\n\n Examples\n --------\n >>> e = [(1, 2), (1, 2), (1, 3), (3, 4)] # list of edges\n >>> G = nx.MultiGraph(e)\n >>> G.edges[1, 2, 0][\"weight\"] = 3\n >>> result = set()\n >>> for edgekey, data in G[1][2].items():\n ... result.add(data.get('weight', 1))\n >>> result\n {1, 3}\n\n For directed graphs, `G.adj` holds outgoing (successor) info.\n ", "language": "en", "n_whitespaces": 263, "n_words": 123, "vocab_size": 94 }

{ "docstring": "Check if no relationship model is used by more than one m2m field.", "language": "en", "n_whitespaces": 12, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Compute 'Scaled Dot Product Attention' with rel. positional encoding.\n\n :param torch.Tensor query: (batch, time1, size)\n :param torch.Tensor key: (batch, time2, size)\n :param torch.Tensor value: (batch, time2, size)\n :param torch.Tensor pos_emb: (batch, time1, size)\n :param torch.Tensor mask: (batch, time1, time2)\n :param torch.nn.Dropout dropout:\n :return torch.Tensor: attention output (batch, time1, d_model)\n ", "language": "en", "n_whitespaces": 106, "n_words": 49, "vocab_size": 28 }

{ "docstring": "\n The `page_context` event is called after the context for a page is created\n and can be used to alter the context for that specific page only.\n\n Parameters:\n context: dict of template context variables\n page: `mkdocs.nav.Page` instance\n config: global configuration object\n nav: global navigation object\n\n Returns:\n dict of template context variables\n ", "language": "en", "n_whitespaces": 141, "n_words": 50, "vocab_size": 37 }

{ "docstring": "\n Read data from `path_or_buf` according to the passed `read_json` `kwargs` parameters.\n\n Parameters\n ----------\n path_or_buf : str, path object or file-like object\n `path_or_buf` parameter of `read_json` function.\n **kwargs : dict\n Parameters of `read_json` function.\n\n Returns\n -------\n BaseQueryCompiler\n Query compiler with imported data for further processing.\n ", "language": "en", "n_whitespaces": 141, "n_words": 44, "vocab_size": 35 }

{ "docstring": "\n Write shared location information to the SHARED file in .dist-info.\n :param paths: A dictionary as described in the documentation for\n :meth:`shared_locations`.\n :param dry_run: If True, the action is logged but no file is actually\n written.\n :return: The path of the file written to.\n ", "language": "en", "n_whitespaces": 109, "n_words": 43, "vocab_size": 35 }

{ "docstring": "Return the content-transfer-encoding used for body encoding.\n\n This is either the string `quoted-printable' or `base64' depending on\n the encoding used, or it is a function in which case you should call\n the function with a single argument, the Message object being\n encoded. The function should then set the Content-Transfer-Encoding\n header itself to whatever is appropriate.\n\n Returns \"quoted-printable\" if self.body_encoding is QP.\n Returns \"base64\" if self.body_encoding is BASE64.\n Returns conversion function otherwise.\n ", "language": "en", "n_whitespaces": 135, "n_words": 71, "vocab_size": 52 }

{ "docstring": "Return a context manager for temporarily changing matplotlib unit registries and rcParams.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Return True if state updates should be forced.\n\n Overridden because CoordinatorEntity sets `should_poll` to False,\n which causes TrackerEntity to set `force_update` to True.\n ", "language": "en", "n_whitespaces": 44, "n_words": 23, "vocab_size": 21 }

{ "docstring": "Dataset with GLM solutions, well conditioned X.\n\n This is inspired by ols_ridge_dataset in test_ridge.py.\n\n The construction is based on the SVD decomposition of X = U S V'.\n\n Parameters\n ----------\n type : {\"long\", \"wide\"}\n If \"long\", then n_samples > n_features.\n If \"wide\", then n_features > n_samples.\n model : a GLM model\n\n For \"wide\", we return the minimum norm solution:\n\n min ||w||_2 subject to w = argmin deviance(X, y, w)\n\n Note that the deviance is always minimized if y = inverse_link(X w) is possible to\n achieve, which it is in the wide data case. Therefore, we can construct the\n solution with minimum norm like (wide) OLS:\n\n min ||w||_2 subject to link(y) = raw_prediction = X w\n\n Returns\n -------\n model : GLM model\n X : ndarray\n Last column of 1, i.e. intercept.\n y : ndarray\n coef_unpenalized : ndarray\n Minimum norm solutions, i.e. min sum(loss(w)) (with mininum ||w||_2 in\n case of ambiguity)\n Last coefficient is intercept.\n coef_penalized : ndarray\n GLM solution with alpha=l2_reg_strength=1, i.e.\n min 1/n * sum(loss) + ||w[:-1]||_2^2.\n Last coefficient is intercept.\n l2_reg_strength : float\n Always equal 1.\n ", "language": "en", "n_whitespaces": 318, "n_words": 177, "vocab_size": 111 }

{ "docstring": "Return the unique telemetry identifier for this Rasa Open Source install.\n\n The identifier can be any string, but it should be a UUID.\n\n Returns:\n The identifier, if it is configured correctly.\n ", "language": "en", "n_whitespaces": 47, "n_words": 31, "vocab_size": 27 }

{ "docstring": "\n Return a Form class for use in the Formset on the changelist page.\n ", "language": "en", "n_whitespaces": 28, "n_words": 13, "vocab_size": 12 }

{ "docstring": "\n\t\tselect sales_team.sales_person as name, sum(sales_order.base_net_total) as value\n\t\tfrom `tabSales Order` as sales_order join `tabSales Team` as sales_team\n\t\t\ton sales_order.name = sales_team.parent and sales_team.parenttype = 'Sales Order'\n\t\twhere sales_order.docstatus = 1\n\t\t\tand sales_order.company = %s\n\t\t\t{date_condition}\n\t\tgroup by sales_team.sales_person\n\t\torder by value DESC\n\t\tlimit %s\n\t", "language": "en", "n_whitespaces": 35, "n_words": 44, "vocab_size": 32 }

{ "docstring": "Load and return the digits dataset (classification).\n\n Each datapoint is a 8x8 image of a digit.\n\n ================= ==============\n Classes 10\n Samples per class ~180\n Samples total 1797\n Dimensionality 64\n Features integers 0-16\n ================= ==============\n\n This is a copy of the test set of the UCI ML hand-written digits datasets\n https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits\n\n Read more in the :ref:`User Guide <digits_dataset>`.\n\n Parameters\n ----------\n n_class : int, default=10\n The number of classes to return. Between 0 and 10.\n\n return_X_y : bool, default=False\n If True, returns ``(data, target)`` instead of a Bunch object.\n See below for more information about the `data` and `target` object.\n\n .. versionadded:: 0.18\n\n as_frame : bool, default=False\n If True, the data is a pandas DataFrame including columns with\n appropriate dtypes (numeric). The target is\n a pandas DataFrame or Series depending on the number of target columns.\n If `return_X_y` is True, then (`data`, `target`) will be pandas\n DataFrames or Series as described below.\n\n .. versionadded:: 0.23\n\n Returns\n -------\n data : :class:`~sklearn.utils.Bunch`\n Dictionary-like object, with the following attributes.\n\n data : {ndarray, dataframe} of shape (1797, 64)\n The flattened data matrix. If `as_frame=True`, `data` will be\n a pandas DataFrame.\n target: {ndarray, Series} of shape (1797,)\n The classification target. If `as_frame=True`, `target` will be\n a pandas Series.\n feature_names: list\n The names of the dataset columns.\n target_names: list\n The names of target classes.\n\n .. versionadded:: 0.20\n\n frame: DataFrame of shape (1797, 65)\n Only present when `as_frame=True`. DataFrame with `data` and\n `target`.\n\n .. versionadded:: 0.23\n images: {ndarray} of shape (1797, 8, 8)\n The raw image data.\n DESCR: str\n The full description of the dataset.\n\n (data, target) : tuple if ``return_X_y`` is True\n A tuple of two ndarrays by default. The first contains a 2D ndarray of\n shape (1797, 64) with each row representing one sample and each column\n representing the features. The second ndarray of shape (1797) contains\n the target samples. If `as_frame=True`, both arrays are pandas objects,\n i.e. `X` a dataframe and `y` a series.\n\n .. versionadded:: 0.18\n\n Examples\n --------\n To load the data and visualize the images::\n\n >>> from sklearn.datasets import load_digits\n >>> digits = load_digits()\n >>> print(digits.data.shape)\n (1797, 64)\n >>> import matplotlib.pyplot as plt\n >>> plt.gray()\n >>> plt.matshow(digits.images[0])\n <...>\n >>> plt.show()\n ", "language": "en", "n_whitespaces": 877, "n_words": 356, "vocab_size": 207 }

{ "docstring": "Test backward compatibility of the family property.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Finalize startup from inside the event loop.\n\n This method is a coroutine.\n ", "language": "en", "n_whitespaces": 26, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Get a module specified by its module name\n Parameters\n ----------\n model : pytorch model\n the pytorch model from which to get its module\n module_name : str\n the name of the required module\n Returns\n -------\n module, module\n the parent module of the required module, the required module\n ", "language": "en", "n_whitespaces": 95, "n_words": 46, "vocab_size": 25 }

{ "docstring": "Ensure chromecast is available, to facilitate type checking.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n Return whether the wheel package is installed.\n ", "language": "en", "n_whitespaces": 14, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Assert that pick_two_individuals_eligible_for_crossover() picks the correct pair of nodes to perform crossover with", "language": "en", "n_whitespaces": 12, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Tests the correctness of the quantized::qlayer_norm op.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 6 }

{ "docstring": "Fused `upsample_2d()` followed by `Conv2d()`.\n\n Args:\n Padding is performed only once at the beginning, not between the operations. The fused op is considerably more\n efficient than performing the same calculation using standard TensorFlow ops. It supports gradients of arbitrary\n order.\n x: Input tensor of the shape `[N, C, H, W]` or `[N, H, W,\n C]`.\n w: Weight tensor of the shape `[filterH, filterW, inChannels,\n outChannels]`. Grouped convolution can be performed by `inChannels = x.shape[0] // numGroups`.\n k: FIR filter of the shape `[firH, firW]` or `[firN]`\n (separable). The default is `[1] * factor`, which corresponds to nearest-neighbor upsampling.\n factor: Integer upsampling factor (default: 2). gain: Scaling factor for signal magnitude (default: 1.0).\n\n Returns:\n Tensor of the shape `[N, C, H * factor, W * factor]` or `[N, H * factor, W * factor, C]`, and same datatype as\n `x`.\n ", "language": "en", "n_whitespaces": 208, "n_words": 139, "vocab_size": 102 }

{ "docstring": " Obtain GPU devices from PlaidML that are marked as \"supported\".\n\n Returns\n -------\n list_LOGGER.\n The :class:`plaidml._DeviceConfig` objects for all supported GPUs that PlaidML has\n discovered.\n ", "language": "en", "n_whitespaces": 75, "n_words": 24, "vocab_size": 22 }

{ "docstring": "\n Provide a hook to modify the object immediately before saving it (e.g. to encrypt secret data).\n\n Args:\n object_form: The model form instance\n request: The current request\n ", "language": "en", "n_whitespaces": 70, "n_words": 26, "vocab_size": 24 }