semvec/pypi-packages huggingface dataset:
calculator_mcc 0.1.4
Calculator module

# Python Calculator Package

This is a simple calculator package written in Python. 
Package description page on  [PyPI](https://pypi.org/project/calculator_mcc/).

### Package Features

- `add(input)`: add input to current value
- `substract(input)`: substract current value with the input
- `multiply(input)`: multiply current value with the input
- `divide(input)`: divide current value with the input
- `root(input)`: get the nth(input) root of the current value
- `reset()`: reset the calculator to zero

## Getting Started
To use this calculator, you need to have `python`, `numpy`, and the `calculator package` installed.


### Package Installation
Run in the command line:
```sh
$ pip install calculator_mcc
```
#### Import
Import the package in the [Jupyter Notebook](https://jupyter.org/) or Python IDE of your choice:

```sh
from calculator_mcc import Calculator

calc = Calculator() # instantiate a calculator project calc
```

#### Common Usage Examples
```sh
1 calc.add(10)
2 calc.multiply(2)
3 calc.divide(5)
4 calc.root(2)
5 print(calc)
6 calc.reset()

-- Terminal Output --
1 $ 10
2 $ 20
3 $ 4
4 $ 2
5 $ 🧮 current_value: 0
6 $ 0
```

#### Note
##### Float number with 0 in the fractional part is converted to integer
- For better readibility, if the fraction part of the resulting float number is 0, such as `10.0`, the fraction part would be removed, and the output would be `10`.

##### Limitations:

- Calculator has a maximum `3.4028235e+38` and minimun: `3.4028235e-38` range limitaion.
```
c = Calculator()
c.add(3.4028235e+39)

-- Terminal Output --
$ 🤖: 🚫 overflow encountered in cast
$ Traceback (most recent call last):
  File .....
```
- Calculator does not support complex number operation.
```
c = Calculator(10)
c.add(3.4028235e+39)

-- Terminal Output --
$ 🤖: 🚫 float() argument must be a string or a real number, not 'complex'
Traceback (most recent call last):
  File .....
```

### Unit test

Run in the command line:

```sh
$ cd calculator_project_mcc
$ pytest
```

#### License

MIT
concentration-lib 0.2.0
Library for concentration bounds
Requires Python: >=3.6

# Concentration bounds library

* concentration_bounds: fixed sample size confidence bounds on the mean.
* concentration_variance_bounds: fixed sample size confidence bounds on the standard deviation.
* empirical_concentration_bounds: fixed sample size confidence bounds with data-dependent estimators rather than fixed parameters (e.g the variance in Bernstein bound is estimated from the data instead of being prior knowledge).

To install : pip install concentration_lib https://pypi.org/project/concentration-lib/

To test : python -m pytest
dueros-smarthome 0.0.15
Duer OS SmartHome APIs
Requires Python: >=3.7

# Duer OS SmartHome API

![publish to pypi](https://github.com/zsy056/dueros-smarthome/actions/workflows/publish-to-pypi.yml/badge.svg?branch=main)

Based on article [小度设备全面接入HomeAssistant](https://mp.weixin.qq.com/s/0D4X6oL60vv7oiJvJiorkg)
calc-project-christian 0.0.1
A small calculator that can do various calculations. Read the README file
Requires Python: >=3.7

# Simple Calculator

This is a simple calculator that can add, subtract, multiply, divide and take the nth root of a number.
It's a part of a school project at https://turingcollege.com.

In the notebook run the first code cell
Then in the second code cell you can use:
- calc.add()
- calc.sub()
- calc.multi()
- calc.div()
- calc.root()
- calc.reset()

They all take 1 argument except for calc.reset() which takes 0 arguments and calc.root which takes 2.
The first argument in calc.root is the root and the second argument is the value. calc.root will not be saved in the memory.

The Calculator also has it's own memory, so it will start from 0 and will do the calculations from it's memory as you go until you use calc.reset()

Examples:
-- calc.add(5)
5

-- calc.sub(2)
3

-- calc.multi(2)
6

-- calc.div(2)
3

-- calc.reset()
0

-- calc.root(2, 25)
5
SSML-parser 1.0.0
An SSML parsing library.

## This is a simple SSML-parser and is currently under development.

Example:

File output
```python
parseObject = parseSSML("test.xml") ## input file
parseObject.parse()
with (open("test.txt","w")) as f:
    ## output file
f.write(parseObject.final_string)
```
Text output
```python
parseObject = parseSSML("test.xml") ## input file
parseObject.parse()
print(parseObject.final_string)
DynHandGestRecToolkit 0.1.1
x86 mac and windows version

# HandGestureRecSiliconM1
# Short Summary:
This is a dynamic hand gesture detection library for m1 silicon, the user can interact with the library using a GUI built using Tkinter.
## Implementation: 
The library uses the webcam as the sensor and it gives the user access to the webcam using opencv, then the handlandmarks are collected using MediaPipe.
## GUI:
The GUI is the main way for the user to interact with the toolkit. It is written in Tkinter for python wich is the default GUI library for Python. The GUI is simple and easy to use.
## The Backend:
It is comprised of:
### Data Collection:
 The data collection is done using OpenCV and MediaPipe, each gesture is composed of 80 videos each is 30 frames, with each frame containing the 42 landmarks for each hand. Each landmark is an X, Y,  Z  tupple which describes the location of that specific landmark.
### Data Storage Strategy:
No DBMS was used instead a folder tree which is composed of 3 submodules was built. The first submodule is  a  gestures folder that contains all the gestures defined by the user, the second is a datasets submodule which contains all the datasets created by the user. A single dataset is a non null subset of the gestures.
### The machine learning algorithm:
The ML. model used is an LSTM model  which was built using Tensorflow 2.X  and the Keras ApI. for tensorFlow.
# How to use:
install the library from $ pip using pip install HandGestureRecSiliconM1 and in your python project write at the terminal run 
* 1)   The user define one or more gesture using the GUI. One gesture is to be defined at a time. The gesture is defined by giving it a name and pressing create gesture then OpenCV will  give the user access to the webcam, 80 videos will be taken each is 30 frames in length so the user needs to do the gesture for 80 times. The starting time of each try of the 80 will be shown on the screen.
* 2) After the user defines 1 or more gestures, he can then use the datasets submodule to create a dataset which will then serve as an input to the ML. model. To create a dataset the user have to give it a name and choose a subset of the gestures he defiend before hand then press create dataset.
* 3)  After having one or more datasets the user can then can to the models submodule to crerate a model to a specific dataset. There is a 1:1 relation between the datasets and the models meaning that every dataset can only contribute to only one model.
* 4)  After creating one or more models the user can test his models using the testing submodule.
DynHandGestRecLibrary 0.1.1
x86 mac and windows version

# HandGestureRecSiliconM1
# Short Summary:
This is a dynamic hand gesture detection library for m1 silicon, the user can interact with the library using a GUI built using Tkinter.
## Implementation: 
The library uses the webcam as the sensor and it gives the user access to the webcam using opencv, then the handlandmarks are collected using MediaPipe.
## GUI:
The GUI is the main way for the user to interact with the toolkit. It is written in Tkinter for python wich is the default GUI library for Python. The GUI is simple and easy to use.
## The Backend:
It is comprised of:
### Data Collection:
 The data collection is done using OpenCV and MediaPipe, each gesture is composed of 80 videos each is 30 frames, with each frame containing the 42 landmarks for each hand. Each landmark is an X, Y,  Z  tupple which describes the location of that specific landmark.
### Data Storage Strategy:
No DBMS was used instead a folder tree which is composed of 3 submodules was built. The first submodule is  a  gestures folder that contains all the gestures defined by the user, the second is a datasets submodule which contains all the datasets created by the user. A single dataset is a non null subset of the gestures.
### The machine learning algorithm:
The ML. model used is an LSTM model  which was built using Tensorflow 2.X  and the Keras ApI. for tensorFlow.
# How to use:
install the library from $ pip using pip install HandGestureRecSiliconM1 and in your python project write at the terminal run 
* 1)   The user define one or more gesture using the GUI. One gesture is to be defined at a time. The gesture is defined by giving it a name and pressing create gesture then OpenCV will  give the user access to the webcam, 80 videos will be taken each is 30 frames in length so the user needs to do the gesture for 80 times. The starting time of each try of the 80 will be shown on the screen.
* 2) After the user defines 1 or more gestures, he can then use the datasets submodule to create a dataset which will then serve as an input to the ML. model. To create a dataset the user have to give it a name and choose a subset of the gestures he defiend before hand then press create dataset.
* 3)  After having one or more datasets the user can then can to the models submodule to crerate a model to a specific dataset. There is a 1:1 relation between the datasets and the models meaning that every dataset can only contribute to only one model.
* 4)  After creating one or more models the user can test his models using the testing submodule.