semvec/pypi-packages huggingface dataset:
visiopy 0.2.1
A library to automate Visio operations.
Requires Python: >=3.6

# visiopy

A library to automate Visio operations using Python.  
Initially specialized as terminal in a Jupyter Notebook for fast batch editing Visio drawings.

## Installation

    pip install visiopy

## Usage
### List Open Documents
    from visiopy import loaded_docs
    loaded_docs()

### Initialize Visio Application
    from visiopy import vInit
    vInit(0, globals_dict=globals())
    print(c.visSectionUser)

## Revision 2
The workflow is not straightforward enough.    
I often forget the name `loaded_docs`. `vDocs` is a better name. It aligns with `Init`.    
There should be no need to call `vDocs`. if `vInit` is called without arguments a dialog shall open, showing the loaded docs, additionally there should be a button to trigger a file picker to open a Visio file that is not yet loaded.    
As I often work with templates instead of drawings, handling vstx and vstm should be added to the scope.
stoneforge 0.2.0b3
Geophysics equations, algorithms and methods
Requires Python: >=3.10

<p align="center">
<img src="https://raw.githubusercontent.com/giecaruff/logos/main/APPY/stoneforge.png" width="400"/>

<h2 align="center">Algorithms, methods and equations for geophysics in Python</h2>

<p align="center">
Part of the <strong>Appy</strong> project
</p>



<p align="center">
<a href="https://giecaruff.github.io/stoneforge/"><strong>Documentation</strong> (latest)</a> |
<a href="http://gcr.sites.uff.br/"><strong>Institutional</strong> (GIECAR website)</a> 
</p>


<p align="center">
<a href="https://github.com/giecaruff/stoneforge/actions"><img src="https://github.com/giecaruff/stoneforge/actions/workflows/CI.yml/badge.svg" alt="Latest version on PyPI"/></a>
<a href="https://badge.fury.io/py/stoneforge"><img src="https://badge.fury.io/py/stoneforge.svg" alt="PyPI version" height="20"></a>
</p>
  
