semvec/pypi-packages huggingface dataset:
easyzip 1.0.2
Easy zip file or directory with password


EASY ZIP
====

## What is it?

EASY ZIP is a simple tool to create zip archives. Whatever you zip from file or folder, it will be zipped in a single archive.
You can also create a password protected zip archive.

## How to use it?

### Create a zip archive

```

import easyzip

easyzip.zip('path/to/file/or/folder')

```

#### easyzip.zip(pathWillBeZipped, pathToZipArchive, compressLevel, password)
Like 

```
easyzip.zip('path/to/file/or/folder', 'path/to/zip/archive.zip', compressLevel = 4, password = 'hahahahaha')
```

##### pathWillBeZipped
The path of file or folder will be zipped.

##### pathToZipArchive
The path of zip archive. If the path does not exist, it will be created. The name of zip archive default use pathWillBeZipped base path name.

##### compressLevel
The compress level of zip archive. The default value is 4.

##### password
The password of zip archive. If the password is not None, the zip archive will be password protected.

### Unzip a zip archive

```

import easyzip

easyzip.unzip('path/to/zip/archive.zip')

```

#### easyzip.unzip(pathToZipArchive, pathToUnzipFolder, password)
Like

```
easyzip.unzip('path/to/zip/archive.zip', 'path/to/unzip/folder', password = 'hahahahaha')
```

##### pathToZipArchive
The path of zip archive.

##### pathToUnzipFolder
The path of folder will be unzipped. If the path does not exist, it will be created. Default use pathToZipArchive base path name.

##### password
The password of zip archive.
npysearch 1.3.1
Python bindings for nsearch, an efficient BLAST-like sequence comparison algorithm written in C++
Requires Python: >=3.6
Keywords: BLAST nsearch bioinformatics

# npysearch

