doc,edge_id,enhanced_signature,is_property,method_full_name,name,object_type,parameter_types,parameters_count,relationship,requires_parameters,return_type,signature,source,source_object,source_type,target
compressed_text,485,"(repeats, axis)",false,"GraphMatrix.repeat","repeat","GraphMatrix","{}",2,"GraphMatrix -> float","[""repeats"", ""axis""]","float","(repeats, axis)",40,"GraphMatrix","GraphMatrix",2
compressed_text,211,"(old, new, count=-1)",false,"BranchName.replace","replace","BranchName","{}",3,"BranchName -> float","[""old"", ""new""]","float","(old, new, count=-1, /)",16,"BranchName","BranchName",2
"Check if there are uncommitted changes (FFI wrapper around core history system)",34,"()",false,"Graph.has_uncommitted_changes","has_uncommitted_changes","Graph","{}",0,"Graph -> Unknown","[]","Unknown","()",37,"Graph","Graph",0
"Get a NodesTable representation of accessible nodes  
Implements: g.nodes.table()",244,"()",false,"NodesAccessor.table","table","NodesAccessor","{}",0,"NodesAccessor -> NodesTable","[]","NodesTable","()",20,"NodesAccessor","NodesAccessor",28
"Element-wise exponential (e^x)",448,"()",false,"GraphMatrix.exp","exp","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Create federated GraphTable from multiple bundle paths",253,"(bundle_paths, domain_names=None)",false,"GraphTable.from_federated_bundles","from_federated_bundles","GraphTable","{}",2,"GraphTable -> GraphTable","[""bundle_paths""]","GraphTable","(bundle_paths, domain_names=None)",35,"GraphTable","GraphTable",35
compressed_text,389,"(agg_functions, defaults=None)",false,"Subgraph.collapse_to_node_with_defaults","collapse_to_node_with_defaults","Subgraph","{}",2,"Subgraph -> dict","[""agg_functions""]","dict","(agg_functions, defaults=None)",19,"Subgraph","Subgraph",5
compressed_text,380,"()",false,"Subgraph.adj","adj","Subgraph","{}",0,"Subgraph -> Matrix","[]","Matrix","()",19,"Subgraph","Subgraph",38
compressed_text,161,"(expr)",false,"BaseTable.query","query","BaseTable","{}",1,"BaseTable -> str","[""expr""]","str","(expr)",34,"BaseTable","BaseTable",11
compressed_text,159,"(column, q, interpolation=None)",false,"BaseTable.quantile","quantile","BaseTable","{}",3,"BaseTable -> list","[""column"", ""q""]","list","(column, q, interpolation=None)",34,"BaseTable","BaseTable",22
compressed_text,121,"(column, operation)",false,"BaseTable.expanding","expanding","BaseTable","{}",2,"BaseTable -> BaseArray","[""column"", ""operation""]","BaseArray","(column, operation)",34,"BaseTable","BaseTable",26
compressed_text,274,"(predicate)",false,"NodesTable.filter","filter","NodesTable","{}",1,"NodesTable -> str","[""predicate""]","str","(predicate)",28,"NodesTable","NodesTable",11
compressed_text,450,"()",false,"GraphMatrix.flatten","flatten","GraphMatrix","{}",0,"GraphMatrix -> NumArray","[]","NumArray","()",40,"GraphMatrix","GraphMatrix",27
"Get graph statistics  ",264,"()",false,"GraphTable.stats","stats","GraphTable","{}",0,"GraphTable -> Graph","[]","Graph","()",35,"GraphTable","GraphTable",37
"Aggregate attribute values across nodes or edges",5,"(attribute, operation, target=None, _node_ids=None)",false,"Graph.aggregate","aggregate","Graph","{}",4,"Graph -> Unknown","[""attribute"", ""operation""]","Unknown","(attribute, operation, target=None, _node_ids=None)",37,"Graph","Graph",0
compressed_text,226,"()",false,"EdgeId.bit_length","bit_length","EdgeId","{}",0,"EdgeId -> float","[]","float","()",12,"EdgeId","EdgeId",2
"Filter edges by attribute value",309,"(attr_name, value)",false,"EdgesTable.filter_by_attr","filter_by_attr","EdgesTable","{}",2,"EdgesTable -> Unknown","[""attr_name"", ""value""]","Unknown","(attr_name, value)",21,"EdgesTable","EdgesTable",0
compressed_text,452,"(data)",false,"GraphMatrix.from_data","from_data","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""data""]","Matrix","(data)",40,"GraphMatrix","GraphMatrix",38
compressed_text,245,"()",false,"EdgesAccessor.all","all","EdgesAccessor","{}",0,"EdgesAccessor -> Subgraph","[]","Subgraph","()",17,"EdgesAccessor","EdgesAccessor",19
compressed_text,254,"(bundle_path)",false,"GraphTable.get_bundle_info","get_bundle_info","GraphTable","{}",1,"GraphTable -> dict","[""bundle_path""]","dict","(bundle_path)",35,"GraphTable","GraphTable",5
"Get commit history (FFI wrapper around core history system)",12,"()",false,"Graph.commit_history","commit_history","Graph","{}",0,"Graph -> Commit","[]","Commit","()",37,"Graph","Graph",18
"Import NodesTable from CSV file (must contain node_id column)",276,"(path)",false,"NodesTable.from_csv","from_csv","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Check if subgraph contains a specific edge (alias for has_edge)  ",391,"(edge_id)",false,"Subgraph.contains_edge","contains_edge","Subgraph","{}",1,"Subgraph -> Subgraph","[""edge_id""]","Subgraph","(edge_id)",19,"Subgraph","Subgraph",19
"Get edge endpoints (source, target)",397,"(edge_id)",false,"Subgraph.edge_endpoints","edge_endpoints","Subgraph","{}",1,"Subgraph -> Unknown","[""edge_id""]","Unknown","(edge_id)",19,"Subgraph","Subgraph",0
"Convert matrix to BaseArray containing all values as AttrValues",504,"()",false,"GraphMatrix.to_base_array","to_base_array","GraphMatrix","{}",0,"GraphMatrix -> BaseArray","[]","BaseArray","()",40,"GraphMatrix","GraphMatrix",26
"Get neighborhood sampling - delegates to PyGraphAnalysis helper",38,"(center_nodes, radius=None, max_nodes=None)",false,"Graph.neighborhood","neighborhood","Graph","{}",3,"Graph -> GraphAnalysis","[""center_nodes""]","GraphAnalysis","(center_nodes, radius=None, max_nodes=None)",37,"Graph","Graph",32
"Apply sample(k) to all subgraphs",371,"(k)",false,"SubgraphArray.sample","sample","SubgraphArray","{}",1,"SubgraphArray -> Unknown","[""k""]","Unknown","(k)",14,"SubgraphArray","SubgraphArray",0
"Get last n rows (default 5)",178,"(n=5)",false,"BaseTable.tail","tail","BaseTable","{}",1,"BaseTable -> Unknown","[]","Unknown","(n=5)",34,"BaseTable","BaseTable",0
compressed_text,70,"()",false,"AttrName.isnumeric","isnumeric","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Maximum along specified axis (0=rows, 1=columns)",470,"(axis)",false,"GraphMatrix.max_axis","max_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Set bulk edge attributes - delegates to PyGraphAttrMut",49,"(attrs_dict)",false,"Graph.set_edge_attrs","set_edge_attrs","Graph","{}",1,"Graph -> GraphAttrMut","[""attrs_dict""]","GraphAttrMut","(attrs_dict)",37,"Graph","Graph",3
"Create iterator for method chaining",378,"()",false,"TableArray.iter","iter","TableArray","{}",0,"TableArray -> Unknown","[]","Unknown","()",23,"TableArray","TableArray",0
"Check if edge exists - DELEGATED (same as has_edge)  ",13,"(edge)",false,"Graph.contains_edge","contains_edge","Graph","{}",1,"Graph -> Unknown","[""edge""]","Unknown","(edge)",37,"Graph","Graph",0
compressed_text,228,"(length, byteorder, signed=False)",false,"EdgeId.to_bytes","to_bytes","EdgeId","{}",3,"EdgeId -> list","[""length"", ""byteorder""]","list","(length, byteorder, *, signed=False)",12,"EdgeId","EdgeId",22
compressed_text,205,"(width, fillchar= )",false,"BranchName.ljust","ljust","BranchName","{}",2,"BranchName -> str","[""width""]","str","(width, fillchar=' ', /)",16,"BranchName","BranchName",11
"Check if the array is empty",377,"()",false,"TableArray.is_empty","is_empty","TableArray","{}",0,"TableArray -> list","[]","list","()",23,"TableArray","TableArray",22
compressed_text,148,"(value_vars, var_name=None, value_name=None)",false,"BaseTable.melt","melt","BaseTable","{}",3,"BaseTable -> Unpivoted","[""value_vars""]","Unpivoted","(value_vars, var_name=None, value_name=None)",34,"BaseTable","BaseTable",1
"",20,"(edge)",false,"Graph.edge_endpoints","edge_endpoints","Graph","{}",1,"Graph -> Unknown","[""edge""]","Unknown","(edge)",37,"Graph","Graph",0
"Get first element",354,"()",false,"NumArray.first","first","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
"Convert to Python list",364,"()",false,"NumArray.to_list","to_list","NumArray","{}",0,"NumArray -> list","[]","list","()",27,"NumArray","NumArray",22
"Eigenvalue decomposition: A * V = V * Λ
Returns tuple of (eigenvalues, eigenvectors) ",445,"()",false,"GraphMatrix.eigenvalue_decomposition","eigenvalue_decomposition","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Set multiple node attributes (bulk operation) - delegates to accessor",424,"(attrs_dict)",false,"Subgraph.set_node_attrs","set_node_attrs","Subgraph","{}",1,"Subgraph -> Unknown","[""attrs_dict""]","Unknown","(attrs_dict)",19,"Subgraph","Subgraph",0
"Get text summary of subgraph",428,"()",false,"Subgraph.summary","summary","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,282,"()",false,"NodesTable.interactive","interactive","NodesTable","{}",0,"NodesTable -> str","[]","str","()",28,"NodesTable","NodesTable",11
"Get number of columns (max of nodes and edges)",260,"()",false,"GraphTable.ncols","ncols","GraphTable","{}",0,"GraphTable -> float","[]","float","()",35,"GraphTable","GraphTable",2
"Get shape as (rows, cols)",327,"()",false,"EdgesTable.shape","shape","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
"Check if edge has specific attribute - delegates to PyGraphAttr",31,"(edge_id, attr_name)",false,"Graph.has_edge_attribute","has_edge_attribute","Graph","{}",2,"Graph -> GraphAttr","[""edge_id"", ""attr_name""]","GraphAttr","(edge_id, attr_name)",37,"Graph","Graph",33
compressed_text,177,"(column)",false,"BaseTable.std","std","BaseTable","{}",1,"BaseTable -> Standard","[""column""]","Standard","(column)",34,"BaseTable","BaseTable",24
"Calculate transitivity of the subgraph",435,"()",false,"Subgraph.transitivity","transitivity","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,237,"()",false,"NodesAccessor.all","all","NodesAccessor","{}",0,"NodesAccessor -> Subgraph","[]","Subgraph","()",20,"NodesAccessor","NodesAccessor",19
"Compute neighborhoods from this subgraph, returning a PyNeighborhoodResult",417,"(central_nodes, hops)",false,"Subgraph.neighborhood","neighborhood","Subgraph","{}",2,"Subgraph -> Subgraph","[""central_nodes"", ""hops""]","Subgraph","(central_nodes, hops)",19,"Subgraph","Subgraph",19
compressed_text,75,"(iterable)",false,"AttrName.join","join","AttrName","{}",1,"AttrName -> str","[""iterable""]","str","(iterable, /)",15,"AttrName","AttrName",11
"Create matrix from NumArray by reshaping to specified dimensions",453,"(num_array, rows, cols)",false,"GraphMatrix.from_flattened","from_flattened","GraphMatrix","{}",3,"GraphMatrix -> NumArray","[""num_array"", ""rows"", ""cols""]","NumArray","(num_array, rows, cols)",40,"GraphMatrix","GraphMatrix",27
compressed_text,82,"(old, new, count=-1)",false,"AttrName.replace","replace","AttrName","{}",3,"AttrName -> float","[""old"", ""new""]","float","(old, new, count=-1, /)",15,"AttrName","AttrName",2
"Merge with another GraphTable",258,"(other, strategy)",false,"GraphTable.merge_with","merge_with","GraphTable","{}",2,"GraphTable -> GraphTable","[""other"", ""strategy""]","GraphTable","(other, strategy)",35,"GraphTable","GraphTable",35
"Get node IDs as an IntArray for integer operations
Implements: g.nodes.ids()",241,"()",false,"NodesAccessor.ids","ids","NodesAccessor","{}",0,"NodesAccessor -> int","[]","int","()",20,"NodesAccessor","NodesAccessor",6
"Import NodesTable from JSON file (must contain node_id column)",278,"(path)",false,"NodesTable.from_json","from_json","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Calculate the sum",363,"()",false,"NumArray.sum","sum","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,434,"()",false,"Subgraph.to_nodes","to_nodes","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,155,"(column, percentile, interpolation=None)",false,"BaseTable.percentile","percentile","BaseTable","{}",3,"BaseTable -> Unknown","[""column"", ""percentile""]","Unknown","(column, percentile, interpolation=None)",34,"BaseTable","BaseTable",0
compressed_text,195,"()",false,"BranchName.isdecimal","isdecimal","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,200,"()",false,"BranchName.isprintable","isprintable","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Create DisplayConfig with default values",224,"()",false,"DisplayConfig.default","default","DisplayConfig","{}",0,"DisplayConfig -> DisplayConfig","[]","DisplayConfig","()",4,"DisplayConfig","DisplayConfig",4
"Create subgraph from list of edges",426,"(edges)",false,"Subgraph.subgraph_from_edges","subgraph_from_edges","Subgraph","{}",1,"Subgraph -> list","[""edges""]","list","(edges)",19,"Subgraph","Subgraph",22
"Check if the table contains any null values",140,"()",false,"BaseTable.has_nulls","has_nulls","BaseTable","{}",0,"BaseTable -> Unknown","[]","Unknown","()",34,"BaseTable","BaseTable",0
compressed_text,393,"(nodes=None, full_graph=False)",false,"Subgraph.degree","degree","Subgraph","{}",2,"Subgraph -> list","[]","list","(nodes=None, *, full_graph=False)",19,"Subgraph","Subgraph",22
"Convert subgraph nodes to a table - pure delegation to core GraphTable",429,"()",false,"Subgraph.table","table","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,306,"(columns)",false,"EdgesTable.drop_columns","drop_columns","EdgesTable","{}",1,"EdgesTable -> list","[""columns""]","list","(columns)",21,"EdgesTable","EdgesTable",22
compressed_text,78,"(chars=None)",false,"AttrName.lstrip","lstrip","AttrName","{}",1,"AttrName -> str","[]","str","(chars=None, /)",15,"AttrName","AttrName",11
compressed_text,97,"(agg_specs)",false,"BaseTable.agg","agg","BaseTable","{}",1,"BaseTable -> dict","[""agg_specs""]","dict","(agg_specs)",34,"BaseTable","BaseTable",5
"Return a copy of the string converted to uppercase.",93,"()",false,"AttrName.upper","upper","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Get total node count across all NodesAccessor objects",350,"()",false,"NodesArray.total_node_count","total_node_count","NodesArray","{}",0,"NodesArray -> NodesAccessor","[]","NodesAccessor","()",39,"NodesArray","NodesArray",20
"Return the entity type string",399,"()",false,"Subgraph.entity_type","entity_type","Subgraph","{}",0,"Subgraph -> str","[]","str","()",19,"Subgraph","Subgraph",11
"Get neighbors of a node within the subgraph",418,"(node_id)",false,"Subgraph.neighbors","neighbors","Subgraph","{}",1,"Subgraph -> Subgraph","[""node_id""]","Subgraph","(node_id)",19,"Subgraph","Subgraph",19
"Placeholder for scalar operations",489,"(scalar)",false,"GraphMatrix.scalar_multiply","scalar_multiply","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""scalar""]","Unknown","(scalar)",40,"GraphMatrix","GraphMatrix",0
"Calculate the mean (average)",358,"()",false,"NumArray.mean","mean","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
"Check if the graph is connected (delegates to subgraph implementation)",36,"()",false,"Graph.is_connected","is_connected","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
"Convenience method for grouping by a single column",138,"(column)",false,"BaseTable.groupby_single","groupby_single","BaseTable","{}",1,"BaseTable -> Unknown","[""column""]","Unknown","(column)",34,"BaseTable","BaseTable",0
"Get reference to underlying BaseTable",305,"()",false,"EdgesTable.base_table","base_table","EdgesTable","{}",0,"EdgesTable -> BaseTable","[]","BaseTable","()",21,"EdgesTable","EdgesTable",34
compressed_text,119,"()",false,"BaseTable.dropna","dropna","BaseTable","{}",0,"BaseTable -> Unknown","[]","Unknown","()",34,"BaseTable","BaseTable",0
"Get single edge attribute - delegates to PyGraphAttr",23,"(edge, attr, default=None)",false,"Graph.get_edge_attr","get_edge_attr","Graph","{}",3,"Graph -> GraphAttr","[""edge"", ""attr""]","GraphAttr","(edge, attr, default=None)",37,"Graph","Graph",33
"Convert table to SubgraphArray by creating subgraphs from table rows",269,"()",false,"GraphTable.to_subgraphs","to_subgraphs","GraphTable","{}",0,"GraphTable -> SubgraphArray","[]","SubgraphArray","()",35,"GraphTable","GraphTable",14
"Direct delegation: Apply filter to components",518,"(predicate)",false,"ComponentsArray.filter","filter","ComponentsArray","{}",1,"ComponentsArray -> Unknown","[""predicate""]","Unknown","(predicate)",30,"ComponentsArray","ComponentsArray",0
compressed_text,184,"(expected_columns)",false,"BaseTable.validate_schema","validate_schema","BaseTable","{}",1,"BaseTable -> dict","[""expected_columns""]","dict","(expected_columns)",34,"BaseTable","BaseTable",5
compressed_text,468,"(func)",false,"GraphMatrix.map","map","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""func""]","Matrix","(func)",40,"GraphMatrix","GraphMatrix",38
"Get all attribute keys for a node - delegates to PyGraphAttr",41,"(node_id)",false,"Graph.node_attribute_keys","node_attribute_keys","Graph","{}",1,"Graph -> GraphAttr","[""node_id""]","GraphAttr","(node_id)",37,"Graph","Graph",33
"Remove a single node from the graph",45,"(node)",false,"Graph.remove_node","remove_node","Graph","{}",1,"Graph -> Graph","[""node""]","Graph","(node)",37,"Graph","Graph",37
"Check if this subgraph is connected",413,"()",false,"Subgraph.is_connected","is_connected","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Get single node attribute - delegates to PyGraphAttr",25,"(node, attr, default=None)",false,"Graph.get_node_attr","get_node_attr","Graph","{}",3,"Graph -> GraphAttr","[""node"", ""attr""]","GraphAttr","(node, attr, default=None)",37,"Graph","Graph",33
"Create induced subgraph from list of nodes",411,"(nodes)",false,"Subgraph.induced_subgraph","induced_subgraph","Subgraph","{}",1,"Subgraph -> list","[""nodes""]","list","(nodes)",19,"Subgraph","Subgraph",22
compressed_text,232,"(length, byteorder, signed=False)",false,"NodeId.to_bytes","to_bytes","NodeId","{}",3,"NodeId -> list","[""length"", ""byteorder""]","list","(length, byteorder, *, signed=False)",31,"NodeId","NodeId",22
"Create an iterator for method chaining",345,"()",false,"NodesArray.iter","iter","NodesArray","{}",0,"NodesArray -> Unknown","[]","Unknown","()",39,"NodesArray","NodesArray",0
compressed_text,382,"()",false,"Subgraph.adjacency_matrix","adjacency_matrix","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Create EdgesTable from a Python dictionary (must contain 'edge_id', 'source', 'target' columns)",313,"(data)",false,"EdgesTable.from_dict","from_dict","EdgesTable","{}",1,"EdgesTable -> dict","[""data""]","dict","(data)",21,"EdgesTable","EdgesTable",5
"Get number of columns",287,"()",false,"NodesTable.ncols","ncols","NodesTable","{}",0,"NodesTable -> float","[]","float","()",28,"NodesTable","NodesTable",2
"Get Laplacian matrix - delegates to PyGraphMatrixHelper",37,"(normalized=None)",false,"Graph.laplacian_matrix","laplacian_matrix","Graph","{}",1,"Graph -> Matrix","[]","Matrix","(normalized=None)",37,"Graph","Graph",38
"Set bulk node attributes - delegates to PyGraphAttrMut",51,"(attrs_dict)",false,"Graph.set_node_attrs","set_node_attrs","Graph","{}",1,"Graph -> GraphAttrMut","[""attrs_dict""]","GraphAttrMut","(attrs_dict)",37,"Graph","Graph",3
"Remove a single edge from the graph",43,"(edge)",false,"Graph.remove_edge","remove_edge","Graph","{}",1,"Graph -> Graph","[""edge""]","Graph","(edge)",37,"Graph","Graph",37
"Cholesky decomposition: A = L * L^T
Returns L (lower triangular) for positive definite matrices",439,"()",false,"GraphMatrix.cholesky_decomposition","cholesky_decomposition","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Calculate the L∞ norm (maximum absolute value) of the matrix",477,"()",false,"GraphMatrix.norm_inf","norm_inf","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,235,"(bytes, byteorder, signed=False)",false,"StateId.from_bytes","from_bytes","StateId","{}",3,"StateId -> list","[""bytes"", ""byteorder""]","list","(bytes, byteorder, *, signed=False)",9,"StateId","StateId",22
compressed_text,158,"()",false,"BaseTable.profile","profile","BaseTable","{}",0,"BaseTable -> BaseTable","[]","BaseTable","()",34,"BaseTable","BaseTable",34
compressed_text,123,"(rows_data)",false,"BaseTable.extend","extend","BaseTable","{}",1,"BaseTable -> list","[""rows_data""]","list","(rows_data)",34,"BaseTable","BaseTable",22
"ELU (Exponential Linear Unit) activation function",447,"(alpha=None)",false,"GraphMatrix.elu","elu","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[]","Unknown","(alpha=None)",40,"GraphMatrix","GraphMatrix",0
"Calculate the L1 norm (sum of absolute values) of the matrix",478,"()",false,"GraphMatrix.norm_l1","norm_l1","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Sigmoid activation applied to matrix
Implements: matrix.sigmoid()",491,"()",false,"GraphMatrix.sigmoid","sigmoid","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Convert edge attributes to matrix
Implements: g.edges.matrix()",248,"()",false,"EdgesAccessor.matrix","matrix","EdgesAccessor","{}",0,"EdgesAccessor -> Matrix","[]","Matrix","()",17,"EdgesAccessor","EdgesAccessor",38
"Softmax activation applied to matrix
Implements: matrix.softmax(dim=1)",492,"(dim=1)",false,"GraphMatrix.softmax","softmax","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[]","Matrix","(dim=1)",40,"GraphMatrix","GraphMatrix",38
"Direct delegation: Apply sample(k) to each component and return PySubgraphArray",521,"(k)",false,"ComponentsArray.sample","sample","ComponentsArray","{}",1,"ComponentsArray -> SubgraphArray","[""k""]","SubgraphArray","(k)",30,"ComponentsArray","ComponentsArray",14
"Transpose the matrix",514,"()",false,"GraphMatrix.transpose","transpose","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Get reference to underlying BaseTable",272,"()",false,"NodesTable.base_table","base_table","NodesTable","{}",0,"NodesTable -> BaseTable","[]","BaseTable","()",28,"NodesTable","NodesTable",34
compressed_text,243,"(attrs_dict)",false,"NodesAccessor.set_attrs","set_attrs","NodesAccessor","{}",1,"NodesAccessor -> Graph","[""attrs_dict""]","Graph","(attrs_dict)",20,"NodesAccessor","NodesAccessor",37
"Count non-null values (for NumArray, all values are non-null by default)",353,"()",false,"NumArray.count","count","NumArray","{}",0,"NumArray -> NumArray","[]","NumArray","()",27,"NumArray","NumArray",27
"Get last element  ",356,"()",false,"NumArray.last","last","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
"Get in-degree of nodes within subgraph",410,"(nodes=None, full_graph=False)",false,"Subgraph.in_degree","in_degree","Subgraph","{}",2,"Subgraph -> Subgraph","[]","Subgraph","(nodes=None, full_graph=False)",19,"Subgraph","Subgraph",19
"Get table iterator for chaining",145,"()",false,"BaseTable.iter","iter","BaseTable","{}",0,"BaseTable -> Unknown","[]","Unknown","()",34,"BaseTable","BaseTable",0
"Mean along specified axis (0=rows, 1=columns)",472,"(axis)",false,"GraphMatrix.mean_axis","mean_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Calculate the trace (sum of diagonal elements) - only for square matrices",513,"()",false,"GraphMatrix.trace","trace","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Import NodesTable from Parquet file (must contain node_id column)",279,"(path)",false,"NodesTable.from_parquet","from_parquet","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Export EdgesTable to Parquet file ",337,"(path)",false,"EdgesTable.to_parquet","to_parquet","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
compressed_text,294,"(column, ascending=True)",false,"NodesTable.sort_by","sort_by","NodesTable","{}",2,"NodesTable -> NodesTable","[""column""]","NodesTable","(column, ascending=True)",28,"NodesTable","NodesTable",28
compressed_text,187,"()",false,"BranchName.capitalize","capitalize","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Get last n rows (primarily from nodes table, default 5) ",265,"(n=5)",false,"GraphTable.tail","tail","GraphTable","{}",1,"GraphTable -> Unknown","[]","Unknown","(n=5)",35,"GraphTable","GraphTable",0
"Auto-assign edge IDs for null values (useful for meta nodes and imported data)",252,"()",false,"GraphTable.auto_assign_edge_ids","auto_assign_edge_ids","GraphTable","{}",0,"GraphTable -> Unknown","[]","Unknown","()",35,"GraphTable","GraphTable",0
"Create matrix from BaseArray containing numeric values",451,"(base_array, rows, cols)",false,"GraphMatrix.from_base_array","from_base_array","GraphMatrix","{}",3,"GraphMatrix -> float","[""base_array"", ""rows"", ""cols""]","float","(base_array, rows, cols)",40,"GraphMatrix","GraphMatrix",2
"Convert to BaseTable (loses edge-specific typing)",321,"()",false,"EdgesTable.into_base_table","into_base_table","EdgesTable","{}",0,"EdgesTable -> BaseTable","[]","BaseTable","()",21,"EdgesTable","EdgesTable",34
"Export EdgesTable to CSV file",334,"(path)",false,"EdgesTable.to_csv","to_csv","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
compressed_text,193,"()",false,"BranchName.isalpha","isalpha","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Check if the array contains a specific NodesAccessor",339,"(item)",false,"NodesArray.contains","contains","NodesArray","{}",1,"NodesArray -> list","[""item""]","list","(item)",39,"NodesArray","NodesArray",22
"Convert uppercase characters to lowercase and lowercase characters to uppercase.",219,"()",false,"BranchName.swapcase","swapcase","BranchName","{}",0,"BranchName -> Unknown","[]","Unknown","()",16,"BranchName","BranchName",0
compressed_text,114,"(column)",false,"BaseTable.cumsum","cumsum","BaseTable","{}",1,"BaseTable -> BaseArray","[""column""]","BaseArray","(column)",34,"BaseTable","BaseTable",26
compressed_text,150,"()",false,"BaseTable.notna","notna","BaseTable","{}",0,"BaseTable -> bool","[]","bool","()",34,"BaseTable","BaseTable",36
"Apply table() to all subgraphs and return PyTableArray",372,"()",false,"SubgraphArray.table","table","SubgraphArray","{}",0,"SubgraphArray -> TableArray","[]","TableArray","()",14,"SubgraphArray","SubgraphArray",23
"Element-wise natural logarithm",466,"()",false,"GraphMatrix.log","log","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
compressed_text,115,"()",false,"BaseTable.describe","describe","BaseTable","{}",0,"BaseTable -> float","[]","float","()",34,"BaseTable","BaseTable",2
"Global maximum value in the matrix",469,"()",false,"GraphMatrix.max","max","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,236,"(length, byteorder, signed=False)",false,"StateId.to_bytes","to_bytes","StateId","{}",3,"StateId -> list","[""length"", ""byteorder""]","list","(length, byteorder, *, signed=False)",9,"StateId","StateId",22
"Convert to Python list",373,"()",false,"SubgraphArray.to_list","to_list","SubgraphArray","{}",0,"SubgraphArray -> list","[]","list","()",14,"SubgraphArray","SubgraphArray",22
"Collect all subgraphs into a Python list (for compatibility with iterator patterns)",367,"()",false,"SubgraphArray.collect","collect","SubgraphArray","{}",0,"SubgraphArray -> list","[]","list","()",14,"SubgraphArray","SubgraphArray",22
"Check if subgraph contains a specific node (alias for has_node)",392,"(node_id)",false,"Subgraph.contains_node","contains_node","Subgraph","{}",1,"Subgraph -> Subgraph","[""node_id""]","Subgraph","(node_id)",19,"Subgraph","Subgraph",19
compressed_text,170,"(row, column_name, value)",false,"BaseTable.set_value","set_value","BaseTable","{}",3,"BaseTable -> Unknown","[""row"", ""column_name"", ""value""]","Unknown","(row, column_name, value)",34,"BaseTable","BaseTable",0
compressed_text,319,"()",false,"EdgesTable.interactive_embed","interactive_embed","EdgesTable","{}",0,"EdgesTable -> str","[]","str","()",21,"EdgesTable","EdgesTable",11
"Set single edge attribute - delegates to PyGraphAttrMut",48,"(edge, attr, value)",false,"Graph.set_edge_attr","set_edge_attr","Graph","{}",3,"Graph -> GraphAttrMut","[""edge"", ""attr"", ""value""]","GraphAttrMut","(edge, attr, value)",37,"Graph","Graph",3
compressed_text,81,"(suffix)",false,"AttrName.removesuffix","removesuffix","AttrName","{}",1,"AttrName -> str","[""suffix""]","str","(suffix, /)",15,"AttrName","AttrName",11
compressed_text,207,"(chars=None)",false,"BranchName.lstrip","lstrip","BranchName","{}",1,"BranchName -> str","[]","str","(chars=None, /)",16,"BranchName","BranchName",11
"Convert to Python list",379,"()",false,"TableArray.to_list","to_list","TableArray","{}",0,"TableArray -> list","[]","list","()",23,"TableArray","TableArray",22
"Get a single edge attribute value",402,"(edge_id, attr_name)",false,"Subgraph.get_edge_attribute","get_edge_attribute","Subgraph","{}",2,"Subgraph -> Unknown","[""edge_id"", ""attr_name""]","Unknown","(edge_id, attr_name)",19,"Subgraph","Subgraph",0
"Stack matrices along specified axis",496,"(other, axis)",false,"GraphMatrix.stack","stack","GraphMatrix","{}",2,"GraphMatrix -> Unknown","[""other"", ""axis""]","Unknown","(other, axis)",40,"GraphMatrix","GraphMatrix",0
compressed_text,190,"(encoding=utf-8, errors=strict)",false,"BranchName.encode","encode","BranchName","{}",2,"BranchName -> str","[]","str","(encoding='utf-8', errors='strict')",16,"BranchName","BranchName",11
"Calculate similarity between subgraphs using various metrics",384,"(other, metric=jaccard)",false,"Subgraph.calculate_similarity","calculate_similarity","Subgraph","{}",2,"Subgraph -> Unknown","[""other""]","Unknown","(other, metric='jaccard')",19,"Subgraph","Subgraph",0
"Variance along specified axis (0=rows, 1=columns)",515,"(axis)",false,"GraphMatrix.var_axis","var_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Get all unique node attribute names across the entire graph",7,"()",false,"Graph.all_node_attribute_names","all_node_attribute_names","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
"GELU activation applied to matrix
Implements: matrix.gelu()",455,"()",false,"GraphMatrix.gelu","gelu","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Calculate density of this subgraph",394,"()",false,"Subgraph.density","density","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Count null values in each column
Returns a dictionary with column names and their null counts",152,"()",false,"BaseTable.null_counts","null_counts","BaseTable","{}",0,"BaseTable -> dict","[]","dict","()",34,"BaseTable","BaseTable",5
"Import BaseTable from Parquet file",131,"(path)",false,"BaseTable.from_parquet","from_parquet","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
compressed_text,220,"()",false,"BranchName.title","title","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,437,"(func)",false,"GraphMatrix.apply","apply","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""func""]","Matrix","(func)",40,"GraphMatrix","GraphMatrix",38
compressed_text,122,"(operation)",false,"BaseTable.expanding_all","expanding_all","BaseTable","{}",1,"BaseTable -> float","[""operation""]","float","(operation)",34,"BaseTable","BaseTable",2
compressed_text,385,"()",false,"Subgraph.child_meta_nodes","child_meta_nodes","Subgraph","{}",0,"Subgraph -> list","[]","list","()",19,"Subgraph","Subgraph",22
"Import BaseTable from CSV file",128,"(path)",false,"BaseTable.from_csv","from_csv","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
"Create a new branch (FFI wrapper around core history system)",15,"(branch_name)",false,"Graph.create_branch","create_branch","Graph","{}",1,"Graph -> Unknown","[""branch_name""]","Unknown","(branch_name)",37,"Graph","Graph",0
"Get bulk edge attributes - delegates to PyGraphAttr",24,"(edges, attrs)",false,"Graph.get_edge_attrs","get_edge_attrs","Graph","{}",2,"Graph -> GraphAttr","[""edges"", ""attrs""]","GraphAttr","(edges, attrs)",37,"Graph","Graph",33
"Check if node has specific attribute - delegates to PyGraphAttr",33,"(node_id, attr_name)",false,"Graph.has_node_attribute","has_node_attribute","Graph","{}",2,"Graph -> GraphAttr","[""node_id"", ""attr_name""]","GraphAttr","(node_id, attr_name)",37,"Graph","Graph",33
compressed_text,134,"(column, percentile, interpolation=None)",false,"BaseTable.get_percentile","get_percentile","BaseTable","{}",3,"BaseTable -> Object","[""column"", ""percentile""]","Object","(column, percentile, interpolation=None)",34,"BaseTable","BaseTable",13
compressed_text,174,"(start, end)",false,"BaseTable.slice","slice","BaseTable","{}",2,"BaseTable -> BaseTable","[""start"", ""end""]","BaseTable","(start, end)",34,"BaseTable","BaseTable",34
"Get a single node attribute value",403,"(node_id, attr_name)",false,"Subgraph.get_node_attribute","get_node_attribute","Subgraph","{}",2,"Subgraph -> Unknown","[""node_id"", ""attr_name""]","Unknown","(node_id, attr_name)",19,"Subgraph","Subgraph",0
"Get component sizes without materializing subgraphs",522,"()",false,"ComponentsArray.sizes","sizes","ComponentsArray","{}",0,"ComponentsArray -> Unknown","[]","Unknown","()",30,"ComponentsArray","ComponentsArray",0
"Remove multiple edges from the graph",44,"(edges)",false,"Graph.remove_edges","remove_edges","Graph","{}",1,"Graph -> Graph","[""edges""]","Graph","(edges)",37,"Graph","Graph",37
"Get last n rows (default 5)",296,"(n=5)",false,"NodesTable.tail","tail","NodesTable","{}",1,"NodesTable -> Unknown","[]","Unknown","(n=5)",28,"NodesTable","NodesTable",0
"Sample k nodes from this subgraph randomly",422,"(k)",false,"Subgraph.sample","sample","Subgraph","{}",1,"Subgraph -> Subgraph","[""k""]","Subgraph","(k)",19,"Subgraph","Subgraph",19
compressed_text,483,"()",false,"GraphMatrix.rank","rank","GraphMatrix","{}",0,"GraphMatrix -> float","[]","float","()",40,"GraphMatrix","GraphMatrix",2
compressed_text,104,"(updates)",false,"BaseTable.assign","assign","BaseTable","{}",1,"BaseTable -> dict","[""updates""]","dict","(updates)",34,"BaseTable","BaseTable",5
compressed_text,506,"()",false,"GraphMatrix.to_dict","to_dict","GraphMatrix","{}",0,"GraphMatrix -> dict","[]","dict","()",40,"GraphMatrix","GraphMatrix",5
compressed_text,330,"(columns, ascending=None)",false,"EdgesTable.sort_values","sort_values","EdgesTable","{}",2,"EdgesTable -> list","[""columns""]","list","(columns, ascending=None)",21,"EdgesTable","EdgesTable",22
"Calculate variance",366,"()",false,"NumArray.var","var","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,57,"()",false,"Graph.view","view","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
"Convert to regular Python list (materializes all components)",524,"()",false,"ComponentsArray.to_list","to_list","ComponentsArray","{}",0,"ComponentsArray -> list","[]","list","()",30,"ComponentsArray","ComponentsArray",22
compressed_text,227,"(bytes, byteorder, signed=False)",false,"EdgeId.from_bytes","from_bytes","EdgeId","{}",3,"EdgeId -> list","[""bytes"", ""byteorder""]","list","(bytes, byteorder, *, signed=False)",12,"EdgeId","EdgeId",22
compressed_text,326,"(columns)",false,"EdgesTable.select","select","EdgesTable","{}",1,"EdgesTable -> list","[""columns""]","list","(columns)",21,"EdgesTable","EdgesTable",22
"Check if the array is empty",369,"()",false,"SubgraphArray.is_empty","is_empty","SubgraphArray","{}",0,"SubgraphArray -> list","[]","list","()",14,"SubgraphArray","SubgraphArray",22
"Create NodesTable from a Python dictionary (must contain 'node_id' column)",277,"(data)",false,"NodesTable.from_dict","from_dict","NodesTable","{}",1,"NodesTable -> dict","[""data""]","dict","(data)",28,"NodesTable","NodesTable",5
"Check if the array is empty",344,"()",false,"NodesArray.is_empty","is_empty","NodesArray","{}",0,"NodesArray -> list","[]","list","()",39,"NodesArray","NodesArray",22
"",427,"(_other)",false,"Subgraph.subtract_from","subtract_from","Subgraph","{}",1,"Subgraph -> Unknown","[""_other""]","Unknown","(_other)",19,"Subgraph","Subgraph",0
compressed_text,60,"(width, fillchar= )",false,"AttrName.center","center","AttrName","{}",2,"AttrName -> str","[""width""]","str","(width, fillchar=' ', /)",15,"AttrName","AttrName",11
"Get column by index as BaseArray (mixed types) or NumArray (if all numerical)",458,"(col)",false,"GraphMatrix.get_column","get_column","GraphMatrix","{}",1,"GraphMatrix -> BaseArray","[""col""]","BaseArray","(col)",40,"GraphMatrix","GraphMatrix",26
compressed_text,63,"()",false,"AttrName.isalnum","isalnum","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Get first n rows (default 5)",141,"(n=5)",false,"BaseTable.head","head","BaseTable","{}",1,"BaseTable -> Unknown","[]","Unknown","(n=5)",34,"BaseTable","BaseTable",0
compressed_text,233,"()",false,"StateId.as_integer_ratio","as_integer_ratio","StateId","{}",0,"StateId -> int","[]","int","()",9,"StateId","StateId",6
compressed_text,320,"(port=None, layout=None, theme=None, width=None, height=None)",false,"EdgesTable.interactive_viz","interactive_viz","EdgesTable","{}",5,"EdgesTable -> float","[]","float","(port=None, layout=None, theme=None, width=None, height=None)",21,"EdgesTable","EdgesTable",2
"Get connected components within this subgraph (lazy array)",390,"()",false,"Subgraph.connected_components","connected_components","Subgraph","{}",0,"Subgraph -> list","[]","list","()",19,"Subgraph","Subgraph",22
"Set single cell value at (row, col)",490,"(row, col, value)",false,"GraphMatrix.set","set","GraphMatrix","{}",3,"GraphMatrix -> Unknown","[""row"", ""col"", ""value""]","Unknown","(row, col, value)",40,"GraphMatrix","GraphMatrix",0
compressed_text,240,"(attr_name)",false,"NodesAccessor.group_by","group_by","NodesAccessor","{}",1,"NodesAccessor -> list","[""attr_name""]","list","(attr_name)",20,"NodesAccessor","NodesAccessor",22
"Check if edge exists between two nodes",406,"(source, target)",false,"Subgraph.has_edge_between","has_edge_between","Subgraph","{}",2,"Subgraph -> Unknown","[""source"", ""target""]","Unknown","(source, target)",19,"Subgraph","Subgraph",0
compressed_text,88,"(keepends=False)",false,"AttrName.splitlines","splitlines","AttrName","{}",1,"AttrName -> list","[]","list","(keepends=False)",15,"AttrName","AttrName",22
compressed_text,284,"(port=None, layout=None, theme=None, width=None, height=None)",false,"NodesTable.interactive_viz","interactive_viz","NodesTable","{}",5,"NodesTable -> float","[]","float","(port=None, layout=None, theme=None, width=None, height=None)",28,"NodesTable","NodesTable",2
"Convert to NumPy array (when numpy available)
Uses .data property to materialize data",510,"()",false,"GraphMatrix.to_numpy","to_numpy","GraphMatrix","{}",0,"GraphMatrix -> list","[]","list","()",40,"GraphMatrix","GraphMatrix",22
compressed_text,84,"(sep)",false,"AttrName.rpartition","rpartition","AttrName","{}",1,"AttrName -> str","[""sep""]","str","(sep, /)",15,"AttrName","AttrName",11
"Filter NodesAccessor objects using a Python predicate function",340,"(predicate)",false,"NodesArray.filter","filter","NodesArray","{}",1,"NodesArray -> NodesAccessor","[""predicate""]","NodesAccessor","(predicate)",39,"NodesArray","NodesArray",20
"Convert table to NodesAccessor by extracting node IDs from the table",268,"()",false,"GraphTable.to_nodes","to_nodes","GraphTable","{}",0,"GraphTable -> NodesAccessor","[]","NodesAccessor","()",35,"GraphTable","GraphTable",20
"Get unique values for an attribute",338,"(attr_name)",false,"EdgesTable.unique_attr_values","unique_attr_values","EdgesTable","{}",1,"EdgesTable -> Unknown","[""attr_name""]","Unknown","(attr_name)",21,"EdgesTable","EdgesTable",0
"BFS traversal - returns subgraph result",383,"(start, max_depth=None)",false,"Subgraph.bfs","bfs","Subgraph","{}",2,"Subgraph -> Subgraph","[""start""]","Subgraph","(start, max_depth=None)",19,"Subgraph","Subgraph",19
"Calculate clustering coefficient for a node or entire subgraph",386,"(_node_id=None)",false,"Subgraph.clustering_coefficient","clustering_coefficient","Subgraph","{}",1,"Subgraph -> Subgraph","[]","Subgraph","(_node_id=None)",19,"Subgraph","Subgraph",19
compressed_text,421,"()",false,"Subgraph.parent_meta_node","parent_meta_node","Subgraph","{}",0,"Subgraph -> dict","[]","dict","()",19,"Subgraph","Subgraph",5
"DFS traversal - returns subgraph result",395,"(start, max_depth=None)",false,"Subgraph.dfs","dfs","Subgraph","{}",2,"Subgraph -> Subgraph","[""start""]","Subgraph","(start, max_depth=None)",19,"Subgraph","Subgraph",19
compressed_text,328,"(start, end)",false,"EdgesTable.slice","slice","EdgesTable","{}",2,"EdgesTable -> EdgesTable","[""start"", ""end""]","EdgesTable","(start, end)",21,"EdgesTable","EdgesTable",21
"Commit current state of the graph (FFI wrapper around core history system)",11,"(message, author)",false,"Graph.commit","commit","Graph","{}",2,"Graph -> Graph","[""message"", ""author""]","Graph","(message, author)",37,"Graph","Graph",37
"Convert to pandas DataFrame",299,"()",false,"NodesTable.to_pandas","to_pandas","NodesTable","{}",0,"NodesTable -> Unknown","[]","Unknown","()",28,"NodesTable","NodesTable",0
compressed_text,231,"(bytes, byteorder, signed=False)",false,"NodeId.from_bytes","from_bytes","NodeId","{}",3,"NodeId -> list","[""bytes"", ""byteorder""]","list","(bytes, byteorder, *, signed=False)",31,"NodeId","NodeId",22
compressed_text,318,"()",false,"EdgesTable.interactive","interactive","EdgesTable","{}",0,"EdgesTable -> str","[]","str","()",21,"EdgesTable","EdgesTable",11
compressed_text,316,"(columns)",false,"EdgesTable.group_by","group_by","EdgesTable","{}",1,"EdgesTable -> list","[""columns""]","list","(columns)",21,"EdgesTable","EdgesTable",22
compressed_text,175,"(column, ascending=True)",false,"BaseTable.sort_by","sort_by","BaseTable","{}",2,"BaseTable -> BaseTable","[""column""]","BaseTable","(column, ascending=True)",34,"BaseTable","BaseTable",34
compressed_text,74,"()",false,"AttrName.isupper","isupper","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Calculate the Frobenius norm (Euclidean norm) of the matrix",476,"()",false,"GraphMatrix.norm","norm","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Element-wise absolute value",436,"()",false,"GraphMatrix.abs","abs","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Get edges as tuples (edge_id, source, target)",303,"()",false,"EdgesTable.as_tuples","as_tuples","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
"Import EdgesTable from JSON file (must contain edge_id, source, target columns)",314,"(path)",false,"EdgesTable.from_json","from_json","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
"Direct delegation: Apply neighborhood() to each component and return PySubgraphArray",520,"()",false,"ComponentsArray.neighborhood","neighborhood","ComponentsArray","{}",0,"ComponentsArray -> SubgraphArray","[]","SubgraphArray","()",30,"ComponentsArray","ComponentsArray",14
compressed_text,368,"(attr_name, element_type)",false,"SubgraphArray.group_by","group_by","SubgraphArray","{}",2,"SubgraphArray -> list","[""attr_name"", ""element_type""]","list","(attr_name, element_type)",14,"SubgraphArray","SubgraphArray",22
"Get all unique edge attribute names across the entire graph",6,"()",false,"Graph.all_edge_attribute_names","all_edge_attribute_names","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
compressed_text,295,"(columns, ascending=None)",false,"NodesTable.sort_values","sort_values","NodesTable","{}",2,"NodesTable -> list","[""columns""]","list","(columns, ascending=None)",28,"NodesTable","NodesTable",22
"Check if an edge exists in the graph - DELEGATED  ",30,"(edge_id)",false,"Graph.has_edge","has_edge","Graph","{}",1,"Graph -> Graph","[""edge_id""]","Graph","(edge_id)",37,"Graph","Graph",37
"Export EdgesTable to JSON file",335,"(path)",false,"EdgesTable.to_json","to_json","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
compressed_text,65,"()",false,"AttrName.isascii","isascii","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,166,"(window, operation)",false,"BaseTable.rolling_all","rolling_all","BaseTable","{}",2,"BaseTable -> float","[""window"", ""operation""]","float","(window, operation)",34,"BaseTable","BaseTable",2
"Check if an edge exists in this subgraph",405,"(edge_id)",false,"Subgraph.has_edge","has_edge","Subgraph","{}",1,"Subgraph -> Subgraph","[""edge_id""]","Subgraph","(edge_id)",19,"Subgraph","Subgraph",19
compressed_text,143,"(column_name, values)",false,"BaseTable.isin","isin","BaseTable","{}",2,"BaseTable -> list","[""column_name"", ""values""]","list","(column_name, values)",34,"BaseTable","BaseTable",22
"Generate transition matrix - delegates to PyGraphMatrixHelper",56,"()",false,"Graph.transition_matrix","transition_matrix","Graph","{}",0,"Graph -> Matrix","[]","Matrix","()",37,"Graph","Graph",38
compressed_text,66,"()",false,"AttrName.isdecimal","isdecimal","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,176,"(columns, ascending=None)",false,"BaseTable.sort_values","sort_values","BaseTable","{}",2,"BaseTable -> list","[""columns""]","list","(columns, ascending=None)",34,"BaseTable","BaseTable",22
"Convert to pandas DataFrame",181,"()",false,"BaseTable.to_pandas","to_pandas","BaseTable","{}",0,"BaseTable -> Unknown","[]","Unknown","()",34,"BaseTable","BaseTable",0
compressed_text,109,"(col1, col2, method=None)",false,"BaseTable.corr_columns","corr_columns","BaseTable","{}",3,"BaseTable -> float","[""col1"", ""col2""]","float","(col1, col2, method=None)",34,"BaseTable","BaseTable",2
compressed_text,29,"(attribute, aggregation_attr, operation)",false,"Graph.group_nodes_by_attribute","group_nodes_by_attribute","Graph","{}",3,"Graph -> Graph","[""attribute"", ""aggregation_attr"", ""operation""]","Graph","(attribute, aggregation_attr, operation)",37,"Graph","Graph",37
compressed_text,71,"()",false,"AttrName.isprintable","isprintable","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,102,"(func)",false,"BaseTable.apply_to_columns","apply_to_columns","BaseTable","{}",1,"BaseTable -> int","[""func""]","int","(func)",34,"BaseTable","BaseTable",6
"Export BaseTable to JSON file",180,"(path)",false,"BaseTable.to_json","to_json","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
compressed_text,92,"(table)",false,"AttrName.translate","translate","AttrName","{}",1,"AttrName -> dict","[""table""]","dict","(table, /)",15,"AttrName","AttrName",5
compressed_text,209,"(prefix)",false,"BranchName.removeprefix","removeprefix","BranchName","{}",1,"BranchName -> str","[""prefix""]","str","(prefix, /)",16,"BranchName","BranchName",11
compressed_text,210,"(suffix)",false,"BranchName.removesuffix","removesuffix","BranchName","{}",1,"BranchName -> str","[""suffix""]","str","(suffix, /)",16,"BranchName","BranchName",11
"Get summary information without materializing data",500,"()",false,"GraphMatrix.summary","summary","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Checkout a branch (FFI wrapper around core history system)",10,"(branch_name)",false,"Graph.checkout_branch","checkout_branch","Graph","{}",1,"Graph -> Unknown","[""branch_name""]","Unknown","(branch_name)",37,"Graph","Graph",0
compressed_text,137,"(by)",false,"BaseTable.groupby","groupby","BaseTable","{}",1,"BaseTable -> list","[""by""]","list","(by)",34,"BaseTable","BaseTable",22
"Create iterator for method chaining",370,"()",false,"SubgraphArray.iter","iter","SubgraphArray","{}",0,"SubgraphArray -> Unknown","[]","Unknown","()",14,"SubgraphArray","SubgraphArray",0
"Convert this graph to a NetworkX graph.",55,"(directed: bool=False, include_attributes: bool=True)",false,"Graph.to_networkx","to_networkx","Graph","{""directed"": ""bool"", ""include_attributes"": ""bool""}",2,"Graph -> Graph","[]","Graph","(directed: bool = False, include_attributes: bool = True)",37,"Graph","Graph",37
"Get source node IDs",331,"()",false,"EdgesTable.sources","sources","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
"Matrix inverse (Phase 5 - placeholder for now)",462,"()",false,"GraphMatrix.inverse","inverse","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Helper method to resolve string ID to NodeId using uid_key attribute",47,"(string_id, uid_key)",false,"Graph.resolve_string_id_to_node","resolve_string_id_to_node","Graph","{}",2,"Graph -> str","[""string_id"", ""uid_key""]","str","(string_id, uid_key)",37,"Graph","Graph",11
"Find the maximum value",357,"()",false,"NumArray.max","max","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,192,"()",false,"BranchName.isalnum","isalnum","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Calculate standard deviation",362,"()",false,"NumArray.std","std","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,169,"(column_name, values)",false,"BaseTable.set_column","set_column","BaseTable","{}",2,"BaseTable -> list","[""column_name"", ""values""]","list","(column_name, values)",34,"BaseTable","BaseTable",22
compressed_text,262,"(bundle_path)",false,"GraphTable.save_bundle","save_bundle","GraphTable","{}",1,"GraphTable -> GraphTable","[""bundle_path""]","GraphTable","(bundle_path)",35,"GraphTable","GraphTable",35
"Get edge IDs",307,"()",false,"EdgesTable.edge_ids","edge_ids","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
"Solve linear system Ax = b",493,"(b)",false,"GraphMatrix.solve","solve","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""b""]","Unknown","(b)",40,"GraphMatrix","GraphMatrix",0
"",3,"(node_id=None, kwargs)",false,"Graph.add_node","add_node","Graph","{}",2,"Graph -> Unknown","[""kwargs""]","Unknown","(node_id=None, **kwargs)",37,"Graph","Graph",0
"Get rich display representation with NodesTable type",290,"(config=None)",false,"NodesTable.rich_display","rich_display","NodesTable","{}",1,"NodesTable -> NodesTable","[]","NodesTable","(config=None)",28,"NodesTable","NodesTable",28
"Leaky ReLU activation function",465,"(alpha=None)",false,"GraphMatrix.leaky_relu","leaky_relu","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[]","Unknown","(alpha=None)",40,"GraphMatrix","GraphMatrix",0
"Import EdgesTable from Parquet file (must contain edge_id, source, target columns)",315,"(path)",false,"EdgesTable.from_parquet","from_parquet","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
"Set operations - merge, intersect, subtract (placeholders)",415,"(_other)",false,"Subgraph.merge_with","merge_with","Subgraph","{}",1,"Subgraph -> Unknown","[""_other""]","Unknown","(_other)",19,"Subgraph","Subgraph",0
"Minimum along specified axis (0=rows, 1=columns)",474,"(axis)",false,"GraphMatrix.min_axis","min_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Get last n rows (default 5)",332,"(n=5)",false,"EdgesTable.tail","tail","EdgesTable","{}",1,"EdgesTable -> Unknown","[]","Unknown","(n=5)",21,"EdgesTable","EdgesTable",0
"Elementwise multiplication (Hadamard product)
Returns: new GraphMatrix with elementwise product",446,"(other)",false,"GraphMatrix.elementwise_multiply","elementwise_multiply","GraphMatrix","{}",1,"GraphMatrix -> GraphMatrix","[""other""]","GraphMatrix","(other)",40,"GraphMatrix","GraphMatrix",40
"Count unique values",360,"()",false,"NumArray.nunique","nunique","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
"Convert to BaseTable (loses node-specific typing)",285,"()",false,"NodesTable.into_base_table","into_base_table","NodesTable","{}",0,"NodesTable -> BaseTable","[]","BaseTable","()",28,"NodesTable","NodesTable",34
compressed_text,21,"(filter)",false,"Graph.filter_edges","filter_edges","Graph","{}",1,"Graph -> str","[""filter""]","str","(filter)",37,"Graph","Graph",11
"Check if subgraph is empty",414,"()",false,"Subgraph.is_empty","is_empty","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Check if empty",355,"()",false,"NumArray.is_empty","is_empty","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,475,"(other)",false,"GraphMatrix.multiply","multiply","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""other""]","Matrix","(other)",40,"GraphMatrix","GraphMatrix",38
compressed_text,433,"()",false,"Subgraph.to_networkx","to_networkx","Subgraph","{}",0,"Subgraph -> Graph","[]","Graph","()",19,"Subgraph","Subgraph",37
"Get number of total rows (nodes + edges)",261,"()",false,"GraphTable.nrows","nrows","GraphTable","{}",0,"GraphTable -> float","[]","float","()",35,"GraphTable","GraphTable",2
"Find the minimum value",359,"()",false,"NumArray.min","min","NumArray","{}",0,"NumArray -> Unknown","[]","Unknown","()",27,"NumArray","NumArray",0
compressed_text,509,"(eps=None, k=None)",false,"GraphMatrix.to_normalized_laplacian","to_normalized_laplacian","GraphMatrix","{}",2,"GraphMatrix -> Matrix","[]","Matrix","(eps=None, k=None)",40,"GraphMatrix","GraphMatrix",38
"Return a copy of the string converted to uppercase.",222,"()",false,"BranchName.upper","upper","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,120,"(subset)",false,"BaseTable.dropna_subset","dropna_subset","BaseTable","{}",1,"BaseTable -> Unknown","[""subset""]","Unknown","(subset)",34,"BaseTable","BaseTable",0
compressed_text,487,"(new_rows, new_cols)",false,"GraphMatrix.reshape","reshape","GraphMatrix","{}",2,"GraphMatrix -> Matrix","[""new_rows"", ""new_cols""]","Matrix","(new_rows, new_cols)",40,"GraphMatrix","GraphMatrix",38
"Validate the GraphTable and return report",270,"()",false,"GraphTable.validate","validate","GraphTable","{}",0,"GraphTable -> GraphTable","[]","GraphTable","()",35,"GraphTable","GraphTable",35
"Set single node attribute - delegates to PyGraphAttrMut",50,"(node, attr, value)",false,"Graph.set_node_attr","set_node_attr","Graph","{}",3,"Graph -> GraphAttrMut","[""node"", ""attr"", ""value""]","GraphAttrMut","(node, attr, value)",37,"Graph","Graph",3
compressed_text,135,"(columns)",false,"BaseTable.group_by","group_by","BaseTable","{}",1,"BaseTable -> list","[""columns""]","list","(columns)",34,"BaseTable","BaseTable",22
compressed_text,229,"()",false,"NodeId.as_integer_ratio","as_integer_ratio","NodeId","{}",0,"NodeId -> int","[]","int","()",31,"NodeId","NodeId",6
compressed_text,213,"(sep)",false,"BranchName.rpartition","rpartition","BranchName","{}",1,"BranchName -> str","[""sep""]","str","(sep, /)",16,"BranchName","BranchName",11
"Merge multiple GraphTables into one",257,"(tables)",false,"GraphTable.merge","merge","GraphTable","{}",1,"GraphTable -> Unknown","[""tables""]","Unknown","(tables)",35,"GraphTable","GraphTable",0
compressed_text,73,"()",false,"AttrName.istitle","istitle","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,238,"()",false,"NodesAccessor.array","array","NodesAccessor","{}",0,"NodesAccessor -> list","[]","list","()",20,"NodesAccessor","NodesAccessor",22
compressed_text,432,"()",false,"Subgraph.to_matrix","to_matrix","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,61,"(encoding=utf-8, errors=strict)",false,"AttrName.encode","encode","AttrName","{}",2,"AttrName -> str","[]","str","(encoding='utf-8', errors='strict')",15,"AttrName","AttrName",11
compressed_text,202,"()",false,"BranchName.istitle","istitle","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Create an identity matrix with specified size",461,"(size)",false,"GraphMatrix.identity","identity","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""size""]","Matrix","(size)",40,"GraphMatrix","GraphMatrix",38
compressed_text,157,"(index, columns, values, aggfunc)",false,"BaseTable.pivot_table","pivot_table","BaseTable","{}",4,"BaseTable -> Reshaped","[""index"", ""columns"", ""values"", ""aggfunc""]","Reshaped","(index, columns, values, aggfunc)",34,"BaseTable","BaseTable",25
compressed_text,283,"()",false,"NodesTable.interactive_embed","interactive_embed","NodesTable","{}",0,"NodesTable -> str","[]","str","()",28,"NodesTable","NodesTable",11
"Calculate graph density (number of edges / number of possible edges) - PURE DELEGATION",16,"()",false,"Graph.density","density","Graph","{}",0,"Graph -> float","[]","float","()",37,"Graph","Graph",2
compressed_text,291,"(columns)",false,"NodesTable.select","select","NodesTable","{}",1,"NodesTable -> list","[""columns""]","list","(columns)",28,"NodesTable","NodesTable",22
compressed_text,86,"(chars=None)",false,"AttrName.rstrip","rstrip","AttrName","{}",1,"AttrName -> str","[]","str","(chars=None, /)",15,"AttrName","AttrName",11
"Get degree matrix from adjacency matrix",505,"()",false,"GraphMatrix.to_degree_matrix","to_degree_matrix","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,68,"()",false,"AttrName.isidentifier","isidentifier","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Matrix Integration: Reshape NumArray into a GraphMatrix",361,"(rows, cols)",false,"NumArray.reshape","reshape","NumArray","{}",2,"NumArray -> NumArray","[""rows"", ""cols""]","NumArray","(rows, cols)",27,"NumArray","NumArray",27
"Export BaseTable to CSV file",179,"(path)",false,"BaseTable.to_csv","to_csv","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
compressed_text,430,"()",false,"Subgraph.to_edges","to_edges","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Get column as raw BaseArray (always returns BaseArray regardless of type)",133,"(column_name)",false,"BaseTable.get_column_raw","get_column_raw","BaseTable","{}",1,"BaseTable -> BaseArray","[""column_name""]","BaseArray","(column_name)",34,"BaseTable","BaseTable",26
"Add a single edge to the graph with support for string IDs and attributes",0,"(source, target, uid_key=None, kwargs)",false,"Graph.add_edge","add_edge","Graph","{}",4,"Graph -> str","[""source"", ""target"", ""kwargs""]","str","(source, target, uid_key=None, **kwargs)",37,"Graph","Graph",11
"Filter NodesAccessor objects by node count threshold",341,"(min_size)",false,"NodesArray.filter_by_size","filter_by_size","NodesArray","{}",1,"NodesArray -> NodesAccessor","[""min_size""]","NodesAccessor","(min_size)",39,"NodesArray","NodesArray",20
compressed_text,404,"(attr_name, element_type)",false,"Subgraph.group_by","group_by","Subgraph","{}",2,"Subgraph -> list","[""attr_name"", ""element_type""]","list","(attr_name, element_type)",19,"Subgraph","Subgraph",22
compressed_text,467,"()",false,"GraphMatrix.lu_decomposition","lu_decomposition","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Node count property",419,"()",false,"Subgraph.node_count","node_count","Subgraph","{}",0,"Subgraph -> Unknown","[]","Unknown","()",19,"Subgraph","Subgraph",0
"Standard deviation along specified axis (0=rows, 1=columns)",497,"(axis)",false,"GraphMatrix.std_axis","std_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Check if a node exists in this subgraph",408,"(node_id)",false,"Subgraph.has_node","has_node","Subgraph","{}",1,"Subgraph -> Subgraph","[""node_id""]","Subgraph","(node_id)",19,"Subgraph","Subgraph",19
"Add multiple edges at once",1,"(edges, node_mapping=None, uid_key=None, source=None, target=None, warm_cache=None)",false,"Graph.add_edges","add_edges","Graph","{}",6,"Graph -> Unknown","[""edges""]","Unknown","(edges, node_mapping=None, uid_key=None, source=None, target=None, warm_cache=None)",37,"Graph","Graph",0
compressed_text,204,"(iterable)",false,"BranchName.join","join","BranchName","{}",1,"BranchName -> str","[""iterable""]","str","(iterable, /)",16,"BranchName","BranchName",11
"Get first n rows (default 5)",281,"(n=5)",false,"NodesTable.head","head","NodesTable","{}",1,"NodesTable -> Unknown","[]","Unknown","(n=5)",28,"NodesTable","NodesTable",0
"Filter edges and return new subgraph",400,"(filter)",false,"Subgraph.filter_edges","filter_edges","Subgraph","{}",1,"Subgraph -> Subgraph","[""filter""]","Subgraph","(filter)",19,"Subgraph","Subgraph",19
"Global sum of all elements in the matrix",498,"()",false,"GraphMatrix.sum","sum","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Create matrix from graph attributes",454,"(_graph, _attrs, _entities)",false,"GraphMatrix.from_graph_attributes","from_graph_attributes","GraphMatrix","{}",3,"GraphMatrix -> Graph","[""_graph"", ""_attrs"", ""_entities""]","Graph","(_graph, _attrs, _entities)",40,"GraphMatrix","GraphMatrix",37
compressed_text,154,"(column, periods=None)",false,"BaseTable.pct_change","pct_change","BaseTable","{}",2,"BaseTable -> float","[""column""]","float","(column, periods=None)",34,"BaseTable","BaseTable",2
"Return a copy of the string converted to lowercase.",77,"()",false,"AttrName.lower","lower","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,449,"(condition)",false,"GraphMatrix.filter","filter","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""condition""]","Matrix","(condition)",40,"GraphMatrix","GraphMatrix",38
"Export NodesTable to Parquet file ",300,"(path)",false,"NodesTable.to_parquet","to_parquet","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Convert subgraph edges to a table - pure delegation to core GraphTable",398,"()",false,"Subgraph.edges_table","edges_table","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Check if node exists - DELEGATED (same as has_node)",14,"(node)",false,"Graph.contains_node","contains_node","Graph","{}",1,"Graph -> Unknown","[""node""]","Unknown","(node)",37,"Graph","Graph",0
"Convert table to EdgesAccessor by extracting edge IDs from the table",266,"()",false,"GraphTable.to_edges","to_edges","GraphTable","{}",0,"GraphTable -> EdgesAccessor","[]","EdgesAccessor","()",35,"GraphTable","GraphTable",17
"Dropout operation for regularization",444,"(p, training=None)",false,"GraphMatrix.dropout","dropout","GraphMatrix","{}",2,"GraphMatrix -> Unknown","[""p""]","Unknown","(p, training=None)",40,"GraphMatrix","GraphMatrix",0
compressed_text,183,"(other)",false,"BaseTable.union","union","BaseTable","{}",1,"BaseTable -> Unknown","[""other""]","Unknown","(other)",34,"BaseTable","BaseTable",0
"Auto-assign edge IDs for null values (useful for meta nodes)",304,"()",false,"EdgesTable.auto_assign_edge_ids","auto_assign_edge_ids","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
compressed_text,101,"(func, axis=None, result_name=None)",false,"BaseTable.apply","apply","BaseTable","{}",3,"BaseTable -> Transformed","[""func""]","Transformed","(func, axis=None, result_name=None)",34,"BaseTable","BaseTable",7
compressed_text,163,"(new_order)",false,"BaseTable.reorder_columns","reorder_columns","BaseTable","{}",1,"BaseTable -> list","[""new_order""]","list","(new_order)",34,"BaseTable","BaseTable",22
compressed_text,95,"(prefix)",false,"BaseTable.add_prefix","add_prefix","BaseTable","{}",1,"BaseTable -> str","[""prefix""]","str","(prefix)",34,"BaseTable","BaseTable",11
"Split matrix along specified axis",494,"(split_points, axis)",false,"GraphMatrix.split","split","GraphMatrix","{}",2,"GraphMatrix -> Matrix","[""split_points"", ""axis""]","Matrix","(split_points, axis)",40,"GraphMatrix","GraphMatrix",38
compressed_text,99,"(row_data)",false,"BaseTable.append","append","BaseTable","{}",1,"BaseTable -> dict","[""row_data""]","dict","(row_data)",34,"BaseTable","BaseTable",5
compressed_text,308,"(predicate)",false,"EdgesTable.filter","filter","EdgesTable","{}",1,"EdgesTable -> str","[""predicate""]","str","(predicate)",21,"EdgesTable","EdgesTable",11
"Get target node IDs  ",333,"()",false,"EdgesTable.targets","targets","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
compressed_text,239,"(node_id)",false,"NodesAccessor.get_meta_node","get_meta_node","NodesAccessor","{}",1,"NodesAccessor -> Subgraph","[""node_id""]","Subgraph","(node_id)",20,"NodesAccessor","NodesAccessor",19
"Edge count property",396,"()",false,"Subgraph.edge_count","edge_count","Subgraph","{}",0,"Subgraph -> Unknown","[]","Unknown","()",19,"Subgraph","Subgraph",0
compressed_text,96,"(suffix)",false,"BaseTable.add_suffix","add_suffix","BaseTable","{}",1,"BaseTable -> str","[""suffix""]","str","(suffix)",34,"BaseTable","BaseTable",11
compressed_text,116,"(columns)",false,"BaseTable.drop_columns","drop_columns","BaseTable","{}",1,"BaseTable -> list","[""columns""]","list","(columns)",34,"BaseTable","BaseTable",22
"Get table iterator for chaining",286,"()",false,"NodesTable.iter","iter","NodesTable","{}",0,"NodesTable -> Unknown","[]","Unknown","()",28,"NodesTable","NodesTable",0
compressed_text,387,compressed_text,false,"Subgraph.collapse","collapse","Subgraph","{}",9,"Subgraph -> dict","[]","dict",compressed_text,19,"Subgraph","Subgraph",5
"Group nodes by attribute value and compute aggregates (public method for benchmarks)",28,"(attribute, aggregation_attr, operation)",false,"Graph.group_by","group_by","Graph","{}",3,"Graph -> Unknown","[""attribute"", ""aggregation_attr"", ""operation""]","Unknown","(attribute, aggregation_attr, operation)",37,"Graph","Graph",0
compressed_text,117,"(subset=None)",false,"BaseTable.drop_duplicates","drop_duplicates","BaseTable","{}",1,"BaseTable -> list","[]","list","(subset=None)",34,"BaseTable","BaseTable",22
"Zero out all gradients in the computation graph",516,"()",false,"GraphMatrix.zero_grad","zero_grad","GraphMatrix","{}",0,"GraphMatrix -> Graph","[]","Graph","()",40,"GraphMatrix","GraphMatrix",37
"DFS traversal - delegates to PyGraphAnalysis helper  ",17,"(start, max_depth=None, inplace=None, attr_name=None)",false,"Graph.dfs","dfs","Graph","{}",4,"Graph -> GraphAnalysis","[""start""]","GraphAnalysis","(start, max_depth=None, inplace=None, attr_name=None)",37,"Graph","Graph",32
"Return a version of the string suitable for caseless comparisons.",188,"()",false,"BranchName.casefold","casefold","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,160,"(column, quantiles, interpolation=None)",false,"BaseTable.quantiles","quantiles","BaseTable","{}",3,"BaseTable -> list","[""column"", ""quantiles""]","list","(column, quantiles, interpolation=None)",34,"BaseTable","BaseTable",22
"Get node IDs",288,"()",false,"NodesTable.node_ids","node_ids","NodesTable","{}",0,"NodesTable -> Unknown","[]","Unknown","()",28,"NodesTable","NodesTable",0
"Collapse subgraph to a single node with aggregated attributes",388,"(agg_functions)",false,"Subgraph.collapse_to_node","collapse_to_node","Subgraph","{}",1,"Subgraph -> Subgraph","[""agg_functions""]","Subgraph","(agg_functions)",19,"Subgraph","Subgraph",19
compressed_text,230,"()",false,"NodeId.bit_length","bit_length","NodeId","{}",0,"NodeId -> float","[]","float","()",31,"NodeId","NodeId",2
compressed_text,208,"(sep)",false,"BranchName.partition","partition","BranchName","{}",1,"BranchName -> str","[""sep""]","str","(sep, /)",16,"BranchName","BranchName",11
"Create a zero matrix with specified dimensions and type",517,"(rows, cols, dtype=None)",false,"GraphMatrix.zeros","zeros","GraphMatrix","{}",3,"GraphMatrix -> Matrix","[""rows"", ""cols""]","Matrix","(rows, cols, dtype=None)",40,"GraphMatrix","GraphMatrix",38
"Get first n rows (primarily from nodes table, default 5)",255,"(n=5)",false,"GraphTable.head","head","GraphTable","{}",1,"GraphTable -> Unknown","[]","Unknown","(n=5)",35,"GraphTable","GraphTable",0
compressed_text,214,"(sep=None, maxsplit=-1)",false,"BranchName.rsplit","rsplit","BranchName","{}",2,"BranchName -> list","[]","list","(sep=None, maxsplit=-1)",16,"BranchName","BranchName",22
"Apply aggregation to all tables - placeholder method",374,"(agg_spec)",false,"TableArray.agg","agg","TableArray","{}",1,"TableArray -> Unknown","[""agg_spec""]","Unknown","(agg_spec)",23,"TableArray","TableArray",0
"Get number of rows",289,"()",false,"NodesTable.nrows","nrows","NodesTable","{}",0,"NodesTable -> float","[]","float","()",28,"NodesTable","NodesTable",2
compressed_text,147,"(column)",false,"BaseTable.median","median","BaseTable","{}",1,"BaseTable -> Median","[""column""]","Median","(column)",34,"BaseTable","BaseTable",10
"Check if this subgraph contains nodes that are meta-nodes",407,"()",false,"Subgraph.has_meta_nodes","has_meta_nodes","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
compressed_text,112,"(column)",false,"BaseTable.cummax","cummax","BaseTable","{}",1,"BaseTable -> BaseArray","[""column""]","BaseArray","(column)",34,"BaseTable","BaseTable",26
compressed_text,127,"(predicate)",false,"BaseTable.filter","filter","BaseTable","{}",1,"BaseTable -> str","[""predicate""]","str","(predicate)",34,"BaseTable","BaseTable",11
"Get shape as (rows, cols)",292,"()",false,"NodesTable.shape","shape","NodesTable","{}",0,"NodesTable -> Unknown","[]","Unknown","()",28,"NodesTable","NodesTable",0
"Parse the 'on' parameter for join operations",153,"(on)",false,"BaseTable.parse_join_on","parse_join_on","BaseTable","{}",1,"BaseTable -> Unknown","[""on""]","Unknown","(on)",34,"BaseTable","BaseTable",0
"Get rich display representation using Rust formatter",164,"(config=None)",false,"BaseTable.rich_display","rich_display","BaseTable","{}",1,"BaseTable -> Unknown","[]","Unknown","(config=None)",34,"BaseTable","BaseTable",0
"Element-wise square root",495,"()",false,"GraphMatrix.sqrt","sqrt","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Filter edges by source nodes",310,"(source_nodes)",false,"EdgesTable.filter_by_sources","filter_by_sources","EdgesTable","{}",1,"EdgesTable -> Unknown","[""source_nodes""]","Unknown","(source_nodes)",21,"EdgesTable","EdgesTable",0
"Compute multiple percentiles for a specific column",156,"(column, percentiles, interpolation=None)",false,"BaseTable.percentiles","percentiles","BaseTable","{}",3,"BaseTable -> Unknown","[""column"", ""percentiles""]","Unknown","(column, percentiles, interpolation=None)",34,"BaseTable","BaseTable",0
"Get historical view at specific commit (FFI wrapper around core history system)",35,"(commit_id)",false,"Graph.historical_view","historical_view","Graph","{}",1,"Graph -> Commit","[""commit_id""]","Commit","(commit_id)",37,"Graph","Graph",18
compressed_text,186,"(column)",false,"BaseTable.var","var","BaseTable","{}",1,"BaseTable -> Variance","[""column""]","Variance","(column)",34,"BaseTable","BaseTable",8
"Global mean of all elements in the matrix  ",471,"()",false,"GraphMatrix.mean","mean","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,103,"(func, result_name=None)",false,"BaseTable.apply_to_rows","apply_to_rows","BaseTable","{}",2,"BaseTable -> int","[""func""]","int","(func, result_name=None)",34,"BaseTable","BaseTable",6
"Matrix power - raise matrix to integer power
Returns: new GraphMatrix that is self^n",480,"(n)",false,"GraphMatrix.power","power","GraphMatrix","{}",1,"GraphMatrix -> int","[""n""]","int","(n)",40,"GraphMatrix","GraphMatrix",6
compressed_text,343,"(port=None, layout=None, theme=None, width=None, height=None)",false,"NodesArray.interactive","interactive","NodesArray","{}",5,"NodesArray -> float","[]","float","(port=None, layout=None, theme=None, width=None, height=None)",39,"NodesArray","NodesArray",2
"BFS traversal - delegates to PyGraphAnalysis helper",8,"(start, max_depth=None, inplace=None, attr_name=None)",false,"Graph.bfs","bfs","Graph","{}",4,"Graph -> GraphAnalysis","[""start""]","GraphAnalysis","(start, max_depth=None, inplace=None, attr_name=None)",37,"Graph","Graph",32
compressed_text,69,"()",false,"AttrName.islower","islower","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,199,"()",false,"BranchName.isnumeric","isnumeric","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Get entire row as BaseArray (mixed types) or NumArray (if all numerical)",460,"(row)",false,"GraphMatrix.get_row","get_row","GraphMatrix","{}",1,"GraphMatrix -> BaseArray","[""row""]","BaseArray","(row)",40,"GraphMatrix","GraphMatrix",26
"Get shortest path - delegates to PyGraphAnalysis helper",52,"(source, target, weight_attribute=None, inplace=None, attr_name=None)",false,"Graph.shortest_path","shortest_path","Graph","{}",5,"Graph -> GraphAnalysis","[""source"", ""target""]","GraphAnalysis","(source, target, weight_attribute=None, inplace=None, attr_name=None)",37,"Graph","Graph",32
"Convert node attributes to matrix
Implements: g.nodes.matrix()",242,"()",false,"NodesAccessor.matrix","matrix","NodesAccessor","{}",0,"NodesAccessor -> Matrix","[]","Matrix","()",20,"NodesAccessor","NodesAccessor",38
"Create subgraph representing shortest path between two nodes",425,"(source, target)",false,"Subgraph.shortest_path_subgraph","shortest_path_subgraph","Subgraph","{}",2,"Subgraph -> Subgraph","[""source"", ""target""]","Subgraph","(source, target)",19,"Subgraph","Subgraph",19
"",4,"(data, uid_key=None)",false,"Graph.add_nodes","add_nodes","Graph","{}",2,"Graph -> Unknown","[""data""]","Unknown","(data, uid_key=None)",37,"Graph","Graph",0
compressed_text,94,"(width)",false,"AttrName.zfill","zfill","AttrName","{}",1,"AttrName -> str","[""width""]","str","(width, /)",15,"AttrName","AttrName",11
"Convert graph to attribute matrix - delegates to PyGraphMatrixHelper",54,"()",false,"Graph.to_matrix","to_matrix","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
compressed_text,125,"(fill_values)",false,"BaseTable.fillna","fillna","BaseTable","{}",1,"BaseTable -> Unknown","[""fill_values""]","Unknown","(fill_values)",34,"BaseTable","BaseTable",0
"Return a version of the string suitable for caseless comparisons.",59,"()",false,"AttrName.casefold","casefold","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Get first n rows (default 5)",317,"(n=5)",false,"EdgesTable.head","head","EdgesTable","{}",1,"EdgesTable -> Unknown","[]","Unknown","(n=5)",21,"EdgesTable","EdgesTable",0
"Get standard Laplacian matrix (D - A)",507,"()",false,"GraphMatrix.to_laplacian","to_laplacian","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,72,"()",false,"AttrName.isspace","isspace","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,76,"(width, fillchar= )",false,"AttrName.ljust","ljust","AttrName","{}",2,"AttrName -> str","[""width""]","str","(width, fillchar=' ', /)",15,"AttrName","AttrName",11
"Get edge IDs as a NumArray for numerical operations
Implements: g.edges.ids()",247,"()",false,"EdgesAccessor.ids","ids","EdgesAccessor","{}",0,"EdgesAccessor -> NumArray","[]","NumArray","()",17,"EdgesAccessor","EdgesAccessor",27
"Export NodesTable to JSON file",298,"(path)",false,"NodesTable.to_json","to_json","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Set multiple edge attributes (bulk operation) - delegates to accessor  ",423,"(attrs_dict)",false,"Subgraph.set_edge_attrs","set_edge_attrs","Subgraph","{}",1,"Subgraph -> Unknown","[""attrs_dict""]","Unknown","(attrs_dict)",19,"Subgraph","Subgraph",0
compressed_text,129,"(data)",false,"BaseTable.from_dict","from_dict","BaseTable","{}",1,"BaseTable -> dict","[""data""]","dict","(data)",34,"BaseTable","BaseTable",5
compressed_text,280,"(columns)",false,"NodesTable.group_by","group_by","NodesTable","{}",1,"NodesTable -> list","[""columns""]","list","(columns)",28,"NodesTable","NodesTable",22
"Get statistics about the NodesAccessor collection",347,"()",false,"NodesArray.stats","stats","NodesArray","{}",0,"NodesArray -> NodesAccessor","[]","NodesAccessor","()",39,"NodesArray","NodesArray",20
"Get rich display representation with EdgesTable type",325,"(config=None)",false,"EdgesTable.rich_display","rich_display","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[]","EdgesTable","(config=None)",21,"EdgesTable","EdgesTable",21
"Convert to pandas DataFrame",336,"()",false,"EdgesTable.to_pandas","to_pandas","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
"Get column by name as BaseArray (mixed types) or NumArray (if all numerical)",459,"(name)",false,"GraphMatrix.get_column_by_name","get_column_by_name","GraphMatrix","{}",1,"GraphMatrix -> BaseArray","[""name""]","BaseArray","(name)",40,"GraphMatrix","GraphMatrix",26
compressed_text,218,"(chars=None)",false,"BranchName.strip","strip","BranchName","{}",1,"BranchName -> str","[]","str","(chars=None, /)",16,"BranchName","BranchName",11
compressed_text,62,"(tabsize=8)",false,"AttrName.expandtabs","expandtabs","AttrName","{}",1,"AttrName -> Unknown","[]","Unknown","(tabsize=8)",15,"AttrName","AttrName",0
compressed_text,79,"(sep)",false,"AttrName.partition","partition","AttrName","{}",1,"AttrName -> str","[""sep""]","str","(sep, /)",15,"AttrName","AttrName",11
compressed_text,256,"(bundle_path)",false,"GraphTable.load_bundle","load_bundle","GraphTable","{}",1,"GraphTable -> Graph","[""bundle_path""]","Graph","(bundle_path)",35,"GraphTable","GraphTable",37
"Get number of columns",323,"()",false,"EdgesTable.ncols","ncols","EdgesTable","{}",0,"EdgesTable -> float","[]","float","()",21,"EdgesTable","EdgesTable",2
compressed_text,110,"(ddof=None)",false,"BaseTable.cov","cov","BaseTable","{}",1,"BaseTable -> float","[]","float","(ddof=None)",34,"BaseTable","BaseTable",2
"Get the first NodesAccessor",342,"()",false,"NodesArray.first","first","NodesArray","{}",0,"NodesArray -> NodesAccessor","[]","NodesAccessor","()",39,"NodesArray","NodesArray",20
compressed_text,225,"()",false,"EdgeId.as_integer_ratio","as_integer_ratio","EdgeId","{}",0,"EdgeId -> int","[]","int","()",12,"EdgeId","EdgeId",6
"Convert matrix to nested Python list
Returns: [[row1], [row2], ...] format",508,"()",false,"GraphMatrix.to_list","to_list","GraphMatrix","{}",0,"GraphMatrix -> list","[]","list","()",40,"GraphMatrix","GraphMatrix",22
compressed_text,162,"(columns)",false,"BaseTable.rename","rename","BaseTable","{}",1,"BaseTable -> dict","[""columns""]","dict","(columns)",34,"BaseTable","BaseTable",5
compressed_text,216,"(sep=None, maxsplit=-1)",false,"BranchName.split","split","BranchName","{}",2,"BranchName -> list","[]","list","(sep=None, maxsplit=-1)",16,"BranchName","BranchName",22
"Get column as numeric array if possible (returns NumArray/IntArray or error)",132,"(column_name)",false,"BaseTable.get_column_numeric","get_column_numeric","BaseTable","{}",1,"BaseTable -> list","[""column_name""]","list","(column_name)",34,"BaseTable","BaseTable",22
compressed_text,271,"(bundle_path)",false,"GraphTable.verify_bundle","verify_bundle","GraphTable","{}",1,"GraphTable -> dict","[""bundle_path""]","dict","(bundle_path)",35,"GraphTable","GraphTable",5
"Convert to Python list",349,"()",false,"NodesArray.to_list","to_list","NodesArray","{}",0,"NodesArray -> list","[]","list","()",39,"NodesArray","NodesArray",22
"SVD decomposition: A = U * Σ * V^T
Returns tuple of (U, singular_values, V_transpose)",501,"()",false,"GraphMatrix.svd","svd","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
compressed_text,212,"(width, fillchar= )",false,"BranchName.rjust","rjust","BranchName","{}",2,"BranchName -> str","[""width""]","str","(width, fillchar=' ', /)",16,"BranchName","BranchName",11
compressed_text,251,"(attr_name=None)",false,"EdgesAccessor.weight_matrix","weight_matrix","EdgesAccessor","{}",1,"EdgesAccessor -> Matrix","[]","Matrix","(attr_name=None)",17,"EdgesAccessor","EdgesAccessor",38
compressed_text,58,"()",false,"AttrName.capitalize","capitalize","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Get unique values for an attribute",301,"(attr_name)",false,"NodesTable.unique_attr_values","unique_attr_values","NodesTable","{}",1,"NodesTable -> Unknown","[""attr_name""]","Unknown","(attr_name)",28,"NodesTable","NodesTable",0
"Sum along specified axis (0=rows, 1=columns)",499,"(axis)",false,"GraphMatrix.sum_axis","sum_axis","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[""axis""]","Unknown","(axis)",40,"GraphMatrix","GraphMatrix",0
"Get single cell value at (row, col)",457,"(row, col)",false,"GraphMatrix.get_cell","get_cell","GraphMatrix","{}",2,"GraphMatrix -> Unknown","[""row"", ""col""]","Unknown","(row, col)",40,"GraphMatrix","GraphMatrix",0
"Return a copy of the string converted to lowercase.",206,"()",false,"BranchName.lower","lower","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Filter edges by target nodes",311,"(target_nodes)",false,"EdgesTable.filter_by_targets","filter_by_targets","EdgesTable","{}",1,"EdgesTable -> Unknown","[""target_nodes""]","Unknown","(target_nodes)",21,"EdgesTable","EdgesTable",0
compressed_text,87,"(sep=None, maxsplit=-1)",false,"AttrName.split","split","AttrName","{}",2,"AttrName -> list","[]","list","(sep=None, maxsplit=-1)",15,"AttrName","AttrName",22
compressed_text,106,"(column_name)",false,"BaseTable.column","column","BaseTable","{}",1,"BaseTable -> BaseArray","[""column_name""]","BaseArray","(column_name)",34,"BaseTable","BaseTable",26
"Iterate over rows - returns iterator of BaseArrays or NumArrays",464,"()",false,"GraphMatrix.iter_rows","iter_rows","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Convert uppercase characters to lowercase and lowercase characters to uppercase.",90,"()",false,"AttrName.swapcase","swapcase","AttrName","{}",0,"AttrName -> Unknown","[]","Unknown","()",15,"AttrName","AttrName",0
"Get shape as (rows, cols)",263,"()",false,"GraphTable.shape","shape","GraphTable","{}",0,"GraphTable -> Unknown","[]","Unknown","()",35,"GraphTable","GraphTable",0
"Get out-degree of nodes within subgraph",420,"(nodes=None, full_graph=False)",false,"Subgraph.out_degree","out_degree","Subgraph","{}",2,"Subgraph -> Subgraph","[]","Subgraph","(nodes=None, full_graph=False)",19,"Subgraph","Subgraph",19
compressed_text,201,"()",false,"BranchName.isspace","isspace","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Compute gradients via backpropagation",438,"()",false,"GraphMatrix.backward","backward","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
compressed_text,91,"()",false,"AttrName.title","title","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
"Merge with conflict resolution strategy",259,"(tables, strategy)",false,"GraphTable.merge_with_strategy","merge_with_strategy","GraphTable","{}",2,"GraphTable -> Unknown","[""tables"", ""strategy""]","Unknown","(tables, strategy)",35,"GraphTable","GraphTable",0
"Get bulk node attributes - delegates to PyGraphAttr",26,"(nodes, attrs)",false,"Graph.get_node_attrs","get_node_attrs","Graph","{}",2,"Graph -> GraphAttr","[""nodes"", ""attrs""]","GraphAttr","(nodes, attrs)",37,"Graph","Graph",33
"Get an EdgesTable representation of accessible edges
Implements: g.edges.table()  ",250,"()",false,"EdgesAccessor.table","table","EdgesAccessor","{}",0,"EdgesAccessor -> EdgesTable","[]","EdgesTable","()",17,"EdgesAccessor","EdgesAccessor",21
compressed_text,197,"()",false,"BranchName.isidentifier","isidentifier","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,64,"()",false,"AttrName.isalpha","isalpha","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,85,"(sep=None, maxsplit=-1)",false,"AttrName.rsplit","rsplit","AttrName","{}",2,"AttrName -> list","[]","list","(sep=None, maxsplit=-1)",15,"AttrName","AttrName",22
compressed_text,185,"(column, sort=None, ascending=None, dropna=None)",false,"BaseTable.value_counts","value_counts","BaseTable","{}",4,"BaseTable -> Table","[""column""]","Table","(column, sort=None, ascending=None, dropna=None)",34,"BaseTable","BaseTable",29
compressed_text,203,"()",false,"BranchName.isupper","isupper","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
compressed_text,234,"()",false,"StateId.bit_length","bit_length","StateId","{}",0,"StateId -> float","[]","float","()",9,"StateId","StateId",2
"Direct delegation: Apply table() to each component and return PyTableArray",523,"()",false,"ComponentsArray.table","table","ComponentsArray","{}",0,"ComponentsArray -> TableArray","[]","TableArray","()",30,"ComponentsArray","ComponentsArray",23
"Get rich display representation using Rust formatter",488,"(config=None)",false,"GraphMatrix.rich_display","rich_display","GraphMatrix","{}",1,"GraphMatrix -> Unknown","[]","Unknown","(config=None)",40,"GraphMatrix","GraphMatrix",0
compressed_text,246,"(attr_name)",false,"EdgesAccessor.group_by","group_by","EdgesAccessor","{}",1,"EdgesAccessor -> list","[""attr_name""]","list","(attr_name)",17,"EdgesAccessor","EdgesAccessor",22
compressed_text,171,"(mask, column_name, value)",false,"BaseTable.set_values_by_mask","set_values_by_mask","BaseTable","{}",3,"BaseTable -> list","[""mask"", ""column_name"", ""value""]","list","(mask, column_name, value)",34,"BaseTable","BaseTable",22
compressed_text,217,"(keepends=False)",false,"BranchName.splitlines","splitlines","BranchName","{}",1,"BranchName -> list","[]","list","(keepends=False)",16,"BranchName","BranchName",22
compressed_text,249,"(attrs_dict)",false,"EdgesAccessor.set_attrs","set_attrs","EdgesAccessor","{}",1,"EdgesAccessor -> Graph","[""attrs_dict""]","Graph","(attrs_dict)",17,"EdgesAccessor","EdgesAccessor",37
compressed_text,221,"(table)",false,"BranchName.translate","translate","BranchName","{}",1,"BranchName -> dict","[""table""]","dict","(table, /)",16,"BranchName","BranchName",5
compressed_text,111,"(col1, col2, ddof=None)",false,"BaseTable.cov_columns","cov_columns","BaseTable","{}",3,"BaseTable -> float","[""col1"", ""col2""]","float","(col1, col2, ddof=None)",34,"BaseTable","BaseTable",2
compressed_text,22,"(filter)",false,"Graph.filter_nodes","filter_nodes","Graph","{}",1,"Graph -> str","[""filter""]","str","(filter)",37,"Graph","Graph",11
compressed_text,80,"(prefix)",false,"AttrName.removeprefix","removeprefix","AttrName","{}",1,"AttrName -> str","[""prefix""]","str","(prefix, /)",15,"AttrName","AttrName",11
"Create a dense materialized version of the matrix",441,"()",false,"GraphMatrix.dense","dense","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
"Get all meta-nodes within this subgraph",416,"()",false,"Subgraph.meta_nodes","meta_nodes","Subgraph","{}",0,"Subgraph -> Subgraph","[]","Subgraph","()",19,"Subgraph","Subgraph",19
"Get unique values as a new NumArray",365,"()",false,"NumArray.unique","unique","NumArray","{}",0,"NumArray -> NumArray","[]","NumArray","()",27,"NumArray","NumArray",27
"Determinant calculation (for square matrices)",443,"()",false,"GraphMatrix.determinant","determinant","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
compressed_text,503,"(reps)",false,"GraphMatrix.tile","tile","GraphMatrix","{}",1,"GraphMatrix -> float","[""reps""]","float","(reps)",40,"GraphMatrix","GraphMatrix",2
"Get preview of matrix for display (first N rows/cols by default)",481,"(row_limit=None, col_limit=None)",false,"GraphMatrix.preview","preview","GraphMatrix","{}",2,"GraphMatrix -> Matrix","[]","Matrix","(row_limit=None, col_limit=None)",40,"GraphMatrix","GraphMatrix",38
compressed_text,2,"(other)",false,"Graph.add_graph","add_graph","Graph","{}",1,"Graph -> Graph","[""other""]","Graph","(other)",37,"Graph","Graph",37
compressed_text,67,"()",false,"AttrName.isdigit","isdigit","AttrName","{}",0,"AttrName -> str","[]","str","()",15,"AttrName","AttrName",11
compressed_text,512,"()",false,"GraphMatrix.to_table_for_streaming","to_table_for_streaming","GraphMatrix","{}",0,"GraphMatrix -> BaseTable","[]","BaseTable","()",40,"GraphMatrix","GraphMatrix",34
"Apply table() to each NodesAccessor and return TableArray",348,"()",false,"NodesArray.table","table","NodesArray","{}",0,"NodesArray -> TableArray","[]","TableArray","()",39,"NodesArray","NodesArray",23
"List all branches (FFI wrapper around core history system)",9,"()",false,"Graph.branches","branches","Graph","{}",0,"Graph -> list","[]","list","()",37,"Graph","Graph",22
"Get neighborhood sampling performance statistics",39,"()",false,"Graph.neighborhood_statistics","neighborhood_statistics","Graph","{}",0,"Graph -> Unknown","[]","Unknown","()",37,"Graph","Graph",0
compressed_text,151,"(n, column_name)",false,"BaseTable.nsmallest","nsmallest","BaseTable","{}",2,"BaseTable -> float","[""n"", ""column_name""]","float","(n, column_name)",34,"BaseTable","BaseTable",2
"Get a GraphTable representation of this graph
Implements: g.table()",53,"()",false,"Graph.table","table","Graph","{}",0,"Graph -> Graph","[]","Graph","()",37,"Graph","Graph",37
"ReLU activation applied to matrix
Implements: matrix.relu()",484,"()",false,"GraphMatrix.relu","relu","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,196,"()",false,"BranchName.isdigit","isdigit","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Remove multiple nodes from the graph",46,"(nodes)",false,"Graph.remove_nodes","remove_nodes","Graph","{}",1,"Graph -> Graph","[""nodes""]","Graph","(nodes)",37,"Graph","Graph",37
compressed_text,409,"(node1_id, node2_id)",false,"Subgraph.has_path","has_path","Subgraph","{}",2,"Subgraph -> Subgraph","[""node1_id"", ""node2_id""]","Subgraph","(node1_id, node2_id)",19,"Subgraph","Subgraph",19
"Export BaseTable to Parquet file ",182,"(path)",false,"BaseTable.to_parquet","to_parquet","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
"Filter all tables using a query - placeholder method",376,"(query)",false,"TableArray.filter","filter","TableArray","{}",1,"TableArray -> Unknown","[""query""]","Unknown","(query)",23,"TableArray","TableArray",0
"QR decomposition: A = Q * R
Returns tuple of (Q, R) where Q is orthogonal and R is upper triangular",482,"()",false,"GraphMatrix.qr_decomposition","qr_decomposition","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
compressed_text,98,"(agg_specs)",false,"BaseTable.aggregate","aggregate","BaseTable","{}",1,"BaseTable -> dict","[""agg_specs""]","dict","(agg_specs)",34,"BaseTable","BaseTable",5
"Get all attribute keys for an edge - delegates to PyGraphAttr",18,"(edge_id)",false,"Graph.edge_attribute_keys","edge_attribute_keys","Graph","{}",1,"Graph -> GraphAttr","[""edge_id""]","GraphAttr","(edge_id)",37,"Graph","Graph",33
compressed_text,173,"(column, periods, fill_value=None)",false,"BaseTable.shift","shift","BaseTable","{}",3,"BaseTable -> float","[""column"", ""periods""]","float","(column, periods, fill_value=None)",34,"BaseTable","BaseTable",2
compressed_text,142,"(other)",false,"BaseTable.intersect","intersect","BaseTable","{}",1,"BaseTable -> Unknown","[""other""]","Unknown","(other)",34,"BaseTable","BaseTable",0
compressed_text,189,"(width, fillchar= )",false,"BranchName.center","center","BranchName","{}",2,"BranchName -> str","[""width""]","str","(width, fillchar=' ', /)",16,"BranchName","BranchName",11
compressed_text,107,"()",false,"BaseTable.column_info","column_info","BaseTable","{}",0,"BaseTable -> dict","[]","dict","()",34,"BaseTable","BaseTable",5
"Check if a node exists in the graph - DELEGATED",32,"(node_id)",false,"Graph.has_node","has_node","Graph","{}",1,"Graph -> Graph","[""node_id""]","Graph","(node_id)",37,"Graph","Graph",37
"Export NodesTable to CSV file",297,"(path)",false,"NodesTable.to_csv","to_csv","NodesTable","{}",1,"NodesTable -> NodesTable","[""path""]","NodesTable","(path)",28,"NodesTable","NodesTable",28
"Tanh activation applied to matrix
Implements: matrix.tanh()",502,"()",false,"GraphMatrix.tanh","tanh","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,223,"(width)",false,"BranchName.zfill","zfill","BranchName","{}",1,"BranchName -> str","[""width""]","str","(width, /)",16,"BranchName","BranchName",11
compressed_text,293,"(start, end)",false,"NodesTable.slice","slice","NodesTable","{}",2,"NodesTable -> NodesTable","[""start"", ""end""]","NodesTable","(start, end)",28,"NodesTable","NodesTable",28
"",412,"(_other)",false,"Subgraph.intersect_with","intersect_with","Subgraph","{}",1,"Subgraph -> Unknown","[""_other""]","Unknown","(_other)",19,"Subgraph","Subgraph",0
"Enable or disable gradient tracking for this matrix",486,"(requires_grad)",false,"GraphMatrix.requires_grad_","requires_grad_","GraphMatrix","{}",1,"GraphMatrix -> Matrix","[""requires_grad""]","Matrix","(requires_grad)",40,"GraphMatrix","GraphMatrix",38
"Get single cell value at (row, col) - public interface",456,"(row, col)",false,"GraphMatrix.get","get","GraphMatrix","{}",2,"GraphMatrix -> Unknown","[""row"", ""col""]","Unknown","(row, col)",40,"GraphMatrix","GraphMatrix",0
"Get the number of edges in the graph - DELEGATED",19,"()",false,"Graph.edge_count","edge_count","Graph","{}",0,"Graph -> float","[]","float","()",37,"Graph","Graph",2
"Collect all tables into a Python list (for compatibility with iterator patterns)",375,"()",false,"TableArray.collect","collect","TableArray","{}",0,"TableArray -> list","[]","list","()",23,"TableArray","TableArray",22
"Convert to Pandas DataFrame (when pandas available)",511,"()",false,"GraphMatrix.to_pandas","to_pandas","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Get largest component without materializing others",519,"()",false,"ComponentsArray.largest_component","largest_component","ComponentsArray","{}",0,"ComponentsArray -> Unknown","[]","Unknown","()",30,"ComponentsArray","ComponentsArray",0
"Get node mapping for a specific attribute (FFI wrapper around core operations)",27,"(uid_key, return_inverse=False)",false,"Graph.get_node_mapping","get_node_mapping","Graph","{}",2,"Graph -> Unknown","[""uid_key""]","Unknown","(uid_key, return_inverse=False)",37,"Graph","Graph",0
"Global minimum value in the matrix",473,"()",false,"GraphMatrix.min","min","GraphMatrix","{}",0,"GraphMatrix -> Matrix","[]","Matrix","()",40,"GraphMatrix","GraphMatrix",38
compressed_text,136,"(group_cols, agg_specs)",false,"BaseTable.group_by_agg","group_by_agg","BaseTable","{}",2,"BaseTable -> dict","[""group_cols"", ""agg_specs""]","dict","(group_cols, agg_specs)",34,"BaseTable","BaseTable",5
compressed_text,144,"()",false,"BaseTable.isna","isna","BaseTable","{}",0,"BaseTable -> bool","[]","bool","()",34,"BaseTable","BaseTable",36
compressed_text,165,"(column, window, operation)",false,"BaseTable.rolling","rolling","BaseTable","{}",3,"BaseTable -> BaseArray","[""column"", ""window"", ""operation""]","BaseArray","(column, window, operation)",34,"BaseTable","BaseTable",26
compressed_text,105,"(column, factor=None)",false,"BaseTable.check_outliers","check_outliers","BaseTable","{}",2,"BaseTable -> float","[""column""]","float","(column, factor=None)",34,"BaseTable","BaseTable",2
"Import BaseTable from JSON file",130,"(path)",false,"BaseTable.from_json","from_json","BaseTable","{}",1,"BaseTable -> BaseTable","[""path""]","BaseTable","(path)",34,"BaseTable","BaseTable",34
compressed_text,168,"(columns)",false,"BaseTable.select","select","BaseTable","{}",1,"BaseTable -> list","[""columns""]","list","(columns)",34,"BaseTable","BaseTable",22
"Filter nodes and return new subgraph  ",401,"(filter)",false,"Subgraph.filter_nodes","filter_nodes","Subgraph","{}",1,"Subgraph -> Subgraph","[""filter""]","Subgraph","(filter)",19,"Subgraph","Subgraph",19
"Concatenate matrices along specified axis",440,"(other, axis)",false,"GraphMatrix.concatenate","concatenate","GraphMatrix","{}",2,"GraphMatrix -> Unknown","[""other"", ""axis""]","Unknown","(other, axis)",40,"GraphMatrix","GraphMatrix",0
"Generate dense HTML representation for small matrices",442,"()",false,"GraphMatrix.dense_html_repr","dense_html_repr","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Create a ones matrix with specified dimensions",479,"(rows, cols, dtype=None)",false,"GraphMatrix.ones","ones","GraphMatrix","{}",3,"GraphMatrix -> Matrix","[""rows"", ""cols""]","Matrix","(rows, cols, dtype=None)",40,"GraphMatrix","GraphMatrix",38
compressed_text,302,"(attr_name, attributes)",false,"NodesTable.with_attributes","with_attributes","NodesTable","{}",2,"NodesTable -> dict","[""attr_name"", ""attributes""]","dict","(attr_name, attributes)",28,"NodesTable","NodesTable",5
"Import EdgesTable from CSV file (must contain edge_id, source, target columns)",312,"(path)",false,"EdgesTable.from_csv","from_csv","EdgesTable","{}",1,"EdgesTable -> EdgesTable","[""path""]","EdgesTable","(path)",21,"EdgesTable","EdgesTable",21
"Get neighbors of nodes - delegates to PyGraphAnalysis helper",40,"(nodes=None)",false,"Graph.neighbors","neighbors","Graph","{}",1,"Graph -> GraphAnalysis","[]","GraphAnalysis","(nodes=None)",37,"Graph","Graph",32
"Get the number of nodes in the graph - DELEGATED",42,"()",false,"Graph.node_count","node_count","Graph","{}",0,"Graph -> float","[]","float","()",37,"Graph","Graph",2
compressed_text,113,"(column)",false,"BaseTable.cummin","cummin","BaseTable","{}",1,"BaseTable -> BaseArray","[""column""]","BaseArray","(column)",34,"BaseTable","BaseTable",26
compressed_text,124,"(rows)",false,"BaseTable.extend_rows","extend_rows","BaseTable","{}",1,"BaseTable -> list","[""rows""]","list","(rows)",34,"BaseTable","BaseTable",22
"Combine all NodesAccessor objects into a single unified NodesAccessor",351,"()",false,"NodesArray.union","union","NodesArray","{}",0,"NodesArray -> NodesAccessor","[]","NodesAccessor","()",39,"NodesArray","NodesArray",20
compressed_text,100,"(row)",false,"BaseTable.append_row","append_row","BaseTable","{}",1,"BaseTable -> dict","[""row""]","dict","(row)",34,"BaseTable","BaseTable",5
compressed_text,329,"(column, ascending=True)",false,"EdgesTable.sort_by","sort_by","EdgesTable","{}",2,"EdgesTable -> EdgesTable","[""column""]","EdgesTable","(column, ascending=True)",21,"EdgesTable","EdgesTable",21
"Fill null values with a single value for all columns",126,"(fill_value)",false,"BaseTable.fillna_all","fillna_all","BaseTable","{}",1,"BaseTable -> Unknown","[""fill_value""]","Unknown","(fill_value)",34,"BaseTable","BaseTable",0
compressed_text,146,"(other, on, how=None)",false,"BaseTable.join","join","BaseTable","{}",3,"BaseTable -> dict","[""other"", ""on""]","dict","(other, on, how=None)",34,"BaseTable","BaseTable",5
compressed_text,149,"(n, column_name)",false,"BaseTable.nlargest","nlargest","BaseTable","{}",2,"BaseTable -> float","[""n"", ""column_name""]","float","(n, column_name)",34,"BaseTable","BaseTable",2
compressed_text,167,"(n=None, fraction=None, weights=None, subset=None, class_weights=None, replace=False)",false,"BaseTable.sample","sample","BaseTable","{}",6,"BaseTable -> float","[]","float","(n=None, fraction=None, weights=None, subset=None, class_weights=None, replace=False)",34,"BaseTable","BaseTable",2
compressed_text,273,"(columns)",false,"NodesTable.drop_columns","drop_columns","NodesTable","{}",1,"NodesTable -> list","[""columns""]","list","(columns)",28,"NodesTable","NodesTable",22
compressed_text,172,"(start, end, column_name, value, step=1)",false,"BaseTable.set_values_by_range","set_values_by_range","BaseTable","{}",5,"BaseTable -> Unknown","[""start"", ""end"", ""column_name"", ""value""]","Unknown","(start, end, column_name, value, step=1)",34,"BaseTable","BaseTable",0
"Convert to different numeric type",352,"(dtype)",false,"NumArray.astype","astype","NumArray","{}",1,"NumArray -> float","[""dtype""]","float","(dtype)",27,"NumArray","NumArray",2
compressed_text,191,"(tabsize=8)",false,"BranchName.expandtabs","expandtabs","BranchName","{}",1,"BranchName -> Unknown","[]","Unknown","(tabsize=8)",16,"BranchName","BranchName",0
compressed_text,198,"()",false,"BranchName.islower","islower","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Iterate over columns - returns iterator of BaseArrays or NumArrays",463,"()",false,"GraphMatrix.iter_columns","iter_columns","GraphMatrix","{}",0,"GraphMatrix -> Unknown","[]","Unknown","()",40,"GraphMatrix","GraphMatrix",0
"Get adjacency list representation
Returns: Dict mapping node_id -> list of connected node_ids",381,"()",false,"Subgraph.adjacency_list","adjacency_list","Subgraph","{}",0,"Subgraph -> dict","[]","dict","()",19,"Subgraph","Subgraph",5
"Convert to a new independent graph",431,"()",false,"Subgraph.to_graph","to_graph","Subgraph","{}",0,"Subgraph -> Graph","[]","Graph","()",19,"Subgraph","Subgraph",37
"Get number of rows",324,"()",false,"EdgesTable.nrows","nrows","EdgesTable","{}",0,"EdgesTable -> float","[]","float","()",21,"EdgesTable","EdgesTable",2
compressed_text,194,"()",false,"BranchName.isascii","isascii","BranchName","{}",0,"BranchName -> str","[]","str","()",16,"BranchName","BranchName",11
"Filter nodes by attribute value",275,"(attr_name, value)",false,"NodesTable.filter_by_attr","filter_by_attr","NodesTable","{}",2,"NodesTable -> Unknown","[""attr_name"", ""value""]","Unknown","(attr_name, value)",28,"NodesTable","NodesTable",0
compressed_text,83,"(width, fillchar= )",false,"AttrName.rjust","rjust","AttrName","{}",2,"AttrName -> str","[""width""]","str","(width, fillchar=' ', /)",15,"AttrName","AttrName",11
compressed_text,89,"(chars=None)",false,"AttrName.strip","strip","AttrName","{}",1,"AttrName -> str","[]","str","(chars=None, /)",15,"AttrName","AttrName",11
"Convert back to Graph",267,"()",false,"GraphTable.to_graph","to_graph","GraphTable","{}",0,"GraphTable -> Graph","[]","Graph","()",35,"GraphTable","GraphTable",37
"Get table iterator for chaining",322,"()",false,"EdgesTable.iter","iter","EdgesTable","{}",0,"EdgesTable -> Unknown","[]","Unknown","()",21,"EdgesTable","EdgesTable",0
compressed_text,108,"(method=None)",false,"BaseTable.corr","corr","BaseTable","{}",1,"BaseTable -> float","[]","float","(method=None)",34,"BaseTable","BaseTable",2
compressed_text,215,"(chars=None)",false,"BranchName.rstrip","rstrip","BranchName","{}",1,"BranchName -> str","[]","str","(chars=None, /)",16,"BranchName","BranchName",11
"Get the last NodesAccessor  ",346,"()",false,"NodesArray.last","last","NodesArray","{}",0,"NodesArray -> NodesAccessor","[]","NodesAccessor","()",39,"NodesArray","NodesArray",20
compressed_text,118,"(indices)",false,"BaseTable.drop_rows","drop_rows","BaseTable","{}",1,"BaseTable -> list","[""indices""]","list","(indices)",34,"BaseTable","BaseTable",22
"Check if column exists",139,"(name)",false,"BaseTable.has_column","has_column","BaseTable","{}",1,"BaseTable -> Unknown","[""name""]","Unknown","(name)",34,"BaseTable","BaseTable",0