semvec/pypi-packages huggingface dataset:
Quickshot 1.2
A simple tool to visdiff two web pages.

# quickshot
Make a quick visualdiff between two pages or png files.


## Requirements
Currently Quickshot only uses the Geckodriver webdriver.
Downloading and installing [Firefox](https://www.mozilla.org/en-US/firefox/new/) may be sufficient to get you set up.

Ensure Firefox is in your path after installing.

You may also need to install Geckodriver separately.
- On a Mac run, `brew install geckodriver`
- For Windows or Unix binaries see the release section of the [Geckodriver project page](https://github.com/mozilla/geckodriver).

You should also have ImageMagick installed.
Test if you already have ImageMagick installed by running, `convert -version` in your terminal.

### Installing ImageMagick
- On a Mac run, `brew install imagemagick`
- [Windows binaries](https://imagemagick.org/script/download.php#windows)
- [Unix Binaries](https://imagemagick.org/script/download.php#unix)


## Installation
### Via Pip
- Run `pip install quickshot`

### From source
- Set up a virtuanenv in some fashion, `vex --python /usr/local/bin/python3 -m quickshot`
- Install dependencies `pip3 install -r requirements.txt`


## ini files
You can add credentials to sign in to a web form in a file called 'quickshot.ini'.

Since the .ini is included in the `.gitignore` file, (To help prevent you from committing your credentials to the cloud), you'll first need to create it.

Each block can contain an `email` and `password` items.

Quickshot will attempt to use `webdriver.find_element_by_name()` to locate elements on the page that correspond to these values.

An example configuration block might look like;
```
[example]
email = doe@example.com
password = foobar
```


## Usage
Quickshot takes two required arguments being the urls of the two pages you want to compare.
```python quickshot.py "http://www.google.com" "http://www.google.fr"```

There are also some optional arguments;
- `-w, --wait`, length in seconds to wait after loading a page before taking a screenshot.
- `-i, --ini`, named section to load from `quickshot.ini` configuration file.
- `-f, --files`, flag allowing you to pass in names of `.png` files stored in `/screenshots` instead of urls.
reconcile 0.0.5
A reconciliation loop system.
Requires Python: >=3.6.8

# Reconcile

pyReconcile is a library providing a reconciliation loop system for enabling declarative configuration of arbitrary systems.

You bring the systems, the state representations, and the actions to modify them, and this brings the glue to put it all together.

## Installaion

## Usage
See two-lists.py for an example of a built around mutating one list into another.

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
[Mozilla Public License, v2.0](http://mozilla.org/MPL/2.0/)
koch-trainer 0.0.5
Koch method Morse code training program with Word Mode, Callsign Mode, and Random Character Mode

Koch method Morse code trainer
==============================

Morse code audio generation and training program, with Word Mode, Callsign Mode, and Random Character Mode.

Installation
------------

::

    $ pip install koch_trainer

Requires:

- `audiogen <https://pypi.python.org/pypi/audiogen>`_ 
- `PyAudio <http://people.csail.mit.edu/hubert/pyaudio/>`_ for audio playback (as opposed to file generation) 

Tested with Python 2.7.9 on Mac OS X.

Note that to install the PyAudio dependency on Mac OS X, you'll need to first
install ``portaudio`` with Homebrew::

    $ brew install portaudio

Examples
--------

Play back strings in Morse by passing them as command line arguments::

    $ koch_trainer hello world

Save the generated code to a WAV file::

    $ koch_trainer -f hello.wav hello world

Change the code speed from the default 20 WPM to 30 WPM::

    $ koch_trainer --effective-speed 30 hello world

And the tone frequency from the default 770 Hz to 440 Hz::

    $ koch_trainer --hertz 440 hello world

Changing the level will add or remove characters from the training pool. The following will result in a default of 100 characters output using the following characters as a base: K·M·R·S·U·A·P·T·L·O·W·I::

    $ koch_trainer --level 12 --effective-speed 7 --character-speed 20

You can also specify word mode by passing the word-mode flag. Settings exist to customize the experience. The following will result in 20 words being output with character counts ranging from 2 to 6 characters using the same 12 characters as above. Changing the level will change the characters available::

    $ koch_trainer --level 12 --effective-speed 7 --character-speed 20 --word-mode --word-count 20 --word-char-min 2 --word-char-max 6

A callsign practice mode is also available via the following::

    $ koch_trainer --effective-speed 7 --character-speed 20 --callsign-mode --callsign-count 20

Get help with CLI options::

    $ koch_trainer -h

See also
--------

- `audiogen`_ (`Github project <https://github.com/casebeer/audiogen>`_),
  a Python generator-based audio generation and processing library

Contributing
------------

Get the source and report any bugs on Github:

    https://github.com/rguisewite/koch_trainer
MimV6 1.0.0
This package implement a Man In the Middle attack in IPv6, a IPv6 Sniffer and a Statistic Packet Tool.
Requires Python: >=3.6

# MimV6

## Description
This package implement a Man In the Middle attack in IPv6, a IPv6 Sniffer and a Statistic Packet Tool.

## Requirements
 - Python 3
 - Librairies standarts
 - Scapy

## Install
```bash
pip install MimV6
```

## Usage
Command line:
```bash
mimV6
mimV6 -h && mimV6 --help
mimV6 -H -s -D -d -p -r -i -T "all" -S "save.pcap" -t "all" -v && mimV6 --no-hexa-sniffer --summary-sniffer --details-sniffer --details2-sniffer --python-sniffer --raw-sniffer --info-sniffer --target-sniffer "all" --save-filename-sniffer "save.pcap" --target-spoofer "all" --verbose-spoofer
```
To stop it use `Ctrl` + `C`.

## Test
To launch test install and use `pytest` like this:
```bash
python3 -m pip install pytest
pytest
```
## Examples

To launch mim attack like the command line in python:
```python
from MimV6 import mim_attack

mim_attack()
```
Use Packet Printer Tool:
```python
from MimV6 import PacketPrinter
from scapy.all import Ether, IPv6, TCP

printer = PacketPrinter()
printer.print(Ether()/IPv6()/TCP())
```

Use Spoofer Tool:
```python
from MimV6 import Spoofer

spoofer = Spoofer()
spoofer.launcher()
```

Use the Packet Statistic Tool:
```python
from MimV6 import statistics, PacketStats
from scapy.all import Ether, IP, TCP, UDP, IPv6

statistics.append(PacketStats(Ether()))
statistics.append(PacketStats(Ether()/IP()))
statistics.append(PacketStats(Ether()/IP()/TCP()))
statistics.append(PacketStats(Ether()/IP()/UDP()))
statistics.append(PacketStats(Ether()/IPv6()/TCP()))
statistics.append(PacketStats(Ether()/IPv6()/UDP()))
statistics.append(PacketStats(Ether()/IPv6()))
statistics.append(PacketStats(Ether()))

print(f"""
UDP: {PacketStats.udp}
TCP: {PacketStats.tcp}
Other: {PacketStats.other}
""")

print("Lenght: " + ", ".join([str(pkt.lenght) for pkt in statistics]))
```

To use Custom Sniffer and use sniffed packets:

```python
from MimV6 import Sniffer, Spoofer, PacketPrinter

class CustomAnalysis (Sniffer):
	
	def __init__ (self):
		super().__init__("all", PacketPrinter(), None)

	def analysis (self, packet):
		print(bytes(packet))

attack = Spoofer("all", CustomAnalysis())
attack.launcher()
```

## License
Licensed under the [GPL, version 3](https://www.gnu.org/licenses/).

## Link
[Gitlab Page](https://gitlab.com/ChrisASSR/mim_ipv6_scapy)