semvec/pypi-packages huggingface dataset:
ionq 0.0.0a15
A Python library for interacting with IonQ's quantum computing API
Requires Python: <3.13,>=3.9

# IonQ SDK

The IonQ SDK provides tools for interacting with the IonQ platform, enabling users to manage backends, jobs, and quantum circuits programmatically.

## Features

- **Backend Management**: Access and manage quantum computers.
- **Job Management**: Submit, manage, and retrieve quantum jobs.
- **Quantum Circuit Design**: Build and manipulate quantum circuits for execution (not a focus of this SDK).

## Installation

This SDK requires Python 3.9 or later. Below are the steps to install and set it up using a virtual environment and Poetry.

### Prerequisites

Ensure you have Python and Poetry installed. Poetry is a tool for dependency management and packaging in Python. To install Poetry, you can use the following command:

```bash
curl -sSL https://install.python-poetry.org | python3 -
```

### Installing the SDK

To install the SDK, clone the repository, create a virtual environment, and install the dependencies using Poetry:

```bash
# Clone the repository
git clone https://github.com/ionq/python-ionq.git
cd python-ionq

# Create a virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

# Install dependencies using Poetry
pip install poetry
poetry install

# Optional: Install with extras for development
poetry install -E all
```

## Quick Start

Here is a quick example to get you started with the IonQ SDK.

### Initialize the SDK

First, set up your API key and initialize the Backend object:

```python
from ionq import Backend

backend = Backend(api_key='your_api_key_here')
```

### List Available Backends

You can list the available backends like this:

```python
backends = backend.get_backends()
print(backends)
```

### Create and Submit a Job

To create a circuit and submit a job:

```python
from ionq import Circuit, Job

circuit = Circuit(2)
circuit.h(0)
circuit.cx(0, 1)

job = Job(api_key='your_api_key_here')
job_details = job.create_job(circuit=circuit)
print(job_details)
```

### Retrieve Job Results

To check the results of a submitted job:

```python
results = job.get_job_results(job_id='your_job_id_here')
print(results)
```

## Documentation

