semvec/pypi-packages huggingface dataset:
stapsdt 0.1.1
Create USDT probes and instrument your Python application dynamically
License: MIT
Keywords: usdt stapsdt systemtap sdt tracing probes instrumentation performance

# python-stapsdt

Create USDT probes and instrument your Python application dynamically.

# Dependencies

At the moment this package only runs on Linux and requires
[libstapsdt](https://github.com/sthima/libstapsdt) to be installed to create
runtime probes.

## Ubuntu 16.04

To install libstapsdt, run:

```bash
sudo add-apt-repository ppa:sthima/oss
sudo apt-get update
sudo apt-get install libstapsdt0 libstapsdt-dev
```

## Other

Build from [libstapsdt](https://github.com/sthima/libstapsdt).

# Install

```bash
pip install stapsdt
```

# Example

The following code will create a probe named `firstProbe`.

```python
from time import sleep

import stapsdt

provider = stapsdt.Provider("pythonapp")
probe = provider.add_probe(
    "firstProbe", stapsdt.ArgTypes.uint64, stapsdt.ArgTypes.int32)
provider.load()


while True:
    print("Firing probe...")
    if probe.fire("My little probe", 42):
        print("Probe fired!")
    sleep(1)
```

You can then trace this probe with any tool able to trace Systemtap's probes.
Here's an example with eBPF/bcc:

```bash
sudo trace -p PID 'u::firstProbe "%s - %d", arg1, arg2'
```
dagpy 0.3.2
Data science collaboration tool based on iPython notebooks.
License: MIT
Keywords: jupyter ipython collaboration dag datasci

DAGpy
=====

DAGpy is a data science collaboration tool based on iPython notebooks enabling data science teams to:

- easily collaborate by branching out of others' notebooks 
- minimize code duplication 
- give a clean overview of the project 
- cache intermediate outputs so team members can use them without re-evaluation 
- automate the process of code execution upon data changes or on schedule 
- provide a clean interface to the data visualization dashboard designers and developers

DAGpy manages a DAG (directed acyclic graph) of blocks of code, with
each block being a sequence of iPython notebook cells, together with
their outputs. It is designed to work seamlessly with popular VC systems
like git and can be run locally or as a server application.

GitHub: `github.com/ibestvina/dagpy/
<https://github.com/ibestvina/dagpy/>`_.

Author: Ivan Bestvina


Example project
---------------

To play around with the example project, you can:

- view the project DAG: ``dagpy view``
- run all the blocks: ``dagpy execute -a``
- add blocks through flows (with block B as a parent) and run them automatically: ``dagpy makeflow B -r``
- commit the changes: ``dagpy submitflow dagpy_flow.ipynb``
- explore other DAGpy options with  ``dagpy -h``

Please note that notebook execution time includes a significant overhead
of over a second, because a kernel must be started for each one. In
future, we plan on adding support for non-notebook plane python blocks.
These would also be edited through a flow notebook view, but would be
saved as .py scripts, and executed without noticable overhead.

Dependencies:

- python 3 
- jupyter 
- dill 
- networkx, matplotlib (for DAG view)