Datasets:

semeru

/

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

like 0

Follow

Semeru Lab 7

{ "docstring": "Creates a dataframe for all functions in 'models' and 'views'.\n\n Returns:\n ----------\n pd.DataFrame\n Information for all view and model functions\n ", "language": "en", "n_whitespaces": 39, "n_words": 20, "vocab_size": 16 }

{ "docstring": "\n Timer designed to track the cumulative time spent training the full pairlist in\n FreqAI.\n ", "language": "en", "n_whitespaces": 36, "n_words": 14, "vocab_size": 13 }

{ "docstring": "Returns the caching device for the RNN variable.\n\n This is useful for distributed training, when variable is not located as same\n device as the training worker. By enabling the device cache, this allows\n worker to read the variable once and cache locally, rather than read it every\n time step from remote when it is needed.\n\n Note that this is assuming the variable that cell needs for each time step is\n having the same value in the forward path, and only gets updated in the\n backprop. It is true for all the default cells (SimpleRNN, GRU, LSTM). If the\n cell body relies on any variable that gets updated every time step, then\n caching device will cause it to read the stall value.\n\n Args:\n rnn_cell: the rnn cell instance.\n ", "language": "en", "n_whitespaces": 141, "n_words": 127, "vocab_size": 79 }

{ "docstring": "\n Get a list with all of the tabels in TDEngine\n ", "language": "en", "n_whitespaces": 25, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Return the current AnsibleCoreCI instance, loading it if not already loaded.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n Sorted the bbox in the same line(group)\n compare coord 'x' value, where 'y' value is closed in the same group.\n :param g: index in the same group\n :param bg: bbox in the same group\n :return:\n ", "language": "en", "n_whitespaces": 54, "n_words": 35, "vocab_size": 22 }

{ "docstring": "Get closed exchanges.\n\n Parameters\n ----------\n\n Returns\n -------\n pd.DataFrame\n Currently closed exchanges\n ", "language": "en", "n_whitespaces": 36, "n_words": 11, "vocab_size": 10 }

{ "docstring": "\n Generate hidden states mask, and optionally an attention mask.\n ", "language": "en", "n_whitespaces": 16, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Most likely you are running a development (non-packaged) copy of\n Wagtail and have not built the static assets -\n see https://docs.wagtail.org/en/latest/contributing/developing.html\n\n File not found: %s\n ", "language": "en", "n_whitespaces": 77, "n_words": 25, "vocab_size": 24 }

{ "docstring": "Scan for a specific device using identifier as filter.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Context management method for databases.\n ", "language": "en", "n_whitespaces": 20, "n_words": 5, "vocab_size": 5 }

{ "docstring": " The Hermitian matrix `H` is split into two matrices `H_minus`\n `H_plus`, respectively sharing its eigenspaces beneath and above\n its `split_point`th eigenvalue.\n\n Returns, in addition, `V_minus` and `V_plus`, isometries such that\n `Hi = Vi.conj().T @ H @ Vi`. If `V0` is not None, `V0 @ Vi` are\n returned instead; this allows the overall isometries mapping from\n an initial input matrix to progressively smaller blocks to be formed.\n\n Args:\n H: The Hermitian matrix to split.\n split_point: The eigenvalue to split along.\n V0: Matrix of isometries to be updated.\n Returns:\n H_minus: A Hermitian matrix sharing the eigenvalues of `H` beneath\n `split_point`.\n V_minus: An isometry from the input space of `V0` to `H_minus`.\n H_plus: A Hermitian matrix sharing the eigenvalues of `H` above\n `split_point`.\n V_plus: An isometry from the input space of `V0` to `H_plus`.\n rank: The dynamic size of the m subblock.\n The main work loop performing the symmetric eigendecomposition of H.\n# Each step recursively computes a projector into the space of eigenvalues\n# above jnp.mean(jnp.diag(H)). The result of the projections into and out of\n# that space, along with the isometries accomplishing these, are then computed.\n# This is performed recursively until the projections have size 1, and thus\n# store an eigenvalue of the original input; the corresponding isometry is\n# the related eigenvector. The results are then composed.\n#\n# Args:\n# H: The Hermitian input.\n# V: Stores the isometries projecting H into its subspaces.\n# precision: :class:`~jax.lax.Precision` object specifying the matmul precision.\n#\n# Returns:\n# H, V: The result of the projection.\n# ", "language": "en", "n_whitespaces": 321, "n_words": 257, "vocab_size": 138 }

{ "docstring": "\n How to join segments of the line if it `~Line2D.is_dashed`.\n\n The default joinstyle is :rc:`lines.dash_joinstyle`.\n\n Parameters\n ----------\n s : `.JoinStyle` or %(JoinStyle)s\n ", "language": "en", "n_whitespaces": 65, "n_words": 22, "vocab_size": 22 }

{ "docstring": "Set the OMP_NUM_THREADS to default to num cpus assigned to the worker\n\n This function sets the environment variable OMP_NUM_THREADS for the worker,\n if the env is not previously set and it's running in worker (WORKER_MODE).\n\n Returns True if OMP_NUM_THREADS is set in this function.\n\n ", "language": "en", "n_whitespaces": 56, "n_words": 44, "vocab_size": 31 }

{ "docstring": "\n Give the groups who currently manage all collections permission to manage root collections\n ", "language": "en", "n_whitespaces": 20, "n_words": 13, "vocab_size": 11 }

{ "docstring": "Tests that an event doesn't get expired if there is neither a default retention\n policy nor a policy specific to the room.\n ", "language": "en", "n_whitespaces": 36, "n_words": 22, "vocab_size": 20 }

{ "docstring": "\n Create a DagBag with DAGs looking like this. The dotted lines represent external dependencies\n set up using ExternalTaskMarker and ExternalTaskSensor.\n\n dag_0: task_a_0 >> task_b_0\n |\n |\n dag_1: ---> task_a_1 >> task_b_1\n |\n |\n dag_2: ---> task_a_2 >> task_b_2\n |\n |\n dag_3: ---> task_a_3 >> task_b_3\n ", "language": "en", "n_whitespaces": 480, "n_words": 45, "vocab_size": 35 }

{ "docstring": "Retrieve the object by deserializing the config dict.\n\n The config dict is a Python dictionary that consists of a set of key-value\n pairs, and represents a Keras object, such as an `Optimizer`, `Layer`,\n `Metrics`, etc. The saving and loading library uses the following keys to\n record information of a Keras object:\n\n - `class_name`: String. This is the name of the class,\n as exactly defined in the source\n code, such as \"LossesContainer\".\n - `config`: Dict. Library-defined or user-defined key-value pairs that store\n the configuration of the object, as obtained by `object.get_config()`.\n - `module`: String. The path of the python module, such as\n \"keras.engine.compile_utils\". Built-in Keras classes\n expect to have prefix `keras`.\n - `registered_name`: String. The key the class is registered under via\n `keras.utils.register_keras_serializable(package, name)` API. The key has\n the format of '{package}>{name}', where `package` and `name` are the\n arguments passed to `register_keras_serializable()`. If `name` is not\n provided, it defaults to the class name. If `registered_name` successfully\n resolves to a class (that was registered), the `class_name` and `config`\n values in the dict will not be used. `registered_name` is only used for\n non-built-in classes.\n\n For example, the following dictionary represents the built-in Adam optimizer\n with the relevant config:\n\n ```python\n dict_structure = {\n \"class_name\": \"Adam\",\n \"config\": {\n \"amsgrad\": false,\n \"beta_1\": 0.8999999761581421,\n \"beta_2\": 0.9990000128746033,\n \"decay\": 0.0,\n \"epsilon\": 1e-07,\n \"learning_rate\": 0.0010000000474974513,\n \"name\": \"Adam\"\n },\n \"module\": \"keras.optimizers\",\n \"registered_name\": None\n }\n # Returns an `Adam` instance identical to the original one.\n deserialize_keras_object(dict_structure)\n ```\n\n If the class does not have an exported Keras namespace, the library tracks\n it by its `module` and `class_name`. For example:\n\n ```python\n dict_structure = {\n \"class_name\": \"LossesContainer\",\n \"config\": {\n \"losses\": [...],\n \"total_loss_mean\": {...},\n },\n \"module\": \"keras.engine.compile_utils\",\n \"registered_name\": \"LossesContainer\"\n }\n\n # Returns a `LossesContainer` instance identical to the original one.\n deserialize_keras_object(dict_structure)\n ```\n\n And the following dictionary represents a user-customized `MeanSquaredError`\n loss:\n\n ```python", "language": "en", "n_whitespaces": 591, "n_words": 296, "vocab_size": 179 }

{ "docstring": "\n Build a frame from an Arrow table.\n\n Parameters\n ----------\n at : pyarrow.Table\n Source table.\n index_cols : list of str, optional\n List of index columns in the source table which\n are ignored in transformation.\n index : pandas.Index, optional\n An index to be used by the new frame. Should present\n if `index_cols` is not None.\n columns : Index or array-like, optional\n Column labels to use for resulting frame.\n\n Returns\n -------\n HdkOnNativeDataframe\n The new frame.\n ", "language": "en", "n_whitespaces": 227, "n_words": 72, "vocab_size": 56 }

{ "docstring": "Tests that the server configuration can override the policy for a room when\n running the purge jobs.\n ", "language": "en", "n_whitespaces": 31, "n_words": 17, "vocab_size": 15 }

{ "docstring": "\n Raise an exception if the response contains an HTTPStatusError.\n\n The `PrefectHTTPStatusError` contains useful additional information that\n is not contained in the `HTTPStatusError`.\n ", "language": "en", "n_whitespaces": 51, "n_words": 22, "vocab_size": 19 }

{ "docstring": "Trainable crashes with fail_fast flag and the original crash message\n should bubble up.", "language": "en", "n_whitespaces": 19, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Check the type of object passed to query relations.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Find shortest weighted path lengths in G from a source node.\n\n Compute the shortest path length between source and all other\n reachable nodes for a weighted graph.\n\n Parameters\n ----------\n G : NetworkX graph\n\n source : node label\n Starting node for path\n\n cutoff : integer or float, optional\n Length (sum of edge weights) at which the search is stopped.\n If cutoff is provided, only return paths with summed weight <= cutoff.\n\n weight : string or function\n If this is a string, then edge weights will be accessed via the\n edge attribute with this key (that is, the weight of the edge\n joining `u` to `v` will be ``G.edges[u, v][weight]``). If no\n such edge attribute exists, the weight of the edge is assumed to\n be one.\n\n If this is a function, the weight of an edge is the value\n returned by the function. The function must accept exactly three\n positional arguments: the two endpoints of an edge and the\n dictionary of edge attributes for that edge. The function must\n return a number or None to indicate a hidden edge.\n\n Returns\n -------\n length : dict\n Dict keyed by node to shortest path length from source.\n\n Raises\n ------\n NodeNotFound\n If `source` is not in `G`.\n\n Examples\n --------\n >>> G = nx.path_graph(5)\n >>> length = nx.single_source_dijkstra_path_length(G, 0)\n >>> length[4]\n 4\n >>> for node in [0, 1, 2, 3, 4]:\n ... print(f\"{node}: {length[node]}\")\n 0: 0\n 1: 1\n 2: 2\n 3: 3\n 4: 4\n\n Notes\n -----\n Edge weight attributes must be numerical.\n Distances are calculated as sums of weighted edges traversed.\n\n The weight function can be used to hide edges by returning None.\n So ``weight = lambda u, v, d: 1 if d['color']==\"red\" else None``\n will find the shortest red path.\n\n See Also\n --------\n single_source_dijkstra, single_source_bellman_ford_path_length\n\n ", "language": "en", "n_whitespaces": 512, "n_words": 289, "vocab_size": 174 }

{ "docstring": "Deploys a faulty config file and checks its status.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Generate a style string from the GraphicsContext and rgbFace.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Private utility to retrieves an attribute (e.g. inputs) from a node.\n\n This is used to implement the methods:\n - get_input_shape_at\n - get_output_shape_at\n - get_input_at\n etc...\n\n Args:\n node_index: Integer index of the node from which\n to retrieve the attribute.\n attr: Exact node attribute name.\n attr_name: Human-readable attribute name, for error messages.\n\n Returns:\n The layer's attribute `attr` at the node of index `node_index`.\n\n Raises:\n RuntimeError: If the layer has no inbound nodes, or if called in Eager\n mode.\n ValueError: If the index provided does not match any node.\n ", "language": "en", "n_whitespaces": 257, "n_words": 86, "vocab_size": 66 }

{ "docstring": "\n Return True if the file_path is current for this zip_path\n ", "language": "en", "n_whitespaces": 25, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Return mapped nodes that depend on the current task the expansion.\n\n For now, this walks the entire DAG to find mapped nodes that has this\n current task as an upstream. We cannot use ``downstream_list`` since it\n only contains operators, not task groups. In the future, we should\n provide a way to record an DAG node's all downstream nodes instead.\n ", "language": "en", "n_whitespaces": 94, "n_words": 59, "vocab_size": 45 }

{ "docstring": "Fixture for the present traits of the device under test.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 9 }

{ "docstring": "Retrieve the corresponding layout by the string key.\n\n When there isn't an exact match, all the existing keys in the layout map\n will be treated as a regex and map against the input key again. The first\n match will be returned, based on the key insertion order. Return None if\n there isn't any match found.\n\n Args:\n key: the string key as the query for the layout.\n\n Returns:\n Corresponding layout based on the query.\n ", "language": "en", "n_whitespaces": 140, "n_words": 73, "vocab_size": 50 }

{ "docstring": "Load and return the diabetes dataset (regression).\n\n ============== ==================\n Samples total 442\n Dimensionality 10\n Features real, -.2 < x < .2\n Targets integer 25 - 346\n ============== ==================\n\n .. note::\n The meaning of each feature (i.e. `feature_names`) might be unclear\n (especially for `ltg`) as the documentation of the original dataset is\n not explicit. We provide information that seems correct in regard with\n the scientific literature in this field of research.\n\n Read more in the :ref:`User Guide <diabetes_dataset>`.\n\n Parameters\n ----------\n return_X_y : bool, default=False\n If True, returns ``(data, target)`` instead of a Bunch object.\n See below for more information about the `data` and `target` object.\n\n .. versionadded:: 0.18\n\n as_frame : bool, default=False\n If True, the data is a pandas DataFrame including columns with\n appropriate dtypes (numeric). The target is\n a pandas DataFrame or Series depending on the number of target columns.\n If `return_X_y` is True, then (`data`, `target`) will be pandas\n DataFrames or Series as described below.\n\n .. versionadded:: 0.23\n\n scaled : bool, default=True\n If True, the feature variables are mean centered and scaled by the\n standard deviation times the square root of `n_samples`.\n If False, raw data is returned for the feature variables.\n\n .. versionadded:: 1.1\n\n Returns\n -------\n data : :class:`~sklearn.utils.Bunch`\n Dictionary-like object, with the following attributes.\n\n data : {ndarray, dataframe} of shape (442, 10)\n The data matrix. If `as_frame=True`, `data` will be a pandas\n DataFrame.\n target: {ndarray, Series} of shape (442,)\n The regression target. If `as_frame=True`, `target` will be\n a pandas Series.\n feature_names: list\n The names of the dataset columns.\n frame: DataFrame of shape (442, 11)\n Only present when `as_frame=True`. DataFrame with `data` and\n `target`.\n\n .. versionadded:: 0.23\n DESCR: str\n The full description of the dataset.\n data_filename: str\n The path to the location of the data.\n target_filename: str\n The path to the location of the target.\n\n (data, target) : tuple if ``return_X_y`` is True\n Returns a tuple of two ndarray of shape (n_samples, n_features)\n A 2D array with each row representing one sample and each column\n representing the features and/or target of a given sample.\n\n .. versionadded:: 0.18\n ", "language": "en", "n_whitespaces": 739, "n_words": 339, "vocab_size": 194 }

{ "docstring": "\n Decorator marking a test that requires pyctcdecode\n ", "language": "en", "n_whitespaces": 14, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\n StreamChangeCache.get_entities_changed will return the entities in the\n given list that have changed since the provided stream ID. If the\n stream position is earlier than the earliest known position, it will\n return all of the entities queried for.\n ", "language": "en", "n_whitespaces": 74, "n_words": 37, "vocab_size": 28 }

{ "docstring": "\n Return True if the link has a hash and it is allowed.\n ", "language": "en", "n_whitespaces": 27, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Return the list of available content paths under the given path.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 10 }

{ "docstring": "Normalizes items to construct a dictionary with normalized keys.\n\n This routine is where the names become keys and are made the same\n regardless of source - configuration files or environment.\n ", "language": "en", "n_whitespaces": 51, "n_words": 30, "vocab_size": 29 }

{ "docstring": "\n Decorator for test cases that generate and compare two figures.\n\n The decorated function must take two keyword arguments, *fig_test*\n and *fig_ref*, and draw the test and reference images on them.\n After the function returns, the figures are saved and compared.\n\n This decorator should be preferred over `image_comparison` when possible in\n order to keep the size of the test suite from ballooning.\n\n Parameters\n ----------\n extensions : list, default: [\"png\", \"pdf\", \"svg\"]\n The extensions to test.\n tol : float\n The RMS threshold above which the test is considered failed.\n\n Raises\n ------\n RuntimeError\n If any new figures are created (and not subsequently closed) inside\n the test function.\n\n Examples\n --------\n Check that calling `.Axes.plot` with a single argument plots it against\n ``[0, 1, 2, ...]``::\n", "language": "en", "n_whitespaces": 200, "n_words": 121, "vocab_size": 97 }

{ "docstring": "Compute the lowest common ancestor of the given pair of nodes.\n\n Parameters\n ----------\n G : NetworkX directed graph\n\n node1, node2 : nodes in the graph.\n\n default : object\n Returned if no common ancestor between `node1` and `node2`\n\n Returns\n -------\n The lowest common ancestor of node1 and node2,\n or default if they have no common ancestors.\n\n Examples\n --------\n >>> G = nx.DiGraph([(0, 1), (0, 2), (2, 3), (2, 4), (1, 6), (4, 5)])\n >>> nx.lowest_common_ancestor(G, 3, 5)\n 2\n\n We can also set `default` argument as below. The value of default is returned\n if there are no common ancestors of given two nodes.\n\n >>> G = nx.DiGraph([(4, 5), (12, 13)])\n >>> nx.lowest_common_ancestor(G, 12, 5, default=\"No common ancestors!\")\n 'No common ancestors!'\n\n Notes\n -----\n Only defined on non-null directed acyclic graphs.\n Takes n log(n) time in the size of the graph.\n See `all_pairs_lowest_common_ancestor` when you have\n more than one pair of nodes of interest.\n\n See Also\n --------\n tree_all_pairs_lowest_common_ancestor\n all_pairs_lowest_common_ancestor\n ", "language": "en", "n_whitespaces": 252, "n_words": 155, "vocab_size": 107 }

{ "docstring": " Populate the attribute :attr:`_per_session_stats` with a sorted list by session ID\n of each ID in the training/loaded session. Stats contain the session ID, start, end and\n elapsed times, the training rate, batch size and number of iterations for each session.\n\n If a training session is running, then updates the training sessions stats only.\n ", "language": "en", "n_whitespaces": 82, "n_words": 53, "vocab_size": 39 }

{ "docstring": "Prints instructions to load a CSV\n\n Returns\n ----------\n text : str\n Information on how to load a csv\n \nIn order to load a CSV do the following:\n\n1. Add headers to the first row, below is data for each column:\\n\n\\t1. Identifier for the asset (such as a stock ticker)\n\\t2. Type of asset (stock, bond, option, crypto)\n\\t3. The volume of the asset transacted\n\\t4. The buy date in yyyy/mm/dd\n\\t5. The Price paid for the asset\n\\t6. Any fees paid during the transaction\n\\t7. A premium paid or received if this was an option\n\\t8. Whether the asset was bought (covered) or sold (shorted)\\n\n2. Place this file in gamestonk_terminal/portfolio/portfolios\\n\n ", "language": "en", "n_whitespaces": 128, "n_words": 112, "vocab_size": 82 }

{ "docstring": "\n Creates a continuous random variable with Multivariate Normal\n Distribution.\n\n The density of the multivariate normal distribution can be found at [1].\n\n Parameters\n ==========\n\n mu : List representing the mean or the mean vector\n sigma : Positive semidefinite square matrix\n Represents covariance Matrix\n If `\\sigma` is noninvertible then only sampling is supported currently\n\n Returns\n =======\n\n RandomSymbol\n\n Examples\n ========\n\n >>> from sympy.stats import MultivariateNormal, density, marginal_distribution\n >>> from sympy import symbols, MatrixSymbol\n >>> X = MultivariateNormal('X', [3, 4], [[2, 1], [1, 2]])\n >>> y, z = symbols('y z')\n >>> density(X)(y, z)\n sqrt(3)*exp(-y**2/3 + y*z/3 + 2*y/3 - z**2/3 + 5*z/3 - 13/3)/(6*pi)\n >>> density(X)(1, 2)\n sqrt(3)*exp(-4/3)/(6*pi)\n >>> marginal_distribution(X, X[1])(y)\n exp(-(y - 4)**2/4)/(2*sqrt(pi))\n >>> marginal_distribution(X, X[0])(y)\n exp(-(y - 3)**2/4)/(2*sqrt(pi))\n\n The example below shows that it is also possible to use\n symbolic parameters to define the MultivariateNormal class.\n\n >>> n = symbols('n', integer=True, positive=True)\n >>> Sg = MatrixSymbol('Sg', n, n)\n >>> mu = MatrixSymbol('mu', n, 1)\n >>> obs = MatrixSymbol('obs', n, 1)\n >>> X = MultivariateNormal('X', mu, Sg)\n\n The density of a multivariate normal can be\n calculated using a matrix argument, as shown below.\n\n >>> density(X)(obs)\n (exp(((1/2)*mu.T - (1/2)*obs.T)*Sg**(-1)*(-mu + obs))/sqrt((2*pi)**n*Determinant(Sg)))[0, 0]\n\n References\n ==========\n\n .. [1] https://en.wikipedia.org/wiki/Multivariate_normal_distribution\n\n ", "language": "en", "n_whitespaces": 325, "n_words": 193, "vocab_size": 137 }

{ "docstring": "Move the cursor to the end of the text\n\n Returns:\n bool: True if the cursor moved. False otherwise.\n ", "language": "en", "n_whitespaces": 43, "n_words": 18, "vocab_size": 14 }

{ "docstring": "\n Return True if the user has each of the specified permissions. If\n object is passed, check if the user has all required perms for it.\n ", "language": "en", "n_whitespaces": 47, "n_words": 25, "vocab_size": 20 }

{ "docstring": " Checks server use native for learn or analyse.\n Will return right result only on Linux.\n ", "language": "en", "n_whitespaces": 34, "n_words": 15, "vocab_size": 15 }

{ "docstring": "\n Suffix labels with string `suffix`.\n ", "language": "en", "n_whitespaces": 20, "n_words": 5, "vocab_size": 5 }

{ "docstring": "Wrapper around XLA `Select` that broadcasts its arguments.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "A placeholder method for backward compatibility.\n\n The preprocessing logic has been included in the regnet model\n implementation. Users are no longer required to call this method to\n normalize the input data. This method does nothing and only kept as a\n placeholder to align the API surface between old and new version of model.\n\n Args:\n x: A floating point `numpy.array` or a `tf.Tensor`.\n data_format: Optional data format of the image tensor/array. Defaults to\n None, in which case the global setting\n `tf.keras.backend.image_data_format()` is used (unless you changed it,\n it defaults to \"channels_last\").{mode}\n\n Returns:\n Unchanged `numpy.array` or `tf.Tensor`.\n ", "language": "en", "n_whitespaces": 152, "n_words": 95, "vocab_size": 76 }

{ "docstring": "\n Enable display of debugging messages while doing pattern matching.\n ", "language": "en", "n_whitespaces": 24, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Batch format hint for upstream producers to try yielding best block format.\n\n The preferred batch format to use if both `_predict_pandas` and\n `_predict_numpy` are implemented. Defaults to Pandas.\n\n Can be overriden by predictor classes depending on the framework type,\n e.g. TorchPredictor prefers Numpy and XGBoostPredictor prefers Pandas as\n native batch format.\n\n ", "language": "en", "n_whitespaces": 93, "n_words": 51, "vocab_size": 44 }

{ "docstring": "\n Tests if Song.from_data_dump() works correctly.\n \n {\n \"name\": \"Ropes\",\n \"artists\": [\"Dirty Palm\", \"Chandler Jewels\"],\n \"album_name\": \"Ropes\",\n \"album_artist\": \"Dirty Palm\",\n \"genres\": [\"gaming edm\", \"melbourne bounce international\"],\n \"disc_number\": 1,\n \"duration\": 188,\n \"year\": 2021,\n \"date\": \"2021-10-28\",\n \"track_number\": 1,\n \"tracks_count\": 1,\n \"isrc\": \"GB2LD2110301\",\n \"song_id\": \"1t2qKa8K72IBC8yQlhD9bU\",\n \"cover_url\": \"https://i.scdn.co/image/ab67616d0000b273fe2cb38e4d2412dbb0e54332\",\n \"explicit\": false,\n \"download_url\": null,\n \"artist\" : \"Dirty Palm\",\n \"disc_count\": 1,\n \"copyright\": \"\",\n \"publisher\": \"\",\n \"url\": \"https://open.spotify.com/track/1t2qKa8K72IBC8yQlhD9bU\"\n }\n ", "language": "en", "n_whitespaces": 319, "n_words": 59, "vocab_size": 51 }

{ "docstring": "\n rule: dict\n\n This applies self._dedupe_indices on all values of rule.\n ", "language": "en", "n_whitespaces": 32, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Tests that media deleted if it is older than `before_ts` and never accessed\n `last_access_ts` is `NULL` and `created_ts` < `before_ts`\n ", "language": "en", "n_whitespaces": 42, "n_words": 20, "vocab_size": 17 }

{ "docstring": "Parse the line into a command name and a string containing\n the arguments. Returns a tuple containing (command, args, line).\n 'command' and 'args' may be None if the line couldn't be parsed.\n ", "language": "en", "n_whitespaces": 54, "n_words": 32, "vocab_size": 24 }

{ "docstring": "\n This performs field level filtering on the result set\n Eg: ?title=James Joyce\n ", "language": "en", "n_whitespaces": 34, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Default function generating examples for each `SplitGenerator`.\n\n This function preprocess the examples from the raw data to the preprocessed\n dataset files.\n This function is called once for each `SplitGenerator` defined in\n `_split_generators`. The examples yielded here will be written on\n disk.\n\n Args:\n **kwargs (additional keyword arguments): Arguments forwarded from the SplitGenerator.gen_kwargs\n\n Yields:\n key: `str` or `int`, a unique deterministic example identification key.\n * Unique: An error will be raised if two examples are yield with the\n same key.\n * Deterministic: When generating the dataset twice, the same example\n should have the same key.\n Good keys can be the image id, or line number if examples are extracted\n from a text file.\n The key will be hashed and sorted to shuffle examples deterministically,\n such as generating the dataset multiple times keep examples in the\n same order.\n example: `dict<str feature_name, feature_value>`, a feature dictionary\n ready to be encoded and written to disk. The example will be\n encoded with `self.info.features.encode_example({...})`.\n ", "language": "en", "n_whitespaces": 419, "n_words": 157, "vocab_size": 98 }

{ "docstring": "Return finalized dict of all fields that should be saved along with the job status change", "language": "en", "n_whitespaces": 15, "n_words": 16, "vocab_size": 16 }

{ "docstring": "\n Args:\n feat (Tensor): Tensor of shape :math:`(N, D_i, H, W)`.\n out_enc (Tensor): Encoder output of shape\n :math:`(N, D_m, H, W)`.\n targets (Tensor): a tensor of shape :math:`(N, T)`. Each element is the index of a\n character.\n valid_ratios (Tensor): valid length ratio of img.\n Returns:\n Tensor: A raw logit tensor of shape :math:`(N, T, C-1)` if\n ``return_feature=False``. Otherwise it would be the hidden feature\n before the prediction projection layer, whose shape is\n :math:`(N, T, D_m)`.\n ", "language": "en", "n_whitespaces": 214, "n_words": 74, "vocab_size": 50 }

{ "docstring": "Normalize an iterable of glob style patterns based on OS.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n :return: details of this exception\n ", "language": "en", "n_whitespaces": 20, "n_words": 5, "vocab_size": 5 }

{ "docstring": "Bind the provided arguments and return a DeploymentNode.\n\n The returned bound deployment can be deployed or bound to other\n deployments to create a multi-deployment application.\n ", "language": "en", "n_whitespaces": 46, "n_words": 25, "vocab_size": 22 }

{ "docstring": " Return C, h such that h is a G function of argument z**n and\n g = C*h. ", "language": "en", "n_whitespaces": 25, "n_words": 17, "vocab_size": 16 }

{ "docstring": "\n Split the parameters into names and values, check if these parameters\n are within the testable parameters and return in a dictionary.\n ", "language": "en", "n_whitespaces": 31, "n_words": 21, "vocab_size": 17 }

{ "docstring": "Given an rgb tuple, allocate palette entry.\n\n .. warning:: This method is experimental.\n ", "language": "en", "n_whitespaces": 27, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Draw masks on the image and their edges on the axes.\n\n Args:\n ax (matplotlib.Axes): The input axes.\n img (ndarray): The image with the shape of (3, h, w).\n masks (ndarray): The masks with the shape of (n, h, w).\n color (ndarray): The colors for each masks with the shape\n of (n, 3).\n with_edge (bool): Whether to draw edges. Default: True.\n alpha (float): Transparency of bounding boxes. Default: 0.8.\n\n Returns:\n matplotlib.Axes: The result axes.\n ndarray: The result image.\n ", "language": "en", "n_whitespaces": 153, "n_words": 77, "vocab_size": 47 }

{ "docstring": "Produces a list of Experiment objects.\n\n Converts input from dict, single experiment, or list of\n experiments to list of experiments. If input is None,\n will return an empty list.\n\n Arguments:\n experiments (Experiment | list | dict): Experiments to run.\n\n Returns:\n List of experiments.\n ", "language": "en", "n_whitespaces": 75, "n_words": 43, "vocab_size": 32 }

{ "docstring": "Test corner case where an network might predict no boxes and no\n gt.", "language": "en", "n_whitespaces": 19, "n_words": 13, "vocab_size": 12 }

{ "docstring": "\n Tests that no exception raised on removing not installed package\n ", "language": "en", "n_whitespaces": 17, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Applies a Transformer decoder layer on the input.\n\n Parameters:\n tgt (Tensor): The input of Transformer decoder layer. It is a tensor\n with shape `[batch_size, target_length, d_model]`. The data type\n should be float32 or float64.\n memory (Tensor): The output of Transformer encoder. It is a tensor\n with shape `[batch_size, source_length, d_model]`. The data type\n should be float32 or float64.\n tgt_mask (Tensor, optional): A tensor used in self attention\n to prevents attention to some unwanted positions, usually the\n the subsequent positions. It is a tensor with shape broadcasted\n to `[batch_size, n_head, target_length, target_length]`.\n When the data type is bool, the unwanted positions have `False` \n values and the others have `True` values. When the data type is \n int, the unwanted positions have 0 values and the others have 1 \n values. When the data type is float, the unwanted positions have \n `-INF` values and the others have 0 values. It can be None when \n nothing wanted or needed to be prevented attention to. Default None.\n memory_mask (Tensor, optional): A tensor used in decoder-encoder\n cross attention to prevents attention to some unwanted positions,\n usually the paddings. It is a tensor with shape broadcasted to \n `[batch_size, n_head, target_length, source_length]`. When the \n data type is bool, the unwanted positions have `False` values \n and the others have `True` values. When the data type is int, \n the unwanted positions have 0 values and the others have 1 \n values. When the data type is float, the unwanted positions have \n `-INF` values and the others have 0 values. It can be None when \n nothing wanted or needed to be prevented attention to. Default None.\n cache (tuple, optional): It is a tuple( :code:`(incremental_cache, static_cache)` ),\n `incremental_cache` is an instance of `MultiHeadAttention.Cache`,\n `static_cache` is an instance of `MultiHeadAttention.StaticCache.\n See `TransformerDecoderLayer.gen_cache` for more details. It is\n only used for inference and should be None for training. Default\n None.\n\n Returns:\n Tensor|tuple: It is a tensor that has the same shape and data type \\\n as `tgt`, representing the output of Transformer decoder layer. \\\n Or a tuple if `cache` is not None, except for decoder layer output, \\\n the tuple includes the new cache which is same as input `cache` \\\n argument but `incremental_cache` in it has an incremental length. \\\n See `MultiHeadAttention.gen_cache` and `MultiHeadAttention.forward` \\\n for more details.\n ", "language": "en", "n_whitespaces": 976, "n_words": 374, "vocab_size": 130 }

{ "docstring": "Try to convert value to an int, and raise if it fails.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Matrix or vector norm.\n\n This function is able to return one of eight different matrix norms,\n or one of an infinite number of vector norms (described below), depending\n on the value of the ``ord`` parameter.\n\n Parameters\n ----------\n x : array_like\n Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord`\n is None. If both `axis` and `ord` are None, the 2-norm of\n ``x.ravel`` will be returned.\n ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional\n Order of the norm (see table under ``Notes``). inf means numpy's\n `inf` object. The default is None.\n axis : {None, int, 2-tuple of ints}, optional.\n If `axis` is an integer, it specifies the axis of `x` along which to\n compute the vector norms. If `axis` is a 2-tuple, it specifies the\n axes that hold 2-D matrices, and the matrix norms of these matrices\n are computed. If `axis` is None then either a vector norm (when `x`\n is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default\n is None.\n\n .. versionadded:: 1.8.0\n\n keepdims : bool, optional\n If this is set to True, the axes which are normed over are left in the\n result as dimensions with size one. With this option the result will\n broadcast correctly against the original `x`.\n\n .. versionadded:: 1.10.0\n\n Returns\n -------\n n : float or ndarray\n Norm of the matrix or vector(s).\n\n See Also\n --------\n scipy.linalg.norm : Similar function in SciPy.\n\n Notes\n -----\n For values of ``ord < 1``, the result is, strictly speaking, not a\n mathematical 'norm', but it may still be useful for various numerical\n purposes.\n\n The following norms can be calculated:\n\n ===== ============================ ==========================\n ord norm for matrices norm for vectors\n ===== ============================ ==========================\n None Frobenius norm 2-norm\n 'fro' Frobenius norm --\n 'nuc' nuclear norm --\n inf max(sum(abs(x), axis=1)) max(abs(x))\n -inf min(sum(abs(x), axis=1)) min(abs(x))\n 0 -- sum(x != 0)\n 1 max(sum(abs(x), axis=0)) as below\n -1 min(sum(abs(x), axis=0)) as below\n 2 2-norm (largest sing. value) as below\n -2 smallest singular value as below\n other -- sum(abs(x)**ord)**(1./ord)\n ===== ============================ ==========================\n\n The Frobenius norm is given by [1]_:\n\n :math:`||A||_F = [\\\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n\n The nuclear norm is the sum of the singular values.\n\n Both the Frobenius and nuclear norm orders are only defined for\n matrices and raise a ValueError when ``x.ndim != 2``.\n\n References\n ----------\n .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n\n Examples\n --------\n >>> from numpy import linalg as LA\n >>> a = np.arange(9) - 4\n >>> a\n array([-4, -3, -2, ..., 2, 3, 4])\n >>> b = a.reshape((3, 3))\n >>> b\n array([[-4, -3, -2],\n [-1, 0, 1],\n [ 2, 3, 4]])\n\n >>> LA.norm(a)\n 7.745966692414834\n >>> LA.norm(b)\n 7.745966692414834\n >>> LA.norm(b, 'fro')\n 7.745966692414834\n >>> LA.norm(a, np.inf)\n 4.0\n >>> LA.norm(b, np.inf)\n 9.0\n >>> LA.norm(a, -np.inf)\n 0.0\n >>> LA.norm(b, -np.inf)\n 2.0\n\n >>> LA.norm(a, 1)\n 20.0\n >>> LA.norm(b, 1)\n 7.0\n >>> LA.norm(a, -1)\n -4.6566128774142013e-010\n >>> LA.norm(b, -1)\n 6.0\n >>> LA.norm(a, 2)\n 7.745966692414834\n >>> LA.norm(b, 2)\n 7.3484692283495345\n\n >>> LA.norm(a, -2)\n 0.0\n >>> LA.norm(b, -2)\n 1.8570331885190563e-016 # may vary\n >>> LA.norm(a, 3)\n 5.8480354764257312 # may vary\n >>> LA.norm(a, -3)\n 0.0\n\n Using the `axis` argument to compute vector norms:\n\n >>> c = np.array([[ 1, 2, 3],\n ... [-1, 1, 4]])\n >>> LA.norm(c, axis=0)\n array([ 1.41421356, 2.23606798, 5. ])\n >>> LA.norm(c, axis=1)\n array([ 3.74165739, 4.24264069])\n >>> LA.norm(c, ord=1, axis=1)\n array([ 6., 6.])\n\n Using the `axis` argument to compute matrix norms:\n\n >>> m = np.arange(8).reshape(2,2,2)\n >>> LA.norm(m, axis=(1,2))\n array([ 3.74165739, 11.22497216])\n >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])\n (3.7416573867739413, 11.224972160321824)\n\n ", "language": "en", "n_whitespaces": 1267, "n_words": 581, "vocab_size": 322 }

{ "docstring": "\n Tagged items use a generic relationship, which results in duplicate rows being returned when queried.\n This is combatted by by appending distinct() to the config context querysets. This test creates a config\n context assigned to two tags and ensures objects related by those same two tags result in only a single\n config context record being returned.\n\n This test case is seperate from the above in that it deals with multiple config context objects in play.\n\n See https://github.com/netbox-community/netbox/issues/5387\n ", "language": "en", "n_whitespaces": 127, "n_words": 77, "vocab_size": 54 }

{ "docstring": "Test RecorderPool gives the same connection in the creating thread.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 9 }

{ "docstring": "\n Tries to infer output dtype of ``func`` for a small set of input arguments.\n\n Parameters\n ----------\n func: Callable\n Function for which output dtype is to be determined\n\n args: List of array like\n Arguments to the function, which would usually be used. Only attributes\n ``ndim`` and ``dtype`` are used.\n\n kwargs: dict\n Additional ``kwargs`` to the ``func``\n\n funcname: String\n Name of calling function to improve potential error messages\n\n suggest_dtype: None/False or String\n If not ``None`` adds suggestion to potential error message to specify a dtype\n via the specified kwarg. Defaults to ``'dtype'``.\n\n nout: None or Int\n ``None`` if function returns single output, integer if many.\n Deafults to ``None``.\n\n Returns\n -------\n : dtype or List of dtype\n One or many dtypes (depending on ``nout``)\n ", "language": "en", "n_whitespaces": 231, "n_words": 121, "vocab_size": 86 }

{ "docstring": "Return our Cursor. This will be None if we're not running in a\n ScriptThread - e.g., if we're running a \"bare\" script outside of\n Streamlit.\n ", "language": "en", "n_whitespaces": 46, "n_words": 25, "vocab_size": 21 }

{ "docstring": "\n If user downgraded and is upgrading again, we have to check for existing\n indexes on mysql because we can't (and don't) drop them as part of the\n downgrade.\n ", "language": "en", "n_whitespaces": 41, "n_words": 28, "vocab_size": 27 }

{ "docstring": "Fit model on training data X.\n\n Parameters\n ----------\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\n Training data.\n\n y : Ignored\n Not used, present here for API consistency by convention.\n\n Returns\n -------\n self : object\n Returns the transformer object.\n ", "language": "en", "n_whitespaces": 129, "n_words": 40, "vocab_size": 37 }

{ "docstring": "Performs a channel shift.\n\n Args:\n x: Input tensor. Must be 3D.\n intensity: Transformation intensity.\n channel_axis: Index of axis for channels in the input tensor.\n\n Returns:\n Numpy image tensor.\n ", "language": "en", "n_whitespaces": 51, "n_words": 28, "vocab_size": 26 }

{ "docstring": "Notification to TrialScheduler and requeue trial.\n\n This does not notify the SearchAlgorithm because the function\n evaluation is still in progress.\n\n ", "language": "en", "n_whitespaces": 41, "n_words": 20, "vocab_size": 19 }

{ "docstring": "\n Tests that specific, stripped state events from a room are returned after\n a remote homeserver successfully knocks on a local room.\n ", "language": "en", "n_whitespaces": 43, "n_words": 21, "vocab_size": 19 }

{ "docstring": "Returns whether the filepath should be overwritten.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "Make a linear system Ax=b\n\n Parameters\n ----------\n A : LinearOperator\n sparse or dense matrix (or any valid input to aslinearoperator)\n M : {LinearOperator, Nones}\n preconditioner\n sparse or dense matrix (or any valid input to aslinearoperator)\n x0 : {array_like, str, None}\n initial guess to iterative method.\n ``x0 = 'Mb'`` means using the nonzero initial guess ``M @ b``.\n Default is `None`, which means using the zero initial guess.\n b : array_like\n right hand side\n\n Returns\n -------\n (A, M, x, b, postprocess)\n A : LinearOperator\n matrix of the linear system\n M : LinearOperator\n preconditioner\n x : rank 1 ndarray\n initial guess\n b : rank 1 ndarray\n right hand side\n postprocess : function\n converts the solution vector to the appropriate\n type and dimensions (e.g. (N,1) matrix)\n\n ", "language": "en", "n_whitespaces": 303, "n_words": 123, "vocab_size": 77 }

{ "docstring": "Print select details from a html response containing xml", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Create new estimator which converting all attributes that are arrays.\n\n Parameters\n ----------\n estimator : Estimator\n Estimator to convert\n\n converter : callable\n Callable that takes an array attribute and returns the converted array.\n\n Returns\n -------\n new_estimator : Estimator\n Convert estimator\n ", "language": "en", "n_whitespaces": 84, "n_words": 39, "vocab_size": 32 }

{ "docstring": "Returns variables of this Optimizer based on the order created.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Create a link annotation object for embedding URLs.\n ", "language": "en", "n_whitespaces": 15, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Exclude variables from weight decay.\n\n This method must be called before the optimizer's `build` method is\n called. You can set specific variables to exclude out, or set a list of\n strings as the anchor words, if any of which appear in a variable's\n name, then the variable is excluded.\n\n Args:\n var_list: A list of `tf.Variable`s to exclude from weight decay.\n var_names: A list of strings. If any string in `var_names` appear\n in the model variable's name, then this model variable is\n excluded from weight decay. For example, `var_names=['bias']`\n excludes all bias variables from weight decay.\n ", "language": "en", "n_whitespaces": 204, "n_words": 95, "vocab_size": 59 }

{ "docstring": "Render the given version pieces into the requested style.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "Return the user ID to be used for actions received via the local SDK.\n\n Return None is no agent user id is found.\n ", "language": "en", "n_whitespaces": 37, "n_words": 23, "vocab_size": 19 }

{ "docstring": "Return the factored form of ``expr`` while handling non-commutative\n expressions.\n\n Examples\n ========\n\n >>> from sympy import factor_nc, Symbol\n >>> from sympy.abc import x\n >>> A = Symbol('A', commutative=False)\n >>> B = Symbol('B', commutative=False)\n >>> factor_nc((x**2 + 2*A*x + A**2).expand())\n (x + A)**2\n >>> factor_nc(((x + A)*(x + B)).expand())\n (x + A)*(x + B)\n ", "language": "en", "n_whitespaces": 89, "n_words": 53, "vocab_size": 36 }

{ "docstring": "\n The `template_context` event is called immediately after the context is created\n for the subject template and can be used to alter the context for that specific\n template only.\n\n Parameters:\n context: dict of template context variables\n template_name: string filename of template\n config: global configuration object\n\n Returns:\n dict of template context variables\n ", "language": "en", "n_whitespaces": 137, "n_words": 50, "vocab_size": 35 }

{ "docstring": "Loads the dataset, downloaded and processing it if needed.\n\n If dataset is already processed, does nothing.\n ", "language": "en", "n_whitespaces": 30, "n_words": 16, "vocab_size": 16 }

{ "docstring": "OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S\n and values equal to v (which defaults to None).\n\n ", "language": "en", "n_whitespaces": 41, "n_words": 19, "vocab_size": 18 }

{ "docstring": "\n Get the full app-label-qualified permission name (as required by\n user.has_perm(...) ) for the given action on this model\n ", "language": "en", "n_whitespaces": 40, "n_words": 18, "vocab_size": 17 }

{ "docstring": "\n Return a QuerySet of child objects.\n\n Args:\n request: The current request\n parent: The parent object\n ", "language": "en", "n_whitespaces": 59, "n_words": 15, "vocab_size": 14 }

{ "docstring": "Do nothing and return the estimator unchanged\n This method is just there to implement the usual API and hence\n work in pipelines.\n Parameters\n ----------\n X : array-like\n ", "language": "en", "n_whitespaces": 69, "n_words": 27, "vocab_size": 25 }

{ "docstring": "\n Return the context variables required to render the underlying hidden input element\n ", "language": "en", "n_whitespaces": 27, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Redirection should not break if the current request does not correspond to a site\n ", "language": "en", "n_whitespaces": 29, "n_words": 14, "vocab_size": 13 }

{ "docstring": "select min(year_start_date) as year_start_date,\n\t\tmax(year_end_date) as year_end_date from `tabFiscal Year` where\n\t\tname between %(from_fiscal_year)s and %(to_fiscal_year)s", "language": "en", "n_whitespaces": 13, "n_words": 16, "vocab_size": 15 }

{ "docstring": "\n import sys\n\n from {0}.QtGui import QGuiApplication\n from {0}.QtQml import QQmlApplicationEngine\n\n is_qt6 = '{0}' in {{'PyQt6', 'PySide6'}}\n\n if is_qt6:\n from {0}.QtWebEngineQuick import QtWebEngineQuick\n else:\n from {0}.QtWebEngine import QtWebEngine as QtWebEngineQuick\n QtWebEngineQuick.initialize()\n\n app = QGuiApplication([])\n engine = QQmlApplicationEngine()\n engine.loadData(b)\n\n if not engine.rootObjects():\n sys.exit(-1)\n\n if is_qt6:\n # Qt6: exec_() is deprecated in PySide6 and removed from PyQt6 in favor of exec()\n res = app.exec()\n else:\n res = app.exec_()\n del engine\n sys.exit(res)\n ", "language": "en", "n_whitespaces": 247, "n_words": 68, "vocab_size": 47 }