semvec/pypi-packages huggingface dataset:
autoclasstoc 1.7.0
Add a succinct TOC to auto-documented classes.
Requires Python: >=3.6

************
autoclasstoc
************

.. image:: https://img.shields.io/pypi/v/autoclasstoc.svg
   :target: https://pypi.python.org/pypi/autoclasstoc

.. image:: https://img.shields.io/pypi/pyversions/autoclasstoc.svg
   :target: https://pypi.python.org/pypi/autoclasstoc

.. image:: https://img.shields.io/readthedocs/autoclasstoc.svg
   :target: https://autoclasstoc.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/github/actions/workflow/status/kalekundert/autoclasstoc/test.yml?branch=master
   :target: https://github.com/kalekundert/autoclasstoc/actions

.. image:: https://img.shields.io/codecov/c/gh/kalekundert/autoclasstoc
   :target: https://app.codecov.io/gh/kalekundert/autoclasstoc

It's surprisingly difficult to document large Python classes in a way that's 
easy for users to navigate.  Most projects use the ``autodoc`` Sphinx plugin, 
which simply puts the complete documentation for each class member one after 
another.  While this does fully document the class, it doesn't give the user a 
quick way to see everything the class can do.  This makes classes of even 
moderate complexity difficult to navigate.  It also encourages projects to be 
stingy about which class members to include in the documentation (e.g.  
excluding special methods, inherited methods, private methods, and/or 
undocumented methods), to the further detriment of the user.

What's needed is for each class to have a succinct table of contents (TOC) 
that:

- Is organized into sections that will be meaningful to the user.  Different 
  projects and classes may call for different sections, e.g. public/private 
  methods, methods that share a decorator, methods with a common prefix, etc.  

- Includes every method of the class (so that the documentation is complete), 
  while still making it easy for the user to get a sense for what the class 
  does and find what they're looking for.

