\\n And this is the amazing second page!\\n
\\n ' + self.footer()", "docstring": "Produce HTTP response body of another page app index URI.", "type": "method", "file_path": "cherrypy\\cherrypy\\tutorial\\tut05_derived_objects.py", "ast_data": "FunctionDef name:index arg:self arguments arg Return return:yes Call Call" }, { "library": "pytorch", "name": "is_initialized", "source_code": "def is_initialized():\n return _initialized and (not _is_in_bad_fork())", "docstring": "Return whether PyTorch's CUDA state has been initialized.", "type": "function", "file_path": "pytorch\\torch\\cuda\\__init__.py", "ast_data": "FunctionDef name:is_initialized arguments Return return:yes BoolOp Call" }, { "library": "django", "name": "sanitize_separators", "source_code": "def sanitize_separators(value):\n if isinstance(value, str):\n parts = []\n decimal_separator = get_format('DECIMAL_SEPARATOR')\n if decimal_separator in value:\n value, decimals = value.split(decimal_separator, 1)\n parts.append(decimals)\n if settings.USE_THOUSAND_SEPARATOR:\n thousand_sep = get_format('THOUSAND_SEPARATOR')\n if thousand_sep == '.' and value.count('.') == 1 and (len(value.split('.')[-1]) != 3):\n pass\n else:\n for replacement in {thousand_sep, unicodedata.normalize('NFKD', thousand_sep)}:\n value = value.replace(replacement, '')\n parts.append(value)\n value = '.'.join(reversed(parts))\n return value", "docstring": "Sanitize a value according to the current decimal and thousand separator setting. Used with form field input.", "type": "function", "file_path": "django\\django\\utils\\formats.py", "ast_data": "FunctionDef name:sanitize_separators arg:value arguments arg If Call Assign Assign Call If Compare Assign Call Call If Assign Call If BoolOp Compare Compare Call Compare Call Call For Call Assign Call Call Assign Call Call Return return:yes" }, { "library": "matplotlib", "name": "gca", "source_code": "def gca(self):\n ax = self._axstack.current()\n return ax if ax is not None else self.add_subplot()", "docstring": "Get the current Axes. If there is currently no Axes on this Figure, a new one is created using . (To test whether there is currently an Axes on a Figure, check whether `.pyplot.get_fignums()` is empty.)", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\figure.py", "ast_data": "FunctionDef name:gca arg:self arguments arg Assign Call Return return:yes Compare Call" }, { "library": "pytorch", "name": "register_extension", "source_code": "def register_extension(op_type: type[Any], extension_handler: type[ExtensionHandler]):\n assert issubclass(extension_handler, ExtensionHandler), f'Expected ExtensionHandler, got {extension_handler}.'\n assert op_type not in _serialization_registry, f'{op_type} is already registered.'\n assert isinstance(op_type, type)\n assert not (op_type.__module__.startswith('torch') or op_type.__module__.startswith('builtins'))\n assert extension_handler.namespace() not in _deserialization_registry\n _serialization_registry[op_type] = extension_handler\n _deserialization_registry[extension_handler.namespace()] = extension_handler", "docstring": "Register custom de/serialization method for a node with non-standard type.", "type": "function", "file_path": "pytorch\\torch\\_export\\serde\\serialize.py", "ast_data": "FunctionDef name:register_extension arg:op_type arg:extension_handler arguments arg arg Call Compare Call BoolOp Call Call Compare Call Assign Assign Call" }, { "library": "pytorch", "name": "_launch_backward", "source_code": "def _launch_backward(self, test_case, iters, print_per_iter=False):\n test_case.run_forward(num_runs=1, print_per_iter=False, cuda_sync=False)\n test_case._output_mean()\n backward_time = timeit.timeit(functools.partial(test_case.run_backward, iters, print_per_iter), number=1)\n return backward_time", "docstring": "This function runs forward path of an op to get an output. Then the backward path is executed and the execution time is reported", "type": "method", "file_path": "pytorch\\benchmarks\\operator_benchmark\\benchmark_core.py", "ast_data": "FunctionDef name:_launch_backward arg:self arg:test_case arg:iters arg:print_per_iter arguments arg arg arg arg Call Call Assign Call Call Return return:yes" }, { "library": "pytorch", "name": "redact", "source_code": "def redact(self, needle: str, replace: str='Toggle tracebacks %s
\\nClick me; I\\'m a broken link!
\\n\\n \\n Use a custom error page from a file.\\n \\n
\\nThese errors are explicitly raised by the application:
\\n \\nYou can also set the response body\\n when you raise an error.
\\n \\n ' % trace", "docstring": "Produce HTTP response body of error display app index URI.", "type": "method", "file_path": "cherrypy\\cherrypy\\tutorial\\tut10_http_errors.py", "ast_data": "FunctionDef name:index arg:self arguments arg Assign If Assign Assign Return return:yes" }, { "library": "tensorflow", "name": "__call__", "source_code": "def __call__(self, shape, dtype=dtypes.float32, **kwargs):\n self._validate_kwargs(kwargs, support_partition=False)\n dtype = _assert_float_dtype(dtype)\n if len(shape) < 2:\n raise ValueError(f'The tensor to initialize, specified by argument `shape` must be at least two-dimensional. Received shape={shape}')\n num_rows = 1\n for dim in shape[:-1]:\n num_rows *= dim\n num_cols = shape[-1]\n flat_shape = (max(num_cols, num_rows), min(num_cols, num_rows))\n a = self._random_generator.random_normal(flat_shape, dtype=dtype)\n q, r = gen_linalg_ops.qr(a, full_matrices=False)\n d = array_ops.diag_part(r)\n q *= math_ops.sign(d)\n if num_rows < num_cols:\n q = array_ops.matrix_transpose(q)\n return self.gain * array_ops.reshape(q, shape)", "docstring": "Returns a tensor object initialized as specified by the initializer. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point types are supported. **kwargs: Additional keyword arguments. Raises: ValueError: If the dtype is not floating point or the input shape is not valid.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\ops\\init_ops_v2.py", "ast_data": "FunctionDef name:__call__ arg:self arg:shape arg:dtype arguments arg arg arg arg Call Assign Call If Compare Call Raise Call Assign For Assign Assign Call Call Assign Call Assign Call Assign Call Call If Compare Assign Call Return return:yes Call" }, { "library": "tensorflow", "name": "pad_sparse_embedding_lookup_indices", "source_code": "def pad_sparse_embedding_lookup_indices(sparse_indices, padded_size):\n batch_size = sparse_indices.dense_shape[0]\n sparse_indices = sparse_ops.sparse_slice(sparse_indices, [0, 0], [batch_size, padded_size])\n indices, values = (sparse_indices.indices, sparse_indices.values)\n padded_values = array_ops.scatter_nd(indices, math_ops.cast(values, dtypes.int32), shape=(batch_size, padded_size))\n weights = array_ops.ones_like(values, dtype=dtypes.float32)\n padded_mask = array_ops.scatter_nd(indices, weights, shape=(batch_size, padded_size))\n return (padded_values, padded_mask)", "docstring": "Creates statically-sized Tensors containing indices and weights. From third_party/cloud_tpu/models/movielens/tpu_embedding.py Also computes sparse_indices.values % embedding_table_size, for equivalent functionality to sparse_column_with_integerized_feature. The returned padded weight Tensor also doubles as a mask indicating which values in the returned padded indices Tensor are indices versus padded zeros. Args: sparse_indices: SparseTensor of embedding lookup indices. padded_size: Number of columns of the returned Tensors. Indices which fall out of bounds will be truncated to the padded size. Returns: (sparse_indices.values padded to the specified size, a mask the same size as the returned padded values in which 0s indicate padded locations and 1s (or values from sparse_weights) indicate actual values)", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\tpu\\feature_column_v2.py", "ast_data": "FunctionDef name:pad_sparse_embedding_lookup_indices arg:sparse_indices arg:padded_size arguments arg arg Assign Assign Call Assign Assign Call Call Assign Call Assign Call Return return:yes" }, { "library": "tensorflow", "name": "get_signature_to_agg_fn_map", "source_code": "def get_signature_to_agg_fn_map(self):\n return {TRACE_MODE_NORM: linalg_ops.norm, TRACE_MODE_HISTORY: math_ops.reduce_max, TRACE_MODE_MAX_ABS: math_ops.reduce_max, TRACE_MODE_NAN_INF: math_ops.reduce_max, TT_SUMMARY_NORM: linalg_ops.norm, TT_SUMMARY_MAX: math_ops.reduce_max, TT_SUMMARY_MAX_ABS: lambda t, axis=0: math_ops.reduce_max(math_ops.abs(t), axis=axis), TT_SUMMARY_MIN: math_ops.reduce_min, TT_SUMMARY_SPARSITY: math_ops.reduce_mean, TT_SUMMARY_MEAN: math_ops.reduce_mean, TT_SUMMARY_VAR: math_ops.reduce_max, TT_SUMMARY_SIZE: math_ops.reduce_sum}", "docstring": "Returns a map that contains the aggregate function for each signature.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\tpu\\tensor_tracer_flags.py", "ast_data": "FunctionDef name:get_signature_to_agg_fn_map arg:self arguments arg Return return:yes arguments arg arg Call Call" }, { "library": "tensorflow", "name": "value", "source_code": "def value(self):\n with c_api_util.tf_buffer() as buffer_:\n pywrap_tfe.TFE_MonitoringStringGaugeCellValue(self._cell, buffer_)\n value = pywrap_tf_session.TF_GetBuffer(buffer_).decode('utf-8')\n return value", "docstring": "Retrieves the current value.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\eager\\monitoring.py", "ast_data": "FunctionDef name:value arg:self arguments arg With Call Call Assign Call Call Return return:yes" }, { "library": "tensorflow", "name": "cluster_resolver", "source_code": "@property\ndef cluster_resolver(self):\n if hasattr(self.extended, '_cluster_resolver'):\n return self.extended._cluster_resolver\n return None", "docstring": "Returns the cluster resolver associated with this strategy. In general, when using a multi-worker strategy such as or , there is a associated with the strategy used, and such an instance is returned by this property. Strategies that intend to have an associated must set the relevant attribute, or override this property; otherwise, is returned by default. Those strategies should also provide information regarding what is returned by this property. Single-worker strategies usually do not have a , and in those cases this property will return . The may be useful when the user needs to access information such as the cluster spec, task type or task id. For example, For more information, please see 's API docstring. Returns: The cluster resolver associated with this strategy. Returns if a cluster resolver is not applicable or available in this strategy.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\distribute\\distribute_lib.py", "ast_data": "FunctionDef name:cluster_resolver arg:self arguments arg If Call Return return:yes Return return:no" }, { "library": "uvicorn", "name": "pause_writing", "source_code": "def pause_writing(self) -> None:\n self.flow.pause_writing()", "docstring": "Called by the transport when the write buffer exceeds the high water mark.", "type": "method", "file_path": "uvicorn\\uvicorn\\protocols\\http\\h11_impl.py", "ast_data": "FunctionDef name:pause_writing arg:self arguments arg Call" }, { "library": "sphinx", "name": "ASTParenAttribute", "source_code": "class ASTParenAttribute(ASTAttribute):\n\n def __init__(self, id: str, arg: str) -> None:\n self.id = id\n self.arg = arg\n\n def __eq__(self, other: object) -> bool:\n if not isinstance(other, ASTParenAttribute):\n return NotImplemented\n return self.id == other.id and self.arg == other.arg\n\n def __hash__(self) -> int:\n return hash((self.id, self.arg))\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return f'{self.id}({self.arg})'\n\n def describe_signature(self, signode: TextElement) -> None:\n signode.append(nodes.Text(str(self)))", "docstring": "For paren attributes defined by the user.", "type": "class", "file_path": "sphinx\\sphinx\\util\\cfamily.py", "ast_data": "ClassDef name:ASTParenAttribute FunctionDef name:__init__ arg:self arg:id arg:arg arguments arg arg arg Assign Assign FunctionDef name:__eq__ arg:self arg:other arguments arg arg If Call Return return:yes Return return:yes BoolOp Compare Compare FunctionDef name:__hash__ arg:self arguments arg Return return:yes Call FunctionDef name:_stringify arg:self arg:transform arguments arg arg Return return:yes FunctionDef name:describe_signature arg:self arg:signode arguments arg arg Call Call Call" }, { "library": "scikit-learn", "name": "_lars_path_residues", "source_code": "def _lars_path_residues(X_train, y_train, X_test, y_test, Gram=None, copy=True, method='lar', verbose=False, fit_intercept=True, max_iter=500, eps=np.finfo(float).eps, positive=False):\n X_train = _check_copy_and_writeable(X_train, copy)\n y_train = _check_copy_and_writeable(y_train, copy)\n X_test = _check_copy_and_writeable(X_test, copy)\n y_test = _check_copy_and_writeable(y_test, copy)\n if fit_intercept:\n X_mean = X_train.mean(axis=0)\n X_train -= X_mean\n X_test -= X_mean\n y_mean = y_train.mean(axis=0)\n y_train = as_float_array(y_train, copy=False)\n y_train -= y_mean\n y_test = as_float_array(y_test, copy=False)\n y_test -= y_mean\n alphas, active, coefs = lars_path(X_train, y_train, Gram=Gram, copy_X=False, copy_Gram=False, method=method, verbose=max(0, verbose - 1), max_iter=max_iter, eps=eps, positive=positive)\n residues = np.dot(X_test, coefs) - y_test[:, np.newaxis]\n return (alphas, active, coefs, residues.T)", "docstring": "Compute the residues on left-out data for a full LARS path Parameters ----------- X_train : array-like of shape (n_samples, n_features) The data to fit the LARS on y_train : array-like of shape (n_samples,) The target variable to fit LARS on X_test : array-like of shape (n_samples, n_features) The data to compute the residues on y_test : array-like of shape (n_samples,) The target variable to compute the residues on Gram : None, 'auto' or array-like of shape (n_features, n_features), default=None Precomputed Gram matrix (X' * X), if ``, whichever is smaller. active : list Indices of active variables at the end of the path. coefs : array-like of shape (n_features, n_alphas) Coefficients along the path residues : array-like of shape (n_alphas, n_samples) Residues of the prediction on the test data", "type": "function", "file_path": "scikit-learn\\sklearn\\linear_model\\_least_angle.py", "ast_data": "FunctionDef name:_lars_path_residues arg:X_train arg:y_train arg:X_test arg:y_test arg:Gram arg:copy arg:method arg:verbose arg:fit_intercept arg:max_iter arg:eps arg:positive arguments arg arg arg arg arg arg arg arg arg arg arg arg Call Assign Call Assign Call Assign Call Assign Call If Assign Call Assign Call Assign Call Assign Call Assign Call Call Assign Call Return return:yes" }, { "library": "pandas", "name": "prepare_function_arguments", "source_code": "def prepare_function_arguments(func: Callable, args: tuple, kwargs: dict, *, num_required_args: int) -> tuple[tuple, dict]:\n if not kwargs:\n return (args, kwargs)\n signature = inspect.signature(func)\n arguments = signature.bind(*[_sentinel] * num_required_args, *args, **kwargs)\n arguments.apply_defaults()\n args = arguments.args\n kwargs = arguments.kwargs\n if kwargs:\n raise NumbaUtilError('numba does not support keyword-only argumentshttps://github.com/numba/numba/issues/2916, https://github.com/numba/numba/issues/6846')\n args = args[num_required_args:]\n return (args, kwargs)", "docstring": "Prepare arguments for jitted function. As numba functions do not support kwargs, we try to move kwargs into args if possible. Parameters ---------- func : function User defined function args : tuple User input positional arguments kwargs : dict User input keyword arguments num_required_args : int The number of leading positional arguments we will pass to udf. These are not supplied by the user. e.g. for groupby we require \"values\", \"index\" as the first two arguments: , in this case num_required_args=2. See :func: Returns ------- tuple[tuple, dict] args, kwargs", "type": "function", "file_path": "pandas\\pandas\\core\\util\\numba_.py", "ast_data": "FunctionDef name:prepare_function_arguments arg:func arg:args arg:kwargs arguments arg arg arg arg If Return return:yes Assign Call Assign Call Call Assign Assign If Raise Call Assign Return return:yes" }, { "library": "scipy", "name": "_get_message", "source_code": "def _get_message(status):\n messages = ['Optimization terminated successfully.', 'The iteration limit was reached before the algorithm converged.', 'The algorithm terminated successfully and determined that the problem is infeasible.', 'The algorithm terminated successfully and determined that the problem is unbounded.', 'Numerical difficulties were encountered before the problem converged. Please check your problem formulation for errors, independence of linear equality constraints, and reasonable scaling and matrix condition numbers. If you continue to encounter this error, please submit a bug report.']\n return messages[status]", "docstring": "Given problem status code, return a more detailed message. Parameters ---------- status : int An integer representing the exit status of the optimization:: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Serious numerical difficulties encountered Returns ------- message : str A string descriptor of the exit status of the optimization.", "type": "function", "file_path": "scipy\\scipy\\optimize\\_linprog_ip.py", "ast_data": "FunctionDef name:_get_message arg:status arguments arg Assign Return return:yes" }, { "library": "pytorch", "name": "_NoParamDecoratorContextManager", "source_code": "class _NoParamDecoratorContextManager(_DecoratorContextManager):\n\n def __new__(cls, orig_func=None):\n if orig_func is None:\n return super().__new__(cls)\n return cls()(orig_func)", "docstring": "Allow a context manager to be used as a decorator without parentheses.", "type": "class", "file_path": "pytorch\\torch\\utils\\_contextlib.py", "ast_data": "ClassDef name:_NoParamDecoratorContextManager FunctionDef name:__new__ arg:cls arg:orig_func arguments arg arg If Compare Return return:yes Call Call Return return:yes Call Call" }, { "library": "django", "name": "get_extra_descriptor_filter", "source_code": "def get_extra_descriptor_filter(self, instance):\n return {}", "docstring": "Return an extra filter condition for related object fetching when user does 'instance.fieldname', that is the extra filter is used in the descriptor of the field. The filter should be either a dict usable in .filter(**kwargs) call or a Q-object. The condition will be ANDed together with the relation's joining columns. A parallel method is get_extra_restriction() which is used in JOIN and subquery conditions.", "type": "method", "file_path": "django\\django\\db\\models\\fields\\related.py", "ast_data": "FunctionDef name:get_extra_descriptor_filter arg:self arg:instance arguments arg arg Return return:no" }, { "library": "tensorflow", "name": "register_custom_device", "source_code": "def register_custom_device(device_capsule, device_name, device_info_capsule):\n context().register_custom_device(device_capsule, device_name, device_info_capsule)", "docstring": "Calls TFE_RegisterCustomDevice to register a custom device with Python. Enables using C extensions specifying a custom device from Python. See the experimental eager C API in tensorflow/c/eager/c_api_experimental.h for details. Note that custom devices are not currently supported inside s. Args: device_capsule: A PyCapsule with the name set to 'TFE_CustomDevice' containing a pointer to a TFE_CustomDevice struct. The capsule retains ownership of the memory. device_name: A string indicating the name to register the custom device under, e.g. '/job:localhost/replica:0/task:0/device:CUSTOM:0'. It may subsequently be passed to . device_info_capsule: A PyCapsule with the name set to 'TFE_CustomDevice_DeviceInfo' containing a pointer to a device-specific struct with the initial state of the custom device (the void* device_info argument to TFE_RegisterCustomDevice). This method takes ownership of the memory and clears the capsule destructor.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\eager\\context.py", "ast_data": "FunctionDef name:register_custom_device arg:device_capsule arg:device_name arg:device_info_capsule arguments arg arg arg Call Call" }, { "library": "scipy", "name": "isbetter", "source_code": "def isbetter(f1: float, c1: float, f2: float, c2: float, ctol: float) -> bool:\n if DEBUGGING:\n assert not any(np.isnan([f1, c1]) | np.isposinf([f2, c2]))\n assert not any(np.isnan([f2, c2]) | np.isposinf([f2, c2]))\n assert c1 >= 0 and c2 >= 0\n assert ctol >= 0\n is_better = False\n is_better = is_better or (any(np.isnan([f1, c1]) | np.isposinf([f1, c1])) and (not any(np.isnan([f2, c2]) | np.isposinf([f2, c2]))))\n is_better = is_better or (f1 < f2 and c1 <= c2)\n is_better = is_better or (f1 <= f2 and c1 < c2)\n cref = 10 * max(EPS, min(ctol, 0.01 * CONSTRMAX))\n is_better = is_better or (f1 < REALMAX and c1 <= ctol and (c2 > max(ctol, cref) or np.isnan(c2)))\n if DEBUGGING:\n assert not (is_better and f1 >= f2 and (c1 >= c2))\n assert is_better or not (f1 <= f2 and c1 < c2)\n assert is_better or not (f1 < f2 and c1 <= c2)\n return is_better", "docstring": "This function compares whether FC1 = (F1, C1) is (strictly) better than FC2 = (F2, C2), which basically means that (F1 < F2 and C1 <= C2) or (F1 <= F2 and C1 < C2). It takes care of the cases where some of these values are NaN or Inf, even though some cases should never happen due to the moderated extreme barrier. At return, BETTER = TRUE if and only if (F1, C1) is better than (F2, C2). Here, C means constraint violation, which is a nonnegative number.", "type": "function", "file_path": "scipy\\scipy\\_lib\\pyprima\\pyprima\\src\\pyprima\\common\\selectx.py", "ast_data": "FunctionDef name:isbetter arg:f1 arg:c1 arg:f2 arg:c2 arg:ctol arguments arg arg arg arg arg If Call Call Call Call Call Call BoolOp Compare Compare Compare Assign Assign BoolOp BoolOp Call Call Call Call Call Call Assign BoolOp BoolOp Compare Compare Assign BoolOp BoolOp Compare Compare Assign Call Call Assign BoolOp BoolOp Compare Compare BoolOp Compare Call Call If BoolOp Compare Compare BoolOp BoolOp Compare Compare BoolOp BoolOp Compare Compare Return return:yes" }, { "library": "sphinx", "name": "resolve_xref", "source_code": "def resolve_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder, typ: str, target: str, node: pending_xref, contnode: Element) -> nodes.reference | None:\n pass", "docstring": "Resolve the pending_xref *node* with the given *typ* and *target*. This method should return a new node, to replace the xref node, containing the *contnode* which is the markup content of the cross-reference. If no resolution can be found, None can be returned; the xref node will then given to the :event: event, and if that yields no resolution, replaced by *contnode*. The method can also raise :exc: to suppress the :event: event being emitted.", "type": "method", "file_path": "sphinx\\sphinx\\domains\\__init__.py", "ast_data": "FunctionDef name:resolve_xref arg:self arg:env arg:fromdocname arg:builder arg:typ arg:target arg:node arg:contnode arguments arg arg arg arg arg arg arg arg" }, { "library": "numpy", "name": "NotFoundError", "source_code": "class NotFoundError(DistutilsError):\n pass", "docstring": "Some third-party program or library is not found.", "type": "class", "file_path": "numpy\\numpy\\distutils\\system_info.py", "ast_data": "ClassDef name:NotFoundError" }, { "library": "pandas", "name": "_coerce_indexer_frozen", "source_code": "def _coerce_indexer_frozen(array_like, categories, copy: bool=False) -> np.ndarray:\n array_like = coerce_indexer_dtype(array_like, categories)\n if copy:\n array_like = array_like.copy()\n array_like.flags.writeable = False\n return array_like", "docstring": "Coerce the array-like indexer to the smallest integer dtype that can encode all of the given categories. Parameters ---------- array_like : array-like categories : array-like copy : bool Returns ------- np.ndarray Non-writeable.", "type": "function", "file_path": "pandas\\pandas\\core\\indexes\\multi.py", "ast_data": "FunctionDef name:_coerce_indexer_frozen arg:array_like arg:categories arg:copy arguments arg arg arg Assign Call If Assign Call Assign Return return:yes" }, { "library": "scikit-learn", "name": "get_canonical_name_git_grep", "source_code": "def get_canonical_name_git_grep(filename):\n return re.sub('\\\\.pyx(\\\\.tp)?', '', filename)", "docstring": "Return name based on filename. The goal is to return a name that can easily be matched with the output from .", "type": "function", "file_path": "scikit-learn\\build_tools\\check-meson-openmp-dependencies.py", "ast_data": "FunctionDef name:get_canonical_name_git_grep arg:filename arguments arg Return return:yes Call" }, { "library": "django", "name": "set_field_name", "source_code": "def set_field_name(self):\n self.field_name = None", "docstring": "Set the related field's name, this is not available until later stages of app loading, so set_field_name is called from set_attributes_from_rel()", "type": "method", "file_path": "django\\django\\db\\models\\fields\\reverse_related.py", "ast_data": "FunctionDef name:set_field_name arg:self arguments arg Assign" }, { "library": "scipy", "name": "_read_body_coo", "source_code": "def _read_body_coo(cursor, generalize_symmetry=True):\n from . import _fmm_core\n index_dtype = 'int32'\n if cursor.header.nrows >= 2 ** 31 or cursor.header.ncols >= 2 ** 31:\n index_dtype = 'int64'\n i = np.zeros(cursor.header.nnz, dtype=index_dtype)\n j = np.zeros(cursor.header.nnz, dtype=index_dtype)\n data = np.zeros(cursor.header.nnz, dtype=_field_to_dtype.get(cursor.header.field))\n _fmm_core.read_body_coo(cursor, i, j, data)\n if generalize_symmetry and cursor.header.symmetry != 'general':\n off_diagonal_mask = i != j\n off_diagonal_rows = i[off_diagonal_mask]\n off_diagonal_cols = j[off_diagonal_mask]\n off_diagonal_data = data[off_diagonal_mask]\n if cursor.header.symmetry == 'skew-symmetric':\n off_diagonal_data *= -1\n elif cursor.header.symmetry == 'hermitian':\n off_diagonal_data = off_diagonal_data.conjugate()\n i = np.concatenate((i, off_diagonal_cols))\n j = np.concatenate((j, off_diagonal_rows))\n data = np.concatenate((data, off_diagonal_data))\n return ((data, (i, j)), cursor.header.shape)", "docstring": "Read MatrixMarket coordinate body", "type": "function", "file_path": "scipy\\scipy\\io\\_fast_matrix_market\\__init__.py", "ast_data": "FunctionDef name:_read_body_coo arg:cursor arg:generalize_symmetry arguments arg arg Assign If BoolOp Compare Compare Assign Assign Call Assign Call Assign Call Call Call If BoolOp Compare Assign Compare Assign Assign Assign If Compare If Compare Assign Call Assign Call Assign Call Assign Call Return return:yes" }, { "library": "django", "name": "feed_extra_kwargs", "source_code": "def feed_extra_kwargs(self, obj):\n return {}", "docstring": "Return an extra keyword arguments dictionary that is used when initializing the feed generator.", "type": "method", "file_path": "django\\django\\contrib\\syndication\\views.py", "ast_data": "FunctionDef name:feed_extra_kwargs arg:self arg:obj arguments arg arg Return return:no" }, { "library": "pytorch", "name": "output", "source_code": "@compatibility(is_backward_compatible=True)\ndef output(self, target: 'Target', args: tuple[Argument, ...], kwargs: dict[str, Any]) -> Any:\n return args[0]", "docstring": "Execute an `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return: Any: The return value referenced by the output node", "type": "method", "file_path": "pytorch\\torch\\fx\\interpreter.py", "ast_data": "FunctionDef name:output arg:self arg:target arg:args arg:kwargs arguments arg arg arg arg Return return:yes Call" }, { "library": "scikit-learn", "name": "HasMethods", "source_code": "class HasMethods(_Constraint):\n\n @validate_params({'methods': [str, list]}, prefer_skip_nested_validation=True)\n def __init__(self, methods):\n super().__init__()\n if isinstance(methods, str):\n methods = [methods]\n self.methods = methods\n\n def is_satisfied_by(self, val):\n return all((callable(getattr(val, method, None)) for method in self.methods))\n\n def __str__(self):\n if len(self.methods) == 1:\n methods = f'{self.methods[0]!r}'\n else:\n methods = f'{', '.join([repr(m) for m in self.methods[:-1]])} and {self.methods[-1]!r}'\n return f'an object implementing {methods}'", "docstring": "Constraint representing objects that expose specific methods. It is useful for parameters following a protocol and where we don't want to impose an affiliation to a specific module or class. Parameters ---------- methods : str or list of str The method(s) that the object is expected to expose.", "type": "class", "file_path": "scikit-learn\\sklearn\\utils\\_param_validation.py", "ast_data": "ClassDef name:HasMethods FunctionDef name:__init__ arg:self arg:methods arguments arg arg Call Call If Call Assign Assign Call FunctionDef name:is_satisfied_by arg:self arg:val arguments arg arg Return return:yes Call Call Call FunctionDef name:__str__ arg:self arguments arg If Compare Call Assign Assign Call Call Return return:yes" }, { "library": "tensorflow", "name": "Masking", "source_code": "class Masking(Layer):\n\n def __init__(self, mask_value=0.0, **kwargs):\n super(Masking, self).__init__(**kwargs)\n self.supports_masking = True\n self.mask_value = mask_value\n self._compute_output_and_mask_jointly = True\n\n def compute_mask(self, inputs, mask=None):\n return K.any(math_ops.not_equal(inputs, self.mask_value), axis=-1)\n\n def call(self, inputs):\n boolean_mask = K.any(math_ops.not_equal(inputs, self.mask_value), axis=-1, keepdims=True)\n outputs = inputs * math_ops.cast(boolean_mask, inputs.dtype)\n outputs._keras_mask = array_ops.squeeze(boolean_mask, axis=-1)\n return outputs\n\n def compute_output_shape(self, input_shape):\n return input_shape\n\n def get_config(self):\n config = {'mask_value': self.mask_value}\n base_config = super(Masking, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))", "docstring": "Masks a sequence by using a mask value to skip timesteps. For each timestep in the input tensor (dimension #1 in the tensor), if all values in the input tensor at that timestep are equal to , then the timestep will be masked (skipped) in all downstream layers (as long as they support masking). If any downstream layer does not support masking yet receives such an input mask, an exception will be raised. Example: Consider a Numpy data array of shape , to be fed to an LSTM layer. You want to mask timestep #3 and #5 because you lack data for these timesteps. You can: - Set and - Insert a layer with before the LSTM layer: See [the masking and padding guide]( for more details.", "type": "class", "file_path": "tensorflow\\tensorflow\\python\\keras\\layers\\core.py", "ast_data": "ClassDef name:Masking FunctionDef name:__init__ arg:self arg:mask_value arguments arg arg arg Call Call Assign Assign Assign FunctionDef name:compute_mask arg:self arg:inputs arg:mask arguments arg arg arg Return return:yes Call Call FunctionDef name:call arg:self arg:inputs arguments arg arg Assign Call Call Assign Call Assign Call Return return:yes FunctionDef name:compute_output_shape arg:self arg:input_shape arguments arg arg Return return:yes FunctionDef name:get_config arg:self arguments arg Assign Assign Call Call Return return:yes Call Call Call Call Call" }, { "library": "pytorch", "name": "OutputSpec", "source_code": "class OutputSpec:\n\n def get_device(self) -> Optional[torch.device]:\n raise NotImplementedError(type(self).__name__)\n\n def storage_size(self) -> int:\n raise NotImplementedError(type(self).__name__)", "docstring": "Abstract base for Layout, MultiOutputLayout, NoneLayout. Represents the memory layout of the output of an Operation.", "type": "class", "file_path": "pytorch\\torch\\_inductor\\ir.py", "ast_data": "ClassDef name:OutputSpec FunctionDef name:get_device arg:self arguments arg Raise Call Call FunctionDef name:storage_size arg:self arguments arg Raise Call Call" }, { "library": "pytorch", "name": "pin_memory", "source_code": "def pin_memory(self, device: Union[str, torch.device]='cuda'):\n _warn_typed_storage_removal()\n return self._new_wrapped_storage(self._untyped_storage.pin_memory(device=device))", "docstring": "Copy the CPU TypedStorage to pinned memory, if it's not already pinned. Args: device (str or torch.device): The device to pin memory on (default: ``). This argument is discouraged and subject to deprecated. Returns: A pinned CPU storage.", "type": "method", "file_path": "pytorch\\torch\\storage.py", "ast_data": "FunctionDef name:pin_memory arg:self arg:device arguments arg arg Call Return return:yes Call Call" }, { "library": "django", "name": "_check_list_display_links", "source_code": "def _check_list_display_links(self, obj):\n from django.contrib.admin.options import ModelAdmin\n if obj.list_display_links is None:\n return []\n elif not isinstance(obj.list_display_links, (list, tuple)):\n return must_be('a list, a tuple, or None', option='list_display_links', obj=obj, id='admin.E110')\n elif obj.get_list_display.__func__ is ModelAdmin.get_list_display:\n return list(chain.from_iterable((self._check_list_display_links_item(obj, field_name, 'list_display_links[%d]' % index) for index, field_name in enumerate(obj.list_display_links))))\n return []", "docstring": "Check that list_display_links is a unique subset of list_display.", "type": "method", "file_path": "django\\django\\contrib\\admin\\checks.py", "ast_data": "FunctionDef name:_check_list_display_links arg:self arg:obj arguments arg arg If Compare Return return:no If Call Return return:yes Call If Compare Return return:yes Call Call Call Call Return return:no" }, { "library": "scikit-learn", "name": "_VerboseHelper", "source_code": "class _VerboseHelper(_Constraint):\n\n def __init__(self):\n super().__init__()\n self._constraints = [Interval(Integral, 0, None, closed='left'), _InstancesOf(bool), _InstancesOf(np.bool_)]\n\n def is_satisfied_by(self, val):\n return any((c.is_satisfied_by(val) for c in self._constraints))\n\n def __str__(self):\n return f'{', '.join([str(c) for c in self._constraints[:-1]])} or {self._constraints[-1]}'", "docstring": "Helper constraint for the verbose parameter. Convenience class for [Interval(Integral, 0, None, closed=\"left\"), bool, numpy.bool_]", "type": "class", "file_path": "scikit-learn\\sklearn\\utils\\_param_validation.py", "ast_data": "ClassDef name:_VerboseHelper FunctionDef name:__init__ arg:self arguments arg Call Call Assign Call Call Call FunctionDef name:is_satisfied_by arg:self arg:val arguments arg arg Return return:yes Call Call FunctionDef name:__str__ arg:self arguments arg Return return:yes Call Call" }, { "library": "scipy", "name": "strict_bounds", "source_code": "def strict_bounds(lb, ub, keep_feasible, n_vars):\n strict_lb = np.resize(lb, n_vars).astype(float)\n strict_ub = np.resize(ub, n_vars).astype(float)\n keep_feasible = np.resize(keep_feasible, n_vars)\n strict_lb[~keep_feasible] = -np.inf\n strict_ub[~keep_feasible] = np.inf\n return (strict_lb, strict_ub)", "docstring": "Remove bounds which are not asked to be kept feasible.", "type": "function", "file_path": "scipy\\scipy\\optimize\\_constraints.py", "ast_data": "FunctionDef name:strict_bounds arg:lb arg:ub arg:keep_feasible arg:n_vars arguments arg arg arg arg Assign Call Call Assign Call Call Assign Call Assign Assign Return return:yes" }, { "library": "cryptography", "name": "serialize_ssh_public_key", "source_code": "def serialize_ssh_public_key(public_key: SSHPublicKeyTypes) -> bytes:\n if isinstance(public_key, dsa.DSAPublicKey):\n warnings.warn('SSH DSA key support is deprecated and will be removed in a future release', utils.DeprecatedIn40, stacklevel=4)\n key_type = _get_ssh_key_type(public_key)\n kformat = _lookup_kformat(key_type)\n f_pub = _FragList()\n f_pub.put_sshstr(key_type)\n kformat.encode_public(public_key, f_pub)\n pub = binascii.b2a_base64(f_pub.tobytes()).strip()\n return b''.join([key_type, b' ', pub])", "docstring": "One-line public key format for OpenSSH", "type": "function", "file_path": "cryptography\\src\\cryptography\\hazmat\\primitives\\serialization\\ssh.py", "ast_data": "FunctionDef name:serialize_ssh_public_key arg:public_key arguments arg If Call Call Assign Call Assign Call Assign Call Call Call Assign Call Call Call Return return:yes Call" }, { "library": "pandas", "name": "DatelikeOps", "source_code": "class DatelikeOps(DatetimeLikeArrayMixin):\n\n @Substitution(URL='https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior')\n def strftime(self, date_format: str) -> npt.NDArray[np.object_]:\n result = self._format_native_types(date_format=date_format, na_rep=np.nan)\n if using_string_dtype():\n from pandas import StringDtype\n return pd_array(result, dtype=StringDtype(na_value=np.nan))\n return result.astype(object, copy=False)", "docstring": "Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex.", "type": "class", "file_path": "pandas\\pandas\\core\\arrays\\datetimelike.py", "ast_data": "ClassDef name:DatelikeOps FunctionDef name:strftime arg:self arg:date_format arguments arg arg Assign Call If Call Return return:yes Call Call Return return:yes Call Call" }, { "library": "pytorch", "name": "ignore", "source_code": "def ignore(drop=False, **kwargs):\n if callable(drop):\n fn = drop\n fn._torchscript_modifier = FunctionModifiers.IGNORE\n return fn\n if not isinstance(drop, bool):\n raise RuntimeError(f'Argument to @torch.jit.ignore must be a bool or a function but got {drop}')\n drop_on_export = kwargs.pop('drop_on_export', None)\n if drop_on_export:\n warnings.warn('ignore(drop_on_export=True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {}', category=FutureWarning)\n drop = drop_on_export\n elif drop:\n warnings.warn('ignore(True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {}', category=FutureWarning)\n\n def decorator(fn):\n if drop:\n fn._torchscript_modifier = FunctionModifiers.UNUSED\n else:\n fn._torchscript_modifier = FunctionModifiers.IGNORE\n return fn\n return decorator", "docstring": "This decorator indicates to the compiler that a function or method should be ignored and left as a Python function. This allows you to leave code in your model that is not yet TorchScript compatible. If called from TorchScript, ignored functions will dispatch the call to the Python interpreter. Models with ignored functions cannot be exported; use :func: instead. Example (using `debugger@ignoredebuggertraining_methodraise`. m.save(\"m.pt\") .. testcleanup:: import os os.remove('m.pt')", "type": "function", "file_path": "pytorch\\torch\\_jit_internal.py", "ast_data": "FunctionDef name:ignore arg:drop arguments arg arg If Call Assign Assign Return return:yes If Call Raise Call Assign Call If Call Assign If Call FunctionDef name:decorator arg:fn arguments arg If Assign Assign Return return:yes Return return:yes" }, { "library": "matplotlib", "name": "_get_rotate_command", "source_code": "def _get_rotate_command(lbrt):\n l, b, r, t = lbrt\n return f'{l + r:.2f} {0:.2f} translate\\n90 rotate'", "docstring": "Return a PostScript 90° rotation command for bounding box *lbrt*=(l, b, r, t).", "type": "function", "file_path": "matplotlib\\lib\\matplotlib\\backends\\backend_ps.py", "ast_data": "FunctionDef name:_get_rotate_command arg:lbrt arguments arg Assign Return return:yes" }, { "library": "pytorch", "name": "_make_copy_from_view", "source_code": "def _make_copy_from_view(fn):\n aten_fn = getattr(aten, fn.__name__)\n annotations = getattr(fn, '__annotations__', {})\n fn = out_wrapper()(aten_fn)\n\n @wraps(fn)\n def _fn(*args, out=None, **kwargs):\n result = fn(*args, out=out, **kwargs)\n if out is not None:\n return result\n return pytree.tree_map(lambda x: x.clone(memory_format=torch.contiguous_format), result)\n copy_name = f'{fn.__name__}_copy'\n _fn.__name__ = copy_name\n _fn.__annotations__.update(annotations)\n register_decomposition(getattr(aten, copy_name))(_fn)\n return _fn", "docstring": "Given a view function (e.g. torch.diagonal) generates its copy variant (e.g. torch.diagonal_copy)", "type": "function", "file_path": "pytorch\\torch\\_refs\\__init__.py", "ast_data": "FunctionDef name:_make_copy_from_view arg:fn arguments arg Assign Call Assign Call Assign Call Call FunctionDef name:_fn arguments arg arg arg Assign Call If Compare Return return:yes Return return:yes Call arguments arg Call Call Assign Assign Call Call Call Call Return return:yes" }, { "library": "scipy", "name": "skew", "source_code": "def skew(a, axis=0, bias=True):\n a, axis = _chk_asarray(a, axis)\n mean = a.mean(axis, keepdims=True)\n m2 = _moment(a, 2, axis, mean=mean)\n m3 = _moment(a, 3, axis, mean=mean)\n zero = m2 <= (np.finfo(m2.dtype).resolution * mean.squeeze(axis)) ** 2\n with np.errstate(all='ignore'):\n vals = ma.where(zero, 0, m3 / m2 ** 1.5)\n if not bias and zero is not ma.masked and (m2 is not ma.masked):\n n = a.count(axis)\n can_correct = ~zero & (n > 2)\n if can_correct.any():\n n = np.extract(can_correct, n)\n m2 = np.extract(can_correct, m2)\n m3 = np.extract(can_correct, m3)\n nval = ma.sqrt((n - 1.0) * n) / (n - 2.0) * m3 / m2 ** 1.5\n np.place(vals, can_correct, nval)\n return vals", "docstring": "Computes the skewness of a data set. Parameters ---------- a : ndarray data axis : int or None, optional Axis along which skewness is calculated. Default is 0. If None, compute over the whole array . bias : bool, optional If False, then the calculations are corrected for statistical bias. Returns ------- skewness : ndarray The skewness of values along an axis, returning 0 where all values are equal. Notes ----- For more details about , see .", "type": "function", "file_path": "scipy\\scipy\\stats\\_mstats_basic.py", "ast_data": "FunctionDef name:skew arg:a arg:axis arg:bias arguments arg arg arg Assign Call Assign Call Assign Call Assign Call Assign Compare Call Call With Call Assign Call If BoolOp Compare Compare Assign Call Assign Compare If Call Assign Call Assign Call Assign Call Assign Call Call Return return:yes" }, { "library": "tensorflow", "name": "_make_eager_execution_function", "source_code": "def _make_eager_execution_function(model, mode):\n\n def _per_replica_function(model):\n f = model._make_execution_function(mode)\n return (f.inputs, f.outputs)\n strategy = model._distribution_strategy\n global_graph = backend.get_graph()\n with global_graph.as_default(), strategy.scope():\n with backend._scratch_graph(global_graph):\n grouped = strategy.extended.call_for_each_replica(_per_replica_function, args=(get_distributed_model(model, mode),))\n grouped_inputs, grouped_outputs = grouped\n all_inputs, all_outputs, _, _ = unwrap_values(strategy, grouped_inputs, grouped_outputs, with_loss_tensor=mode != ModeKeys.PREDICT)\n return backend.function(all_inputs, all_outputs, name='eager_distributed_{}_function'.format(mode))", "docstring": "Makes function to run one step of distributed model eager execution.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\keras\\distribute\\distributed_training_utils_v1.py", "ast_data": "FunctionDef name:_make_eager_execution_function arg:model arg:mode arguments arg arg FunctionDef name:_per_replica_function arg:model arguments arg Assign Call Return return:yes Assign Assign Call With Call Call With Call Assign Call Call Assign Assign Call Compare Return return:yes Call Call" }, { "library": "sphinx", "name": "env", "source_code": "@property\ndef env(self) -> BuildEnvironment:\n return self.document.settings.env", "docstring": "Reference to the :class: object.", "type": "method", "file_path": "sphinx\\sphinx\\transforms\\__init__.py", "ast_data": "FunctionDef name:env arg:self arguments arg Return return:yes" }, { "library": "pandas", "name": "check_setitem_lengths", "source_code": "def check_setitem_lengths(indexer, value, values) -> bool:\n no_op = False\n if isinstance(indexer, (np.ndarray, list)):\n if is_list_like(value):\n if len(indexer) != len(value) and values.ndim == 1:\n if isinstance(indexer, list):\n indexer = np.array(indexer)\n if not (isinstance(indexer, np.ndarray) and indexer.dtype == np.bool_ and (indexer.sum() == len(value))):\n raise ValueError('cannot set using a list-like indexer with a different length than the value')\n if not len(indexer):\n no_op = True\n elif isinstance(indexer, slice):\n if is_list_like(value):\n if len(value) != length_of_indexer(indexer, values) and values.ndim == 1:\n raise ValueError('cannot set using a slice indexer with a different length than the value')\n if not len(value):\n no_op = True\n return no_op", "docstring": "Validate that value and indexer are the same length. An special-case is allowed for when the indexer is a boolean array and the number of true values equals the length of ``. In this case, no exception is raised. Parameters ---------- indexer : sequence Key for the setitem. value : array-like Value for the setitem. values : array-like Values being set into. Returns ------- bool Whether this is an empty listlike setting which is a no-op. Raises ------ ValueError When the indexer is an ndarray or list and the lengths don't match.", "type": "function", "file_path": "pandas\\pandas\\core\\indexers\\utils.py", "ast_data": "FunctionDef name:check_setitem_lengths arg:indexer arg:value arg:values arguments arg arg arg Assign If Call If Call If BoolOp Compare Call Call Compare If Call Assign Call If BoolOp Call Compare Compare Call Call Raise Call If Call Assign If Call If Call If BoolOp Compare Call Call Compare Raise Call If Call Assign Return return:yes" }, { "library": "django", "name": "_check_list_max_show_all", "source_code": "def _check_list_max_show_all(self, obj):\n if not isinstance(obj.list_max_show_all, int):\n return must_be('an integer', option='list_max_show_all', obj=obj, id='admin.E119')\n else:\n return []", "docstring": "Check that list_max_show_all is an integer.", "type": "method", "file_path": "django\\django\\contrib\\admin\\checks.py", "ast_data": "FunctionDef name:_check_list_max_show_all arg:self arg:obj arguments arg arg If Call Return return:yes Call Return return:no" }, { "library": "tensorflow", "name": "get_error", "source_code": "def get_error(self):\n self._check_status()\n return (self._error_code, self._error_message)", "docstring": "Returns (TF Error Code, Error Message) from RPC Response. This call will block for RPC result.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\distribute\\experimental\\rpc\\rpc_ops.py", "ast_data": "FunctionDef name:get_error arg:self arguments arg Call Return return:yes" }, { "library": "tensorflow", "name": "reopen", "source_code": "def reopen(self):\n if self._closed:\n self._closed = False\n self._session.run(self._init_op)", "docstring": "Reopens the EventFileWriter. Can be called after to add more events in the same directory. The events will go into a new events file. Does nothing if the EventFileWriter was not closed.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\summary\\writer\\event_file_writer_v2.py", "ast_data": "FunctionDef name:reopen arg:self arguments arg If Assign Call" }, { "library": "tensorflow", "name": "choose_from_datasets_v2", "source_code": "@deprecation.deprecated(None, 'Use `tf.data.Dataset.choose_from_datasets(...)` instead. Note that, unlike the experimental endpoint, the non-experimental endpoint sets `stop_on_empty_dataset=True` by default. You should set this argument explicitly in case you would like to match the behavior of the experimental endpoint.')\n@tf_export('data.experimental.choose_from_datasets', v1=[])\ndef choose_from_datasets_v2(datasets, choice_dataset, stop_on_empty_dataset=False):\n return dataset_ops.Dataset.choose_from_datasets(datasets=datasets, choice_dataset=choice_dataset, stop_on_empty_dataset=stop_on_empty_dataset)", "docstring": "Creates a dataset that deterministically chooses elements from . For example, given the following datasets: The elements of will be: Args: datasets: A non-empty list of objects with compatible structure. choice_dataset: A of scalar tensors between and . stop_on_empty_dataset: If , selection stops if it encounters an empty dataset. If , it skips empty datasets. It is recommended to set it to . Otherwise, the selected elements start off as the user intends, but may change as input datasets become empty. This can be difficult to detect since the dataset starts off looking correct. Default to for backward compatibility. Returns: A dataset that interleaves elements from according to the values of . Raises: TypeError: If or has the wrong type. ValueError: If is empty.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\data\\experimental\\ops\\interleave_ops.py", "ast_data": "FunctionDef name:choose_from_datasets_v2 arg:datasets arg:choice_dataset arg:stop_on_empty_dataset arguments arg arg arg Return return:yes Call Call Call" }, { "library": "matplotlib", "name": "__init__", "source_code": "def __init__(self, vcenter=0, halfrange=None, clip=False):\n super().__init__(vmin=None, vmax=None, clip=clip)\n self._vcenter = vcenter\n self.halfrange = halfrange", "docstring": "Normalize symmetrical data around a center (0 by default). Unlike , applies an equal rate of change around the center. Useful when mapping symmetrical data around a conceptual center e.g., data that range from -2 to 4, with 0 as the midpoint, and with equal rates of change around that midpoint. Parameters ---------- vcenter : float, default: 0 The data value that defines ``. This behavior is usually desirable, as colormaps can mark these *under* and *over* values with specific colors. If clipping is on, values below *vmin* are mapped to 0 and values above *vmax* are mapped to 1. Such values become indistinguishable from regular boundary values, which may cause misinterpretation of the data. Examples -------- This maps data values -2 to 0.25, 0 to 0.5, and 4 to 1.0 (assuming equal rates of change above and below 0.0): >>> import matplotlib.colors as mcolors >>> norm = mcolors.CenteredNorm(halfrange=4.0) >>> data = [-2., 0., 4.] >>> norm(data) array([0.25, 0.5 , 1. ])", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\colors.py", "ast_data": "FunctionDef name:__init__ arg:self arg:vcenter arg:halfrange arg:clip arguments arg arg arg arg Call Call Assign Assign" }, { "library": "tensorflow", "name": "experimental_between_graph", "source_code": "@property\ndef experimental_between_graph(self):\n raise NotImplementedError('must be implemented in descendants')", "docstring": "Whether the strategy uses between-graph replication or not. This is expected to return a constant value that will not be changed throughout its life cycle.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\distribute\\distribute_lib.py", "ast_data": "FunctionDef name:experimental_between_graph arg:self arguments arg Raise Call" }, { "library": "django", "name": "is_url", "source_code": "def is_url(self, template):\n if ':' not in template:\n return False\n scheme = template.split(':', 1)[0].lower()\n return scheme in self.url_schemes", "docstring": "Return True if the name looks like a URL.", "type": "method", "file_path": "django\\django\\core\\management\\templates.py", "ast_data": "FunctionDef name:is_url arg:self arg:template arguments arg arg If Compare Return return:yes Assign Call Call Return return:yes Compare" }, { "library": "kornia", "name": "__init__", "source_code": "def __init__(self, num_dims: int, num_freqs: int, log_space: bool=False) -> None:\n super().__init__()\n self._num_dims = num_dims\n self._embed_fns = [lambda x: x]\n freq_bands: Tensor\n if log_space:\n freq_bands = 2.0 ** torch.linspace(0.0, num_freqs - 1, num_freqs)\n else:\n freq_bands = torch.linspace(2.0 ** 0.0, 2.0 ** (num_freqs - 1), num_freqs)\n for freq in freq_bands:\n self._embed_fns.append(partial(_torch_sin, freq=freq))\n self._embed_fns.append(partial(_torch_cos, freq=freq))\n self._num_encoded_dims = self._num_dims * len(self._embed_fns)", "docstring": "Initialize positional encoder. Args: num_dims: Number of input dimensions (channels): int num_freqs: Number of frequency bands for encoding span: int log_space: Whether frequency sampling should be log spaced: bool", "type": "method", "file_path": "kornia\\kornia\\nerf\\positional_encoder.py", "ast_data": "FunctionDef name:__init__ arg:self arg:num_dims arg:num_freqs arg:log_space arguments arg arg arg arg Call Call Assign Assign arguments arg If Assign Call Assign Call For Call Call Call Call Assign Call" }, { "library": "tensorflow", "name": "get_signature_def_map", "source_code": "def get_signature_def_map(saved_model_dir, tag_set):\n meta_graph = saved_model_utils.get_meta_graph_def(saved_model_dir, tag_set)\n return meta_graph.signature_def", "docstring": "Gets SignatureDef map from a MetaGraphDef in a SavedModel. Returns the SignatureDef map for the given tag-set in the SavedModel directory. Args: saved_model_dir: Directory containing the SavedModel to inspect or execute. tag_set: Group of tag(s) of the MetaGraphDef with the SignatureDef map, in string format, separated by ','. For tag-set contains multiple tags, all tags must be passed in. Returns: A SignatureDef map that maps from string keys to SignatureDefs.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\tools\\saved_model_cli.py", "ast_data": "FunctionDef name:get_signature_def_map arg:saved_model_dir arg:tag_set arguments arg arg Assign Call Return return:yes" }, { "library": "django", "name": "get_source_fields", "source_code": "def get_source_fields(self):\n return [e._output_field_or_none for e in self.get_source_expressions()]", "docstring": "Return the underlying field types used by this aggregate.", "type": "method", "file_path": "django\\django\\db\\models\\expressions.py", "ast_data": "FunctionDef name:get_source_fields arg:self arguments arg Return return:yes Call" }, { "library": "matplotlib", "name": "edit_outer_margin_mins", "source_code": "def edit_outer_margin_mins(self, margin, ss):\n self.edit_margin_min('left', margin['left'], ss.colspan.start)\n self.edit_margin_min('leftcb', margin['leftcb'], ss.colspan.start)\n self.edit_margin_min('right', margin['right'], ss.colspan.stop - 1)\n self.edit_margin_min('rightcb', margin['rightcb'], ss.colspan.stop - 1)\n self.edit_margin_min('top', margin['top'], ss.rowspan.start)\n self.edit_margin_min('topcb', margin['topcb'], ss.rowspan.start)\n self.edit_margin_min('bottom', margin['bottom'], ss.rowspan.stop - 1)\n self.edit_margin_min('bottomcb', margin['bottomcb'], ss.rowspan.stop - 1)", "docstring": "Edit all four margin minimums in one statement. Parameters ---------- margin : dict size of margins in a dict with keys 'left', 'right', 'bottom', 'top' ss : SubplotSpec defines the subplotspec these margins should be applied to", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\_layoutgrid.py", "ast_data": "FunctionDef name:edit_outer_margin_mins arg:self arg:margin arg:ss arguments arg arg arg Call Call Call Call Call Call Call Call" }, { "library": "tensorflow", "name": "_ragged_tensor_binary_crossentropy", "source_code": "@dispatch.dispatch_for_types(binary_crossentropy, ragged_tensor.RaggedTensor)\ndef _ragged_tensor_binary_crossentropy(y_true, y_pred, from_logits=False, label_smoothing=0, axis=-1):\n fn = functools.partial(binary_crossentropy, from_logits=from_logits, label_smoothing=label_smoothing, axis=axis)\n return _ragged_tensor_apply_loss(fn, y_true, y_pred)", "docstring": "Implements support for handling RaggedTensors. Args: y_true: Tensor of one-hot true targets. y_pred: Tensor of predicted targets. from_logits: Whether is expected to be a logits tensor. By default, we assume that encodes a probability distribution. label_smoothing: Float in [0, 1]. If > then smooth the labels. For example, if , use for non-target labels and for target labels. axis: Axis along which to compute crossentropy. Returns: Binary crossentropy loss value. Expected shape: (batch, sequence_len) with sequence_len being variable per batch. Return shape: (batch,); returns the per batch mean of the loss values. When used by BinaryCrossentropy() with the default reduction (SUM_OVER_BATCH_SIZE), the reduction averages the per batch losses over the number of batches.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\keras\\losses.py", "ast_data": "FunctionDef name:_ragged_tensor_binary_crossentropy arg:y_true arg:y_pred arg:from_logits arg:label_smoothing arg:axis arguments arg arg arg arg arg Assign Call Return return:yes Call Call" }, { "library": "tensorflow", "name": "_create_weighted_sum", "source_code": "def _create_weighted_sum(column, builder, units, sparse_combiner, weight_collections, trainable, weight_var=None):\n if isinstance(column, _CategoricalColumn):\n return _create_categorical_column_weighted_sum(column=column, builder=builder, units=units, sparse_combiner=sparse_combiner, weight_collections=weight_collections, trainable=trainable, weight_var=weight_var)\n else:\n return _create_dense_column_weighted_sum(column=column, builder=builder, units=units, weight_collections=weight_collections, trainable=trainable, weight_var=weight_var)", "docstring": "Creates a weighted sum for a dense/categorical column for linear_model.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\feature_column\\feature_column.py", "ast_data": "FunctionDef name:_create_weighted_sum arg:column arg:builder arg:units arg:sparse_combiner arg:weight_collections arg:trainable arg:weight_var arguments arg arg arg arg arg arg arg If Call Return return:yes Call Return return:yes Call" }, { "library": "pytorch", "name": "can_inline_constant", "source_code": "@staticmethod\ndef can_inline_constant(t: torch.Tensor) -> bool:\n return len(t.shape) == 1 and t.shape[0] <= 8", "docstring": "True if this is a small constant attr that will be inlined.", "type": "method", "file_path": "pytorch\\torch\\_inductor\\graph.py", "ast_data": "FunctionDef name:can_inline_constant arg:t arguments arg Return return:yes BoolOp Compare Call Compare" }, { "library": "scipy", "name": "f3", "source_code": "def f3(x):\n return x * (x - 1.0) * (x - 2.0) * (x - 3.0)", "docstring": "A quartic with roots at 0, 1, 2 and 3", "type": "function", "file_path": "scipy\\scipy\\optimize\\_tstutils.py", "ast_data": "FunctionDef name:f3 arg:x arguments arg Return return:yes" }, { "library": "tensorflow", "name": "SlicingOpLambda", "source_code": "class SlicingOpLambda(TFOpLambda):\n\n @trackable.no_automatic_dependency_tracking\n def __init__(self, function, **kwargs):\n super(SlicingOpLambda, self).__init__(function, **kwargs)\n original_call = self.call\n\n def _call_wrapper(*args, **kwargs):\n new_args = []\n for arg in args:\n arg = _dict_to_slice(arg)\n if isinstance(arg, (list, tuple)):\n new_arg = []\n for sub_arg in arg:\n new_arg.append(_dict_to_slice(sub_arg))\n arg = new_arg\n new_args.append(arg)\n new_kwargs = {}\n for key, value in kwargs.items():\n value = _dict_to_slice(value)\n if isinstance(value, (list, tuple)):\n new_value = []\n for v in value:\n new_value.append(_dict_to_slice(v))\n value = new_value\n new_kwargs[key] = value\n return original_call(*new_args, **new_kwargs)\n self.call = tf_decorator.make_decorator(original_call, _call_wrapper)", "docstring": "Wraps TF API symbols in a object. It is inserted by the Functional API construction whenever users call a supported TF symbol on KerasTensors. Like Lambda layers, this layer tries to raise warnings when it detects users explicitly use variables in the call. (To let them know that the layer will not capture the variables). This is useful in the case where users do something like: x = keras.Input(...) y = tf.Variable(...) out = x * tf_variable", "type": "class", "file_path": "tensorflow\\tensorflow\\python\\keras\\layers\\core.py", "ast_data": "ClassDef name:SlicingOpLambda FunctionDef name:__init__ arg:self arg:function arguments arg arg arg Call Call Assign FunctionDef name:_call_wrapper arguments arg arg Assign For Assign Call If Call Assign For Call Call Assign Call Assign For Call Assign Call If Call Assign For Call Call Assign Assign Return return:yes Call Assign Call" }, { "library": "numpy", "name": "packbits", "source_code": "@array_function_from_c_func_and_dispatcher(_multiarray_umath.packbits)\ndef packbits(a, axis=None, bitorder='big'):\n return (a,)", "docstring": "packbits(a, /, axis=None, bitorder='big') Packs the elements of a binary-valued array into bits in a uint8 array. The result is padded to full bytes by inserting zero bits at the end. Parameters ---------- a : array_like An array of integers or booleans whose elements should be packed to bits. axis : int, optional The dimension over which bit-packing is done. `packedaxis` is None, in which case the output is 1-D). See Also -------- unpackbits: Unpacks elements of a uint8 array into a binary-valued output array. Examples -------- >>> import numpy as np >>> a = np.array([[[1,0,1], ... [0,1,0]], ... [[1,1,0], ... [0,0,1]]]) >>> b = np.packbits(a, axis=-1) >>> b array([[[160], [ 64]], [[192], [ 32]]], dtype=uint8) Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, and 32 = 0010 0000.", "type": "function", "file_path": "numpy\\numpy\\_core\\multiarray.py", "ast_data": "FunctionDef name:packbits arg:a arg:axis arg:bitorder arguments arg arg arg Return return:yes Call" }, { "library": "django", "name": "lang_stats", "source_code": "def lang_stats(resources=None, languages=None, verbosity=0):\n locale_dirs = _get_locale_dirs(resources)\n for name, dir_ in locale_dirs:\n print(\"\\nShowing translations stats for '%s':\" % name)\n langs = sorted((d for d in os.listdir(dir_) if not d.startswith('_')))\n for lang in langs:\n if languages and lang not in languages:\n continue\n po_path = '{path}/{lang}/LC_MESSAGES/django{ext}.po'.format(path=dir_, lang=lang, ext='js' if name.endswith('-js') else '')\n p = run(['msgfmt', '-vc', '-o', '/dev/null', po_path], capture_output=True, env={'LANG': 'C'}, encoding='utf-8', verbosity=verbosity)\n if p.returncode == 0:\n print('%s: %s' % (lang, p.stderr.strip()))\n else:\n print('Errors happened when checking %s translation for %s:\\n%s' % (lang, name, p.stderr))", "docstring": "Output language statistics of committed translation files for each Django catalog. If resources is provided, it should be a list of translation resource to limit the output (e.g. ['core', 'gis']).", "type": "function", "file_path": "django\\scripts\\manage_translations.py", "ast_data": "FunctionDef name:lang_stats arg:resources arg:languages arg:verbosity arguments arg arg arg Assign Call For Call Assign Call Call Call For If BoolOp Compare Assign Call Call Assign Call If Compare Call Call Call" }, { "library": "pytorch", "name": "_map_blocks_to_lifted_attrs", "source_code": "def _map_blocks_to_lifted_attrs(entry):\n arguments: set[str] = set()\n for node in entry.nodes():\n for block in node.blocks():\n arguments = arguments.union(_map_blocks_to_lifted_attrs(block))\n if node.kind() == 'prim::GetAttr':\n irv_name = node.output().debugName()\n if irv_name not in set(node_to_parent_map.values()):\n arguments.add(construct_fqn(irv_name, node_to_parent_map, node_to_attr_name))\n if not isinstance(entry, torch._C.Graph):\n blocks_to_lifted_attrs[entry] = arguments\n return arguments", "docstring": "Walk the graph in a bottom-up fashion to build the expected to be lifted arguments for each block.", "type": "function", "file_path": "pytorch\\torch\\_export\\converter.py", "ast_data": "FunctionDef name:_map_blocks_to_lifted_attrs arg:entry arguments arg Call For Call For Call Assign Call Call If Compare Call Assign Call Call If Compare Call Call Call Call If Call Assign Return return:yes" }, { "library": "seaborn", "name": "_version_predates", "source_code": "def _version_predates(lib: ModuleType, version: str) -> bool:\n return Version(lib.__version__) < Version(version)", "docstring": "Helper function for checking version compatibility.", "type": "function", "file_path": "seaborn\\seaborn\\utils.py", "ast_data": "FunctionDef name:_version_predates arg:lib arg:version arguments arg arg Return return:yes Compare Call Call" }, { "library": "django", "name": "validate", "source_code": "def validate(self):\n capi.srs_validate(self.ptr)", "docstring": "Check to see if the given spatial reference is valid.", "type": "method", "file_path": "django\\django\\contrib\\gis\\gdal\\srs.py", "ast_data": "FunctionDef name:validate arg:self arguments arg Call" }, { "library": "tensorflow", "name": "range_dimension", "source_code": "@property\ndef range_dimension(self):\n if self.shape.dims:\n return self.shape.dims[-2]\n else:\n return tensor_shape.Dimension(None)", "docstring": "Dimension (in the sense of vector spaces) of the range of this operator. If this operator acts like the batch matrix with , then this returns . Returns: object.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\ops\\linalg\\linear_operator.py", "ast_data": "FunctionDef name:range_dimension arg:self arguments arg If Return return:yes Return return:yes Call" }, { "library": "kornia", "name": "hg", "source_code": "def hg(cfg: HourglassConfig) -> HourglassNet:\n return HourglassNet(Bottleneck2D, head=cfg.head, depth=cfg.depth, num_stacks=cfg.num_stacks, num_blocks=cfg.num_blocks, num_classes=cfg.num_classes, input_channels=cfg.input_channels)", "docstring": "Create HourglassNet.", "type": "function", "file_path": "kornia\\kornia\\feature\\sold2\\backbones.py", "ast_data": "FunctionDef name:hg arg:cfg arguments arg Return return:yes Call" }, { "library": "tensorflow", "name": "size", "source_code": "@dispatch.dispatch_for_types(array_ops.size, StructuredTensor)\ndef size(input, name=None, out_type=None):\n if out_type is None:\n if flags.config().tf_shape_default_int64.value():\n out_type = dtypes.int64\n else:\n out_type = dtypes.int32\n with ops.name_scope(name, 'size', [input]) as name:\n if not input.row_partitions:\n if input.nrows() is not None:\n return math_ops.cast(input.nrows(), out_type)\n else:\n return math_ops.cast(1, out_type)\n nvals = input.row_partitions[-1].nvals()\n if nvals is None or out_type is None:\n return nvals\n return math_ops.cast(nvals, dtype=out_type)", "docstring": "Returns the size of a tensor.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\ops\\structured\\structured_array_ops.py", "ast_data": "FunctionDef name:size arg:input arg:name arg:out_type arguments arg arg arg If Compare If Call Call Assign Assign With Call If If Compare Call Return return:yes Call Call Return return:yes Call Assign Call If BoolOp Compare Compare Return return:yes Return return:yes Call Call" }, { "library": "pytorch", "name": "dont_skip_tracing", "source_code": "def dont_skip_tracing(fn=None):\n ctx = patch_dynamo_config(dont_skip_tracing=True)\n if fn:\n return ctx(fn)\n return ctx", "docstring": "Context manager/decorator to trace into functions intentionally marked by developers to be skipped when tracing. This decorator will also apply to recursively invoked functions.", "type": "function", "file_path": "pytorch\\torch\\_dynamo\\decorators.py", "ast_data": "FunctionDef name:dont_skip_tracing arg:fn arguments arg Assign Call If Return return:yes Call Return return:yes" }, { "library": "tensorflow", "name": "_merge_with", "source_code": "def _merge_with(self, other: 'DynamicRaggedShape') -> 'DynamicRaggedShape':\n max_num_row_partitions = max(self.num_row_partitions, other.num_row_partitions)\n a = self._with_num_row_partitions(max_num_row_partitions)\n b = other._with_num_row_partitions(max_num_row_partitions)\n new_row_partitions = [rp_a._merge_precomputed_encodings(rp_b) for rp_a, rp_b in zip(a._row_partitions, b._row_partitions)]\n new_dtype = b.dtype if a.dtype == dtypes.int32 else dtypes.int64\n new_static_inner_shape = a._static_inner_shape.merge_with(b._static_inner_shape)\n new_inner_shape = a._inner_shape\n return DynamicRaggedShape(new_row_partitions, new_inner_shape, new_dtype, True, new_static_inner_shape)", "docstring": "Merge two shapes that are equal modulo num_row_partitions. The resulting num_row_partitions is the maximum of the two num_row_partitions. Args: other: a DynamicRaggedShape representing the same shape with a possibly different number of row partitions. Returns: A DynamicRaggedShape with the same shape and the maximum of the num_row_partitions of the two shapes.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\ops\\ragged\\dynamic_ragged_shape.py", "ast_data": "FunctionDef name:_merge_with arg:self arg:other arguments arg arg Assign Call Assign Call Assign Call Assign Call Call Assign Compare Assign Call Assign Return return:yes Call" }, { "library": "django", "name": "getlist", "source_code": "def getlist(self, key, default=None):\n return self._getlist(key, default, force_list=True)", "docstring": "Return the list of values for the key. If key doesn't exist, return a default value.", "type": "method", "file_path": "django\\django\\utils\\datastructures.py", "ast_data": "FunctionDef name:getlist arg:self arg:key arg:default arguments arg arg arg Return return:yes Call" }, { "library": "pandas", "name": "all", "source_code": "def all(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs) -> np.bool_ | NAType:\n nv.validate_all((), kwargs)\n values = self._data.copy()\n np.putmask(values, self._mask, self.dtype._truthy_value)\n result = values.all(axis=axis)\n if skipna:\n return result\n elif not result or len(self) == 0 or (not self._mask.any()):\n return result\n else:\n return self.dtype.na_value", "docstring": "Return whether all elements are truthy. Returns True unless there is at least one element that is falsey. By default, NAs are skipped. If `Kleene logic skipnaskipnapandas.NA` is True or False influences the result): >>> pd.array([True, True, pd.NA]).all(skipna=False) >>> pd.array([1, 1, pd.NA]).all(skipna=False) >>> pd.array([True, False, pd.NA]).all(skipna=False) np.False_ >>> pd.array([1, 0, pd.NA]).all(skipna=False) np.False_", "type": "method", "file_path": "pandas\\pandas\\core\\arrays\\masked.py", "ast_data": "FunctionDef name:all arg:self arguments arg arg arg arg Call Assign Call Call Assign Call If Return return:yes If BoolOp Compare Call Call Return return:yes Return return:yes" }, { "library": "pytorch", "name": "buffers", "source_code": "def buffers(self, recurse: bool=True) -> Iterator[Tensor]:\n for _, buf in self.named_buffers(recurse=recurse):\n yield buf", "docstring": "Return an iterator over module buffers. Args: recurse (bool): if True, then yields buffers of this module and all submodules. Otherwise, yields only buffers that are direct members of this module. Yields: torch.Tensor: module buffer Example:: >>> # xdoctest: +SKIP(\"undefined vars\") >>> for buf in model.buffers(): >>> print(type(buf), buf.size()) (20L,) (20L, 1L, 5L, 5L)", "type": "method", "file_path": "pytorch\\torch\\nn\\modules\\module.py", "ast_data": "FunctionDef name:buffers arg:self arg:recurse arguments arg arg For Call" }, { "library": "matplotlib", "name": "Add", "source_code": "class Add(_Base):\n\n def __init__(self, a, b):\n self._a = a\n self._b = b\n\n def get_size(self, renderer):\n a_rel_size, a_abs_size = self._a.get_size(renderer)\n b_rel_size, b_abs_size = self._b.get_size(renderer)\n return (a_rel_size + b_rel_size, a_abs_size + b_abs_size)", "docstring": "Sum of two sizes.", "type": "class", "file_path": "matplotlib\\lib\\mpl_toolkits\\axes_grid1\\axes_size.py", "ast_data": "ClassDef name:Add FunctionDef name:__init__ arg:self arg:a arg:b arguments arg arg arg Assign Assign FunctionDef name:get_size arg:self arg:renderer arguments arg arg Assign Call Assign Call Return return:yes" }, { "library": "tensorflow", "name": "_should_act_as_resource_variable", "source_code": "def _should_act_as_resource_variable(self):\n pass", "docstring": "Pass resource_variable_ops.is_resource_variable check.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\distribute\\ps_values.py", "ast_data": "FunctionDef name:_should_act_as_resource_variable arg:self arguments arg" }, { "library": "pandas", "name": "_list_of_dict_to_arrays", "source_code": "def _list_of_dict_to_arrays(data: list[dict], columns: Index | None) -> tuple[np.ndarray, Index]:\n if columns is None:\n gen = (list(x.keys()) for x in data)\n sort = not any((isinstance(d, dict) for d in data))\n pre_cols = lib.fast_unique_multiple_list_gen(gen, sort=sort)\n columns = ensure_index(pre_cols)\n data = [d if type(d) is dict else dict(d) for d in data]\n content = lib.dicts_to_array(data, list(columns))\n return (content, columns)", "docstring": "Convert list of dicts to numpy arrays if is not passed, column names are inferred from the records - for OrderedDict and dicts, the column names match the key insertion-order from the first record to the last. - For other kinds of dict-likes, the keys are lexically sorted. Parameters ---------- data : iterable collection of records (OrderedDict, dict) columns: iterables or None Returns ------- content : np.ndarray[object, ndim=2] columns : Index", "type": "function", "file_path": "pandas\\pandas\\core\\internals\\construction.py", "ast_data": "FunctionDef name:_list_of_dict_to_arrays arg:data arg:columns arguments arg arg If Compare Assign Call Call Assign Call Call Assign Call Assign Call Assign Compare Call Call Assign Call Call Return return:yes" }, { "library": "pandas", "name": "_identify_group", "source_code": "def _identify_group(self, key: str, append: bool) -> Node:\n group = self.get_node(key)\n assert self._handle is not None\n if group is not None and (not append):\n self._handle.remove_node(group, recursive=True)\n group = None\n if group is None:\n group = self._create_nodes_and_group(key)\n return group", "docstring": "Identify HDF5 group based on key, delete/create group if needed.", "type": "method", "file_path": "pandas\\pandas\\io\\pytables.py", "ast_data": "FunctionDef name:_identify_group arg:self arg:key arg:append arguments arg arg arg Assign Call Compare If BoolOp Compare Call Assign If Compare Assign Call Return return:yes" }, { "library": "django", "name": "now", "source_code": "def now():\n return datetime.now(tz=UTC if settings.USE_TZ else None)", "docstring": "Return an aware or naive datetime.datetime, depending on settings.USE_TZ.", "type": "function", "file_path": "django\\django\\utils\\timezone.py", "ast_data": "FunctionDef name:now arguments Return return:yes Call" }, { "library": "pytorch", "name": "stream", "source_code": "def stream(stream: Optional['torch.mtia.Stream']) -> StreamContext:\n return StreamContext(stream)", "docstring": "Wrap around the Context-manager StreamContext that selects a given stream. Arguments: stream (Stream): selected stream. This manager is a no-op if it's ``. .. note:: In eager mode stream is of type Stream class while in JIT it doesn't support torch.mtia.stream", "type": "function", "file_path": "pytorch\\torch\\mtia\\__init__.py", "ast_data": "FunctionDef name:stream arg:stream arguments arg Return return:yes Call" }, { "library": "tensorflow", "name": "tuple", "source_code": "@tf_export(v1=['tuple'])\n@dispatch.add_dispatch_support\ndef tuple(tensors, name=None, control_inputs=None):\n if context.executing_eagerly():\n return tensors\n with ops.name_scope(name, 'tuple', tensors) as name:\n tensors = [t if isinstance(t, ops.Operation) or tensor_util.is_tf_type(t) or t is None else ops.convert_to_tensor(t) for t in tensors]\n gating_ops = [t if isinstance(t, ops.Operation) else t.op for t in tensors if t is not None]\n if control_inputs:\n for c in control_inputs:\n if isinstance(c, tensor_lib.Tensor):\n c = c.op\n elif not isinstance(c, ops.Operation):\n raise TypeError(f\"'control_inputs' must only contain Operation or Tensor. Received: {type(c)}\")\n gating_ops.append(c)\n gating_ops = sorted(set(gating_ops), key=lambda op: op._id)\n if not gating_ops:\n raise ValueError(f\"'tensors' must have at least one Tensor. Received: {tensors}.\")\n gate = group(*gating_ops)\n tpl = []\n for t in tensors:\n if tensor_util.is_tf_type(t):\n tpl.append(with_dependencies([gate], t))\n elif isinstance(t, ops.Operation):\n with ops.control_dependencies([gate]):\n tpl.append(group(t))\n else:\n tpl.append(None)\n return tpl", "docstring": "Group tensors together. This creates a tuple of tensors with the same values as the argument, except that the value of each tensor is only returned after the values of all tensors have been computed. contains additional ops that have to finish before this op finishes, but whose outputs are not returned. This can be used as a \"join\" mechanism for parallel computations: all the argument tensors can be computed in parallel, but the values of any tensor returned by are only available after all the parallel computations are done. See also and . Args: tensors: A list of s or , some entries can be . name: (optional) A name to use as a for the operation. control_inputs: List of additional ops to finish before returning. Returns: Same as . Raises: ValueError: If does not contain any or . TypeError: If is not a list of or objects.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\ops\\control_flow_ops.py", "ast_data": "FunctionDef name:tuple arg:tensors arg:name arg:control_inputs arguments arg arg arg If Call Return return:yes With Call Assign BoolOp Call Call Compare Call Assign Call Compare If For If Call Assign If Call Raise Call Call Call Assign Call Call arguments arg If Raise Call Assign Call Assign For If Call Call Call If Call With Call Call Call Call Return return:yes Call" }, { "library": "pandas", "name": "f", "source_code": "def f(self, node, *args, **kwargs):\n return partial(op_class, op_symbol, *args, **kwargs)", "docstring": "Return a partial function with an Op subclass with an operator already passed. Returns ------- callable", "type": "function", "file_path": "pandas\\pandas\\core\\computation\\expr.py", "ast_data": "FunctionDef name:f arg:self arg:node arguments arg arg arg arg Return return:yes Call" }, { "library": "pytorch", "name": "use_mem_pool", "source_code": "@contextlib.contextmanager\ndef use_mem_pool(pool: MemPool, device: 'Device'=None):\n ctx = MemPoolContext(pool)\n device_index = torch.cuda.current_device() if device is None else _get_device_index(device)\n _cuda_beginAllocateCurrentThreadToPool(device_index, pool.id)\n try:\n yield\n finally:\n _cuda_endAllocateToPool(device_index, pool.id)\n _cuda_releasePool(device_index, pool.id)\n del ctx", "docstring": "A context manager that routes allocations to a given pool. Args: pool(torch.cuda.MemPool): a MemPool object to be made active so that allocations route to this pool. device (torch.device or int, optional): selected device. Uses MemPool on the current device, given by :func:, if :attr: is `` (default). .. note:: This context manager makes only current thread's allocations route to the given pool. If a new thread is spawned inside the context manager (e.g. by calling backward) the allocations in that thread will not route to the given pool.", "type": "function", "file_path": "pytorch\\torch\\cuda\\memory.py", "ast_data": "FunctionDef name:use_mem_pool arg:pool arg:device arguments arg arg Assign Call Assign Compare Call Call Call Try Call Call" }, { "library": "tensorflow", "name": "parse_expression", "source_code": "def parse_expression(src):\n src = STANDARD_PREAMBLE + src.strip()\n node = parse(src, preamble_len=STANDARD_PREAMBLE_LEN, single_node=True)\n if __debug__:\n if not isinstance(node, gast.Expr):\n raise ValueError('expected exactly one node of type Expr, got {}'.format(node))\n return node.value", "docstring": "Returns the AST of given identifier. Args: src: A piece of code that represents a single Python expression Returns: A gast.AST object. Raises: ValueError: if src does not consist of a single Expression.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\autograph\\pyct\\parser.py", "ast_data": "FunctionDef name:parse_expression arg:src arguments arg Assign Call Assign Call If If Call Raise Call Call Return return:yes" }, { "library": "sphinx", "name": "add_builder", "source_code": "def add_builder(self, builder: type[Builder], override: bool=False) -> None:\n self.registry.add_builder(builder, override=override)", "docstring": "Register a new builder. :param builder: A builder class :param override: If true, install the builder forcedly even if another builder is already installed as the same name .. versionchanged:: 1.8 Add *override* keyword.", "type": "method", "file_path": "sphinx\\sphinx\\application.py", "ast_data": "FunctionDef name:add_builder arg:self arg:builder arg:override arguments arg arg arg Call" }, { "library": "authlib", "name": "validate_request_object_encryption_alg", "source_code": "def validate_request_object_encryption_alg(self):\n self._validate_claim_value('request_object_encryption_alg')", "docstring": "JWE [JWE] alg algorithm [JWA] the RP is declaring that it may use for encrypting Request Objects sent to the OP. This parameter SHOULD be included when symmetric encryption will be used, since this signals to the OP that a client_secret value needs to be returned from which the symmetric key will be derived, that might not otherwise be returned. The RP MAY still use other supported encryption algorithms or send unencrypted Request Objects, even when this parameter is present. If both signing and encryption are requested, the Request Object will be signed then encrypted, with the result being a Nested JWT, as defined in [JWT]. The default, if omitted, is that the RP is not declaring whether it might encrypt any Request Objects.", "type": "method", "file_path": "authlib\\authlib\\oidc\\registration\\claims.py", "ast_data": "FunctionDef name:validate_request_object_encryption_alg arg:self arguments arg Call" }, { "library": "pytorch", "name": "fetch_args_kwargs_from_env", "source_code": "@compatibility(is_backward_compatible=True)\ndef fetch_args_kwargs_from_env(self, n: Node) -> tuple[tuple, dict]:\n args = self.map_nodes_to_values(n.args, n)\n assert isinstance(args, tuple)\n kwargs = self.map_nodes_to_values(n.kwargs, n)\n assert isinstance(kwargs, dict)\n return (args, kwargs)", "docstring": "Fetch the concrete values of ``.", "type": "method", "file_path": "pytorch\\torch\\fx\\interpreter.py", "ast_data": "FunctionDef name:fetch_args_kwargs_from_env arg:self arg:n arguments arg arg Assign Call Call Assign Call Call Return return:yes Call" }, { "library": "pytorch", "name": "all_paths", "source_code": "def all_paths(self, src: str, dst: str) -> str:\n return self.dependency_graph.all_paths(src, dst)", "docstring": "Return a dot representation of the subgraph that has all paths from src to dst. Returns: A dot representation containing all paths from src to dst. (", "type": "method", "file_path": "pytorch\\torch\\package\\package_exporter.py", "ast_data": "FunctionDef name:all_paths arg:self arg:src arg:dst arguments arg arg arg Return return:yes Call" }, { "library": "django", "name": "get_group_permissions", "source_code": "def get_group_permissions(self, user_obj, obj=None):\n return self._get_permissions(user_obj, obj, 'group')", "docstring": "Return a set of permission strings the user has from the groups they belong.", "type": "method", "file_path": "django\\django\\contrib\\auth\\backends.py", "ast_data": "FunctionDef name:get_group_permissions arg:self arg:user_obj arg:obj arguments arg arg arg Return return:yes Call" }, { "library": "django", "name": "_get_validation_exclusions", "source_code": "def _get_validation_exclusions(self):\n exclude = set()\n for f in self.instance._meta.fields:\n field = f.name\n if field not in self.fields:\n exclude.add(f.name)\n elif self._meta.fields and field not in self._meta.fields:\n exclude.add(f.name)\n elif self._meta.exclude and field in self._meta.exclude:\n exclude.add(f.name)\n elif field in self._errors:\n exclude.add(f.name)\n else:\n form_field = self.fields[field]\n field_value = self.cleaned_data.get(field)\n if not f.blank and (not form_field.required) and (field_value in form_field.empty_values):\n exclude.add(f.name)\n return exclude", "docstring": "For backwards-compatibility, exclude several types of fields from model validation. See tickets #12507, #12521, #12553.", "type": "method", "file_path": "django\\django\\forms\\models.py", "ast_data": "FunctionDef name:_get_validation_exclusions arg:self arguments arg Assign Call For Assign If Compare Call If BoolOp Compare Call If BoolOp Compare Call If Compare Call Assign Assign Call If BoolOp Compare Call Return return:yes" }, { "library": "tensorflow", "name": "scatter_mul", "source_code": "def scatter_mul(self, sparse_delta, use_locking=False, name=None):\n raise NotImplementedError", "docstring": "Multiply this variable by . Args: sparse_delta: to multiply this variable by. use_locking: If , use locking during the operation. name: the name of the operation. Returns: The updated variable. Raises: TypeError: if is not an .", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\ops\\variables.py", "ast_data": "FunctionDef name:scatter_mul arg:self arg:sparse_delta arg:use_locking arg:name arguments arg arg arg arg Raise" }, { "library": "pytorch", "name": "_quant_node_constraint", "source_code": "def _quant_node_constraint(n: Node) -> bool:\n return n.op == 'call_function' and n.target in _QUANT_OPS", "docstring": "If there is any pure ops between get_attr and quantize op they will be const propagated e.g. get_attr(weight) -> transpose -> quantize -> dequantize* (Note: dequantize op is not going to be constant propagated) This filter is added because we don't want to constant fold the things that are not related to quantization", "type": "function", "file_path": "pytorch\\torch\\ao\\quantization\\quantize_pt2e.py", "ast_data": "FunctionDef name:_quant_node_constraint arg:n arguments arg Return return:yes BoolOp Compare Compare" }, { "library": "tensorflow", "name": "__init__", "source_code": "def __init__(self, filenames, record_bytes, header_bytes=None, footer_bytes=None, buffer_size=None, compression_type=None, num_parallel_reads=None, name=None):\n filenames = _create_or_validate_filenames_dataset(filenames, name=name)\n self._filenames = filenames\n self._record_bytes = record_bytes\n self._header_bytes = header_bytes\n self._footer_bytes = footer_bytes\n self._buffer_size = buffer_size\n self._compression_type = compression_type\n\n def creator_fn(filename):\n return _FixedLengthRecordDataset(filename, record_bytes, header_bytes, footer_bytes, buffer_size, compression_type, name=name)\n self._impl = _create_dataset_reader(creator_fn, filenames, num_parallel_reads, name=name)\n variant_tensor = self._impl._variant_tensor\n super(FixedLengthRecordDatasetV2, self).__init__(variant_tensor)", "docstring": "Creates a . Args: filenames: A tensor or containing one or more filenames. record_bytes: A scalar representing the number of bytes in each record. header_bytes: (Optional.) A scalar representing the number of bytes to skip at the start of a file. footer_bytes: (Optional.) A scalar representing the number of bytes to ignore at the end of a file. buffer_size: (Optional.) A scalar representing the number of bytes to buffer when reading. compression_type: (Optional.) A scalar evaluating to one of (no compression), , or . num_parallel_reads: (Optional.) A scalar representing the number of files to read in parallel. If greater than one, the records of files read in parallel are outputted in an interleaved order. If your input pipeline is I/O bottlenecked, consider setting this parameter to a value greater than one to parallelize the I/O. If , files will be read sequentially. name: (Optional.) A name for the tf.data operation.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\data\\ops\\readers.py", "ast_data": "FunctionDef name:__init__ arg:self arg:filenames arg:record_bytes arg:header_bytes arg:footer_bytes arg:buffer_size arg:compression_type arg:num_parallel_reads arg:name arguments arg arg arg arg arg arg arg arg arg Assign Call Assign Assign Assign Assign Assign Assign FunctionDef name:creator_fn arg:filename arguments arg Return return:yes Call Assign Call Assign Call Call" }, { "library": "django", "name": "_should_handle", "source_code": "def _should_handle(self, path):\n return path.startswith(self.base_url.path) and (not self.base_url.netloc)", "docstring": "Check if the path should be handled. Ignore the path if: * the host is provided as part of the base_url * the request's path isn't under the media path (or equal)", "type": "method", "file_path": "django\\django\\contrib\\staticfiles\\handlers.py", "ast_data": "FunctionDef name:_should_handle arg:self arg:path arguments arg arg Return return:yes BoolOp Call" }, { "library": "pytorch", "name": "run_node", "source_code": "def run_node(self, n: torch.fx.Node) -> Result:\n from torch._guards import detect_fake_mode\n result = super().run_node(n)\n rebind_unbacked(detect_fake_mode().shape_env, n, result)\n return result", "docstring": "Run an FX node, propagating unbacked Symbol bindings to the new fake tensor", "type": "method", "file_path": "pytorch\\torch\\fx\\experimental\\symbolic_shapes.py", "ast_data": "FunctionDef name:run_node arg:self arg:n arguments arg arg Assign Call Call Call Call Return return:yes" }, { "library": "pytorch", "name": "Mish", "source_code": "class Mish(Module):\n __constants__ = ['inplace']\n inplace: bool\n\n def __init__(self, inplace: bool=False):\n super().__init__()\n self.inplace = inplace\n\n def forward(self, input: Tensor) -> Tensor:\n return F.mish(input, inplace=self.inplace)\n\n def extra_repr(self) -> str:\n inplace_str = 'inplace=True' if self.inplace else ''\n return inplace_str", "docstring": "Applies the Mish function, element-wise. Mish: A Self Regularized Non-Monotonic Neural Activation Function. .. math:: \\text{Mish}(x) = x * \\text{Tanh}(\\text{Softplus}(x)) .. note:: See _ Shape: - Input: :math:, where :math: means any number of dimensions. - Output: :math:, same shape as the input. .. image:: ../scripts/activation_images/Mish.png Examples:: >>> m = nn.Mish() >>> input = torch.randn(2) >>> output = m(input)", "type": "class", "file_path": "pytorch\\torch\\nn\\modules\\activation.py", "ast_data": "ClassDef name:Mish Assign FunctionDef name:__init__ arg:self arg:inplace arguments arg arg Call Call Assign FunctionDef name:forward arg:self arg:input arguments arg arg Return return:yes Call FunctionDef name:extra_repr arg:self arguments arg Assign Return return:yes" }, { "library": "tensorflow", "name": "__init__", "source_code": "def __init__(self, wait_until_step):\n self._wait_until_step = wait_until_step", "docstring": "Initializes a . Args: wait_until_step: an shows until which global step should we wait.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\training\\basic_session_run_hooks.py", "ast_data": "FunctionDef name:__init__ arg:self arg:wait_until_step arguments arg arg Assign" }, { "library": "matplotlib", "name": "clear", "source_code": "def clear(self):\n if self._subclass_uses_cla:\n self.cla()\n else:\n self.__clear()", "docstring": "Clear the Axes.", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\axes\\_base.py", "ast_data": "FunctionDef name:clear arg:self arguments arg If Call Call" }, { "library": "tensorflow", "name": "_track_trackable", "source_code": "def _track_trackable(self, trackable, name, overwrite=False):\n self._maybe_initialize_trackable()\n if not isinstance(trackable, Trackable):\n raise TypeError(f'Trackable._track_trackable() can only be used to track objects of type Trackable. Got type {type(trackable)}.')\n if not getattr(self, '_manual_tracking', True):\n return trackable\n new_reference = TrackableReference(name=name, ref=trackable)\n current_object = self._lookup_dependency(name)\n if current_object is not None and current_object is not trackable:\n if not overwrite:\n raise ValueError(f\"Called Trackable._track_trackable() with name='{name}', but a Trackable with this name is already declared as a dependency. Names must be unique (or overwrite=True).\")\n for index, (old_name, _) in enumerate(self._self_unconditional_checkpoint_dependencies):\n if name == old_name:\n self._self_unconditional_checkpoint_dependencies[index] = new_reference\n elif current_object is None:\n self._self_unconditional_checkpoint_dependencies.append(new_reference)\n self._handle_deferred_dependencies(name=name, trackable=trackable)\n self._self_unconditional_dependency_names[name] = trackable\n return trackable", "docstring": "Declare a dependency on another object. Indicates that checkpoints for this object should include variables from . Variables in a checkpoint are mapped to s based on the names provided when the checkpoint was written. To avoid breaking existing checkpoints when modifying a class, neither variable names nor dependency names (the names passed to ) may change. Args: trackable: A which this object depends on. name: A local name for , used for loading checkpoints into the correct objects. overwrite: Boolean, whether silently replacing dependencies is OK. Used for __setattr__, where throwing an error on attribute reassignment would be inappropriate. Returns: , for convenience when declaring a dependency and assigning to a member variable in one statement. Raises: TypeError: If does not inherit from . ValueError: If another object is already tracked by this name.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\trackable\\base.py", "ast_data": "FunctionDef name:_track_trackable arg:self arg:trackable arg:name arg:overwrite arguments arg arg arg arg Call If Call Raise Call Call If Call Return return:yes Assign Call Assign Call If BoolOp Compare Compare If Raise Call For Call If Compare Assign If Compare Call Call Assign Return return:yes" }, { "library": "pygame", "name": "compile", "source_code": "def compile(strings, black='X', white='.', xor='o'):\n size = (len(strings[0]), len(strings))\n if size[0] % 8 or size[1] % 8:\n raise ValueError(f'cursor string sizes must be divisible by 8 {size}')\n for s in strings[1:]:\n if len(s) != size[0]:\n raise ValueError('Cursor strings are inconsistent lengths')\n maskdata = []\n filldata = []\n maskitem = fillitem = 0\n step = 8\n for s in strings:\n for c in s:\n maskitem = maskitem << 1\n fillitem = fillitem << 1\n step = step - 1\n if c == black:\n maskitem = maskitem | 1\n fillitem = fillitem | 1\n elif c == white:\n maskitem = maskitem | 1\n elif c == xor:\n fillitem = fillitem | 1\n if not step:\n maskdata.append(maskitem)\n filldata.append(fillitem)\n maskitem = fillitem = 0\n step = 8\n return (tuple(filldata), tuple(maskdata))", "docstring": "pygame.cursors.compile(strings, black, white, xor) -> data, mask compile cursor strings into cursor data This takes a set of strings with equal length and computes the binary data for that cursor. The string widths must be divisible by 8. The black and white arguments are single letter strings that tells which characters will represent black pixels, and which characters represent white pixels. All other characters are considered clear. Some systems allow you to set a special toggle color for the system color, this is also called the xor color. If the system does not support xor cursors, that color will simply be black. This returns a tuple containing the cursor data and cursor mask data. Both these arguments are used when setting a cursor with pygame.mouse.set_cursor().", "type": "function", "file_path": "pygame\\src_py\\cursors.py", "ast_data": "FunctionDef name:compile arg:strings arg:black arg:white arg:xor arguments arg arg arg arg Assign Call Call If BoolOp Raise Call For If Compare Call Raise Call Assign Assign Assign Assign For For Assign Assign Assign If Compare Assign Assign If Compare Assign If Compare Assign If Call Call Assign Assign Return return:yes Call Call" }, { "library": "scipy", "name": "cdf", "source_code": "def cdf(self, x, loc=None, shape=1, df=1, allow_singular=False, *, maxpts=None, lower_limit=None, random_state=None):\n dim, loc, shape, df = self._process_parameters(loc, shape, df)\n shape = _PSD(shape, allow_singular=allow_singular)._M\n return self._cdf(x, loc, shape, df, dim, maxpts, lower_limit, random_state)", "docstring": "Multivariate t-distribution cumulative distribution function. Parameters ---------- x : array_like Points at which to evaluate the cumulative distribution function. %(_mvt_doc_default_callparams)s maxpts : int, optional Maximum number of points to use for integration. The default is 1000 times the number of dimensions. lower_limit : array_like, optional Lower limit of integration of the cumulative distribution function. Default is negative infinity. Must be broadcastable with . %(_doc_random_state)s Returns ------- cdf : ndarray or scalar Cumulative distribution function evaluated at . Examples -------- >>> from scipy.stats import multivariate_t >>> x = [0.4, 5] >>> loc = [0, 1] >>> shape = [[1, 0.1], [0.1, 1]] >>> df = 7 >>> multivariate_t.cdf(x, loc, shape, df) 0.64798491", "type": "method", "file_path": "scipy\\scipy\\stats\\_multivariate.py", "ast_data": "FunctionDef name:cdf arg:self arg:x arg:loc arg:shape arg:df arg:allow_singular arguments arg arg arg arg arg arg arg arg arg Assign Call Assign Call Return return:yes Call" }, { "library": "pandas", "name": "components", "source_code": "@property\ndef components(self) -> DataFrame:\n from pandas import DataFrame\n columns = ['days', 'hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds']\n hasnans = self._hasna\n if hasnans:\n\n def f(x):\n if isna(x):\n return [np.nan] * len(columns)\n return x.components\n else:\n\n def f(x):\n return x.components\n result = DataFrame([f(x) for x in self], columns=columns)\n if not hasnans:\n result = result.astype('int64')\n return result", "docstring": "Return a DataFrame of the individual resolution components of the Timedeltas. The components (days, hours, minutes seconds, milliseconds, microseconds, nanoseconds) are returned as columns in a DataFrame. Returns ------- DataFrame See Also -------- TimedeltaIndex.total_seconds : Return total duration expressed in seconds. Timedelta.components : Return a components namedtuple-like of a single timedelta. Examples -------- >>> tdelta_idx = pd.to_timedelta([\"1 day 3 min 2 us 42 ns\"]) >>> tdelta_idx TimedeltaIndex(['1 days 00:03:00.000002042'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.components days hours minutes seconds milliseconds microseconds nanoseconds 0 1 0 3 0 0 2 42", "type": "method", "file_path": "pandas\\pandas\\core\\arrays\\timedeltas.py", "ast_data": "FunctionDef name:components arg:self arguments arg Assign Assign If FunctionDef name:f arg:x arguments arg If Call Return return:yes Call Return return:yes FunctionDef name:f arg:x arguments arg Return return:yes Assign Call Call If Assign Call Return return:yes" }, { "library": "cherrypy", "name": "toggleTracebacks", "source_code": "@cherrypy.expose\ndef toggleTracebacks(self):\n tracebacks = cherrypy.request.show_tracebacks\n cherrypy.config.update({'request.show_tracebacks': not tracebacks})\n raise cherrypy.HTTPRedirect('/')", "docstring": "Switch tracebacks setting on `` URI.", "type": "method", "file_path": "cherrypy\\cherrypy\\tutorial\\tut10_http_errors.py", "ast_data": "FunctionDef name:toggleTracebacks arg:self arguments arg Assign Call Raise Call" }, { "library": "django", "name": "tuple", "source_code": "@property\ndef tuple(self):\n n = self.size\n get_point = self._point_getter\n if n == 1:\n return get_point(0)\n return tuple((get_point(i) for i in range(n)))", "docstring": "Return a tuple version of this coordinate sequence.", "type": "method", "file_path": "django\\django\\contrib\\gis\\geos\\coordseq.py", "ast_data": "FunctionDef name:tuple arg:self arguments arg Assign Assign If Compare Return return:yes Call Return return:yes Call Call Call" }, { "library": "pytorch", "name": "flush", "source_code": "def flush(self):\n self.event_writer.flush()", "docstring": "Flushes the event file to disk. Call this method to make sure that all pending events have been written to disk.", "type": "method", "file_path": "pytorch\\torch\\utils\\tensorboard\\writer.py", "ast_data": "FunctionDef name:flush arg:self arguments arg Call" }, { "library": "pytorch", "name": "diff", "source_code": "def diff(self, other):\n r = set(self.global_state.keys()).difference(set(other.global_state.keys()))\n if len(r) == 0:\n return None\n return r", "docstring": "Produces a delta against another GlobalContextCheckpointState. Returns None if no delta is found, otherwise, return a set() of mismatched global key names.", "type": "method", "file_path": "pytorch\\torch\\_guards.py", "ast_data": "FunctionDef name:diff arg:self arg:other arguments arg arg Assign Call Call Call Call Call If Compare Call Return return:no Return return:yes" }, { "library": "pytorch", "name": "mesh", "source_code": "def mesh(tag, vertices, colors, faces, config_dict, display_name=None, description=None):\n from tensorboard.plugins.mesh import metadata\n from tensorboard.plugins.mesh.plugin_data_pb2 import MeshPluginData\n json_config = _get_json_config(config_dict)\n summaries = []\n tensors = [(vertices, MeshPluginData.VERTEX), (faces, MeshPluginData.FACE), (colors, MeshPluginData.COLOR)]\n tensors = [tensor for tensor in tensors if tensor[0] is not None]\n components = metadata.get_components_bitmask([content_type for tensor, content_type in tensors])\n for tensor, content_type in tensors:\n summaries.append(_get_tensor_summary(tag, display_name, description, tensor, content_type, components, json_config))\n return Summary(value=summaries)", "docstring": "Output a merged protocol buffer with a mesh/point cloud. Args: tag: A name for this summary operation. vertices: Tensor of shape representing the 3D coordinates of vertices. faces: Tensor of shape containing indices of vertices within each triangle. colors: Tensor of shape containing colors for each vertex. display_name: If set, will be used as the display name in TensorBoard. Defaults to . description: A longform readable description of the summary data. Markdown is supported. config_dict: Dictionary with ThreeJS classes names and configuration. Returns: Merged summary for mesh/point cloud representation.", "type": "function", "file_path": "pytorch\\torch\\utils\\tensorboard\\summary.py", "ast_data": "FunctionDef name:mesh arg:tag arg:vertices arg:colors arg:faces arg:config_dict arg:display_name arg:description arguments arg arg arg arg arg arg arg Assign Call Assign Assign Assign Compare Assign Call For Call Call Return return:yes Call" }, { "library": "pytorch", "name": "state_dict", "source_code": "def state_dict(self) -> dict[str, Any]:\n return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}", "docstring": "Return the state of the scheduler as a :class:. It contains an entry for every variable in self.__dict__ which is not the optimizer.", "type": "method", "file_path": "pytorch\\torch\\optim\\lr_scheduler.py", "ast_data": "FunctionDef name:state_dict arg:self arguments arg Return return:yes Call Compare" }, { "library": "scikit-learn", "name": "transform", "source_code": "def transform(self, X):\n check_is_fitted(self)\n X = validate_data(self, X, accept_sparse=('csr', 'csc'), copy=self.copy, dtype=FLOAT_DTYPES, force_writeable=True, reset=False, ensure_all_finite='allow-nan')\n if sparse.issparse(X):\n if self.with_scaling:\n inplace_column_scale(X, 1.0 / self.scale_)\n else:\n if self.with_centering:\n X -= self.center_\n if self.with_scaling:\n X /= self.scale_\n return X", "docstring": "Center and scale the data. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data used to scale along the specified axis. Returns ------- X_tr : {ndarray, sparse matrix} of shape (n_samples, n_features) Transformed array.", "type": "method", "file_path": "scikit-learn\\sklearn\\preprocessing\\_data.py", "ast_data": "FunctionDef name:transform arg:self arg:X arguments arg arg Call Assign Call If Call If Call If If Return return:yes" }, { "library": "tensorflow", "name": "get_temp_export_dir", "source_code": "def get_temp_export_dir(timestamped_export_dir):\n dirname, basename = os.path.split(timestamped_export_dir)\n if isinstance(basename, bytes):\n str_name = basename.decode('utf-8')\n else:\n str_name = str(basename)\n temp_export_dir = file_io.join(compat.as_bytes(dirname), compat.as_bytes('temp-{}'.format(str_name)))\n return temp_export_dir", "docstring": "Builds a directory name based on the argument but starting with 'temp-'. This relies on the fact that TensorFlow Serving ignores subdirectories of the base directory that can't be parsed as integers. Args: timestamped_export_dir: the name of the eventual export directory, e.g. /foo/bar/ Returns: A sister directory prefixed with 'temp-', e.g. /foo/bar/temp-.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\saved_model\\model_utils\\export_utils.py", "ast_data": "FunctionDef name:get_temp_export_dir arg:timestamped_export_dir arguments arg Assign Call If Call Assign Call Assign Call Assign Call Call Call Call Return return:yes" }, { "library": "authlib", "name": "validate_redirect_uris", "source_code": "def validate_redirect_uris(self):\n uris = self.get('redirect_uris')\n if uris:\n for uri in uris:\n self._validate_uri('redirect_uris', uri)", "docstring": "Array of redirection URI strings for use in redirect-based flows such as the authorization code and implicit flows. As required by Section 2 of OAuth 2.0 [RFC6749], clients using flows with redirection MUST register their redirection URI values. Authorization servers that support dynamic registration for redirect-based flows MUST implement support for this metadata value.", "type": "method", "file_path": "authlib\\authlib\\oauth2\\rfc7591\\claims.py", "ast_data": "FunctionDef name:validate_redirect_uris arg:self arguments arg Assign Call If For Call" }, { "library": "kornia", "name": "get_transformation_matrix", "source_code": "def get_transformation_matrix(self, input: Tensor, params: Optional[Dict[str, Tensor]]=None, flags: Optional[Dict[str, Any]]=None) -> Tensor:\n flags = self.flags if flags is None else flags\n if params is not None:\n transform = self.generate_transformation_matrix(input, params, flags)\n elif self.transform_matrix is None:\n params = self.forward_parameters(input.shape)\n transform = self.generate_transformation_matrix(input, params, flags)\n else:\n transform = self.transform_matrix\n return as_tensor(transform, device=input.device, dtype=input.dtype)", "docstring": "Obtain transformation matrices. Return the current transformation matrix if existed. Generate a new one, otherwise.", "type": "method", "file_path": "kornia\\kornia\\augmentation\\_2d\\geometric\\base.py", "ast_data": "FunctionDef name:get_transformation_matrix arg:self arg:input arg:params arg:flags arguments arg arg arg arg Assign Compare If Compare Assign Call If Compare Assign Call Assign Call Assign Return return:yes Call" }, { "library": "numpy", "name": "_frommethod", "source_code": "class _frommethod:\n\n def __init__(self, methodname, reversed=False):\n self.__name__ = methodname\n self.__qualname__ = methodname\n self.__doc__ = self.getdoc()\n self.reversed = reversed\n\n def getdoc(self):\n meth = getattr(MaskedArray, self.__name__, None) or getattr(np, self.__name__, None)\n signature = self.__name__ + get_object_signature(meth)\n if meth is not None:\n doc = f' {signature}\\n{getattr(meth, '__doc__', None)}'\n return doc\n\n def __call__(self, a, *args, **params):\n if self.reversed:\n args = list(args)\n a, args[0] = (args[0], a)\n marr = asanyarray(a)\n method_name = self.__name__\n method = getattr(type(marr), method_name, None)\n if method is None:\n method = getattr(np, method_name)\n return method(marr, *args, **params)", "docstring": "Define functions from existing MaskedArray methods. Parameters ---------- methodname : str Name of the method to transform.", "type": "class", "file_path": "numpy\\numpy\\ma\\core.py", "ast_data": "ClassDef name:_frommethod FunctionDef name:__init__ arg:self arg:methodname arg:reversed arguments arg arg arg Assign Assign Assign Call Assign FunctionDef name:getdoc arg:self arguments arg Assign BoolOp Call Call Assign Call If Compare Assign Call Return return:yes FunctionDef name:__call__ arg:self arg:a arguments arg arg arg arg If Assign Call Assign Assign Call Assign Assign Call Call If Compare Assign Call Return return:yes Call" }, { "library": "scipy", "name": "parse_data", "source_code": "def parse_data(self, data_str):\n return None", "docstring": "Parse a value of this type.", "type": "method", "file_path": "scipy\\scipy\\io\\arff\\_arffread.py", "ast_data": "FunctionDef name:parse_data arg:self arg:data_str arguments arg arg Return return:no" }, { "library": "pytorch", "name": "OperatorSupportBase", "source_code": "@compatibility(is_backward_compatible=False)\nclass OperatorSupportBase(abc.ABC):\n\n @abc.abstractmethod\n def is_node_supported(self, submodules: t.Mapping[str, torch.nn.Module], node: torch.fx.Node) -> bool:\n raise NotImplementedError", "docstring": "Interface for determining if a fx.Node is supported by a backend", "type": "class", "file_path": "pytorch\\torch\\fx\\passes\\operator_support.py", "ast_data": "ClassDef name:OperatorSupportBase FunctionDef name:is_node_supported arg:self arg:submodules arg:node arguments arg arg arg Raise Call" }, { "library": "kornia", "name": "_perform_padding", "source_code": "def _perform_padding(image: Tensor) -> tuple[Tensor, int, int]:\n H, W = image.shape[-2:]\n h_pad: int = math.ceil(H / 16) * 16 - H\n w_pad: int = math.ceil(W / 16) * 16 - W\n image_padded: Tensor = F.pad(image, (0, w_pad, 0, h_pad), 'replicate')\n return (image_padded, h_pad, w_pad)", "docstring": "Pad a given image to be dividable by 16. Args: image: Image of the shape :math:. Returns: image_padded: Padded image of the shape :math:. h_pad: Padded pixels along the horizontal axis. w_pad: Padded pixels along the vertical axis.", "type": "function", "file_path": "kornia\\kornia\\enhance\\jpeg.py", "ast_data": "FunctionDef name:_perform_padding arg:image arguments arg Assign Call Call Call Return return:yes" }, { "library": "matplotlib", "name": "_CollectionWithSizes", "source_code": "class _CollectionWithSizes(Collection):\n _factor = 1.0\n\n def get_sizes(self):\n return self._sizes\n\n def set_sizes(self, sizes, dpi=72.0):\n if sizes is None:\n self._sizes = np.array([])\n self._transforms = np.empty((0, 3, 3))\n else:\n self._sizes = np.asarray(sizes)\n self._transforms = np.zeros((len(self._sizes), 3, 3))\n scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n self._transforms[:, 0, 0] = scale\n self._transforms[:, 1, 1] = scale\n self._transforms[:, 2, 2] = 1.0\n self.stale = True\n\n @artist.allow_rasterization\n def draw(self, renderer):\n self.set_sizes(self._sizes, self.get_figure(root=True).dpi)\n super().draw(renderer)", "docstring": "Base class for collections that have an array of sizes.", "type": "class", "file_path": "matplotlib\\lib\\matplotlib\\collections.py", "ast_data": "ClassDef name:_CollectionWithSizes Assign FunctionDef name:get_sizes arg:self arguments arg Return return:yes FunctionDef name:set_sizes arg:self arg:sizes arg:dpi arguments arg arg arg If Compare Assign Call Assign Call Assign Call Assign Call Call Assign Call Assign Assign Assign Assign FunctionDef name:draw arg:self arg:renderer arguments arg arg Call Call Call Call" }, { "library": "numpy", "name": "setbufsize", "source_code": "@set_module('numpy')\ndef setbufsize(size):\n old = _get_extobj_dict()['bufsize']\n extobj = _make_extobj(bufsize=size)\n _extobj_contextvar.set(extobj)\n return old", "docstring": "Set the size of the buffer used in ufuncs. .. versionchanged:: 2.0 The scope of setting the buffer is tied to the context. Exiting a `numpy.errstate` context manager the bufsize is restored: >>> import numpy as np >>> with np.errstate(): ... np.setbufsize(4096) ... print(np.getbufsize()) ... 8192 4096 >>> np.getbufsize() 8192", "type": "function", "file_path": "numpy\\numpy\\_core\\_ufunc_config.py", "ast_data": "FunctionDef name:setbufsize arg:size arguments arg Assign Call Assign Call Call Return return:yes Call" }, { "library": "tensorflow", "name": "_parse_dtensor_env_var_from_cluster_resolver", "source_code": "def _parse_dtensor_env_var_from_cluster_resolver(cluster_resolver):\n result = {}\n cluster_spec = multi_worker_util.normalize_cluster_spec(cluster_resolver.cluster_spec())\n dtensor_jobs = []\n if 'chief' in cluster_spec.jobs:\n dtensor_jobs.extend(cluster_spec.job_tasks('chief'))\n if 'worker' in cluster_spec.jobs:\n dtensor_jobs.extend(cluster_spec.job_tasks('worker'))\n if None in dtensor_jobs:\n raise ValueError(f'Unexpected dtensor job address from cluster spec: {cluster_spec}')\n result['DTENSOR_JOBS'] = ','.join(dtensor_jobs)\n result['DTENSOR_NUM_CLIENTS'] = str(len(dtensor_jobs))\n if cluster_resolver.task_type == 'chief':\n dtensor_client_id = 0\n elif cluster_resolver.task_type == 'worker':\n dtensor_client_id = cluster_resolver.task_id\n if 'chief' in cluster_spec.jobs:\n dtensor_client_id += 1\n result['DTENSOR_CLIENT_ID'] = str(dtensor_client_id)\n result['DTENSOR_JOB_NAME'] = 'worker'\n return result", "docstring": "Parse the env vars for Dtensor based on the cluster resolver. In the multi-client setting, each of the DTensor jobs need to aware of each other, and the interface to setup those values are via the envvars. The value used by dtensor are different from the existing . This function will parse the value from cluster resolver, and populate the corresponding value for DTensor jobs in the . Args: cluster_resolver: A instance. Returns: A dict of {Str:Str} which contains all the env vars needed by DTensor jobs. The value is for verification purpose. Raises: The value parsed from existing cluster spec is not valid.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\distribute\\experimental\\multi_worker_mirrored_strategy.py", "ast_data": "FunctionDef name:_parse_dtensor_env_var_from_cluster_resolver arg:cluster_resolver arguments arg Assign Assign Call Call Assign If Compare Call Call If Compare Call Call If Compare Raise Call Assign Call Assign Call Call If Compare Assign If Compare Assign If Compare Assign Call Assign Return return:yes" }, { "library": "authlib", "name": "create_token_response", "source_code": "def create_token_response(self):\n token = self.generate_token(scope=self.request.payload.scope, user=self.request.user, include_refresh_token=False)\n log.debug('Issue token %r to %r', token, self.request.client)\n self.save_token(token)\n return (200, token, self.TOKEN_RESPONSE_HEADER)", "docstring": "If valid and authorized, the authorization server issues an access token.", "type": "method", "file_path": "authlib\\authlib\\oauth2\\rfc7523\\jwt_bearer.py", "ast_data": "FunctionDef name:create_token_response arg:self arguments arg Assign Call Call Call Return return:yes" }, { "library": "tensorflow", "name": "_grad_fn", "source_code": "def _grad_fn(ys, xs, args, func_graph):\n grad_ys = args[3:]\n grad_outs = gradients_util._GradientsHelper(ys, xs, grad_ys=grad_ys, src_graph=func_graph, unconnected_gradients='zero')\n assert all((g is not None for g in grad_outs))\n counter = args[0]\n maximum_iterations = args[1]\n total_iters = args[2]\n return [counter + 1, maximum_iterations, total_iters] + grad_outs", "docstring": "Computes the gradient of in the current graph. This function builds the gradient graph of the corresponding forward-pass by differentiating 's outputs w.r.t. its inputs. Args: ys: A or list of tensors to be differentiated. xs: A or list of tensors to be used for differentiation. args: The input arguments. args[0] - Loop counter args[1] - Total number of iterations. args[2] - maximum_iterations. args[3:] - Incoming gradients for . func_graph: function.FuncGraph. The corresponding forward-pass function. Returns: The output gradient Tensors.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\ops\\while_v2.py", "ast_data": "FunctionDef name:_grad_fn arg:ys arg:xs arg:args arg:func_graph arguments arg arg arg arg Assign Assign Call Call Compare Assign Assign Assign Return return:yes" }, { "library": "pytorch", "name": "_add_fixed_qparams_to_dtype_configs", "source_code": "def _add_fixed_qparams_to_dtype_configs(dtype_configs: list[DTypeConfig], constraints: DTypeWithConstraints) -> list[DTypeConfig]:\n new_dtype_configs = []\n for dtype_config in dtype_configs:\n dc = copy.deepcopy(dtype_config)\n for orig_constraints in [dc.input_dtype_with_constraints, dc.output_dtype_with_constraints]:\n if orig_constraints.dtype != constraints.dtype:\n continue\n if orig_constraints.scale_min_lower_bound is not None:\n raise ValueError(f'scale_min_lower_bound is invalid for fixed qparams ops: {dtype_config}')\n if orig_constraints.scale_max_upper_bound is not None:\n raise ValueError(f'scale_max_upper_bound is invalid for fixed qparams ops: {dtype_config}')\n orig_constraints.quant_min_lower_bound = constraints.quant_min_lower_bound\n orig_constraints.quant_max_upper_bound = constraints.quant_max_upper_bound\n orig_constraints.scale_exact_match = constraints.scale_exact_match\n orig_constraints.zero_point_exact_match = constraints.zero_point_exact_match\n new_dtype_configs.append(dc)\n return new_dtype_configs", "docstring": "Return a copy of the list of DTypeConfigs where activations are subject to the specified constraints required for fixed qparams ops. If the data type doesn't match the one in the constraints, simply leave the corresponding DTypeConfig unchanged. If or is specified in the activations, throw an exception since these settings are incompatible with fixed qparams ops.", "type": "function", "file_path": "pytorch\\torch\\ao\\quantization\\backend_config\\_common_operator_config_utils.py", "ast_data": "FunctionDef name:_add_fixed_qparams_to_dtype_configs arg:dtype_configs arg:constraints arguments arg arg Assign For Assign Call For If Compare If Compare Raise Call If Compare Raise Call Assign Assign Assign Assign Call Return return:yes" }, { "library": "scipy", "name": "sparray", "source_code": "class sparray:\n\n @classmethod\n def __class_getitem__(cls, arg, /):\n from types import GenericAlias\n return GenericAlias(cls, arg)", "docstring": "A namespace class to separate sparray from spmatrix", "type": "class", "file_path": "scipy\\scipy\\sparse\\_base.py", "ast_data": "ClassDef name:sparray FunctionDef name:__class_getitem__ arguments arg arg Return return:yes Call" }, { "library": "kornia", "name": "interp", "source_code": "def interp(x: torch.Tensor, xp: torch.Tensor, fp: torch.Tensor) -> torch.Tensor:\n i = torch.clip(torch.searchsorted(xp, x, right=True), 1, len(xp) - 1)\n return (fp[i - 1] * (xp[i] - x) + fp[i] * (x - xp[i - 1])) / (xp[i] - xp[i - 1])", "docstring": "One-dimensional linear interpolation for monotonically increasing sample points. Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points :math:, evaluated at :math:. This is confirmed to be a correct implementation. See Args: x: the :math:-coordinates at which to evaluate the interpolated values. xp: the :math:-coordinates of the data points, must be increasing. fp: the :math:-coordinates of the data points, same length as . Returns: the interpolated values, same size as .", "type": "function", "file_path": "kornia\\kornia\\contrib\\histogram_matching.py", "ast_data": "FunctionDef name:interp arg:x arg:xp arg:fp arguments arg arg arg Assign Call Call Call Return return:yes" }, { "library": "tensorflow", "name": "with_function_scope", "source_code": "def with_function_scope(thunk, scope_name, options):\n with FunctionScope('lambda_', scope_name, options) as scope:\n return thunk(scope)", "docstring": "Inline version of the FunctionScope context manager.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\autograph\\core\\function_wrappers.py", "ast_data": "FunctionDef name:with_function_scope arg:thunk arg:scope_name arg:options arguments arg arg arg With Call Return return:yes Call" }, { "library": "pandas", "name": "min", "source_code": "@_period_dispatch\ndef min(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs):\n nv.validate_min((), kwargs)\n nv.validate_minmax_axis(axis, self.ndim)\n result = nanops.nanmin(self._ndarray, axis=axis, skipna=skipna)\n return self._wrap_reduction_result(axis, result)", "docstring": "Return the minimum value of the Array or minimum along an axis. See Also -------- numpy.ndarray.min Index.min : Return the minimum value in an Index. Series.min : Return the minimum value in a Series.", "type": "method", "file_path": "pandas\\pandas\\core\\arrays\\datetimelike.py", "ast_data": "FunctionDef name:min arg:self arguments arg arg arg arg Call Call Assign Call Return return:yes Call" }, { "library": "kornia", "name": "Rgb255ToNormals", "source_code": "class Rgb255ToNormals(Module):\n\n def forward(self, image: Tensor) -> Tensor:\n return rgb255_to_normals(image)", "docstring": "Convert an image from RGB [0, 255] to surface normals for visualization purposes. Returns: surface normals version of the image. Shape: - image: :math: - output: :math: Example: >>> input = torch.rand(2, 3, 4, 5) >>> normals = Rgb255ToNormals() >>> output = normals(input) # 2x3x4x5", "type": "class", "file_path": "kornia\\kornia\\color\\rgb.py", "ast_data": "ClassDef name:Rgb255ToNormals FunctionDef name:forward arg:self arg:image arguments arg arg Return return:yes Call" }, { "library": "pandas", "name": "pad_or_backfill_inplace", "source_code": "def pad_or_backfill_inplace(values: np.ndarray, method: Literal['pad', 'backfill']='pad', axis: AxisInt=0, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None) -> None:\n transf = (lambda x: x) if axis == 0 else lambda x: x.T\n if values.ndim == 1:\n if axis != 0:\n raise AssertionError('cannot interpolate on a ndim == 1 with axis != 0')\n values = values.reshape(tuple((1,) + values.shape))\n method = clean_fill_method(method)\n tvalues = transf(values)\n func = get_fill_func(method, ndim=2)\n func(tvalues, limit=limit, limit_area=limit_area)", "docstring": "Perform an actual interpolation of values, values will be make 2-d if needed fills inplace, returns the result. Parameters ---------- values: np.ndarray Input array. method: str, default \"pad\" Interpolation method. Could be \"bfill\" or \"pad\" axis: 0 or 1 Interpolation axis limit: int, optional Index limit on interpolation. limit_area: str, optional Limit area for interpolation. Can be \"inside\" or \"outside\" Notes ----- Modifies values in-place.", "type": "function", "file_path": "pandas\\pandas\\core\\missing.py", "ast_data": "FunctionDef name:pad_or_backfill_inplace arg:values arg:method arg:axis arg:limit arg:limit_area arguments arg arg arg arg arg Assign Compare arguments arg arguments arg If Compare If Compare Raise Call Assign Call Call Assign Call Assign Call Assign Call Call" }, { "library": "scipy", "name": "OptimizeWarning", "source_code": "class OptimizeWarning(UserWarning):\n pass", "docstring": "General warning for :mod:.", "type": "class", "file_path": "scipy\\scipy\\optimize\\_optimize.py", "ast_data": "ClassDef name:OptimizeWarning" }, { "library": "tensorflow", "name": "_is_subscribed_identity", "source_code": "def _is_subscribed_identity(tensor):\n if tensor.op.type != 'Identity':\n return False\n match = re.match('(?PHere are some useful links:
\\n\\n- \\n
- \\n The CherryPy Homepage\\n \\n
- \\n The Python Homepage\\n \\n
You can check out some extra useful\\n links here.
\\n\\n[Return]
\\n '", "docstring": "Produce HTTP response body of links page app index URI.", "type": "method", "file_path": "cherrypy\\cherrypy\\tutorial\\tut04_complex_site.py", "ast_data": "FunctionDef name:index arg:self arguments arg Return return:yes" }, { "library": "kornia", "name": "nms3d", "source_code": "def nms3d(input: Tensor, kernel_size: tuple[int, int, int], mask_only: bool=False) -> Tensor:\n return NonMaximaSuppression3d(kernel_size)(input, mask_only)", "docstring": "Apply non maxima suppression to filter. See :class: for details.", "type": "function", "file_path": "kornia\\kornia\\geometry\\subpix\\nms.py", "ast_data": "FunctionDef name:nms3d arg:input arg:kernel_size arg:mask_only arguments arg arg arg Return return:yes Call Call" }, { "library": "tensorflow", "name": "is_default", "source_code": "def is_default(method):\n return getattr(method, '_is_default', False)", "docstring": "Check if a method is decorated with the wrapper.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\keras\\utils\\generic_utils.py", "ast_data": "FunctionDef name:is_default arg:method arguments arg Return return:yes Call" }, { "library": "django", "name": "handle_fk_field", "source_code": "def handle_fk_field(self, obj, field):\n self._start_relational_field(field)\n related_att = getattr(obj, field.attname)\n if related_att is not None:\n if self.use_natural_foreign_keys and hasattr(field.remote_field.model, 'natural_key'):\n related = getattr(obj, field.name)\n related = related.natural_key()\n for key_value in related:\n self.xml.startElement('natural', {})\n self.xml.characters(str(key_value))\n self.xml.endElement('natural')\n else:\n self.xml.characters(str(related_att))\n else:\n self.xml.addQuickElement('None')\n self.xml.endElement('field')", "docstring": "Handle a ForeignKey (they need to be treated slightly differently from regular fields).", "type": "method", "file_path": "django\\django\\core\\serializers\\xml_serializer.py", "ast_data": "FunctionDef name:handle_fk_field arg:self arg:obj arg:field arguments arg arg arg Call Assign Call If Compare If BoolOp Call Assign Call Assign Call For Call Call Call Call Call Call Call Call" }, { "library": "pytorch", "name": "forward", "source_code": "def forward(self, soft_quantized_output: torch.Tensor, original_output: torch.Tensor, V: torch.Tensor, curr_iter: int) -> tuple[torch.Tensor, torch.Tensor]:\n regularization_term = self.rounding_regularization(V, curr_iter)\n reconstruction_term = self.reconstruction_loss(soft_quantized_output, original_output)\n return (regularization_term, reconstruction_term)", "docstring": "Compute the asymmetric reconstruction formulation as eq [25]", "type": "method", "file_path": "pytorch\\torch\\ao\\quantization\\experimental\\adaround_loss.py", "ast_data": "FunctionDef name:forward arg:self arg:soft_quantized_output arg:original_output arg:V arg:curr_iter arguments arg arg arg arg arg Assign Call Assign Call Return return:yes" }, { "library": "pandas", "name": "validate_categories", "source_code": "@staticmethod\ndef validate_categories(categories, fastpath: bool=False) -> Index:\n from pandas.core.indexes.base import Index\n if not fastpath and (not is_list_like(categories)):\n raise TypeError(f\"Parameter 'categories' must be list-like, was {categories!r}\")\n if not isinstance(categories, ABCIndex):\n categories = Index._with_infer(categories, tupleize_cols=False)\n if not fastpath:\n if categories.hasnans:\n raise ValueError('Categorical categories cannot be null')\n if not categories.is_unique:\n raise ValueError('Categorical categories must be unique')\n if isinstance(categories, ABCCategoricalIndex):\n categories = categories.categories\n return categories", "docstring": "Validates that we have good categories Parameters ---------- categories : array-like fastpath : bool Whether to skip nan and uniqueness checks Returns ------- categories : Index", "type": "method", "file_path": "pandas\\pandas\\core\\dtypes\\dtypes.py", "ast_data": "FunctionDef name:validate_categories arg:categories arg:fastpath arguments arg arg If BoolOp Call Raise Call If Call Assign Call If If Raise Call If Raise Call If Call Assign Return return:yes" }, { "library": "kornia", "name": "top_right", "source_code": "@property\ndef top_right(self) -> torch.Tensor:\n out = self.top_left\n out[..., 0] += self.width\n return out", "docstring": "The [x y] position of the top-left coordinate of the bounding box.", "type": "method", "file_path": "kornia\\kornia\\contrib\\face_detection.py", "ast_data": "FunctionDef name:top_right arg:self arguments arg Assign Return return:yes" }, { "library": "pytorch", "name": "patch_dynamo_config", "source_code": "def patch_dynamo_config(arg1: Optional[Union[str, dict[str, Any], tuple[tuple[str, Any], ...]]]=None, arg2: Any=None, **kwargs: Any) -> DynamoConfigPatchProxy:\n if isinstance(arg1, tuple):\n arg1 = dict(arg1)\n config_patch = torch._dynamo.config.patch(arg1, arg2, **kwargs)\n _patch_dynamo_config_check(config_patch.changes)\n return DynamoConfigPatchProxy(config_patch)", "docstring": "A wrapper around torch._dynamo.config.patch that can be traced by Dynamo to temporarily change config values DURING tracing. See _allowed_config_patches for the list of allowed config patches. Arguments are the same as with torch._dynamo.confing.patch. Can be used as a decorator or a context manager. User code SHOULD NOT MODIFY the return value of this function. WARNING: changing Dynamo config during tracing can lead to unpredictable tracing behavior! Proceed only as advised!", "type": "function", "file_path": "pytorch\\torch\\_dynamo\\decorators.py", "ast_data": "FunctionDef name:patch_dynamo_config arg:arg1 arg:arg2 arguments arg arg arg If Call Assign Call Assign Call Call Return return:yes Call" }, { "library": "cryptography", "name": "__copy__", "source_code": "@abc.abstractmethod\ndef __copy__(self) -> X448PublicKey:\n pass", "docstring": "Returns a copy.", "type": "method", "file_path": "cryptography\\src\\cryptography\\hazmat\\primitives\\asymmetric\\x448.py", "ast_data": "FunctionDef name:__copy__ arg:self arguments arg" }, { "library": "matplotlib", "name": "set_verts", "source_code": "def set_verts(self, verts, closed=True):\n self.stale = True\n if isinstance(verts, np.ma.MaskedArray):\n verts = verts.astype(float).filled(np.nan)\n if not closed:\n self._paths = [mpath.Path(xy) for xy in verts]\n return\n if isinstance(verts, np.ndarray) and len(verts.shape) == 3 and verts.size:\n verts_pad = np.concatenate((verts, verts[:, :1]), axis=1)\n template_path = mpath.Path(verts_pad[0], closed=True)\n codes = template_path.codes\n _make_path = mpath.Path._fast_from_codes_and_verts\n self._paths = [_make_path(xy, codes, internals_from=template_path) for xy in verts_pad]\n return\n self._paths = []\n for xy in verts:\n if len(xy):\n self._paths.append(mpath.Path._create_closed(xy))\n else:\n self._paths.append(mpath.Path(xy))", "docstring": "Set the vertices of the polygons. Parameters ---------- verts : list of array-like The sequence of polygons [*verts0*, *verts1*, ...] where each element *verts_i* defines the vertices of polygon *i* as a 2D array-like of shape (M, 2). closed : bool, default: True Whether the polygon should be closed by adding a CLOSEPOLY connection at the end.", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\collections.py", "ast_data": "FunctionDef name:set_verts arg:self arg:verts arg:closed arguments arg arg arg Assign If Call Assign Call Call If Assign Call Return return:no If BoolOp Call Compare Call Assign Call Assign Call Assign Assign Assign Call Return return:no Assign For If Call Call Call Call Call" }, { "library": "scikit-learn", "name": "is_scalar_nan", "source_code": "def is_scalar_nan(x):\n return not isinstance(x, numbers.Integral) and isinstance(x, numbers.Real) and math.isnan(x)", "docstring": "Test if x is NaN. This function is meant to overcome the issue that np.isnan does not allow non-numerical types as input, and that np.nan is not float('nan'). Parameters ---------- x : any type Any scalar value. Returns ------- bool Returns true if x is NaN, and false otherwise. Examples -------- >>> import numpy as np >>> from sklearn.utils._missing import is_scalar_nan >>> is_scalar_nan(np.nan) True >>> is_scalar_nan(float(\"nan\")) True >>> is_scalar_nan(None) False >>> is_scalar_nan(\"\") False >>> is_scalar_nan([np.nan]) False", "type": "function", "file_path": "scikit-learn\\sklearn\\utils\\_missing.py", "ast_data": "FunctionDef name:is_scalar_nan arg:x arguments arg Return return:yes BoolOp Call Call Call" }, { "library": "tensorflow", "name": "get_init_tokens_op", "source_code": "def get_init_tokens_op(self, num_tokens=-1):\n if self._gradients_applied is False:\n raise ValueError('get_init_tokens_op() should be called after apply_gradients().')\n tokens_needed = self._replicas_to_aggregate - self._total_num_replicas\n if num_tokens == -1:\n num_tokens = self._replicas_to_aggregate\n elif num_tokens < tokens_needed:\n raise ValueError('Too few tokens to finish the first step: %d (given) vs %d (needed)' % (num_tokens, tokens_needed))\n if num_tokens > 0:\n with ops.device(self._global_step.device), ops.name_scope(''):\n tokens = array_ops.fill([num_tokens], self._global_step)\n init_tokens = self._sync_token_queue.enqueue_many((tokens,))\n else:\n init_tokens = control_flow_ops.no_op(name='no_init_tokens')\n return init_tokens", "docstring": "Returns the op to fill the sync_token_queue with the tokens. This is supposed to be executed in the beginning of the chief/sync thread so that even if the total_num_replicas is less than replicas_to_aggregate, the model can still proceed as the replicas can compute multiple steps per variable update. Make sure: . Args: num_tokens: Number of tokens to add to the queue. Returns: An op for the chief/sync replica to fill the token queue. Raises: ValueError: If this is called before apply_gradients(). ValueError: If num_tokens are smaller than replicas_to_aggregate - total_num_replicas.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\training\\sync_replicas_optimizer.py", "ast_data": "FunctionDef name:get_init_tokens_op arg:self arg:num_tokens arguments arg arg If Compare Raise Call Assign If Compare Assign If Compare Raise Call If Compare With Call Call Assign Call Assign Call Assign Call Return return:yes" }, { "library": "pytorch", "name": "draft_export", "source_code": "def draft_export(mod: torch.nn.Module, args: tuple[Any, ...], kwargs: Optional[dict[str, Any]]=None, *, dynamic_shapes: Optional[Union[dict[str, Any], tuple[Any], list[Any]]]=None, preserve_module_call_signature: tuple[str, ...]=(), strict: bool=False) -> ExportedProgram:\n from ._draft_export import draft_export\n return draft_export(mod=mod, args=args, kwargs=kwargs, dynamic_shapes=dynamic_shapes, preserve_module_call_signature=preserve_module_call_signature, strict=strict)", "docstring": "A version of torch.export.export which is designed to consistently produce an ExportedProgram, even if there are potential soundness issues, and to generate a report listing the issues found.", "type": "function", "file_path": "pytorch\\torch\\export\\__init__.py", "ast_data": "FunctionDef name:draft_export arg:mod arg:args arg:kwargs arguments arg arg arg arg arg arg Return return:yes Call" }, { "library": "scikit-learn", "name": "fit_predict", "source_code": "def fit_predict(self, X, y=None):\n return super().fit_predict(X, y)", "docstring": "Fit clustering from features/affinity matrix; return cluster labels. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features), or array-like of shape (n_samples, n_samples) Training instances to cluster, or similarities / affinities between instances if ``. y : Ignored Not used, present here for API consistency by convention. Returns ------- labels : ndarray of shape (n_samples,) Cluster labels.", "type": "method", "file_path": "scikit-learn\\sklearn\\cluster\\_affinity_propagation.py", "ast_data": "FunctionDef name:fit_predict arg:self arg:X arg:y arguments arg arg arg Return return:yes Call Call" }, { "library": "pandas", "name": "_validate", "source_code": "@classmethod\ndef _validate(cls, left, right, dtype: IntervalDtype) -> None:\n if not isinstance(dtype, IntervalDtype):\n msg = f'invalid dtype: {dtype}'\n raise ValueError(msg)\n if len(left) != len(right):\n msg = 'left and right must have the same length'\n raise ValueError(msg)\n left_mask = notna(left)\n right_mask = notna(right)\n if not (left_mask == right_mask).all():\n msg = 'missing values must be missing in the same location both left and right sides'\n raise ValueError(msg)\n if not (left[left_mask] <= right[left_mask]).all():\n msg = 'left side of interval must be <= right side'\n raise ValueError(msg)", "docstring": "Verify that the IntervalArray is valid. Checks that * dtype is correct * left and right match lengths * left and right have the same missing values * left is always below right", "type": "method", "file_path": "pandas\\pandas\\core\\arrays\\interval.py", "ast_data": "FunctionDef name:_validate arg:cls arg:left arg:right arg:dtype arguments arg arg arg arg If Call Assign Raise Call If Compare Call Call Assign Raise Call Assign Call Assign Call If Call Compare Assign Raise Call If Call Compare Assign Raise Call" }, { "library": "pytorch", "name": "_append_qdq", "source_code": "def _append_qdq(x, is_per_channel, is_bias, kwargs):\n per_channel_axis = 0\n scale_key = 'bias_scale' if is_bias else 'weight_scale'\n zp_key = 'bias_zero_point' if is_bias else 'weight_zero_point'\n scale = kwargs[scale_key] if is_per_channel else 1.0\n zp = kwargs[zp_key] if is_per_channel else 0\n qmin = -127\n qmax = 127\n dtype = torch.int8\n qd = torch.ops.quantized_decomposed\n if is_per_channel:\n x = qd.quantize_per_channel(x, scale, zp, per_channel_axis, qmin, qmax, dtype)\n x = qd.dequantize_per_channel(x, scale, zp, per_channel_axis, qmin, qmax, dtype)\n else:\n x = qd.quantize_per_tensor(x, scale, zp, qmin, qmax, dtype)\n x = qd.dequantize_per_tensor(x, scale, zp, qmin, qmax, dtype)\n return x", "docstring": "Helper function to append q-dq ops after , using dummy values for the qparams and qmin/qmax. We use dummy values here because we match with and will manually replace these values after subgraph rewriting. Return the dq node.", "type": "function", "file_path": "pytorch\\torch\\ao\\quantization\\pt2e\\qat_utils.py", "ast_data": "FunctionDef name:_append_qdq arg:x arg:is_per_channel arg:is_bias arg:kwargs arguments arg arg arg arg Assign Assign Assign Assign Assign Assign Assign Assign Assign If Assign Call Assign Call Assign Call Assign Call Return return:yes" }, { "library": "kornia", "name": "bgr_to_rgb", "source_code": "def bgr_to_rgb(image: Tensor) -> Tensor:\n if not isinstance(image, Tensor):\n raise TypeError(f'Input type is not a Tensor. Got {type(image)}')\n if len(image.shape) < 3 or image.shape[-3] != 3:\n raise ValueError(f'Input size must have a shape of (*, 3, H, W).Got {image.shape}')\n out: Tensor = image.flip(-3)\n return out", "docstring": "Convert a BGR image to RGB. Args: image: BGR Image to be converted to BGR of shape :math:. Returns: RGB version of the image with shape of shape :math:. Example: >>> input = torch.rand(2, 3, 4, 5) >>> output = bgr_to_rgb(input) # 2x3x4x5", "type": "function", "file_path": "kornia\\kornia\\color\\rgb.py", "ast_data": "FunctionDef name:bgr_to_rgb arg:image arguments arg If Call Raise Call Call If BoolOp Compare Call Compare Raise Call Call Return return:yes" }, { "library": "tensorflow", "name": "count_params", "source_code": "def count_params(self):\n if not self.built:\n if getattr(self, '_is_graph_network', False):\n with tf_utils.maybe_init_scope(self):\n self._maybe_build(self.inputs)\n else:\n raise ValueError('You tried to call `count_params` on ' + self.name + \", but the layer isn't built. You can build it manually via: `\" + self.name + '.build(batch_input_shape)`.')\n return layer_utils.count_params(self.weights)", "docstring": "Count the total number of scalars composing the weights. Returns: An integer count. Raises: ValueError: if the layer isn't yet built (in which case its weights aren't yet defined).", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\keras\\engine\\base_layer.py", "ast_data": "FunctionDef name:count_params arg:self arguments arg If If Call With Call Call Raise Call Return return:yes Call" }, { "library": "scikit-learn", "name": "_generate_sparse_data", "source_code": "def _generate_sparse_data(X_csr):\n assert X_csr.format == 'csr'\n yield ('csr', X_csr.copy())\n for sparse_format in ['dok', 'lil', 'dia', 'bsr', 'csc', 'coo']:\n yield (sparse_format, X_csr.asformat(sparse_format))\n X_coo = X_csr.asformat('coo')\n X_coo.row = X_coo.row.astype('int64')\n X_coo.col = X_coo.col.astype('int64')\n yield ('coo_64', X_coo)\n for sparse_format in ['csc', 'csr']:\n X = X_csr.asformat(sparse_format)\n X.indices = X.indices.astype('int64')\n X.indptr = X.indptr.astype('int64')\n yield (sparse_format + '_64', X)", "docstring": "Generate sparse matrices or arrays with {32,64}bit indices of diverse format. Parameters ---------- X_csr: scipy.sparse.csr_matrix or scipy.sparse.csr_array Input in CSR format. Returns ------- out: iter(Matrices) or iter(Arrays) In format['dok', 'lil', 'dia', 'bsr', 'csr', 'csc', 'coo', 'coo_64', 'csc_64', 'csr_64']", "type": "function", "file_path": "scikit-learn\\sklearn\\utils\\estimator_checks.py", "ast_data": "FunctionDef name:_generate_sparse_data arg:X_csr arguments arg Compare Call For Call Assign Call Assign Call Assign Call For Assign Call Assign Call Assign Call" }, { "library": "cryptography", "name": "nonce", "source_code": "@property\n@abc.abstractmethod\ndef nonce(self) -> utils.Buffer:\n pass", "docstring": "The value of the nonce for this mode as bytes.", "type": "method", "file_path": "cryptography\\src\\cryptography\\hazmat\\primitives\\ciphers\\modes.py", "ast_data": "FunctionDef name:nonce arg:self arguments arg" }, { "library": "tensorflow", "name": "targets", "source_code": "@property\ndef targets(self) -> Iterable[function_type.FunctionType]:\n return self._dispatch_table.keys()", "docstring": "Returns an iterable to all targets in the table.", "type": "method", "file_path": "tensorflow\\tensorflow\\core\\function\\polymorphism\\type_dispatch.py", "ast_data": "FunctionDef name:targets arg:self arguments arg Return return:yes Call" }, { "library": "scikit-learn", "name": "_fit", "source_code": "def _fit(self, X, y=None, routed_params=None, raw_params=None):\n self.steps = list(self.steps)\n self._validate_steps()\n memory = check_memory(self.memory)\n fit_transform_one_cached = memory.cache(_fit_transform_one)\n for step_idx, name, transformer in self._iter(with_final=False, filter_passthrough=False):\n if transformer is None or transformer == 'passthrough':\n with _print_elapsed_time('Pipeline', self._log_message(step_idx)):\n continue\n if hasattr(memory, 'location') and memory.location is None:\n cloned_transformer = transformer\n else:\n cloned_transformer = clone(transformer)\n step_params = self._get_metadata_for_step(step_idx=step_idx, step_params=routed_params[name], all_params=raw_params)\n X, fitted_transformer = fit_transform_one_cached(cloned_transformer, X, y, weight=None, message_clsname='Pipeline', message=self._log_message(step_idx), params=step_params)\n self.steps[step_idx] = (name, fitted_transformer)\n return X", "docstring": "Fit the pipeline except the last step. routed_params is the output of raw_params is the parameters passed by the user, used when is set by the user, to transform metadata using a sub-pipeline.", "type": "method", "file_path": "scikit-learn\\sklearn\\pipeline.py", "ast_data": "FunctionDef name:_fit arg:self arg:X arg:y arg:routed_params arg:raw_params arguments arg arg arg arg arg Assign Call Call Assign Call Assign Call For Call If BoolOp Compare Compare With Call Call If BoolOp Call Compare Assign Assign Call Assign Call Assign Call Call Assign Return return:yes" }, { "library": "tensorflow", "name": "_NoneCodec", "source_code": "class _NoneCodec:\n\n def can_encode(self, pyobj):\n return pyobj is None\n\n def do_encode(self, none_value, encode_fn):\n del encode_fn, none_value\n value = struct_pb2.StructuredValue()\n value.none_value.CopyFrom(struct_pb2.NoneValue())\n return value\n\n def can_decode(self, value):\n return value.HasField('none_value')\n\n def do_decode(self, value, decode_fn):\n del decode_fn, value\n return None", "docstring": "Codec for None.", "type": "class", "file_path": "tensorflow\\tensorflow\\python\\saved_model\\nested_structure_coder.py", "ast_data": "ClassDef name:_NoneCodec FunctionDef name:can_encode arg:self arg:pyobj arguments arg arg Return return:yes Compare FunctionDef name:do_encode arg:self arg:none_value arg:encode_fn arguments arg arg arg Assign Call Call Call Return return:yes FunctionDef name:can_decode arg:self arg:value arguments arg arg Return return:yes Call FunctionDef name:do_decode arg:self arg:value arg:decode_fn arguments arg arg arg Return return:no" }, { "library": "tensorflow", "name": "dest_nrows", "source_code": "def dest_nrows(self):\n return math_ops.cast(array_ops.shape(self.gather_index)[0], dtype=self.dtype)", "docstring": "Return the number of rows in the resulting gather, or None if tiling.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\ops\\ragged\\dynamic_ragged_shape.py", "ast_data": "FunctionDef name:dest_nrows arg:self arguments arg Return return:yes Call Call" }, { "library": "pytorch", "name": "set_reduce_scatter_divide_factor", "source_code": "def set_reduce_scatter_divide_factor(self, factor: float) -> None:\n state = self._get_fsdp_state()\n if (fsdp_param_group := state._fsdp_param_group) is not None:\n mul_factor = 1.0 / float(factor)\n reduce_op = torch.distributed._make_nccl_premul_sum(mul_factor)\n fsdp_param_group.reduce_scatter_reduce_op = reduce_op", "docstring": "Sets a custom divide factor for the reduce-scatter. This becomes a custom reduce op using NCCL's PreMulSum, which allows multiplying by the factor before reduction. Args: factor (float): Custom divide factor.", "type": "method", "file_path": "pytorch\\torch\\distributed\\fsdp\\_fully_shard\\_fully_shard.py", "ast_data": "FunctionDef name:set_reduce_scatter_divide_factor arg:self arg:factor arguments arg arg Assign Call If Compare Assign Call Assign Call Assign" }, { "library": "kornia", "name": "to_axis_angle", "source_code": "def to_axis_angle(self) -> Tensor:\n return quaternion_to_axis_angle(self.data)", "docstring": "Convert the quaternion to an axis-angle representation. Example: >>> q = Quaternion.identity() >>> axis_angle = q.to_axis_angle() >>> axis_angle tensor([0., 0., 0.], grad_fn=)", "type": "method", "file_path": "kornia\\kornia\\geometry\\quaternion.py", "ast_data": "FunctionDef name:to_axis_angle arg:self arguments arg Return return:yes Call" }, { "library": "scikit-learn", "name": "__call__", "source_code": "def __call__(self, estimator, *args, **kwargs):\n return estimator.score(*args, **kwargs)", "docstring": "Method that wraps estimator.score", "type": "method", "file_path": "scikit-learn\\sklearn\\metrics\\_scorer.py", "ast_data": "FunctionDef name:__call__ arg:self arg:estimator arguments arg arg arg arg Return return:yes Call" }, { "library": "pytorch", "name": "_has_custom_op", "source_code": "def _has_custom_op(sharding_spec, op):\n class_name = type(sharding_spec).__qualname__\n return class_name in _CUSTOM_SHARDING_SPEC_OPS and op in _CUSTOM_SHARDING_SPEC_OPS[class_name]", "docstring": "Returns whether or not the ShardingSpec has a custom op implementation.", "type": "function", "file_path": "pytorch\\torch\\distributed\\_shard\\sharding_spec\\api.py", "ast_data": "FunctionDef name:_has_custom_op arg:sharding_spec arg:op arguments arg arg Assign Call Return return:yes BoolOp Compare Compare" }, { "library": "scipy", "name": "random_base2", "source_code": "def random_base2(self, m: IntNumber) -> np.ndarray:\n n = 2 ** m\n total_n = self.num_generated + n\n if not total_n & total_n - 1 == 0:\n raise ValueError(f\"The balance properties of Sobol' points require n to be a power of 2. {self.num_generated} points have been previously generated, then: n={self.num_generated}+2**{m}={total_n}. If you still want to do this, the function 'Sobol.random()' can be used.\")\n return self.random(n)", "docstring": "Draw point(s) from the Sobol' sequence. This function draws :math: points in the parameter space ensuring the balance properties of the sequence. Parameters ---------- m : int Logarithm in base 2 of the number of samples; i.e., n = 2^m. Returns ------- sample : array_like (n, d) Sobol' sample.", "type": "method", "file_path": "scipy\\scipy\\stats\\_qmc.py", "ast_data": "FunctionDef name:random_base2 arg:self arg:m arguments arg arg Assign Assign If Compare Raise Call Return return:yes Call" }, { "library": "tensorflow", "name": "_set_output_attrs", "source_code": "@trackable.no_automatic_dependency_tracking\ndef _set_output_attrs(self, outputs):\n outputs = nest.flatten(outputs)\n self.outputs = outputs\n self.output_names = training_utils_v1.generic_output_names(outputs)\n self.built = True", "docstring": "Sets attributes related to the outputs of the Model.", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\keras\\engine\\training_v1.py", "ast_data": "FunctionDef name:_set_output_attrs arg:self arg:outputs arguments arg arg Assign Call Assign Assign Call Assign" }, { "library": "tensorflow", "name": "_unable_to_call_layer_due_to_serialization_issue", "source_code": "def _unable_to_call_layer_due_to_serialization_issue(layer, *unused_args, **unused_kwargs):\n raise ValueError('Cannot call custom layer {} of type {}, because the call function was not serialized to the SavedModel.Please try one of the following methods to fix this issue:\\n\\n(1) Implement `get_config` and `from_config` in the layer/model class, and pass the object to the `custom_objects` argument when loading the model. For more details, see: https://www.tensorflow.org/guide/keras/save_and_serialize\\n\\n(2) Ensure that the subclassed model or layer overwrites `call` and not `__call__`. The input shape and dtype will be automatically recorded when the object is called, and used when saving. To manually specify the input shape/dtype, decorate the call function with `@tf.function(input_signature=...)`.'.format(layer.name, type(layer)))", "docstring": "Replaces the if the layer was not fully serialized. Keras Model/Layer serialization is relatively relaxed because SavedModels are not always loaded back as keras models. Thus, when there is an issue tracing a non-signature function, a warning is logged instead of raising an error. This results in a SavedModel where the model's call function is saved, but the internal layer call functions are not. When deserialized with , the internal layers which do not have serialized call functions should raise an error when called. Args: layer: Layer without the serialized call function. Raises: ValueError", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\keras\\saving\\saved_model\\load.py", "ast_data": "FunctionDef name:_unable_to_call_layer_due_to_serialization_issue arg:layer arguments arg arg arg Raise Call Call Call" }, { "library": "pytorch", "name": "enable_param_learning", "source_code": "@torch.jit.export\ndef enable_param_learning(self):\n self.toggle_qparam_learning(enabled=True).toggle_fake_quant(enabled=True).toggle_observer_update(enabled=False)\n return self", "docstring": "Enable parameter learning over static observer estimates. Enables learning of quantization parameters and disables static observer estimates. Forward path returns fake quantized X.", "type": "method", "file_path": "pytorch\\torch\\ao\\quantization\\_learnable_fake_quantize.py", "ast_data": "FunctionDef name:enable_param_learning arg:self arguments arg Call Call Call Return return:yes" }, { "library": "kornia", "name": "AdjustLog", "source_code": "class AdjustLog(Module):\n\n def __init__(self, gain: float=1, inv: bool=False, clip_output: bool=True) -> None:\n super().__init__()\n self.gain: float = gain\n self.inv: bool = inv\n self.clip_output: bool = clip_output\n\n def forward(self, image: Tensor) -> Tensor:\n return adjust_log(image, gain=self.gain, inv=self.inv, clip_output=self.clip_output)", "docstring": "Adjust log correction on the input image tensor. The input image is expected to be in the range of [0, 1]. Reference: [1]: Args: image: Image to be adjusted in the shape of :math:. gain: The multiplier of logarithmic function. inv: If is set to True the function will return the inverse logarithmic correction. clip_output: Whether to clip the output image with range of [0, 1]. Example: >>> x = torch.zeros(1, 1, 2, 2) >>> AdjustLog(inv=True)(x) tensor([[[[0., 0.], [0., 0.]]]])", "type": "class", "file_path": "kornia\\kornia\\enhance\\adjust.py", "ast_data": "ClassDef name:AdjustLog FunctionDef name:__init__ arg:self arg:gain arg:inv arg:clip_output arguments arg arg arg arg Call Call FunctionDef name:forward arg:self arg:image arguments arg arg Return return:yes Call" }, { "library": "cherrypy", "name": "LazyRfc3339UtcTime", "source_code": "class LazyRfc3339UtcTime(object):\n\n def __str__(self):\n iso_formatted_now = datetime.datetime.now(datetime.timezone.utc).isoformat('T')\n return f'{iso_formatted_now!s}Z'", "docstring": "A postponed timestamp string retrieval class.", "type": "class", "file_path": "cherrypy\\cherrypy\\_cplogging.py", "ast_data": "ClassDef name:LazyRfc3339UtcTime FunctionDef name:__str__ arg:self arguments arg Assign Call Call Return return:yes" }, { "library": "django", "name": "_get_related_models", "source_code": "def _get_related_models(m):\n related_models = [subclass for subclass in m.__subclasses__() if issubclass(subclass, models.Model)]\n related_fields_models = set()\n for f in m._meta.get_fields(include_parents=True, include_hidden=True):\n if f.is_relation and f.related_model is not None and (not isinstance(f.related_model, str)):\n related_fields_models.add(f.model)\n related_models.append(f.related_model)\n opts = m._meta\n if opts.proxy and m in related_fields_models:\n related_models.append(opts.concrete_model)\n return related_models", "docstring": "Return all models that have a direct relationship to the given model.", "type": "function", "file_path": "django\\django\\db\\migrations\\state.py", "ast_data": "FunctionDef name:_get_related_models arg:m arguments arg Assign Call Call Assign Call For Call If BoolOp Compare Call Call Call Assign If BoolOp Compare Call Return return:yes" }, { "library": "scikit-learn", "name": "_is_fitted", "source_code": "def _is_fitted(estimator, attributes=None, all_or_any=all):\n if attributes is not None:\n if not isinstance(attributes, (list, tuple)):\n attributes = [attributes]\n return all_or_any([hasattr(estimator, attr) for attr in attributes])\n if hasattr(estimator, '__sklearn_is_fitted__'):\n return estimator.__sklearn_is_fitted__()\n fitted_attrs = [v for v in vars(estimator) if v.endswith('_') and (not v.startswith('__'))]\n return len(fitted_attrs) > 0", "docstring": "Determine if an estimator is fitted Parameters ---------- estimator : estimator instance Estimator instance for which the check is performed. attributes : str, list or tuple of str, default=None Attribute name(s) given as string or a list/tuple of strings Eg.: `Noneestimator` is considered fitted if there exist an attribute that ends with a underscore and does not start with double underscore. all_or_any : callable, {all, any}, default=all Specify whether all or any of the given attributes must exist. Returns ------- fitted : bool Whether the estimator is fitted.", "type": "function", "file_path": "scikit-learn\\sklearn\\utils\\validation.py", "ast_data": "FunctionDef name:_is_fitted arg:estimator arg:attributes arg:all_or_any arguments arg arg arg If Compare If Call Assign Return return:yes Call Call If Call Return return:yes Call Assign Call BoolOp Call Call Return return:yes Compare Call" }, { "library": "scipy", "name": "scipy_namespace_for", "source_code": "def scipy_namespace_for(xp: ModuleType) -> ModuleType | None:\n if is_cupy(xp):\n import cupyx\n return cupyx.scipy\n if is_jax(xp):\n import jax\n return jax.scipy\n if is_torch(xp):\n return xp\n return None", "docstring": "Return the -like namespace of a non-NumPy backend That is, return the namespace corresponding with backend that contains sub-namespaces like and . If no such namespace exists, return ``. Useful for dispatching.", "type": "function", "file_path": "scipy\\scipy\\_lib\\_array_api.py", "ast_data": "FunctionDef name:scipy_namespace_for arg:xp arguments arg If Call Return return:yes If Call Return return:yes If Call Return return:yes Return return:no" }, { "library": "django", "name": "cache_page", "source_code": "def cache_page(timeout, *, cache=None, key_prefix=None):\n return decorator_from_middleware_with_args(CacheMiddleware)(page_timeout=timeout, cache_alias=cache, key_prefix=key_prefix)", "docstring": "Decorator for views that tries getting the page from the cache and populates the cache if the page isn't in the cache yet. The cache is keyed by the URL and some data from the headers. Additionally there is the key prefix that is used to distinguish different cache areas in a multi-site setup. You could use the get_current_site().domain, for example, as that is unique across a Django project. Additionally, all headers from the response's Vary header will be taken into account on caching -- just like the middleware does.", "type": "function", "file_path": "django\\django\\views\\decorators\\cache.py", "ast_data": "FunctionDef name:cache_page arg:timeout arguments arg arg arg Return return:yes Call Call" }, { "library": "django", "name": "crosses", "source_code": "def crosses(self, other):\n return self._topology(capi.ogr_crosses, other)", "docstring": "Return True if this geometry crosses the other.", "type": "method", "file_path": "django\\django\\contrib\\gis\\gdal\\geometries.py", "ast_data": "FunctionDef name:crosses arg:self arg:other arguments arg arg Return return:yes Call" }, { "library": "tensorflow", "name": "Identity", "source_code": "class Identity(Initializer):\n\n def __init__(self, gain=1.0):\n self.gain = gain\n\n def __call__(self, shape, dtype=dtypes.float32, **kwargs):\n self._validate_kwargs(kwargs, support_partition=False)\n dtype = _assert_float_dtype(dtype)\n if len(shape) != 2:\n raise ValueError(f'The tensor to initialize, specified by argument `shape` must be at least two-dimensional. Received shape={shape}')\n initializer = linalg_ops_impl.eye(*shape, dtype=dtype)\n return self.gain * initializer\n\n def get_config(self):\n return {'gain': self.gain}", "docstring": "Initializer that generates the identity matrix. Initializers allow you to pre-specify an initialization strategy, encoded in the Initializer object, without knowing the shape and dtype of the variable being initialized. Only usable for generating 2D matrices. Examples: >>> def make_variable(k, initializer): ... return tf.Variable(initializer(shape=[k, k], dtype=tf.float32)) >>> make_variable(2, tf.initializers.Identity()) >>> make_variable(3, tf.initializers.Identity(gain=0.5)) Args: gain: Multiplicative factor to apply to the identity matrix.", "type": "class", "file_path": "tensorflow\\tensorflow\\python\\ops\\init_ops_v2.py", "ast_data": "ClassDef name:Identity FunctionDef name:__init__ arg:self arg:gain arguments arg arg Assign FunctionDef name:__call__ arg:self arg:shape arg:dtype arguments arg arg arg arg Call Assign Call If Compare Call Raise Call Assign Call Return return:yes FunctionDef name:get_config arg:self arguments arg Return return:yes" }, { "library": "scipy", "name": "entropy", "source_code": "@_axis_nan_policy_factory(lambda x: x, n_samples=lambda kwgs: 2 if 'qk' in kwgs and kwgs['qk'] is not None else 1, n_outputs=1, result_to_tuple=lambda x, _: (x,), paired=True, too_small=-1)\ndef entropy(pk: np.typing.ArrayLike, qk: np.typing.ArrayLike | None=None, base: float | None=None, axis: int=0) -> np.number | np.ndarray:\n if base is not None and base <= 0:\n raise ValueError('`base` must be a positive number or `None`.')\n xp = array_namespace(pk, qk)\n pk, qk = xp_promote(pk, qk, broadcast=True, xp=xp)\n with np.errstate(invalid='ignore'):\n if qk is not None:\n pk, qk = _share_masks(pk, qk, xp=xp)\n qk = qk / xp.sum(qk, axis=axis, keepdims=True)\n pk = pk / xp.sum(pk, axis=axis, keepdims=True)\n if qk is None:\n vec = special.entr(pk)\n elif is_marray(xp):\n vec = special.rel_entr(pk.data, qk.data)\n vec = xp.asarray(vec, mask=pk.mask)\n else:\n vec = special.rel_entr(pk, qk)\n S = xp.sum(vec, axis=axis)\n if base is not None:\n S /= math.log(base)\n return S", "docstring": "Calculate the Shannon entropy/relative entropy of given distribution(s). If only probabilities are given, the Shannon entropy is calculated as `qkpkqkpkpkqkpkqkpkqkpkentropy: >>> CE = entropy(pk, base=base) + entropy(pk, qk, base=base) >>> CE 1.736965594166206 >>> CE == -np.sum(pk * np.log(qk)) / np.log(base) True", "type": "function", "file_path": "scipy\\scipy\\stats\\_entropy.py", "ast_data": "FunctionDef name:entropy arg:pk arg:qk arg:base arg:axis arguments arg arg arg arg If BoolOp Compare Compare Raise Call Assign Call Assign Call With Call If Compare Assign Call Assign Call Assign Call If Compare Assign Call If Call Assign Call Assign Call Assign Call Assign Call If Compare Call Return return:yes Call arguments arg arguments arg BoolOp Compare Compare arguments arg arg" }, { "library": "matplotlib", "name": "_check_xy", "source_code": "def _check_xy(self, renderer):\n b = self.get_annotation_clip()\n if b or (b is None and self.coords1 == 'data'):\n xy_pixel = self._get_xy(self.xy1, self.coords1, self.axesA)\n if self.axesA is None:\n axes = self.axes\n else:\n axes = self.axesA\n if not axes.contains_point(xy_pixel):\n return False\n if b or (b is None and self.coords2 == 'data'):\n xy_pixel = self._get_xy(self.xy2, self.coords2, self.axesB)\n if self.axesB is None:\n axes = self.axes\n else:\n axes = self.axesB\n if not axes.contains_point(xy_pixel):\n return False\n return True", "docstring": "Check whether the annotation needs to be drawn.", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\patches.py", "ast_data": "FunctionDef name:_check_xy arg:self arg:renderer arguments arg arg Assign Call If BoolOp BoolOp Compare Compare Assign Call If Compare Assign Assign If Call Return return:yes If BoolOp BoolOp Compare Compare Assign Call If Compare Assign Assign If Call Return return:yes Return return:yes" }, { "library": "tensorflow", "name": "_get_tensor_by_tf_output", "source_code": "def _get_tensor_by_tf_output(self, tf_output) -> tensor_lib.Tensor:\n op = self._get_operation_by_tf_operation(tf_output.oper)\n return op.outputs[tf_output.index]", "docstring": "Returns the representing . Note that there is only one such , i.e. multiple calls to this function with the same TF_Output value will always return the same object. Args: tf_output: A wrapped (the C API equivalent of ). Returns: The that represents .", "type": "method", "file_path": "tensorflow\\tensorflow\\python\\framework\\ops.py", "ast_data": "FunctionDef name:_get_tensor_by_tf_output arg:self arg:tf_output arguments arg arg Assign Call Return return:yes" }, { "library": "scipy", "name": "stde_median", "source_code": "def stde_median(data, axis=None):\n\n def _stdemed_1D(data):\n data = np.sort(data.compressed())\n n = len(data)\n z = 2.5758293035489004\n k = int(np.round((n + 1) / 2.0 - z * np.sqrt(n / 4.0), 0))\n return (data[n - k] - data[k - 1]) / (2.0 * z)\n data = ma.array(data, copy=False, subok=True)\n if axis is None:\n return _stdemed_1D(data)\n else:\n if data.ndim > 2:\n raise ValueError(f\"Array 'data' must be at most two dimensional, but got data.ndim = {data.ndim}\")\n return ma.apply_along_axis(_stdemed_1D, axis, data)", "docstring": "Returns the McKean-Schrader estimate of the standard error of the sample median along the given axis. masked values are discarded. Parameters ---------- data : ndarray Data to trim. axis : {None,int}, optional Axis along which to perform the trimming. If None, the input array is first flattened.", "type": "function", "file_path": "scipy\\scipy\\stats\\_mstats_basic.py", "ast_data": "FunctionDef name:stde_median arg:data arg:axis arguments arg arg FunctionDef name:_stdemed_1D arg:data arguments arg Assign Call Call Assign Call Assign Assign Call Call Call Return return:yes Assign Call If Compare Return return:yes Call If Compare Raise Call Return return:yes Call" }, { "library": "tensorflow", "name": "_enumerate_cores", "source_code": "def _enumerate_cores(bounds: List[int], ring_bounds: List[int], ring_sizes: List[int], host_bounds: List[int], host_sizes: List[int]) -> List[List[int]]:\n if not bounds:\n return [[]]\n partials = _enumerate_cores(bounds[:-1], ring_bounds[:-1], ring_sizes[:-1], host_bounds[:-1], host_sizes[:-1])\n results = []\n for ring_i in range(0, bounds[-1], ring_bounds[-1]):\n for ring_j in range(0, len(partials), ring_sizes[-1]):\n for host_i in range(ring_i, ring_i + ring_bounds[-1], host_bounds[-1]):\n for host_j in range(ring_j, ring_j + ring_sizes[-1], host_sizes[-1]):\n for i in range(host_i, host_i + host_bounds[-1]):\n for j in range(host_j, host_j + host_sizes[-1]):\n results.append(partials[j] + [i])\n return results", "docstring": "Enumerates cores within from fatest to slowest varying axes. Args: bounds: Upper bounds of axes, from fastest to slowest varying. ring_bounds: Upper bounds of ring size per axis in the same axis order. ring_sizes: Number consecutive cores in the ring built so far, cumulatively. host_bounds: Number of axis values per host in the same axis order. host_sizes: Number consecutive cores on one host, cumulatively. Returns: Cores represented as a list of 4 integers in the same axis order.", "type": "function", "file_path": "tensorflow\\tensorflow\\dtensor\\python\\tpu_util.py", "ast_data": "FunctionDef name:_enumerate_cores arg:bounds arg:ring_bounds arg:ring_sizes arg:host_bounds arg:host_sizes arguments arg arg arg arg arg If Return return:no Assign Call Assign For Call For Call Call For Call For Call For Call For Call Call Return return:yes" }, { "library": "tensorflow", "name": "__init__", "source_code": "def __init__(self, html_template_path, export_report_path):\n if not _file_io.file_exists(html_template_path):\n raise IOError(\"File '{0}' does not exist.\".format(html_template_path))\n with _file_io.FileIO(html_template_path, 'r') as f:\n self.html_template = f.read()\n _file_io.recursive_create_dir(os.path.dirname(export_report_path))\n self.export_report_path = export_report_path", "docstring": "Reads the HTML template content. Args: html_template_path: A string, path to the template HTML file. export_report_path: A string, path to the generated HTML report. This path should point to a '.html' file with date and time in its name. e.g. 2019-01-01-10:05.toco_report.html. Raises: IOError: File doesn't exist.", "type": "method", "file_path": "tensorflow\\tensorflow\\lite\\toco\\logging\\gen_html.py", "ast_data": "FunctionDef name:__init__ arg:self arg:html_template_path arg:export_report_path arguments arg arg arg If Call Raise Call Call With Call Assign Call Call Call Assign" }, { "library": "django", "name": "warning", "source_code": "def warning(request, message, extra_tags='', fail_silently=False):\n add_message(request, constants.WARNING, message, extra_tags=extra_tags, fail_silently=fail_silently)", "docstring": "Add a message with the `` level.", "type": "function", "file_path": "django\\django\\contrib\\messages\\api.py", "ast_data": "FunctionDef name:warning arg:request arg:message arg:extra_tags arg:fail_silently arguments arg arg arg arg Call" }, { "library": "matplotlib", "name": "edit_margin_min", "source_code": "def edit_margin_min(self, todo, size, cell=0):\n if size > self.margin_vals[todo][cell]:\n self.edit_margin(todo, size, cell)", "docstring": "Change the minimum size of the margin for one cell. Parameters ---------- todo : string (one of 'left', 'right', 'bottom', 'top') margin to alter. size : float Minimum size of the margin . If it is larger than the existing minimum it updates the margin size. Fraction of figure size. cell : int Cell column or row to edit.", "type": "method", "file_path": "matplotlib\\lib\\matplotlib\\_layoutgrid.py", "ast_data": "FunctionDef name:edit_margin_min arg:self arg:todo arg:size arg:cell arguments arg arg arg arg If Compare Call" }, { "library": "scikit-learn", "name": "_route_params", "source_code": "def _route_params(self, params, parent, caller):\n self._check_warnings(params=params)\n unrequested = dict()\n args = {arg: value for arg, value in params.items() if value is not None}\n res = Bunch()\n for prop, alias in self._requests.items():\n if alias is False or alias == WARN:\n continue\n elif alias is True and prop in args:\n res[prop] = args[prop]\n elif alias is None and prop in args:\n unrequested[prop] = args[prop]\n elif alias in args:\n res[prop] = args[alias]\n if unrequested:\n if self.method in COMPOSITE_METHODS:\n callee_methods = COMPOSITE_METHODS[self.method]\n else:\n callee_methods = [self.method]\n set_requests_on = ''.join([f'.set_{method}_request({{metadata}}=True/False)' for method in callee_methods])\n message = f'[{', '.join([key for key in unrequested])}] are passed but are not explicitly set as requested or not requested for {self.owner}.{self.method}, which is used within {parent}.{caller}. Call `{self.owner}' + set_requests_on + '` for each metadata you want to request/ignore. See the Metadata Routing User guide%s
' % escape(p).replace('\\n', '') for p in paras]\n else:\n paras = ['
%s
' % p.replace('\\n', '') for p in paras]\n return '\\n\\n'.join(paras)", "docstring": "Convert newlines into and s.", "type": "function", "file_path": "django\\django\\utils\\html.py", "ast_data": "FunctionDef name:linebreaks arg:value arg:autoescape arguments arg arg Assign Call Assign Call Call If Assign Call Call Assign Call Return return:yes Call" }, { "library": "tensorflow", "name": "ResidualWrapper", "source_code": "@tf_export(v1=['nn.rnn_cell.ResidualWrapper'])\nclass ResidualWrapper(rnn_cell_wrapper_impl.ResidualWrapperBase, _RNNCellWrapperV1):\n\n def __init__(self, *args, **kwargs):\n super(ResidualWrapper, self).__init__(*args, **kwargs)\n __init__.__doc__ = rnn_cell_wrapper_impl.ResidualWrapperBase.__init__.__doc__", "docstring": "RNNCell wrapper that ensures cell inputs are added to the outputs.", "type": "class", "file_path": "tensorflow\\tensorflow\\python\\keras\\layers\\legacy_rnn\\rnn_cell_impl.py", "ast_data": "ClassDef name:ResidualWrapper FunctionDef name:__init__ arg:self arguments arg arg arg Call Call Assign Call" }, { "library": "pandas", "name": "_values", "source_code": "@property\ndef _values(self) -> np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray:\n mgr = self._mgr\n blocks = mgr.blocks\n if len(blocks) != 1:\n return ensure_wrapped_if_datetimelike(self.values)\n arr = blocks[0].values\n if arr.ndim == 1:\n return self.values\n arr = cast('np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray', arr)\n return arr.T", "docstring": "Analogue to ._values that may return a 2D ExtensionArray.", "type": "method", "file_path": "pandas\\pandas\\core\\frame.py", "ast_data": "FunctionDef name:_values arg:self arguments arg Assign Assign If Compare Call Return return:yes Call Assign If Compare Return return:yes Assign Call Return return:yes" }, { "library": "pytorch", "name": "mm_grid", "source_code": "@SymbolicGridFn\ndef mm_grid(m, n, meta, *, cdiv):\n return (cdiv(m, meta['BLOCK_M']) * cdiv(n, meta['BLOCK_N']), 1, 1)", "docstring": "The CUDA grid size for matmul triton templates.", "type": "function", "file_path": "pytorch\\torch\\_inductor\\kernel\\mm_common.py", "ast_data": "FunctionDef name:mm_grid arg:m arg:n arg:meta arguments arg arg arg arg Return return:yes Call Call" }, { "library": "matplotlib", "name": "set_loglevel", "source_code": "def set_loglevel(level):\n _log.setLevel(level.upper())\n _ensure_handler().setLevel(level.upper())", "docstring": "Configure Matplotlib's logging levels. Matplotlib uses the standard library framework under the root logger 'matplotlib'. This is a helper function to: - set Matplotlib's root logger level - set the root logger handler's level, creating the handler if it does not exist yet Typically, one should call `` rather than use this function. Parameters ---------- level : {\"notset\", \"debug\", \"info\", \"warning\", \"error\", \"critical\"} The log level of the handler. Notes ----- The first time this function is called, an additional handler is attached to Matplotlib's root handler; this handler is reused every time and this function simply manipulates the logger and handler's level.", "type": "function", "file_path": "matplotlib\\lib\\matplotlib\\__init__.py", "ast_data": "FunctionDef name:set_loglevel arg:level arguments arg Call Call Call Call Call" }, { "library": "tensorflow", "name": "_tf_data_pack_sequence_as", "source_code": "def _tf_data_pack_sequence_as(structure, flat_sequence):\n if not (_tf_data_is_nested(flat_sequence) or isinstance(flat_sequence, list)):\n raise TypeError(f\"Argument `flat_sequence` must be a sequence. Got '{type(flat_sequence).__name__}'.\")\n if not _tf_data_is_nested(structure):\n if len(flat_sequence) != 1:\n raise ValueError(f'Argument `structure` is a scalar but `len(flat_sequence)`={len(flat_sequence)} > 1')\n return flat_sequence[0]\n flat_structure = _tf_data_flatten(structure)\n if len(flat_structure) != len(flat_sequence):\n raise ValueError(f'Could not pack sequence. Argument `structure` had {len(flat_structure)} elements, but argument `flat_sequence` had {len(flat_sequence)} elements. Received structure: {structure}, flat_sequence: {flat_sequence}.')\n _, packed = _tf_data_packed_nest_with_indices(structure, flat_sequence, 0)\n return sequence_like(structure, packed)", "docstring": "Returns a given flattened sequence packed into a nest. If is a scalar, must be a single-element list; in this case the return value is . Args: structure: tuple or list constructed of scalars and/or other tuples/lists, or a scalar. Note: numpy arrays are considered scalars. flat_sequence: flat sequence to pack. Returns: packed: converted to have the same recursive structure as . Raises: ValueError: If nest and structure have different element counts.", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\util\\nest_util.py", "ast_data": "FunctionDef name:_tf_data_pack_sequence_as arg:structure arg:flat_sequence arguments arg arg If BoolOp Call Call Raise Call Call If Call If Compare Call Raise Call Call Return return:yes Assign Call If Compare Call Call Raise Call Call Call Assign Call Return return:yes Call" }, { "library": "pytorch", "name": "LazyBatchNorm2d", "source_code": "class LazyBatchNorm2d(_LazyNormBase, _BatchNorm):\n cls_to_become = BatchNorm2d\n\n def _check_input_dim(self, input):\n if input.dim() != 4:\n raise ValueError(f'expected 4D input (got {input.dim()}D input)')", "docstring": "A :class: module with lazy initialization. Lazy initialization is done for the `BatchNorm2dweightbiasrunning_meanrunning_vartorch.nn.modules.lazy.LazyModuleMixinrunning_meanrunning_var`", "type": "class", "file_path": "pytorch\\torch\\nn\\modules\\batchnorm.py", "ast_data": "ClassDef name:LazyBatchNorm2d Assign FunctionDef name:_check_input_dim arg:self arg:input arguments arg arg If Compare Call Raise Call Call" }, { "library": "pytorch", "name": "view_to_reshape", "source_code": "def view_to_reshape(gm):\n subgraph_names: OrderedSet[str] = OrderedSet((x.target for x in gm.graph.find_nodes(op='get_attr')))\n for child_name, child_mod in gm.named_children():\n if child_name in subgraph_names and isinstance(child_mod, torch.fx.GraphModule):\n view_to_reshape(child_mod)\n for nd in gm.graph.find_nodes(op='call_function', target=torch.ops.aten.view.default):\n nd.target = torch.ops.aten.reshape.default", "docstring": "Replace view ops in the GraphModule to reshape ops.", "type": "function", "file_path": "pytorch\\torch\\_inductor\\fx_passes\\post_grad.py", "ast_data": "FunctionDef name:view_to_reshape arg:gm arguments arg Call Call For Call If BoolOp Compare Call Call For Call Assign" }, { "library": "pytorch", "name": "tensor_storage_size", "source_code": "def tensor_storage_size(self) -> Optional[int]:\n if self.tensor_data is None:\n return None\n numels = reduce(operator.mul, self.tensor_data.size, 1)\n dtype_size = torch._utils._element_size(self.tensor_data.properties.dtype)\n return numels * dtype_size", "docstring": "Calculates the storage size of the underlying tensor, or None if this is not a tensor write. Returns: Optional[int] storage size, in bytes of underlying tensor if any.", "type": "method", "file_path": "pytorch\\torch\\distributed\\checkpoint\\planner.py", "ast_data": "FunctionDef name:tensor_storage_size arg:self arguments arg If Compare Return return:no Assign Call Assign Call Return return:yes" }, { "library": "tensorflow", "name": "_build_map_helper", "source_code": "def _build_map_helper(tensor, finished_nodes, nodes_in_progress, nodes_in_decreasing_depth, layer_indices):\n layer, node_index, _ = tensor._keras_history\n node = layer._inbound_nodes[node_index]\n if node in finished_nodes:\n return\n if node in nodes_in_progress:\n raise ValueError('The tensor ' + str(tensor) + ' at layer \"' + layer.name + '\" is part of a cycle.')\n if layer not in layer_indices:\n layer_indices[layer] = len(layer_indices)\n nodes_in_progress.add(node)\n if not node.is_input:\n for tensor in node.keras_inputs:\n _build_map_helper(tensor, finished_nodes, nodes_in_progress, nodes_in_decreasing_depth, layer_indices)\n finished_nodes.add(node)\n nodes_in_progress.remove(node)\n nodes_in_decreasing_depth.append(node)", "docstring": "Recursive helper for .", "type": "function", "file_path": "tensorflow\\tensorflow\\python\\keras\\engine\\functional.py", "ast_data": "FunctionDef name:_build_map_helper arg:tensor arg:finished_nodes arg:nodes_in_progress arg:nodes_in_decreasing_depth arg:layer_indices arguments arg arg arg arg arg Assign Assign If Compare Return return:no If Compare Raise Call Call If Compare Assign Call Call If For Call Call Call Call" }, { "library": "scikit-learn", "name": "HalfLogitLink", "source_code": "class HalfLogitLink(BaseLink):\n interval_y_pred = Interval(0, 1, False, False)\n\n def link(self, y_pred, out=None):\n out = logit(y_pred, out=out)\n out *= 0.5\n return out\n\n def inverse(self, raw_prediction, out=None):\n return expit(2 * raw_prediction, out)", "docstring": "Half the logit link function g(x)=1/2 * logit(x). Used for the exponential loss.", "type": "class", "file_path": "scikit-learn\\sklearn\\_loss\\link.py", "ast_data": "ClassDef name:HalfLogitLink Assign Call FunctionDef name:link arg:self arg:y_pred arg:out arguments arg arg arg Assign Call Return return:yes FunctionDef name:inverse arg:self arg:raw_prediction arg:out arguments arg arg arg Return return:yes Call" }, { "library": "pytorch", "name": "get_operator_range", "source_code": "def get_operator_range(chars_range):\n if chars_range == 'None' or chars_range is None:\n return None\n if all((item not in chars_range for item in [',', '-'])):\n raise ValueError('The correct format for operator_range is
{self.name}
{color_block(self.get_under())} under
bad {color_block(self.get_bad())}
over {color_block(self.get_over())}