semvec/pypi-packages huggingface dataset:
pykanban 0.1.0
Initializing flask project 

# CS162 Kanban Board

The website is deployed on heroku and can be accessed on the following url: https://kanban-app-cs162.herokuapp.com/

## Project Structure

`/web` contains application code.

`/web/static` css files.

`/web/templates` html files.

`/web/__init__.py` project initializer file.

`/web/auth.py` routes related to authorization/authentication.

`/web/config.py` different configurations based on running environment (test/dev/prod).

`/web/models.py` ORM mapping (from DB models to python classes) using SQLAlchemy.

`/web/routes.py` application routes.

`/unit_test` contains 25 unit tests in total. Tests for: registration, login, reset password, and kanban operations (todo, doing, done).

`/migrations` directory used to control DB migrations, using Flask-migrate.

`.env/example` contains all variables needed on your .env so the project runs on production or locally.

`Procfile` used for heroku deployment.

## Virtual Environment
Creation of virtualenv:

    $ virtualenv -p python3 venv

If the above code does not work, you could also do

    $ python3 -m venv venv

To activate the virtualenv:

    $ source venv/bin/activate

Or, if you are **using Windows** - [reference source:](https://stackoverflow.com/questions/8921188/issue-with-virtualenv-cannot-activate)

    $ venv\Scripts\activate

To deactivate the virtualenv (after you finished working):

    $ deactivate

Install dependencies in virtual environment:

    $ pip3 install -r requirements.txt

## Environment Variables

`.env.example` is a file containing all the environment variables that you need to define in a `.env` file for this project to run.

## Run Application

Start the server on a mac locally by running:

    $ source venv/bin/activate
    $ pip install -r requirements.txt
    $ export FLASK_ENV=dev
    $ export FLASK_APP=web
    $ python3 -m flask run

## Unit Tests
To run the unit tests on mac use the following commands:

    $ source venv/bin/activate
    $ pip install -r requirements.txt
    $ export FLASK_ENV=test
    $ export SECRET_KEY='test-key'
    $ python -m pytest unit_test
CodeDrive 1.8
This package contains codes/functions that are useful in school level python programming
Requires Python: >=3.0
Keywords: python,school level programs,beginners

# CodeDrive

This is a **Python Library** contains some basic programs given in schools for assessments.

It has only one **Class**: **Functions**


```

Example of how to use this module:

from CodeDrive import Functions as fn
#or the alternative way
import CodeDrive.Functions as cf

#Now you want to run a palindrome test, so you need to do:

user = int(input("Enter number: "))

test = fn.palindromeNum(user) #This function will return True if the number passes the test, else False

if test == True:
    print(f"{user} is a palindrome number")
else:
    print(f"{user} is not a palindrome number")


```

To **upgrade** to the latest version, use:

```
pip install --upgrade CodeDrive
```

or 

```
python -m pip install --upgrade CodeDrive
```
spirofs 0.3
Salt Fileserver handling dynamic saltenvs and discrete deployments from CI/CD.
Keywords: salt saltstack spirostack spirofs salt-extension

SpiroFS
=======

SpiroFS is a fileserver backend for Salt focusing on deployment and saltenv
management. It allows automated systems to push deployment bundles to Salt
without giving them undue permissions. It is dynamic and does not require
on-going reconfiguration as your technology stack grows and changes.

Full documentation is https://saltstack.com/spirofs

Installation
------------
0. Have pip for the Python that salt is installed into
1. `pip install spirofs` (Adapt as necessary)
2. Configure the salt master (see [docs](https://spirostack.com/spirofs/#configuration))
3. Restart the salt master

Note: libsodium is used, but is pre-packaged in the binary wheels. If these are
not used on your system for whatever reason, install either `libsodium-dev` (apt)
or `libsodium-devel` (yum).
spiro-network 0.2
Salt modules for discovering and exposing minion's IP addresses
Keywords: salt saltstack spirostack salt-extension

spiro-network
=============

A variety of network utilities.

This is meant to be installed on minions.

Full docs available [online](https://spirostack.com/spiro-net.html).

Installation
============

On minions, install the `spiro-network` PyPI package.


Interface
=========

A number of things are provided:

Modules
-------

* `ipaddr.external_four`, `ipaddr.external_six`: Queries external services for
  your IP, useful if the minion is behind a NAT or other complex network

* `ipaddr.four`, `ipaddr.six`: Collates information about a minion's IP address
  from several sources. 

    * `network.ipaddrs` / `network.ipaddrs6`
    * AWS metadata if the [metadata grain](https://docs.saltstack.com/en/latest/ref/grains/all/salt.grains.metadata.html) is available
    * `ipaddr.external_four` / `ipaddr.external_six` (above)

States
------

* `hostname.is`: Sets the hostname, takes no arguments. (Note: See hostname(1)
  for information on FQDNs and other hostname variants.)


Configuration
=============

spiro-network requires no configuration to function.
spiro-deploy 0.4
Deployment script for SpiroFS
Keywords: salt saltstack spiro deploy salt-extension

spiro-deploy
============

A deployment tool for [SpiroFS](https://spirostack.com/spirofs/).

[Full documentation](https://spirostack.com/spirofs/deploy/)

Installation
============

* `pip install spiro-deploy`
* [A container](https://gitlab.com/spirostack/spiro-deploy/container_registry)

Usage Summary
=============
`spiro-deploy <project> <deployment>`, with the environment variables `SPIRO_URL`
and `SPIRO_TOKEN`.
salt-cumin 0.7
A CLI front-end to a running salt-api system
Keywords: salt saltstack salt-extension

======
Cumin
======

Cumin contains a Python library and CLI scripts for accessing a remote
`salt-api`__ instance.

``cumin`` abstracts the HTTP calls to ``salt-api`` so existing Python
projects can easily integrate with a remote Salt installation just by
instantiating a class.

The ``cumin`` CLI script allows users to execute Salt commands from computers
that are external to computers running the ``salt-master`` or ``salt-minion``
daemons as though they were running Salt locally. The long-term goal is to add
additional CLI scripts maintain the same interface as Salt's own CLI scripts
(``salt``, ``salt-run``, ``salt-key``, etc).

.. __: https://github.com/saltstack/salt-api

Installation
------------
.. code-block:: bash

    pip install salt-cumin

Usage
-----


.. code-block:: bash

    export SALTAPI_USER=saltdev SALTAPI_PASS=saltdev SALTAPI_EAUTH=pam
    cumin '*' test.ping
    cumin '*' test.kwarg hello=dolly

Examples leveraging the runner client.

.. code-block:: bash

    cumin-run reactor.list
    cumin-run reactor.add event='test/provision/*' reactors='/srv/salt/state/reactor/test-provision.sls'

Configuration
-------------

You can configure cumin through the command line, using environment variables
or in a configuration file ``$HOME/.pepperrc`` with the following syntax :

.. code-block::

  [main]
  SALTAPI_URL=https://localhost:8000/
  SALTAPI_USER=saltdev
  SALTAPI_PASS=saltdev
  SALTAPI_EAUTH=pam
xrzz 0.1.5
HTTP Request from scratch 101

*XRZZ* HTTP Request

# Description

     Just a simple module for HTTP Request 

     supports : {

     	 1: GET,
     	 2: POST 
     	 
     }

# Todo

    Accept Cookies
    Persistent Connection to server
    Auto Encode url 
    proxy support
    Auto Redirect facility
	PUT; PATCH; TRACE; CONNECT
	optimization needed

# Supports

	GET, POST	

# Installation

	till now it doesn't need any external modules
	
	pip install xrzz

# Usage 

	import xrzz

	a = xrzz.http("get", 
			url="https://httpbin.org/get", 
			headers={"user-agent": "Xrzz/v1"},
			tls=True)
	print(a.body())


	# output (Bytes)

			b'{\n"args": {},\n"headers": {\n"Host": "httpbin.org",\n "User-Agent": "Xrzz/v1", \n
			"X-Amzn-Trace-Id": "Root=1-606b416e-79346cf934ed2d6f4aa2cbf7"\n  },\n  "origin": "45.103.157.9", \n 
			"url": "https://httpbin.org/get"\n}\n'

			Usually it returns in bytes 

	# output (decoded)

			{
			  "args": {},
			  "headers": {
			    "Host": "httpbin.org",
			    "User-Agent": "Xrzz/v1",
			    "X-Amzn-Trace-Id": "Root=1-606b416e-79346cf934ed2d6f4aa2cbf7"
			  },
			  "origin": "45.103.157.9",
			  "url": "https://httpbin.org/get"
			}


	print(a.head() 

	# output (dict)

			{
				'Date': 'Mon, 05 Apr 2021 17:06:13 GMT', 
				'Content-Type': 'application/json', 
				'Content-Length': '242', 
				'Connection': 'close', 
				'Server': 'gunicorn/19.9.0', 
				'Access-Control-Allow-Origin': '*', 
				'Access-Control-Allow-Credentials': 'true'
			}

# Whats new

	POST METHOD 

# Version 
	
	 v0.1.3
pyr2 2.0.0
Yet anohter radare2 python bindings.
Requires Python: >=3.6

## pyr2

Yet another radare2 python bindings.

Compared to [radare2-bindings](https://github.com/radareorg/radare2-bindings) and [radare2-r2pipe](https://github.com/radareorg/radare2-r2pipe), this binding:

- Doesn't need any extra installation of radare2. Just `pip install` and you are ready to go.
- Gives you the full control of the core radare2 API and helps build your own tools.

## Install

```bash
pip3 install --upgrade pyr2
```

**No need to install radare2** since all dynamic libraries are bundled with the Python wheels.

## Example

Implement a basic command line r2 by pyr2.

```python
import r2
import ctypes
import argparse

class R2:

    def __init__(self, bin):
        self._r2c = r2.r_core.r_core_new()
        fh = r2.r_core.r_core_file_open(self._r2c, ctypes.create_string_buffer(b"/bin/ls"), 0b101, 0)
        r2.r_core.r_core_bin_load(self._r2c, ctypes.create_string_buffer(b"/bin/ls"), (1<<64) - 1)

    def cmd(self, cmd):
        r = r2.r_core.r_core_cmd_str(self._r2c, ctypes.create_string_buffer(cmd.encode("utf-8")))
        return ctypes.string_at(r).decode('utf-8')

    def __del__(self):
        r2.r_core.r_core_free(self._r2c)

if __name__ == "__main__":
    ap = argparse.ArgumentParser("Implement a basic command line r2 by pyr2")
    ap.add_argument("binary", help="The binary to analyse.")
    args = ap.parse_args()

    r2pipe = R2(args.binary)

    while True:
        print("> ", end="")
        cmd = input()
        if cmd.strip() == "q":
            break
        print(r2pipe.cmd(cmd))
```

Note that all radare2 APIs are exported as bare ctypes function prototype. Be catious with c-style strings.

## Build Instructions

Clone the repository and submodules.

```bash
git clone https://github.com/wtdcode/pyr2
cd pyr2
git submodule update --init --recursive
```

Since radare2 chooses `meson` as their alternative building system and it's cross-platform, the first step is install `meson`.

```bash
pip3 install meson
```

Build the package. Note that on Windows, `x64 Native Tools Command Prompt` is required to build.

```bash
python3 setup.py build
```

Install and use.

```bash
# Or pip3 install -e .
pip3 install .
```

## Credits

- [radare2](https://github.com/radareorg/radare2): Awesome project.
- [ctypeslib](https://github.com/trolldbois/ctypeslib): Bindings generation.