Saravanan666/pypi-org huggingface dataset:
Package: graphlib2
graphlib2This is a Rust port of Python's stdlibgraphlib.
It passes all of the standard libraries tests and is a drop in replacement.
This also happens to be Python 3.7 compatible, so it can be used as a backport.
Since usage is exactly the same as the standard libraries, please refer to their documentation for usage details.See this project onGitHub.Examplefromgraphlib2importTopologicalSortergraph={0:[1],1:[2]}# 0 depends on 1, 1 depends on 2ts=TopologicalSorter(graph)ts.prepare()whilets.is_active():ready_nodes=ts.get_ready()ts.done(*ready_nodes)# all at a time or one by oneMotivationThis was primarily written fordiand for me to learn Rust.
In other words: please vet the code yourself before using this.Differences with the stdlib implementationAddedTopologicalSorter.copy()which copies a prepared or unprepared graph so that it can be executed multiple times.Pretty solid performance improvements (seebenchmarks).Misc improvements, like working generics without postponed evaluation (ToplologicalSorter[int]works at runtime).PerformanceThe implementation was designed for the specific use case of adding all nodes, callingprepare()then copying and executing in a loop:fromgraphlib2importTopologicalSortergraph={0:[1],1:[2]}ts=TopologicalSorter(graph)ts.prepare()whileTrue:# hot loopt=ts.copy()whilet.is_active():ready_nodes=t.get_ready()t.done(*ready_nodes)This means that the focus is on the performance ofTopologicalSorter.get_ready()andTopologicalSorter.done(), and only minimal effort was put into other methods (prepare(),add()andget_static_order()), although these are still quite performant.ContributingClone the repo.Runmake initRunmake testMake your changesPush and open a pull requestWait for CI to run.If your pull request gets approved and merged, it will automatically be relased to PyPi (every commit tomainis released).
Package: graphlib-backport
graphlib backportBackport of the Python 3.9graphlibmodule for older Python versions.Github:https://github.com/mariushelf/graphlib_backportSupported versionsThis backport currently support Python 3.6, 3.7, 3.8, 3.9 and and pypy3
(tested with pypy3.6).Installationpip install graphlib_backportUsageThe package works the very same way as the original package.Here'sthe documentation.DevelopmentThe sourcecode is hosted ongithub.
To develop on this package, just clone it, work on it and submit a pull request.Dev requirementsFor testing against different Python versions,toxis required.To download the latest original sourcecode into the repository, there is a make target:make download_sourcecodeWarning: This overwrites the code in this repo. By default it uses the tagv3.9.0,
but you can overwrite that with atagenvironment variable.Running testsAs simple as runningtoxon the command line.The executables for all python versions must be in the path, e.g,python3.6, ...,python3.9,pypy3.
You can install them withpyenv.Publishing a new versionUpdate the version in the pyproject.toml and runmake publishto build and upload
the package ti PyPI.ThanksI did not create this code -- I only repackaged it so it can be
pip-installed into older versions of Python.So all thanks go to the original contributors of theoriginal sourcecode.LicensePSF
Package: graphlite
Graphlite is an MIT-licensed graph DB for Python.There are currently no embedded graph databases for Python.
Graphlite aims to change that by building a simple and fast
graph layer over SQLite. Similar to FlockDB, Graphlite only
stores adjacency lists, but they can be queried in the style
of normal graph databases, e.g. with traversals.>>>importgraphliteasg>>>db=g.connect(':memory:',graphs=['knows'])>>>withdb.transaction():...forpersonin[2,3]:...db.store(g.V(1).knows(person))...>>>db.find(g.V(1).knows).to(list)[2, 3]Graphlite inherits it’s API from that of FlockDB’s. Also, like
FlockDB Graphlite only stores the relations between the nodes,
which are integers- not the data of the nodes themselves. You
will therefore need a high performance database like BerkleyDB
or one of thedbmimplementations to store your data.FeaturesThread-safe transactions withthreading.LockSmall, easy to learn API with around 100% coverageLazy generator based API when queryingHighly documented codebaseInstallationTo install Graphlite, simply:$ pip install graphlite
Package: graphlog
GraphLogAPI to interface with the GraphLog Dataset. GraphLog is a multi-purpose, multi-relational graph dataset built using rules grounded in first-order logic.Homepage|Paper|API DocsInstallationSupported Python Version: 3.6+Install PyTorch fromhttps://pytorch.org/get-started/locally/Install pytorch-geometric (and other dependencies) fromhttps://github.com/rusty1s/pytorch_geometric#installation. Make sure that cpu/cuda versions for pytorch and pytorch-geometric etc matches.pip install graphlogQuickStartCheck out the notebooks onBasic UsageandAdvanced Usageto quickly start playing with GraphLog.Dev Setuppip install -e ".[dev]"Install pre-commit hookspre-commit installThe code is linted using:blackflake8mypyAll the tests can be run locally usingnoxExperimentsCode for experiments used in our paper are available inexperiments/folder.QuestionsIf you have questions, open an IssueOr,join our Slack channeland post your questions / comments!To contribute, open a Pull Request (PR)ContributingPlease open a Pull Request (PR).CitationIf our work is useful for your research, consider citing it using the following bibtex:@article{sinha2020graphlog,
  Author = {Koustuv Sinha and Shagun Sodhani and Joelle Pineau and William L. Hamilton},
  Title = {Evaluating Logical Generalization in Graph Neural Networks},
  Year = {2020},
  arxiv = {https://arxiv.org/abs/2003.06560}
}LicenseCC-BY-NC 4.0 (Attr Non-Commercial Inter.)Terms of Usehttps://opensource.facebook.com/legal/termsPrivacy Policyhttps://opensource.facebook.com/legal/privacy
Package: graphlot
GraphlotGraphlot is a library that allows to simply visualize networks. It is built upon matplotlib, and plotly and exploits network layouts from networkx, igraph and graphviz.For this reason the first step is to install graphviz by runningsudo apt install graphvizThen we can install graphlot through pippip install graphlotThe library takes as input a networx graph and can plot the degree distribution and the network itself with different layouts.To demonstrate it we will generate a random network with the function CreateNetworkFromRandomClasses(). This function takes as input a list and an integer. The list is of length n_classes and in which every value is the number of nodes of that specific classes. The integer is the number of random edges of the graph.The function stores the information of the node belonging to a specific class in "Type" node attribute and node name in "name" node attribute.import graphlot as gv
import random


