Datasets:

semeru

/

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

like 1

Follow

Semeru Lab 7

{ "docstring": "\n Test setting the owner of a file with test=True\n ", "language": "en", "n_whitespaces": 16, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Return a key given source and destination ranks for p2p tasks.\n\n The p2p key is in the following form:\n [min_rank]_[gpu_index]:[max_rank]_[gpu_index].\n\n Args:\n my_rank (int): the rank of the source process.\n my_gpu_idx (int): the source gpu index on the process.\n peer_rank (int): the rank of the destination process.\n peer_gpu_idx (int): the destination gpu index on the process.\n\n Returns:\n comm_key (str): a string key to query the communication cache.\n ", "language": "en", "n_whitespaces": 128, "n_words": 66, "vocab_size": 38 }

{ "docstring": "\n A signal receiver which updates the last_login date for\n the user logging in.\n ", "language": "en", "n_whitespaces": 23, "n_words": 13, "vocab_size": 12 }

{ "docstring": "\n Ensure the method raises if we specify a field in `search_fields` that's not text\n ", "language": "en", "n_whitespaces": 29, "n_words": 14, "vocab_size": 14 }

{ "docstring": "\n Plot y versus x as lines and/or markers.\n\n Call signatures::\n\n plot([x], y, [fmt], *, data=None, **kwargs)\n plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n\n The coordinates of the points or line nodes are given by *x*, *y*.\n\n The optional parameter *fmt* is a convenient way for defining basic\n formatting like color, marker and linestyle. It's a shortcut string\n notation described in the *Notes* section below.\n\n >>> plot(x, y) # plot x and y using default line style and color\n >>> plot(x, y, 'bo') # plot x and y using blue circle markers\n >>> plot(y) # plot y using x as index array 0..N-1\n >>> plot(y, 'r+') # ditto, but with red plusses\n\n You can use `.Line2D` properties as keyword arguments for more\n control on the appearance. Line properties and *fmt* can be mixed.\n The following two calls yield identical results:\n\n >>> plot(x, y, 'go--', linewidth=2, markersize=12)\n >>> plot(x, y, color='green', marker='o', linestyle='dashed',\n ... linewidth=2, markersize=12)\n\n When conflicting with *fmt*, keyword arguments take precedence.\n\n\n **Plotting labelled data**\n\n There's a convenient way for plotting objects with labelled data (i.e.\n data that can be accessed by index ``obj['y']``). Instead of giving\n the data in *x* and *y*, you can provide the object in the *data*\n parameter and just give the labels for *x* and *y*::\n\n >>> plot('xlabel', 'ylabel', data=obj)\n\n All indexable objects are supported. This could e.g. be a `dict`, a\n `pandas.DataFrame` or a structured numpy array.\n\n\n **Plotting multiple sets of data**\n\n There are various ways to plot multiple sets of data.\n\n - The most straight forward way is just to call `plot` multiple times.\n Example:\n\n >>> plot(x1, y1, 'bo')\n >>> plot(x2, y2, 'go')\n\n - If *x* and/or *y* are 2D arrays a separate data set will be drawn\n for every column. If both *x* and *y* are 2D, they must have the\n same shape. If only one of them is 2D with shape (N, m) the other\n must have length N and will be used for every data set m.\n\n Example:\n\n >>> x = [1, 2, 3]\n >>> y = np.array([[1, 2], [3, 4], [5, 6]])\n >>> plot(x, y)\n\n is equivalent to:\n\n >>> for col in range(y.shape[1]):\n ... plot(x, y[:, col])\n\n - The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n groups::\n\n >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n\n In this case, any additional keyword argument applies to all\n datasets. Also this syntax cannot be combined with the *data*\n parameter.\n\n By default, each line is assigned a different style specified by a\n 'style cycle'. The *fmt* and line property parameters are only\n necessary if you want explicit deviations from these defaults.\n Alternatively, you can also change the style cycle using\n :rc:`axes.prop_cycle`.\n\n\n Parameters\n ----------\n x, y : array-like or scalar\n The horizontal / vertical coordinates of the data points.\n *x* values are optional and default to ``range(len(y))``.\n\n Commonly, these parameters are 1D arrays.\n\n They can also be scalars, or two-dimensional (in that case, the\n columns represent separate data sets).\n\n These arguments cannot be passed as keywords.\n\n fmt : str, optional\n A format string, e.g. 'ro' for red circles. See the *Notes*\n section for a full description of the format strings.\n\n Format strings are just an abbreviation for quickly setting\n basic line properties. All of these and more can also be\n controlled by keyword arguments.\n\n This argument cannot be passed as keyword.\n\n data : indexable object, optional\n An object with labelled data. If given, provide the label names to\n plot in *x* and *y*.\n\n .. note::\n Technically there's a slight ambiguity in calls where the\n second label is a valid *fmt*. ``plot('n', 'o', data=obj)``\n could be ``plt(x, y)`` or ``plt(y, fmt)``. In such cases,\n the former interpretation is chosen, but a warning is issued.\n You may suppress the warning by adding an empty format string\n ``plot('n', 'o', '', data=obj)``.\n\n Returns\n -------\n list of `.Line2D`\n A list of lines representing the plotted data.\n\n Other Parameters\n ----------------\n scalex, scaley : bool, default: True\n These parameters determine if the view limits are adapted to the\n data limits. The values are passed on to\n `~.axes.Axes.autoscale_view`.\n\n **kwargs : `.Line2D` properties, optional\n *kwargs* are used to specify properties like a line label (for\n auto legends), linewidth, antialiasing, marker face color.\n Example::\n\n >>> plot([1, 2, 3], [1, 2, 3], 'go-', label='line 1', linewidth=2)\n >>> plot([1, 2, 3], [1, 4, 9], 'rs', label='line 2')\n\n If you specify multiple lines with one plot call, the kwargs apply\n to all those lines. In case the label object is iterable, each\n element is used as labels for each set of data.\n\n Here is a list of available `.Line2D` properties:\n\n %(Line2D:kwdoc)s\n\n See Also\n --------\n scatter : XY scatter plot with markers of varying size and/or color (\n sometimes also called bubble chart).\n\n Notes\n -----\n **Format Strings**\n\n A format string consists of a part for color, marker and line::\n\n fmt = '[marker][line][color]'\n\n Each of them is optional. If not provided, the value from the style\n cycle is used. Exception: If ``line`` is given, but no ``marker``,\n the data will be a line without markers.\n\n Other combinations such as ``[color][marker][line]`` are also\n supported, but note that their parsing may be ambiguous.\n\n **Markers**\n\n ============= ===============================\n character description\n ============= ===============================\n ``'.'`` point marker\n ``','`` pixel marker\n ``'o'`` circle marker\n ``'v'`` triangle_down marker\n ``'^'`` triangle_up marker\n ``'<'`` triangle_left marker\n ``'>'`` triangle_right marker\n ``'1'`` tri_down marker\n ``'2'`` tri_up marker\n ``'3'`` tri_left marker\n ``'4'`` tri_right marker\n ``'8'`` octagon marker\n ``'s'`` square marker\n ``'p'`` pentagon marker\n ``'P'`` plus (filled) marker\n ``'*'`` star marker\n ``'h'`` hexagon1 marker\n ``'H'`` hexagon2 marker\n ``'+'`` plus marker\n ``'x'`` x marker\n ``'X'`` x (filled) marker\n ``'D'`` diamond marker\n ``'d'`` thin_diamond marker\n ``'|'`` vline marker\n ``'_'`` hline marker\n ============= ===============================\n\n **Line Styles**\n\n ============= ===============================\n character description\n ============= ===============================\n ``'-'`` solid line style\n ``'--'`` dashed line style\n ``'-.'`` dash-dot line style\n ``':'`` dotted line style\n ============= ===============================\n\n Example format strings::\n\n 'b' # blue markers with default shape\n 'or' # red circles\n '-g' # green solid line\n '--' # dashed line with default color\n '^k:' # black triangle_up markers connected by a dotted line\n\n **Colors**\n\n The supported color abbreviations are the single letter codes\n\n ============= ===============================\n character color\n ============= ===============================\n ``'b'`` blue\n ``'g'`` green\n ``'r'`` red\n ``'c'`` cyan\n ``'m'`` magenta\n ``'y'`` yellow\n ``'k'`` black\n ``'w'`` white\n ============= ===============================\n\n and the ``'CN'`` colors that index into the default property cycle.\n\n If the color is the only part of the format string, you can\n additionally use any `matplotlib.colors` spec, e.g. full names\n (``'green'``) or hex strings (``'#008000'``).\n ", "language": "en", "n_whitespaces": 2954, "n_words": 1065, "vocab_size": 527 }

{ "docstring": "\n Since `start` returns the result of `task_status.started()` but here we must\n return the key instead, we just won't support this method for now.\n ", "language": "en", "n_whitespaces": 45, "n_words": 23, "vocab_size": 21 }

{ "docstring": "Cannot serialize the column [datetime1]\nbecause its data contents are not [string] but [date] object dtype", "language": "en", "n_whitespaces": 14, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Generic setattr() implementation for records: set the given\n record member, i.e. a scalar.\n ", "language": "en", "n_whitespaces": 23, "n_words": 13, "vocab_size": 13 }

{ "docstring": "\n Return the fully serialized queryset (or None if the output stream is\n not seekable).\n ", "language": "en", "n_whitespaces": 36, "n_words": 14, "vocab_size": 13 }

{ "docstring": "\n Return an iterator for one month. The iterator will yield datetime.date\n values and will always iterate through complete weeks, so it will yield\n dates outside the specified month.\n ", "language": "en", "n_whitespaces": 57, "n_words": 28, "vocab_size": 23 }

{ "docstring": "\n Getting a single item should lazily load the StreamField, only\n accessing the database once the StreamField is accessed\n ", "language": "en", "n_whitespaces": 40, "n_words": 18, "vocab_size": 16 }

{ "docstring": " update `tabPrint Format` set disabled = 0 where\n\t\tname in('Simplified Tax Invoice', 'Detailed Tax Invoice', 'Tax Invoice') ", "language": "en", "n_whitespaces": 17, "n_words": 17, "vocab_size": 15 }

{ "docstring": "Mixing in arguments required by every module into the given parser.\n :param parser: the parser instance to which we add arguments\n \n The name of this object.\n\n This will be used in the following places:\n - how you refer to this object in Python/YAML/CLI\n - visualization\n - log message header\n - ...\n\n When not given, then the default naming strategy will apply.\n ", "language": "en", "n_whitespaces": 112, "n_words": 61, "vocab_size": 49 }

{ "docstring": "\n Treebeard's path comparison logic can fail on certain locales such as sk_SK, which\n sort numbers after letters. To avoid this, we explicitly set the collation for the\n 'path' column to the (non-locale-specific) 'C' collation.\n\n See: https://groups.google.com/d/msg/wagtail/q0leyuCnYWI/I9uDvVlyBAAJ\n \n ALTER TABLE wagtailcore_collection ALTER COLUMN path TYPE VARCHAR(255) COLLATE \"C\"\n ", "language": "en", "n_whitespaces": 81, "n_words": 46, "vocab_size": 42 }

{ "docstring": "\n A PUT request to /json/realm/logo with an invalid file should fail.\n ", "language": "en", "n_whitespaces": 26, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n *Only functional with FreqAI enabled strategies*\n This optional function will be called once with the dataframe of the base timeframe.\n This is the final function to be called, which means that the dataframe entering this\n function will contain all the features and columns created by all other\n freqai_feature_engineering_* functions.\n\n This function is a good place to do custom exotic feature extractions (e.g. tsfresh).\n This function is a good place for any feature that should not be auto-expanded upon\n (e.g. day of the week).\n\n All features must be prepended with `%` to be recognized by FreqAI internals.\n\n More details about feature engineering available:\n\n https://www.freqtrade.io/en/latest/freqai-feature-engineering\n\n :param df: strategy dataframe which will receive the features\n usage example: dataframe[\"%-day_of_week\"] = (dataframe[\"date\"].dt.dayofweek + 1) / 7\n ", "language": "en", "n_whitespaces": 220, "n_words": 121, "vocab_size": 80 }

{ "docstring": "\n Pack multiple vectors into one\n Test intrinsics:\n npyv_pack_b8_b16\n npyv_pack_b8_b32\n npyv_pack_b8_b64\n ", "language": "en", "n_whitespaces": 65, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Test color_mode is not combined with deprecated config.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n Test decryption using a renderer which is not permitted. It should\n fail, leaving the encrypted keys intact, and add an error to the pillar\n dictionary.\n\n decrypt_pillar_default: foo\n decrypt_pillar_renderers:\n - foo\n - bar\n decrypt_pillar:\n - 'secrets:vault': gpg\n ", "language": "en", "n_whitespaces": 97, "n_words": 36, "vocab_size": 32 }

{ "docstring": "Test file handling when closing with an unreadable file.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Returns an Algebra of Recurrence Operators and the operator for\n shifting i.e. the `Sn` operator.\n The first argument needs to be the base polynomial ring for the algebra\n and the second argument must be a generator which can be either a\n noncommutative Symbol or a string.\n\n Examples\n ========\n\n >>> from sympy import ZZ\n >>> from sympy import symbols\n >>> from sympy.holonomic.recurrence import RecurrenceOperators\n >>> n = symbols('n', integer=True)\n >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')\n ", "language": "en", "n_whitespaces": 114, "n_words": 74, "vocab_size": 53 }

{ "docstring": " Patch faces.\n\n Run the convert process on the swapped faces and return the patched faces.\n\n patch_queue_in: :class:`queue.Queue`\n The input queue for the patching process\n queue_out: :class:`queue.Queue`\n The output queue from the patching process\n sample_size: int\n The number of samples to be displayed\n\n Returns\n -------\n list\n The swapped faces patched with the selected convert settings\n ", "language": "en", "n_whitespaces": 155, "n_words": 54, "vocab_size": 36 }

{ "docstring": "\n Load or convert input to OpenCV BGR image numpy array.\n\n Parameters\n ----------\n image : str, PIL.Image, or np.ndarray\n Image to load or convert.\n\n Raises\n ------\n FileNotFoundError\n Raised when the input is a path to file (str), but the file is not found.\n TypeError\n Raised when the data type of the input is not supported.\n\n Returns\n -------\n image : np.ndarray\n OpenCV BGR image.\n ", "language": "en", "n_whitespaces": 191, "n_words": 62, "vocab_size": 41 }

{ "docstring": "Convert a Keras Model into a bytecode representation for pickling.\n\n Args:\n model: Keras Model instance.\n\n Returns:\n Tuple that can be read by `deserialize_from_bytecode`.\n ", "language": "en", "n_whitespaces": 46, "n_words": 23, "vocab_size": 20 }

{ "docstring": "Generator of lines for the automated part of pyplot.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "SELECT name, lft, parent_territory, is_group FROM `tabTerritory` ORDER BY lft", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Return the layers in sorted order if the layers of the multipartite\n graph are sortable. See gh-5691", "language": "en", "n_whitespaces": 19, "n_words": 17, "vocab_size": 14 }

{ "docstring": "\n Trace basic information about the provided objects.\n ", "language": "en", "n_whitespaces": 22, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\n Returns a plot object representing the beam diagram of the beam.\n\n .. note::\n The user must be careful while entering load values.\n The draw function assumes a sign convention which is used\n for plotting loads.\n Given a right handed coordinate system with XYZ coordinates,\n the beam's length is assumed to be along the positive X axis.\n The draw function recognizes positive loads(with n>-2) as loads\n acting along negative Y direction and positive moments acting\n along positive Z direction.\n\n Parameters\n ==========\n\n pictorial: Boolean (default=True)\n Setting ``pictorial=True`` would simply create a pictorial (scaled) view\n of the beam diagram not with the exact dimensions.\n Although setting ``pictorial=False`` would create a beam diagram with\n the exact dimensions on the plot\n\n Examples\n ========\n\n .. plot::\n :context: close-figs\n :format: doctest\n :include-source: True\n\n >>> from sympy.physics.continuum_mechanics.beam import Beam\n >>> from sympy import symbols\n >>> R1, R2 = symbols('R1, R2')\n >>> E, I = symbols('E, I')\n >>> b = Beam(50, 20, 30)\n >>> b.apply_load(10, 2, -1)\n >>> b.apply_load(R1, 10, -1)\n >>> b.apply_load(R2, 30, -1)\n >>> b.apply_load(90, 5, 0, 23)\n >>> b.apply_load(10, 30, 1, 50)\n >>> b.apply_support(50, \"pin\")\n >>> b.apply_support(0, \"fixed\")\n >>> b.apply_support(20, \"roller\")\n >>> p = b.draw()\n >>> p\n Plot object containing:\n [0]: cartesian line: 25*SingularityFunction(x, 5, 0) - 25*SingularityFunction(x, 23, 0)\n + SingularityFunction(x, 30, 1) - 20*SingularityFunction(x, 50, 0)\n - SingularityFunction(x, 50, 1) + 5 for x over (0.0, 50.0)\n [1]: cartesian line: 5 for x over (0.0, 50.0)\n >>> p.show()\n\n ", "language": "en", "n_whitespaces": 694, "n_words": 234, "vocab_size": 153 }

{ "docstring": "\n\t\tSELECT\n\t\t\tCOUNT(DISTINCT holiday_date)\n\t\tFROM `tabHoliday` h1,`tabHoliday List` h2\n\t\tWHERE\n\t\t\th1.parent = h2.name and\n\t\t\th1.holiday_date between %s and %s and\n\t\t\th2.name = %s", "language": "en", "n_whitespaces": 15, "n_words": 22, "vocab_size": 16 }

{ "docstring": "\n Get the mapping of generator local variables to their current values.\n\n A dict is returned, with the keys the local variable names and values the\n bound values.", "language": "en", "n_whitespaces": 36, "n_words": 27, "vocab_size": 22 }

{ "docstring": "\n Remove the current authenticated user in the request which is invalid\n but only if the user is authenticated via the RemoteUserBackend.\n ", "language": "en", "n_whitespaces": 43, "n_words": 21, "vocab_size": 15 }

{ "docstring": "Run AWSNodeProvider.set_node_tags in several threads, with a\n specified delay between thread launches.\n\n Return the number of batches of tag updates and the number of tags\n updated.\n ", "language": "en", "n_whitespaces": 38, "n_words": 26, "vocab_size": 22 }

{ "docstring": "\n Generates a dictionary of features for a given input sample that is to be consumed by a text classification model.\n\n :param sample: Sample object that contains human readable text and label fields from a single text classification data sample\n :type sample: Sample\n :param tasks: A dictionary where the keys are the names of the tasks and the values are the details of the task (e.g. label_list, metric, tensor name)\n :type tasks: dict\n :param max_seq_len: Sequences are truncated after this many tokens\n :type max_seq_len: int\n :param tokenizer: A tokenizer object that can turn string sentences into a list of tokens\n :return: A list with one dictionary containing the keys \"input_ids\", \"padding_mask\" and \"segment_ids\" (also \"label_ids\" if not\n in inference mode). The values are lists containing those features.\n :rtype: list\n ", "language": "en", "n_whitespaces": 174, "n_words": 128, "vocab_size": 84 }

{ "docstring": "Return whether the state is based on actual reading from device.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Helper function for tab_close to get the tab to select.\n\n Args:\n prev: Force selecting the tab before the current tab.\n next_: Force selecting the tab after the current tab.\n opposite: Force selecting the tab in the opposite direction of\n what's configured in 'tabs.select_on_remove'.\n\n Return:\n QTabBar.SelectionBehavior.SelectLeftTab, QTabBar.SelectionBehavior.SelectRightTab, or None if no change\n should be made.\n ", "language": "en", "n_whitespaces": 151, "n_words": 54, "vocab_size": 37 }

{ "docstring": "drf-spectacular library method modified as described above", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\n Midpoint of rectangle edges in data coordinates from left,\n moving anti-clockwise.\n ", "language": "en", "n_whitespaces": 33, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n Return the type of this event.\n\n See ``sentry.eventtypes``.\n ", "language": "en", "n_whitespaces": 30, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n dequantize quantized value.\n Because we simulate quantization in training process, all the computations still happen as float point computations, which means we\n first quantize tensors then dequantize them. For more details, please refer to the paper.\n\n Parameters\n ----------\n quantized_val : torch.Tensor\n the quantized value to be de-quantized\n scale : torch.Tensor\n quantization scale\n zero_point : torch.Tensor\n quantization zero point\n\n Returns\n -------\n Tensor\n ", "language": "en", "n_whitespaces": 179, "n_words": 61, "vocab_size": 47 }

{ "docstring": "Return a dictionary of attributes for this instance.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Returns iterator of node-attribute pairs for all edges in G.\n\n Parameters\n ----------\n G: NetworkX graph\n\n attribute: key\n The node attribute key.\n\n nodes: list or iterable (optional)\n Use only edges that are incident to specified nodes.\n The default is all nodes.\n\n Returns\n -------\n (x, y): 2-tuple\n Generates 2-tuple of (attribute, attribute) values.\n\n Examples\n --------\n >>> G = nx.DiGraph()\n >>> G.add_node(1, color=\"red\")\n >>> G.add_node(2, color=\"blue\")\n >>> G.add_edge(1, 2)\n >>> list(nx.node_attribute_xy(G, \"color\"))\n [('red', 'blue')]\n\n Notes\n -----\n For undirected graphs each edge is produced twice, once for each edge\n representation (u, v) and (v, u), with the exception of self-loop edges\n which only appear once.\n ", "language": "en", "n_whitespaces": 194, "n_words": 101, "vocab_size": 83 }

{ "docstring": "Caches can disable applying cache factor updates, mainly used by\n event cache size.\n ", "language": "en", "n_whitespaces": 27, "n_words": 13, "vocab_size": 12 }

{ "docstring": "Remove the Widget from the DOM (effectively deleting it)\n\n Returns:\n AwaitRemove: An awaitable object that waits for the widget to be removed.\n ", "language": "en", "n_whitespaces": 47, "n_words": 22, "vocab_size": 20 }

{ "docstring": "\n Paperless requires the existence of a few binaries, so we do some checks\n for those here.\n ", "language": "en", "n_whitespaces": 26, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Generates the sequence of bit vectors of a Gray Code.\n\n Examples\n ========\n\n >>> from sympy.combinatorics import GrayCode\n >>> a = GrayCode(3)\n >>> list(a.generate_gray())\n ['000', '001', '011', '010', '110', '111', '101', '100']\n >>> list(a.generate_gray(start='011'))\n ['011', '010', '110', '111', '101', '100']\n >>> list(a.generate_gray(rank=4))\n ['110', '111', '101', '100']\n\n See Also\n ========\n\n skip\n\n References\n ==========\n\n .. [1] Knuth, D. (2011). The Art of Computer Programming,\n Vol 4, Addison Wesley\n\n ", "language": "en", "n_whitespaces": 206, "n_words": 65, "vocab_size": 49 }

{ "docstring": "Checks if current error lies not in timeout after last trigger (potential reset of connection).", "language": "en", "n_whitespaces": 14, "n_words": 15, "vocab_size": 15 }

{ "docstring": "Find the loader or namespace_path for this module/package name.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Test that we can get a full list of rooms through pagination", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Draw the rack unit placeholders which form the \"background\" of the rack elevation.\n ", "language": "en", "n_whitespaces": 28, "n_words": 13, "vocab_size": 10 }

{ "docstring": "Update the new state of the sensor.\n\n This is done through the DanfossAir object that does the actual\n communication with the Air CCM.\n ", "language": "en", "n_whitespaces": 44, "n_words": 23, "vocab_size": 19 }

{ "docstring": "Can code for the `provided` platform run on the `required` platform?\n\n Returns true if either platform is ``None``, or the platforms are equal.\n\n XXX Needs compatibility checks for Linux and other unixy OSes.\n ", "language": "en", "n_whitespaces": 42, "n_words": 33, "vocab_size": 29 }

{ "docstring": "Get a list of all options, including those in option groups.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Test if this address is allocated for private networks.\n\n Returns:\n A boolean, True if the address is reserved per\n iana-ipv4-special-registry or iana-ipv6-special-registry.\n\n ", "language": "en", "n_whitespaces": 58, "n_words": 22, "vocab_size": 19 }

{ "docstring": "Get tune.run arguments common for both new and resumed runs.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Performs a single optimization step.\n\n Args:\n closure (callable, optional): A closure that reevaluates the model and returns the loss.\n ", "language": "en", "n_whitespaces": 44, "n_words": 19, "vocab_size": 17 }

{ "docstring": "\n Retrieve a list of messages from the request's session. This storage\n always stores everything it is given, so return True for the\n all_retrieved flag.\n ", "language": "en", "n_whitespaces": 53, "n_words": 24, "vocab_size": 23 }

{ "docstring": "\n Parse known args to ignore help flag.\n ", "language": "en", "n_whitespaces": 22, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Test _uptime runs and check if microseconds are dropped.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Tries to match city, state and country of address to existing territory", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 11 }

{ "docstring": "This should result in errors as dots in paths are not allowed.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Compute the metadata for the result of reduce function.\n\n Parameters\n ----------\n axis : int\n The axis on which reduce function was applied.\n new_parts : NumPy 2D array\n Partitions with the result of applied function.\n\n Returns\n -------\n PandasDataframe\n Modin series (1xN frame) containing the reduced data.\n ", "language": "en", "n_whitespaces": 142, "n_words": 45, "vocab_size": 36 }

{ "docstring": "Returns an exception that is an instance of the cause's class.\n\n The returned exception will inherit from both RayTaskError and the\n cause class and will contain all of the attributes of the cause\n exception.\n ", "language": "en", "n_whitespaces": 62, "n_words": 34, "vocab_size": 24 }

{ "docstring": "Examines whether G1 and G2 are isomorphic.\n\n Parameters\n ----------\n G1, G2 : NetworkX Graph or MultiGraph instances.\n The two graphs to check for isomorphism.\n\n node_label : str, optional\n The name of the node attribute to be used when comparing nodes.\n The default is `None`, meaning node attributes are not considered\n in the comparison. Any node that doesn't have the `node_label`\n attribute uses `default_label` instead.\n\n default_label : scalar\n Default value to use when a node doesn't have an attribute\n named `node_label`. Default is `None`.\n\n Returns\n -------\n bool\n True if the two graphs are isomorphic, False otherwise.\n ", "language": "en", "n_whitespaces": 178, "n_words": 95, "vocab_size": 71 }

{ "docstring": "Assert that TPOT's predict_proba is exposed when available, and hidden when not.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Access a lexical unit by its ID. luName, frameID, and frameName are used\n only in the event that the LU does not have a file in the database\n (which is the case for LUs with \"Problem\" status); in this case,\n a placeholder LU is created which just contains its name, ID, and frame.\n\n\n Usage examples:\n\n >>> from nltk.corpus import framenet as fn\n >>> fn.lu(256).name\n 'foresee.v'\n >>> fn.lu(256).definition\n 'COD: be aware of beforehand; predict.'\n >>> fn.lu(256).frame.name\n 'Expectation'\n >>> list(map(PrettyDict, fn.lu(256).lexemes))\n [{'POS': 'V', 'breakBefore': 'false', 'headword': 'false', 'name': 'foresee', 'order': 1}]\n\n >>> fn.lu(227).exemplars[23] # doctest: +NORMALIZE_WHITESPACE\n exemplar sentence (352962):\n [sentNo] 0\n [aPos] 59699508\n <BLANKLINE>\n [LU] (227) guess.v in Coming_to_believe\n <BLANKLINE>\n [frame] (23) Coming_to_believe\n <BLANKLINE>\n [annotationSet] 2 annotation sets\n <BLANKLINE>\n [POS] 18 tags\n <BLANKLINE>\n [POS_tagset] BNC\n <BLANKLINE>\n [GF] 3 relations\n <BLANKLINE>\n [PT] 3 phrases\n <BLANKLINE>\n [Other] 1 entry\n <BLANKLINE>\n [text] + [Target] + [FE]\n <BLANKLINE>\n When he was inside the house , Culley noticed the characteristic\n ------------------\n Content\n <BLANKLINE>\n he would n't have guessed at .\n -- ******* --\n Co C1 [Evidence:INI]\n (Co=Cognizer, C1=Content)\n <BLANKLINE>\n <BLANKLINE>\n\n The dict that is returned from this function will contain most of the\n following information about the LU. Note that some LUs do not contain\n all of these pieces of information - particularly 'totalAnnotated' and\n 'incorporatedFE' may be missing in some LUs:\n\n - 'name' : the name of the LU (e.g. 'merger.n')\n - 'definition' : textual definition of the LU\n - 'ID' : the internal ID number of the LU\n - '_type' : 'lu'\n - 'status' : e.g. 'Created'\n - 'frame' : Frame that this LU belongs to\n - 'POS' : the part of speech of this LU (e.g. 'N')\n - 'totalAnnotated' : total number of examples annotated with this LU\n - 'incorporatedFE' : FE that incorporates this LU (e.g. 'Ailment')\n - 'sentenceCount' : a dict with the following two keys:\n - 'annotated': number of sentences annotated with this LU\n - 'total' : total number of sentences with this LU\n\n - 'lexemes' : a list of dicts describing the lemma of this LU.\n Each dict in the list contains these keys:\n\n - 'POS' : part of speech e.g. 'N'\n - 'name' : either single-lexeme e.g. 'merger' or\n multi-lexeme e.g. 'a little'\n - 'order': the order of the lexeme in the lemma (starting from 1)\n - 'headword': a boolean ('true' or 'false')\n - 'breakBefore': Can this lexeme be separated from the previous lexeme?\n Consider: \"take over.v\" as in::\n\n Germany took over the Netherlands in 2 days.\n Germany took the Netherlands over in 2 days.\n\n In this case, 'breakBefore' would be \"true\" for the lexeme\n \"over\". Contrast this with \"take after.v\" as in::\n\n Mary takes after her grandmother.\n *Mary takes her grandmother after.\n\n In this case, 'breakBefore' would be \"false\" for the lexeme \"after\"\n\n - 'lemmaID' : Can be used to connect lemmas in different LUs\n - 'semTypes' : a list of semantic type objects for this LU\n - 'subCorpus' : a list of subcorpora\n - Each item in the list is a dict containing the following keys:\n - 'name' :\n - 'sentence' : a list of sentences in the subcorpus\n - each item in the list is a dict with the following keys:\n - 'ID':\n - 'sentNo':\n - 'text': the text of the sentence\n - 'aPos':\n - 'annotationSet': a list of annotation sets\n - each item in the list is a dict with the following keys:\n - 'ID':\n - 'status':\n - 'layer': a list of layers\n - each layer is a dict containing the following keys:\n - 'name': layer name (e.g. 'BNC')\n - 'rank':\n - 'label': a list of labels for the layer\n - each label is a dict containing the following keys:\n - 'start': start pos of label in sentence 'text' (0-based)\n - 'end': end pos of label in sentence 'text' (0-based)\n - 'name': name of label (e.g. 'NN1')\n\n Under the hood, this implementation looks up the lexical unit information\n in the *frame* definition file. That file does not contain\n corpus annotations, so the LU files will be accessed on demand if those are\n needed. In principle, valence patterns could be loaded here too,\n though these are not currently supported.\n\n :param fn_luid: The id number of the lexical unit\n :type fn_luid: int\n :param ignorekeys: The keys to ignore. These keys will not be\n included in the output. (optional)\n :type ignorekeys: list(str)\n :return: All information about the lexical unit\n :rtype: dict\n ", "language": "en", "n_whitespaces": 2239, "n_words": 723, "vocab_size": 328 }

{ "docstring": "\n Combine a list of subexpressions into a single expression, using\n the provided connecting operator. This is required because operators\n can vary between backends (e.g., Oracle with %% and &) and between\n subexpression types (e.g., date expressions).\n ", "language": "en", "n_whitespaces": 72, "n_words": 36, "vocab_size": 32 }

{ "docstring": "Map infrequent categories to integer representing the infrequent category.\n\n This modifies X_int in-place. Values that were invalid based on `X_mask`\n are mapped to the infrequent category if there was an infrequent\n category for that feature.\n\n Parameters\n ----------\n X_int: ndarray of shape (n_samples, n_features)\n Integer encoded categories.\n\n X_mask: ndarray of shape (n_samples, n_features)\n Bool mask for valid values in `X_int`.\n ", "language": "en", "n_whitespaces": 137, "n_words": 59, "vocab_size": 46 }

{ "docstring": "Test that the IS and WIS estimators work.\n\n First we compute the estimates with RLlib's algorithm and then compare the\n results to the estimates that are manually computed on raw data frame version\n of the dataset to check correctness.\n ", "language": "en", "n_whitespaces": 67, "n_words": 39, "vocab_size": 31 }

{ "docstring": "Rewrite Fortran expression as f2py supported C expression.\n\n Due to the lack of a proper expression parser in f2py, this\n function uses a heuristic approach that assumes that Fortran\n arithmetic expressions are valid C arithmetic expressions when\n mapping Fortran function calls to the corresponding C function/CPP\n macros calls.\n\n ", "language": "en", "n_whitespaces": 66, "n_words": 48, "vocab_size": 36 }

{ "docstring": " Checks that a key-value table exists, otherwise creates it. create table store (key text, value text)", "language": "en", "n_whitespaces": 16, "n_words": 16, "vocab_size": 15 }

{ "docstring": "\n Export all table data in CSV format.\n\n :param table: The Table instance to export\n :param columns: A list of specific columns to include. If not specified, all columns will be exported.\n ", "language": "en", "n_whitespaces": 60, "n_words": 31, "vocab_size": 27 }

{ "docstring": "Generates the Euler polynomial of degree `n` in `x`.\n\n Parameters\n ==========\n\n n : int\n Degree of the polynomial.\n x : optional\n polys : bool, optional\n If True, return a Poly, otherwise (default) return an expression.\n ", "language": "en", "n_whitespaces": 67, "n_words": 35, "vocab_size": 29 }

{ "docstring": "Tests that expired events are correctly purged when the room's retention policy\n is defined by the server's configuration's default retention policy.\n ", "language": "en", "n_whitespaces": 35, "n_words": 21, "vocab_size": 19 }

{ "docstring": "Test that the error and reconnection attempts are logged correctly.\n\n \"Handles device/service unavailable. Log a warning once when\n unavailable, log once when reconnected.\"\n\n https://developers.home-assistant.io/docs/en/integration_quality_scale_index.html\n ", "language": "en", "n_whitespaces": 36, "n_words": 24, "vocab_size": 22 }

{ "docstring": "\n Check that a ValidationError is raised if any required custom fields are not present.\n ", "language": "en", "n_whitespaces": 29, "n_words": 14, "vocab_size": 14 }

{ "docstring": " AND (finance_book in (%s, %s, '') OR finance_book IS NULL)\n\t\t\t\n\t\tselect sum(credit) - sum(debit)\n\t\tfrom `tabGL Entry`\n\t\twhere company=%s and posting_date >= %s and posting_date <= %s\n\t\t\tand voucher_type != 'Period Closing Voucher'\n\t\t\tand account in ( SELECT name FROM tabAccount WHERE account_type = %s) {cond}\n\t", "language": "en", "n_whitespaces": 41, "n_words": 46, "vocab_size": 40 }

{ "docstring": "Calculates number of new and repeated customers and revenue.select territory, posting_date, customer, base_grand_total from `tabSales Invoice`\n\t\twhere docstatus=1 and posting_date <= %(to_date)s\n\t\t{company_condition} order by posting_date", "language": "en", "n_whitespaces": 23, "n_words": 26, "vocab_size": 23 }

{ "docstring": "Read the number of bytes requested.\n\n This function should be used when <amt> bytes \"should\" be present for\n reading. If the bytes are truly not available (due to EOF), then the\n IncompleteRead exception can be used to detect the problem.\n ", "language": "en", "n_whitespaces": 68, "n_words": 40, "vocab_size": 31 }

{ "docstring": "Get the number of cells required to render this object.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side. During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft). Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.", "language": "en", "n_whitespaces": 221, "n_words": 222, "vocab_size": 117 }

{ "docstring": "\n Remember a line number drawable to paint later.\n ", "language": "en", "n_whitespaces": 23, "n_words": 8, "vocab_size": 8 }

{ "docstring": "\n Compute the qr factorization of a matrix.\n\n Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is\n upper-triangular.\n\n Parameters\n ----------\n a : array_like, shape (..., M, N)\n An array-like object with the dimensionality of at least 2.\n mode : {'reduced', 'complete', 'r', 'raw'}, optional\n If K = min(M, N), then\n\n * 'reduced' : returns q, r with dimensions\n (..., M, K), (..., K, N) (default)\n * 'complete' : returns q, r with dimensions (..., M, M), (..., M, N)\n * 'r' : returns r only with dimensions (..., K, N)\n * 'raw' : returns h, tau with dimensions (..., N, M), (..., K,)\n\n The options 'reduced', 'complete, and 'raw' are new in numpy 1.8,\n see the notes for more information. The default is 'reduced', and to\n maintain backward compatibility with earlier versions of numpy both\n it and the old default 'full' can be omitted. Note that array h\n returned in 'raw' mode is transposed for calling Fortran. The\n 'economic' mode is deprecated. The modes 'full' and 'economic' may\n be passed using only the first letter for backwards compatibility,\n but all others must be spelled out. See the Notes for more\n explanation.\n\n\n Returns\n -------\n q : ndarray of float or complex, optional\n A matrix with orthonormal columns. When mode = 'complete' the\n result is an orthogonal/unitary matrix depending on whether or not\n a is real/complex. The determinant may be either +/- 1 in that\n case. In case the number of dimensions in the input array is\n greater than 2 then a stack of the matrices with above properties\n is returned.\n r : ndarray of float or complex, optional\n The upper-triangular matrix or a stack of upper-triangular\n matrices if the number of dimensions in the input array is greater\n than 2.\n (h, tau) : ndarrays of np.double or np.cdouble, optional\n The array h contains the Householder reflectors that generate q\n along with r. The tau array contains scaling factors for the\n reflectors. In the deprecated 'economic' mode only h is returned.\n\n Raises\n ------\n LinAlgError\n If factoring fails.\n\n See Also\n --------\n scipy.linalg.qr : Similar function in SciPy.\n scipy.linalg.rq : Compute RQ decomposition of a matrix.\n\n Notes\n -----\n This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``,\n ``dorgqr``, and ``zungqr``.\n\n For more information on the qr factorization, see for example:\n https://en.wikipedia.org/wiki/QR_factorization\n\n Subclasses of `ndarray` are preserved except for the 'raw' mode. So if\n `a` is of type `matrix`, all the return values will be matrices too.\n\n New 'reduced', 'complete', and 'raw' options for mode were added in\n NumPy 1.8.0 and the old option 'full' was made an alias of 'reduced'. In\n addition the options 'full' and 'economic' were deprecated. Because\n 'full' was the previous default and 'reduced' is the new default,\n backward compatibility can be maintained by letting `mode` default.\n The 'raw' option was added so that LAPACK routines that can multiply\n arrays by q using the Householder reflectors can be used. Note that in\n this case the returned arrays are of type np.double or np.cdouble and\n the h array is transposed to be FORTRAN compatible. No routines using\n the 'raw' return are currently exposed by numpy, but some are available\n in lapack_lite and just await the necessary work.\n\n Examples\n --------\n >>> a = np.random.randn(9, 6)\n >>> q, r = np.linalg.qr(a)\n >>> np.allclose(a, np.dot(q, r)) # a does equal qr\n True\n >>> r2 = np.linalg.qr(a, mode='r')\n >>> np.allclose(r, r2) # mode='r' returns the same r as mode='full'\n True\n >>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input\n >>> q, r = np.linalg.qr(a)\n >>> q.shape\n (3, 2, 2)\n >>> r.shape\n (3, 2, 2)\n >>> np.allclose(a, np.matmul(q, r))\n True\n\n Example illustrating a common use of `qr`: solving of least squares\n problems\n\n What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for\n the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points\n and you'll see that it should be y0 = 0, m = 1.) The answer is provided\n by solving the over-determined matrix equation ``Ax = b``, where::\n\n A = array([[0, 1], [1, 1], [1, 1], [2, 1]])\n x = array([[y0], [m]])\n b = array([[1], [0], [2], [1]])\n\n If A = qr such that q is orthonormal (which is always possible via\n Gram-Schmidt), then ``x = inv(r) * (q.T) * b``. (In numpy practice,\n however, we simply use `lstsq`.)\n\n >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])\n >>> A\n array([[0, 1],\n [1, 1],\n [1, 1],\n [2, 1]])\n >>> b = np.array([1, 2, 2, 3])\n >>> q, r = np.linalg.qr(A)\n >>> p = np.dot(q.T, b)\n >>> np.dot(np.linalg.inv(r), p)\n array([ 1., 1.])\n\n ", "language": "en", "n_whitespaces": 1269, "n_words": 761, "vocab_size": 356 }

{ "docstring": "Return the ZHA devices that are members of this group.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "{% if doc.contact_person -%}\n<p>Dear {{ doc.contact_person }},</p>\n{%- else %}<p>Hello,</p>{% endif %}\n\n<p>{{ _(\"Requesting payment against {0} {1} for amount {2}\").format(doc.doctype,\n\tdoc.name, doc.get_formatted(\"grand_total\")) }}</p>\n\n<a href=\"{{ payment_url }}\">{{ _(\"Make Payment\") }}</a>\n\n<p>{{ _(\"If you have any questions, please get back to us.\") }}</p>\n\n<p>{{ _(\"Thank you for your business!\") }}</p>\n", "language": "en", "n_whitespaces": 43, "n_words": 51, "vocab_size": 44 }

{ "docstring": "Process find command\n Find similar coin by coin name,symbol or id. If you don't remember exact name or id of the Coin at CoinGecko,\n Binance, Coinbase or CoinPaprika you can use this command to display coins with similar name, symbol or id\n to your search query.\n Example of usage: coin name is something like \"polka\". So I can try: find -c polka -k name -t 25\n It will search for coin that has similar name to polka and display top 25 matches.\n -c, --coin stands for coin - you provide here your search query\n -k, --key it's a searching key. You can search by symbol, id or name of coin\n -l, --limit it displays top N number of records.\n coins: Shows list of coins available on CoinGecko, CoinPaprika and Binance.If you provide name of\n coin then in result you will see ids of coins with best match for all mentioned services.\n If you provide ALL keyword in your search query, then all coins will be displayed. To move over coins you\n can use pagination mechanism with skip, top params. E.g. coins ALL --skip 100 --limit 30 then all coins\n from 100 to 130 will be displayed. By default skip = 0, limit = 10.\n If you won't provide source of the data everything will be displayed (CoinGecko, CoinPaprika, Binance).\n If you want to search only in given source then use --source flag. E.g. if you want to find coin with name\n uniswap on CoinPaprika then use: coins uniswap --source cp --limit 10\n ", "language": "en", "n_whitespaces": 439, "n_words": 252, "vocab_size": 140 }

{ "docstring": "\n This method determines if it is necessary to invalidate\n the existing cache based on whether the device has entered\n configuration mode or if the last command sent to the device\n is potentially capable of making configuration changes.\n\n :param command: The last command sent to the target device.\n :returns: A boolean indicating if cache invalidation is required or not.\n ", "language": "en", "n_whitespaces": 108, "n_words": 58, "vocab_size": 41 }

{ "docstring": "Project data to maximize class separation.\n\n Parameters\n ----------\n X : array-like of shape (n_samples, n_features)\n Input data.\n\n Returns\n -------\n X_new : ndarray of shape (n_samples, n_components) or \\\n (n_samples, min(rank, n_components))\n Transformed data. In the case of the 'svd' solver, the shape\n is (n_samples, min(rank, n_components)).\n ", "language": "en", "n_whitespaces": 139, "n_words": 46, "vocab_size": 34 }

{ "docstring": "\n Save a pre-change snapshot of the object immediately after retrieving it. This snapshot will be used to\n record the \"before\" data in the changelog.\n ", "language": "en", "n_whitespaces": 46, "n_words": 24, "vocab_size": 21 }

{ "docstring": "Helper method which loads coins from all sources: CoinGecko, CoinPaprika,\n Binance, Yahoo Finance and merge those coins on keys:\n\n CoinGecko - > name < - CoinPaprika\n CoinGecko - > id <- Binance\n\n Returns\n -------\n pd.DataFrame\n CoinGecko - id for coin in CoinGecko API: uniswap\n CoinPaprika - id for coin in CoinPaprika API: uni-uniswap\n Binance - symbol (baseAsset) for coin in Binance API: UNI\n Coinbase - symbol for coin in Coinbase Pro API e.g UNI\n Yahoo Finance - symbol for coin in Yahoo Finance e.g. UNI1-USD\n\n Symbol: uni\n ", "language": "en", "n_whitespaces": 158, "n_words": 87, "vocab_size": 47 }

{ "docstring": "Autoscaling config with memory and gpu annotations.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\\\nimport os, sys\nif sys.stdin:\n os.close(sys.stdin.fileno())\nif sys.stdout:\n os.close(sys.stdout.fileno())\nif sys.stderr:\n os.close(sys.stderr.fileno())\nos.execlp('kitty', 'kitty', '+runpy', 'import sys; raise SystemExit(1 if sys.stdout is None or sys.stdin is None or sys.stderr is None else 0)')\n", "language": "en", "n_whitespaces": 37, "n_words": 34, "vocab_size": 26 }

{ "docstring": "\n Return the X, Y coordinates of the top left corner for a device in the specified rack unit.\n ", "language": "en", "n_whitespaces": 33, "n_words": 18, "vocab_size": 16 }

{ "docstring": "Test that a NOTSET value (used by an empty parameterset) generates\n a proper ID.\n\n Regression test for #7686.\n ", "language": "en", "n_whitespaces": 39, "n_words": 18, "vocab_size": 17 }

{ "docstring": "This function allows the user to fork environments.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Report the current size of the cluster.\n\n To avoid log spam, only cluster size changes (CPU or GPU count change)\n are reported to the event summarizer. The event summarizer will report\n only the latest cluster size per batch.\n ", "language": "en", "n_whitespaces": 66, "n_words": 38, "vocab_size": 30 }

{ "docstring": "Lookup and instantiate a formatter by filename pattern.\n\n Raises ClassNotFound if not found.\n ", "language": "en", "n_whitespaces": 19, "n_words": 13, "vocab_size": 13 }

{ "docstring": "\n Loads the work queue objects corresponding to the agent's target work\n queues. If any of them don't exist, they are created.\n ", "language": "en", "n_whitespaces": 43, "n_words": 21, "vocab_size": 19 }