semvec/pypi-packages huggingface dataset:
virtosecure 0.1
An advanced encryption/decryption and VIRTO-1024 hashing package
Requires Python: >=3.6

# Virtosecure

Virtosecure is a Python package that provides robust encryption and hashing functionalities. It allows for the secure encryption and decryption of data using a customizable character set and implements a unique 1024-bit hashing function.

## Features

- **Encryption & Decryption**: Encrypt and decrypt strings with a repeating key.
- **Custom Character Set**: Use an expanded character set for enhanced security.
- **VIRTO1024 Hashing**: Generate a 1024-bit hash of data using a deterministic method.

## Installation

You can install the `virtosecure` package via PyPI:

```bash
pip install virtosecure
```
medify 0.1
A package for medical scribing using AWS Transcribe for the healthcare domain

# HealthScribe

A Python package for medical scribing using AWS Transcribe Medical service.

## Overview

HealthScribe is a package focused on the healthcare domain. It enables medical scribing by transcribing audio files (e.g., doctor-patient conversations) using AWS Transcribe Medical service. The package uploads the provided audio file to an S3 bucket, starts a transcription job, and retrieves a summary from the job's JSON output.

## Installation

```sh
 pip install medify
```
## Usage

You can use the command-line interface:

```bash
healthscribe-cli <audio_file> <job_name> <data_access_role_arn> <s3_bucket> 
```

For example:

```bash
healthscribe-cli conversation.wav myJob arn:aws:iam::aws_accountid:role/your-role my-s3-bucket s3-key
```

You can use this in python script: 
```sh 
import os
import medify

# Set the environment variables for the AWS SDK
os.environ['AWS_ACCESS_KEY_ID'] = aws_access_key_id
os.environ['AWS_SECRET_ACCESS_KEY'] = aws_secret_access_key
os.environ['AWS_REGION'] = aws_region

# Call the function with sensitive information masked
summary = medify.healthscribe(
    audio_file="/path/to/audio.mp3",
    job_name="job_name",
    data_access_role_arn="arn:aws:iam::accountid:role/your-role",
    s3_bucket="s3_bucket"
)

print(summary)
```


## License

This project is licensed under the MIT License.
grpc-svcs 0.1.2
A gRPC integration for SVCS
Requires Python: >=3.11

# grpc-svcs: A gRPC integration for SVCS

Very in-development

## Installation
```shell
pip install grpc-svcs
```

## Usage
```python
import grpc_svcs
import svcs

registry = svcs.Registry()
# Register services
registry.register_value(MyType, MyType())

# Attach a `SVCSInterceptor` when creating server.
server = grpc.server(intercepters=[grpc_svcs.SVCSInterceptor(registry)])

# Attach a `SVCSAsyncIntercept` when creating an async server.
server = grpc.aio.server(intercepters=[grpc_svcs.SVCSAsyncInterceptor(registry)])

# Retrieve container inside a servicer
class Greeter(helloworld_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        # call svcs_from
        container = grpc_svcs.svcs_from()
        # get items from svcs
        my_type = container.get(MyType)

        return helloworld_pb2.HelloReply(message="Hello, %s!" % request.name)
gsheet-manager 0.4.0
A Google Sheets manager for Python
Requires Python: >=3.6

# GSheetManager

GSheetManager is a Python package that provides a convenient interface for managing Google Sheets. It offers features like batch updates, local caching, and automatic worksheet refreshing to optimize interactions with Google Sheets.

## Installation

You can install GSheetManager using pip:

```
pip install gsheet-manager
```

## Requirements

- Python 3.6+
- gspread library

## Usage

Here's a basic example of how to use GSheetManager:

```python
from gsheet_manager import GSheetManager

class MySheetManager(GSheetManager):
    @GSheetManager.batch_sync_with_remote
    def update_sales_data(self, product, quantity, price):
        # Find the row for the product
        product_column = 0
        quantity_column = 1
        price_column = 2
        total_column = 3

        for row, row_data in enumerate(self.local_sheet_values):
            if row_data[product_column] == product:
                # Update quantity
                self._set_buffer_cells(row, quantity_column, quantity)
                
                # Update price
                self._set_buffer_cells(row, price_column, price)
                
                # Calculate and update total
                total = quantity * price
                self._set_buffer_cells(row, total_column, total)
                
                print(f"Updated {product}: Quantity={quantity}, Price=${price}, Total=${total}")
                return

        # If product not found, add a new row
        new_row = len(self.local_sheet_values)
        self._set_buffer_cells(new_row, product_column, product)
        self._set_buffer_cells(new_row, quantity_column, quantity)
        self._set_buffer_cells(new_row, price_column, price)
        self._set_buffer_cells(new_row, total_column, quantity * price)
        print(f"Added new product {product}: Quantity={quantity}, Price=${price}, Total=${quantity * price}")

# Usage
manager = MySheetManager('path/to/key_file.json', 'Sales Sheet', 'Product Data')
manager.update_sales_data('Widget A', 100, 19.99)
manager.update_sales_data('Gadget B', 50, 24.99)
```

## Features

- Batch updates to minimize API calls
- Local caching of sheet values
- Automatic worksheet refreshing
- Decorator for syncing operations with remote

## API Reference

### GSheetManager(key_file, doc_name, sheet_name)

Creates a new GSheetManager instance.

- `key_file`: Path to your Google Service Account key file
- `doc_name`: Name of your Google Sheet
- `sheet_name`: Name of the worksheet

### Methods

- `refresh_worksheet()`: Refreshes the worksheet if the timeout has passed
- `sync_from_remote()`: Syncs local values from the remote sheet
- `batch_update_remote()`: Sends batched updates to the remote sheet
- `_set_buffer_cells(python_row_idx, python_col_idx, value)`: Sets a value in the local buffer

### Decorators

- `@batch_sync_with_remote`: Decorator for methods that need to sync with the remote sheet

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.