random.seed(123127844)

grafo = gv.CreateNetworkFromRandomClasses([20,20,30], 150)
gv.plot_degree_distribution(grafo)random.seed(123127844)
gv.visualize_network(grafo,mode = '2d',node_color_attribute='Type',legend = 'Type',cmap='viridis',node_annotation = 'Name')Moreover graphlot allows to plot networks in 3d in order to have a more flexible visualization.random.seed(123127844)
gv.visualize_network(grafo,mode = '3d',node_color_attribute='Type',legend = 'Type',cmap='viridis',node_annotation = 'Name')3D Network
Package: graph-ltpl
Graph-Based Local Trajectory PlannerThe graph-based local trajectory planner is python-based and comes with open interfaces as well as debug, visualization
and development tools. The local planner is designed in a way to return an action set (e.g. keep straight, pass left,
pass right), where each action is the globally cost optimal solution for that task. If any of the action primitives is
not feasible, it is not returned in the set. That way, one can either select available actions based on a priority list
(e.g. try to pass if possible) or use an own dedicated behaviour planner.The planner was used on a real race vehicle during the Roborace Season Alpha and achieved speeds above 200kph.
A video of the performance at the Monteblanco track can be foundhere.DisclaimerThis software is providedas-isand has not been subject to a certified safety validation. Autonomous Driving is a
highly complex and dangerous task. In case you plan to use this software on a vehicle, it is by all means required that
you assess the overall safety of your project as a whole. By no means is this software a replacement for a valid
safety-concept. See the license for more details.DocumentationThe documentation of the project can be foundhere.Contributions[1] T. Stahl, A. Wischnewski, J. Betz, and M. Lienkamp,
“Multilayer Graph-Based Trajectory Planning for Race Vehicles in Dynamic Scenarios,”
in 2019 IEEE Intelligent Transportation Systems Conference (ITSC), Oct. 2019, pp. 3149–3154.(view pre-print)Contact:Tim Stahl.If you find our work useful in your research, please consider citing:@inproceedings{stahl2019,
     title = {Multilayer Graph-Based Trajectory Planning for Race Vehicles in Dynamic Scenarios},
     booktitle = {2019 IEEE Intelligent Transportation Systems Conference (ITSC)},
     author = {Stahl, Tim and Wischnewski, Alexander and Betz, Johannes and Lienkamp, Markus},
     year = {2019},
     pages = {3149--3154}
   }
