semvec/pypi-packages huggingface dataset:
ksd 0.1.3
Utility for decoding Kubernetes secret resources
Requires Python: >=3.7
Keywords: kubernetes,kubectl,secrets

# Easily Read Kubernetes Secrets

Read base64 encoded Kubernetes secrets without getting in your way.

Kubernetes secrets resources base64 encode the secret values. It is often
useful to view the decoded values for those secrets in place. This tool
offers a useful means to do that. 

## Features

- allows you to read one or more Secrets
- works with individual secrets, lists of secrets, and multiple yaml docs
- simple auditable Python source code

### Install

Install with pip

```bash
pip install ksd
```

Install with pipx

```bash
pipx install ksd
```

## Quick Example

```bash
$ kubectl get secret -n mynamespace -o yaml mysecret | ksd
```
```yaml
apiVersion: v1
data:
  password: my-decoded-password-secret
  username: my-decoded-username-secret
kind: Secret
metadata:
  creationTimestamp: '2024-01-01T00:00:0Z'
  labels:
    name: mynamespace
  name: mysecret
  namespace: mynamespace
  resourceVersion: '1234'
  uid: c4f4c4db-bdba-47d0-9a17-1e307e1448c7
type: Opaque
```

## Detailed Usage

Get help

```bash
ksd --help
```

Get single secret as YAML and decode as YAML

```bash
kubectl get secret -o yaml mysecret | ksd 
```

Get single secret as YAML and decode as JSON

```bash
kubectl get secret -o yaml mysecret | ksd -f json
```

Get multiple secrets as YAML and decode as YAML

```bash
kubectl get secret -o yaml  | ksd
```

Get multiple secrets as YAML and decode as JSON

```bash
kubectl get secret -o yaml  | ksd -f json
```

Get secrets as JSON and decode as YAML

```bash
kubectl  get secret -o json | ksd
```

Get secrets as JSON and decode as JSON

```bash
kubectl  get secret -o json | ksd -f json
```


Use k8s flags as normal

```bash
kubectl  get secret -n my_namespace -l label_key=label_value -o json | ksd
```

I don't know why you would do this, but the output is idempotent

```bash
kubectl get secret -o yaml  | ksd | ksd
```

Read Secrets from a file 

```bash
cat secrets.yaml | ksd
```

Suppoert multi-document yaml input (separated with the yaml '---')

```bash
kubectl get secret -o yaml mysecret > secrets.yaml
echo "---" >> secrets.yaml
kubectl get secret -o yaml ohter_secret >> secrets.yaml
cat secrets.yaml | ksd
```


## Inspired by

There are several projects with a similar name and purpose. However, they
are written in Go and distribute compiled binaries. I prefer to use a version
of this tool written in Python, for which the source code is auditable. 


## Tests

```bash
pip install -e .[tests]
pytest -vvv tests/
```
skycli.py 0.0.1
A CLI package which attempts to mimic the style of discord.py
Requires Python: >=3.8

