semvec/pypi-packages huggingface dataset:
sloris 1.0.3
Slow Loris denial of service attack
License: MIT
Requires Python: >=3.8
Keywords: sloris,dos,security,hacking,denial of service

# Slow Loris DoS Attack

Python implementation of the Slow Loris denial of service attack

https://gitlab.com/richardnagy/security/sloris

## Disclaimer

This tool is intended for demonstrational purposes, so only use against your systems or against ones you have authorization for. I take no responsibility for your actions.

## Introduction

Slow Loris is a low-bandwidth denial of service attack, utilizing lots of connections to the same host and keeping them alive while sending minimal data.

When receiving a GET request, the server will wait until an empty line is sent to transmit the requested resource. We don't want any data in return, only to occupy the given connection.

The HTTP standard does not define a limit to the header count, but most frameworks have a limit defined in bytes, after which they will abort the connection. A default NodeJS 14+ setup has an upper limit of 16 kb. Using our current header size (average 15 bytes per header), it will take ~1,000 headers to fill this up.

If we consider an average of 5 seconds as a timeout period, one connection can occupy a channel for about 5000 seconds or around 1 hour 23 minutes. This happens while sending only 16kb of data.

This attack is most effective if:

- The host has a hard-limited number of possible connections at a time
- The host has no load balancing or firewalls
- The host has no DoS protection
- The attack is carried out by a distributed network of systems

## Requirements

- Python 3.10+

## Usage

Start an attack

```bash
sloris HOST_IP [OPTIONS]
```

Help:

Use the following command to get a list of options.

```bash
sloris -h
```

Example run

```bash
sloris localhost -p 8080 -c 1000 -m GET -u /page -t 5 -pc true
```

## Repository

