semvec/pypi-packages huggingface dataset:
Employee 0.0.4
Managing Employee details

This is a very simple Employee data manager

```sh
class Employee:

    num_of_emps = 0
    raise_amt = 1.04

    def __init__(self, first, last, pay):
        self.first = first
        self.last = last
        self.email = first + '.' + last + '@DataSocle.ai'
        self.pay = pay

        Employee.num_of_emps += 1

    def fullname(self):
        return '{} {}'.format(self.first, self.last)

    def apply_raise(self):
        self.pay = int(self.pay * self.raise_amt)

    def details(self):
        return '{} {} {} {}'.format(self.first, self.last, self.email, self.pay)

    def __str__(self):
        return '{} {} - {} - {}'.format(self.first, self.last, self.email,  self.pay)

    @classmethod
    def set_raise_amt(cls, amount):
        cls.raise_amt = amount

    @classmethod
    def from_string(cls, emp_str):
        first, last, pay = emp_str.split('-')
        return cls(first, last, pay)
'''
class Company(Employee):
    def __init__(self, first, last, pay, company):
        super().__init__(first, last, pay)
        self.company = company
        pass
'''
class Manager(Employee):

    def __init__(self, first, last, pay, employees = None):    #Creating List of employees
        super().__init__(first, last, pay)
        if employees is None:
            self.employees = []
        else:
            self.employees = employees

    def add_emp(self, emp):
        if emp in self.employees:
            self.employees.append(emp)

    def remove_emp(self, emp):
        if emp in self.employees:
            self.employees.remove(emp)

    def print_emps(self):
        print("Here the list of Employees under Manager - {} {}".format(self.first, self.last))
        for emp in self.employees:
            print('-->',emp.fullname())

```
magicsound 0.0.5
Super simple sound player
Requires Python: >=3.6
Keywords: sound magicsound playsound music wave wav mp3 media song play audio

magicsound
=========
*Cross platform, single function module with no dependencies for playing sounds.*

Installation
------------
Install via pip:

    $ pip install magicsound

Done.

If you want to just work from the source,
just copy the magicsound.py file into the same folder as your project,
or into a library path.

The latest version of the source code can be found at:
https://github.com/jhanish/magicsound

Quick Start
-----------
Once you've installed, you can really quickly verify that it works with just this:

    >>> from magicsound import magicsound
    >>> magicsound('/path/to/a/sound/file/you/want/to/play.wav') 

Documentation
-------------
The magicsound module contains only one thing - the function (also named) magicsound.

It requires one argument - the path to the file with the sound you'd like to play. This may be a local file, or a URL.

There's an optional second argument, block, which is set to True by default. Setting it to False makes the function run asynchronously when possible, which is not always at this point.

On Windows, uses windll.winmm. WAVE and MP3 have been tested and are known to work. Other file formats may work as well.

On MacOS, we use the command line utility afplay so nothing else needs to be installed.

On Raspberry Pi, we use ffplay command line utility for the same reason.

On Linux, uses GStreamer. Known to work on Ubuntu 14.04 and ElementaryOS
Loki. Support for the ``block`` argument is currently not implemented.

Requirements
------------
Tested on Windows 10, MacOS 10.15.6 (Catalina), and Raspian on a 4 gig PI 4.
I've only tested with Python 3.8 on all 3 platforms.
The code is all simple enough that it's application should be able with a broad set
of software versions, but let me know, I'd like to fix any found problems
on modern systems, and add others as possible.  
If you need older systems to work, please check out
the playsound project that this project was forked from.

https://github.com/TaylorSMarks/playsound

Copyright
---------
This software is Copyright (c) 2020 Joe Hanish <joe.hanish@gmail.com>.

This is a derivitive work from Taylor Marks playsound library that you can find
here: https://github.com/TaylorSMarks/playsound. 

If you are using Python older than 3.6, I recommend you use his library.  Magicsound was made just to fix some problems on newer systems, eradicate the install requirement for OSX, and detect and work with Raspberry Pi directly.  This project is MIT licensed as is his. 

Taylor's original source copyright:
This software is Copyright (c) 2016 Taylor Marks <taylor@marksfam.com>.

