semvec/pypi-packages huggingface dataset:
dns-spoofer 1.0
Spoof DNS queries over UDP

# dns-spoofer

Send spoofed DNS queries over UDP.

# Installation

```
pip install git+https://github.com/kimbo/dns-spoofer.git
```

That will install two scripts

- `dns-spoof` - send DNS queries with a different source port and source IP address than your own.
- `dns-listen` - listen for and print UDP packets (i.e. DNS queries) on a port and address

# Quick example

This will be a little bit cooler if you have access to two different computers on the same network, 
but it'll work just the same on just one.

### Step #1: 
Open up a terminal and run:
```
$ dns-listen 53535
Listening on port 53535 and address ...
```
You can replace 53535 with whatever port number you want (I'd recommend one bigger than 1024).

Note that the address is blank (meaning we're listening on all addresses).

If you have two computers, take note of the first computer's IP address (look into `ip addr`, or `ifconfig` if you're on a Mac)

### Step #2
If you have two computers, you'll need the IP address from your first machine here:
```
$ dns-spoof example.com 1.1.1.1 --sport 53535 --src-addr <IP-address-here>
```
Otherwise, if you're doing this on one computer, run:
```
$ dns-spoof example.com 1.1.1.1 --sport 53535
```
Your output after running `dns-spoof` should look something like this:
```
(query) 192.168.0.25#53535 --> 1.1.1.1#53, "example.com" type "A"

### QUERY TIME: 0.00028133392333984375
```

Soon after running `dns-spoof`, look at the terminal you were running `dns-listen` on. 
It should have printed out something like this:
```
Got 45 bytes from ('1.1.1.1', 53)
id 62725
opcode QUERY
rcode NOERROR
flags QR RD RA
;QUESTION
example.com. IN A
;ANSWER
example.com. 3574 IN A 93.184.216.34
;AUTHORITY
;ADDITIONAL
```

Congratulations! You just sent a spoofed DNS query :smile:

# Usage for dns-spoof
```
$ dns-spoof -h
usage: dns-spoof [-h] [--dport DST_PORT] [--src-addr SRC_ADDR]
                 [--sport SRC_PORT] [-t RDTYPE] [-n NUM_QUERIES]
                 qname dst_addr

positional arguments:
  qname
  dst_addr              The address to send the DNS query to

optional arguments:
  -h, --help            show this help message and exit
  --dport DST_PORT, --destintaion-port DST_PORT
  --src-addr SRC_ADDR, --source-address SRC_ADDR
  --sport SRC_PORT, --source-port SRC_PORT
  -t RDTYPE, --rdtype RDTYPE
  -n NUM_QUERIES, --num-queries NUM_QUERIES
```

# Usage for dns-listen
```
$ dns-listen -h
usage: dns-listen [-h] [--addr ADDRESS] port

positional arguments:
  port

optional arguments:
  -h, --help            show this help message and exit
  --addr ADDRESS, --address ADDRESS
```

# Disclaimers

- I've only tested this from behind a NAT
- Only works with UDP and IPv4
- I'm not responsible for what you do with this.

# License

see [LICENSE](./LICENSE)
urbandict 0.6.1
CLI client and a library for urbandictionary.com

# py-urbandict

[![Build
Status](https://travis-ci.org/novel/py-urbandict.svg?branch=master)](https://travis-ci.org/novel/py-urbandict)

py-urbandict is a client for urbandictionary.com.

Project page on github: https://github.com/novel/py-urbandict
PyPI: https://pypi.org/project/urbandict/

## Installation

Just run:

  `sudo setup.py install`

## Usage

To use it from command line, just use 'urbancli' tool like that:

```
$ urbandicli xterm
1. xterm
  Godly creature, omnipotent, guru in every way imaginable.
  
  Examples:
  
  * I wish i was an xterm

$
```

Usage from Python:

```
$ python3.2
Python 3.2 (r32:88445, Feb 27 2011, 09:51:00) 
[GCC 4.2.1 20070719  [FreeBSD]] on freebsd8
Type "help", "copyright", "credits" or "license" for more information.
>>> import urbandict
>>> urbandict.define('xterm')
[{'word': 'xterm', 'example': 'I wish i was an xterm', 'def': 'Godly creature, omnipotent, guru in every way imaginable.'}]
>>> 
```

It returns list of defitinitions for a term. Each list item is a dict with the following keys:

* word -- the word itself
* def -- definition of the term
* example -- example of its usage (could be empty)
microplink 0.0.1
PLINK file processing with numba
Requires Python: >=2.7

`microplink`
===========

This class provides a minimal and fast interface for retrieving genotypes
from Plinks's BED/BIM/FAM file trios. The BED file must fit in memory.

Requirements
------------

`numpy`, `pandas`, and `numba`. These are included with many Python
distributions.

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

Run `pip install microplink` or clone this repository and run `python setup.py
install` from the repository directory.

Usage
-----

Typical usage:

    import microplink as mic

    # Equivalent to `pf = mic.PlinkFiles('test.bed', 'test.bim', 'test.fam')`
    pf = mic.PlinkFiles('test')

    # fetch by chromosome and position
    pf.get_genotypes(chromosome=1, position=10000)

    # fetch by variant name (often RSID)
    pf.get_genotypes(snp='rs1235123')

    # fetch by SNP integer index
    pf.get_genotypes(snp_index=0)