semvec/pypi-packages huggingface dataset:
kalki 0.1.8
Kalki is a library to create dynamic CSS

# Kalki

A small library to create dynamic CSS

follow link for Usage: https://github.com/biswajitbimoli/kalki


MIT License

Copyright (c) 2023 biswajitbimoli

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
nnvisualizertf 0.7
Visualizing Tensorflow networks.

# nn_visualizer
Visualizing Tensorflow neural networks.

Please see the *examples.ipynb* notebook for an example on how to use the package.

![example_output1.png](https://raw.githubusercontent.com/akdd11/nn_visualizer/main/doc/figures/example_output1.png)

Currently supporting:
* Input layers:
  * For dense networks with the shape (x_size)
  * For convolution with the shape (x_size, y_size, n_channels)
* Convolutional Network Layers:
  * Conv2D
  * MaxPooling2D
  * AveragePooling2D
* Dense Layers:
  * Dense (also as output)
  * Flatten

## Changes

### 0.7
* Fixed cases, in which the layers descriptions have overlapped.

### 0.6
* Supporting dense layers as input.

### 0.5
* Changed build tool to flit, now available as package from PyPi under the name **nnvisualizertf**.

### 0.4
* Changed build configuration.

### 0.3
* Changed build tool to hachtling.

### 0.2
* Renaming to comply with the python naming conventions.

### 0.1
* Initial version.
CryptographyMethods 0.1.1
An implementation of cryptography used for keeping secrets within Lab-93.
Requires Python: >=3.11

# Lab-93 Cryptography Methods

## Module Imports


```python
#!/bin/python3
from base64 import urlsafe_b64encode
import hashlib as hashlib
from cryptography.fernet import Fernet
```

## CryptographyMethodsAPI


```python
class CryptographyMethodsAPI():
  """
  The CryptographyMethodsAPI class enscapulates methods used for keeping
  secrets in both one-way and two-way forms.

  SHA-256 is delivered in a much simpler syntax than the default method
  utilized by hashlib; the CryptographyMethods.SHA256 object merely
  requires a secret to be hashed and delivers the hexdigest of the
  resulting byte object.

  For two-way secret keeping CryptographyMethods.Encryption and
  CryptographyMethods.Decryption are offered; both of which utilize the
  CryptographyMethods.BuildKey function for locking and unlocking secrets,
  respectively.
  """
```

### Constants Setup


```python
  def __init__(self):
    self = self
```

### SHA-256


```python
  def SHA256(self, secret: str):
    """
    Create a SHA-256 hash of whatever value is given as 'secret' and
    return the the hexdigest of the bytes-encoded secret.
    """
    return hashlib.sha256(secret.encode())\
                  .hexdigest()
```

### BuildKey


```python
  def BuildKey(self, key: str):
    """
    Create a two-way encryption token using the first 32
    digits of the hash of a given string named 'key'.

    The results are then encoded in urlsafe-base64 bytes
    and returned to the caller.
    """
    basecode = self.SHA256(str(key))[:32]
    return urlsafe_b64encode(basecode.encode())
```

### Encryption


```python
  def Encryption(self, phrase: bytes, target: str):
    """
    Encrypt a 'target' string using a byte 'phrase' provided by
    CryptographyMethods.BuildKey as an encryption token.
    """
    intelligence = Fernet(phrase)
    return intelligence.encrypt(bytes(target, 'utf-8'))
```

### Decryption


```python
  def Decryption(self, phrase: bytes, target: str):
    """
    Decrypt a 'target' string using a byte 'phrase' provided by
    CryptographyMethods.BuildKey as an encryption token.
    """
    intelligence = Fernet(phrase)
    return intelligence.decrypt(target)
```