semvec/pypi-packages huggingface dataset:
ptlib 0.0.5
This library aims to provide efficient implementation and detaile debugging of solutions to problems in the asynchronous domain.
Requires Python: >=3.8

# Parallel Timing Library
This library that aims to decrease the latency of shared-memory-based communication between asynchronous processes in Python. The common practice for sharing data between parallel processes is using a Python standard library multiprocessing Queue-like data structure. However, this requires that the data be serialized and transferred over a local socket, leading to a significant bottleneck when dealing with large data structures. I have been able to decrease this latency by leveraging the multiprocessing SharedMemory class added to the standard library with the release of Python 3.8. This addition allows the user to allocate bytes in memory and directly read/write to a buffer without serializing data. As it currently stands, implementing this requires an intimidating amount of familiarity with multiprocessing. I aim to abstract most of the heavy lifting in this library with the hope of increasing the readability and efficiency of asynchronous pipelines.

* tests show that ptlib.Queue can be more than 50 times faster than multiprocessing.Queue.


### TODO

- implement option to directly specify job spec
- infer job by passing a list into `output_job`, have job map assign 
indices like before, and then iterate over jobs and infer shape
- write job to be a dict. overload set item and make sure assignment fills
- save key of job in job spec
- pass in output and input job buffers when job map is created
- refer to embedded jobs as subjobs? 
- overload getitem for jobinfer such that the first assignment allows for 
  something immutable

- create requirements file 
- way to implement task order non linear pipelines
- document the code lol
- get rid of unused imports

- remove duplicated code from controller `_set_up_tasks`

- fix task job map documentation
- create way to specify spec in typing. for ex, job: Job[JobSpec]
- create several objects in _typing



- *** instead of creating controller, decorate tasks
- *** CHANGE queue to hold selection index until job is done so we dont have to copy data from buffer
- *** have put copy directly to output buffer (this may mean locking down output buffer before task starts)
- *** try to figure out optimal worker numbers under constraints
- *** instead of having several buffers for several I/O, have one buffer and 
keep track of the offset and number of bytes
- *** add way to enable/disable metadata
pwnc 0.0.1
A package for automating libc exploitation
Requires Python: >=3.6

# pwnc
A python library for finding libc offsets based on leaked addresses. 
It utilizes the [libc-database](https://github.com/niklasb/libc-database) API.

## Installation

    pip3 install pwnc

## Usage

### get\_libc

Retrieve a libc in the form of a bytestring. Provide known symbol names mapped
to their addresses in memory. Not all symbol names are stored in the database.
Checkout [libc-database](https://github.com/niklasb/libc-database) for 
information on which symbols are stored.

    >>> import pwnc
    >>> known_addresses = {"strncpy": "0x7fffffff0db0",
                           "strcat": "0x7fffffffd800"}
    >>> libc_bytestring = pwnc.get_libc(known_addresses)
    >>> libc_bytestring[:4]
    b'\x7fELF'
    >>> 

### query

This method returns all known symbol offsets for a libc. Provide a dictionary
of symbol names mapped to their in memory offsets

    >>> import pwnc
    >>> known_addresses = {"strncpy": "0x7fffffff0db0",
                           "strcat": "0x7fffffffd800"}
    >>> symbols = pwnc.query(known_addresses)
    >>> for sym in symbols.items():
    ...     print(f"{sym[0]} = {hex(sym[1])}")
    ...
    __libc_start_main_ret = 0x21b97
    dup2 = 0x110ab0
    printf = 0x64f00
    puts = 0x80a30
    read = 0x110180
    str_bin_sh = 0x1b40fa
    system = 0x4f4e0
    write = 0x110250
nvdsw 0.0.395
Nvidia Data Science Workbench
Requires Python: >=3.6.9

# Data Science Workbench

## Build process
Clone the repo, build the docker image for the build environment, e.g. `cd nvdss && sh build-docker.sh`. Now you can launch your build docker container, e.g. `sh run-docker.sh`

To run the build:
```
sh build.sh none
# if you want to push to the pip test or prod
# sh build.sh test
# sh build.sh prod
```
The build creates a .whl file, e.g. `dist/nvdsw-0.0.382-py3-none-any.whl`

Now, you can reinstall nvdsw, e.g. do this *outside of docker*

```
pip3 install --force-reinstall dist/nvdsw-0.0.382-py3-none-any.whl
```
Now you can launch nvdsw:
```
nvdsw
```