Saravanan666/pypi-org huggingface dataset:
Package: graphic-verification-code
Graphic Verification CodeInstallationpip install graphic-verification-codeUsageIn [1]: import gvcode

In [2]: gvcode.generate()
Out[2]: (<PIL.Image.Image image mode=RGB size=120x30 at 0x7FD2380E1310>, 'ubAR')

In [3]: gvcode.base64()
Out[3]:
('iVBORw0KGgoAAAANSUhEUgAAAHgAAAAeCAIAAABoq03CAAACyklEQVR4nN1aO04kMRB9NdoIQUIAEVcgIuAEKyQyUsShIOUmmwEpZyAgG4SI+GRTBB48bn+6XXZ52uxTB6OWXS5XPb+y20PMDAAAEdnfPaOFn+M2VUZcVPb/b0BEbe27ubKDtab2jKvHzFE0ekGXEANGM7Mx1yK9rs0ZNcqVyvwu9Q4nmeWlsUMF79ClESQ12qRxa2JSgEmXmsqu1PhEMTSxFhltXVXyoUiOcFJS438mW7iqnWO9Q+73AJnMueH+XRI5O0qCpbLd2TJmp4X+gYVo82wNJveXlwMHbm9xc7N2Qxpl9UozrdEhRlT7Z1YAcHgIIqjTKMpNZt7ZwfGxJ27lo6jTvyTQBqlw25/LJYjw/o69Pf1wezg7w+enyavvSSebIDXlIqKQB4sFVit9XqcENzpQi1WV6Y8LX6OLtSl6dl+tyoxljeUh5fgWSmAOWX3pmLE0W333QpbvkZbvZTkb34wp7zoKTpJOXwAgwvk5Li7ADGY8PfmrZMS4ihy79dzzbRzjHNXcXXpqaJUrXyVTIou8qWrJMRGOjvD8LHZgzGa7QGPDvtxBUlPKjKBioIOJxB3Lh/6B5e5uc2RwP3D387EpB+6BSyV/5fvoEAcHa5/Mrs7BX4CB6UCHlVAKIphl6m25RMGy1cL0YsbHR5VX0GX0y8s6Ug8Pm1kR4fT0H3NVncyECQrAGG43r67KU2jCvbsLZiyX5b61uFEGglOZVySRlu36eui2dHktInWNKEcnGGd0De/cdee+cRqIr+DKVj0GV3GyqDHj+nrwgcw+9/eTfWPnqdYnlMdHnJzkNnbz64pP+FJkStQxZaHGFHSLYRRfX0A2oaJtXB3I/+Y5FCuBD7ZLqnGZqrRitNWplEx3fm+Q0r39fby9lWz4ep+wCNL8TV4Vhepha4A0bN39JayuDktrbME13jrKr6/CjrMw+jfeOlbiGyMXxYAIZpe8AAAAAElFTkSuQmCC',
 'QnCg')
