semvec/pypi-packages huggingface dataset:
claves 1.0a4
Manage your code enclaves on AWS.
Requires Python: >=3.6

```diff
- This is alpha release of the software. Use with caution. 
- You are responsible for proper management of your AWS account,
- any resources created by this software and all associated costs. 
```

# 1. Overview

Claves (from **c**ode enc**laves**) is a software for seamless management of virtual environments on AWS for code development.

The command line application can:
- create new EC2 instances with cloned CodeCommit repository
- manage IAM roles on your behalf to grant the enclave the least privileges
- list and delete previously created code enclaves

# 2. Motivation
Developers write the code on daily basis. They often work on multiple projects at the same time and are willing to try new libraries as it's essential part of their job. From information security point of view it's a real challange to protect them from emerging threats. For a long time supply-chain attacks remained in a area of theoretic attacks not feasible to perform in real world scenarios but it changes...  Both real and simulated attempts appeared recent years which prove that use of malicious dependencies is a great way to infect the last links of software development ecosystem. We can act and change our behaviour by following the rules of least privilege approach and security by isolation. Sometimes we won't be able to prevent the attack itself but we can minimise the impact.

The security objectives of Claves is to:
- allow developers create separated environment for each project they contribute
- prevent project's code (and its dependencies) from reading and modifying other projects data or developer's private data
- prevent the attacker from achieving the persistence on a system by the use of ephemeral environments

But also from general development perspective:
- create easily deployable environments to speed up the introduction of new code contributors
- use cloud capabilities to decrease build and test time when making changes to the codebase

References:
- https://portswigger.net/daily-swig/open-source-security-malicious-npm-packages-broadcast-sensitive-user-data-online
- https://nakedsecurity.sophos.com/2017/09/19/pypi-python-repository-hit-by-typosquatting-sneak-attack/

# 3. Long term goals

- Add more deployment options besides AWS EC2 (more CSP but also a local VMs/Dockers maybe?)
- Add more code provider options besides AWS CodeCommit (GitHub, etc.)
- Let Claves be used easily as the API not only command line app
- Let Claves be more customisable in terms of post-cloning configuration
- More ideas? Open an issue :)
mys-bits 0.2.0
Bits operations.

|buildstatus|_

Bits
====

Basic bits operations in the `Mys programming language`_.

Examples
========

.. code-block:: python

   from bits import reverse
   from bits import leading_ones
   from bits import leading_zeros
   from bits import count_ones
   from bits import count_zeros
   from bits import rotate_left
   from bits import rotate_right

   def main():
       value: u32 = 0x12345678
       assert_eq(reverse(value), 0x1e6a2c48)
       assert_eq(leading_ones(value), 0)
       assert_eq(leading_zeros(value), 3)
       assert_eq(count_ones(value), 13)
       assert_eq(count_zeros(value), 19)
       assert_eq(rotate_left(value, 8), 0x34567812)
       assert_eq(rotate_right(value, 8), 0x78123456)

.. code-block:: text

   $ mys run

.. |buildstatus| image:: https://travis-ci.com/eerimoq/mys-bits.svg?branch=master
.. _buildstatus: https://travis-ci.com/eerimoq/mys-bits

.. _Mys programming language: https://github.com/eerimoq/mys
nanotts 0.0.1
Python wrapper for the NanoTTS speech synthesizer
Requires Python: >=3.6

# NanoTTS python wrapper

This package is a python wrapper for the NanoTTS speech synthesizer utility as described here: https://github.com/gmn/nanotts.

## Installation

You can install this package with `pip install nanotts`.
Make sure you have the NanoTTS synthesizer installed and added to your $PATH.

## Usage

The NanoTTS python wrapper provides two methods to generate speech, one from a string input, the other from a text file.

```python
import nanotts

ntts = nanotts.NanoTTS()

# Generate speech from a string
ntts.speaks("Hello World!")

# Generate speech from a text file
ntts.speak("input.txt")
```

The attributes that can be set are described below:

