Saravanan666/pypi-org huggingface dataset:
Package: graphite_log_feeder
OverviewGraphite Log Feeder (GLF) is a generic tool that can parse application
log files, extract meaningful data, and forward it to Graphite for
visualizing.  There is a parser included for ingesting data from
The Grinder.  This parser can be used as the basis for creating other parsers
(for Apache, Scribe, your own application, or whatever.)There is a similar tool – Logster – which also feeds log data
to Graphite.  However, Logster only supports realtime log analysis,
whereas glf only supports non-realtime analysis, making the two tools
complimentary.InstallationGLF is installed via pip.pip install graphite_log_feederOnce pip has installed glf, you will need to generate a
config file, and edit it to be suitable for your
environment.  Glf comes with a command-line option to
generate a sample config filegraphite_log_feeder.py -eThis will generate a file named ‘glf.sample.conf’
which you can use as the basis for creating your own
configuration.There must be a running installation of Graphite on your
network for GLF to forward data to.  See the Graphite web site for
details on setting up and configuring Graphitehttp://graphite.wikidot.com/Usage(after adjusting the values in your sample config file to be
appropriate for your environment)graphite_log_feeder.py  <config_file>Additional ResourcesJava/JMX counters and application-level metrics can be fed to
Graphite using the JMXTrans tool:http://code.google.com/p/jmxtrans/OS-level metrics (CPU, mem, etc.) can be fed to Graphite via
quickstatd or collectd (with graphite plugin)https://bitbucket.org/travis_bear/quickstatd
Package: graphite-pymetrics
graphite-pymetrics is a lightweight Python framework which makes it super simple to add application metrics
that is sent to a remote graphite/carbon server.All that is needed is this package (which also includes pystatsd) and access to a remote graphite server.To install it just run Pip as usual:$ pip install graphite-pymetricsPackage requirements:pystatsd==0.1.6geventUsageMake sure there is a local graphite proxy running - start it at an early point in your application:from metrics.graphite import start_graphite_proxy
start_graphite_proxy({"host": "graphite.mycompany.com", "port": 2003})The proxy is pystatsd, a local server that receives UDP packets from the metrics client and periodically
emits data to graphite over TCP.CountersTo add a counter for anything anywhere in your code, use Metric.add:from metrics import Metric

Metric.add("foo.bar")Use the @metric decorator to count specific method invocations:from metrics import metric

@metric("bar.baz")
def foo():
    # do stuff hereTimingThere are several ways to log timing. The most naive way is to first measure time manually and then submit it:from metrics import Metric
import time

start = time.time()
# do stuff
elapsed = time.time() - start
Metric.timing("do.stuff", elapsed)An easier way is to to let the metric client keep track of time with Metric.start_timing and call done() on the
returned timing instance. Following is an example for measuring time consumed for every endpoint individually
in a Flask webapp:from metrics import Metric
from flask import Blueprint, current_app, request, g

app = Blueprint("myapp", __name__)

@app.before_request
def before_request():
    try:
        g.timing = Metric.start_timing(str(request.endpoint))  # start timing
    except:
        current_app.logger.error("Unable to time call for 'request.endpoint'")

@app.teardown_request
def teardown_request(exc):
    try:
        g.timing.done()                                        # stop timing
    except:
        current_app.logger.error("Timing not available")Similar to the @metric decorator there is a @timing decorator which is used to measure time for specific methods:from metrics import timing

@timing("heavy.task")
def heavy_task(x, y, z):
    # do heavy stuff here
