semvec/pypi-packages huggingface dataset:
multithread-parallel-processing 1.0.0
Library support parallel processing with multi-thread
Requires Python: >=3.6

# Multi-thread Parallel Processing

Library support parallel processing with multi-thread.

## Installation
```shell
$ pip3 install miltithread_parallel_processing
```

## Example

Example job to calculate sum of the squares of the first billion natural numbers.

```python
from multithread_processing.base_job import BaseJob


class SumSquaresJob(BaseJob):
    def __init__(self, batch_size=1000, max_workers=4):
        self.n = 10 ** 9
        work_iterable = range(self.n)
        super().__init__(work_iterable, batch_size, max_workers)

    def _start(self):
        self.sum = 0

    def _execute(self):
        self.batch_executor.execute(
            self.work_iterable,
            self._execute_batch,
            total_items=self.n
        )

    def _execute_batch(self, works):
        _sum = 0
        for i in works:
            _sum += i * i
        self.sum += _sum

    def _end(self):
        print(f"Sum of the squares of the first {self.n} natural numbers: {self.sum}")
        self.batch_executor.shutdown()


if __name__ == "__main__":
    job = SumSquaresJob(
        batch_size=10000,
        max_workers=10
    )
    job.run()
```
PythonicBrain 0.0.3
A python Util package

# PythonicBrain

### Install

```bash
pip install PythonicBrain
```


## Available functions

```python
from PythonicBrain.PBTable import table
- table(): prints a data table provided as list

table([[1,2,3,4],[3,4,5,6]])

```

```python
from PythonicBrain.PBDecorators import executiontime

- @executiontime [decorator] : prints the time of execution of a parameter

@executiontime
def hello()
    --

```
```python
from PythonicBrain.PBInteger import *

- float_range() : Returns a iterable of floating range

float_range(start, stop, step)


```
```python
from PythonicBrain.PBString import *

- random_string() : return a random string of given length and character set

print(random_string(54))


- slugify() : Returns a slug text from given vlaue

slugify(hello world)


- splash() : return a string with given splash style

splash(hello world)


- headline() : return a formatted string in headline style

headline(hello world)

- multiline_input() : takes multiline user input

 inp=multiline_input()
 print(inp)



```
dn3 1.0.2
Lightweight alternative to pwntools
Requires Python: >=3.6, <4
Keywords: pwn

deathnot3
====

## Description
deathnot3 was created as a wrapper for pwntools, but with the addition of the "l1ght" submodule, it aims to be a lightweight alternative to pwntools
while providing majority of the essential functionality for exploit scripts.
deathnot3 aims to:
 - allow strings and bytes interchageably
 - be lightweight
 - provide basic automation
 - be an all around pwn helper for CTFs

## Requirements
Supports: Python 3.6+

Library Dependency:
- pwntools
- zstandard
- unix_ar
- requests
- wget

## Usage

 ```py
  from dn3 import *
  from pwn import ELF

  binary = ELF("./binary")
  libc = ELF("./libc.so.6")

  context.mode = str      
  # recv in string. Can also be set to bytes
  
  io = process("./binary")
  DeathNot3(io, libc=libc) # Initialize deathnot3
  
  reu("yeet")              # equivalent of io.recvuntil()
  sl(b"leet")              # equivalent of io.sendline()
  sla("yeet",8)            # equivalent of io.sendlineafter()
  s("bruh")                # equivalent of io.send()
  # bytes, string and integers can be used interchageably to send
  
  sl(p64(0xdeadbeef))      # equivalent of p64() but returns string
  sla("oof", flat([
	  0xdeadbeef,"ABCD"    # equivalent of flat() but returns string
	  ])
  
  libc = libcleak("puts")  # Offset integer can be given instead of symbol
  # Equivalent to
  # libc = unpack(io.recv(6),48) - libc.symbols.puts
  # log.info("Libc -> %s" % hex(libc)
  
  interactive()             # equivalent of io.interactive()
  ```

 - CLI
 
	**`dn3 template <binary_path> -l <libc_path> -r <ip>:<port>`**
	 - used to generate template exploit on the go, based on a template format
	 - edit config using `dn3 config` and specify template format url or path (if path prefix with `local:`)
	 - [example template format](https://raw.githubusercontent.com/k1R4/deathnot3/v1.0.0/template.py)
	 
	**`dn3 linker <binary_path> -l <libc_path>`**
	 - Find appropriate dynamic linker for given libc and patch binary with it and provided libc using `patchelf`

    **`dn3 config <key(optional)>`**
     - Edit dn3's config
     - Config is located at `~/.dn3.conf`

## TODO
 - [ ] Implement ELF similar to that of pwntools
 - [ ] Implement buffering for process, remote
 - [ ] Add automation
    - [ ] static vulnerability detection
    - [ ] ret2win
    - [ ] ret2shellcode
    - [ ] ret2libc/ROP
    - [ ] tcache poisoning
 - [ ] Add documentation to wiki
 - [ ] Add support for big endian
 - [ ] Add support for arm based architectures
    - [ ] aarch64
    - [ ] arm