npysearch implements an efficient BLAST-like sequence comparison algorithm, written in C++11 and using native Python datatypes and bindings. npysearch is light-weight, fast, and dependency-free. The code base of npysearch is adapted from [nsearch](https://github.com/stevschmid/nsearch).


## Installation

### from pypi

```
pip install npysearch
```

### from conda-forge

Installing from the `conda-forge` channel can be achieved by adding `conda-forge` to your channes with:
```
conda config --add channels conda-forge
conda config --set channel_priority strict
```
You can skip the above step if `conda-forge` channel has been added already.

Once the conda-forge channel has been enabled, `npysearch` can be installed with:

```
conda install npysearch
```

### from github

```
# Clone repository from github
git clone https://github.com/tamminenlab/npysearch.git

# Install package using pip
pip install ./npysearch
```


## Examples

```Python
# Import npysearch package
import npysearch as npy

# Read query file into a dictionary
query = npy.read_fasta("npysearch/data/query.fasta")

# Read database file into a dictionary
database = npy.read_fasta("npysearch/data/db.fasta")

# BLAST the query against the database
results_dna = npy.blast(query, database)

# BLAST protein sequence file against itself using filenames as blast function arguments

results_prot = npy.blast(query = "npysearch/data/prot.fasta",
                   		 database = "npysearch/data/prot.fasta",
                     	 alphabet = "protein")
```

## Caveats

* The `blast` function automatically detects whether the query and database arguments were passed as string paths to fasta files or as dictionaries of sequences. Both of them need not be input as the same type.
* Use `help(npy)` (assuming you've imported npysearch as npy) to get a list of the functions included and their docstrings. For docstrings of specific functions, for example blast, use `help(npy.blast)`
expkit-framework 0.0.1b4
A framework and build automation tool to process exploits/payloads to evade antivirus and endpoint detection response products using reusable building-blocks like encryption or obfuscation.
Requires Python: >=3.10

# Getting started

ExploitKit ([ExpKit](https://gitlab.com/0xCCF4/expkit))
is a framework and build automation tool
to process exploits/payloads to evade antivirus and
endpoint detection response products using reusable
building blocks like encryption or obfuscation stages.

For the full documentation visit the [docs](https://0xccf4.gitlab.io/expkit/).

## Installation

ExpKit can be installed locally using `pip` and `python3.10`,
ideally by using a virtual environment:

```
pip install -e .
```

or by using PyPI:

```
pip install expkit-framework
```

This will install ExpKit and all its runtime dependencies.

## Creating a new project

Create a new folder containing a `config.json` file and
your exploit/payload code. The `config.json` contains
the configuration for the project. The following example
shows an example configuration for a C# project assuming
the C# project is located in a sub folder named `payload_code`:

```json
{
  "config": {
    "BUILD_TYPE": "Release"
  },
  
  "artifacts": {
    "base": {
      "stages": [
        {
          "name": "LOAD_FOLDER",
          "config": {
            "LOAD_FOLDER_PATH": "./payload_code",
            "LOAD_TARGET_FORMAT": "CSHARP_PROJECT"
          }
        },
        { "name": "OBFUSCATE_CSHARP" },
        { "name": "COMPILE_CSHARP" },
        {
          "name": "EXPORT",
          "config": {
            "EXPORT_NAME": "build.exe"
          }
        }
      ]
    }
  }
}
```

The syntax of the configuration file is described within the
[API Reference](../api/configuration) section.

## Building the project

To build the project, run the following command:

```bash
expkit build WINDOWS AMD64
```

This will build the project and create an executable file,
according to the configuration, within the current working directory,
named `build.exe`.
Building the project from a different operating system/architecture
requires the setup up of a [build worker](../user-guide/build-worker) environment.

## Serving and building the project on the fly

To serve the project and build a payload on the fly whenever a
web-request is received, run the following command:

```bash
expkit server 80 0.0.0.0 secret-token
```

This will start a web server on port 80 and listen on all interfaces.
The server will build a payload for the operating system and architecture
specified in the web request. The web request must contain the
`secret-token` as a query parameter. The following example shows
a web request to build a payload for Windows 64-bit:

```bash
curl http://localhost:80/build?token=secret-token&os=WINDOWS&arch=AMD64&target=base
```

The `target` parameter specifies the target artifact to build.
When requiring an HTTPS connection, it is advised to run a nginx
proxy in front of the ExpKit server.
pycronjob 1.2.2
An easy to start crontab
Requires Python: >=3.5

# pycronjob
> An easy start crontab tools  
> Supports 5~7 cron symbols  
> 0/1 * * * *  or  0 */2 * * * ?  or 0 */3 * * * ? *  



### How to Use

#### install
```
pip install pycronjob
```

#### base
```python
from pycronjob import Crontab

def p(*args):
    print(args, datetime.datetime.now())
    print('====\n')

joblist = [
    {'crontab': '0/1 * * * *', 'func': p, 'args': ('job1',)},
    {'crontab': '0 */2 * * * ?', 'func': p, 'args': ('job2',)},
    {'crontab': '0 */3 * * * ? *', 'func': p, 'args': ('job3',)},
]
```

#### sync
```python
crontab = Crontab(joblist)
crontab.start()
```

#### async
```python
crontab = Crontab(joblist, True)
crontab.start()
# do other thing
```

#### sync to async
```python
import threading
def inner():
    crontab = Crontab(job_list)
    while True:
        try:
            crontab.start()
        except:
            logger.info(traceback.format_exc())
timer = threading.Timer(1, inner)
timer.daemon = True
timer.start()
```
causar 0.2.0
A high level testing framework for Disnake bots
Requires Python: >=3.10,<4.0

Causar
---

### A high level testing framework for Disnake bots

Written for my needs, open source for yours.

---

Currently still in extremely early development so don't expect a lot.

---

### Support

Want realtime help? Join the discord [here](https://discord.gg/BqPNSH2jPg).

---

### Funding

This project is built entirely around my current personal & freelance needs, 
therefore it only covers the areas of Disnake I wish to test. If you want
this package to support further areas of Disnake consider 
sponsoring me [here](https://github.com/sponsors/Skelmis)