semvec/pypi-packages huggingface dataset:
calculator_bladda 0.0.1
Calculator package by Adda Blaise

# Python Calculator

Calculator Functions:
-   Addition / Subtraction.
-   Multiplication / Division.
-   Take (n) root of a number.


## Installation

```sh
pip install calculator_bladda
```


## Usage

```sh
* Show memory value             calc.memory()
* Addition                      calc.add(number)
* Subtraction                   calc.subtract(number)
* Multiplication                calc.multiply(number)
* Division                      calc.divide(number)
* nth root of a number          calc.nth_root(n)
* Reset                         calc.reset()
    
>>>>calc = CalcBladda()
>>>>calc.add(10)
10
>>>>calc.subtract(2)
8
>>>>calc.multiply(3)
24
>>>>calc.divide(2)
12.0
>>>>calc.nth_root(2)
3.4641
```
labos 0.1.2.7
Paquete para trabajar en el labo
Requires Python: >=3.8,<3.12

# Labos

Este paquete está dedicado principalmente a facilitar el uso de herramientas y paquetes utilizados en la adquisición y procesamiento de datos en el marco de los laboratorios de la carrera en [*Ciencias Físicas de la UBA*](https://www.df.uba.ar/es/).

Los paquetes hasta ahora implementados son de adquisición y análisis de datos.

<!-- headings -->
## Análisis de datos

### Propagación
Este paquete está dedicado a propagar errores utilizando una aproximación lineal sobre la formula de covarianza. El paquete está basado en las librerías numpy e sympy.
```python
from labos.propagacion import Propagacion_errores
import numpy as np

# Formula a propagar
expr = 'A*cos(f*t) + C'    

# Las variables dependientes y sus valores
variables = [
    ('f', 100), # Hz
    ('A', 2), # Volts
    ('t', 1), # s
    ('C', .5), # Volts
    ]

# Los errores de las variables
errores = np.array(
    [.0005,
    .0001, 
    0, 
    .0001]
    ).reshape(-1,1)

# Instancia de la clase
propaga = Propagacion_errores(
    formula = expr,
    variables = variables,
    errores = errores)
propaga.fit()
>>(2.224637744575368, 0.0005232992460070357)
```
### Ajuste
Este paquete está dedicado a realizar ajustes sobre datos. El paquete está basado en las librerías numpy e sympy.

#### Heading 3
##### Heading 4
###### Heading 5

<!-- line breaks -->
<!-- ENTER -->

<!-- Italics -->
This is an *italic* text

This is an _italic_ text

<!-- Strongs -->
This is an **strong** text

This is an __strong__ text

<!-- StrikeTrough -->
This is an ~~striketrogh~~ text



<!-- UL -->
* item 1
* item 2
* item 3
    * item 3.1
    * item 3.2    
* item 4

<!-- OL -->
1. item 1
1. item 2
1. item 3
1. item 4

<!-- Links -->
[Faztweb.com](https://www.faztweb.com)

[Faztweb.com](https://www.faztweb.com "Custom title")
<!-- Blockquote -->
> this is a quote

<!-- Horizontal Rule -->
___
---

<!-- Inline code -->
`console.log('hello world')`

`<h1>Hello world</h1>`

<!-- IMAGES -->
<!-- ![Vscode Logo](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/Visual_Studio_Code_1.35_icon.svg/1200px-Visual_Studio_Code_1.35_icon.svg.png) -->

<!-- ![Vscode logo](./vscode.png "vscode") -->

<!-- GITHUB MD -->

```
first line of code
second line of code
```

```python
print("hello world")
```

```javascript
console.log('hello world')

const test = (str) => str + 'test';
```

```html
<h1>Hello World</h1>
```

<!-- TABLES -->
| Product       | Price         |quantity   |
| ------------- |:-------------:| :--------:|
| Laptop        | 3.33          | 2         |
| Mouse         | 10.33         | 1         |

* [x] task1
* [] task2
* [] task3
* [x] task4

<!-- Mentiosn -->
@faztweb :+1: :smile:
darkgmailapi 0.0.4
A package to access the google gmail api
Requires Python: >=3.7

# Gmail API Python Library
This library provides an easy way to interact with the Gmail API using Python. With this library, you can send emails with attachments, authenticate with the Gmail API, and manage your email accounts.

## Usage
To use this library, you'll need to have a Google API Console project with the Gmail API enabled. You can follow the steps outlined in the Gmail API Quickstart Guide to set up your project.

The library requires the following dependencies:
```
google-api-python-client
google-auth-httplib2
google-auth-oauthlib
```
you can install these dependencies using pip:
```
pip install -r requirements.txt
```
You'll also need to have a credentials.json file for your API project, which you can download from the API Console.

You can use the following code to get started with the Gmail API:
```py
from darkgmailapi import GmailApi

# Create a GmailApi object
gmail = GmailApi(credentials="path/to/credentials.json", send_email="you@example.com", token_file="path/to/token.pickle", scope="https://mail.google.com/")

# Build a message to send
message = gmail.build_message(destination="recipient@example.com",
                               obj="Subject of the email",
                               body="Body of the email")

# Send the message
gmail.send_message("me", message.as_bytes())
```
You can also attach files to your emails using the add_attachment method:
```py
# Add an attachment to the message
gmail.add_attachment(message, "path/to/attachment.pdf")
```
to search for emails, you can use the search method:
```py
# Search for emails
emails = gmail.search("search query")
# returns a list of messages
```
to get the body of an email, you can use the read_message method:
```py
# Read the data of an email
message_data = gmail.read_message(emails[0])
# returns a dictionary with the email data, in this format
# {
#   "from": "",
#   "to": "",
#   "subject": "",
#   "date": "",
#   "body_html": "",
#   "body_text": ""
# }
```
to delete an email, you can use the delete_message method:
```py
# Delete an email
gmail.delete_message(emails[0])
```
to read and unread emails, you can use the mark_as_read and mark_as_unread methods:
```py
# Mark an email as read
gmail.mark_as_read(emails[0])

# Mark an email as unread
gmail.mark_as_unread(emails[0])
```
roleplaycog 1.0.2
Roleplay cog for py-cord
Requires Python: >=3.8

# Roleplay Cog
This package is a cog edition of [my roleplay bot repository](https://github.com/mariohero24/Roleplay-Bot) that has been heavily modified
## Installation
```cs
pip install roleplaycog
```
## Setup
```py
import discord
bot = discord.Bot()

# Loading via the setup function
bot.load_extension("roleplaycog")

# Loading directly (why would you do this)
from roleplaycog import Roleplay
bot.add_cog(Roleplay(bot))

bot.run("Token")
```
tomlini 1.0.1
A tiny library for initializing objects from TOML files
Requires Python: >=3.11

# TOMLini

A minimal, unintrusive library that allows you to add the ability to initialize an object from a TOML file without having to go through the dictionary dance.

## Install

Available on PyPI

```bash
pip install tomlini
```

## Example

>All you need to do is create your class with the `@toml_init` decorator:


```python
# myclass.py

@toml_init
class MyClass:
    def __init__(v1, v2):
        self.v1 = v1
        self.v2 = v2

@toml_init
class MyClass2:
    def __init__(v3, v4: MyClass):
        self.v3 = v3
        self.v4 = v4

```

>Define your TOML file (make sure the TOML key names match the `__init__` parameter names!):

```TOML
# file1.toml

v1 = "aaa"
v2 = 1

```

```TOML
# file2.toml

v3 = [1, 2, 3]

[v4]
v1 = "aaa"
v2 = 1

```

>And you're off to the races!

```python
from myclass import MyClass, MyClass2

my_class = MyClass.load_from_toml("/path/to/file1.toml")

my_class_2 = MyClass2.load_from_toml("/path/to/file2.toml")

print(my_class.v1, my_class.v2)
# Outputs: 'aaa', 1

print(my_class_2.v4.v1)
# Outputs: 'aaa'


```
warc-knot 0.2.5
Python library to work with ARC, WARC and WET files
Requires Python: >=3.3

# knot-warc - Python library to work with Web ARChive files

*Note: This is one of forks of original WARC repository. It was primarily created for projects of [Knowledge Technology Research Group](https://knot.fit.vutbr.cz/), but its public-wide usage isn't limited.*
<details>
<summary>Fork history</summary>

1. https://github.com/internetarchive/warc (original Python 2 library)
2. https://github.com/recrm/warc3 (Python 3 port)
3. https://github.com/jpbruinsslot/warc3 (Python 3 port)
4. https://github.com/Willian-Zhang/warc3 (WET support)
</details>

WARC (Web ARChive) is a file format for storing web crawls (see http://bibnum.bnf.fr/WARC/).

## Examples

This `warc` library makes it very easy to work with WARC files:
```python
import warc
with warc.open("test.warc") as f:
    for record in f:
        print(record['WARC-Target-URI'], record['Content-Length'])
```

And WET files:
```python
import warc
with warc.open("test.warc.wet") as f:
    for record in f:
        print(record['WARC-Target-URI'], record['Content-Length'])
```

There are some examples provided without warranty and support (just for inspiration) in [examples](https://github.com/KNOT-FIT-BUT/warc3/tree/master/examples) folder. They are not updated at all, too.

## Documentation

The documentation of this fork of the warc library is on [Github Pages](https://knot-fit-but.github.io/warc3) (alternatively see [original documentation](http://warc.readthedocs.org/)).

## Installation

You can install this fork of warc library using [pip](http://www.pip-installer.org/):
```shell
pip install warc-knot
```

## License

This software is licensed under GPL v2. See [LICENSE](http://github.com/internetarchive/warc/blob/master/LICENSE) file for details.

## Authors

**Original Python2 Versions:**
- Anand Chitipothu
- Noufal Ibrahim

**Python3 Port:**
- Ryan Chartier 
- Jan Pieter Bruins Slot
- Almer S. Tigelaar

**Modifications:**
- Willian Zhang
- Michal Šmahel

## Change Log

**0.2.5**:
- Update sphinx docs

**0.2.4**:
- Fix for Python 3.10+
- Upgrade HTTP --> HTTPS in tests

**0.2.3**
- Support seeking in WARC/WET

**0.2.2**
- Allow WET parse

**Older...**
- see https://github.com/internetarchive/warc