* `loglevel`: set loglevel for the logging module (i.e. `logging.*`)
* `outputFile`: set name of the output .wav file (at least one of `outputFile` and `play` has to be set)
* `pitch`: set pitch in range [0.5, 2.0]
* `play`: toggle whether to directly play the created speech (at least one of `outputFile` and `play` jas to be set)
* `speed`: set speed in range [0.2, 5.0]
* `voice`: choose language from "de-DE", "en-GB", "en-US", "es-ES", "fr-FR", "it-IT"
* `volume`: set volume in range [0.0, 5.0]
convert-units 0.1.0
This module help you convert data from unit to other unit.
Requires Python: >=3.6,<4.0

This module uses for convert lengh, volume, mass and area from unit, to other unit.

Documentation:

 How to use:
import Convert
print(Convert.from_[unit].to_[unit]()) # First unit converted to second unit, always return float

 Example:
import Convert
print(Convert.from_m.to_km(1200)) # 1.2

 Units:

Lengh: m - meter, km - kilometer, dm - decimeter, mm - millimeter, cm - centimeter.

Weight: g - gram, kg - kilogram, mg - milligram, c - centner, t - ton.

Area: sm - square meter, skm - square kilometer, sdm - square decimeter, smm - square millimeter, scm - square centimeter.

Volume: mc - cubic meter, kmc - cubic kilometer, dmc - cubic decimeter, mmc - cubic millimeter, cmc - cubic centimeter.
chcko-r 1.3.2
A random mix of exercises for chcko

chko-r
======

`chko-r`_ is an example content package and test data for `chcko`_.
`chko-r`_ is a random mix of problems and texts.

A live version is available at:

    https://chcko.eu

This python package depends on the `chcko`_ python package,
which is not automatically installed,
because on gcloud `chcko`_ is *uploaded*, not installed.
Therefore locally install with::

    pip install --user chcko
    pip install --user chcko-r

There is no need to install,
if `chcko`_ is parallel to `chcko-r`_.

A content package can add additional dependencies.
This ``chcko-r`` depends on
`schemdraw <https://pypi.org/project/SchemDraw/>`__
`pint <https://pypi.org/project/Pint/>`__.
To install the dependencies without installing ``chcko-r``,
use ``pip install -r requirements.txt``.

Prepare content::

    make html

To run content locally with `chcko`_ installed::

    cd chcko-r
    runchcko

Install content::

    cd chcko-r
    pip install --user .

Image files are compiled to ``/chcko-r/chcko/_images``,
and copied to ``chcko/chcko/_images`` common to all `chcko`_ content when installing.
Image files need to have globally unique names across all ``chcko-<author_id>`` packages.
Use ``<author_id>_<problem_id>_xxx`` scheme,
e.g ``.. texfigure:: r_dg_c1.tex``.

Images can also be generated on the fly.
Examples:
`r.a3 <https://github.com/chcko/chcko-r/blob/master/chcko/r/a3/circuit.html>`__
`r.a4 <https://github.com/chcko/chcko-r/blob/master/chcko/r/a4/circuit.html>`__.

.. _`chcko`: https://github.com/chcko/chcko
.. _`chcko-r`: https://github.com/chcko/chcko-r
luchtmeetnet 0.0.2
Package for luchtmeetned (Dutch)
Requires Python: >=3.6

# AirQuality

This is a Python Package for Air Quality in Dutch Provinces from the site luchtmeetnet. 

Explanation LKI
The air quality index card (LKI) is the sum of the most important air pollutants.

Dutch:
De luchtkwaliteitsindex-kaart (LKI) is een optelsom van de belangrijkste luchtverontreinigende stoffen.

The app will search for your closes station that measures your air quality. 

## Installation

Luchtmeetnet requires Python 3.6+ to run

<pre><code class="has-line-data" data-line-start="9" data-line-end="11" class="language-bash">pip install luchtmeetnet
</code></pre>

## TO-DO 
Several confitions 
More measurements of different substance
token-utils 0.1.8
Small utility to work with Python tokens
Requires Python: >=3.6

# token-utils

This project consists of a single module which is extracted from the
[ideas](https://github.com/aroberge/ideas) package.
Its purpose is to simplify manipulations of tokens from
Python's [tokenize module](https://docs.python.org/3/library/tokenize.html).
One of its features is that, unlike Python's version, the following
is always guaranteed:

```python
from token_utils import tokenize, untokenize

source = "Arbitrary Python code here"

assert source == untokenize(tokenize(source))
```

See [ideas documentation](https://aroberge.github.io/ideas/docs/html/) for more information