semvec/pypi-packages huggingface dataset:
graf 0.1.2
Light weight numpy, scipy, and matplotlib wrapper
License: MIT
Keywords: numpy,scipy,matplotlib,gnuplot,plot,graph,analysis

# Graf

Graf was built as a daily graph drawing program.
There is a powerfull graph drawing tool called [matplotlib][] but that is too
powerfull and complecated to use as a daily tool.
The purpose of the Graf is to make it easier and simpler for daily graph drawing
powerd by wrapping matplotlib and giving some useful methods for loading or
analysing data.

# Example
Prepare example data in `raw` directory as `data.00.txt`, `data.01.txt`, ...etc.
Save the following code as `example01.graf` and run `graf example01.graf`

```python
# Load column 0 and 1 of data.00.txt, data.01.txt, ... in raw directory
dataset = load('raw/data.??.txt', using=(0, 1))
# Plot all data
for x, y in dataset:
    plot(x, y)
# Show
show()
```
sonnet 0.1.6
UNKNOWN
License: MIT
Keywords: networkx json graph javascript D3

========================
Sonnet J(SON + Net)workX
========================

Sonnet wraps a NetworkX graph and produces detailed JSON output for use with JavaScript to produce detailed graph visualizations in the browser.

Getting Started
===============

Install Sonnet::

	pip install sonnet

Build a NetworkX graph::
	
	import networkx as nx

	g = nx.gnp_random_graph(20, 0.5)

Wrap it with Sonnet:: 

	import sonnet as sn

	s = sn.Sonnet(g, name='An Awesome Graph')

Build stats directly into node directory using modified NetworkX algorithms. Currently available: degree, degree_centrality, in_degree_centrality, out_degree_centrality, closeness_centrality, betweenness_centrality, eigenvector_centrality::

	s.betweenness_centrality()

Find communities and assign nodes to group based on community::

	s.find_communities()

Rank node size by nodes by attribute::

	s.rank_nodes(rank_by='betweenness_centrality')

Now we have a nodes with lots of relevant data::

Produce JSON data (example data reduced for readability)::

	s.jsonify()

	'{
	    "directed": false,
	    "name": "An Awesome Graph",
	    "links": [
	        {
	            "source": 4,
	            "target": 8
	        },
	        {
	            "source": 5,
	            "target": 7
	        },
	        {
	            "source": 6,
	            "target": 8
	        },
	    ],
	    "multigraph": false,
	    "graph": [
	        [
	            "name",
	            "gnp_random_graph(10,0.5)"
	        ]
	    ],
	    "nodes": [
	        {
	            "betweenness_centrality_ranking": 2.7258064516129035,
	            "community": 2,
	            "id": 0,
	            "betweenness_centrality": 0.04953703703703703
	        },
	        {
	            "betweenness_centrality_ranking": 1,
	            "community": 1,
	            "id": 1,
	            "betweenness_centrality": 0.0
	        },
	        {
	            "betweenness_centrality_ranking": 4.580645161290322,
	            "community": 1,
	            "id": 2,
	            "betweenness_centrality": 0.10277777777777775
	        },
	        {
	            "betweenness_centrality_ranking": 6.0,
	            "community": 2,
	            "id": 3,
	            "betweenness_centrality": 0.1435185185185185
	        },
	    ]
	}'


D3Graph
=======

D3Graph is designed to produce JSON output for D3.js graphs. It works just like Sonnet, but it has extra attributes set at during init.

Compare::

	s = sn.Sonnet(g)

	vars(s)

	{'color_by': 'community',
	 'graph': <networkx.classes.graph.Graph at 0x1726210>,
	 'max_node_size': 6,
	 'min_node_size': 1,
	 'name': None,
	 'rank_by': 'degree_centrality'}

	d = ns.D3Graph()

	vars(d)

	{'charge': -150,
	 'color_by': 'community',
	 'graph': <networkx.classes.graph.Graph at 0x1726210>,
	 'gravity': 0.06,
	 'height': 800,
	 'link_distance': 40,
	 'max_node_size': 6,
	 'min_node_size': 1,
	 'name': None,
	 'rank_by': 'degree_centrality',
	 'width': 1280}
xtraceback 0.4.0-rc1
A verbose traceback formatter
License: MIT
Keywords: traceback exception nose

XTraceback is a verbose Python traceback formatter with support for variable
expansion and syntax highlighting. It is intended both as a development tool
and as an aide to post-mortem debugging.

.. image:: https://secure.travis-ci.org/0compute/xtraceback.png?branch=master
    :target: http://travis-ci.org/0compute/xtraceback

Documentation is published at `read the docs`_.

.. _read the docs: https://xtraceback.readthedocs.org/en/latest/
pyflogd 0.1.1
File system access monitoring daemon
License: MIT

pyflogd
=======

pyflogd is a monitoring tool to support you when tracking down potential
file system bottlenecks. It uses the inotify kernel API.

pyflogd uses a dev-friendly JSON output format. Every line will contain
one JSON object with a type and a path property. You can parse the lines
and analyse which files are accessed and written the most.

Requirements
------------

-  daemon
-  docopt
-  hashlib
-  json
-  lockfile
-  pyinotify
-  schema
-  signal

Notes on using pyflogd on Ubuntu
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

When pyinotify is installed via apt you will get an old version that has
a known bug regarding recursive watching. When using this version it is
not possible to track files and folders in folders that are created
after pyflogd has started. To solve this, you can run
``pip install --upgrade pyinotify``.

Python 3 compatibility
~~~~~~~~~~~~~~~~~~~~~~

pyflogd depends on python-daemon which is currently not compatible with
Python 3. Running pyflogd as daemon will not work without this, but the
``run`` command should work just fine.

Installation
------------

To install pyflog run the following commands:

::

    git clone https://github.com/mkzero/pyflogd
    python2 setup.py install

After that you should be able to use the ``pyflod`` command from you
commandline.

Usage
-----

::

    Usage:
     pyflogd run [-f | --only-files] [-r | --recursive] [-o <file> | --outfile=<file>] <folder> ...
     pyflogd start [-f | --only-files] [-r | --recursive] [-o <file> | --outfile=<file>] <folder> ...
     pyflogd stop <folder> ...
     pyflogd -h | --help
     pyflogd -v | --version

    Options:
     -h --help                 Show this screen
     -v --version              Show version
     -r --recursive            Watch a folder recursivly
     -f --only-files           Don't report events for folders
     -o FILE --outfile=FILE    Write to file instead of stdout

run
~~~

The ``run`` command starts pyflogd in foreground and outputs events to
stdout when no ``outfile`` is supplied.

Example:

::

    pyflogd run --outfile=/tmp/pyflogd.log --recursive /path/to/folder1 \
               /path/to/folder2 /path/to/folder3

start/stop
~~~~~~~~~~

The ``start`` command starts a pyflogd daemon in the background and
outputs events to the supplied ``outfile``. To stop the daemon use the
same folders as for the start command and omit all other options like
``outfile`` or ``recursive``.

Example:

::

    pyflogd start --outfile=/tmp/pyflogd.log --recursive /path/to/folder1 \
               /path/to/folder2 /path/to/folder3

    pyflogd stop /path/to/folder1 /path/to/folder2 /path/to/folder3