# cli.py
A simple package that allows "CLI"-style interfaces for users.
Styled like [discord.py](https://github.com/Rapptz/discord.py), code-wise.

It is in a pretty alpha state right now, it is functional, but very rough around the edges.
weather-station 0.1.0
Obtain local weather information based on zipcode.
Requires Python: >=3.10,<4.0

# Python Weather: Weather Forecast

## Overview

Get the current weather forecast from a zipcode.  This module uses the U.S. Census 2022 Gazetteer (Zip Code Tabulation Areas).  The original file has been modified to JSON.

## Installation

```bash
TODO
```

## Usage

```python
import json
from weather_station.weather_station import Weather

weather = Weather("32904")

# Internal weather methods.
print(weather._load_json_data())
print(weather._get_latitude_longitude())
print(weather._get_weather_forecast_url())
print(json.dumps(weather._get_weather_data(), indent=2))

# Get the short forecast.
short_forecast = weather.get_short_forecast()
print(short_forecast)

# Get the detailed forecast.
detailed_forecast = weather.get_detailed_forecast()
print(detailed_forecast)

# Get the temperature in fahrenheit.
temperature_in_fahrenheit = weather.get_temperature_in_fahrenheit(temperature_unit=True)
print(temperature_in_fahrenheit)

# Get the temperature in celsius.
temperature_in_celsius = weather.get_temperature_in_celsius()
print(temperature_in_celsius)

# Get the chance of rain.
chance_of_rain = weather.get_probability_of_precipitation()
print(chance_of_rain)

# Get the wind.
wind = weather.get_wind()
print(wind)
```

## References

- ### Gazetteer Files

  - <https://www.census.gov/geographies/reference-files/time-series/geo/gazetteer-files.html>

- ### API Documentation

  - <https://www.weather.gov/documentation/services-web-api>

- ### API Discussion

  - <https://github.com/weather-gov/api/discussions>

- ### Outage & Status Messages

  - <https://www.nco.ncep.noaa.gov/status/messages/>

## TODO

- Get severe weather alerts.
- Active Alerts
  - <https://api.weather.gov/alerts/active?point=38.9807,-76.9373>
- All Alerts
  - <https://api.weather.gov/alerts?point=38.9807,-76.9373>
kiezbox-messages 0.2
Kiezbox Messages App to send emergency calls
Requires Python: >=3.11

# Kiezbox Notruf-App

Tested with Python 3.11

## Architecture

One main driver was the will to have something minimalistic while still modern.
A first try to have a separate frontend using react and dynamic routes has proven to be problematic
as installing node modules and having a running node instance on IoT devices isn't great.
Thus we have server-side template rendering for the frontend.
In these templates we use HTMX to handle the interactivity.

The backend is fastapi, using sqlmodel to unite sqlalchemy and pydantic. FastAPI is serving some static files as well as the Jinja2 templates using uvicorn. 
We use a HTML form to send the emergency calls.
We use server-sent events (SSE) to trigger reloads on the inbox.

## Backend Installation guide

### Set your virtual environment

The following steps are not required but recommended. This will allow you to install packages in your isolated virtual environment instead of globally, reducing the risk of breaking system tools or other projects.

1. Install [pyenv](https://github.com/pyenv/pyenv) and the [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv) plugin.
2. Download the appropriate Python version with `pyenv install 3.11` in the command line.
3. Create a virtual environment with the appropriate Python version and name for your environment, for example `pyenv virtualenv 3.11 kiezbox`
4. Activate the environment with `pyenv activate kiezbox`

### Run the App

1. Install the required libraries with the command line `pip install -r requirements.txt`
2. Run the server with the command line `uvicorn main:app --reload`
3. Your terminal should show something like: 

```
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

Open this URL with the `/docs` suffix in your server to access the Swagger documentation of the API. For this example: `http://127.0.0.1:8000/docs

### Update the model

If you want to run an updated version of the API which introduces changes in the database models (for example, a new field), you will have to wipe the database clean first. To do this, simply delete the `backend.db` file.

## Frontend

On the JS side, the interactivity is handled by HTMX, which is shipped locally as we are in a case where phones have no internet connectivity. Currently v1.9.10 is included. See https://github.com/bigskysoftware/htmx/releases.

We have a second JS file which is the SSE extension for HTMX. You can get the latest version from https://github.com/bigskysoftware/htmx/tree/master/dist/ext.

The frontend is simple Jinja2 server-rendered templates styled with TailwindCSS.

Run `npm install`.

To watch CSS updates, you may run `npm run dev`
word-unscrambler 0.1.2
A python module that unscrambles characters into words
Requires Python: >=3.5

# Word Unscrambler

[![Downloads](https://static.pepy.tech/badge/word-unscrambler/week)](https://pepy.tech/project/word-unscrambler)

This Python module, `word_unscrambler`, is a versatile and user-friendly tool designed to find all word combinations from a set of letters. This module provides a reliable way to find these combinations, handling various scenarios, including input validation and error handling.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Documentation](#documentation)
- [Features](#features)
- [Contributing](#contributing)
- [License](#license)

## Installation

To use the `word_unscrambler` module, you can simply install it using pip from the command line. Make sure to install `word_unscrambler` to the right python version (3.x), otherwise it will not work. There is no need to install other modules, as the required modules will be install when you install it using pip.

```python
pip install word_unscrambler
```

## Usage

You can use the `unscramble` function provided by the `word_unscramble` module to discover which words can be made from any combination of characters. Here's a basic example:

```python
import word_unscrambler as w

result = w.unscramble('enam')
print(result)  # Output: ['name', 'amen', 'mean', 'mane']
```

## Documentation

The `word_unscrambler` module includes detailed documentation in the form of docstrings. These docstrings provide information about the module's purpose, function arguments, return values, and usage examples. You can access this documentation using Python's built-in `help()` function or by viewing the docstrings directly in your code editor.

```python
import word_unscrambler as w

help(w.unscramble)
```

## Features

- **Input Validation**: The module ensures that input is all in the same case.

- **Error Handling**: If an invalid input is provided, the function will not break and will still return None.

- **Interactive Mode**: When run as a script, the module enters an interactive mode, allowing users to unscramble any word of their choice.

- **Documentation**: The module includes docstrings that provide information about its purpose, usage, and examples, making it easy for users to understand and use.

## Contributing

Contributions to this project are welcome! If you'd like to improve the module, fix a bug, or add a new feature, please follow these steps:

1. Fork the repository.
2. Create a new branch for your feature or bug fix.
3. Make your changes and test them thoroughly.
4. Commit your changes and push them to your fork.
5. Open a pull request against the original repository.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
retico-core-slim 0.1.1
A framework for real time incremental dialogue processing.
Requires Python: >=3.6, <4
Keywords: retico,framework,incremental,dialogue,dialog

# retico-core-slim
  

This project includes the core functionality of the retico slim module

## How to install
This will also install the retico-core-core modules that are required for all of retico to function


via pip:

  

```bash

$ pip  install  retico-core-slim

```

## Import
```
import slim_common
import wac
import words_as_classifiers
```

## Retico
Documentation for the main retico project can be found here
[![Documentation Status](https://readthedocs.org/projects/retico-core/badge/?version=latest)](https://retico-core.readthedocs.io/en/latest/?badge=latest)
retico-core-sds-class 0.1.1
A framework for real time incremental dialogue processing.
Requires Python: >=3.6, <4
Keywords: retico,framework,incremental,dialogue,dialog

# retico-core-sds-class
  

This project includes the core functionality of the retico sds-class module

## How to install
This will also install the retico-core-core modules that are required for all of retico to function


via pip:

  

```bash

$ pip  install  retico-core-sds-class

```

## Import
```
import sds_class_iu
import TaggerModule
```

## Retico
Documentation for the main retico project can be found here
[![Documentation Status](https://readthedocs.org/projects/retico-core/badge/?version=latest)](https://retico-core.readthedocs.io/en/latest/?badge=latest)
retico-core-rasa-nlu 0.1.1
A framework for real time incremental dialogue processing.
Requires Python: >=3.6, <4
Keywords: retico,framework,incremental,dialogue,dialog

# retico-core-rasa
  

This project includes the core functionality of the retico rasa module

## How to install
This will also install the retico-core-core modules that are required for all of retico to function


via pip:

  

```bash

$ pip  install  retico-core-rasa

```

## Usage
For this module you must have a rasa pretrained model saved in the system then pass it to the NLU

```
from retico_core.modules.rasa.retico_nlu import RasaNLUModule
nlu = RasaNLUModule(model_dir=<PATH TO MODEL DIRECTORY>, incremental=False)
```

## Import
```
import retico_nlu
```

## Retico
Documentation for the main retico project can be found here
[![Documentation Status](https://readthedocs.org/projects/retico-core/badge/?version=latest)](https://retico-core.readthedocs.io/en/latest/?badge=latest)
retico-core-psi 0.1.1
A framework for real time incremental dialogue processing.
Requires Python: >=3.6, <4
Keywords: retico,framework,incremental,dialogue,dialog

# retico-core-psi
  

This project includes the core functionality of the retico psi module

## How to install
This will also install the retico-core-core modules that are required for all of retico to function


via pip:

  

```bash

$ pip  install  retico-core-psi

```

## Import
```
import configFileReader
import psi_common
import psiAsrReceiver
```

## Retico
Documentation for the main retico project can be found here
[![Documentation Status](https://readthedocs.org/projects/retico-core/badge/?version=latest)](https://retico-core.readthedocs.io/en/latest/?badge=latest)
retico-core-asr 0.1.6
A framework for real time incremental dialogue processing.
Requires Python: >=3.6, <4
Keywords: retico,framework,incremental,dialogue,dialog

# retico-core-asr
  

This project includes the core functionality of the retico asr module

## How to install
This will also install the retico-core-core modules that are required for all of retico to function


via pip:

  

```bash

$ pip  install  retico-core-asr

```

## Import
```
import asr
import asr_cat
import asr_deepspeech
```

## Retico
Documentation for the main retico project can be found here
[![Documentation Status](https://readthedocs.org/projects/retico-core/badge/?version=latest)](https://retico-core.readthedocs.io/en/latest/?badge=latest)

## Sample Program
```
from retico_core.core.audio import MicrophoneModule
from retico_core.core.debug import DebugModule
from asr import OfflineASRModule


debug = DebugModule()

microphone = MicrophoneModule(rate=16000)
localAsr = OfflineASRModule()

'''
subscribe to modules in a cascading pattern
Microphone is needed by localAsr so subscribe to localAsr
debug will relay the information form localAsr so subscribe localAsr to debug
'''

microphone.subscribe(localAsr)
localAsr.subscribe(debug)


# run modules
microphone.run()
localAsr.run()
debug.run()


input()

# stop modules
microphone.stop()
localAsr.stop()
debug.stop()
```
url-short 0.1.1
A python module that shorterns urls using TinyURL API, no API token required.
Requires Python: >=3.5

# URL Shortener Module

This Python module, `url_short`, is a convenient tool designed to shorten URLs using the TinyURL API. This module aims to provide a simple and efficient way to generate shortened URLs for any given long URL.

## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [Documentation](#documentation)
- [Features](#features)
- [Contributing](#contributing)
- [License](#license)

## Installation

To use the `url_short` module, you can install it via pip from the command line. Ensure that you have the correct Python version (3.x) before installation. The necessary dependencies will be automatically installed when you use pip.

```bash
pip install url_short
```

## Usage
You can utilize the `shorten_url` function provided by the `url_short` module to shorten any given URL using the TinyURL API. Here's a basic example:

```python
import url_short as u

shortened_url = u.shorten_url('https://www.example.com/very-long-url')
print(shortened_url)
# Output: 'https://tinyurl.com/abc123'
```

## Documentation
The `url_short` module includes detailed documentation in the form of docstrings. These docstrings offer insights into the module's purpose, function arguments, return values, and usage examples. You can access this documentation using Python's `help()` function or by viewing the docstrings directly in your code editor.

```python
import url_short as u
help(u.shorten_url)
```

## Features
- **URL Shortening**: The module efficiently shortens long URLs using the TinyURL API.
- **Error Handling**: Robust error handling ensures smooth operation even in case of invalid URLs.
- **Customization**: Users can customize the shortened URLs for specific needs.
- **Documentation**: Detailed docstrings provide comprehensive information for easy understanding and usage.

## Contributing
Contributions to this project are encouraged! If you wish to enhance the module, fix any issues, or introduce new features, please follow these steps:
1. Fork the repository.
2. Create a new branch for your changes.
3. Implement and thoroughly test your modifications.
4. Commit your changes and push them to your fork.
5. Open a pull request against the original repository.

## License
This project is licensed under the MIT License. For more details, refer to the [LICENSE](LICENSE) file.
bmusic 0.1.2
Utilities for procedural music animation in Blender.

# BMusic

Music animations combine music, 3D art, and computer generated animation.

BMusic is a Python library providing tools for procedural (program generated)
music animation.

[See an example here.](https://www.youtube.com/watch?v=ZE92NEA41nw)

![](https://github.com/phuang1024/bmusic/blob/master/examples/Debussy_ClairDeLune/example.jpg?raw=true)