Package: graphite.theme
Graphite Theme==============Latest stable version: **v1.2** · released: 2015-10-27Graphite Theme is a Diazo Theme for [Bika Open Source LIMS](https://github.com/bikalabs/Bika-LIMS), mainly focused on improving usability and user experience. The highlights are a clear and clean design that allows to maximize the workspace, quick access to most of the Bika LIMS features with only one click and dynamic loading of views without page refresh.This product may contain traces of nuts.![Client's Analysis Requests](https://github.com/naralabs/graphite.theme/blob/master/screenshots/client_analysisrequests.png)Installation------------To install Graphite Theme, add ``graphite.theme`` to the eggs section from the buildout:eggs =...graphite.themeFeedback and support--------------------If you have questions, please post to one of our mailing lists:* Bika Health Users: http://groups.google.com/forum/?hl=en#!forum/bika-health* Bika LIMS Users: http://lists.sourceforge.net/lists/listinfo/bika-users* LIMS design: https://groups.google.com/forum/?hl=en#%21forum/bika-design* Developers: http://lists.sourceforge.net/lists/listinfo/bika-developersPlease log issues, feature requests, or bug reports in the [issue tracker](http://jira.bikalabs.com/browse/GRTH)***[Naralabs](http://naralabs.com) - info@naralabs.comChangelog=========1.2 (unreleased)----------------- GRTH-50 Worksheet Filter does not work- GRTH-51 Creating New AR doesn't function correctly until a refresh- GRTH-45 Analysis Request: Ugly results interpretation- GRTH-44 Analysis Request's invoice doesn't look properly- GRTH-40 Add form analyses don't expand- GRTH-23 Add Contact to Client throws error- GRTH-35 Lack of AR invoice (and proforma) formatting- GRTH-6 Add an acces to Late Analyses- GRTH-39 graphite.theme 1.1.1 requires 'bika.lims==3.1.7'- portalMessage rendered twice in setup view- Graphite Theme doesn't work properly on production mode1.1 (2015-02-26)----------------- GRTH-34 Print invoice doesn't show the invoice to print- GRTH-4 No doctor, patient, diseases... access in menu bar- GRTH-30 Overlays don't work- GRTH-26 Portal instrument alerts not shown- GRTH-25 After autosave something in AR/view, the notification panel hasn't style.- GRTH-29 On AR publish, the page is not redirected to the publication preview- Restyling- Selective loading of CSS - fix cached CSS malfunctioning- Left menu removal. Contextual top menu- Compatibility with Bika LIMS 3.1.71.0 (2014-11-06)----------------- GRTH-23 Add Contact to Client throws error- GRTH-19 Error after trying to add an Attachment Type, Batch Labels or Sub-groups- GRTH-22 When you deactivate the theme by Add-ons, the pages doesn't render well- GRTH-20 Unable to save a new Invoice- GRTH-17 Sometimes activate/deactivate on bikasetup/Instrument doesn't work- GRTH-5 Site Setup becomes strange- GRTH-2 AR Imports icon not found- GRTH-15 Import/LoadSetup data is not working- GRTH-10 The save icon should be something more than simple txt- GRTH-9 No good construction in Add AR Form- ON/OFF button to deactivate/activate Grpahite Theme
Package: graphite-web
Graphite-WebOverviewGraphite consists of three major components:Graphite-Web, a Django-based web application that renders graphs and dashboardsTheCarbonmetric processing daemonsTheWhispertime-series database libraryInstallation, Configuration and UsagePlease refer to the instructions atreadthedocs.LicenseGraphite-Web is licensed under version 2.0 of the Apache License. See theLICENSEfile for details.
Package: graphiti
Graphitiis python module for sending any metrics tographite/carbonBuild status:FeaturesAsynchronous sendingCombine several metrics to single packetUses pickle protocolHandle temporary network outageGevent supportInstallationgraphitiis installed via pip.pip install graphitiUsage ExampleSample:from graphiti import Client

client = Client(carbon_host)
client.send("graphiti.server.cpu_usage", 12.4, timestamp)
client.send("graphiti.server.cpu_usage", 15.1)  # current time will be used

project = "graphite"
server = "server"
client.send((project, server, "cpu_usage"), 11)  # metric name is graphiti.server.cpu_usage


# also you can aggregate values on client side
from graphiti import Aggregator, timeit

aggregator = Aggregator(client, interval=60)  # aggregate metrics during minute

aggregator.add_sum('processed_messages', 1)
aggregator.add_avg('message_processing_avg_time', time_taken)
aggregator.add_active('service_is_up')

with timeit(aggregator, ["graphiti", "server", "messages"]):
   process_message()  #  send metrics graphiti.server.messages.time_avg -- average time of message processing
                      #               graphiti.server.messages.time_sum -- total time of message processing
                      #               graphiti.server.messages.count -- number of processed message per minute

client.stop()SourceTheGraphitisources are hosted on bitbucket:https://bitbucket.org/asdtech/graphiti
Package: graphitty
# Graphitty[![Circle CI](https://circleci.com/gh/sketchytechky/graphitty.svg?style=svg&circle-token=<cirlce-ci-token>)](https://circleci.com/gh/sketchytechky/graphitty)[![Coverage Status](https://coveralls.io/repos/github/sketchytechky/graphitty/badge.svg?branch=master)](https://coveralls.io/github/sketchytechky/graphitty?branch=master)A Python library that convert time series to direction Graph to discover the story within data.![Example graph](apollo.png)# InstallingTo install this package, runs:pip install git+https://github.com/sketchytechky/graphitty.gitRemember to add the following line to `requirements.txt`git+https://github.com/sketchytechky/graphitty.git-----------# How to use```from graphitty.graphitty import Graphittyimport pandas as pd# Example input data - see test_simple.py for exampledf = pd.DataFrame([...],columns=['timestamp','action', 'user_id'])# Parsing and outputting graphg = Graphitty(df,id_col='user_id',beahivour_col='action',ts_col='timestamp')nx_graph = g.render()# create the beautiful directional graph# see https://github.com/chebee7i/nxpd for usageimport nxpdnxpd.draw(nx_graph, show='ipynb')```# Running TestsRun test withpy.test --pep8To run test in watch modepy.test.watch -- --pep8# same with: ptw -- --pep8-----------# Related research* Information Foraging Theory:Adaptive Interaction with Information - http://www.peterpirolli.com/Professional/About_Me_files/IFT%20Ch%201.pdf* Jakob Nielson example on how to apply information foraging theory to understand visitor's behaviour- http://www.useit.com/alertbox/scrolling-attention.html- https://www.nngroup.com/articles/information-scent/
Package: graphix
Graphixis a measurement-based quantum computing (MBQC) software package, featuringthe measurement calculus framework with integrated graphical rewrite rules for Pauli measurement preprocessingcircuit-to-pattern transpiler, graph-based deterministic pattern generator and manual pattern generationflow- and gflow-based graph visualization toolsstatevector and tensornetwork pattern simulation backendsQPU interface and fusion network extraction toolInstallationInstallgraphixwithpip:$pipinstallgraphixInstall together with device interface:$pipinstallgraphix[extra]this will installgraphixand inteface forIBMQandPercevalto run MBQC patterns on superconducting and optical QPUs and their simulators.Using graphixgenerating pattern from a circuitfromgraphiximportCircuitcircuit=Circuit(4)circuit.h(0)...pattern=circuit.transpile()pattern.draw_graph()note: this graph is generated from QAOA circuit, seeour example code. Arrows indicate thecausal flowof MBQC and dashed lines are the other edges of the graph. the vertical dashed partitions and the labels 'l:n' below indicate the executionlayersor the order in the graph (measurements should happen from left to right, and nodes in the same layer can be measured simultaneously), based on the partial order associated with the (maximally-delayed) flow.preprocessing Pauli measurementspattern.perform_pauli_measurements()pattern.draw_graph()(here, the graph hasgeneralized flow.)simulating the patternstate_out=pattern.simulate_pattern(backend='statevector')and more..Seedemosshowing other features ofgraphix.You can try demos on browser with mybinder.org:Read thetutorialfor more usage guides.For theoretical background, read our quick introduction intoMBQCandLC-MBQC.Full API docs ishere.CitingShinichi Sunami and Masato Fukushima, Graphix. (2023)https://doi.org/10.5281/zenodo.7861382Update on thearXiv paper: [^1][^1]: Following the release of this arXiv preprint, we were made aware ofBackens et al.and related work, where graph-theoretic simplification (Pauli measurement elimination) of patterns were shown.
Many thanks for letting us know about this work - at the time of the writing we were not aware of these important relevant works but will certainly properly mention in the new version; we are working on significant restructuring and rewriting of the paper and hope to update the paper soon.ContributingWe useGitHub issuesfor tracking feature requests and bugs reports.Discord ServerPlease visitUnitary Fund's Discord server, where you can find a channel forgraphixto ask questions.Core ContributorsDr. Shinichi Sunami (University of Oxford)Masato Fukushima (University of Tokyo, Fixstars Amplify)AcknowledgementsWe are proud to be supported byunitary fund microgrant program.Special thanks to Fixstars Amplify:LicenseApache License 2.0
Package: graphix-ibmq
Graphix IBMQ interfaceProvides an interface to run MBQC pattern (graphix.Pattern) on IBM quantum devices as well as the Aer simulators.Requiresgraphixto generate the measurement pattern.Installationinstall withpip$ pip install graphix-ibmqLicenseApache License 2.0Notethis project is not associated with IBM or IBMQuantum.
Package: graphkb
GraphKB (Python)This repository is part of theplatform for oncogenomic reporting and interpretation.Python adapter package for querying the GraphKB API. See theuser manualGetting StartedInstall (For developers)Run TestsGenerating the DocumentationDeployment (Publishing)Getting StartedInstall (For developers)clone this repositorygitclonehttps://github.com/bcgsc/pori_graphkb_pythoncdpori_graphkb_pythoncreate a virtual environmentpython3-mvenvvenvsourcevenv/bin/activateinstall the package and its development dependenciespipinstall-Upipsetuptools
pipinstall-e.[dev]Run TestspytesttestsGenerating the DocumentationUser documentation for this repository is hosted in thecentral PORI repositoryDeployment (Publishing)Install the deployment dependenciespipinstall.[deploy]Build the distribution filespythonsetup.pyinstallsdistbdist_wheelUpload the distibutions to the package server (-ris defined in your pypirc)twineupload-rbcgscdist/*
Package: graphknn
# Graph KNN Python moduleGiven an undirected graph and a set of terminal (or seed) vertices T, this python package finds, for every vertex, its K nearest neighbors from the set T.# UsageThe main functions are **graphknn.algorithm1(W, mask, k)** and **graphknn.algorithm2(W, mask, k)**.Both algorithms have the same interface with slightly different implementations.**Input**:* **W:** n x n matrix of edge weights, of type scipy.sparse.csr_matrix.* **mask:** boolean array of length n indicating which vertices belong to the terminal set T.* **k:** how many nearest neighbors to find for each vertex.**Output:*** **knn:** this is an array of size n such that knn[i] is a list of up to k pairs of (distance, terminal_vertex_index). Note that knn[i] is not sorted.Algorithm 1 is simpler whereas Algorithm 2 has tighter runtime guarantees. We have seen cases where algorithm 1 is faster than algorithm 2 and vice versa, so try both on your data and choose the faster one.## Example```import numpy as npimport scipy.sparseimport graphknndef build_sparse_undirected_nonnegative_csr_matrix(n):W = np.random.random((n,n))W = W + W.transpose()W[W < 1.5] = np.infreturn scipy.sparse.csr_matrix(W)def test_graphknn():N = 10p = 0.5k = 3W = build_sparse_undirected_nonnegative_csr_matrix(N)mask = np.random.random(N) < pprint('Graph edges:')print(W,'\n')print('Terminal indices:')print(mask.nonzero()[0], '\n')result = graphknn.algorithm1(W, mask, k)print('K nearest terminal indices of all vertices:')for i in range(len(result)):print('result[{0}]:\n{1}'.format(i, sorted(result[i])))test_graphknn()```# DetailsA simple solution to the problem of finding the k nearest terminal vertices isto run Dijkstra's algorithm from each of the terminal vertices, forming a |T| by |V| matrix. Then for each vertex i we examine the i-th column of the matrix and pick the k nearest cells (this can be done efficiently using Hoare's selection algorithm). The runtime of this method is O(|T||V|log|V| + |E|).However, this approach is wasteful, since it spends a lot of time finding irrelevant shortest paths from terminals to vertices that are very far from them.This module implements a faster approach that can be described as performing |T| Dijkstra runs in parallel combined with an early stopping rule that prevents unnecessary traversals. This stopping rule simply stops exploring vertices once we have found shortest paths from k different terminals.For more details, including a proof of correctness and runtime bounds, see Section 4 and Appendix B of our paper:[Amit Moscovich](https://mosco.github.io), [Ariel Jaffe](https://arieljaffe.wixsite.com/homepage), [Boaz Nadler](http://www.weizmann.ac.il/math/Nadler/home)[**Minimax-optimal semi-supervised regression on unknown manifolds**](https://arxiv.org/abs/1611.02221),AISTATS (2017).Please cite our paper if using this code for your research.
Package: graphlearning
Graph-based Clustering and Semi-Supervised LearningThis python package is devoted to efficient implementations of modern graph-based learning algorithms for semi-supervised learning, active learning, and clustering. The package implements many popular datasets (currently MNIST, FashionMNIST, and CIFAR-10) in a way that makes it simple for users to test out new algorithms and rapidly compare against existing methods. Fulldocumentationis available, including detailed example scripts.This package also reproduces experiments from the paperJ. Calder, B. Cook, M. Thorpe, D. Slepcev.Poisson Learning: Graph Based Semi-Supervised Learning at Very Low Label Rates., Proceedings of the 37th International Conference on Machine Learning, PMLR 119:1306-1316, 2020.InstallationInstall withpipinstallgraphlearningRequired packages will be installed automatically, and include numpy, scipy, sklearn, and matplotlib. Some features in the package rely on other packages, includingannoyfor approximate nearest neighbor searches, andtorchfor GPU acceleration. You will have to install these manually, if needed, withpipinstallannoytorchIt can be difficult to install annoy, depending on your operating system.To install the most recent version of GraphLearning from the github source, which is updated more frequently, rungitclonehttps://github.com/jwcalder/GraphLearningcdGraphLearning
pipinstall.If you prefer to use ssh swap the first line withgitclonegit@github.com:jwcalder/GraphLearning.gitDocumentation and ExamplesFull documentation for the package is availablehere. The documentation includes examples of how to use the package. All example scripts linked from the documentation can be found in the examples folder.Older versions of GraphLearningThis repository hosts the current version of the package, which is numbered >=1.0.0. This version is not backwards compatible with earlier versions of the package. The old version is archivedhereand can be installed withpipinstallgraphlearning==0.0.3To make sure you will load the old version when runningimport graphlearning, it may be necessary to uninstall all existing versionspip uninstall graphlearningbefore running the installation command above.CitationsIf you use this package in your research, please cite the package with the bibtex entry below.@software{graphlearning,
  author       = {Jeff Calder},
  title        = {GraphLearning Python Package},
  month        = jan,
  year         = 2022,
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.5850940},
  url          = {https://doi.org/10.5281/zenodo.5850940}
}Contact and questionsEmailjwcalder@umn.eduwith any questions or comments.AcknowledgmentsSeveral people have contributed to the development of this software:Mauricio Rios Flores (Machine Learning Researcher, Amazon)Brendan Cook (PhD Candidate in Mathematics, University of Minnesota)Matt Jacobs (Postdoc, UCLA)Mahmood Ettehad (Postdoc, IMA)Jason SetiadiKevin Miller (Postdoc, Oden Institute)
Package: graphlet
Graphlet AI Knowledge Graph FactoryThis is the PyPi module for the Graphlet AI Knowledge Graph Factory. Our mission is to create a Spark-based wizard for building large knowledge graphs that makes them easier to build for fewer dolalrs and with less risk.Core FeaturesThis project is new, some features we are building are:Create a Pydantic/PySpark base class for transforming multiple entities into a uniform ontologyCreate a generic, configurable system for entity resolution of heterogeneous networksCreate an efficient pipeline for computing network motifs and aggregating higher order networksImplement efficient motif searching via neural subgraph matchingSystem ArchitectureLicenseThis project is created and published under theApache License, version 2.0.ConventionsThis project uses pre-commit hooks to enforce its conventions: git will reject commits that don't comply with our various flake8 plugins.We usenumpy docstring formaton all Python classes and functions, which is enforced bypydocstringandflake8-docstrings.We runblack,flake8,isortandmypyin.pre-commit-config.yaml. All of these are configured inpyproject.tomlexcept for flake8 which uses.flake8.
Flake8 uses the following plugins. We will consider adding any exceptions to the flake config that are warranted, but please document them in your pull requests.flake8-docstrings="^1.6.0"pydocstyle="^6.1.1"flake8-simplify="^0.19.2"flake8-unused-arguments="^0.0.10"flake8-class-attributes-order="^0.1.3"flake8-comprehensions="^3.10.0"flake8-return="^1.1.3"flake8-use-fstring="^1.3"flake8-builtins="^1.5.3"flake8-functions-names="^0.3.0"flake8-comments="^0.1.2"Developer SetupThis project is in a state of development, things are still forming and changing. If you are here, it must be to contribute :)DependenciesWe manage dependencies withpoetrywhich are managed (along with most settings) inpyproject.toml.To build the project, run:poetryinstallTo add a PyPi package, run:poetryadd<package>To add a development package, run:poetryadd--dev<package>If you do editpyproject.tomlyou must update to regeneratepoetry.lock:poetryupdatePre-Commit HooksWe usepre-committo runblack,flake8,isortandmypy. This is configured in.pre-commit-config.yaml.VSCode SettingsThe followingVSCodesettings are defined for the project in.vscode/settings.jsonto ensure code is formatted consistent with our pre-commit hooks:{"editor.rulers":[90,120],"[python]":{"editor.defaultFormatter":"ms-python.python","editor.formatOnSave":true,"editor.codeActionsOnSave":{"source.organizeImports":true},},"python.jediEnabled":false,"python.languageServer":"Pylance","python.linting.enabled":true,"python.formatting.provider":"black","python.sortImports.args":["--profile","black"],"python.linting.pylintEnabled":false,"python.linting.flake8Enabled":true,"autoDocstring.docstringFormat":"numpy",}
Package: graph-lib
===============graph_lib===============A graph library containing some useful diffusion algorithms.Features===============* Written in C++* Extract import features like pagerank value without looking the whole graph.* Graph is stored in CSR.Installation===============1. Install with pip::pip install graph_lib2. Uninstall::pip uninstall graph_lib3. Compile from the source code::python setup.py installCurrent Routines===============1. aclpagerank2. aclpagerank_weighted3. sweepcut4. MQI5. ppr_path6. proxl1PRaccelUsage===============See examples.ipynbLicense===============GPL version 2.Copyright by Meng Liu, David F. Gleich, 2017-2022