See the bundled LICENSE file for more information.
redmask 1.1.0
A simple tool to create palette swap mask
Keywords: palette,gimp,krita,shaders

# ![icon](https://raw.githubusercontent.com/williamd1k0/redmask/master/icon.png) redmask
A simple tool to create palette swap mask


## How palette swap mask works

A palette swap mask is an image used to map a palette using a gradient scale.

The tool will generate a red gradient image because green and blue values are useless for the mask.

Full explanation about palette mask: [https://www.youtube.com/watch?v=u4Iz5AJa31Q](https://www.youtube.com/watch?v=u4Iz5AJa31Q)

![palette-mask-tuto](https://raw.githubusercontent.com/williamd1k0/redmask/master/tests/palette-mask.png)

## Using the generated mask

The mask can be used in a palette swap shader.

Example shader in Godot Engine 2.1.x:

```glsl
// fragment
uniform texture palette;
uniform float colors;
uniform float color_step;

if (COLOR.a != 0){
    COLOR = tex(palette, vec2((COLOR.r*255.0)/(colors-0.001) / color_step, 0));
}
// '0.001' part is a workaround to fix float precision issues.
```

## Basic usage

```bash
# redmask = python redmask.py

redmask <input> <palette>
# generate a mask using default color step (1)

redmask <input> <palette> -s 10
# generate a mask using 10 as color step

redmask <generated-mask> <palette> -a
# apply a palette (paint the mask) using default color step (1)
```

You can test using images in the `tests` directory.

Also, you can view usage info using the `-h/--help` command.

---

> Example art made by [Yomieda](https://twitter.com/yomieda).
RedditReader 1.0
RedditReader is a package to get random images from any Subreddit available on Reddit.
Requires Python: >=3.6

# RedditReader
RedditReader is a package to get random images from any Subreddit available on Reddit.

# Usage
## Subreddit Class
```python
from RedditReader import Subreddit

meme = Subreddit("memes")
meme.get_random()
url = meme.url
print(url)

> https://i.redd.it/tunx3ghxjqb51.jpg
```

Attributes available for RedditReader.Subreddit obejct -
```
url - Returns submission url
title - Returns submission title
upvotes - Returns upvote count of the submission
comments - Returns comment count of the submission
```
ssm-manage 0.1.0
Manage Kubernetes secrets with ParameterStore and SecretsManager.
Requires Python: >=3.5, <4
Keywords: kubernetes k8s ssm parameter store secrets manager

# ssm-manage
Manage your Parameter Store and Secrets Manager secrets in AWS.

## Usage
```
usage: ssm-manage [-h] {param,secret} ...

Manage Kubernetes secrets with ParameterStore and SecretsManager.

positional arguments:
  {param,secret}  subcommand help
    param         run commands against aws parameter store values
    secret        run commands against a secret inside of a parameter value

optional arguments:
  -h, --help      show this help message and exit
```

**Examples**
```
# get a parameter's value
ssm-manage param get my-param-name

# decode a parameter as yaml and read a specific value
#   --decode : if you want to base64 decode the string before printing it.
ssm-manage secret get my-param-name secret-name [--decode]

# create a new parameter
#   --encode : if you want the value base64 encoded.
ssm-manage param new my-new-param some-new-value-123 [--encode]

# add a new secret to a yaml formatted parameter
#   --encode : if you want the value base64 encoded.
ssm-manage secret add my-param-name some-secret-name new-value-5678 [--encode]

# etc ...
```

## Contributing 
this project uses pipenv to compartmentalize development packages. because of this there are a few commands to run to get everything working.

if you want completion in your editor you need to set up pipenv.
```
    pipenv install
```
this will install your dependencies and (usually) configure your editor to use the virtualenv.

if you add new files to the ssm_manage package, you'll need to run
```
    python setup.py build
```
this adds the new files into the package inside of pipenv

to run ssm-manage inside of pipenv, run
```
    pipenv run ssm-manage [args] [-h,--help]
```

if you get an error stating that `ssm-manage` is not a command. when running in pipenv, it can be helpful to run
```
    pipenv install '-e .'
```
this installs the ssm-manage package as an editable package into pipenv, though this should already be setup with the Pipfile in the project.