Datasets:

semeru

/

code-text-galeras-code-summarization-3k-deduped

like 1

Follow

Semeru Lab 7

{ "docstring": "docs(data: {text: \"abcd\"}) { \n id \n text\n matches {\n id\n }\n } \n }\n ", "language": "en", "n_whitespaces": 115, "n_words": 12, "vocab_size": 8 }

{ "docstring": "\n Return a tuple of (binaries, datas, hiddenimports) to be used by PyGObject related hooks.\n ", "language": "en", "n_whitespaces": 29, "n_words": 14, "vocab_size": 14 }

{ "docstring": "Generate the script that shows the pdf with pdf.js.\n\n Args:\n filename: The name of the file to open.\n \n document.addEventListener(\"DOMContentLoaded\", function() {\n if (typeof window.PDFJS !== 'undefined') {\n // v1.x\n window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info;\n } else {\n // v2.x\n const options = window.PDFViewerApplicationOptions;\n options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS);\n }\n\n const viewer = window.PDFView || window.PDFViewerApplication;\n viewer.open({{ url }});\n });\n ", "language": "en", "n_whitespaces": 195, "n_words": 54, "vocab_size": 45 }

{ "docstring": "\n Apply *value* to the format string *fmt*.\n\n This works both with unnamed %-style formatting and\n unnamed {}-style formatting. %-style formatting has priority.\n If *fmt* is %-style formattable that will be used. Otherwise,\n {}-formatting is applied. Strings without formatting placeholders\n are passed through as is.\n\n Examples\n --------\n >>> _auto_format_str('%.2f m', 0.2)\n '0.20 m'\n >>> _auto_format_str('{} m', 0.2)\n '0.2 m'\n >>> _auto_format_str('const', 0.2)\n 'const'\n >>> _auto_format_str('%d or {}', 0.2)\n '0 or {}'\n ", "language": "en", "n_whitespaces": 122, "n_words": 70, "vocab_size": 55 }

{ "docstring": "\n Return the appropriate serializer for the destination, if any.\n ", "language": "en", "n_whitespaces": 24, "n_words": 9, "vocab_size": 8 }

{ "docstring": "\n Return the information exported by this distribution.\n :return: A dictionary of exports, mapping an export category to a dict\n of :class:`ExportEntry` instances describing the individual\n export entries, and keyed by name.\n ", "language": "en", "n_whitespaces": 85, "n_words": 31, "vocab_size": 27 }

{ "docstring": "Get a short text description of the error.\n\n This is a string suitable to show to the user as error message.\n ", "language": "en", "n_whitespaces": 35, "n_words": 21, "vocab_size": 18 }

{ "docstring": "\n Function to create a arangodb session\n and execute the AQL query in the session.\n\n :param query: AQL query\n :return: Result\n ", "language": "en", "n_whitespaces": 56, "n_words": 20, "vocab_size": 17 }

{ "docstring": "\n Helper function to count the number of entry orders that have been filled.\n :return: int count of entry orders that have been filled for this trade.\n ", "language": "en", "n_whitespaces": 48, "n_words": 26, "vocab_size": 19 }

{ "docstring": "Chunk and combine function of argtopk\n\n Extract the indices of the k largest elements from a on the given axis.\n If k is negative, extract the indices of the -k smallest elements instead.\n Note that, unlike in the parent function, the returned elements\n are not sorted internally.\n ", "language": "en", "n_whitespaces": 62, "n_words": 47, "vocab_size": 35 }

{ "docstring": "\n Extract name, version, python version from a filename (no extension)\n\n Return name, version, pyver or None\n ", "language": "en", "n_whitespaces": 26, "n_words": 16, "vocab_size": 14 }