Package: graphid
[![Travis](https://img.shields.io/travis/Erotemic/graphid/master.svg?label=Travis%20CI)](https://travis-ci.org/Erotemic/graphid)
[![Codecov](https://codecov.io/github/Erotemic/graphid/badge.svg?branch=master&service=github)](https://codecov.io/github/Erotemic/graphid?branch=master)
[![Appveyor](https://ci.appveyor.com/api/projects/status/github/Erotemic/graphid?svg=True)](https://ci.appveyor.com/project/Erotemic/graphid/branch/master)
[![Pypi](https://img.shields.io/pypi/v/graphid.svg)](https://pypi.python.org/pypi/graphid)# Graph IdentificationA graph algorithm to manage the identification of individuals in a population
using automatic pairwise decision algorithms with a humans in the loop.  It is
agnostic to the specific ranking and verification algorithms. In fact, it can
work without a ranking or verification algorithm, but in that case all reviews
will have to be manual, and it will be difficult to prioritize which pairs of
annotations (typically images) to look at first.This is the graph identification described in Chapter 5 of [my thesis](https://github.com/Erotemic/crall-thesis-2017/blob/master/crall-thesis_2017-08-10_compressed.pdf). Viewing this PDF online can be slow, so I’ve linked there raw text [here](https://github.com/Erotemic/crall-thesis-2017/blob/master/chapter5-graphid.tex).# General InformationThis repo is currently a work in progress.Helpful commands I’m currently using in development and debugging. Perhaps they
will be someone illustrative of what this package is trying to do.` python-mgraphid.demo.dummy_infr demodata_infr--showpython-mgraphid.demo.dummy_infr demodata_infr--num_pccs=25--showpython-mgraphid.demo.dummy_infr demodata_infr--num_pccs=100--show`This README is a mess. Why not look at [this Jupyter
notebook](notebooks/core_example.ipynb) in the meantime.# InstallationOnce this package becomes stable you can install viapip install graphid.
However, this will currently give you an older version of the project I
uploaded to reserve the name.# Dependencies`bash sudoapt-getinstall-ygraphvizlibgraphviz-devpip install graphviz pip install-e. `This project is Python 3.6+, Python 2 is not supported.If you want to be able to draw the graphs, you must install graphviz, which is
needed by pygraphviz.I’m currently having trouble getting this to work on windows due to pygraphviz.Conda can be used to install pygraphviz on windows?
conda install -c marufr pygraphviz
Package: graphiit
GraphiitUtilities for buildingPyPhinetworks
that need to be large and/or malleable.InstallationYou can installgraphiitfromPyPi:pip install graphiitOr the latest development version fromGithub:pip install git+https://github.com/grahamfindlay/graphiit@developBasic UsageAt the core ofgraphiitis theGraphobject.>>> from graphiit import GraphGraphtakes a graph configuration as a parameter:>>> graph_config = [
    ('A', 'OR', 'B', 'C'),
    ('B', 'AND', 'A', 'C'),
    ('C', 'XOR', 'A', 'B')]
>>> graph = Graph(graph_config)Each line in the configuration specifies the name of a node, the mechanism that
the node implements, and the nodes in the network which input to the node. For
example, in the above configuration the line('A', 'OR', 'B', 'C')specifies
that nodeAis an OR-gate over the inputsBandC.Once we’ve initialized aGraphobject, we can create a PyPhiNetwork:>>> network = graph.pyphi_network()That’s it! You can now perform all IIT computations using this network.MechanismsWhilegraphiithas a number of builtin mechanisms, you can easily specify
your own by defining a function which takes the states of the input nodes as a
parameter and returnsTrueif the mechanism should be on andFalseif
it should be off.>>> def ALWAYS_ON(inputs):
...     return TrueYou can then use this function in the graph configuration:>>> graph_config = [('A', ALWAYS_ON, 'A')]
>>> graph = Graph(graph_config)Seegraphiit.micro_mechanismsfor implementations of the basic mechanisms.Other FunctionalityTODO
Package: graphility
Graphility is based on CodernityDB byCodernity LabsGraphility is opensource, pure python (no 3rd party dependency), fast (really fast check Speed in documentation if you don’t believe in words), multiplatform, schema-less,NoSQLdatabase. It has optional support for HTTP server version (Graphility-HTTP), and also Python client library (Graphility-PyClient) that aims to be 100% compatible with embeded version.You can call it a more advanced key-value database. With multiple key-values indexes in the same engine. Also Graphility supports functions that are executed inside database.Documentation in repo still refers to CodernityDB and will be updated at the end of reconstruction process.ReconstructionAs of 2020 the original CodernityDB has been neglected for quite some time and the original repo has been lost.Nick M.already started porting CodernityDB to Python 3. Go to his repo to see progress.
I’ll try to backport any changes he makes but I cant’ guarantee anything.I decided to make my own port because I want to tear it down and rebuild it piece by piece using only Python 3.8+.
You know, to fully know the internals. I also want to add graph layer on top of it.
Also, Apache 2.0 License requires me to change the name of the project since “CodernityDB”
is a trademark/servicemark ofCodernity.Key featuresNative python databaseMultiple indexesFast (more than 50 000 insert operations per second see Speed in documentation for details)Embeded mode (default). REST Server and client are planned.Easy way to implement custom StorageSharding supportInstallGraphility is pure Python and does not need external dependencies.pip install graphilityor from sources:git clone ssh://git@github.com:Gromobrody/graphility.git
cd graphility
python setup.py installDevelopmentPoetryis used as project management tool. After downloading the project, activate the virtual env and install dev dependencies:poetry shell
poetry installNow you’re ready to go.LicenseCopyright 2020 Dominik Kozaczko (https://github.com/dekoza)Copyright 2020 Nick M. (https://github.com/nickmasster)Copyright 2011-2013 Codernity (http://codernity.com)Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: graphilp
GraphILPGraphILP is a Python API to automatically cast graph-related optimisation problems into integer linear programming (ILP) instances.Source:https://github.com/VF-DE-CDS/GraphILP-APIDocumentation:https://VF-DE-CDS.github.io/GraphILP-API-docs/Simple exampleFind the smallest number of colours needed to colour the vertices of a cycle such that adjacent vertices have different colours.importnetworkxasnxfromgraphilp.importsimportnetworkxasimp_nxfromgraphilp.partitioningimportmin_vertex_coloringasvtxG_init=nx.cycle_graph(n=5)G=imp_nx.read(G_init)m=vtx.create_model(G)m.optimize()color_to_node,node_to_color=vtx.extract_solution(G,m)The best way to get started with GraphILP is through one of our examples.InstallationGraphILP has two main requirements:NetworkXis used internally to represent graphs. It is also the easiest way to create problem instances.GraphILP creates integer linear programs in the form ofGurobimodels. To create and solve these models, you need the Gurobi solver and itsPython API.Some additional libraries are required for running the examples.While GraphILP is not yet on PyPI, it can be installed by checking out the repository and adding the path to your PYTHONPATH.
For example:exportPYTHONPATH=$PYTHONPATH:<yourpath>LicenceThe GraphILP API is released under the MIT License. See LICENSE.txt for the details.AuthorsCore development teamRolf Bardelirolf.bardeli1@vodafone.comRichard Schmiedrichard.schmied@vodafone.comMorris Stallmannmorris.stallmann1@vodafone.comContributorsAdrian PrinzThomas Sauter
Package: graphinder
GraphinderGraphinder is a tool that extracts all GraphQL endpoints from a given domain.Run with dockerdockerpullescapetech/graphinder
dockerrun-it--rmescapetech/graphinder-dexample.comIf you want to save your results.json file, you can use:dockerrun-it--namegraphinderescapetech/graphinder-dexample.com
dockercpgraphinder:/graphinder/results.jsonresults.json
dockerrm-fgraphinderOr if you want to pass a file containing domain names (one per line):dockerrun-v/full/path/to/file.csv:/graphinder/file.csv-it--rmescapetech/graphinder--inplace-f/graphinder/file.csvInstall using Pippipinstallgraphinder# using specific python binarypython3-mpipinstallgraphinderRun it withgraphinder...UsageA Scan consistes of:Running on a specific domain (-d,--domain) or a list of domains (-f,--input-file).Searching all scripts loaded by the browser for graphql endpoint (-s,--script)Brute forcing the directories of all discovered urls (-b,--bruteforce)Using precision mode (-p,--precision)By default, bruteforce and script search are enabled.graphinder-dexample.comgraphinder-fdomains.txtExtra features--no-bruteforce: Disable bruteforce--no-script: Disable script search-p --precision --no-precision: Enable/disable precision mode (default: enabled) (precision mode is slower but more accurate)-f --input-file <FILE_PATH>: Input domain names from file-w --max-workers <int>: Maximum of concurrent workers on multiple domains.-o --output-file <FILE_PATH>: Output the results to file-v --verbose --no-verbose: Verbose mode-r --reduce: The maximum number of subdomains to scan.-wb --webhook_url: The discord webhook url to send the results to.If you experience any issues, irregularities or networking bottlenecks, please reduce your number of workers, otherwise, better is your network, the more workers you can have.Local installationClone the repository and run the installation scriptgitclonehttps://github.com/Escape-Technologies/graphinder.gitcdGraphinder
./install-dev.shRun this command to enter the virtual enviromentpoetryshellProfit !graphinder-dexample.comHow do you make sure this is a valid graphql endpoint ?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: graphinf
fast-midynetFramework for graph inference.InstallationRequirementspybind11scikit-buildnumpyscipynetworkxpandaspytestInstallation with pipYou can use pip to install the python module:pipinstall.Note that thebasegraphmust be installed. You can either download it and install it yourself, or you can load the submodules and install it directly from the repository:gitsubmodule--init
pipinstallext/base_graphBuild the C++ libraryTO build the C++ library, we use cmake. First, we must set up the CMake environment. From the root directory (i.e., where the root fileCMakeFile.txtis located), run the following command:cmake-S.-BbuildThis commands build the necessary scripts for building the library. To set up the environment for building the C++ unit tests as well, set theBUILD_TESTargument toON:cmake-S.-Bbuild-DBUILD_TESTS=ON-Wno-devFinally, build the C++ library by running the following command:cmake--buildbuild-j4
Package: graphing
# graphingThis Python library provides several graphing-related utilities that can be used to apply graph theory concepts and graph algorithms to a variety of problems.## Getting Started
This library is available for use on PyPI here: [https://pypi.org/project/graphing/](https://pypi.org/project/graphing/)For local development, do the following.
- Clone this repository.
- Set up and activate a Python3 virtual environment usingconda. More info here: [https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-with-commands](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-with-commands)
- Navigate to thegraphingrepo.
- Run the command:python3 setup.py installto install the package in the conda virtual environment.
- As development progresses, run the above command to update the build in the conda virtual environment.## Sample CodeTry to run the following sample code:> from graphing.special_graphs.neural_trigraph.path_cover import min_cover_trigraph
>
> from graphing.special_graphs.neural_trigraph.rand_graph import *
> ## Generate a random neural trigraph. Here, it is two sets of edges between layers 1 and 2 (edges1) and layers 2 and 3 (edges2)
> edges1, edges2 = neur_trig_edges(7, 3, 7, shuffle_p=.05)
> ## Find the full-path cover for this neural trigraph.
> paths1 = min_cover_trigraph(edges1, edges2)
>
> print(paths1)
Package: graphio
GraphIOA Python library to bulk load data to Neo4j.DocumentationDocs available at:https://graphio.readthedocs.ioInstallInstall graphio from PyPI:pipinstallgraphioInstall the latest build version from github:pipinstallgit+https://github.com/kaiserpreusse/graphio.gitDevelopmentYou need Docker to run the test suite. First start the Neo4j instances to test against:docker-compose-ftest_neo4j_compose.ymlupInstall dependencies:pipinstall-rrequirements.txt
pipinstall-rtest_requirements.txtThen run the tests:python-mpytestAll tests that use thegraphfixture found intests/conftest.pywill run against all databases.FeedbackPlease provide feedback, ideas and bug reports through GitHub issues.
Package: graphite_anomaly_detector
Graphite-Anomaly-Detector=========================Command line application that determines spikes in Graphite metrics for a given host and generates a CSV reportUsage-----<pre>usage: generate_report.py [-h] -s SERVERS [SERVERS ...] -o OUTPUT [-l LIMIT][-p PATTERN] [-t TIMEOUT]Generates CSV report with spikes found on Graphite hostsoptional arguments:-h, --help            show this help message and exit-s SERVERS [SERVERS ...], --servers SERVERS [SERVERS ...]Servers queried by program (default: None)-o OUTPUT, --output OUTPUTOutput CSV file (default: [None])-l LIMIT, --limit LIMITLimit request count per host (default: [500])-p PATTERN, --pattern PATTERNGlob pattern for metrics (default: ['*'])-t TIMEOUT, --timeout TIMEOUTTimeout bethween requests for host (default: [1])</pre>For example<pre>./generate_report.py -s dumdum:81 -o report.csv -l 2 -p *.cpu.* -t 42</pre>Will gather the first two metrics that match \*.cpu.\* with 42 seconds timeout bethween the requests.The command will ouptut the results in report.csvResult------The program creates a csv file ginven as argument for the --output option having 5 columns:| HOST    | METRIC     | TIME        | RELEVANCE | GRAPH_URL                               ||---------|------------|-------------|-----------|-----------------------------------------|| host:81 | cpu.0.wait | 4 Jul 2013  | .42       | http://host:81/render/?target=cpu.0.wait|Developing Detectors--------------------All detectors should extend the Detector class and implement the detect_anomalies method.To change the detector in the program, just change the DETECTOR=SpikeDetector() line with an instanceof your detector.Testing Detectors-----------------For testing you can use test_local.py.It requires matplotlib for plotting the results.test_local.py receives a Graphite json response for a given target and plots the following:* Original timeseries* Timeseries after running the detector* Detector results* A treshold line (you can remove it while testing)You just have to replace SpikeDetector with your detector.For testing large data, you can use the util.logger ```create_logfile``` function.It creates a json file that can be viewed using view_log.py script that plots a graphsimmilar to the one yielded by test_local.py.
Package: graphite-api
Graphite-web, without the interface. Just the rendering HTTP API.This is a minimalistic API server that replicates the behavior of
Graphite-web. I removed everything I could and simplified as much code as
possible while keeping the basic functionality.Implemented API calls:/metrics/find/metrics/expand/renderNo-ops:/dashboard/find/dashboard/load/<name>/events/get_dataAdditional API calls:/index(POSTorPUTonly): rebuilds the search index by
recursively querying the storage backends for available paths. Replaces
graphite-web’sbuild-indexcommand-line script.Difference from graphite-webStateless. No need for a database.No Pickle rendering.No remote rendering.JSON data in request bodies is supported, additionally to form data and
querystring parameters.Ceres integration will be as an external backend.Compatibility with python 2 and 3.Easy to install and configure.GoalsSolid codebase. Strict flake8 compatibility, good test coverage.Ease of installation/use/configuration.Compatibility with the original Graphite-web API and 3rd-party dashboards.Non-goalsSupport for very old Python versions (Python 2.6 is still supported but
maybe not for long).Built-in support for every metric storage system in the world. Whisper is
included by default, other storages are added via 3rd-party backends.DocumentationOn readthedocs.orgor in thedocs/directory.HackingToxis used to run the tests for all supported environments. To get started
from a fresh clone of the repository:pipinstalltoxtox
Package: graphite_aws_cleaner
Delete old graphite data based on instance name pattern and current
running AWS instances.This is very useful if you have AWS instances that are terminated and
you no longer need their metrics, so you can just remove their stats.It is required to have AWS credentials set via environment variables
(AWS_ACCESS_KEY_IDandAWS_SECRET_ACCESS_KEY) or IAM roles.Installation$ pip install graphite_aws_cleanerUsage# aws context
web_i-123 # running
web_i-456 # running
web_i-789 # terminated


$ graphite-aws-cleaner '*web*' /opt/graphite/storageThis is going to delete all graphite data related toweb_i-789,
since the instance is no longer runnning.PatternsAnything that matches Python’sfnmatch.fnmatchworks as a pattern:PatternMeaning*matches everything?matches any single character[seq]matches any character in seq[!seq]matches any character not in seqDevelopment$ make setupRunning tests$ make test
Package: graphite-blueflood
# DescriptionGraphite _'backend'_. Twisted-based server accepts graphite source metrics and forward them to [blueflood][blueflood-git].Server accepts only pickle protocols metrics (as it's the only protocol used by graphite `carbon-relay`.)It does very primitive _'caching'_: aggregates all metrics and flushes them in regular intervals.The subsequent version of package is renamed to blueflood-carbon-forwarder.# Dependencies* twisted* mock* pytest* txKeystone# Installation```git clone https://github.com/rackerlabs/blueflood-carbon-forwarder.gitcd blueflood-carbon-forwarderpython setup.py install```# Running```twistd blueflood-forward```| Switch | Description | default || ----- | ------- | --------- || -e | Endpoint to listen on for pickle protocol metrics | tcp:2004 || -i | Metrics send interval, sec | 30.0 || -b | Blueflood address | http://localhost:19000 || -t | Tenant ID | tenant || -p | Prefix to be prepended to metrics name | metric_prefix || --ttl | TimeToLive value for metrics, sec | 86400 || -u | Keystone user | || -k | Keystone key | || --auth-url | Keystone token URL | |In case you need no authentication leave `-u`/`--user` command line argument empty (default value).# Sending metricsTo send a test metric to the twistd server you started above, you can run the following:```python tests/scripts/sendPickle.py```Modify the script accordingly for your local testing# ConfigurationConfiguration is done with command line arguments passed to twistd daemon when running:```twistd -n -l - blueflood-forward --help```#LoggingLogging can be controlled using LogObserver provided along or you can use your own LogObserver```twistd --logger carbonforwarderlogging.forwarder_log_observer.get_log_observer blueflood-forward```[blueflood-git]: https://github.com/rackerlabs/blueflood "blueflood"# Running unit tests```py.test```
Package: graphite-influxdb
An influxdb (0.8-rc5 or higher) backend for Graphite-web (source or 0.10.x) or graphite-api.Install and configure using dockerUsing docker is an easy way to get graphite-api + graphite-influx up and running.
Seehttps://github.com/Dieterbe/graphite-api-influxdb-dockerOtherwise, follow instructions below.
Graphite-api is the simplest to setup, though graphite-web might perform better.
You can use the experimental statsd support in graphite-api to have this backend
submit performance metrics (not supported with graphite-web)Manual installationpip install graphite_influxdbAbout the retention schemasIn the configs below, you’ll see that you need to configure the schemas (datapoint resolutions) explicitly.
It basically contains the same information as /etc/carbon/storage-schemas.conf would for whisper.
But Influxdb currently has no way to supply us this information (yet), so we must configure it explicitly here.
Also, it seems like internally, the graphite-web/graphite-api is to configure the step (resolution in seconds)
per metric (i.e. per Node/Reader), without looking at the timeframe.   I don’t know how to deal with this yet (TODO), so for now it’s one step per
pattern, so we don’t need to specify retention timeframes.
(In fact, in the code we can assume the data exists from now to -infinity, missing data you query for
will just show up as nulls anyway)Using with graphite-apiYou need the patched version fromhttps://github.com/brutasse/graphite-api/pull/36This adds support for caching, statsd instrumentation, and graphite-style templatesIn your graphite-api config file:finders:
  - graphite_influxdb.InfluxdbFinder
influxdb:
   host: localhost
   port: 8086
   user: graphite
   pass: graphite
   db:   graphite
   schema:
     - ['', 60]
     - ['high-res-metrics', 10]Also enable the cache. memcache doesn’t seem to work well because the list of series is too big.
filesystem seems to work well:cache:
    CACHE_TYPE: 'filesystem'
    CACHE_DIR: '/tmp/graphite-api-cache'Using with graphite-webIn graphite’slocal_settings.py:STORAGE_FINDERS = (
    'graphite_influxdb.InfluxdbFinder',
)
INFLUXDB_HOST = "localhost"
INFLUXDB_PORT = 8086
INFLUXDB_USER = "graphite"
INFLUXDB_PASS = "graphite"
INFLUXDB_DB =  "graphite"
INFLUXDB_SCHEMA = [
    ('', 60),
    ('high-res-metrics', 10)
]