semvec/pypi-packages huggingface dataset:
TACalculator-v4 0.2
Simple calculator, performing basic functions


 
 
<h1><p style="font-family: 'Brush Script MT', cursive;">Hello!</h1></p>
For the Module 1 Sprint 1 project I was supposed to create a Python package that is capable of conducting basic calculator-like functions, including:
<li> Addition/ Subtraction;
<li> Multiplication/ Division;
<li> Taking (n) root of a number;
<li> Resetting memory.


<b>IMPORTANT note!</b> Calculator is capable of accepting both integers and float numbers.

## How to use it?

### 1. First of all, let's install the package. It can be accessed both - in your local machine and remote (like Google Colab)
``` shell
pip install TACalculator-v3
```
### 2. Import module "Calculator" from a package

```python
from file.calculator import Calculator
```
### 3. Create an instance of the Calculator class:

```python
calculator = Calculator()
```

*<b>IMPORTANT note</b>: By default calculator's memory is set to 0.0

<h2>Known biases, possible areas for improvement:</h2>

1. <b>Error handling and input validation.</b> It is expected that user will by himself handle possible Errors i. e. (division by Zero, math with string values, etc.)
2. <b>Additional functionality.</b> Calculator can easily have more algebra functions.

<h1> Main functions</u>

## Addition
To add a value to the memory value, use the `add(value)` method. This will add 12.0 to the memory value and will return the new value.
```python
calculator.add(12.0)
```


## Substraction
To subtract a value from the memory value, use the `subtract(value)` method. This will subtract 5.0 from the memory value and will return the new value.
```python
calculator.subtract(5.0)
``` 


## Multiplication
To multiply the memory value by a value, use the `multiply(value)` method. This will multiply the memory value by 6.0 and will return the new value.
```python
calculator.multiply(6.0)
``` 


## Division
To divide the memory value by a value, use the `divide(value)` method. This will divide the memory value by 2.0 and will return the new value.
```python
calculator.divide(2.0)
``` 


## Root
To take the 1/nth root of the memory value, use the `root(value)` method. This will take the third level root of the memory value and will return the new value.
```python
calculator.root(3)
```

## Reset
To reset the memory value to 0.0, use the `reset()` method. This will reset the memory value to 0.0 and will return the 0.0 value.
```python   
calculator.reset()
```


<h2> Thank you for you attention!

I am open for a feedback!
cleangpt 0.1.2
CLI to make AI-generated text more human-like.
Requires Python: >=3.6

### cleangpt

Make GPT's output seem more human-like and non-detectable by GPTZero and such. 

`cleangpt <input_file>.txt` will produce a `clean_gpt_output.txt` file with output.

--------------------------
@author: technoabsurdist
PyMergeMail 0.0.1a4
A simple module to send bulk personalized html mail with jinja2 template
Requires Python: >=3.9
Keywords: email,html,mail,merge

# PyMergeMail
A simple module to send bulk personalized html mail with jinja2 template
# Installation
```python
pip install PyMergeMail
```
# Usage
```python
import asyncio
from PyMergeMail import mail

CRED_FILE_PATH = "key.json"
DATA_FILE_PATH = "source_data.xlsx"
SUBJECT_FILE_PATH = "subject.txt"
BODY_FILE_PATH = "test.html"
CID_FIELDS = ["img_path", "sig_path"]
ATTACH_FIELD = "attachment"

asyncio.run(mail(CRED_FILE_PATH,
                 DATA_FILE_PATH,
                 SUBJECT_FILE_PATH,
                 BODY_FILE_PATH,
                 CID_FIELDS,     # optional
                 ATTACH_FIELD    # optional
            ), debug=True
        )
```
mptt-reader 1.0.2
A framework for easily logging and modifying Tristar-MPTT-45 Solar Controllers over a serial connection.
Requires Python: >=3.10

# MPTT-Reader

A work in progress way to quickly read from an TRISTAR-MPTT-45. Soon there will be added features to logging the data to unique data formats.

If you use the tool, please leave a star, so others can find it too in their search.

Use `pip install mptt_reader` to download the library.

If you want to just read and modify the MPTT-reader in a pythonic way without logging variables, use `MPTTReader` class.

If you want to log variables, you can just take your `MPTTReader` class and pass it into an `MPTTLogger` instance.

```py
from mptt_reader.reader import MPTTReader
from mptt_reader.logger import MPTTLogger
from mptt_reader.constants import Variable

reader = MPTTReader("COM3")
# You must provide variables, but file_name will default to the current date and time. Update interval is normally 1 second.
logger = MPTTLogger(reader, variables=[Variable.BATTERY_VOLTAGE, Variable.ARRAY_VOLTAGE], file_name="output", update_interval=2)
# Now it will be logging all variables every second to output.csv and you can still mess with the MPTTReader
reader.overrides.battery_voltage_regulation.set_value(11)
# The value is set, but is not currently controlling the actual voltage regulation.
reader.overrides.battery_voltage_regulation.lock() 
# Now, it will start updating with your given value and you can change it.
reader.overrides.battery_voltage_regulation.set_value(10) 
# If you set too high or a too low value, you could cause a fault!
reader.overrides.battery_voltage_regulation.unlock()
# Now it will return control to the slave, make sure to unlock or you will just keep the same value forever.
```