semvec/pypi-packages huggingface dataset:
ibm-gdsc-sdk-saas 1.0.0
IBM Guardium Data Security Center
Keywords: OpenAPI, OpenAPI-Generator, IBM Guardium Data Security Center

# IBM Guardium Data Security Center Python client

## Requirements.

Python 3.7+

## Installation & Usage
### pip install

If the python package is hosted on a repository, you can install directly using:

```sh
pip install ibm-gdsc-sdk-saas==1.0.0
```
(you may need to run `pip` with root permission: `sudo pip install ibm-gdsc-sdk-saas==1.0.0`)

Then import the package:
```python
import ibm_gdsc_sdk_saas
```
## Getting Started

Please follow the [installation procedure](https://github.com/IBM/gdsc-sdk) and then run the following:

```python

import os
import ibm_gdsc_sdk_saas
from ibm_gdsc_sdk_saas.models.tenantuserv3_get_users_response import Tenantuserv3GetUsersResponse
from ibm_gdsc_sdk_saas.rest import ApiException
from pprint import pprint



# Configure HTTP basic authorization: BasicAuth
configuration = ibm_gdsc_sdk_saas.Configuration(
    host = os.environ['URL'],
    username = os.environ['API_USERNAME'],
    password = os.environ['API_PASSWORD']
)

# Configure API key authorization: ApiKeyAuth
#configuration.api_key['ApiKeyAuth'] = os.environ['API_KEY']
configuration.verify_ssl = False
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#configuration.api_key_prefix['ApiKeyAuth'] = "Basic"
# Enter a context with an instance of the API client

with ibm_gdsc_sdk_saas.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = ibm_gdsc_sdk_saas.JumpboxServiceApi(api_client)
    uid = '' # str | Email. (optional)

    try:
        # Summary: Get users Description: Get all users base on a tenantID.
        api_response = api_instance.jumpbox_service_get_users(uid=uid)
        print("The response of JumpboxServiceApi->jumpbox_service_get_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JumpboxServiceApi->jumpbox_service_get_users: %s\n" % e)

```
eip712 0.3.3
eip712: Message classes for typed structured data hashing and signing in Ethereum
Requires Python: <4,>=3.10

# Quick Start

Message classes for typed structured data hashing and signing in Ethereum.
See [EIP-712](https://eips.ethereum.org/EIPS/eip-712) for details.

## Dependencies

- [python3](https://www.python.org/downloads) version 3.10 up to 3.14.

## Installation

### via `pip`

You can install the latest release via [`pip`](https://pypi.org/project/pip/):

```bash
pip install eip712
```

### via `uv`

You can clone the repository and use [`uv`](https://docs.astral.sh/uv) for the most up-to-date version:

```bash
git clone https://github.com/ApeWorX/eip712.git
cd eip712
uv sync --group dev
```

## Quick Usage

Define EIP-712 models:

```python
from eip712.messages import EIP712Message

# NOTE: It is **highly** recommended to use ABI types from this library
from eth_pydantic_types import abi

from pydantic import BaseModel


# You can define your inner nested types using normal Pydantic models
class Person(EIP712Type):
    # Define fields using types from the `abi` module
    name: abi.string
    wallet: abi.address


# All valid EIP712 Message Structs **must** subclass `EIP712Message`
class Mail(EIP712Message):
    #  to define your EIP712 domain configuration
    eip712_domain = EIP712Domain(
        name="Ether Mail",
        version="1",
        verifyingContract="0xDDdDddDdDdddDDddDDddDDDDdDdDDdDDdDDDDDDd",
        chainId=1,
    )

    # Struct fields (can be "basic" types, `BaseModel` types, or arrays of either)
    sender: Person
    # Dynamic array support is as easy as using `list` with the corresponding type
    receivers: list[Person]
    ttl: abi.uint256
```

Then initialize these models:

```python
sender = Person(name="Alice", wallet="0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa")
receivers = [
    Person(name="Bob", wallet="0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"),
    Person(name="Charlie", wallet="0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"),
]
mail = Mail(sender=sender, receiver=receiver)
```

Finally, you can sign these messages using `eth-account`:

```python
from eth_account import Account

acct = Account.from_key(private_key)
sig = acct.sign_message(mail.signable_message)
```

or natively in [Ape](https://docs.apeworx.io/ape):

```python
# `ape console`
me = accounts.load(me)
sig = me.sign_message(mail)
```
arcane-bigquery-storage 1.2.2
A package to use the BigQuery Storage Write API
Requires Python: <4.0,>=3.9

# Arcane bigquery-storage README

A package to call the BigQuery Storage Write API. To have more info check https://cloud.google.com/bigquery/docs/write-api
This API uses the protocol buffers for serialization and deserialization. You can find the protobuf definitions in the `proto` folder.
More information on protobuf https://protobuf.dev/getting-started/pythontutorial/

## Using the compiler

### Install the compiler
To compile a protocol buffer, you will to have the compiler install.
Check this page to see the latest version https://protobuf.dev/downloads/.
It is important to check the version of the compiler and the version of the protobuf definitions. They must be compatible.
Check https://protobuf.dev/support/version-support/#python for the compatibility matrix.
At the time of writing, the protoc version is 21.12 and the protobuf version is 3.20.3.

Download the binary for the Mac OS. The name is something like `protoc-21.12-osx-universal_binary.zip`. Run this command in your Downloads folder:
```
PB_REL="https://github.com/protocolbuffers/protobuf/releases"
curl -LO $PB_REL/download/v21.12/protoc-21.12-osx-universal_binary.zip
```
Unzip the file and copy the `protoc` binary to `/usr/local/bin` : `sudo mv ~/Downloads/protoc-21.12-osx-universal_binary/bin/protoc /usr/local/bin/`
Finally copy the include folder `sudo cp -r ~/Downloads/protoc-21.12-osx-universal_binary/include/* /usr/local/include`
Verify that the compiler is installed by running `protoc --version`

### Running the compiler
In the arcane/bigquery-storage/proto/ folder, you will find the protobuf definitions.
To compile a file, run the following command `protoc -I. -I/usr/local/include --python_out=. --pyi_out=. <file>.proto`
It generates a python file with the same name as the proto file. You can now commit it and create a new version of this package.

## Release history
To see changes, please see CHANGELOG.md