semvec/pypi-packages huggingface dataset:
cfg-contextdiff 0.6.4
Compare configuration files using contextual structures

CFG-CONTEXTDIFF
===============

This package contains two main elements used to compare text-based
configuration files (or other files in simple text in a similar format) where
they are structured using indented blocks of directives/commands:

* a parser to read in configuration files and stored them in a dictionary --
  the parser utilises the hierarchical nature of the configuration to
  understand that the same command name might mean different things in
  different contexts

* a comparator that takes two configuration dictionaries (typically produced by
  the parser, above) - a source and a target configuration - and writes out
  a configuration file (or update command set) to transform the source
  configuration into the destination

Currently, only Cisco IOS configuration files can be parsed and compared, but
the parser and comparators (and the wrapper command line tool) are written such
that they should be extensible to new platforms (by creating new concrete
classes from the abstract toplevel classes).

At the present time, only a subset of configuration directives for Cisco IOS
are supported but more can be added, as required.

The scripts also support a system whereby rules can be included (rather like an
access control list) to specify which elements of the configuration are
included in the output.  This allows known differences to be ignored.
jupytermodule 0.5.0
import jupyter notebooks as python modules
Requires Python: >=3.6

# jupyter-module

![](https://img.shields.io/pypi/v/jupytermodule?style=flat-square)
![](https://img.shields.io/pypi/l/jupytermodule?style=flat-square)

Import jupyter notebooks as python modules.

* Only imports, top-level variables, and class/function definition will be imported.
* Jupyter magics can still be used in the notebook without affecting importing.


## Install

```
pip install jupytermodule
```

## Synopsis

```python
from jupytermodule import open

notebook_module = open("https://raw.githubusercontent.com/poga/jupytermodule/master/examples/primes.ipynb")

print(notebook_module.primes(10))
# [2,3,5,7]

# Access to top-level variables
print(notebook_module.PI)
# 3.1415
```

## License

MIT
SimpleBencher 0.6.0
Benchmarking Suite

# Bencher
Benchmarking system for python 3

## Description
This is a little Benchmarking module for Python 3. It provides a easy to use Benchmarking class and a statistics class for further analysis.
It can save the measured benchmarks into a centralized folder in the home/user directory. This works crossplatform, I currently tested it on Windows and Debian, but it should work on most linux distributions and on OSX as well.

## Install

`python setup.py install` 


## Usage
```python
from bencher import Bencher
benchmark = Bencher("benchmarkcase")
benchmark.start()
# Productive coding
######
#
benchmark.stop()

# To get the measured time
time_needed = benchmark.get_time()

# To print a benchmark hint
print(benchmark)

# Save current benchmark for later analysing via the bencher.Statter class
benchmark.save()

# Reset benchmark
benchmark.reset()
```

## Usage statter

```python
from bencher import Statter

statter = Statter("benchmarkcase")

# Get sum
statter.sum()

# Get average
statter.avg()

# Get count
statter.count()
```

I will add more features, when I need them or someone requests them.
simple_python_profiler 0.2
A simple cli-based profiler for Python

# simple_python_profiler

An early look at a _simple_ Python profiler, written in Python. Get started by typing `pip install simple_python_profiler`.

## Description
A profiler that times every function call and reports back the top 100 slowest functions.

_logs every function call means it's non-sampling, hence resource-intensive. If that's unsuitable, check out something like [py-spy](https://github.com/benfred/py-spy)._

Usage:
```python
# your-script.py

from simple_python_profiler import Profiler
if __name__ == '__main__':
    with Profiler():
        run_your_code()

```

This will decorate all your top-level functions in your modules. System (built-in) and pip-installed packages (those that go in `dist-packages`) are excluded.

Since the default behaviour is to not include nested functions, you can profile your nested functions too as follows:

```python
from simple_python_profiler import profile_recursive

# your-module.py

def top_level_function():

    @profile_recursive
    def inner_function():
        print('in inner fn')

```

This recursive feature relies on the [codetransformer](https://github.com/llllllllll/codetransformer) dependency. However, it has a few bugs in recent versions of Python. If you encounter runtime exceptions with `simple_python_profiler`, use the second, non-recursive decorator:

```python
from simple_python_profiler import profile

# your-module.py

def top_level_function():

    @profile
    def inner_function():
        print('in inner fn')

```

# Releasing on PyPI
- `pipenv shell`
- `flit build`
- `flit publish`

Enter password when prompted.

# TODO
- option to include system packages

Released under the MIT licence. See file named LICENCE for details.