semvec/pypi-packages huggingface dataset:
netbg 0.1
A simple package for Big Data Analytics Practical
Requires Python: >=3.6

# NetBG Package

NetBG is a Python package designed for various data processing and analysis tasks, providing a suite of methods for handling different algorithms and techniques in network analysis, data mining, and more.

## Installation

To install the NetBG package, you can use pip:

```bash
pip install netbg
```

## Usage

To use the NetBG package, you can import it as follows:

```python
import netbg as ng
```

## Available Methods

The following methods are available in the NetBG package:

1. **crud()** - Perform Create, Read, Update, and Delete operations.
2. **logistic()** - Implement logistic regression for classification tasks.
3. **pipeline()** - Create a processing pipeline for data transformations.
4. **shingles_word()** or **shingles_char()** - Generate word or character shingles from text.
5. **minhash()** - Perform MinHash for estimating the similarity between datasets.
6. **minhashpro()** - Apply MinHash for k-shingles.
7. **martin()** - Implement the Martin algorithm for network analysis.
8. **bloom()** - Use Bloom filters for probabilistic data structures.
9. **ams()** - Apply Alon-Matias-Szegedy algorithm for frequency estimation.
10. **bipartite()** - Analyze bipartite graphs.
11. **social()** - Implement social network analysis methods.
12. **pcy()** - Use the PCY algorithm for frequent itemset mining.

## Example

Here's an example of how to use the `social` method:

```python
import netbg as ng

# Call the social method
ng.social()
```

## Documentation

For more detailed information on each method, please refer to the official documentation or the source code within the package.

## License

This package is licensed under the MIT License. See the LICENSE file for more information.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request for any improvements or suggestions.
omie-py 0.0.0
Client não oficial da Omie API em Python
Requires Python: >=3.11
Keywords: api, client, omie, python

# Documentação do Integrador Omie