For more detailed information and API specifications, please refer to the [official documentation](https://docs.ionq.com/api-reference/).

## Contributing

Contributions are welcome! Please read our contributing guidelines to get started.
pyrsfnfile 0.0.1
Wrapper da biblioteca para criptografia de arquivos que trafegam na RSFN
Requires Python: <4,>=3.14

# py RSFN File

Wrapper da biblioteca para criptografia de arquivos que trafegam na RSFN.

Exemplo de uso:

```python
from pathlib import Path

import pyrsfnfile

part_a_cert = Path('part-a.crt').read_bytes()
part_a_key = Path('part-a.key').read_bytes()
part_b_cert = Path('part-b.crt').read_bytes()
part_b_key = Path('part-b.key').read_bytes()

msg = b'Test 123'

encrypt_params = pyrsfnfile.EncryptParams()
encrypted_msg = pyrsfnfile.encrypt(part_a_cert, part_a_key, part_b_cert, encrypt_params, msg)
print(encrypted_msg)

print()

decrypt_params = pyrsfnfile.DecryptParams()
decrypted_msg = pyrsfnfile.decrypt(part_a_cert, part_b_cert, part_b_key, decrypt_params, encrypted_msg)
print(decrypted_msg)
```
uscis-opts 0.2.7
A python module to simplify RSA Archer API calls.
Requires Python: >=3.7

# Archer API

For more information on the Archer platform, please visit [this help page](https://help.archerirm.cloud/platform_611/en-us/content/platform/integration/int_api_basics.htm).

The Archer platform has 3 main APIs that can be queried using system provided
credentials.

1) [Web Services API](https://help.archerirm.cloud/platform_611/en-us/content/api/webapi/webhelplanding.htm)
2) [RESTful](https://help.archerirm.cloud/platform_611/en-us/content/api/restapi/webhelplanding.htm)
3) [Content API](https://help.archerirm.cloud/platform_611/en-us/content/api/contentapi/contentapi_overview.htm)

The Web Services API is currently used to pull reports created by a user in the
Archer graphical environment. Please see the [SearchOptions guidlines](https://help.archerirm.cloud/platform_611/en-us/content/api/webapi/xml_formatting_guidelines_for_5.x_search_input.htm)
if you would like to call ArcherServerClient.exec_search with custom options.

The RESTful API is currently used to pull history log data. The RESTful API
requires a contents id to make queries. These ids will be colletively
reffered to as an ArcherServerClient instance's context.

This module provides 2 main classes:

- ArcherAuth
- ArcherClient

## Important Note on Session Maintainence

The ArcherAuth class starts and maintains the session created with the user's
credentials. Session authentication is handled through session tokens. Token are
only valid as long as they are generated from the most recent signing. A new
signing event will invalidate any previously generated token. If you have a need
to access the API and/or UI simultaneously, separate credentials must be used or
you risk invalidating your previous session.

## Important Note on API Availability

The ArcherClient classes are responsible for making the various API
calls and returning data to the user. An instance will have access to data
provisioned to the user. These provisions are made by the Archer system admin
and linked to the credentials used for signing. Please make sure your account
has the necessary provisions before calling ArcherAuth.login().
json-to-func 0.1.0
Convert JSON keys to callable Python methods
Requires Python: >=3.9

# JSON to Func

A Python library that converts JSON keys to callable methods on a class.

## Installation

```bash
pip install json-to-func
```

## Usage

### Basic Usage

```python
from json_to_func import JsonToFunc, load

# Load from a JSON file
translator = JsonToFunc("messages.json")

# Or use the convenience function
translator = load("messages.json")

# Or load from a dictionary
translator = JsonToFunc({
    "hello": "Hello, World!",
    "greeting": "Hello, %s!"
})
```

### Calling Methods

JSON keys are automatically transformed into valid Python method names:

```python
# Simple key
translator.hello()  # Returns: "Hello, World!"

# With placeholder
translator.greeting("John")  # Returns: "Hello, John!"
```

### Key Transformation Rules

| Original Key | Method Name |
|-------------|-------------|
| `tomans` | `tomans()` |
| `field-required` | `field_required()` |
| `hint:title` | `hint__title()` |
| `hint-bar:text:message` | `hint_bar__text__message()` |

**Rules:**
- Dashes (`-`) become single underscores (`_`)
- Colons (`:`) become double underscores (`__`)
- Other invalid characters become underscores
- Keys starting with numbers get a leading underscore

### Format String Support

The library supports `%s` placeholders in values:

```python
data = {
    "field-required": "%s is required",
    "range-error": "Value must be between %s and %s"
}

translator = JsonToFunc(data)

translator.field_required("Email")  # "Email is required"
translator.range_error("1", "10")   # "Value must be between 1 and 10"
```

### Alternative Access Methods

```python
# Get by original key name
translator.get("field-required", "Email")

# Get by transformed function name
translator.get_by_func_name("field_required", "Email")

# With default value
translator.get("nonexistent", default="fallback")
```

### Utility Methods

```python
# List all original keys
translator.keys()  # ["hello", "field-required", ...]

# List all method names
translator.func_names()  # ["hello", "field_required", ...]

# Check if key exists
"hello" in translator  # True
"field_required" in translator  # True

# Get count
len(translator)  # Number of entries
```

## Example with i18n/Translation Files

```json
{
  "tomans": "تومان",
  "field-required": "%s الزامی است",
  "entity-not-exists": "چنین %s وجود ندارد",
  "hint-bar:title:welcome": "خوش آمدید"
}
```

```python
from json_to_func import JsonToFunc

messages = JsonToFunc("fa.json")

print(messages.tomans())  # تومان
print(messages.field_required("ایمیل"))  # ایمیل الزامی است
print(messages.entity_not_exists("کاربر"))  # چنین کاربر وجود ندارد
print(messages.hint_bar__title__welcome())  # خوش آمدید
```

## License

MIT
plush-fabric 1.1.3
Helper library for Fabric to simplify creating and managing GitHub deploy keys when deploying GitHub-hosted repositories
Requires Python: >=3.12
Keywords: Fabric, GitHub, deployment

Plush
==============

A helper library for [Fabric](https://www.fabfile.org) to simplify creating and managing GitHub deploy keys when deploying your GitHub-hosted
repository. Currently, Plush is only tested on Ubuntu 24.04 LTS.

Plush aims to make deployments easier by:
- Using OAuth flows to securely connect to the GitHub API on your behalf
(while supporting 2 factor auth and never handling your username/password)
- Generating SSH deploy keys on your target server/computer
- Registering these deploy keys with your GitHub repo programmatically
- Configuring your new clone to use the appropriate deploy key while not conflicting with other 
SSH keys used elsewhere on your server
- ACL'ing these keys so they can be reused by people to fetch/deploy on your behalf
(and not readable by anyone else on the server)
- Example PowerShell scripts are provided that give tab completion around fab.exe

To see this project in action, follow the directions in Setup-Dev-Environment.md. You will need access to an Ubuntu 24.04 machine (ideally a VM).

## Usage

This project is intended to be used by projects that use or are considering [Fabric](https://www.fabfile.org) for their deployments. Plush versions 1.0 and greater expect Fabric 3.2.2 and greater. In a project that uses Fabric, install Plush by running:

```
pip install plush-fabric
```

To get started, see the fabfile.py in this repo for a minimal usage of Plush. For a more complete example, see my [BaseDjangoAngular template](https://github.com/kbarnes3/BaseDjangoAngular).