Datasets:

semeru

/

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

like 1

{ "docstring": "\n This is a test of the pytest marker \"logmodetest\".\n This should only be invoked if the environment variable is properly set\n (before pytest is run).\n\n Also, tests that kivy.logger paid attention to the environment variable\n ", "language": "en", "n_whitespaces": 51, "n_words": 35, "vocab_size": 27 }

{ "docstring": " Return the the files to check for cuDNN locations for Linux by querying\n the dynamic link loader.\n\n Returns\n -------\n list\n List of header file locations to scan for cuDNN versions\n ", "language": "en", "n_whitespaces": 77, "n_words": 30, "vocab_size": 23 }

{ "docstring": " Set the default options for :mod:`lib.gui.projects`\n\n The Default GUI options are stored on Faceswap startup.\n\n Exposed as the :attr:`_default_opts` for a project cannot be set until after the main\n Command Tabs have been loaded.\n ", "language": "en", "n_whitespaces": 63, "n_words": 34, "vocab_size": 30 }

{ "docstring": "Try to import all of Synapse and see if we spot any Pydantic type coercions.", "language": "en", "n_whitespaces": 14, "n_words": 15, "vocab_size": 15 }

{ "docstring": "Use a hack to try keep autosimplification from distributing a\n a number into an Add; this modification does not\n prevent the 2-arg Mul from becoming an Add, however.\n\n Examples\n ========\n\n >>> from sympy.core.sympify import kernS\n >>> from sympy.abc import x, y\n\n The 2-arg Mul distributes a number (or minus sign) across the terms\n of an expression, but kernS will prevent that:\n\n >>> 2*(x + y), -(x + 1)\n (2*x + 2*y, -x - 1)\n >>> kernS('2*(x + y)')\n 2*(x + y)\n >>> kernS('-(x + 1)')\n -(x + 1)\n\n If use of the hack fails, the un-hacked string will be passed to sympify...\n and you get what you get.\n\n XXX This hack should not be necessary once issue 4596 has been resolved.\n ", "language": "en", "n_whitespaces": 175, "n_words": 121, "vocab_size": 82 }

{ "docstring": "\n Test install of non-recognized extension, first dnf then fileset\n AIX generic repository 12 kB/s | 2.6 kB 00:00\nAIX noarch repository 12 kB/s | 2.5 kB 00:00 \nAIX 7.2 specific repository 12 kB/s | 2.5 kB 00:00 \nNo match for argument: bos.net\nError: Unable to find a match: bos.net\n", "language": "en", "n_whitespaces": 709, "n_words": 49, "vocab_size": 33 }

{ "docstring": "Plot resource usage in a bokeh plot.\n\n Parameters\n ----------\n results : sequence\n Output of ResourceProfiler.results\n palette : string, optional\n Name of the bokeh palette to use, must be a member of\n bokeh.palettes.all_palettes.\n **kwargs\n Other keyword arguments, passed to bokeh.figure. These will override\n all defaults set by plot_resources.\n\n Returns\n -------\n The completed bokeh plot object.\n ", "language": "en", "n_whitespaces": 116, "n_words": 54, "vocab_size": 46 }

{ "docstring": "\n\t\t\tselect t.owner,\n\t\t\t t.posting_date,\n\t\t\t\t t.mode_of_payment,\n\t\t\t\t sum(t.paid_amount) as paid_amount\n\t\t\tfrom (\n\t\t\t\tselect a.owner, a.posting_date,\n\t\t\t\tifnull(b.mode_of_payment, '') as mode_of_payment, sum(b.base_amount) as paid_amount\n\t\t\t\tfrom `tabSales Invoice` a, `tabSales Invoice Payment` b\n\t\t\t\twhere a.name = b.parent\n\t\t\t\tand a.docstatus = 1\n\t\t\t\tand a.name in ({invoice_list_names})\n\t\t\t\tgroup by a.owner, a.posting_date, mode_of_payment\n\t\t\t\tunion\n\t\t\t\tselect a.owner,a.posting_date,\n\t\t\t\tifnull(b.mode_of_payment, '') as mode_of_payment, sum(c.allocated_amount) as paid_amount\n\t\t\t\tfrom `tabSales Invoice` a, `tabPayment Entry` b,`tabPayment Entry Reference` c\n\t\t\t\twhere a.name = c.reference_name\n\t\t\t\tand b.name = c.parent\n\t\t\t\tand b.docstatus = 1\n\t\t\t\tand a.name in ({invoice_list_names})\n\t\t\t\tgroup by a.owner, a.posting_date, mode_of_payment\n\t\t\t\tunion\n\t\t\t\tselect a.owner, a.posting_date,\n\t\t\t\tifnull(a.voucher_type,'') as mode_of_payment, sum(b.credit)\n\t\t\t\tfrom `tabJournal Entry` a, `tabJournal Entry Account` b\n\t\t\t\twhere a.name = b.parent\n\t\t\t\tand a.docstatus = 1\n\t\t\t\tand b.reference_type = \"Sales Invoice\"\n\t\t\t\tand b.reference_name in ({invoice_list_names})\n\t\t\t\tgroup by a.owner, a.posting_date, mode_of_payment\n\t\t\t) t\n\t\t\tgroup by t.owner, t.posting_date, t.mode_of_payment\n\t\t\tselect a.owner, a.posting_date,\n\t\t\tifnull(b.mode_of_payment, '') as mode_of_payment, sum(a.base_change_amount) as change_amount\n\t\t\tfrom `tabSales Invoice` a, `tabSales Invoice Payment` b\n\t\t\twhere a.name = b.parent\n\t\t\tand a.name in ({invoice_list_names})\n\t\t\tand b.type = 'Cash'\n\t\t\tand a.base_change_amount > 0\n\t\t\tgroup by a.owner, a.posting_date, mode_of_payment", "language": "en", "n_whitespaces": 142, "n_words": 169, "vocab_size": 64 }

{ "docstring": "def adv_search_extension(q, include_extension_inputs, exclude_extension_inputs):\n for extension in include_extension_inputs:\n q = q.filter(db.Books.data.any(db.Data.format == extension))\n for extension in exclude_extension_inputs:\n q = q.filter(not_(db.Books.data.any(db.Data.format == extension)))\n return q\n\n", "language": "en", "n_whitespaces": 46, "n_words": 24, "vocab_size": 17 }