## Dependencias
A única dependencia necessária é a biblioteca [zeep](https://docs.python-zeep.org/en/master/index.html), que é usada para criar os clientes SOAP. 

## Autenticação

Para autenticar na API do Omie, você precisa fornecer uma `app_key` e um (`app_secret`). Esse dados são obtidos no site da [omie](https://developer.omie.com.br/).

```python
import os

from omie_py.client import OmieClient

key = os.getenv('OMIE_APP_KEY')
secret = os.getenv('OMIE_APP_SECRET')
client = OmieClient(key, secret)
```

## Usar métodos das API

A Omie disponibiliza várias APIs e o cliente recebe uma chamada e verifica em qual API o método está disponível e executa a chamada. O mesmo vale para os tipos disponibilizados na API.

Para verificar os métodos e tipos disponiveis o [site da API](https://developer.omie.com.br/service-list/) deve ser usado.

Os tipos oferecem validação de campos e tipos.

Exemplo para listar departamentos.

```python
departamento_listar_request = client.get_type('departamento_listar_request')

response_pages = client.execute_call("ListarDepartamentos", departamento_listar_request(**{
  "pagina": 1,
  "registros_por_pagina": 20,
}), True)

for response in response_pages:
    print(response)
```

### Métodos principais do cliente

- `execute_call(method_name: str, params: dict, is_paginated: bool = False)`: Executa uma chamada à API.
- `get_type(type_name)`: Obtém um tipo específico para ser usado nas requisições.

### Classe PaginatedResponse

Quando o `is_paginated` é passado como `True` para o método execute_call, o retorno é um `Iterable` que faz as chamadas subsequentes para o método.

### Rate limit
A API atualmente limite a 4 req/s e o projeto não gerencia isso.

[Mais informações](https://ajuda.omie.com.br/pt-BR/articles/8112984-limites-de-consumo-da-api-do-omie).
fastapi-tj-tpauth-jwt 1.0.0
Integrate JWT into FastAPI using TP Servers authentication.
Requires Python: <4.0,>=3.9

# fastapi-tj-tpauth-jwt

![PyPI - Version](https://img.shields.io/pypi/v/fastapi-tj-tpauth-jwt)

Integrate JWT into FastAPI using TP Servers authentication.

## Installation

```bash
pip install fastapi-tj-tpauth-jwt
```

## Usage

### Basic Example

```python
from datetime import timedelta
from typing import Annotated

from fastapi import FastAPI, Depends
from tj_tpauth import TJTPAuth, TPAuthData

from fastapi_tj_tpauth_jwt.tpauth_jwt import TPAuthJWT

app = FastAPI()

tpauth = TJTPAuth(
    host="localhost:8080"
)

tpauth_jwt = TPAuthJWT(
    tp_auth=tpauth,
    secret_key="<SECRET_KEY>",
    refresh_secret_key="<SECRET_KEY>",
    access_token_expires_in=timedelta(minutes=60),
    refresh_token_expires_in=timedelta(minutes=120),
    algorithm='HS256'
)


@app.get("/")
async def root():
    return {"message": "Hello World"}


@app.post("/login")
async def login(
        login_res: Annotated[
            tpauth_jwt.provide_login_handler(), Depends()
        ]
):
    return login_res


@app.post("/refresh")
async def refresh(
        refresh_res: Annotated[
            tpauth_jwt.provide_refresh_token_handler(), Depends()
        ]
):
    return refresh_res


@app.get("/secret_data")
async def secret_data(
        payload: Annotated[
            tpauth_jwt.provide_require_jwt(), Depends()
        ]
):
    if not isinstance(payload, TPAuthData):
        return payload

    payload: TPAuthData

    return {
        "payload": payload.id,
    }

```

### Custom Unauthorized Error Response

```python
def unauthorized_response_provider(tpauth_status: TPAuthStatus):
    return {
        "error": "Unauthorized",
        "status": tpauth_status.error.value
    }


tpauth_jwt.unauthorized_response_provider = unauthorized_response_provider
```

### Custom JWT Response

```python
def jwt_provider(access_token: str, refresh_token: str, token_type: str):
    return {
        "access_token": access_token,
        "refresh_token": refresh_token,
        "token_type": token_type
    }


tpauth_jwt.jwt_response_provider = jwt_provider
```

## License

This library is released under the MIT License.

## Contact

If you have any questions or issues, please open an issue
on [GitHub](https://github.com/duynguyen02/fastapi-tj-tpauth-jwt/issues) or
email us at [duynguyen02.dev@gmail.com](mailto:duynguyen02.dev@gmail.com).
urmom 0.1.1
A Python package that prints 'URMOM' in ASCII art.
Requires Python: >=3.6

# URMOM

`URMOM` is a simple, light-hearted Python package that prints "URMOM" in glorious ASCII art. Because sometimes, you just need to laugh at something absurd.

## Features

- Prints "URMOM" in ASCII art.
- Perfect for adding a touch of humor to your Python scripts.
- Minimal dependencies and easy to use.

## Installation

To install `URMOM`, you can use `pip`. It's available on PyPI, so you can easily install it like any other package.

### Using pip (Preferred)

Run the following command to install the package:

```bash
pip install urmom
```

## Usage

To use `URMOM` in your Python script, simply import it and call the `print_urmom` function:

```python
from urmom import print_urmom

print_urmom()
```

This will display the ASCII art of "URMOM" in your terminal.

## Command-Line Interface (CLI)

You can also use the package directly in your terminal after installation. Just type:

```bash
urmom
```

This command will print the ASCII art directly in your terminal, without needing to write any Python code.

```

  _    _ _____  __  __  ____  __  __ 
| |  | |  __ \|  \/  |/ __ \|  \/  |
| |  | | |__) | \  / | |  | | \  / |
| |  | |  _  /| |\/| | |  | | |\/| |
| |__| | | \ \| |  | | |__| | |  | |
 \____/|_|  \_\_|  |_|\____/|_|  |_|

```

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.