Package: graphmin
Source Code:http://github.com/wwaites/graphminPyPI:http://pypi.python.org/pypi/graphminHome Page:http://river.styx.org/ww/2010/10/graphminInstallationFor the inferencing, a special branch of rdflib is
needed:## don't install this stuff system-wide, use virtualenv
virtualenv foo
. ./foo/bin/activate

## install the prerequisites
pip install pyparsing
pip install -e svn+http://python-dlp.googlecode.com/svn/trunk/layercake-python#egg=rdflib
pip install hg+https://fuxi.googlecode.com/hg/#egg=fuxi

## install this package from git
git clone git://github.com/wwaites/graphmin.git
cd graphmin
python setup.py developExampleRunning this example:graphmin -i examples/ex1.n3 -f n3 -r examples/rdfs-rules.n3Should give this result:@prefix eg: <http://example.org/>.
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.

eg:a a eg:A.Because the statementeg:a a rdfs:Resourcein ex1.n3 is entailed by
the RDFS inference rules.Referenceshttp://code.google.com/p/fuxi/wiki/TopDownSW
Package: graphml
GraphMLTBDGetting Started•Features & Screenshots•Documentation•Support•Report a Bug•FAQ•Known Issues•Contribution•ChangelogEvery project should contain a short description here to help users understand what it does. This description should cover a maximum of 4 lines. If there is a UI, you can also put a screenshot under this description.Highlights📄  README template with predefined structure.🗃  Labeling and issue organization system.📝  Contribution guideline template.Getting StartedThis section should contain the simplest and most basic way to run and use the project, preferably with one command.Support & FeedbackThis project is maintained byBenjamin Räthlein,Lukas Masuch, andJan Kalkan. Please understand that we won't be able to provide individual support via email. We also believe that help is much more valuable if it's shared publicly so that more people can benefit from it.TypeChannel🚨Bug Reports🎁Feature Requests👩‍💻Usage Questionstbd📢Announcementstbd❓Other RequestsFeaturesUse this section for advertising the most important features and advantages of the project. Also, add screenshots or examples to showcase important features. The main purpose of this section is marketing.DocumentationEither put the documentation here or use a deployed documentation site via mkdocs and link to the documentation.Please refer toour documentationfor information about deployment or usage.FAQThis is the example description of an faq item(click to expand...)Known IssuesThis is the example description of a known issue(click to expand...)ContributorsTODO: sourcererhall of fameis deprecated, find something different?ContributionPull requests are encouraged and always welcome. Read ourcontribution guidelinesand check outhelp-wantedissues.Submit Github issues for anyfeature request and enhancement,bugs, ordocumentationproblems.By participating in this project, you agree to abide by itsCode of Conduct.Thedevelopment sectionbelow contains information on how to build and test the project after you have implemented some changes.DevelopmentRequirements:DockerandActare required to be installed on your machine to execute the containerized build process.To simplify the process of building this project from scratch, we provide build-scripts - based onuniversal-build- that run all necessary steps (build, check, test, and release) within a containerized environment. To build and test your changes, execute the following command in the project root folder:act-b-jbuildRefer to ourcontribution guidesfor more detailed information on our build scripts and development process.LicensedMIT. Created and maintained with ❤️  by developers from Berlin.
Package: graph-model-parser
GraphModelParserGraphModelParser is a Python library for representing and simulating dynamical graph models from a string description. The library supports various probability distributions such as normal, poisson, expon, binom, and uniform from thescipy.statsmodule.InstallationYou can install GraphModelParser from PyPI by running:pipinstallgraph-model-parserUsagefromgraph_model_parserimportGraphModelParserimportnumpyasnp# Set seed for reproducibilitynp.random.seed(42)model_description='''a_{t}= a_{t-1} + 1b_{t}= b_{t-1} + 2*b_{t-2} + a_0c_{t}= c_{t-1} + normal(1, 2)'''# Always enclose the dynamic time index in curly braces e.g. {t-1}initial_values={'a_0':0,'a_1':1,'b_0':0,'b_1':1,'c_0':0}model=GraphModelParser(model_description,initial_values)print(model(t=20))In this example, we define a simple dynamical graph model with three variables (a_{t},b_{t}, andc_{t}) and their relationships over time. Thec_{t}variable is also affected by a random normal distribution with a mean of 1 and a standard deviation of 2.FeaturesDefine dynamical graph models using a simple string-based syntax.Support for various probability distributions fromscipy.stats, including normal, poisson, expon, binom, and uniform.Easily compute the values of variables at specific time points.Define initial values for variables and model their evolution over time.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: graph-nitta
graph-nittamatplotlibをラップしたグラフライブラリです。Usagepipinstall-Ugraph-nittafromgraph_nittaimportmake_graph,apply_ax_config,AxConfig,SpineConfig# グラフ作成fig,axes=make_graph()# グラフにデータを追加axes[0].plot(df[df.columns[1]],df[df.columns[2]],label="sample1")axes[0].plot(df[df.columns[1]]*1.1,df[df.columns[2]]*1.1,label="sample2")# グラフの設定config=AxConfig(x=SpineConfig(lim=(0,5)),y=SpineConfig(lim=(0,1)))apply_ax_config(axes[0],config)fig.show()exampleに使用例を置いています。
Package: grapho
Grapho is yet another Graph Library, written in Python with the idea of being able to represent
Grapho is compatible with: Python 3.5-3.7.Free software: MIT licenseDocumentation:https://grapho.readthedocs.io.FeaturesTypes of Graphs supported[X] Directed Graph[ ] UnDirected Graph[X] Node Labeled Graph (store data in Node)[X] Edge Labeled Graph (store data in Edge)[X] Weighted GraphCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: graph-of-words
Graph of wordsCreate a graph of word representation from a text. Roughly based onMalliaros, F. D., & Skianis, K. (2015). Graph-Based Term Weighting for Text Categorization. 1473–1479.https://doi.org/10.1145/2808797.2808872Example:importgraphgraph=graph.GraphOfWords(window_size=2)graph.build_graph('Roses are red. Violets are blue',# OR a sentences list['Roses  are  red.', 'Violets are blue'],remove_stopwords=False,workers=4)graph.display_graph()graph.write_graph_edges('edges_list.txt')Note thatbuild_graphalso accepts a list of sentences.The following actions are performed:Split the text into sentences if requiredSlide a window across each sentenceAdd a directed graph edge form the current word to the other ones within the
window, the weight being the distance between the two wordsDocumentationSeethe documentation.
Package: graphomaly
GraphomalyAutomatic tool for Anti-Money Laundering (AML) and  detecting abnormal behavior in computer networks. Find abnormal data in graph and network structures.Official package documentationhere.This work was initially supported by theGraphomaly Research Grantand later partially supported by theNetalert Research Grant.Installation and setupInstall via pip from thePyPi repository:pip install graphomalyor for the latest changes not yet in the official release:pip install git+https://gitlab.com/unibuc/graphomaly/graphomalyInstall via docker from theDockerHub repositorydocker pull pirofti/graphomalyFor using the GPU pull the dedicated image:docker pull pirofti/graphomaly:latest_gpuUsageThe package follows thesklearnAPI and can be included in your projects viafrom graphomaly.estimator import GraphomalyEstimatorwhich will provide you with a standard scikit-learn estimator that you can use in your pipeline.For configuration and tweaks please consult the YAML file for now until documentation matures.Development and testingFirst clone the repository and change directory to the root of your fresh checkout.0. Install PrerequisitesInstall PyPA’sbuild:python3 -m pip install --upgrade build1. BuildInside the Graphomaly directorypython -m build2. Virtual EnvironmentCreate a virtual environment with Python:python -m venv venvActivate the environment:source venv/bin/activateFor Windows execute instead:venv\Scripts\activate3. InstallInside the virtual environment execute:pip install dist/graphomaly-*.whlRunning unit testsFirst create the results directory:mkdir -p tests/results/syntheticRun the initial test on synthetic data to make sure things installed ok:cd tests && python test_syntheticThen run the other unit tests by hand as above or viapytest:pytest  # add -v for verbose, add -s to print(...) to console from tests
Package: graph-onedrive
Graph-OneDriveInteract with Microsoft's OneDrive service using the Graph API.The Graph-OneDrive package facilitates the creation of OneDrive class instances which are objects that you can use to interact with OneDrive sessions. Thus multiple OneDrives can be connected to in parallel.Functions include:listing directoriesmoving, copying, and renaming files and foldersuploading and asynchronously downloading filesgetting file and drive metadata including usagegetting links to files and creating sharing linksAzure app requirementFor the package to connect to the Graph API, you need to have an app registered in the Microsoft Azure Portal. Thedocumentationprovides basic guidance on how to register an app.Note that some Microsoft work and school accounts will not allow apps to connect with them without admin consent.InstallationThe package currently requires Python 3.7 or greater.Install and update usingpipwhich will use the releases hosted onPyPI. Further options in the docs.pip install -U graph-onedriveDocumentationDocumentation and examples areprovided on GitHub in the docs folder.A simple exampleThis is a simple example using a config file. Refer to the documentation for other instance constructors including inline options.Run this command in the terminal after installation which will create a config file in the current working directory.graph-onedrive --configure --authenticate -f "config.json" -k "onedrive"Save the following in a .py file in the same folder.fromgraph_onedriveimportOneDriveManager# Use a context manager to manage the sessionwithOneDriveManager(config_path="config.json",config_key="onedrive")asmy_drive:# Print the OneDrive usagemy_drive.get_usage(verbose=True)# Upload a file to the root directorynew_file_id=my_drive.upload_file("my-photo.jpg",verbose=True)License and Terms of UseThis project itself is subject to BSD 3-Clause License detailed inLICENSE.The Graph API is provided by Microsoft Corporation and subject to theirterms of use.LinksDocumentationLicenseChange LogPyPIPyPI Release HistorySource CodeContributingIssue Tracker
Package: graphoW
graphoW: A python package for building Graph of WordsgraphoW is a Python package for the creation of a Graph-of-Words (GoW) representation of texts.Structure is based on:"Graph-of-word and TW-IDF: new approach to ad hoc IR"Graph metrics are based on:"Graph analysis of dream reports is especially informative about psychosis"Narrative consistency and rapidity are based on:"Measuring Narrative Fluency by Analyzing Dynamic Interaction Networks in Textual Narratives"It allows to:Create a GoW for individual texts.Create a container of GoW in which each GoW corresponds to a paragraph in the text.Compute diverse types of graph metrics (e.g., individual, global, connectivity...).Compute the narrative consistency of text based on all terms or only on noun phrases.Compute the rapidity of a text, i.e., how slow/fast change the structure of paragraphs.GoW is supported usingNetworkX.
Package: graphpanda
Graphpanda 🛠Graphpandais a python package that allows you to convert pandas dataframe intoCypherinsert queries. It gives you a way to specify your record linking algorithms for determining edges and setting attributes.Who should use it?Anyone who is analyzing data in python using pandas and wants to have a way to analyze it with cypher in a graph database.InstallationUse the package managerpipto install graphpanda.pipinstall-epath_to_graphpandaUsagedf=pd.DataFrame(data=[{"c1":1,"c2":2,"c3":"wow"},{"c1":1,"c2":2,"c3":"wow"},{"c1":1,"c2":2,"c3":"wow"},])df2=pd.DataFrame(data=[{"d1":1},{"d1":2},{"d1":3},])domain1=form_node_domain(df,("TestNode",["c2"]))domain2=form_node_domain(df2,("Node2",["d1"]))get_selection_func1=domain1.get_selection_function(["c2"])get_selection_func2=domain2.get_selection_function(["d1"])exact_match_one_field=exact_match(get_selection_func1,get_selection_func2)graph=form_edges(domain1,domain2,exact_match_one_field)cypher_graph=CypherGraph(graph)out=cypher_graph.get_create_statements()print(out)CREATE(node_339606590492800375:Node2{d1:2})CREATE(node_4387139851793128730:Node2{d1:1})CREATE(node_4180099955292202157:Node2{d1:3})CREATE(node_5208008065052232978:TestNode{c2:2})CREATE(node_5208008065052232978)-[:EXACT_MATCH{}]->(node_339606590492800375)Contributing 💓Pull requests are welcome. For significant changes, please open an issue first to discuss what you would like to change. Please make sure to update the tests as appropriate. It would be nice to ask @Bobrinik before to make sure that we follow the same guidelines and vision.Future workAdd more record linking functions:https://en.wikipedia.org/wiki/Record_linkageLicenseMIT