semvec/pypi-packages huggingface dataset:
pointbreak 0.0.2
System process debug and analysis library.

# Pointbreak

Pointbreak lets you write python programs that debug or analysis other programs. It works like a debugger but because it's a Python library you can extend and interact with it very easily.

Pointbreak is designed to make debugging and analysing complex things like JITs simpler without having to added lots of debugging code to the target.

## General Advantages
* Breakpoints are any Python callable
* Simple API
* Can be used from a Python REPL like IPython
* Can be easily embedded in other things e.g. a Flask app
* Easy to add support for custom symbols and JIT generated code
* Simpler and less restrictive than GDB Python API

## Disadvantage
* Early developement
* Missing many standard debugger features
* Other issues see https://github.com/tonysimpson/pointbreak/issues

# Example print BOO! when function is called
If you compile `gcc ghost.c -o ghost` and run `./ghost` nothing much happens
But if we run `python boo_ghost.py` it prints
```Boo!
Boo!
Boo!
Boo!
Boo!
Boo!
Boo!
Boo!
Boo!
Boo!
```
because our python function is getting called each time there_is_a_ghost is called.
There are more examples in the examples directory.

## ghost.c
```C
/* I'm a silly program that does nothing much on its own. */
/* Compile me with "gcc ghost.c -o ghost".                */

void there_is_a_ghost(void) {
    return;
}

int main(int argc, char *argv[]) {
    int i;
    for (i = 0; i < 10; i++) {
        there_is_a_ghost();
    }
    return 0;
}
```
## boo_ghost.py
```python
from __future__ import print_function
import pointbreak

def print_boo(debugger):
    print("Boo!")
    return True

db = pointbreak.create_debugger('ghost')
db.add_breakpoint('there_is_a_ghost', print_boo)
db.continue_to_last_event()
```
fftpower23 1.0.0
Fast Fourier Transformation with powers 2 and 3

fftpower23 package contains library to calculate Fast Foutrier Transformation.
Also it provides a set of functions to calculate commonly used sprectral characteristics (both single and mutual) for numerical series.

The main difference from the other simular packages that it provides FFT for the series those have length based both powers 2 and 3.
The exact formula for acceptable lenghts is 4*2**n*3**m; n,m >= 0.
Any particular length can be checked by calling function IsValidLength (lenght)
List of first 100 allowed numbers (number №100 = 373248) can be found in docs/first_100_allowed_lengths.txt

The source code successfully compiled and tested on both python 2.7.6 and python 3.4.3
Original algoryth has been rewritten to python from C++, C++ source code is available at https://bitbucket.org/VladimirPopov43/fft_cpp/src

Full public API with the example of usage can be found at docs/api_doc.txt

Sincerely yours,
Vladimir Popov, vladimir.popov@gmx.com