{ "docstring": "Concatenates `array1` and `array2` on first axis, applying padding on the second if necessary.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 13 }

{ "docstring": "Get the latest data from NOAA Tides and Currents API.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n The source archive download URL for this distribution.\n ", "language": "en", "n_whitespaces": 23, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Starts the pcap adapter. Will ask for admin. Returns True if success", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Create a unique ansible-test cgroup in the v1 systemd hierarchy and return its path.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 14 }

{ "docstring": "\n Close the connection.\n \n # Connect to the server / broker.\n # ", "language": "en", "n_whitespaces": 39, "n_words": 11, "vocab_size": 9 }

{ "docstring": "Computes the polar decomposition.\n\n Given the :math:`m \\times n` matrix :math:`a`, returns the factors of the polar\n decomposition :math:`u` (also :math:`m \\times n`) and :math:`p` such that\n :math:`a = up` (if side is ``\"right\"``; :math:`p` is :math:`n \\times n`) or\n :math:`a = pu` (if side is ``\"left\"``; :math:`p` is :math:`m \\times m`),\n where :math:`p` is positive semidefinite. If :math:`a` is nonsingular,\n :math:`p` is positive definite and the\n decomposition is unique. :math:`u` has orthonormal columns unless\n :math:`n > m`, in which case it has orthonormal rows.\n\n Writing the SVD of :math:`a` as\n :math:`a = u_\\mathit{svd} \\cdot s_\\mathit{svd} \\cdot v^h_\\mathit{svd}`, we\n have :math:`u = u_\\mathit{svd} \\cdot v^h_\\mathit{svd}`. Thus the unitary\n factor :math:`u` can be constructed as the application of the sign function to\n the singular values of :math:`a`; or, if :math:`a` is Hermitian, the\n eigenvalues.\n\n Several methods exist to compute the polar decomposition. Currently two\n are supported:\n\n * ``method=\"svd\"``:\n\n Computes the SVD of :math:`a` and then forms\n :math:`u = u_\\mathit{svd} \\cdot v^h_\\mathit{svd}`.\n\n * ``method=\"qdwh\"``:\n\n Applies the `QDWH`_ (QR-based Dynamically Weighted Halley) algorithm.\n\n Args:\n a: The :math:`m \\times n` input matrix.\n side: Determines whether a right or left polar decomposition is computed.\n If ``side`` is ``\"right\"`` then :math:`a = up`. If ``side`` is ``\"left\"``\n then :math:`a = pu`. The default is ``\"right\"``.\n method: Determines the algorithm used, as described above.\n precision: :class:`~jax.lax.Precision` object specifying the matmul precision.\n eps: The final result will satisfy\n :math:`\\left|x_k - x_{k-1}\\right| < \\left|x_k\\right| (4\\epsilon)^{\\frac{1}{3}}`,\n where :math:`x_k` are the QDWH iterates. Ignored if ``method`` is not\n ``\"qdwh\"``.\n max_iterations: Iterations will terminate after this many steps even if the\n above is unsatisfied. Ignored if ``method`` is not ``\"qdwh\"``.\n\n Returns:\n A ``(unitary, posdef)`` tuple, where ``unitary`` is the unitary factor\n (:math:`m \\times n`), and ``posdef`` is the positive-semidefinite factor.\n ``posdef`` is either :math:`n \\times n` or :math:`m \\times m` depending on\n whether ``side`` is ``\"right\"`` or ``\"left\"``, respectively.\n\n .. _QDWH: https://epubs.siam.org/doi/abs/10.1137/090774999\n ", "language": "en", "n_whitespaces": 403, "n_words": 310, "vocab_size": 178 }

{ "docstring": "Aggregates batch-level results into total results.\n\n Args:\n batch_outs: A list of batch-level outputs.\n batch_start: The start index of this batch. Always `None` if `use_steps`\n is `True`.\n batch_end: The end index of this batch. Always `None` if `use_steps` is\n `True`.\n ", "language": "en", "n_whitespaces": 102, "n_words": 39, "vocab_size": 26 }

{ "docstring": "\n Return the first DjangoTemplates backend that's configured, or raise\n ImproperlyConfigured if none are configured.\n\n This is required for preserving historical APIs that rely on a\n globally available, implicitly configured engine such as:\n\n >>> from django.template import Context, Template\n >>> template = Template(\"Hello {{ name }}!\")\n >>> context = Context({'name': \"world\"})\n >>> template.render(context)\n 'Hello world!'\n ", "language": "en", "n_whitespaces": 125, "n_words": 54, "vocab_size": 50 }

{ "docstring": "Assert that get_by_name raises ValueError with duplicate operators in operator dictionary.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Convert dask Array to dask Dataframe\n\n Parameters\n ----------\n columns: list or string\n list of column names if DataFrame, single string if Series\n index : dask.dataframe.Index, optional\n An optional *dask* Index to use for the output Series or DataFrame.\n\n The default output index depends on whether the array has any unknown\n chunks. If there are any unknown chunks, the output has ``None``\n for all the divisions (one per chunk). If all the chunks are known,\n a default index with known divsions is created.\n\n Specifying ``index`` can be useful if you're conforming a Dask Array\n to an existing dask Series or DataFrame, and you would like the\n indices to match.\n meta : object, optional\n An optional `meta` parameter can be passed for dask\n to specify the concrete dataframe type to use for partitions of\n the Dask dataframe. By default, pandas DataFrame is used.\n\n See Also\n --------\n dask.dataframe.from_dask_array\n ", "language": "en", "n_whitespaces": 340, "n_words": 145, "vocab_size": 94 }

{ "docstring": "\n Compute what the p_mean_variance output would have been, should the\n model's score function be conditioned by cond_fn.\n\n See condition_mean() for details on cond_fn.\n\n Unlike condition_mean(), this instead uses the conditioning strategy\n from Song et al (2020).\n ", "language": "en", "n_whitespaces": 79, "n_words": 36, "vocab_size": 33 }

{ "docstring": "\n Pickle and b64encode the object, optionally compressing it.\n\n The pickling protocol is specified explicitly (by default 2),\n rather than as -1 or HIGHEST_PROTOCOL, because we don't want the\n protocol to change over time. If it did, ``exact`` and ``in``\n lookups would likely fail, since pickle would now be generating\n a different string.\n\n ", "language": "en", "n_whitespaces": 102, "n_words": 52, "vocab_size": 48 }

{ "docstring": "\n create predictor p_test_1\n from files (select sqft, location, rental_price from test_file limit 30)\n predict rental_price\n \n select * from mindsdb.p_test_1 where sqft = 1000\n \n select * from files.small_test_file ta join mindsdb.p_test_1\n ", "language": "en", "n_whitespaces": 109, "n_words": 30, "vocab_size": 23 }

{ "docstring": "Compute the paired L1 distances between X and Y.\n\n Distances are calculated between (X[0], Y[0]), (X[1], Y[1]), ...,\n (X[n_samples], Y[n_samples]).\n\n Read more in the :ref:`User Guide <metrics>`.\n\n Parameters\n ----------\n X : array-like of shape (n_samples, n_features)\n An array-like where each row is a sample and each column is a feature.\n\n Y : array-like of shape (n_samples, n_features)\n An array-like where each row is a sample and each column is a feature.\n\n Returns\n -------\n distances : ndarray of shape (n_samples,)\n L1 paired distances between the row vectors of `X`\n and the row vectors of `Y`.\n\n Examples\n --------\n >>> from sklearn.metrics.pairwise import paired_manhattan_distances\n >>> import numpy as np\n >>> X = np.array([[1, 1, 0], [0, 1, 0], [0, 0, 1]])\n >>> Y = np.array([[0, 1, 0], [0, 0, 1], [0, 0, 0]])\n >>> paired_manhattan_distances(X, Y)\n array([1., 2., 1.])\n ", "language": "en", "n_whitespaces": 221, "n_words": 136, "vocab_size": 75 }

{ "docstring": "\n Process `file_path` in accordance to it's type.\n\n Parameters\n ----------\n file_path : str, os.PathLike[str] object or file-like object\n The file, or a path to the file. Paths to S3 buckets are also\n acceptable.\n\n Returns\n -------\n str\n Updated or verified `file_path` parameter.\n\n Notes\n -----\n if `file_path` is a URL, parameter will be returned as is, otherwise\n absolute path will be returned.\n ", "language": "en", "n_whitespaces": 177, "n_words": 59, "vocab_size": 48 }

{ "docstring": "\n Plot a horizontal sequence of rectangles.\n\n A rectangle is drawn for each element of *xranges*. All rectangles\n have the same vertical position and size defined by *yrange*.\n\n This is a convenience function for instantiating a\n `.BrokenBarHCollection`, adding it to the Axes and autoscaling the\n view.\n\n Parameters\n ----------\n xranges : sequence of tuples (*xmin*, *xwidth*)\n The x-positions and extends of the rectangles. For each tuple\n (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* +\n *xwidth*.\n yrange : (*ymin*, *yheight*)\n The y-position and extend for all the rectangles.\n\n Returns\n -------\n `~.collections.BrokenBarHCollection`\n\n Other Parameters\n ----------------\n data : indexable object, optional\n DATA_PARAMETER_PLACEHOLDER\n **kwargs : `.BrokenBarHCollection` properties\n\n Each *kwarg* can be either a single argument applying to all\n rectangles, e.g.::\n\n facecolors='black'\n\n or a sequence of arguments over which is cycled, e.g.::\n\n facecolors=('black', 'blue')\n\n would create interleaving black and blue rectangles.\n\n Supported keywords:\n\n %(BrokenBarHCollection:kwdoc)s\n ", "language": "en", "n_whitespaces": 418, "n_words": 140, "vocab_size": 98 }

{ "docstring": "\n {% get_admin_log %} works if the user model's primary key isn't named\n 'id'.\n ", "language": "en", "n_whitespaces": 35, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Determine whether the supplied distribution is in the environment.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "\n Assert that rate limits per-org and globally are applied at all.\n\n Since we don't have control over ordering in sets/dicts, we have no\n control over which string gets rate-limited. That makes assertions\n quite awkward and imprecise.\n ", "language": "en", "n_whitespaces": 52, "n_words": 36, "vocab_size": 31 }

{ "docstring": "Get the aliases for the key, including the key itself", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 8 }

{ "docstring": "\n Return the name of the primary key column for the given table.\n ", "language": "en", "n_whitespaces": 27, "n_words": 12, "vocab_size": 10 }

{ "docstring": "Compute cosine similarity between samples in X and Y.\n\n Cosine similarity, or the cosine kernel, computes similarity as the\n normalized dot product of X and Y:\n\n K(X, Y) = <X, Y> / (||X||*||Y||)\n\n On L2-normalized data, this function is equivalent to linear_kernel.\n\n Read more in the :ref:`User Guide <cosine_similarity>`.\n\n Parameters\n ----------\n X : {ndarray, sparse matrix} of shape (n_samples_X, n_features)\n Input data.\n\n Y : {ndarray, sparse matrix} of shape (n_samples_Y, n_features), \\\n default=None\n Input data. If ``None``, the output will be the pairwise\n similarities between all samples in ``X``.\n\n dense_output : bool, default=True\n Whether to return dense output even when the input is sparse. If\n ``False``, the output is sparse if both input arrays are sparse.\n\n .. versionadded:: 0.17\n parameter ``dense_output`` for dense output.\n\n Returns\n -------\n kernel matrix : ndarray of shape (n_samples_X, n_samples_Y)\n Returns the cosine similarity between samples in X and Y.\n ", "language": "en", "n_whitespaces": 260, "n_words": 144, "vocab_size": 95 }

{ "docstring": "An environment variable is truthy if it exists and isn't one of (0, false, no, off)", "language": "en", "n_whitespaces": 15, "n_words": 16, "vocab_size": 16 }

{ "docstring": "Computing a minimum-weight maximal matching of G.\n\n Use reciprocal edge weights with the maximum-weight algorithm.\n\n A matching is a subset of edges in which no node occurs more than once.\n The weight of a matching is the sum of the weights of its edges.\n A maximal matching cannot add more edges and still be a matching.\n The cardinality of a matching is the number of matched edges.\n\n This method replaces the weights with their reciprocal and\n then runs :func:`max_weight_matching`.\n Read the documentation of max_weight_matching for more information.\n\n Parameters\n ----------\n G : NetworkX graph\n Undirected graph\n\n maxcardinality: bool, optional (default=False)\n If maxcardinality is True, compute the maximum-cardinality matching\n with minimum weight among all maximum-cardinality matchings.\n\n weight: string, optional (default='weight')\n Edge data key corresponding to the edge weight.\n If key not found, uses 1 as weight.\n\n Returns\n -------\n matching : set\n A minimal weight matching of the graph.\n ", "language": "en", "n_whitespaces": 233, "n_words": 146, "vocab_size": 92 }

{ "docstring": "\n Check whether the provided array or dtype is of the datetime64[ns] dtype.\n\n Parameters\n ----------\n arr_or_dtype : array-like or dtype\n The array or dtype to check.\n\n Returns\n -------\n bool\n Whether or not the array or dtype is of the datetime64[ns] dtype.\n\n Examples\n --------\n >>> is_datetime64_ns_dtype(str)\n False\n >>> is_datetime64_ns_dtype(int)\n False\n >>> is_datetime64_ns_dtype(np.datetime64) # no unit\n False\n >>> is_datetime64_ns_dtype(DatetimeTZDtype(\"ns\", \"US/Eastern\"))\n True\n >>> is_datetime64_ns_dtype(np.array(['a', 'b']))\n False\n >>> is_datetime64_ns_dtype(np.array([1, 2]))\n False\n >>> is_datetime64_ns_dtype(np.array([], dtype=\"datetime64\")) # no unit\n False\n >>> is_datetime64_ns_dtype(np.array([], dtype=\"datetime64[ps]\")) # wrong unit\n False\n >>> is_datetime64_ns_dtype(pd.DatetimeIndex([1, 2, 3], dtype=\"datetime64[ns]\"))\n True\n ", "language": "en", "n_whitespaces": 188, "n_words": 86, "vocab_size": 49 }

{ "docstring": "Context manager to make DeprecationWarning raise an error\n\n This is to catch SymPyDeprecationWarning from library code while running\n tests and doctests. It is important to use this context manager around\n each individual test/doctest in case some tests modify the warning\n filters.\n ", "language": "en", "n_whitespaces": 56, "n_words": 41, "vocab_size": 36 }

{ "docstring": "Compute online update of Gaussian mean and variance.\n\n Given starting sample count, mean, and variance, a new set of\n points X, and optionally sample weights, return the updated mean and\n variance. (NB - each dimension (column) in X is treated as independent\n -- you get variance, not covariance).\n\n Can take scalar mean and variance, or vector mean and variance to\n simultaneously update a number of independent Gaussians.\n\n See Stanford CS tech report STAN-CS-79-773 by Chan, Golub, and LeVeque:\n\n http://i.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf\n\n Parameters\n ----------\n n_past : int\n Number of samples represented in old mean and variance. If sample\n weights were given, this should contain the sum of sample\n weights represented in old mean and variance.\n\n mu : array-like of shape (number of Gaussians,)\n Means for Gaussians in original set.\n\n var : array-like of shape (number of Gaussians,)\n Variances for Gaussians in original set.\n\n sample_weight : array-like of shape (n_samples,), default=None\n Weights applied to individual samples (1. for unweighted).\n\n Returns\n -------\n total_mu : array-like of shape (number of Gaussians,)\n Updated mean for each Gaussian over the combined set.\n\n total_var : array-like of shape (number of Gaussians,)\n Updated variance for each Gaussian over the combined set.\n ", "language": "en", "n_whitespaces": 412, "n_words": 191, "vocab_size": 105 }

{ "docstring": "\n The XGLM Model transformer with a language modeling head on top (linear layer with weights tied to the input\n embeddings).\n ", "language": "en", "n_whitespaces": 30, "n_words": 20, "vocab_size": 19 }

{ "docstring": "SUM(IF(t1.%(trans_date)s BETWEEN '%(sd)s' AND '%(ed)s', t2.stock_qty, NULL)),\n\t\t\t\t\tSUM(IF(t1.%(trans_date)s BETWEEN '%(sd)s' AND '%(ed)s', t2.base_net_amount, NULL)),\n\t\t\t\t", "language": "en", "n_whitespaces": 12, "n_words": 14, "vocab_size": 8 }

{ "docstring": "Annotation for documenting developer APIs.\n\n Developer APIs are lower-level methods explicitly exposed to advanced Ray\n users and library developers. Their interfaces may change across minor\n Ray releases.\n\n Examples:\n >>> @DeveloperAPI\n >>> def func(x):\n >>> return x\n ", "language": "en", "n_whitespaces": 76, "n_words": 36, "vocab_size": 33 }

{ "docstring": "\n This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n behavior.\n\n Parameters:\n config ([`Data2VecVisionConfig`]): Model configuration class with all the parameters of the model.\n Initializing with a config file does not load the weights associated with the model, only the\n configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n\n Args:\n pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n Pixel values. Pixel values can be obtained using [`BeitFeatureExtractor`]. See\n [`BeitFeatureExtractor.__call__`] for details.\n\n head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):\n Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:\n\n - 1 indicates the head is **not masked**,\n - 0 indicates the head is **masked**.\n\n output_attentions (`bool`, *optional*):\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\n tensors for more detail.\n output_hidden_states (`bool`, *optional*):\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n more detail.\n return_dict (`bool`, *optional*):\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n", "language": "en", "n_whitespaces": 379, "n_words": 190, "vocab_size": 113 }

{ "docstring": "Resize the stream to the given size in bytes.\n\n If size is unspecified resize to the current position.\n The current stream position isn't changed.\n\n Return the new file size.\n ", "language": "en", "n_whitespaces": 57, "n_words": 29, "vocab_size": 22 }

{ "docstring": "\n Test that tests the behavior of going from Critical status to Warning status to Resolved\n for Crash Rate Alerts\n ", "language": "en", "n_whitespaces": 41, "n_words": 19, "vocab_size": 17 }

{ "docstring": "\n Tests that the google_matrix doesn't change except for the dangling\n nodes.\n ", "language": "en", "n_whitespaces": 33, "n_words": 11, "vocab_size": 10 }

{ "docstring": "if not config_read_column:\n query = (self.session.query(Books, ub.ArchivedBook.is_archived, ub.ReadBook).select_from(Books)\n .outerjoin(ub.ReadBook, and_(Books.id == ub.ReadBook.book_id,\n int(current_user.id) == ub.ReadBook.user_id)))\n else:\n try:\n read_column = cc_classes[config_read_column]\n query = (self.session.query(Books, ub.ArchivedBook.is_archived, read_column.value)\n .select_from(Books)\n .outerjoin(read_column, read_column.book == Books.id))\n except (KeyError, AttributeError, IndexError):\n log.error(\"Custom Column No.{} is not existing in calibre database\".format(config_read_column))\n # Skip linking read column\n query = self.session.query(Books, ub.ArchivedBook.is_archived, None)\n query = query.outerjoin(ub.ArchivedBook, and_(Books.id == ub.ArchivedBook.book_id,\n int(current_user.id) == ub.ArchivedBook.user_id))", "language": "en", "n_whitespaces": 353, "n_words": 62, "vocab_size": 45 }

{ "docstring": "\n\t\tselect\n\t\t\t`tabSales Invoice Item`.gst_hsn_code,\n\t\t\t`tabSales Invoice Item`.stock_uom,\n\t\t\tsum(`tabSales Invoice Item`.stock_qty) as stock_qty,\n\t\t\tsum(`tabSales Invoice Item`.base_net_amount) as base_net_amount,\n\t\t\tsum(`tabSales Invoice Item`.base_price_list_rate) as base_price_list_rate,\n\t\t\t`tabSales Invoice Item`.parent,\n\t\t\t`tabSales Invoice Item`.item_code,\n\t\t\t`tabGST HSN Code`.description,\n\t\t\tjson_extract(`tabSales Taxes and Charges`.item_wise_tax_detail,\n\t\t\tconcat('$.\"' , `tabSales Invoice Item`.item_code, '\"[0]')) * count(distinct `tabSales Taxes and Charges`.name) as tax_rate\n\t\tfrom\n\t\t\t`tabSales Invoice`,\n\t\t\t`tabSales Invoice Item`,\n\t\t\t`tabGST HSN Code`,\n\t\t\t`tabSales Taxes and Charges`\n\t\twhere\n\t\t\t`tabSales Invoice`.name = `tabSales Invoice Item`.parent\n\t\t\tand `tabSales Taxes and Charges`.parent = `tabSales Invoice`.name\n\t\t\tand `tabSales Invoice`.docstatus = 1\n\t\t\tand `tabSales Invoice Item`.gst_hsn_code is not NULL\n\t\t\tand `tabSales Invoice Item`.gst_hsn_code = `tabGST HSN Code`.name %s %s\n\t\tgroup by\n<<<<<<< HEAD\n\t\t\t`tabSales Invoice Item`.parent, `tabSales Invoice Item`.item_code\n\n\t\t % (conditions, match_conditions), filters, as_dict=1)\n>>>>>>> 363752510e (fix: HSN-wise-summary of outward supplies Updated Report)\n\n\treturn items\n\n", "language": "en", "n_whitespaces": 98, "n_words": 125, "vocab_size": 68 }

{ "docstring": "\n intersection area over box area\n :param chips: C\n :param boxes: B\n :return: iob, CxB\n ", "language": "en", "n_whitespaces": 32, "n_words": 14, "vocab_size": 12 }

{ "docstring": "Test whether two pathnames reference the same actual file or directory\n\n This is determined by the device number and i-node number and\n raises an exception if an os.stat() call on either pathname fails.\n ", "language": "en", "n_whitespaces": 42, "n_words": 33, "vocab_size": 29 }

{ "docstring": "Returns the line of text containing loc within a string, counting newlines as line separators.\n ", "language": "en", "n_whitespaces": 21, "n_words": 15, "vocab_size": 14 }

{ "docstring": "Sorts the rules by path length, descending (most specific rule first).", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Resizes the number of remote workers based on available resources.\n Total number of workers will never exceed `num_workers` amount.\n\n Args:\n state_dict (dict): The state dict to load to all workers.\n max_retries (int): How many times to attempt to resize workers\n before failing.\n ", "language": "en", "n_whitespaces": 100, "n_words": 42, "vocab_size": 35 }

{ "docstring": "\n Read fortran codes from files and\n 1) Get rid of comments, line continuations, and empty lines; lower cases.\n 2) Call dowithline(line) on every line.\n 3) Recursively call itself when statement \\\"include '<filename>'\\\" is met.\n \")\n if istop:\n dowithline('', -1)\n ll, l1 = '', ''\n spacedigits = [' '] + [str(_m) for _m in range(10)]\n filepositiontext = ''\n fin = fileinput.FileInput(ffile, openhook=openhook)\n while True:\n try:\n l = fin.readline()\n except UnicodeDecodeError as msg:\n raise Exception(\n f'readfortrancode: reading {fin.filename()}#{fin.lineno()}'\n f' failed with\\n{msg}.\\nIt is likely that installing chardet'\n ' package will help f2py determine the input file encoding'\n ' correctly.')\n if not l:\n break\n if fin.isfirstline():\n filepositiontext = ''\n currentfilename = fin.filename()\n gotnextfile = 1\n l1 = l\n strictf77 = 0\n sourcecodeform = 'fix'\n ext = os.path.splitext(currentfilename)[1]\n if is_f_file(currentfilename) and \\\n not (_has_f90_header(l) or _has_fix_header(l)):\n strictf77 = 1\n elif is_free_format(currentfilename) and not _has_fix_header(l):\n sourcecodeform = 'free'\n if strictf77:\n beginpattern = beginpattern77\n else:\n beginpattern = beginpattern90\n outmess('\\tReading file %s (format:%s%s)\\n'\n % (repr(currentfilename), sourcecodeform,\n strictf77 and ',strict' or ''))\n\n l = l.expandtabs().replace('\\xa0', ' ')\n # Get rid of newline characters\n while not l == '':\n if l[-1] not in \"\\n\\r\\f\":\n break\n l = l[:-1]\n if not strictf77:\n (l, rl) = split_by_unquoted(l, '!')\n l += ' '\n if rl[:5].lower() == '!f2py': # f2py directive\n l, _ = split_by_unquoted(l + 4 * ' ' + rl[5:], '!')\n if l.strip() == '': # Skip empty line\n if sourcecodeform == 'free':\n # In free form, a statement continues in the next line\n # that is not a comment line [3.3.2.4^1], lines with\n # blanks are comment lines [3.3.2.3^1]. Hence, the\n # line continuation flag must retain its state.\n pass\n else:\n # In fixed form, statement continuation is determined\n # by a non-blank character at the 6-th position. Empty\n # line indicates a start of a new statement\n # [3.3.3.3^1]. Hence, the line continuation flag must\n # be reset.\n cont = False\n continue\n if sourcecodeform == 'fix':\n if l[0] in ['*', 'c', '!', 'C', '#']:\n if l[1:5].lower() == 'f2py': # f2py directive\n l = ' ' + l[5:]\n else: # Skip comment line\n cont = False\n continue\n elif strictf77:\n if len(l) > 72:\n l = l[:72]\n if not (l[0] in spacedigits):\n raise Exception('readfortrancode: Found non-(space,digit) char '\n 'in the first column.\\n\\tAre you sure that '\n 'this code is in fix form?\\n\\tline=%s' % repr(l))\n\n if (not cont or strictf77) and (len(l) > 5 and not l[5] == ' '):\n # Continuation of a previous line\n ll = ll + l[6:]\n finalline = ''\n origfinalline = ''\n else:\n if not strictf77:\n # F90 continuation\n r = cont1.match(l)\n if r:\n l = r.group('line') # Continuation follows ..\n if cont:\n ll = ll + cont2.match(l).group('line')\n finalline = ''\n origfinalline = ''\n else:\n # clean up line beginning from possible digits.\n l = ' ' + l[5:]\n if localdolowercase:\n finalline = ll.lower()\n else:\n finalline = ll\n origfinalline = ll\n ll = l\n cont = (r is not None)\n else:\n # clean up line beginning from possible digits.\n l = ' ' + l[5:]\n if localdolowercase:\n finalline = ll.lower()\n else:\n finalline = ll\n origfinalline = ll\n ll = l\n\n elif sourcecodeform == 'free':\n if not cont and ext == '.pyf' and mline_mark.match(l):\n l = l + '\\n'\n while True:\n lc = fin.readline()\n if not lc:\n errmess(\n 'Unexpected end of file when reading multiline\\n')\n break\n l = l + lc\n if mline_mark.match(lc):\n break\n l = l.rstrip()\n r = cont1.match(l)\n if r:\n l = r.group('line') # Continuation follows ..\n if cont:\n ll = ll + cont2.match(l).group('line')\n finalline = ''\n origfinalline = ''\n else:\n if localdolowercase:\n finalline = ll.lower()\n else:\n finalline = ll\n origfinalline = ll\n ll = l\n cont = (r is not None)\n else:\n raise ValueError(\n \"Flag sourcecodeform must be either 'fix' or 'free': %s\" % repr(sourcecodeform))\n filepositiontext = 'Line #%d in %s:\"%s\"\\n\\t' % (\n fin.filelineno() - 1, currentfilename, l1)\n m = includeline.match(origfinalline)\n if m:\n fn = m.group('name')\n if os.path.isfile(fn):\n readfortrancode(fn, dowithline=dowithline, istop=0)\n else:\n include_dirs = [\n os.path.dirname(currentfilename)] + include_paths\n foundfile = 0\n for inc_dir in include_dirs:\n fn1 = os.path.join(inc_dir, fn)\n if os.path.isfile(fn1):\n foundfile = 1\n readfortrancode(fn1, dowithline=dowithline, istop=0)\n break\n if not foundfile:\n outmess('readfortrancode: could not find include file %s in %s. Ignoring.\\n' % (\n repr(fn), os.pathsep.join(include_dirs)))\n else:\n dowithline(finalline)\n l1 = ll\n if localdolowercase:\n finalline = ll.lower()\n else:\n finalline = ll\n origfinalline = ll\n filepositiontext = 'Line #%d in %s:\"%s\"\\n\\t' % (\n fin.filelineno() - 1, currentfilename, l1)\n m = includeline.match(origfinalline)\n if m:\n fn = m.group('name')\n if os.path.isfile(fn):\n readfortrancode(fn, dowithline=dowithline, istop=0)\n else:\n include_dirs = [os.path.dirname(currentfilename)] + include_paths\n foundfile = 0\n for inc_dir in include_dirs:\n fn1 = os.path.join(inc_dir, fn)\n if os.path.isfile(fn1):\n foundfile = 1\n readfortrancode(fn1, dowithline=dowithline, istop=0)\n break\n if not foundfile:\n outmess('readfortrancode: could not find include file %s in %s. Ignoring.\\n' % (\n repr(fn), os.pathsep.join(include_dirs)))\n else:\n dowithline(finalline)\n filepositiontext = ''\n fin.close()\n if istop:\n dowithline('', 1)\n else:\n gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\\\n beginpattern, quiet, verbose, dolowercase = saveglobals\n\n# Crack line\nbeforethisafter = r'\\s*(?P<before>%s(?=\\s*(\\b(%s)\\b)))' + \\\n r'\\s*(?P<this>(\\b(%s)\\b))' + \\\n r'\\s*(?P<after>%s)\\s*\\Z'\n##\nfortrantypes = r'character|logical|integer|real|complex|double\\s*(precision\\s*(complex|)|complex)|type(?=\\s*\\([\\w\\s,=(*)]*\\))|byte'\ntypespattern = re.compile(\n beforethisafter % ('', fortrantypes, fortrantypes, '.*'), re.I), 'type'\ntypespattern4implicit = re.compile(beforethisafter % (\n '', fortrantypes + '|static|automatic|undefined', fortrantypes + '|static|automatic|undefined', '.*'), re.I)\n#\nfunctionpattern = re.compile(beforethisafter % (\n r'([a-z]+[\\w\\s(=*+-/)]*?|)', 'function', 'function', '.*'), re.I), 'begin'\nsubroutinepattern = re.compile(beforethisafter % (\n r'[a-z\\s]*?', 'subroutine', 'subroutine', '.*'), re.I), 'begin'\n# modulepattern=re.compile(beforethisafter%('[a-z\\s]*?','module','module','.*'),re.I),'begin'\n#\ngroupbegins77 = r'program|block\\s*data'\nbeginpattern77 = re.compile(\n beforethisafter % ('', groupbegins77, groupbegins77, '.*'), re.I), 'begin'\ngroupbegins90 = groupbegins77 + \\\n r'|module(?!\\s*procedure)|python\\s*module|(abstract|)\\s*interface|' + \\\n r'type(?!\\s*\\()'\nbeginpattern90 = re.compile(\n beforethisafter % ('', groupbegins90, groupbegins90, '.*'), re.I), 'begin'\ngroupends = (r'end|endprogram|endblockdata|endmodule|endpythonmodule|'\n r'endinterface|endsubroutine|endfunction')\nendpattern = re.compile(\n beforethisafter % ('', groupends, groupends, r'.*'), re.I), 'end'\nendifs = r'end\\s*(if|do|where|select|while|forall|associate|block|' + \\\n r'critical|enum|team)'\nendifpattern = re.compile(\n beforethisafter % (r'[\\w]*?', endifs, endifs, r'[\\w\\s]*'), re.I), 'endif'\n#\nmoduleprocedures = r'module\\s*procedure'\nmoduleprocedurepattern = re.compile(\n beforethisafter % ('', moduleprocedures, moduleprocedures, r'.*'), re.I), \\\n 'moduleprocedure'\nimplicitpattern = re.compile(\n beforethisafter % ('', 'implicit', 'implicit', '.*'), re.I), 'implicit'\ndimensionpattern = re.compile(beforethisafter % (\n '', 'dimension|virtual', 'dimension|virtual', '.*'), re.I), 'dimension'\nexternalpattern = re.compile(\n beforethisafter % ('', 'external', 'external', '.*'), re.I), 'external'\noptionalpattern = re.compile(\n beforethisafter % ('', 'optional', 'optional', '.*'), re.I), 'optional'\nrequiredpattern = re.compile(\n beforethisafter % ('', 'required', 'required', '.*'), re.I), 'required'\npublicpattern = re.compile(\n beforethisafter % ('', 'public', 'public', '.*'), re.I), 'public'\nprivatepattern = re.compile(\n beforethisafter % ('', 'private', 'private', '.*'), re.I), 'private'\nintrinsicpattern = re.compile(\n beforethisafter % ('', 'intrinsic', 'intrinsic', '.*'), re.I), 'intrinsic'\nintentpattern = re.compile(beforethisafter % (\n '', 'intent|depend|note|check', 'intent|depend|note|check', r'\\s*\\(.*?\\).*'), re.I), 'intent'\nparameterpattern = re.compile(\n beforethisafter % ('', 'parameter', 'parameter', r'\\s*\\(.*'), re.I), 'parameter'\ndatapattern = re.compile(\n beforethisafter % ('', 'data', 'data', '.*'), re.I), 'data'\ncallpattern = re.compile(\n beforethisafter % ('', 'call', 'call', '.*'), re.I), 'call'\nentrypattern = re.compile(\n beforethisafter % ('', 'entry', 'entry', '.*'), re.I), 'entry'\ncallfunpattern = re.compile(\n beforethisafter % ('', 'callfun', 'callfun', '.*'), re.I), 'callfun'\ncommonpattern = re.compile(\n beforethisafter % ('', 'common', 'common', '.*'), re.I), 'common'\nusepattern = re.compile(\n beforethisafter % ('', 'use', 'use', '.*'), re.I), 'use'\ncontainspattern = re.compile(\n beforethisafter % ('', 'contains', 'contains', ''), re.I), 'contains'\nformatpattern = re.compile(\n beforethisafter % ('', 'format', 'format', '.*'), re.I), 'format'\n# Non-fortran and f2py-specific statements\nf2pyenhancementspattern = re.compile(beforethisafter % ('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef',\n 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*'), re.I | re.S), 'f2pyenhancements'\nmultilinepattern = re.compile(\n r\"\\s*(?P<before>)\\s*\\Z\", re.S), 'multiline'\n##\n", "language": "en", "n_whitespaces": 4055, "n_words": 1168, "vocab_size": 439 }

{ "docstring": "\n hls\\s*:\\s*(?:\n (?P<q>[\"'])(?P<string>.*?)(?P=q)\n |\n decodeURIComponent\\s*\\((?P<obfuscated>\\[.*?])\\.join\\(\n |\n atob\\s*\\(\\s*decodeURIComponent\\s*\\((?P<obfuscated_b64>\\[.*?])\\.join\\(\n )\n ", "language": "en", "n_whitespaces": 144, "n_words": 7, "vocab_size": 6 }

{ "docstring": "Fit Ridge regression model.\n\n Parameters\n ----------\n X : {ndarray, sparse matrix} of shape (n_samples, n_features)\n Training data.\n\n y : ndarray of shape (n_samples,) or (n_samples, n_targets)\n Target values.\n\n sample_weight : float or ndarray of shape (n_samples,), default=None\n Individual weights for each sample. If given a float, every sample\n will have the same weight.\n\n Returns\n -------\n self : object\n Fitted estimator.\n ", "language": "en", "n_whitespaces": 178, "n_words": 60, "vocab_size": 50 }

{ "docstring": "\n Override the options dictionary initialization to keep using apachectl\n instead of httpd and so take advantages of this new bash script in newer versions\n of Fedora to restart httpd.\n ", "language": "en", "n_whitespaces": 58, "n_words": 29, "vocab_size": 26 }

{ "docstring": "Find a 'safe' number of components to randomly project to.\n\n The distortion introduced by a random projection `p` only changes the\n distance between two points by a factor (1 +- eps) in an euclidean space\n with good probability. The projection `p` is an eps-embedding as defined\n by:\n\n (1 - eps) ||u - v||^2 < ||p(u) - p(v)||^2 < (1 + eps) ||u - v||^2\n\n Where u and v are any rows taken from a dataset of shape (n_samples,\n n_features), eps is in ]0, 1[ and p is a projection by a random Gaussian\n N(0, 1) matrix of shape (n_components, n_features) (or a sparse\n Achlioptas matrix).\n\n The minimum number of components to guarantee the eps-embedding is\n given by:\n\n n_components >= 4 log(n_samples) / (eps^2 / 2 - eps^3 / 3)\n\n Note that the number of dimensions is independent of the original\n number of features but instead depends on the size of the dataset:\n the larger the dataset, the higher is the minimal dimensionality of\n an eps-embedding.\n\n Read more in the :ref:`User Guide <johnson_lindenstrauss>`.\n\n Parameters\n ----------\n n_samples : int or array-like of int\n Number of samples that should be a integer greater than 0. If an array\n is given, it will compute a safe number of components array-wise.\n\n eps : float or ndarray of shape (n_components,), dtype=float, \\\n default=0.1\n Maximum distortion rate in the range (0,1 ) as defined by the\n Johnson-Lindenstrauss lemma. If an array is given, it will compute a\n safe number of components array-wise.\n\n Returns\n -------\n n_components : int or ndarray of int\n The minimal number of components to guarantee with good probability\n an eps-embedding with n_samples.\n\n Examples\n --------\n >>> from sklearn.random_projection import johnson_lindenstrauss_min_dim\n >>> johnson_lindenstrauss_min_dim(1e6, eps=0.5)\n 663\n\n >>> johnson_lindenstrauss_min_dim(1e6, eps=[0.5, 0.1, 0.01])\n array([ 663, 11841, 1112658])\n\n >>> johnson_lindenstrauss_min_dim([1e4, 1e5, 1e6], eps=0.1)\n array([ 7894, 9868, 11841])\n\n References\n ----------\n\n .. [1] https://en.wikipedia.org/wiki/Johnson%E2%80%93Lindenstrauss_lemma\n\n .. [2] Sanjoy Dasgupta and Anupam Gupta, 1999,\n \"An elementary proof of the Johnson-Lindenstrauss Lemma.\"\n http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.45.3654\n\n ", "language": "en", "n_whitespaces": 522, "n_words": 318, "vocab_size": 187 }

{ "docstring": "\n Search for overlap with the observation label.\n\n Return the best fitting document. A document is valid if the f1 is above the\n threshold AND the f1 is less than 1.0 AND the target label is not in the\n document.\n ", "language": "en", "n_whitespaces": 75, "n_words": 39, "vocab_size": 27 }

{ "docstring": "\n Bundled aggregations should get applied to the latest thread event.\n ", "language": "en", "n_whitespaces": 25, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Map values of Series according to an input mapping or function.\n\n Used for substituting each value in a Series with another value,\n that may be derived from a function, a ``dict`` or\n a :class:`Series`.\n\n Parameters\n ----------\n arg : function, collections.abc.Mapping subclass or Series\n Mapping correspondence.\n na_action : {None, 'ignore'}, default None\n If 'ignore', propagate NaN values, without passing them to the\n mapping correspondence.\n\n Returns\n -------\n Series\n Same index as caller.\n\n See Also\n --------\n Series.apply : For applying more complex functions on a Series.\n DataFrame.apply : Apply a function row-/column-wise.\n DataFrame.applymap : Apply a function elementwise on a whole DataFrame.\n\n Notes\n -----\n When ``arg`` is a dictionary, values in Series that are not in the\n dictionary (as keys) are converted to ``NaN``. However, if the\n dictionary is a ``dict`` subclass that defines ``__missing__`` (i.e.\n provides a method for default values), then this default is used\n rather than ``NaN``.\n\n Examples\n --------\n >>> s = pd.Series(['cat', 'dog', np.nan, 'rabbit'])\n >>> s\n 0 cat\n 1 dog\n 2 NaN\n 3 rabbit\n dtype: object\n\n ``map`` accepts a ``dict`` or a ``Series``. Values that are not found\n in the ``dict`` are converted to ``NaN``, unless the dict has a default\n value (e.g. ``defaultdict``):\n\n >>> s.map({'cat': 'kitten', 'dog': 'puppy'})\n 0 kitten\n 1 puppy\n 2 NaN\n 3 NaN\n dtype: object\n\n It also accepts a function:\n\n >>> s.map('I am a {}'.format)\n 0 I am a cat\n 1 I am a dog\n 2 I am a nan\n 3 I am a rabbit\n dtype: object\n\n To avoid applying the function to missing values (and keep them as\n ``NaN``) ``na_action='ignore'`` can be used:\n\n >>> s.map('I am a {}'.format, na_action='ignore')\n 0 I am a cat\n 1 I am a dog\n 2 NaN\n 3 I am a rabbit\n dtype: object\n ", "language": "en", "n_whitespaces": 802, "n_words": 285, "vocab_size": 155 }

{ "docstring": " Validate that the requested architecture is a valid choice for the running system\n configuration.\n\n If the selection is not valid, an error is logged and system exits.\n ", "language": "en", "n_whitespaces": 49, "n_words": 27, "vocab_size": 22 }

{ "docstring": "\n.. DO NOT EDIT.\n.. THIS FILE WAS AUTOMATICALLY GENERATED BY SPHINX-GALLERY.\n.. TO MAKE CHANGES, EDIT THE SOURCE PYTHON FILE:\n.. \"{0}\"\n.. LINE NUMBERS ARE GIVEN BELOW.\n\n.. only:: html\n\n .. meta::\n :keywords: codex\n\n .. note::\n :class: sphx-glr-download-link-note\n\n Click :ref:`here <sphx_glr_download_{1}>`\n to download the full example code{2}\n\n.. rst-class:: sphx-glr-example-title\n\n.. _sphx_glr_{1}:\n\n", "language": "en", "n_whitespaces": 80, "n_words": 54, "vocab_size": 45 }

{ "docstring": "\n Creates the prometheus configurations that are by default provided by Ray.\n This will completely replace the `/tmp/ray/metrics/prometheus` folder.\n ", "language": "en", "n_whitespaces": 40, "n_words": 18, "vocab_size": 16 }

{ "docstring": "\n Set the connection style, possibly with further attributes.\n\n Attributes from the previous connection style are not reused.\n\n Without argument (or with ``connectionstyle=None``), the available box\n styles are returned as a human-readable string.\n\n Parameters\n ----------\n connectionstyle : str or `matplotlib.patches.ConnectionStyle`\n The style of the connection: either a `.ConnectionStyle` instance,\n or a string, which is the style name and optionally comma separated\n attributes (e.g. \"Arc,armA=30,rad=10\"). Such a string is used to\n construct a `.ConnectionStyle` object, as documented in that class.\n\n The following connection styles are available:\n\n %(ConnectionStyle:table_and_accepts)s\n\n **kwargs\n Additional attributes for the connection style. See the table above\n for supported parameters.\n\n Examples\n --------\n ::\n\n set_connectionstyle(\"Arc,armA=30,rad=10\")\n set_connectionstyle(\"arc\", armA=30, rad=10)\n ", "language": "en", "n_whitespaces": 301, "n_words": 106, "vocab_size": 80 }

{ "docstring": "\n Return the creation time of the specified LogRecord as formatted text.\n\n This custom logging formatter inherits from the logging module and\n records timestamps at the microsecond level of granularity.\n\n Parameters\n ----------\n record : LogRecord\n The specified LogRecord object.\n datefmt : str, default: None\n Used with time.ststrftime() to format time record.\n\n Returns\n -------\n datetime\n Datetime object containing microsecond timestamp.\n ", "language": "en", "n_whitespaces": 169, "n_words": 58, "vocab_size": 47 }

{ "docstring": "Converts a host local value to a globally sharded `jax.Array`.\n\n You can use this function to transition to `jax.Array`. Using `jax.Array` with\n `pjit` has the same semantics of using GDA with pjit i.e. all `jax.Array`\n inputs to pjit should be globally shaped.\n\n If you are currently passing host local values to pjit, you can use this\n function to convert your host local values to global Arrays and then pass that\n to pjit.\n\n Example usage:\n\n ```\n global_inputs = jax.experimental.pjit.host_local_array_to_global_array(\n host_local_inputs, global_mesh, in_pspecs)\n\n with mesh:\n global_out = pjitted_fun(global_inputs)\n\n host_local_output = jax.experimental.pjit.global_array_to_host_local_array(\n global_out, mesh, out_pspecs)\n ```\n\n Args:\n local_inputs: A Pytree of host local values.\n global_mesh: The global mesh.\n pspecs: A Pytree of PartitionSpecs.\n ", "language": "en", "n_whitespaces": 142, "n_words": 110, "vocab_size": 76 }

{ "docstring": "Return a list containing the charset(s) used in this message.\n\n The returned list of items describes the Content-Type headers'\n charset parameter for this message and all the subparts in its\n payload.\n\n Each item will either be a string (the value of the charset parameter\n in the Content-Type header of that part) or the value of the\n 'failobj' parameter (defaults to None), if the part does not have a\n main MIME type of \"text\", or the charset is not defined.\n\n The list will contain one string for each part of the message, plus\n one for the container message (i.e. self), so that a non-multipart\n message will still return a list of length 1.\n ", "language": "en", "n_whitespaces": 189, "n_words": 112, "vocab_size": 67 }

{ "docstring": "Return a generator of tuples in the form ``(name, aliases,\n filenames, mimetypes)`` of all know lexers.\n\n If *plugins* is true (the default), plugin lexers supplied by entrypoints\n are also returned. Otherwise, only builtin ones are considered.\n ", "language": "en", "n_whitespaces": 49, "n_words": 36, "vocab_size": 34 }

{ "docstring": "List all placement group information from the cluster.\n\n Returns:\n {pg_id -> pg_data_in_dict}\n pg_data_in_dict's schema is in PlacementGroupState\n ", "language": "en", "n_whitespaces": 53, "n_words": 17, "vocab_size": 17 }

{ "docstring": "\n Returns the list of supported prompt template names.\n :return: List of supported prompt template names.\n ", "language": "en", "n_whitespaces": 37, "n_words": 15, "vocab_size": 10 }

{ "docstring": "Turns a vanilla :class:`NotImplementedError` stemming from data access on a meta tensor into an expressive\n :class:`ErrorMeta`.\n\n Although it looks like meta tensors could be handled upfront, we need to do it lazily: there are use cases\n where a meta tensor wraps a data tensors and dispatches all operator calls to it. Thus, although the tensor is\n a meta tensor, it behaves like a regular one.\n ", "language": "en", "n_whitespaces": 100, "n_words": 65, "vocab_size": 49 }

{ "docstring": "\n CREATE PREDICTOR mindsdb.{model_name}_forecaster\n FROM pg\n (select t, H1 from m4 where train = 1) \n PREDICT H1\n USING engine='merlion'{using}\n \n select p.t, p.H1 real, t.H1, t.H1__upper, t.H1__lower\n from mindsdb.{model_name}_forecaster t\n inner join pg.m4 p on t.t = p.t\n where p.train = 0\n ", "language": "en", "n_whitespaces": 244, "n_words": 40, "vocab_size": 34 }

{ "docstring": "Parses named file or files as toml and returns a dictionary\n\n Args:\n f: Path to the file to open, array of files to read into single dict\n or a file descriptor\n _dict: (optional) Specifies the class of the returned toml dictionary\n decoder: The decoder to use\n\n Returns:\n Parsed toml file represented as a dictionary\n\n Raises:\n TypeError -- When f is invalid type\n TomlDecodeError: Error while decoding toml\n IOError / FileNotFoundError -- When an array with no valid (existing)\n (Python 2 / Python 3) file paths is passed\n ", "language": "en", "n_whitespaces": 174, "n_words": 87, "vocab_size": 62 }

{ "docstring": "\n Maps each child block in a StreamBlock value.\n\n Args:\n stream_block_value:\n The value of the StreamBlock, a list of child blocks\n block_def:\n The definition of the StreamBlock\n block_path:\n A '.' separated list of names of the blocks from the current block (not included) to\n the nested block of which the value will be passed to the operation.\n\n Returns\n mapped_value:\n The value of the StreamBlock after mapping all the children.\n ", "language": "en", "n_whitespaces": 164, "n_words": 68, "vocab_size": 41 }

{ "docstring": "Tests that invites from federation to a particular user are\n actually rate-limited.\n ", "language": "en", "n_whitespaces": 26, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Get the \"authenticated\" entity of the request, which might be the user\n performing the action, or a user being puppeted by a server admin.\n\n Returns:\n A tuple:\n The first item is a string representing the user making the request.\n\n The second item is a string or None representing the user who\n authenticated when making this request. See\n Requester.authenticated_entity.\n ", "language": "en", "n_whitespaces": 158, "n_words": 58, "vocab_size": 38 }

{ "docstring": "Network forward process.\n\n Usually includes backbone, neck and head forward without any post-\n processing.\n ", "language": "en", "n_whitespaces": 35, "n_words": 14, "vocab_size": 13 }

{ "docstring": "Get the top US indices\n\n Returns\n -------\n indices: pd.DataFrame\n Dataframe containing name, price, net change and percent change\n ", "language": "en", "n_whitespaces": 37, "n_words": 18, "vocab_size": 17 }

{ "docstring": "Activate the scene.\n\n This method is a coroutine.\n ", "language": "en", "n_whitespaces": 22, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Deprecated, do NOT use!\n\n Returns the `updates` from all layers that are stateful.\n\n This is useful for separating training updates and\n state updates, e.g. when we need to update a layer's internal state\n during prediction.\n\n Returns:\n A list of update ops.\n ", "language": "en", "n_whitespaces": 94, "n_words": 41, "vocab_size": 39 }

{ "docstring": "Test taking a screen capture with screencap option disabled.\n\n This is based on `test_get_image` in tests/components/media_player/test_init.py.\n ", "language": "en", "n_whitespaces": 22, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Test `__virtual__()` returns a reason for not loading.\n ", "language": "en", "n_whitespaces": 15, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Wrap the bleak classes to return the shared instance if multiple instances are detected.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 13 }

{ "docstring": "Perform in-band configuration. Executed before delegation for the controller and after delegation for targets.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 12 }

{ "docstring": "\n Tests for a bug in which constrained layout and align_ylabels on\n three unevenly sized subplots, one of whose y tick labels include\n negative numbers, drives the non-negative subplots' y labels off\n the edge of the plot\n ", "language": "en", "n_whitespaces": 52, "n_words": 36, "vocab_size": 31 }

{ "docstring": "\n <p>a <a linktype=\"document\" id=\"9999\">document</a> link</p>\n ", "language": "en", "n_whitespaces": 28, "n_words": 5, "vocab_size": 5 }

{ "docstring": "Set the final value of model's trainable variables.\n\n Sometimes there are some extra steps before ending the variable updates,\n such as overriding the model variables with its average value.\n\n Args:\n var_list: list of model variables.\n ", "language": "en", "n_whitespaces": 72, "n_words": 35, "vocab_size": 30 }

{ "docstring": " Obtain the amount of VRAM that is available, in Megabytes, for each connected Nvidia\n GPU.\n\n Returns\n -------\n list\n List of `float`s containing the amount of VRAM available, in Megabytes, for each\n connected GPU as corresponding to the values in :attr:`_handles\n ", "language": "en", "n_whitespaces": 100, "n_words": 40, "vocab_size": 27 }

{ "docstring": "\n Testing that a negative from parameter returns a 400\n ", "language": "en", "n_whitespaces": 24, "n_words": 9, "vocab_size": 8 }

{ "docstring": "Delete leave ledger entry created\n\tvia leave applications with status != Approved", "language": "en", "n_whitespaces": 10, "n_words": 12, "vocab_size": 11 }

{ "docstring": "Clear the current run after ending it.\n\n Must run in the recorder thread.\n ", "language": "en", "n_whitespaces": 27, "n_words": 13, "vocab_size": 11 }

{ "docstring": "\nWorkflow [`sample`](https://app.circleci.com/pipelines/github/prah23/circleci-webhook-test/20/workflows/045c6271-78e2-4802-8a62-f4fa6d25d0c9) within Pipeline #20 has succeeded.\n\nTriggered on the latest tag on [0e6e66c14e6](https://github.com/prah23/circleci-webhook-test/commit/0e6e66c14e61fbcd95db716b0f30d67dbcce7814).\n", "language": "en", "n_whitespaces": 12, "n_words": 14, "vocab_size": 13 }

{ "docstring": "\n Rebuild any CablePaths which traverse the peer CircuitTermination.\n ", "language": "en", "n_whitespaces": 15, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n Convenience method for changing the appearance of ticks and\n tick labels.\n\n See `.Axes.tick_params` for full documentation. Because this function\n applies to 3D Axes, *axis* can also be set to 'z', and setting *axis*\n to 'both' autoscales all three axes.\n\n Also, because of how Axes3D objects are drawn very differently\n from regular 2D axes, some of these settings may have\n ambiguous meaning. For simplicity, the 'z' axis will\n accept settings as if it was like the 'y' axis.\n\n .. note::\n Axes3D currently ignores some of these settings.\n ", "language": "en", "n_whitespaces": 176, "n_words": 86, "vocab_size": 72 }

{ "docstring": "Return the distribution name with version.\n\n If filesafe is true, return a filename-escaped form.", "language": "en", "n_whitespaces": 20, "n_words": 14, "vocab_size": 14 }

{ "docstring": "\n For an associative word `self`, a subword `gen`, and an associative\n word `by` (identity by default), return the associative word obtained by\n replacing each occurrence of `gen` in `self` by `by`. If `_all = True`,\n the occurrences of `gen` that may appear after the first substitution will\n also be replaced and so on until no occurrences are found. This might not\n always terminate (e.g. `(x).eliminate_word(x, x**2, _all=True)`).\n\n Examples\n ========\n\n >>> from sympy.combinatorics import free_group\n >>> f, x, y = free_group(\"x y\")\n >>> w = x**5*y*x**2*y**-4*x\n >>> w.eliminate_word( x, x**2 )\n x**10*y*x**4*y**-4*x**2\n >>> w.eliminate_word( x, y**-1 )\n y**-11\n >>> w.eliminate_word(x**5)\n y*x**2*y**-4*x\n >>> w.eliminate_word(x*y, y)\n x**4*y*x**2*y**-4*x\n\n See Also\n ========\n substituted_word\n\n ", "language": "en", "n_whitespaces": 270, "n_words": 108, "vocab_size": 82 }

{ "docstring": "\n Create a copy of this partition.\n\n Returns\n -------\n PandasOnDaskDataframePartition\n A copy of this partition.\n ", "language": "en", "n_whitespaces": 61, "n_words": 14, "vocab_size": 10 }

{ "docstring": "\n Create a Continuous Random Variable with a Kumaraswamy distribution.\n\n Explanation\n ===========\n\n The density of the Kumaraswamy distribution is given by\n\n .. math::\n f(x) := a b x^{a-1} (1-x^a)^{b-1}\n\n with :math:`x \\in [0,1]`.\n\n Parameters\n ==========\n\n a : Real number, `a > 0`, a shape\n b : Real number, `b > 0`, a shape\n\n Returns\n =======\n\n RandomSymbol\n\n Examples\n ========\n\n >>> from sympy.stats import Kumaraswamy, density, cdf\n >>> from sympy import Symbol, pprint\n\n >>> a = Symbol(\"a\", positive=True)\n >>> b = Symbol(\"b\", positive=True)\n >>> z = Symbol(\"z\")\n\n >>> X = Kumaraswamy(\"x\", a, b)\n\n >>> D = density(X)(z)\n >>> pprint(D, use_unicode=False)\n b - 1\n a - 1 / a\\\n a*b*z *\\1 - z /\n\n >>> cdf(X)(z)\n Piecewise((0, z < 0), (1 - (1 - z**a)**b, z <= 1), (1, True))\n\n References\n ==========\n\n .. [1] https://en.wikipedia.org/wiki/Kumaraswamy_distribution\n\n ", "language": "en", "n_whitespaces": 267, "n_words": 131, "vocab_size": 86 }