<!-- 
[![https://github.com/giecaruff/stoneforge/actions](https://github.com/giecaruff/stoneforge/actions/workflows/CI.yml/badge.svg)](https://github.com/giecaruff/stoneforge/actions)
-->

  
## About

The Stoneforge library is linked to the GIECAR laboratory at the Universidade Federal Fluminense (UFF) related to the Geology and Geophysics Departmnet <a href="http://geologiaegeofisica.sites.uff.br/"> (GGO)</a>, and its purpose is to teach and develop routines in Python to solve geological and geophysical problems.


## Installation and first steps

To install stoneforge use the following syntax in your command interpreter environment:

```
$pip install stoneforge
```

and them verify the installation using the following command in Python:

```
>>> import stoneforge
```
  
## Dataset

The stoneforge dataset comprises the following data: 

Four .las data from wildcat wells in the National Petroleum Reserve in Alaska. Those where drilled in the National Petroleum Reserve in Alaska (NPRA). </br>
[USGS Well Index](https://pubs.usgs.gov/of/1999/ofr-99-0015/Wells/WellIdx.htm)

Two .dlis data from the Mississippi Fan (Gulf of Mexico) from the DSDP (Deep Sea Drilling Project); DSDP Leg 96 - Hole 616; Processed and Original data. </br>
[DSDP Leg 96 - Hole 616](https://mlp.ldeo.columbia.edu/data/dsdp/leg96/616/)

Zihlman, F. N creator ; Oliver, H. L ; Geological Survey (U.S.)
Reston, Va. : Denver, Colo : U.S. Dept. of the Interior, U.S. Geological Survey1999
nvidia-srl-usd-to-urdf 1.0.3
A tool to convert from USD to URDF.
Requires Python: >=3.8
Keywords: docker

# USD To URDF Converter

<h4>
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/">Homepage</a> (
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/getting_started.html">Getting Started</a> |
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/cli.html">CLI</a> |
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/examples.html">Examples</a> |
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/contributing.html">Contributing</a> |
    <a href="https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/api.html">API Reference</a> )
</h4>

A tool for converting USD files to URDF.

Convert this
![UR10 USD](docs/media/ur10_usd.png "Screenshot of UR10 USD"){height=500px}
to this
![UR10 URDF](docs/media/ur10_urdf.png "Screenshot of UR10 URDF"){height=500px}

See the [documentation](https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/) for detailed information.

## Quick Start

**Installation**

Use pip to install this Python distribution from the PYPI package registry (https://pypi.org/project/nvidia-srl-usd-to-urdf/).

```
pip install nvidia-srl-usd-to-urdf
```

**USD To URDF Command Line Interface (CLI)**

Use the `usd_to_urdf` CLI to convert USD files to URDF from the command line.

```
usd_to_urdf -o <path to output URDF file> <path to input USD file>
```

For example to convert the UR10 USD file in the current directory to URDF do the following.

```
usd_to_urdf -o ur10.urdf ur10.usd
```

For a quick reference on the on the CLI options see the help print out.
```
usd_to_urdf -h
```

**USD To URDF Python API**

Use the USD to URDF Python API to convert USD files to URDF using Python.

```python
from nvidia.srl.from_usd.to_urdf import UsdToURDF
UsdToUrdf.init_from_file("<path to USD file>").save_to_file("<path to URDF file>")
```

For example to convert the UR10 USD file in the current directory the URDF do the following.

```python
from nvidia.srl.from_usd.to_urdf import UsdToURDF
UsdToUrdf.init_from_file("ur10.usd").save_to_file("ur10.urdf")
```

Complete API reference can be found in the documentation [here](https://srl.gitlab-master-pages.nvidia.com/py/usd_to_urdf/api.html).
python-fast-grpc 0.3.4
Fast to Code gRPC in Python
Requires Python: >=3.9

# FastGRPC
🚀 Build gRPC services in Python 3.9+ as easily as FastAPI.

## Installation
Require Python 3.9+
```shell
pip install python-fast-grpc
```

## A Simple Example
Define a gRPC service:
```python
from pydantic import BaseModel
from fast_grpc import FastGRPC

app = FastGRPC()

class HelloRequest(BaseModel):
    name: str

class HelloReply(BaseModel):
    message: str

@app.unary_unary()
async def say_hello(request: HelloRequest) -> HelloReply:
    return HelloReply(message=f"Greeter SayHello {request.name}")

if __name__ == '__main__':
    app.run()
```
Client Test:
```python
import grpc
import fast_grpc_pb2 as pb2
import fast_grpc_pb2_grpc as pb2_grpc

channel = grpc.insecure_channel("127.0.0.1:50051")
stub = pb2_grpc.FastGRPCStub(channel)
response = stub.SayHello(pb2.HelloRequest(name="FastGRPC"))
print("Client received: ", response)
```
## Use Middleware
```python
@app.middleware()
async def middleware(call_next, request, context):
    print("before request")
    response = await call_next(request, context)
    print("after request")
    return response

@app.middleware(is_server_streaming=True)
async def middleware(call_next, request, context):
    print("before streaming request")
    async for response in call_next(request, context):
        yield response
    print("after streaming request")
```
## Service
Use Service for modular design, similar to FastAPI's router.
```python
from fast_grpc import Service
srv = Service(name="Greeter")

@srv.unary_unary()
async def say_again(request: HelloRequest) -> HelloReply:
    return HelloReply(message=f"Greeter SayHello {request.name}")
```
## Pb2Service
Use Pb2Service if you're working with generated *_pb2.py and *_pb2_grpc.py files.
```python
import greeter_pb2
import greeter_pb2_grpc
srv = Pb2Service("Greeter", pb2_module=greeter_pb2, pb2_grpc_module=greeter_pb2_grpc)

@srv.unary_unary()
async def say_again(request: HelloRequest) -> HelloReply:
    return HelloReply(message=f"Greeter SayHello {request.name}")
```
## Generate Clients Using Pydantic
Automatically generate a Pydantic-based gRPC client from .proto files:
```python
from fast_grpc.proto import proto_to_python_client
proto_to_python_client("fast_grpc.proto")
```
agi-tools 0.1.7
Biblioteca Python para integração com Spark, Data Lake, envio de e-mails corporativos via Microsoft Graph API e manipulação centralizada de configurações. Ideal para projetos de dados que exigem automação, controle de métricas e comunicação corporativa.
Requires Python: >=3.9

# AGI Tools

Biblioteca Python para facilitar operações de Data Lake, Spark, envio de e-mails corporativos e manipulação de configurações em projetos de dados.

## Funcionalidades

- **Spark Integration**: Criação, configuração e destruição de sessões Spark, inserção de dados em Data Lake, controle de métricas e checkpoints.
- **Mail**: Envio de e-mails via Microsoft Graph API, com suporte a múltiplos destinatários, CC, rodapé customizado e autenticação segura.
- **Configuração**: Carregamento centralizado de arquivos de configuração TOML, com tratamento de erros e timezone Brasil.
- **Teams**: Envio de mensagens para canais do Microsoft Teams via webhook, com personalização de cor, título e mensagem.

## Instalação

```bash
pip install agi-tools
```

## Uso Básico

### Spark

```python
from agi_tools.spark import AgiTools
agi = AgiTools()
spark = agi.create_spark_session('nome_da_sessao')
# ...processamento...
agi.insert_into_lake(
    data=spark.sql(query),
    write_mode='overwrite',
    partition_by='date_partition'
)
agi.destroy_spark_session()
```

### Envio de E-mail

```python
from agi_tools.mail import AgiMail
mail = AgiMail()
mail.send_email(
    subject="Assunto",
    mail_to=["destino@empresa.com"],
    html_body="<h1>Mensagem</h1>",
    mail_cc=["copia@empresa.com"]
)
```

### Teams

```python
from agi_tools.teams import AgiTeams
teams = AgiTeams()
teams.process_message(
    message_type='success',
    process_name='Processo de ETL'
)
# Ou envie uma mensagem personalizada:
teams.send_message(
    title='Alerta',
    color='#FF0000',
    message='Falha no processamento do ETL.'
)
```

### Configuração

```python
from agi_tools.tools import get_config
config = get_config('config')
```

### Semaphore

```python
from agi_tools.semaphore import AgiSemaphore
from agi_tools.spark import AgiTools

# Inicialização
agi = AgiTools()
spark = agi.create_spark_session('nome_da_sessao')
semaphore = AgiSemaphore(spark)

# put_semaphore: Atualiza o status do semáforo
semaphore.put_semaphore('nome_do_semaphore')

# get_last_updated: Retorna a data/hora da última atualização de uma tabela
ultima_atualizacao = semaphore.get_last_updated('database.tabela')

# get_semaphore: Lê o status do semáforo salvo em arquivo parquet
status = semaphore.get_semaphore('nome_do_semaphore')
print(status)
```

## Requisitos

- Python >= 3.9
- Spark (cluster ou local)
- Microsoft Graph API para envio de e-mails

## Licença

MIT
dio-simple-package-project 0.0.1
Example project for creating a simple package - DIO Course
Requires Python: >=3.8

# dio-simple-package-project

Description. 
O pacote **dio-simple-package-project** foi desenvolvido como parte do curso da [DIO](https://www.dio.me/).  
Ele serve de exemplo para criar, estruturar e publicar pacotes Python de forma simples.


## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install dio-simple-package-project

```bash
pip install dio-simple-package-project
```

## Usage

- **file1_name**
```python
from dio_simple_package_project import file1_name
file1_name.my_function()
```

- **file2_name**
```python
from dio_simple_package_project import file2_name
file2_name.my_function()
```

## Author
[Francisco Ricardo](https://github.com/fricardo-it)

## License
[MIT](https://choosealicense.com/licenses/mit/)