- Collapses inherited methods.  Complex classes in particular can inherit a lot 
  of methods from their parent classes, and while these methods should be 
  present in the TOC (since they're part of the class), collapsing them makes 
  it easier for the user to grok the functionality provided by the class 
  itself.

``autoclasstoc`` provides a new Restructured Text directive that is all of 
these things.  It also works well with ``autodoc`` and ``autogen``, and should 
be easy to incorporate into any existing project. 

See the `complete documentation`__ for more information (including examples).

__ https://autoclasstoc.readthedocs.io/en/latest
django-rest-envelope 1.1.0
A mixin for Django REST package List Views to return an object instead of a list.
Requires Python: >=3.9
Keywords: django

# Django REST Envelop

Turn the ViewSet list endpoints to return an object rather than a list directly.

## Installation

From PYPi using `pip`:

```
pip install django-rest-envelope
```

## Usage

In your viewset views, you can use the `ListEnvelopeMixin` along with another mixin that defines the `list()` method:

```python
class MyViewSet(ListEnvelopeMixin, ReadOnlyModelViewSet):
    envelope: "my_envelope"
```

In your ViewSet class that uses the mixin you have to define the `envelope` attribute.

Additionally, you can overwrite the `get_envelope()` method to tweak the behaviour of
which envelope use in different situations.

### Example

By default, django REST ViewSets return a list:

```json
[
  { "id": 1, "foo": "bar" },
  { "id": 2, "foo": "baz" }
]
```

Once the mixin is applied to that same ViewSet, you get, instead, the following response:

```json
{
  "my_envelope": [
    { "id": 1, "foo": "bar" },
    { "id": 2, "foo": "baz" }
  ]
}
```

## Licence

This package is distributed under [MIT Licence](./LICENCE).
calcula 0.0.1
Uma calculadora simples que suporta operações básicas em Python.
Requires Python: >=3.6

# LaboratÃ³rio de Python: uma calculadora
LaboratÃ³rio de calculadora python para publicar no Pypi. Handson para o Curso NTT DATA - Engenharia de Dados com Python da plataforma DIO. Este Ã© um script de uma calculadora bÃ¡sica em Python que suporta diversas operaÃ§Ãµes matemÃ¡ticas, como soma, subtraÃ§Ã£o, multiplicaÃ§Ã£o, divisÃ£o, potÃªncia, raiz quadrada e raiz cÃºbica. A funÃ§Ã£o principal Ã© a `calcula`, que recebe como parÃ¢metros a operaÃ§Ã£o a ser realizada e uma lista de nÃºmeros sobre os quais a operaÃ§Ã£o serÃ¡ aplicada.

## Funcionalidades

- **Soma**: Calcula a soma de todos os nÃºmeros da lista.
- **SubtraÃ§Ã£o**: Subtrai todos os nÃºmeros da lista a partir do primeiro.
- **MultiplicaÃ§Ã£o**: Calcula o produto de todos os nÃºmeros da lista.
- **DivisÃ£o**: Divide o primeiro nÃºmero pelo produto dos nÃºmeros restantes.
- **PotÃªncia**: Eleva o primeiro nÃºmero ao segundo nÃºmero (suporta apenas dois nÃºmeros).
- **Raiz Quadrada**: Calcula a raiz quadrada do primeiro nÃºmero da lista.
- **Raiz CÃºbica**: Calcula a raiz cÃºbica do primeiro nÃºmero da lista.

## Uso

### FunÃ§Ã£o `calcula`

```python
def calcula(operacao: str, numeros: list[float]) -> float:
```

#### ParÃ¢metros:
- `operacao` (str): Uma string que define a operaÃ§Ã£o a ser realizada. Pode ser:
  - `"soma"`
  - `"subtracao"`
  - `"multiplicacao"`
  - `"divisao"`
  - `"potencia"`
  - `"raiz_quadrada"`
  - `"raiz_cubica"`
- `numeros` (list[float]): Uma lista de nÃºmeros de ponto flutuante sobre os quais a operaÃ§Ã£o serÃ¡ realizada.

#### Retorno:
- Retorna o resultado da operaÃ§Ã£o como um nÃºmero de ponto flutuante.

#### ExceÃ§Ãµes:
- `ValueError`: LanÃ§a uma exceÃ§Ã£o caso a operaÃ§Ã£o seja invÃ¡lida ou se houver uma divisÃ£o por zero.

### Exemplo de Uso

```python
# Realizando a soma de 10, 20 e 30
resultado = calcula("soma", [10.0, 20.0, 30.0])
print(resultado)  # SaÃ­da: 60.0

# Realizando a divisÃ£o de 10 por 5
resultado = calcula("divisao", [10.0, 5.0])
print(resultado)  # SaÃ­da: 2.0
```

## ExceÃ§Ãµes Tratadas

A funÃ§Ã£o `calcula` trata as seguintes exceÃ§Ãµes:
- **DivisÃ£o por zero**: Gera uma mensagem de erro especÃ­fica para divisÃµes por zero.
- **OperaÃ§Ã£o invÃ¡lida**: Retorna um erro se a operaÃ§Ã£o nÃ£o estiver entre as suportadas.
- **Erro de tipo ou Ã­ndice**: Caso os parÃ¢metros nÃ£o correspondam aos esperados para uma operaÃ§Ã£o especÃ­fica, uma mensagem de erro Ã© gerada.

## Requisitos

A funÃ§Ã£o utiliza o mÃ³dulo `math` para operaÃ§Ãµes avanÃ§adas, como potÃªncia e raiz quadrada. Este mÃ³dulo Ã© parte da biblioteca padrÃ£o do Python.
emr-password-manager 1.2.0
A simple password manager for generating and validating passwords.
Requires Python: >=3.6

# Python Password Manager Library

This is a Python library that generates random passwords with a specified length, complexity, and character set. Also gives a score of given password.

## Usage

```bash
from password_manager import generate_password , password_strength # Import the library

password = generate_password(length=12, use_letters=True, use_digits=False, use_symbols=False, exclude_chars="a") # Generate a password
print(password) # Print the password

print(password_strength("Emr")) # Check the password strength. Result is like: 3 / 10
```
TritonHub 1.0.2
A collection of Triton-based neural network modules
Requires Python: >=3.7

# TritonHub

## About
TritonHub serves as a container for various PyTorch neural network components written in Triton, offering an easy way to access and integrate Triton-based functions from one centralized source. These components include custom implementations of activation functions, normalization layers, and other neural network operations designed for efficient execution on GPUs.

I hope this repository proves helpful to the community, making Triton-based neural network operations more accessible and convenient for developers and researchers alike.

## Installation

You can install **TritonHub** directly from:

```bash
pip install TritonHub
```

Alternatively, you can install it from the GitHub repository:

```bash
pip install git+https://github.com/AliYoussef97/TritonHub.git
```

Or clone the repository and install manually:

```bash
git clone https://github.com/AliYoussef97/TritonHub.git
cd TritonHub
python setup.py install
```

TritonHub requires the following dependencies:
-   Linux
-   CUDA
-   NVIDIA GPU

## Usage Example

```python
import torch
from TritonHub.Normalization import LayerNorm
from TritonHub.Activation import GeLU

batch, length, dim = 2, 100, 128
device = "cuda"
dtype = torch.float32  # or torch.float16

x = torch.randn(batch, length, dim, device=device, dtype=dtype).to("cuda")

# Initialize LayerNorm and GeLU modules from TritonHub
layernorm = LayerNorm(128, eps=1e-6, elementwise_affine=True, bias=True, device=device, dtype=dtype)
gelu = GeLU(approximate='None') # or tanh

# Apply LayerNorm and GeLU on the input tensor
x = layernorm(x)
x = gelu(x)
```

## Contributions

Contributions are welcome! If you'd like to add new functionalities, please:
1. Create a pull request with your implementation.
2. Ensure the pull request includes a unit test for the new module, similar to the tests found in the `UnitTests` folder.

If you encounter any bugs or issues with the current version, please feel free to report them by creating an issue or submitting a pull request.

## TODO
| Feature                         | Status  |
|----------------------------------|---------|
| Linear Layer Backward Pass       | ✔️      |
| Include Triton Block Sizes in Autotune | ❌  |
| Convolution Layer                      | ❌       |
| BatchNorm                        | ❌       |
| Different Activation Functions   | ❌       |


## License
This project is licensed under the MIT License. See the [LICENSE](https://github.com/AliYoussef97/TritonHub/blob/main/LICENSE) file for more details.

## Acknowledgments
Special thanks to the authors of [Mamba](https://github.com/state-spaces/mamba), as parts of their Triton code was influential or some of the modules in TritonHub.