semvec/pypi-packages huggingface dataset:
pydal-libsql 0.2.0
Custom pyDAL adapter for libsql (distributed SQLite)
Requires Python: >=3.10

# libSQL for pyDAL

Basic driver/adapter for using libSQL/sqld (Turso) with pyDAL.

More info:

- [pydal](https://github.com/web2py/pydal/)
- [libsql](https://github.com/tursodatabase/libsql)
- [libsql-client](https://github.com/tursodatabase/libsql-client-py)
- [sqld](https://github.com/tursodatabase/libsql/blob/main/docs/DESIGN.md)
- [Turso](https://docs.turso.tech/introduction)

## Examples:

### Basic Usage with a SQLite compatible Database

```python
from pydal import DAL
# import is required to set up libsql:// and sqld:// for pyDAL
import pydal_libsql

# Connecting to a libSQL/SQLite database
db = DAL("libsql://example.db")

# example pydal operations:

# Defining a 'person' table with some fields
db.define_table(
    "person",
    db.Field("name", "string"),
    db.Field("age", "integer"),
    db.Field("last_name", "string")
)

# Committing the changes to the database
db.commit()

# Inserting a record into the 'person' table
db.person.insert(name="Henk", age=33)

# Retrieving and printing the inserted record
print(db(db.person.name == "Henk").select().as_list())
```

### Connecting to a SQLd Server

```python
from pydal import DAL
# import is required to set up libsql:// and sqld:// for pyDAL:
import pydal_libsql

# Connect to a SQLd server running on localhost:8080
db = DAL("sqld://localhost:8080")

# ...
```

### Using Turso's SQL Service

```python
from dotenv import dotenv_values
from pydal import DAL
# import is required to set up libsql:// and sqld:// for pyDAL:
import pydal_libsql

# Load Turso credentials from .env file or replace with your values directly
env = dotenv_values()
uri = env.get("TURSO_DATABASE_URL")  # Example: "libsql://your-database-name.turso.io"
token = env.get("TURSO_AUTH_TOKEN")  # Example: "ey****"

# Set up the database connection with Turso's URI and authentication token
db = DAL(uri, driver_args={"auth_token": token})

# ...
```

### Disclaimer

This project is an unofficial tool and is not affiliated, endorsed, or sponsored by the maintainers of pyDAL or Turso.
All references to pyDAL and Turso are for compatibility and integration purposes only.
NetDiagnose 1.0.1
A network diagnostic assistant
Requires Python: >=3.6

# NetDiagnose

A comprehensive network diagnostic tool for both Linux and Windows platforms, designed to test and analyze various network components, including:

- Ping test
- DNS lookup
- Traceroute
- Speed test
- Network interfaces information
- Wireless network analysis
- Port scanning
- Network security checks

## Features

- **Ping Test**: Test the connectivity to a given destination.
- **DNS Lookup**: Resolve domain names to IP addresses.
- **Traceroute**: Trace the route packets take to a destination.
- **Network Speed Test**: Measure your internet's download and upload speeds.
- **Network Interface Info**: Get details about your network interfaces, including IP address, MAC address, and status.
- **Wireless Network Analysis**: Analyze Wi-Fi signal strength, interfaces, and more (Linux-specific).
- **Port Scan**: Scan open ports on a given host (Linux and Windows support).
- **Network Security Check**: Scan for potential vulnerabilities in the network configuration.
- **Generate and Save a Report**: Ability to Scan and save a report of all test to your device or email the report to yourself.
## Installation

To get started with the network diagnostic tool, follow the installation steps below:

1. **Clone the repository**:
    ```bash
    git clone https://github.com/gentlsnek/NetDiagnose
    cd NetDiagnose
    ```

2. **Create a virtual environment** (optional but recommended):
    ```bash
    python3 -m venv venv
    source venv/bin/activate   # On Windows: venv\Scripts\activate
    ```

3. **Install dependencies**:
    ```bash
    pip install -r requirements.txt
    ```

## Usage
```bash
    NetDiagnose
    ```

### Running the Tool

## **Change Logs**
- as of v 0.2.0 we got a gui to work with.
libwebarena 0.0.4
This is an unofficial, use-at-your-own risks port of the webarena benchmark, for use as a standalone library package.
Requires Python: <4,>=3.7

**Warning: use at your own risks!**

Unofficial [WebArena](https://github.com/web-arena-x/webarena) port for compatibility with [BrowserGym](https://github.com/ServiceNow/BrowserGym). Changes below.

More flexible/recent dependencies
 - playwright>=1.32,<1.40
 - openai>=1
 - transformers

Packaging into a single Python namespace
```bash
pip install libwebarena
```

```python
import webarena
import webarena.browser_env
import webarena.agent
import webarena.evaluation_harness
import webarena.llms
import webarena.llms.providers
```

Making `HTMLContentEvaluator` idempotent (`validate()` should not alter the browser's state)
awsecsconnect 0.0.6
Utility for more easily starting a shell on an AWS ECS Container
Requires Python: >=3.11

# awsecsconnect

https://www.notion.so/Start-a-shell-on-any-backend-container-121a349afecb803ebc33ed4d81abd953?pvs=4

Tired of typing a series of `aws` cli commands to get the arns and container name I need, when trying
to just open up a shell in that container.  

Usage: `awsecsconnect`

Dependencies: This assumes that you have AWS Profile environment variables set up already, and that you can
execute the aws cli using `aws`.  

## Notes
- This uses boto3 to get most of the details, but ultimately still depends on having the AWS CLI installed,
  because the execution of an interactive shell is a whole client unto itself.
- This package is published publicly to PYPI so that it can be conveniently installed with pip. Ultimately,
  this is not an open source project and not publicly maintained or documented (yet?).  I've registered
  this in pypi under my personal account just to keep SV1 names out of the picture. You don't REALLY need
  pypi to use this - you can just run it directly from the source - but a global package is very convenient. 

# Install
The latest tested build is available via pip:  `pip install --upgrade awsecsconnect`. 

# Build
`python -m build` will create builds in ./dist/

# Publish
Using twine with an api key, publish a new specific to pypi:
`twine upload --repository pypi dist/awsecsconnect-0.0.4*`

The build number is in the project file, and needs to be updated to create a valid downloadable pypi build.
hcp-vault-secrets-wrapper 0.7.5
A wrapper for handling HCP Vault Secrets on an app-by-app basis
Requires Python: >=3.6

# hcp-vault-secrets-wrapper
Simple HCP Vault Secrets Wrapper library

## Approach
- Simple HTTP client implementation in generic python

## Required Variables
- **Client ID** and **Client Secret**: each application requires a unique client ID and secret.  Keep these values secret.
- Client Org, App and Project IDs, which can be fetched from the secrets fetching URL provided by HCP:
  - Example:
`https://api.cloud.hashicorp.com/secrets/2023-11-28/organizations/XXXX/projects/YYYY/apps/ZZZZ/secrets:open`
    - XXXX is the organization ID (a UUID)
    - YYYY is the project ID (also a UUID)
    - ZZZZ is the application ID (should be human-readble)

## Implementation
- Use the following pattern to setup an HCP Vault connection for an application

```python
# Keep Secret
HCP_CLIENT_ID = getenv("HCP_CLIENT_ID") or None
HCP_CLIENT_SECRET = getenv("HCP_CLIENT_SECRET") or None

# Not Secret - get from HCP Vault app screen:
HCP_ORG_ID = getenv("HCP_ORG_ID") or None
HCP_PROJECT_ID = getenv("HCP_PROJECT_ID") or None
HCP_APP_ID = getenv("HCP_APP_ID") or None

# Setup secrets manage setup
secrets_mgr = HCPVaultClient(HCP_CLIENT_ID, HCP_CLIENT_SECRET, HCP_ORG_ID, HCP_PROJECT_ID, HCP_APP_ID)
# Fetch secrets
secrets_data = secrets_mgr.fetch_secrets() # Returns object with secrets from HCP
# Access static secrets:
some_secret = secrets_data["SOME_SECRET"]
# Access dynamic secrets and set environ variable 
from os import environ
environ["AWS_ACCESS_KEY_ID"] = secrets_data["SOME_SECRET_AWS"]["values"]["access_key_id"]
environ["AWS_SECRET_ACCESS_KEY"] = secrets_data["SOME_SECRET_AWS"]["values"]["secret_access_key"]
environ["AWS_SESSION_TOKEN"] = secrets_data["SOME_SECRET_AWS"]["values"]["session_token"]
```

## Refresh secrets
- The code contains two class variables that cache the secrets to avoid over-querying of secrets from HCP.
    - By default, secrets are cached for 25 minutes (or can be controlled by the `refresh_timeout_min` constructor variable)
- Call `fetch_secrets` to either pull new secrets (if we exceed the refresh timeout) OR return the last cached secrets.