For more information or contribution please take a look at the [git repository](https://gitlab.com/richardnagy/security/sloris)
glom-dict 0.0.2a0
Custom Dictionary with glom get, set and del methods
License: MIT
Requires Python: >=3.6.2,<4.0.0
Keywords: glom,dict,nested

# glom-dict

[![ci](https://github.com/Kilo59/glom-dict/workflows/ci/badge.svg)](https://github.com/Kilo59/glom-dict/actions)
[![documentation](https://img.shields.io/badge/docs-mkdocs%20material-blue.svg?style=flat)](https://glom_dict.github.io/glom-dict/)
[![pypi version](https://img.shields.io/pypi/v/glom-dict.svg)](https://pypi.org/project/glom-dict/)

Custom Dictionary with glom path compatible get, set and delete methods.

https://glom.readthedocs.io/en/latest/

For easy access to and operations on nested data.

## Installation

```bash
python -m pip install glom-dict
```

## Examples

```python
>>> from glom_dict import GlomDict
>>> d = GlomDict(my_dict={"a": {"b": "c"}})
>>> d["my_dict.a.b"]
 'c'

>>> d["my_dict.a.b"] = "C"
>>> d["my_dict.a.b"]
 'C'
```

### Better error messages.

```python
>>> d = GlomDict({'a': {'b': None}})
>>> d["a.b.c"]
Traceback (most recent call last):
...
PathAccessError: could not access 'c', index 2 in path Path('a', 'b', 'c'), got error: ...
```

### Glom Paths

```python
from glom_dict import GlomDict, Path
>>> my_path = Path("a", "b", 1)
>>> d = GlomDict({"a": {"b": ["it", "works", "with", "lists", "too"]}})
>>> d[my_path]
'works'
```

For more examples refer to the excellent `glom` tutorial.

https://glom.readthedocs.io/en/latest/tutorial.html

## Details

Based on `collections.UserDict`

Implemented methods

- [x] `__getitem__` - `glom.glom()`
- [x] `__setitem__` - `glom.assign()`
- [x] `__delitem__` - `glom.delete()`
- [x] `assign` - `glom.assign()` - can pass `missing` callable to automatically backfill missing structures.
- [ ] `update` - Works but no special behavior
accscout 1.3.3
Search for certain user accounts on popular websites on the internet
License: MIT
Requires Python: >=3.8
Keywords: accscout,account,security,hacking,OSINT,crawler

# Account Scout

Search for certain user accounts on popular websites on the internet

## Installation

### With pip package manager

```bash
pip install accscout
```

### From repository

Download repository

```bash
git clone https://gitlab.com/richardnagy/security/accscout
cd accscout
```

Run setup script

> Make sure you use the correct python command. On Linux systems it's python3 by default.

```bash
python setup.py install
```

## Usage

After installation, simply use the command with the username you're searching for

```bash
accscout [USERNAME]
```

## Example

![demo run of the app](/assets/demo.png)

## License

Standard MIT license ([view](/LICENSE))
quick-sqlite 1.5
This library can you help you use sqlite3 much easier and faster.
License: MIT
Keywords: sqlite,sqlite3,quick,quick_sqlite,sqlite3_helper,fast_sqlite

# quick_sqlite

QuickSqlite helps you work with sqlite3 databases in a much easier way.
It is simple and easy to use. You will not have to repeatedly write sql statements.
This will also improve your productivity by recognizing what's happening because of informative function names.

## Installation
```
pip install quick_sqlite
```

Read more in the documentation [here](https://quick-sqlite.readthedocs.io/en/latest/index.html)
lock-defaults 0.1.4
Helper decorator to lock default mutable values
License: MIT
Requires Python: >=3.8,<4.0

# lock-defaults
[![PyPI](https://img.shields.io/pypi/v/lock-defaults.svg)](https://pypi.org/project/lock-defaults/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/inkleby/lock-defaults/blob/main/LICENSE.md)
[![Copy and Paste](https://img.shields.io/badge/Copy%20%2B%20Paste%3F-yes!-blue)](#install)

This decorator is small and only relies on the standard library, so can just be copied into a project.

Python has a weird behaviour around default values for functions. If you use an empty list as a default argument, things added to the list during the function can hang around for next time the function is called. A common pattern of dealing with this is the following:

```python
def func(foo = None):
    if foo is None:
        foo = []
```

But this looks rubbish! And gets worse when you add typing:

```python
def func(foo: list | None = None):
    if foo is None:
        foo = []
```

You don't need that workaround for any other of default value. Why does the list parameter have to pretend it can be None, when that's not the intention at all?

The `lockmutabledefaults` decorator fixes this by introducing what *should* be the default approach, and default values that are lists, dictionaries or sets are isolated in each re-run.

```python
@lockmutabledefaults
def func(foo: list = []):
    pass
```

## Install

You can install from pip: `python -m pip install lock-defaults`

Or you can copy the function directly into your projects.

* For python 3.10+: [with_paramspec/lock_defaults.py](/src/lock_defaults/with_paramspec/lock_defaults.py)
* For python 3.8, 3.9: [without_paramspec/lock_defaults.py](/src/lock_defaults/without_paramspec/lock_defaults.py)
shapley-values 1.0.1
Shapley values package
License: MIT
Requires Python: >=3.8
Keywords: shapley,pypi,package

# Shapley values

An open-source library of [Shapley value algorithms](https://en.wikipedia.org/wiki/Shapley_value) in Python.

***For example of "Shapley values" algorithm you can enter to: [example of "Shapley values"](http://liadn7.pythonanywhere.com/)***

## Installation

    clone https://github.com/LIADN7/shapley_values.git
    cd shapley_values
    pip install -r requirements.txt
    pip install -e .

To verify that everything was installed correctly, run one of the test programs,

    python shapley_values/tests/test_shap.py
    python shapley_values/tests/test_x_shapley.py


## Other algorithms implemented:
  ***[X_Shapley](https://www.aaai.org/AAAI22Papers/SA-00194-NizriM.pdf)***
envotate 0.0.1
Settings management using environment variables and type annotations.
License: MIT
Requires Python: >=3.9

# Envotate

**Work in progress**

Settings management using environment variables and type annotations. This intended to support both class-based and module-based configurations.

## Example

<img src="https://user-images.githubusercontent.com/1376648/173243159-af22ce43-c7b9-4854-9187-aec83342bce0.gif" width="50%" height="50%"/>

Define a configuration like this:

```python
# app/settings.py
from envotate.env import Env, env
from envotate.types import Choice, Default


@env
class Database:
    DB_USER: str
    DB_PASSWORD: str
    DB_HOST: str
    DB_PORT: int
    DB_NAME: str


PY_39 = "py39"
PY_310 = "py310"


@env
class Settings:
    DATABASE: Database
    DEBUG: bool = False
    PY_VERSION: Env[str, Choice([PY_39, PY_310]), Default(PY_39)]

```

Then access it in an application:

```python
# app/main.py
from app.settings import Settings


def main():
    print(Settings.DATABASE.DB_NAME)


if __name__ == "__main__":
    main()

```