semvec/pypi-packages huggingface dataset:
SSHColab 0.1.5
Google Colab Secure Shell connector that automates Ngrok tunnels creation for SSH, TPU and TensorBoard
Requires Python: >=3.6
Keywords: TPU,Colab,SSH,TensorBoard

# SSH-Colab
SSH-Colab is a Python module to facilitate remote access to Google Colaboratory
(Colab) through Secure Shell (SSH) connections, secured by a third-party
software, ngrok. SSH-Colab automates the tedious routine to set up ngrok
tunnels needed for TPU runtime applications, services like TensorBoard, etc.

[![license](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)
![python version](https://img.shields.io/badge/python-3.6%2C3.7%2C3.8-blue?logo=python)

# Prerequisites
- [ngrok](https://ngrok.com/) tunnel authtoken.
- Google account to access a [Colab](https://colab.research.google.com/notebooks/intro.ipynb) notebook.
- Local code editors such as VS Code or PyCharm to make the most of coding on Colab.
# Usage
1. Launch a Colab notebook. Choose a runtime type you prefer.
2. Install SSH-Colab. Type and run the following command in a notebook cell:
   ```shell
   !pip install SSH-Colab
   ```
3. Initiate the establishment of tunnels:
   ```python
   import SSHColab
   SSHColab.connect()
   ```
   The default TensorBoard log directory is `/log/fit`. You can reset it by
   passing into `connect()` the new value `LOG_DIR=/new/path/to/log`.
4. Retrieve information that is used for establishing the SSH connection:
   ```python
   SSHColab.info()
   ```
   If you are using non-TPU runtimes, the setup instruction of TPU resolver is
   ignored.
5. To disable ngrok tunnels created, run the command below:
   ```python
   SSHColab.kill()
   ```

# Quickstart
A quickstart Colab notebook template is provided in the link below. Users can
find a simple end-to-end application starting from SSH-Colab installation, SSH
tunnel creation, to the use of TensorBoard after training a 3-layer MNIST
convolutional neural network. 

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1TKM6Zqk4oY8RrFqGzrM-QEt92iQ0zxwm?usp=sharing) 

What's missed in this quickstart is how to may our way to Colab instances from
local machines. The reference listed below can be a start point for interested
users:

1. [Remote development over SSH on local VS Code](https://code.visualstudio.com/docs/remote/ssh-tutorial)
2. [Run SSH terminal on local PyCharm](https://www.jetbrains.com/help/pycharm/running-ssh-terminal.html)


# Feedback
Comments and suggestions are welcome and appreciated. They can be sent to
lipin.juan02@gmail.com.
pcsg 0.0.3
A constructive solid geometry library for Python
Requires Python: >=3.8

# pcsg - a constructive solid geometry library for Python

Constructive geometry is a technique used for modeling shapes and solids.
The ***pcsg*** library can be used to create 3D printable solid objects, images and animations utilizing external programs like [OpenScad](https://www.openscad.org/) and [POV-Ray](http://www.povray.org/).
Introducing a common description format eleminates the need for learning different scripting languages and rewriting your code.

**NOTE**: The current implementation of pcsg is a prototype. It’s assumed that the API will change in future releases.

## Getting started
* Read the [documentation](http://www.dessecker.net/projects/pcsg/latest/index.html).
* Install from [PyPI](https://pypi.org/project/pcsg).
* Checkout the [sources](https://github.com/WhiteSheet/pcsg).
easy-cryptography 0.0.4
A package designed to make it easier to use Security functions
Requires Python: >=3.6

This is a simple library. You can use it to hash, encrypt and decrypt data. It allows easy use of the [pychryptodome](https://pypi.org/project/pycryptodome/) library.

You can securely encrypt any msg of any length with encrypt_data(text,public_key). It uses asymmetric and symmetric encryption:
``` python
from easycrypt.cipher.cypherfunct import encrypt_data,decrypt_data,gen_asym_keys

private_key,public_key = gen_asym_keys()
msg = "Hello World"
encrypted_msg = encrypt_data(msg,public_key) # output in bytes
#Now it is encrypted
decrypted_msg = decrypt_data(encrypted_msg, private_key) # output in bytes
print(decrypted_msg) # prints "Hello World"
```
And of course decrypt it.

If you want to store passwords securely, you can use the gen_hash(text) function to create and the compare_hash(text,hash) to compare them
``` python
from easycrypt.hash.hash_funct import gen_hash, compare_hash
pw = "Hello Hash"
hash = gen_hash(pw) #output in hex
to_compare = "Hello Hash"
print(compare_hash(pw,hash)) # prints "True"; The output is a boolean
```

You can use old ciphers too, like Vigener or Caesar. More are being added.  
For cryptographically secure encryption/decryption use `easy_crypt.cipher.cypher_funct`


I recommend to not use pyprind with this module for now. I will improve the use over time

For more informations, [read the docs](https://easy-crypt.readthedocs.io/en/latest/)