Saravanan666/pypi-org huggingface dataset:
Package: graphsim
graphsim--------Graph similarity algorithms based on NetworkX.**BSD Licensed**[![Build Status](https://travis-ci.org/caesar0301/graphsim.svg?branch=master)](https://travis-ci.org/caesar0301/graphsim)[![PyPI](https://img.shields.io/pypi/l/graphsim.svg)](https://pypi.python.org/pypi/graphsim)[![PyPI](https://img.shields.io/pypi/pyversions/graphsim.svg)](https://pypi.python.org/pypi/graphsim)[![PyPI](https://img.shields.io/pypi/status/graphsim.svg)](https://pypi.python.org/pypi/graphsim)Install-------First, install building tool:$ yum install -y sconsOn Mac OS:$ brew install sconsThen install graphsim via PyPI:$ pip install -U graphsimPermission Issues------------------By default, `sudo` is required to give permission to install cpp modules into system `/usr/local/{lib,include}`.If you prefer local installation, following instructions may help you:```bashexport LIBTACSIM_LIB_DIR=~/usr/lib/export LIBTACSIM_INC_DIR=~/usr/include/pip install -U graphsim```Make sure that the local directories are aware for C linkers:```bashexport LD_LIBRARY_PATH=~/usr/lib:$LD_LIBRARY_PATHexport C_INCLUDE_PATH=~/usr/include:$C_INCLUDE_PATHexport CPLUS_INCLUDE_PATH=~/usr/include:$CPLUS_INCLUDE_PATH```Coverage---------**NOTE**: `libtacsim` was tested on Ubuntu 12.04, Ubuntu 16.04, CentOS 6.5 and Mac OS 10.11.2, 10.13.2.Usage----->>> import graphsim as gsSupported algorithms--------------------* `gs.ascos`: Asymmetric network Structure COntext Similarity, by Hung-Hsuan Chen et al.* `gs.nsim_bvd04`: node-node similarity matrix, by Blondel et al.* `gs.hits`: the hub and authority scores for nodes, by Kleinberg.* `gs.nsim_hs03`: node-node similarity with mismatch penalty, by Heymans et al.* `gs.simrank`: A Measure of Structural-Context Similarity, by Jeh et al.* `gs.simrank_bipartite`: SimRank for bipartite graphs, by Jeh et al.* `gs.tacsim`: Topology-Attributes Coupling Similarity, by Xiaming Chen et al.* `gs.tacsim_combined`: A combined topology-attributes coupling similarity, by Xiaming Chen et al.* `gs.tacsim_in_C`: an efficient implementation of TACSim in pure C.* `gs.tacsim_combined_in_C`: an efficient implementation of combined TACSim in pure C.Supported utilities-------------------* `gs.normalized`: L2 normalization of vectors, matrices or arrays.* `gs.node_edge_adjacency`: Obtain node-edge adjacency matrices in source and dest directions.Citation----------```tex@article{Chen2017,title = "Discovering and modeling meta-structures in human behavior from city-scale cellular data",journal = "Pervasive and Mobile Computing ",year = "2017",issn = "1574-1192",doi = "http://dx.doi.org/10.1016/j.pmcj.2017.02.001",author = "Xiaming Chen and Haiyang Wang and Siwei Qiang and Yongkun Wang and Yaohui Jin"}```Author------Xiaming Chen <chenxm35@gmail.com>
Package: graphsite
GraphsiteGraphsite is a software written in Python that reads a pocket (in .mol2) and compute its graph representation. In each generated graph, each atom represents a node. If the distance between two atoms are less than or equal to a threshold (default is 4.5 Angstrom), an undirected edge is formed between these two atoms. The edge attribute is the number of chemical bond(s) on this edge.Intallationpip install graphsiteUsageGraphsite is invented for applications which are based on graph neural networks (GNNs). However, the scope of this tool is not limited to deep graph learning. It can be used in any application that requires graph representaions of proteins/binding sites.Basic usageThe main module of Graphsite is a callable class which reads 3 files as input:fromgraphsiteimportGraphsitegraphsite=Graphsite()node_feature,edge_index,edge_attr=pocket_to_graph(# path to the .mol2 file of pocketmol_path=mol_path,# path to the .profile file of pocket which# contains the sequence entropy node featureprofile_path=profile_path,# path to the .popsa file of pocket which contains# the solvent-accessible surface area node featurepop_path=pop_path)Thenode_feature,edge_index, andedge_attrare numpy arrays. For more information about input paramters and output formats, see help:A Pytorch exampleBelow is an example where the output matrices of graphsite are used to create graphs forPytorch-geometric.fromtorch_geometric.dataimportDatadata=Data(x=node_feature,edge_index=edge_index,edge_attr=edge_attr))For a complete deep learning example, please seeGraphsite-classifier, where we build a graph classifier over 14 classes of binding pockets.Cite our workPlease cite our paper if you find this package useful in your project :)Currently under peer reviewFeedbackIf you have any questions or suggestions, please submit an issue or pull request. Anyone is welcome to contribute :)
Package: graphslam
Documentation for this package can be found athttps://python-graphslam.readthedocs.io/.This package implements a Graph SLAM solver in Python.FeaturesOptimizeR^2,R^3,SE(2), andSE(3)datasetsAnalytic JacobiansSupports odometry and landmark edgesSupports custom edge types (seetests/test_custom_edge.pyfor an example)Import and export .g2o filesInstallationpip install graphslamExample UsageSE(3) Dataset>>>fromgraphslam.graphimportGraph>>>g=Graph.from_g2o("data/parking-garage.g2o")# https://lucacarlone.mit.edu/datasets/>>>g.plot(vertex_markersize=1)>>>g.calc_chi2()16720.02100546733>>>g.optimize()>>>g.plot(vertex_markersize=1)Output:Iteration                chi^2        rel. change
---------                -----        -----------
        0           16720.0210
        1              45.6644          -0.997269
        2               1.2936          -0.971671
        3               1.2387          -0.042457
        4               1.2387          -0.000001OriginalOptimizedSE(2) Dataset>>>fromgraphslam.graphimportGraph>>>g=Graph.from_g2o("data/input_INTEL.g2o")# https://lucacarlone.mit.edu/datasets/>>>g.plot()>>>g.calc_chi2()7191686.382493544>>>g.optimize()>>>g.plot()Output:Iteration                chi^2        rel. change
---------                -----        -----------
        0         7191686.3825
        1       319950425.6477          43.488929
        2       124950341.8035          -0.609470
        3          338165.0770          -0.997294
        4             734.7343          -0.997827
        5             215.8405          -0.706233
        6             215.8405          -0.000000OriginalOptimizedReferences and AcknowledgmentsGrisetti, G., Kummerle, R., Stachniss, C. and Burgard, W., 2010.A tutorial on graph-based SLAM. IEEE Intelligent Transportation Systems Magazine, 2(4), pp.31-43.Blanco, J.L., 2010.A tutorial on SE(3) transformation parameterizations and on-manifold optimization. University of Malaga, Tech. Rep, 3.Carlone, L., Tron, R., Daniilidis, K. and Dellaert, F., 2015, May.Initialization techniques for 3D SLAM: a survey on rotation estimation and its use in pose graph optimization. In 2015 IEEE international conference on robotics and automation (ICRA) (pp. 4597-4604). IEEE.Carlone, L. and Censi, A., 2014.From angular manifolds to the integer lattice: Guaranteed orientation estimation with application to pose graph optimization. IEEE Transactions on Robotics, 30(2), pp.475-492.Thanks to Luca Larlone for allowing inclusion of theIntel and parking garage datasetsin this repo.Live Coding Graph SLAM in PythonIf you’re interested, you can watch as I coded this up.Live coding Graph SLAM in Python (Part 1)Live coding Graph SLAM in Python (Part 2)Live coding Graph SLAM in Python (Part 3)Live coding Graph SLAM in Python (Part 4)Live coding Graph SLAM in Python (Part 5)
Package: graph-snapshot
graph_snapshot is a tool to visualize graph algorithms based on networkx (https://networkx.github.io/), pygraphviz (https://pygraphviz.github.io) and dot2tex (https://dot2tex.readthedocs.io/en/latest/#).Say you have a python script that runs Kruskal's algorithm on a networkx graph and you want to show how the algorithm works in your paper.The only thing you have to do is to import graph_snapshot, create snapshots of your graph at important moments during the algorithm and you'll get a directory of .tex files containing the tikz code for your graphs that are just waiting for you to include them into your Latex paper.If you want to give a talk presenting your algorithm, graph_snapshot makes things even easier for you by providing the beamer_slide function that will create one beamer slide with the images of your algorithm as overlays, so that you just need to input this slide in order to be able to 'click through the algorithm' in your talk.
Package: graphsp
GraphspProject descriptionThis project implements algorithms associated withGraph Data Structure.The following is the list of algorithm this library implements:Breadth First SearchDepth First SearchDijkstra (Single Source Shortest Path)Floyd Warshall (All Pairs Shortest Path)Installationpip install graphspUsagefrom graphsp import GraphInitializing graph objectgraph = graphsp.Graph(n, graph_type)n = Total number of nodesgraph_type = directed / undirected [in string]Initializing & Populating the graphgraph = graphsp.Graph(5, "undirected")

graph.bulk_link([(0, 4, 5), (0, 1, 1), (1, 4, 3),
                 (1, 3, 1), (1, 2, 15), (2, 3, 2), (3, 4, 3)])

print(graph.detect_cycle())Using different algorithmsdfs = DFS(n, graph)
print(dfs.dfs(start_node))

bfs = BFS(n, graph)
print(bfs.bfs(start_node))

dj = Dijkstra(n, graph)
print(dj.dijkstra(start_node))

bf = BellmanFord(n, graph)
print(bf.bellman_ford(start_node))

fw = FloydWarshall(n, graph)
print(fw.floyd_warshall())

ts = TopoSorting(n, graph)
print(ts.topo_sorting())

pr = Prim(n, graph)
print(pr.prim())

ks = Kruskal(n, graph)
print(ks.kruskal())

kr = Kosaraju(n, graph)
print(kr.kosaraju())n = Total number of nodesstart_node = Number on the desired starting nodegraph = Object of Graph classGithub repositoryhttps://github.com/jainam2385/graphspLicenseÂ© 2022 Jainam ShahThis repository is licensed under the MIT license. See LICENSE for details.
Package: graph-talk
Graph-TalkGraph-talk is a library for structured data processing to solve tasks like parsing,
interpreting, or converting in a simple and comprehensible manner.The library uses 3 key concepts to achieve the goal: a graph-like representation of
information and its processing; a dialog-like communication between the model and
the process; and a handler-event approach to recognize the input messages.Table of ContentsGraph-TalkFeaturesInstallationSupportCopyrights and LicenseFeaturesEasy to learn architectureHighly customizablePlain Python 2.7.5 or higherVery small footprintDOTexport (experimental)Check thedocsfor the documentation andexamplesfolder for examples of
lexing, interpreting, and converting using Graph-talk.InstallationFrompypi:$ pip install graph-talkEasy_install:$ easy_install graph-talkClone fromgithub:$ git clone git://github.com/krvss/graph-talk.gitSetuptools:$ cd graph-talk
$ sudo python setup.py installTesting:$ python setup.py testDocumentation withsphinx:$ sphinx-build -b html docs docs/htmlSupportIf you’re having problems using the project, make theissueat GitHub.Copyrights and Licensegraph-talkis protected by Apache Software License. Check theLICENSEfile for
details.
Package: graph-tensor
GraphThe goal is to build a Tensor-based computer graphics library that focuses on the field of computer vision.The graphic elements of this project refer to theCanvasof tkinter (Python 3.7 or later). The code implementation principle and the instruction manual can refer totutorialin this project.Graph_tensor user manual referencemanual.PyPI support availableYou can install the latest version using the following command:$pipinstallgraph-tensorThe following command is used when called:importgraph_tensorContributionYou are welcome to contribute new code. A detailed description of the package can be found inDeveloperGuide_enorDeveloperGuide_zh.ReferenceComputer Graphics from scratch👉Github
Package: graphtimer
graphtimerThis library is based around generating nice graphs for timings.
It's highly modular and provides an interface to quickly and cleanly use modules.The high-level interface is thePlotterclass which takes a timer class as its only argument. The builtin timer isMultiTimer, whereTimerNamespacebuilds it without you having to.From here you have three steps:Time the code by using the timer provided. Usual usage isrepeat, astimeitonly times the functions once and skips step 2.Perform the statistical analysis on the timings. Most of the time you'll want to usemin, which gets the lowest value that isn't an outlier. And shows the error bars from the lowest outlier to Q3.Plot the data on the graph. This by default usesmatplotlibvia theMatPlotLibclass.importmatplotlib.pyplotaspltfromgraphtimerimportPlotter,TimerNamespaceclassManualListCreation(TimerNamespace):deftest_comprehension(iterable):return[iforiiniterable]deftest_append(iterable):a=[]append=a.appendforiiniterable:append(i)returnafig,axs=plt.subplots()(Plotter(ManualListCreation).repeat(100,5,list(range(0,10001,1000)),args_conv=range).min().plot(axs))fig.show()InstallationTo install graphtimer, just use pip:$ pip install graphtimer
Package: graph-tool
graph-tool is an efficient python module for manipulation and statistical
analysis of graphs.Despite its nice, soft outer appearance of a regular python module, the core
algorithms and data structures of graph-tool are written in C++, making use of
the  Boost Graph Library and template metaprogramming, with performance in mind.
Most of the time, you can expect the algorithms to run just as fast as if
graph-tool were a pure C++ library.It contains several algorithms present in the Boost Graph Library, and many
others, such as random graph generation (with arbitrary degree sequence and
correlations), clustering, motifs, community detection, graph randomization,
subgraph isomorphism, etc.
Package: graph-tool-nn
Graph-tool is a great open source tool for creating, using and analyzing graphs. It’s a python
library with C++ bindings, uses boost::graph under the hood and seems to be pretty fast
(http://graph-tool.skewed.de/).Graph-tool Neural Networks (gtnn) is an implementation of ANN on top of graph-tool. It makes
researching neural networks nice&easy. You can create custom nets, train, analyze and plot them.
Package: graphtools
Tools for building and manipulating graphs in Python.Installationgraphtools is available onpip. Install by running the following in a terminal:pip install --user graphtoolsAlternatively, graphtools can be installed usingConda(most easily obtained via theMiniconda Python distribution):conda install -c conda-forge graphtoolsOr, to install the latest version from github:pip install --user git+git://github.com/KrishnaswamyLab/graphtools.gitUsage exampleThegraphtools.Graphclass provides an all-in-one interface for k-nearest neighbors, mutual nearest neighbors, exact (pairwise distances) and landmark graphs.Use it as follows:from sklearn import datasets
import graphtools
digits = datasets.load_digits()
G = graphtools.Graph(digits['data'])
K = G.kernel
P = G.diff_op
G = graphtools.Graph(digits['data'], n_landmark=300)
L = G.landmark_opHelpIf you have any questions or require assistance using graphtools, please contact us athttps://krishnaswamylab.org/get-help
Package: graph-tools
graph-tools Packagegraph_tools - tools for graph theory and network science with many generation modelsDESCRIPTIONThis manual page documentsgraph-toolsmodule, a Python module that
provides a number of features for handling directed/undirected graphs and
complex networks.graph-toolswas initially developed for networking
researchers, who perform experiments in the field of graph theory and network
science.graph-toolsprovides Graph class, which supports both directed
and undirected graphs with multi-edges, vertex weights, edge weights, and
graph attributes.  A number of graph/network generation models and graph
algorithms are supported.Major features ofgraph-toolsare:directed/undirected graph with multi-edges, vertex weights, edge weights,
and graph attributesvertex operations (add, delete, degree, neighbors, random vertex, and
set/get vertex attributes)edge operations (add, delete, random edge, and set/get edge attributes)graph operations (copy, adjacency matrix, diagonal matrix, Laplacian matrix)major graph algorithms (exploration, connectivity, components, maximal
component, Dijkstra, Floyd-Warshall, betweenness centrality)spectral graph theory (spectral radius, spectral gap, natural connectivity,
algebraic connectivity, effective_resistance, and spanning tree count)a number of graph/network generation models (random graph, ER (Erdos Renyi),
BA (Barabasi Albert), randomized BA, ring, tree, binary tree, BA tree,
generalized BA, latent, lattice, Voronoi, DB (Degree Bounded), configuration
model, random regular graph, Li-Miani graph)graph import/export in DOT (GraphViz) formatHISTORYThe development ofgraph-toolsstarted in 2007, which was initially an
extension to Graph module in CPAN (Comprehensive Perl Archive Network) by
Jarkko Hietaniemi.  Our Perl module has been calledgraphtoolsfor long
time and Perl module names were Graph::Util and Graph::Enhanced.graphtoolsin Perl has been developed until 2018.  Python version ofgraph-toolswas born in 2018 by portinggraphtoolsin Perl to Python.
Hence, the internal structure and the coding style receives significant
influence from Graph module by Jarkko Hietaniemi.EXAMPLEfromgraph_toolsimportGraph# create a graph with four nodes and two edgesg=Graph(directed=True)g.add_edge(1,2)g.add_edge(2,3)g.add_vertex(4)print(g)# find the all shortest paths from vertex 1dist,prev=g.dijkstra(1)print(dist)# generate BA graph with 100 verticesg=Graph(directed=False).create_graph('barabasi',100)# check if all vertices are mutually connectedprint(g.is_connected())# compute the betweenness centrality of vertex 1print(g.betweenness(1))INSTALLATIONpip3installgraph-toolsAVAILABILITYThe latest version ofgraph-toolsmodule is available at PyPI
(https://pypi.org/project/graph-tools/) .SEE ALSOgraphviz - graph visualization software (https://graphviz.org/)AUTHORHiroyuki Ohsaki <ohsaki[atmark]lsnl.jp>
Package: graphtype
graphtypeType hinting for networkx GraphsInstallationpip install graphtypeUsageThere are two parts in graphtype: the type-hinting part, and the validation. You can use type-hinting with the provided class to indicate attributes graphs should possess, and the validation decorator to additionally ensure the format is respected in every function call.Type-HintingGraphfrom graphtype import Graph

def do_something_to_graph(g: Graph)
    passType-Hinting Graph AttributesGraphDatafrom graphtype import Graph, GraphData


def do_something_to_graph(g: Graph[GraphData["name"]])
    pass

# Each node must have a "name" attribute

def do_something_to_graph(g: Graph[GraphData["name": str]])
    pass

# type(g.graph["name"]) == str must be TrueType-Hinting Graph AttributesNodeDatafrom graphtype import Graph, NodeData

def do_something_to_graph(g: Graph[NodeData["feature"]])
    pass

# Each node must have a "feature" attribute

def do_something_to_graph(g: Graph[NodeData["feature": np.ndarray]])
    pass

# for n, d in g.nodes(data=True):
#   type(d["feature"]) == np.ndarray must be TrueType-Hinting Graph AttributesNodeDatafrom graphtype import Graph, EdgeData

def do_something_to_graph(g: Graph[EdgeData["feature"]])
    pass

# Each edge must have a "feature" attribute

def do_something_to_graph(g: Graph[EdgeData["feature": pd.DataFrame]])
    pass

# for u, v, d in g.edges(data=True):
#   type(d["feature"]) == pd.DataFrame must be TrueEnforcing:@validateThe@validatedecorator ensures that inputGraphshave the right format when the function is called, otherwise raisesTypeError.@validate
def func(g: Graph[NodeData["feature1": pd.DataFrame, "feature2": int],
                  EdgeData["length": float, "counts": np.ndarray],
                  GraphData["name": str]],
         h: Graph[NodeData["feature1": pd.DataFrame, "feature2": int]],
         ):
    passThis package is heavily inspired byDataenforce.
Package: graphunc
# Graphunc -- The data structure that is a graph of functionsPython 3 package allowing manipulation of data by graph pathfinding.## usage exampleimport graffunc# define my convertersdef my_a_to_b_converter(a):b = a.upper()return bdef my_b_to_c_converter(b):c = 'payload: ' + b + '/payload'return c# creation of the main objectcp = graffunc.ConvertionPropagater({'a': {'b': my_a_to_b_converter},'b': {'c': my_b_to_c_converter},})# convert a to cassert cp.convert('data', source='a', target='c') == 'payload: DATA/payload'## installationpip install graffunc## links[github](http://github.com/aluriak/graffunc) and [pypi](http://pypi.python.org/pypi/graffunc
Package: graphus
Graphus is a dynamic GraphQL schema parser and API generator for Python. With Graphus, you can adapt your client's API to any GraphQL server on-the-fly, ensuring real-time compatibility and flexibility.Features📜Dynamic Schema Parsing: Parse any GraphQL schema and understand its structure.🚀Automatic API Generation: Create methods and objects that align with the parsed schema's parameters and arguments.🎛Adaptable Client: Seamlessly adapt your client to different GraphQL servers without manual modifications.🔒Type-Safe: Ensures that the generated methods and objects adhere to the schema's defined types.InstallationpipinstallgraphusQuick StartInitialize Graphus with a GraphQL endpoint:fromgraphusimportGraphusClientclient=GraphusClient(endpoint='https://your-graphql-endpoint.com')Use the generated API:obj=client.query.field(arg1="Hello").attribute.execute()obj=client.mutation.method(param="Hello").execute()DocumentationFor detailed documentation, including advanced features and API references, pleaseclick here.ContributingWe welcome contributions! Please see ourCONTRIBUTING guidefor more details.📞 ContactQueries? Suggestions? Drop me an email ationesiojr@gmail.com.LicenseGraphus is licensed under theApache 2.0 License.
Package: graph-validations
Graph_ValidationsGraph_Validations is package that containsfunctions for checking if Schematic Editor graphs contained in JSON file are built correctlyGraph_Validations is fully implemented in Python.InstallationYou can usepipto install Graph_Validations:$ pip install graph_validationsTo verify that you have installed Graph_Validations correctly run the following command:$ graph_validationsYou should get output like this:Usage: graph_validations [OPTIONS] COMMAND [ARGS]...        

                                                            

Options:                                                    

  --debug  Debug/trace output.                              

  --help   Show this message and exit.                      

                                                            

Commands:                                                   

  validate-graph   Checks if the given graph is valid.      

  validation-list  Lists all currently available validationsPython versionsTested with Python 3.7.4+