{ "docstring": "\n GIVEN:\n - API request to create a storage paths\n - Storage path format is incorrect\n WHEN:\n - API is called\n THEN:\n - Correct HTTP 400 response\n - No storage path is created\n ", "language": "en", "n_whitespaces": 116, "n_words": 32, "vocab_size": 23 }

{ "docstring": "Getting the content of files for template_field / template_ext.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "A decorator which automatically casts results['gt_bboxes'] to the\n destination box type.\n\n It commenly used in mmdet.datasets.transforms to make the transforms up-\n compatible with the np.ndarray type of results['gt_bboxes'].\n\n The speed of processing of np.ndarray and BaseBoxes data are the same:\n\n - np.ndarray: 0.0509 img/s\n - BaseBoxes: 0.0551 img/s\n\n Args:\n dst_box_type (str): Destination box type.\n ", "language": "en", "n_whitespaces": 85, "n_words": 54, "vocab_size": 43 }

{ "docstring": "\n Used when the exact number of bytes to read is unimportant.\n\n Return whatever chunk is conveniently returned from the iterator.\n Useful to avoid unnecessary bookkeeping if performance is an issue.\n ", "language": "en", "n_whitespaces": 59, "n_words": 30, "vocab_size": 26 }

{ "docstring": "\n Determine the utilization rate of power in the rack and return it as a percentage.\n ", "language": "en", "n_whitespaces": 30, "n_words": 15, "vocab_size": 14 }

{ "docstring": "Finds set of edges to k-edge-connect G.\n\n Adding edges from the augmentation to G make it impossible to disconnect G\n unless k or more edges are removed. This function uses the most efficient\n function available (depending on the value of k and if the problem is\n weighted or unweighted) to search for a minimum weight subset of available\n edges that k-edge-connects G. In general, finding a k-edge-augmentation is\n NP-hard, so solutions are not guaranteed to be minimal. Furthermore, a\n k-edge-augmentation may not exist.\n\n Parameters\n ----------\n G : NetworkX graph\n An undirected graph.\n\n k : integer\n Desired edge connectivity\n\n avail : dict or a set of 2 or 3 tuples\n The available edges that can be used in the augmentation.\n\n If unspecified, then all edges in the complement of G are available.\n Otherwise, each item is an available edge (with an optional weight).\n\n In the unweighted case, each item is an edge ``(u, v)``.\n\n In the weighted case, each item is a 3-tuple ``(u, v, d)`` or a dict\n with items ``(u, v): d``. The third item, ``d``, can be a dictionary\n or a real number. If ``d`` is a dictionary ``d[weight]``\n correspondings to the weight.\n\n weight : string\n key to use to find weights if ``avail`` is a set of 3-tuples where the\n third item in each tuple is a dictionary.\n\n partial : boolean\n If partial is True and no feasible k-edge-augmentation exists, then all\n a partial k-edge-augmentation is generated. Adding the edges in a\n partial augmentation to G, minimizes the number of k-edge-connected\n components and maximizes the edge connectivity between those\n components. For details, see :func:`partial_k_edge_augmentation`.\n\n Yields\n ------\n edge : tuple\n Edges that, once added to G, would cause G to become k-edge-connected.\n If partial is False, an error is raised if this is not possible.\n Otherwise, generated edges form a partial augmentation, which\n k-edge-connects any part of G where it is possible, and maximally\n connects the remaining parts.\n\n Raises\n ------\n NetworkXUnfeasible\n If partial is False and no k-edge-augmentation exists.\n\n NetworkXNotImplemented\n If the input graph is directed or a multigraph.\n\n ValueError:\n If k is less than 1\n\n Notes\n -----\n When k=1 this returns an optimal solution.\n\n When k=2 and ``avail`` is None, this returns an optimal solution.\n Otherwise when k=2, this returns a 2-approximation of the optimal solution.\n\n For k>3, this problem is NP-hard and this uses a randomized algorithm that\n produces a feasible solution, but provides no guarantees on the\n solution weight.\n\n Examples\n --------\n >>> # Unweighted cases\n >>> G = nx.path_graph((1, 2, 3, 4))\n >>> G.add_node(5)\n >>> sorted(nx.k_edge_augmentation(G, k=1))\n [(1, 5)]\n >>> sorted(nx.k_edge_augmentation(G, k=2))\n [(1, 5), (5, 4)]\n >>> sorted(nx.k_edge_augmentation(G, k=3))\n [(1, 4), (1, 5), (2, 5), (3, 5), (4, 5)]\n >>> complement = list(nx.k_edge_augmentation(G, k=5, partial=True))\n >>> G.add_edges_from(complement)\n >>> nx.edge_connectivity(G)\n 4\n\n >>> # Weighted cases\n >>> G = nx.path_graph((1, 2, 3, 4))\n >>> G.add_node(5)\n >>> # avail can be a tuple with a dict\n >>> avail = [(1, 5, {\"weight\": 11}), (2, 5, {\"weight\": 10})]\n >>> sorted(nx.k_edge_augmentation(G, k=1, avail=avail, weight=\"weight\"))\n [(2, 5)]\n >>> # or avail can be a 3-tuple with a real number\n >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 51)]\n >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail))\n [(1, 5), (2, 5), (4, 5)]\n >>> # or avail can be a dict\n >>> avail = {(1, 5): 11, (2, 5): 10, (4, 3): 1, (4, 5): 51}\n >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail))\n [(1, 5), (2, 5), (4, 5)]\n >>> # If augmentation is infeasible, then a partial solution can be found\n >>> avail = {(1, 5): 11}\n >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail, partial=True))\n [(1, 5)]\n ", "language": "en", "n_whitespaces": 971, "n_words": 592, "vocab_size": 262 }

{ "docstring": "\n part is a string of ipython text, comprised of at most one\n input, one output, comments, and blank lines. The block parser\n parses the text into a list of::\n\n blocks = [ (TOKEN0, data0), (TOKEN1, data1), ...]\n\n where TOKEN is one of [COMMENT | INPUT | OUTPUT ] and\n data is, depending on the type of token::\n\n COMMENT : the comment string\n\n INPUT: the (DECORATOR, INPUT_LINE, REST) where\n DECORATOR: the input decorator (or None)\n INPUT_LINE: the input as string (possibly multi-line)\n REST : any stdout generated by the input line (not OUTPUT)\n\n OUTPUT: the output string, possibly multi-line\n\n ", "language": "en", "n_whitespaces": 162, "n_words": 98, "vocab_size": 76 }

{ "docstring": "\n Update the direct sparsity for the target node. Here the direct sparsity\n means that the sparsity in the output tensor that caused by the sparsity\n in the input tensors/weight tensors.\n ", "language": "en", "n_whitespaces": 59, "n_words": 30, "vocab_size": 18 }

{ "docstring": "Read simple undirected graphs in graph6 format from path.\n\n Parameters\n ----------\n path : file or string\n File or filename to write.\n\n Returns\n -------\n G : Graph or list of Graphs\n If the file contains multiple lines then a list of graphs is returned\n\n Raises\n ------\n NetworkXError\n If the string is unable to be parsed in graph6 format\n\n Examples\n --------\n You can read a graph6 file by giving the path to the file::\n\n >>> import tempfile\n >>> with tempfile.NamedTemporaryFile(delete=False) as f:\n ... _ = f.write(b\">>graph6<<A_\\\\n\")\n ... _ = f.seek(0)\n ... G = nx.read_graph6(f.name)\n >>> list(G.edges())\n [(0, 1)]\n\n You can also read a graph6 file by giving an open file-like object::\n\n >>> import tempfile\n >>> with tempfile.NamedTemporaryFile() as f:\n ... _ = f.write(b\">>graph6<<A_\\\\n\")\n ... _ = f.seek(0)\n ... G = nx.read_graph6(f)\n >>> list(G.edges())\n [(0, 1)]\n\n See Also\n --------\n from_graph6_bytes, write_graph6\n\n References\n ----------\n .. [1] Graph6 specification\n <http://users.cecs.anu.edu.au/~bdm/data/formats.html>\n\n ", "language": "en", "n_whitespaces": 356, "n_words": 145, "vocab_size": 83 }

{ "docstring": "Given a path or URI, check for a ref and split it from the path if it is\n present, returning a tuple of the original input and the ref or None.\n\n :param AnyStr uri: The path or URI to split\n :returns: A 2-tuple of the path or URI and the ref\n :rtype: Tuple[AnyStr, Optional[AnyStr]]\n ", "language": "en", "n_whitespaces": 69, "n_words": 54, "vocab_size": 34 }

{ "docstring": "Mock an update to the sensor returning no duration_in_traffic.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Process the entity map and load any platforms or entities that need adding.\n\n This is idempotent and will be called at startup and when we detect metadata changes\n via the c# counter on the zeroconf record.\n ", "language": "en", "n_whitespaces": 65, "n_words": 36, "vocab_size": 32 }

{ "docstring": "Patch .app to save some space and make it signable.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Add border to the image\n\n :param image: The image to expand.\n :param border: Border width, in pixels.\n :param fill: Pixel fill value (a color value). Default is 0 (black).\n :return: An image.\n ", "language": "en", "n_whitespaces": 52, "n_words": 32, "vocab_size": 28 }

{ "docstring": "Utility function to get policy data from agent data and policy map function.\n\n It also keeps track of agent_id for each row so that we can retreive the agent\n level information after the forward pass.\n\n Returns:\n dict of module_id to module data\n ", "language": "en", "n_whitespaces": 61, "n_words": 42, "vocab_size": 35 }

{ "docstring": "\n Github token used to authenticate.\n You can set omit it if you have GITHUB_TOKEN env variable set\n Can be generated with:\n https://github.com/settings/tokens/new?description=Read%20Write%20isssues&scopes=repo", "language": "en", "n_whitespaces": 50, "n_words": 22, "vocab_size": 21 }

{ "docstring": "Delete a previously created ansible-test cgroup in the v1 systemd hierarchy.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Helper function to iterate over the leaves of a tree, i.e. a dict of that\n can contain dicts.\n\n The provided key is a tuple that will get prepended to the returned keys.\n\n Example:\n\n cache = TreeCache()\n cache[(1, 1)] = \"a\"\n cache[(1, 2)] = \"b\"\n cache[(2, 1)] = \"c\"\n\n tree_node = cache.get((1,))\n\n items = iterate_tree_cache_items((1,), tree_node)\n assert list(items) == [((1, 1), \"a\"), ((1, 2), \"b\")]\n\n Returns:\n A generator yielding key/value pairs.\n ", "language": "en", "n_whitespaces": 141, "n_words": 70, "vocab_size": 57 }

{ "docstring": "Deserializes a serialized metric class/function instance.\n\n Args:\n config: Metric configuration.\n custom_objects: Optional dictionary mapping names (strings) to custom\n objects (classes and functions) to be considered during deserialization.\n\n Returns:\n A Keras `Metric` instance or a metric function.\n ", "language": "en", "n_whitespaces": 55, "n_words": 36, "vocab_size": 33 }

{ "docstring": "Extract top K items from a matrix of scores for each user-item pair, optionally sort results per user.\n\n Args:\n scores (numpy.ndarray): Score matrix (users x items).\n top_k (int): Number of top items to recommend.\n sort_top_k (bool): Flag to sort top k results.\n\n Returns:\n numpy.ndarray, numpy.ndarray:\n - Indices into score matrix for each user's top items.\n - Scores corresponding to top items.\n\n ", "language": "en", "n_whitespaces": 112, "n_words": 61, "vocab_size": 45 }

{ "docstring": "Return a list of dict messages with the 'key: value' result\n\n <=== width ===>\n __key : 80.5%__\n | | | | |_ trailer\n | | | |_ self.stats[key]\n | | |_ separator\n | |_ key (if display_key is True)\n |_ header\n\n Instead of:\n msg = ' {:8}'.format('idle:')\n ret.append(self.curse_add_line(msg, optional=self.get_views(key='idle', option='optional')))\n msg = '{:5.1f}%'.format(self.stats['idle'])\n ret.append(self.curse_add_line(msg, optional=self.get_views(key='idle', option='optional')))\n\n Use:\n ret.extend(self.curse_add_stat('idle', width=15, header=' '))\n\n ", "language": "en", "n_whitespaces": 215, "n_words": 61, "vocab_size": 43 }

{ "docstring": "\n Classification loss (NLL) targets dicts must contain the key \"class_labels\" containing a tensor of dim\n [nb_target_boxes]\n ", "language": "en", "n_whitespaces": 38, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Extract aggregation function from groupby arguments.\n\n Parameters\n ----------\n key : callable or str\n Default aggregation function. If aggregation function is not specified\n via groupby arguments, then `key` function is used.\n **kwargs : dict\n GroupBy arguments that may contain aggregation function.\n\n Returns\n -------\n callable\n Aggregation function.\n\n Notes\n -----\n There are two ways of how groupby aggregation can be invoked:\n 1. Explicitly with query compiler method: `qc.groupby_sum()`.\n 2. By passing aggregation function as an argument: `qc.groupby_agg(\"sum\")`.\n Both are going to produce the same result, however in the first case actual aggregation\n function can be extracted from the method name, while for the second only from the method arguments.\n ", "language": "en", "n_whitespaces": 271, "n_words": 106, "vocab_size": 78 }

{ "docstring": "Raise errors in case of invalid argument values.\n\n Args:\n validation_split: float between 0 and 1, fraction of data to reserve for\n validation.\n subset: One of \"training\", \"validation\" or \"both\". Only used if `validation_split`\n is set.\n shuffle: Whether to shuffle the data. Either True or False.\n seed: random seed for shuffling and transformations.\n ", "language": "en", "n_whitespaces": 76, "n_words": 52, "vocab_size": 46 }

{ "docstring": "Get testing data after pipeline.\n\n Args:\n idx (int): Index of data.\n\n Returns:\n dict: Testing data after pipeline with new keys introduced by \\\n pipeline.\n ", "language": "en", "n_whitespaces": 82, "n_words": 24, "vocab_size": 21 }

{ "docstring": "Receives a Response. Returns a redirect URI or ``None``", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "Return type hints for an object.\n\n This is often the same as obj.__annotations__, but it handles\n forward references encoded as string literals, adds Optional[t] if a\n default value equal to None is set and recursively replaces all\n 'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'\n (unless 'include_extras=True').\n\n The argument may be a module, class, method, or function. The annotations\n are returned as a dictionary. For classes, annotations include also\n inherited members.\n\n TypeError is raised if the argument is not of a type that can contain\n annotations, and an empty dictionary is returned if no annotations are\n present.\n\n BEWARE -- the behavior of globalns and localns is counterintuitive\n (unless you are familiar with how eval() and exec() work). The\n search order is locals first, then globals.\n\n - If no dict arguments are passed, an attempt is made to use the\n globals from obj (or the respective module's globals for classes),\n and these are also used as the locals. If the object does not appear\n to have globals, an empty dictionary is used.\n\n - If one dict argument is passed, it is used for both globals and\n locals.\n\n - If two dict arguments are passed, they specify globals and\n locals, respectively.\n ", "language": "en", "n_whitespaces": 371, "n_words": 198, "vocab_size": 123 }

{ "docstring": "Return True if the channel supports color temperature.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Partially fit underlying estimators.\n\n Should be used when memory is inefficient to train all data.\n Chunks of data can be passed in several iteration.\n\n Parameters\n ----------\n X : (sparse) array-like of shape (n_samples, n_features)\n Data.\n\n y : (sparse) array-like of shape (n_samples,) or (n_samples, n_classes)\n Multi-class targets. An indicator matrix turns on multilabel\n classification.\n\n classes : array, shape (n_classes, )\n Classes across all calls to partial_fit.\n Can be obtained via `np.unique(y_all)`, where y_all is the\n target vector of the entire dataset.\n This argument is only required in the first call of partial_fit\n and can be omitted in the subsequent calls.\n\n Returns\n -------\n self : object\n Instance of partially fitted estimator.\n ", "language": "en", "n_whitespaces": 286, "n_words": 110, "vocab_size": 84 }

{ "docstring": " Check the passed in command line arguments for requested actions,\n\n For any requested actions, add the item to the actions list along with\n any relevant arguments and keyword arguments.\n\n Returns\n -------\n dict\n The name of the action to be performed as the key. Any action specific\n arguments and keyword arguments as the value.\n ", "language": "en", "n_whitespaces": 118, "n_words": 53, "vocab_size": 37 }

{ "docstring": "\n Purge old local and remote media according to the media retention rules\n defined in the homeserver config.\n ", "language": "en", "n_whitespaces": 39, "n_words": 17, "vocab_size": 15 }

{ "docstring": "\n Return the non-hashed URL in DEBUG mode.\n ", "language": "en", "n_whitespaces": 22, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\n Execute the parse expression with the given string.\n This is the main interface to the client code, once the complete\n expression has been built.\n\n Returns the parsed data as a :class:`ParseResults` object, which may be\n accessed as a list, or as a dict or object with attributes if the given parser\n includes results names.\n\n If you want the grammar to require that the entire input string be\n successfully parsed, then set ``parseAll`` to True (equivalent to ending\n the grammar with ``StringEnd()``).\n\n Note: ``parseString`` implicitly calls ``expandtabs()`` on the input string,\n in order to report proper column numbers in parse actions.\n If the input string contains tabs and\n the grammar uses parse actions that use the ``loc`` argument to index into the\n string being parsed, you can ensure you have a consistent view of the input\n string by:\n\n - calling ``parseWithTabs`` on your grammar before calling ``parseString``\n (see :class:`parseWithTabs`)\n - define your parse action using the full ``(s, loc, toks)`` signature, and\n reference the input string using the parse action's ``s`` argument\n - explictly expand the tabs in your input string before calling\n ``parseString``\n\n Example::\n\n Word('a').parseString('aaaaabaaa') # -> ['aaaaa']\n Word('a').parseString('aaaaabaaa', parseAll=True) # -> Exception: Expected end of text\n ", "language": "en", "n_whitespaces": 389, "n_words": 197, "vocab_size": 121 }

{ "docstring": "Log the actual version and print extra info if there is\n a conflict or if the actual version could not be imported.\n ", "language": "en", "n_whitespaces": 28, "n_words": 22, "vocab_size": 18 }

{ "docstring": "\n Test that an email AND Slack notification are sent with\n the expected values when an issue is resolved.\n ", "language": "en", "n_whitespaces": 40, "n_words": 18, "vocab_size": 17 }

{ "docstring": "Creates a generator to extract data from the queue.\n\n Skip the data if it is `None`.\n # Returns\n Generator yielding tuples `(inputs, targets)`\n or `(inputs, targets, sample_weights)`.\n ", "language": "en", "n_whitespaces": 74, "n_words": 27, "vocab_size": 24 }

{ "docstring": "\n Check each axes has identical lines\n\n Parameters\n ----------\n xp : matplotlib Axes object\n rs : matplotlib Axes object\n ", "language": "en", "n_whitespaces": 61, "n_words": 18, "vocab_size": 14 }

{ "docstring": "\n This generator returns all the parameters of the net except for\n the last classification layer. Note that for each batchnorm layer,\n requires_grad is set to False in deeplab_resnet.py, therefore this function does not return\n any batchnorm parameter\n ", "language": "en", "n_whitespaces": 53, "n_words": 37, "vocab_size": 33 }

{ "docstring": " Parses Apache CLI options from CentOS configuration file ", "language": "en", "n_whitespaces": 9, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Compute a maximum-weighted matching of G.\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 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 maximum 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\n Returns\n -------\n matching : set\n A maximal matching of the graph.\n\n Examples\n --------\n >>> G = nx.Graph()\n >>> edges = [(1, 2, 6), (1, 3, 2), (2, 3, 1), (2, 4, 7), (3, 5, 9), (4, 5, 3)]\n >>> G.add_weighted_edges_from(edges)\n >>> sorted(nx.max_weight_matching(G))\n [(2, 4), (5, 3)]\n\n Notes\n -----\n If G has edges with weight attributes the edge data are used as\n weight values else the weights are assumed to be 1.\n\n This function takes time O(number_of_nodes ** 3).\n\n If all edge weights are integers, the algorithm uses only integer\n computations. If floating point weights are used, the algorithm\n could return a slightly suboptimal matching due to numeric\n precision errors.\n\n This method is based on the \"blossom\" method for finding augmenting\n paths and the \"primal-dual\" method for finding a matching of maximum\n weight, both methods invented by Jack Edmonds [1]_.\n\n Bipartite graphs can also be matched using the functions present in\n :mod:`networkx.algorithms.bipartite.matching`.\n\n References\n ----------\n .. [1] \"Efficient Algorithms for Finding Maximum Matching in Graphs\",\n Zvi Galil, ACM Computing Surveys, 1986.\n ", "language": "en", "n_whitespaces": 429, "n_words": 274, "vocab_size": 173 }

{ "docstring": "Flags actions immutable to notify users when trying to change\n them.\n\n Can also be used with any tree-like structure containing either\n dictionaries, numpy arrays or already immutable objects per se.\n Note, however that `tree.map_structure()` will in general not\n include the shallow object containing all others and therefore\n immutability will hold only for all objects contained in it.\n Use `tree.traverse(fun, action, top_down=False)` to include\n also the containing object.\n\n Args:\n obj: The object to be made immutable.\n\n Returns:\n The immutable object.\n\n Examples:\n >>> import tree\n >>> import numpy as np\n >>> arr = np.arange(1,10)\n >>> d = dict(a = 1, b = (arr, arr))\n >>> tree.traverse(make_action_immutable, d, top_down=False)\n ", "language": "en", "n_whitespaces": 191, "n_words": 106, "vocab_size": 79 }

{ "docstring": "\n List all roles installed on the local system or a specific role\n ", "language": "en", "n_whitespaces": 27, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Check if an input value is a localizable type and return it\n formatted with the appropriate formatting string of the current locale.\n ", "language": "en", "n_whitespaces": 32, "n_words": 22, "vocab_size": 21 }

{ "docstring": "Return True if state conditions are met, return False if they are not.\n\n Returns None if the state is unavailable.\n ", "language": "en", "n_whitespaces": 34, "n_words": 20, "vocab_size": 16 }

{ "docstring": "Scott 1955; here, multi-pi.\n Equivalent to K from Siegel and Castellan (1988).\n\n ", "language": "en", "n_whitespaces": 26, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Tests that the target user calling `/logout/all` does *not* expire\n the token.\n ", "language": "en", "n_whitespaces": 26, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Creates a config for the diffusers based on the config of the LDM model.\n ", "language": "en", "n_whitespaces": 21, "n_words": 14, "vocab_size": 11 }

{ "docstring": "\n Subtract other from self in-place.\n\n ", "language": "en", "n_whitespaces": 20, "n_words": 5, "vocab_size": 5 }

{ "docstring": "Mixing in arguments required by head pods and runtimes into the given parser.\n :param parser: the parser instance to which we add arguments\n ", "language": "en", "n_whitespaces": 29, "n_words": 23, "vocab_size": 21 }

{ "docstring": "\n\t\t\tSELECT\n\t\t\t\t(CASE WHEN reference_no=%(reference_no)s THEN 1 ELSE 0 END\n\t\t\t\t+ CASE WHEN (party_type = %(party_type)s AND party = %(party)s ) THEN 1 ELSE 0 END\n\t\t\t\t+ 1 ) AS rank,\n\t\t\t\t'Payment Entry' as doctype,\n\t\t\t\tname,\n\t\t\t\tpaid_amount,\n\t\t\t\treference_no,\n\t\t\t\treference_date,\n\t\t\t\tparty,\n\t\t\t\tparty_type,\n\t\t\t\tposting_date,\n\t\t\t\t{currency_field}\n\t\t\tFROM\n\t\t\t\t`tabPayment Entry`\n\t\t\tWHERE\n\t\t\t\tpaid_amount {amount_condition} %(amount)s\n\t\t\t\tAND docstatus = 1\n\t\t\t\tAND payment_type IN (%(payment_type)s, 'Internal Transfer')\n\t\t\t\tAND ifnull(clearance_date, '') = \"\"\n\t\t\t\tAND {account_from_to} = %(bank_account)s\n\t\t\t\tAND reference_date >= '{from_reference_date}'\n\t\t\t\tAND reference_date <= '{to_reference_date}'\t \n\t\t\t\t\n\t\t\t\n\t\t\tSELECT\n\t\t\t\t(CASE WHEN reference_no=%(reference_no)s THEN 1 ELSE 0 END\n\t\t\t\t+ CASE WHEN (party_type = %(party_type)s AND party = %(party)s ) THEN 1 ELSE 0 END\n\t\t\t\t+ 1 ) AS rank,\n\t\t\t\t'Payment Entry' as doctype,\n\t\t\t\tname,\n\t\t\t\tpaid_amount,\n\t\t\t\treference_no,\n\t\t\t\treference_date,\n\t\t\t\tparty,\n\t\t\t\tparty_type,\n\t\t\t\tposting_date,\n\t\t\t\t{currency_field}\n\t\t\tFROM\n\t\t\t\t`tabPayment Entry`\n\t\t\tWHERE\n\t\t\t\tpaid_amount {amount_condition} %(amount)s\n\t\t\t\tAND docstatus = 1\n\t\t\t\tAND payment_type IN (%(payment_type)s, 'Internal Transfer')\n\t\t\t\tAND ifnull(clearance_date, '') = \"\"\n\t\t\t\tAND {account_from_to} = %(bank_account)s\n\t\t\t\tAND posting_date >= '{from_date}'\n\t\t\t\tAND posting_date <= '{to_date}'\t \n\t\t\t\t\n\t\t\t", "language": "en", "n_whitespaces": 110, "n_words": 152, "vocab_size": 58 }

{ "docstring": "Set the parser for the cli client\n\n :param parser: an optional existing parser to build upon\n :return: the parser\n ", "language": "en", "n_whitespaces": 28, "n_words": 19, "vocab_size": 15 }

{ "docstring": "select dn.project, sum(dn_item.base_net_amount) as amount\n\t\tfrom `tabDelivery Note` dn, `tabDelivery Note Item` dn_item\n\t\twhere dn.name = dn_item.parent and dn.docstatus = 1 and ifnull(dn.project, '') != ''\n\t\tgroup by dn.projectselect si.project, sum(si_item.base_net_amount) as amount\n\t\tfrom `tabSales Invoice` si, `tabSales Invoice Item` si_item\n\t\twhere si.name = si_item.parent and si.docstatus = 1 and si.update_stock = 1\n\t\tand si.is_pos = 1 and ifnull(si.project, '') != ''\n\t\tgroup by si.project", "language": "en", "n_whitespaces": 57, "n_words": 65, "vocab_size": 40 }

{ "docstring": "\n Set the vertical or horizontal location of the axes in\n parent-normalized coordinates.\n\n Parameters\n ----------\n location : {'top', 'bottom', 'left', 'right'} or float\n The position to put the secondary axis. Strings can be 'top' or\n 'bottom' for orientation='x' and 'right' or 'left' for\n orientation='y'. A float indicates the relative position on the\n parent axes to put the new axes, 0.0 being the bottom (or left)\n and 1.0 being the top (or right).\n ", "language": "en", "n_whitespaces": 170, "n_words": 71, "vocab_size": 51 }

{ "docstring": "\n every Flow created inside JinaD lives inside a container. It is important to know the\n list of ports to be published with localhost before actually starting the container.\n\n 1. `load` the flow yaml here.\n - yaml is stored in `workspace` directory, so we'll `cd` there\n - yaml might include env vars. so we'll set them (passed via query params)\n 2. `build` the Flow so that `gateway` gets added.\n - get the list of ports to be published (port_expose, port_in, port_out, port_ctrl)\n - ports need to be published for gateway & executors that are not `ContainerRuntime` or `JinadRuntime` based\n - Deployment level args for ports are enough, as we don't need to publish Pod ports\n 3. `save` the Flow config.\n - saves port configs of all `executors` into the new yaml.\n - set `JINA_FULL_CLI` envvar, so that `gateway` args are also added.\n - save the config into a new file.\n 4. pass this new file as filename to `partial-daemon` to start the Flow\n ", "language": "en", "n_whitespaces": 300, "n_words": 162, "vocab_size": 103 }

{ "docstring": "Backward maximum matching\n\n Args:\n content (str): string to be searched\n Returns:\n List[Tuple]: list of maximum matching words, each element represents \n the starting and ending position of the matching string.\n ", "language": "en", "n_whitespaces": 88, "n_words": 29, "vocab_size": 24 }

{ "docstring": "Send GSTIN reminder to one party (called from Customer, Supplier form)", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Serialize a list of TabHistoryItems to a data stream.\n\n Args:\n items: An iterable of TabHistoryItems.\n\n Return:\n A (stream, data, user_data) tuple.\n stream: The reset QDataStream.\n data: The QByteArray with the raw data.\n cur_user_data: The user data for the current item or None.\n\n Warning:\n If 'data' goes out of scope, reading from 'stream' will result in a\n segfault!\n ", "language": "en", "n_whitespaces": 130, "n_words": 57, "vocab_size": 49 }

{ "docstring": "\n Ensure that only valid query parameters are included in the URL.\n ", "language": "en", "n_whitespaces": 26, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n Use the request_hook method for our specific style of Jira to\n add authentication data and transform parameters.\n ", "language": "en", "n_whitespaces": 39, "n_words": 17, "vocab_size": 17 }

{ "docstring": "\n Disassociate the Cable from the termination object.\n ", "language": "en", "n_whitespaces": 14, "n_words": 7, "vocab_size": 6 }

{ "docstring": "Calculate hash value of packages importable for a module of this name.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 11 }

{ "docstring": " Compile the individual session statistics and calculate the total.\n\n Format the stats for display\n\n Returns\n -------\n list\n A list of summary statistics dictionaries containing the Session ID, start time, end\n time, elapsed time, rate, batch size and number of iterations for each session id\n within the loaded data as well as the totals.\n ", "language": "en", "n_whitespaces": 122, "n_words": 53, "vocab_size": 39 }

{ "docstring": "\n Zero out the parameters of a module and return it.\n ", "language": "en", "n_whitespaces": 17, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Normalize drive in path so they stay consistent.\n\n This currently only affects local drives on Windows, which can be\n identified with either upper or lower cased drive names. The case is\n always converted to uppercase because it seems to be preferred.\n\n See: <https://github.com/pypa/pipenv/issues/1218>\n ", "language": "en", "n_whitespaces": 58, "n_words": 43, "vocab_size": 40 }

{ "docstring": "Check models defined in module are tested in test_file.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "\n With partitioning settings, the SlicingRouter should route to the correct topic\n based on the org_id header.\n ", "language": "en", "n_whitespaces": 26, "n_words": 16, "vocab_size": 14 }

{ "docstring": "Get the immediate tasks on which this task depends\n\n Examples\n --------\n >>> inc = lambda x: x + 1\n >>> add = lambda x, y: x + y\n >>> dsk = {'x': 1,\n ... 'y': (inc, 'x'),\n ... 'z': (add, 'x', 'y'),\n ... 'w': (inc, 'z'),\n ... 'a': (add, (inc, 'x'), 1)}\n\n >>> get_dependencies(dsk, 'x')\n set()\n\n >>> get_dependencies(dsk, 'y')\n {'x'}\n\n >>> get_dependencies(dsk, 'z') # doctest: +SKIP\n {'x', 'y'}\n\n >>> get_dependencies(dsk, 'w') # Only direct dependencies\n {'z'}\n\n >>> get_dependencies(dsk, 'a') # Ignore non-keys\n {'x'}\n\n >>> get_dependencies(dsk, task=(inc, 'x')) # provide tasks directly\n {'x'}\n ", "language": "en", "n_whitespaces": 190, "n_words": 92, "vocab_size": 61 }

{ "docstring": "Initiates a workflow by creating an instance of ``WorkflowState``", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Clean up current location and download the url repository\n (and vcs infos) into location\n\n :param url: the repository URL starting with a vcs prefix.\n ", "language": "en", "n_whitespaces": 53, "n_words": 24, "vocab_size": 20 }

{ "docstring": "Mutual Information between two clusterings.\n\n The Mutual Information is a measure of the similarity between two labels\n of the same data. Where :math:`|U_i|` is the number of the samples\n in cluster :math:`U_i` and :math:`|V_j|` is the number of the\n samples in cluster :math:`V_j`, the Mutual Information\n between clusterings :math:`U` and :math:`V` is given as:\n\n .. math::\n\n MI(U,V)=\\\\sum_{i=1}^{|U|} \\\\sum_{j=1}^{|V|} \\\\frac{|U_i\\\\cap V_j|}{N}\n \\\\log\\\\frac{N|U_i \\\\cap V_j|}{|U_i||V_j|}\n\n This metric is independent of the absolute values of the labels:\n a permutation of the class or cluster label values won't change the\n score value in any way.\n\n This metric is furthermore symmetric: switching :math:`U` (i.e\n ``label_true``) with :math:`V` (i.e. ``label_pred``) will return the\n same score value. This can be useful to measure the agreement of two\n independent label assignments strategies on the same dataset when the\n real ground truth is not known.\n\n Read more in the :ref:`User Guide <mutual_info_score>`.\n\n Parameters\n ----------\n labels_true : array-like of shape (n_samples,), dtype=integral\n A clustering of the data into disjoint subsets, called :math:`U` in\n the above formula.\n\n labels_pred : array-like of shape (n_samples,), dtype=integral\n A clustering of the data into disjoint subsets, called :math:`V` in\n the above formula.\n\n contingency : {array-like, sparse matrix} of shape \\\n (n_classes_true, n_classes_pred), default=None\n A contingency matrix given by the :func:`contingency_matrix` function.\n If value is ``None``, it will be computed, otherwise the given value is\n used, with ``labels_true`` and ``labels_pred`` ignored.\n\n Returns\n -------\n mi : float\n Mutual information, a non-negative value, measured in nats using the\n natural logarithm.\n\n See Also\n --------\n adjusted_mutual_info_score : Adjusted against chance Mutual Information.\n normalized_mutual_info_score : Normalized Mutual Information.\n\n Notes\n -----\n The logarithm used is the natural logarithm (base-e).\n ", "language": "en", "n_whitespaces": 446, "n_words": 267, "vocab_size": 152 }

{ "docstring": "Set the state of this optimizer object.name: String. The name to use\n for momentum accumulator weights created by\n the optimizer.\n weight_decay: Float, defaults to None. If set, weight decay is applied.\n clipnorm: Float. If set, the gradient of each weight is individually\n clipped so that its norm is no higher than this value.\n clipvalue: Float. If set, the gradient of each weight is clipped to be no\n higher than this value.\n global_clipnorm: Float. If set, the gradient of all weights is clipped so\n that their global norm is no higher than this value.\n use_ema: Boolean, defaults to False. If True, exponential moving average\n (EMA) is applied. EMA consists of computing an exponential moving\n average of the weights of the model (as the weight values change after\n each training batch), and periodically overwriting the weights with\n their moving average.\n ema_momentum: Float, defaults to 0.99. Only used if `use_ema=True`. This is # noqa: E501\n the momentum to use when computing the EMA of the model's weights:\n `new_average = ema_momentum * old_average + (1 - ema_momentum) *\n current_variable_value`.\n ema_overwrite_frequency: Int or None, defaults to None. Only used if\n `use_ema=True`. Every `ema_overwrite_frequency` steps of iterations, we\n overwrite the model variable by its moving average. If None, the optimizer # noqa: E501\n does not overwrite model variables in the middle of training, and you\n need to explicitly overwrite the variables at the end of training\n by calling `optimizer.finalize_variable_values()` (which updates the model # noqa: E501\n variables in-place). When using the built-in `fit()` training loop, this\n happens automatically after the last epoch, and you don't need to do\n anything.\n jit_compile: Boolean, defaults to True. If True, the optimizer will use XLA # noqa: E501\n compilation. If no GPU device is found, this flag will be ignored.\n **kwargs: keyword arguments only used for backward compatibility.", "language": "en", "n_whitespaces": 494, "n_words": 298, "vocab_size": 151 }

{ "docstring": "\n Tests whether the number of keys in the metrics implementation of\n sessions data is the same as in the sessions implementation.\n\n Runs twice. Firstly, against sessions implementation to populate the\n cache. Then, against the metrics implementation, and compares with\n cached results.\n ", "language": "en", "n_whitespaces": 84, "n_words": 41, "vocab_size": 29 }

{ "docstring": "\n Create a schedule with a learning rate that decreases linearly from the initial lr set in the optimizer to 0, after\n a warmup period during which it increases linearly from 0 to the initial lr set in the optimizer.\n\n Args:\n optimizer ([`~torch.optim.Optimizer`]):\n The optimizer for which to schedule the learning rate.\n num_warmup_steps (`int`):\n The number of steps for the warmup phase.\n num_training_steps (`int`):\n The total number of training steps.\n last_epoch (`int`, *optional*, defaults to -1):\n The index of the last epoch when resuming training.\n\n Return:\n `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.\n ", "language": "en", "n_whitespaces": 185, "n_words": 90, "vocab_size": 57 }

{ "docstring": "\n exclude: set\n new: TensExpr\n\n If ``new`` has any dummy indices that are in ``exclude``, return a version\n of new with those indices replaced. If no replacements are needed,\n return None\n\n \n ``self_args_free`` is to be passed to ``_IndexStructure._get_generator_for_dummy_indices()``.\n Since the latter does not use the index position for anything, we just\n set it as ``None`` here.\n ", "language": "en", "n_whitespaces": 127, "n_words": 55, "vocab_size": 48 }

{ "docstring": "\n Either for parsing or building, we store the client_random\n along with the raw string representing this handshake message.\n ", "language": "en", "n_whitespaces": 40, "n_words": 18, "vocab_size": 17 }

{ "docstring": "\n This method reshapes the tensor back to the batch size.\n\n Args:\n batch: batch being processed in this iteration.\n tensor: vector (shape: b' X 1), where b' <= b.\n indices: indices of (either classification or generation) exs for which the loss was computed.\n\n Returns:\n reshaped tensor of shape: b X 1.\n ", "language": "en", "n_whitespaces": 123, "n_words": 50, "vocab_size": 43 }

{ "docstring": "Parse a sequence of RFC 2822 phrases.\n\n A phrase is a sequence of words, which are in turn either RFC 2822\n atoms or quoted-strings. Phrases are canonicalized by squeezing all\n runs of continuous whitespace into one space.\n ", "language": "en", "n_whitespaces": 66, "n_words": 37, "vocab_size": 30 }

{ "docstring": "Test that as users cannot login with wrong as token", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 9 }

{ "docstring": "Python package \"{colored(missing_module, attrs='bold')}\" is not installed, {req_msg}.\n You are trying to use a feature not enabled by your current Jina installation.", "language": "en", "n_whitespaces": 40, "n_words": 22, "vocab_size": 21 }

{ "docstring": "Mock the Server's AppSession import. We don't want\n actual sessions to be instantiated, or scripts to be run.\n ", "language": "en", "n_whitespaces": 32, "n_words": 18, "vocab_size": 16 }

{ "docstring": "\n\t\tselect distinct so.name, so.transaction_date, so.customer, so.base_grand_total\n\t\tfrom `tabSales Order` so, `tabSales Order Item` so_item\n\t\twhere so_item.parent = so.name\n\t\t\tand so.docstatus = 1 and so.status not in (\"Stopped\", \"Closed\")\n\t\t\tand so.company = %(company)s\n\t\t\tand so_item.qty > so_item.work_order_qty {so_filter} {item_filter}\n\t\t\tand (exists (select name from `tabBOM` bom where {bom_item}\n\t\t\t\t\tand bom.is_active = 1)\n\t\t\t\tor exists (select name from `tabPacked Item` pi\n\t\t\t\t\twhere pi.parent = so.name and pi.parent_item = so_item.item_code\n\t\t\t\t\t\tand exists (select name from `tabBOM` bom where bom.item=pi.item_code\n\t\t\t\t\t\t\tand bom.is_active = 1)))\n\t\t", "language": "en", "n_whitespaces": 68, "n_words": 80, "vocab_size": 49 }

{ "docstring": "Creates examples for the training, dev and test sets.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Internal helper for wait().\n\n The fs argument must be a collection of Futures.\n ", "language": "en", "n_whitespaces": 19, "n_words": 13, "vocab_size": 13 }

{ "docstring": " Read the timestamps from the TensorBoard logs.\n\n As loss timestamps are slightly different for each loss, we collect the timestamp from the\n `batch_loss` key.\n\n Parameters\n ----------\n session_id: int, optional\n The Session ID to return the timestamps for. Set to ``None`` to return all session\n timestamps. Default ``None``\n\n Returns\n -------\n dict\n The session id(s) as key with list of timestamps per step as value\n ", "language": "en", "n_whitespaces": 160, "n_words": 63, "vocab_size": 48 }

{ "docstring": "\n Custom pk doesn't affect related_name based lookups\n ", "language": "en", "n_whitespaces": 22, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Draw bounding boxes on the axes.\n\n Args:\n ax (matplotlib.Axes): The input axes.\n bboxes (ndarray): The input bounding boxes with the shape\n of (n, 4).\n color (list[tuple] | matplotlib.color): the colors for each\n bounding boxes.\n alpha (float): Transparency of bounding boxes. Default: 0.8.\n thickness (int): Thickness of lines. Default: 2.\n\n Returns:\n matplotlib.Axes: The result axes.\n ", "language": "en", "n_whitespaces": 127, "n_words": 54, "vocab_size": 39 }

{ "docstring": "\n Convert the target in COCO format into the format expected by DETR.\n ", "language": "en", "n_whitespaces": 27, "n_words": 12, "vocab_size": 10 }

{ "docstring": "A more or less secure way to execute system commands\n\n Multiple command should be separated with a &&\n\n :return: the result of the commands\n ", "language": "en", "n_whitespaces": 33, "n_words": 24, "vocab_size": 22 }

{ "docstring": "\n Get a single value for a row/column label pair.\n ", "language": "en", "n_whitespaces": 24, "n_words": 9, "vocab_size": 8 }

{ "docstring": "\n Update all elements in the current QuerySet, setting all the given\n fields to the appropriate values.\n ", "language": "en", "n_whitespaces": 38, "n_words": 16, "vocab_size": 13 }

{ "docstring": " Test whether the given image is a faceswap extracted face and contains identity\n information. If so, return the identity embedding\n\n Parameters\n ----------\n filename: str\n Full path to the image file to load\n\n Returns\n -------\n :class:`numpy.ndarray`\n The identity embeddings, if they can be obtained from the image header, otherwise an\n empty array\n bool\n ``True`` if the image is a faceswap extracted image otherwise ``False``\n ", "language": "en", "n_whitespaces": 171, "n_words": 63, "vocab_size": 46 }