strongDM SDK for Python

https://github.com/strongdm/strongdm-sdk-python
Admin
The official strongDM SDK for Python that enables programmatic access to the strongDM API for...
Tokens:39,026
Snippets:524
Trust Score:8.8
License:Apache-2.0
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install strongDM SDK

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/README.md

Install the strongDM SDK using pip. It's recommended to pin your dependency to a specific major version.

```bash
pip install strongdm
```

--------------------------------

### Verify strongDM SDK Installation

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

Verify the installation by importing the SDK and printing its version. It also includes a basic connection test using provided access and secret keys.

```python
import strongdm
print(strongdm.__version__)  # 17.8.0

# Test connection
client = strongdm.Client(access_key, secret_key)
print("Connected successfully")
client.close()
```

--------------------------------

### Account Management Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

A practical code example demonstrating account management operations. This could involve creating, retrieving, or updating user accounts.

```python
# This is a conceptual example based on the description of practical examples.
# Actual code would depend on the specific 'accounts' or 'users' service.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: Create a user
# new_user = client.create("users", {"email": "test@example.com", "first_name": "Test", "last_name": "User"})
# print(f"Created user: {new_user.id}")

```

--------------------------------

### Workflows and Approvals Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Shows how to interact with workflows and approval mechanisms. This is useful for managing access requests and ensuring compliance.

```python
# This is a conceptual example based on the description of practical examples.
# Actual code would depend on specific workflow/approval services.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: List pending approval requests
# # approvals = client.list("approval_requests", filter="status=pending")
# # for req in approvals:
# #     print(f"Request ID: {req.id} by {req.requester_id}")

```

--------------------------------

### Integrate Documentation

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Copy markdown files to your documentation system and start with INDEX.md for navigation. Cross-reference other documents as needed.

```bash
1. Copy all .md files to your documentation system
2. Start with INDEX.md for navigation
3. Cross-reference other documents as needed
4. All examples are copy-paste ready for Python 3.6+
```

--------------------------------

### Hello World: List Accounts

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/README.md

A basic example demonstrating how to initialize the strongDM client, list accounts, print their emails, and close the client connection. Requires API credentials to be set.

```python
import strongdm
import os

client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)

for account in client.accounts.list(''):
    print(account.email)

client.close()
```

--------------------------------

### Node Management Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Demonstrates operations related to managing nodes within the StrongDM infrastructure. This includes adding, viewing, or configuring nodes.

```python
# This is a conceptual example based on the description of practical examples.
# Actual code would depend on the 'nodes' service.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: List nodes
# nodes = client.list("nodes")
# for node in nodes:
#     print(f"Node: {node.name} ({node.id})")

```

--------------------------------

### Create Resources of Specific Types

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/08-resource-types.md

This example demonstrates how to create different types of resources (PostgreSQL, MySQL, SSH) by instantiating their respective SDK classes and then using the client's create method. Each resource type requires specific parameters like name, hostname, and port.

```python
# The SDK provides specific classes for each type
postgres = strongdm.Postgres(
    name="my-db",
    hostname="db.example.com",
    port=5432
)

mysql = strongdm.MySQL(
    name="analytics",
    hostname="mysql.example.com",
    port=3306
)

ssh = strongdm.SSH(
    name="bastion",
    hostname="ssh.example.com",
    port=22
)

created_postgres = client.resources.create(postgres)
created_mysql = client.resources.create(mysql)
created_ssh = client.resources.create(ssh)
```

--------------------------------

### Bulk Operations Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Demonstrates how to perform bulk operations, such as creating or deleting multiple resources simultaneously. This improves efficiency for large-scale management.

```python
# This is a conceptual example based on the description of practical examples.
# The SDK might offer specific methods for bulk operations or require iterating.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: Bulk creation (conceptual)
# # resources_to_create = [{"name": "db1"}, {"name": "db2"}]
# # created_resources = client.create_bulk("databases", resources_to_create)

```

--------------------------------

### Example: Checking SSO Provider Configuration

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/05-constants.md

Demonstrates how to retrieve an organization's details and print its configured SSO authentication provider using the AuthProvider constants. Ensure the strongdm client is initialized and the organization ID is correct.

```python
from strongdm.constants import AuthProvider

# Check organization's SSO configuration
org = client.organizations.get('org-id')
print(f"SSO Provider: {org.auth_provider}")
```

--------------------------------

### Example Usage of NodeState

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/05-constants.md

Iterates through nodes and prints their status using the NodeState.STARTED constant.

```python
from strongdm.constants import NodeState

for node in client.nodes.list(''):
    status = "ONLINE" if node.status == NodeState.STARTED else "OFFLINE"
    print(f"{node.name}: {status}")
```

--------------------------------

### Create Policy

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Creates a new access policy with a name, description, and a specific policy rule. This example shows how to enforce MFA for all access.

```python
policy = strongdm.Policy(
    name="require-mfa",
    description="All access requires MFA",
    policy="mfa_required == true"
)

created = client.policies.create(policy)
```

--------------------------------

### Role-Based Access Control (RBAC) Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Illustrates how to manage roles and permissions for access control. This is crucial for implementing fine-grained access policies.

```python
# This is a conceptual example based on the description of practical examples.
# Actual code would depend on the 'roles' and 'permissions' services.
# from strongdm import Client, Permission
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: Create a role with specific permissions
# new_role = client.create("roles", {"name": "Auditor", "description": "Read-only access", "permissions": [Permission.READ]})
# print(f"Created role: {new_role.id}")

```

--------------------------------

### Policies and Fine-Grained Access Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Illustrates how to define and manage policies for fine-grained access control. This allows for detailed configuration of user permissions.

```python
# This is a conceptual example based on the description of practical examples.
# Actual code would depend on the 'policies' service.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Example: Create a policy
# new_policy = client.create("policies", {"name": "RestrictDBAccess", "description": "Limit access to specific databases"})
# print(f"Created policy: {new_policy.id}")

```

--------------------------------

### Get a Specific Resource by ID

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Retrieve a single resource using its unique identifier.

```python
resource = client.resources.get("id")
```

--------------------------------

### Core Model Structure Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Illustrates the typical structure of a resource model in the strongDM SDK, including initialization, representation, and dictionary conversion methods. Properties are optional with default values.

```python
class Account:
    __slots__ = ['id', 'email', 'first_name', 'last_name', 'tags']
    
    def __init__(self, id=None, email=None, first_name=None, ...):
        self.id = id if id is not None else ''
        self.email = email if email is not None else ''
        # ...
    
    def __repr__(self):
        return '<sdm.Account id: ... email: ... >'
    
    def to_dict(self):
        return {'id': self.id, 'email': self.email, ...}
    
    @classmethod
    def from_dict(cls, d):
        return cls(id=d.get('id'), email=d.get('email'), ...)
```

--------------------------------

### Advanced Patterns Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Covers advanced usage patterns and techniques with the StrongDM SDK. This could include custom integrations or complex workflows.

```python
# This is a conceptual example based on the description of practical examples.
# Advanced patterns are highly use-case specific.
# Example: Implementing a custom resource sync mechanism.
# from strongdm import Client
# client = Client(config_path="/path/to/.strongdm")
# 
# # Fetch resources and compare with local state...

```

--------------------------------

### Enforce MFA Requirement with Policy

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/05-constants.md

Example of creating a StrongDM policy that enforces MFA for all access. This utilizes the `MFAProvider.NONE` implicitly by setting `mfa_required=True`.

```python
from strongdm.constants import MFAProvider

# Enforce MFA requirement
policy = strongdm.Policy(
    name="require-mfa",
    description="Requires MFA for all access",
    mfa_required=True
)
```

--------------------------------

### Example Usage of SCIMProvider

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/05-constants.md

Checks if an organization uses an external identity provider by comparing its scim_provider attribute with SCIMProvider.NONE.

```python
from strongdm.constants import SCIMProvider

# Check if organization uses external identity provider
org = client.organizations.get('org-id')
if org.scim_provider != SCIMProvider.NONE:
    print(f"Using {org.scim_provider} for identity management")
```

--------------------------------

### Filter Resources with Complex Queries

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Perform complex multi-condition filtering when listing resources. This example filters for healthy PostgreSQL and MySQL resources.

```python
# Complex multi-condition filter
for resource in client.resources.list(
    "healthy == true AND (type == ? OR type == ?)",
    "POSTGRES",
    "MYSQL"
):
    print(f"{resource.name} is healthy")
```

--------------------------------

### Unit Test Resource Manager

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

Write unit tests for resource management logic using `unittest` and `unittest.mock`. This example demonstrates mocking the strongDM client to test listing healthy databases and safe deletion of resources.

```python
# tests/test_resources.py
import unittest
from unittest.mock import Mock, patch
import strongdm
from services.resource_manager import ResourceManager

class TestResourceManager(unittest.TestCase):
    
    def setUp(self):
        self.mock_client = Mock(spec=strongdm.Client)
        self.manager = ResourceManager(self.mock_client)
    
    def test_list_healthy_databases(self):
        # Mock resource data
        mock_postgres = Mock()
        mock_postgres.name = "prod-db"
        mock_postgres.type = "POSTGRES"
        mock_postgres.healthy = True
        
        self.mock_client.resources.list.return_value = [mock_postgres]
        
        # Test
        databases = list(self.manager.list_healthy_databases())
        
        # Assert
        self.assertEqual(len(databases), 1)
        self.assertEqual(databases[0].name, "prod-db")
        self.mock_client.resources.list.assert_called_once()
    
    def test_delete_nonexistent_resource(self):
        # Mock not found error
        self.mock_client.resources.delete.side_effect = (
            strongdm.NotFoundError("Not found")
        )
        
        # Test
        result = self.manager.delete_resource_safe("missing-id")
        
        # Assert
        self.assertFalse(result)
```

--------------------------------

### Integration Test StrongDM Client

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

Perform integration tests against a live StrongDM environment using `unittest`. This example shows how to connect to the API using credentials and test listing accounts and resources.

```python
# tests/test_integration.py
import os
import unittest
import strongdm
from services.sdm_client import StrongDMClientService

class TestStrongDMIntegration(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        """Create real client for integration tests"""
        if not os.getenv("SDM_API_ACCESS_KEY"):
            raise unittest.SkipTest("No strongDM credentials")
        
        cls.service = StrongDMClientService()
        cls.client = cls.service.connect()
    
    @classmethod
    def tearDownClass(cls):
        """Close client"""
        cls.service.disconnect()
    
    def test_list_accounts(self):
        """Test listing accounts"""
        accounts = list(self.client.accounts.list(''))
        self.assertIsInstance(accounts, list)
    
    def test_list_resources(self):
        """Test listing resources"""
        resources = list(self.client.resources.list(''))
        self.assertIsInstance(resources, list)
```

--------------------------------

### Handle Authentication Errors

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

This example demonstrates how to catch and handle `AuthenticationError` exceptions when invalid credentials or signature issues occur. It prints the error message for debugging.

```python
import strongdm
from strongdm import errors

try:
    client = strongdm.Client("invalid-key", "invalid-secret")
    client.accounts.list('')
except errors.AuthenticationError as e:
    print(f"Auth failed: {e.msg}")
```

--------------------------------

### Ignore Credentials in Version Control

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Example .gitignore file content to prevent committing sensitive credential files or environment variables.

```bash
# .gitignore
.env
credentials.json
secrets/
```

--------------------------------

### Hello World: List User Accounts

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Initialize the strongDM client and list all user accounts. Ensure your API credentials are set as environment variables.

```python
import strongdm
import os

client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)

# List all user accounts
for account in client.accounts.list(''):
    print(f"{account.email}")

client.close()
```

--------------------------------

### Handling TimeoutError

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/02-errors.md

Demonstrates catching a TimeoutError for requests with a short deadline. This example sets a 100ms timeout for the accounts list operation.

```python
try:
    accounts = client.accounts.list('', timeout=0.1)  # 100ms timeout
except strongdm.TimeoutError:
    print("Request timed out")
```

--------------------------------

### Get Operation

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Retrieves a single resource by its unique identifier.

```APIDOC
## Get Operation

### Description
Retrieves a single resource by its unique identifier.

### Method
`get(id: str, timeout: float = None)`

### Parameters
#### Path Parameters
- **id** (str) - Required - Unique resource identifier

#### Query Parameters
- **timeout** (float) - Optional - Request timeout in seconds

### Returns
The requested resource

### Throws
- `NotFoundError`: Resource with given ID does not exist
- `AuthenticationError`: Invalid credentials
- `PermissionError`: Insufficient permissions

#### Example
```python
try:
    account = client.accounts.get("account-id-12345")
    print(account.email)
except strongdm.NotFoundError:
    print("Account not found")
```
```

--------------------------------

### Client Initialization and Configuration

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Demonstrates how to initialize the StrongDM client with configuration options. This is the first step for interacting with the StrongDM API.

```python
from strongdm import Client

client = Client(
    config_path="/path/to/.strongdm"
)

# Or, configure directly:
# client = Client(
#     api_key="YOUR_API_KEY",
#     api_hostname="YOUR_HOSTNAME",
#     api_port=8080,
#     api_token="YOUR_API_TOKEN",
#     timeout=10.0
# )

```

--------------------------------

### Find Production Resources by Name Pattern

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/09-filter-reference.md

Locate resources whose names start with 'prod-'. This uses a regular expression for pattern matching.

```python
prod_resources = client.resources.list("name ~ '^prod-'")
```

--------------------------------

### Replays Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Replay resources for listing and getting operations.

```APIDOC
## Service: replays

### Description
Provides access to Replay resources for listing and getting operations.

### Resource Type
Replay

### Operations
- list
- get
```

--------------------------------

### Secret Engines Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to SecretEngine resources for listing and getting operations.

```APIDOC
## Service: secret_engines

### Description
Provides access to SecretEngine resources for listing and getting operations.

### Resource Type
SecretEngine

### Operations
- list
- get
```

--------------------------------

### List Secret Stores

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

List available secret stores using the strongDM SDK. This example iterates through the stores and prints their name, type, and health status.

```python
# List available secret stores
for store in client.secret_stores.list(''):
    print(f"{store.name}: {store.type} (healthy={store.healthy})")
```

--------------------------------

### Organizations Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Organization resources for listing, getting, and updating operations.

```APIDOC
## Service: organizations

### Description
Provides access to Organization resources for listing, getting, and updating operations.

### Resource Type
Organization

### Operations
- list
- get
- update
```

--------------------------------

### Find Resources Created Within a Date Range

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/09-filter-reference.md

Filter resources based on their creation date, specifying a start and end date. Useful for analyzing resource lifecycle.

```python
resources = client.resources.list(
    "created >= ? AND created <= ?",
    "2024-01-01T00:00:00Z",
    "2024-01-31T23:59:59Z"
)
```

--------------------------------

### List Pending Access Requests

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

List pending access requests using a filter. This example shows how to iterate through requests and print their IDs and requesting accounts.

```python
# List pending access requests
for request in client.access_requests.list("status == ?", "approval_pending"):
    print(f"Request {request.id} from {request.account_id}")
```

--------------------------------

### Control Panel Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to ControlPanel resources for getting and updating operations.

```APIDOC
## Service: control_panel

### Description
Provides access to ControlPanel resources for getting and updating operations.

### Resource Type
ControlPanel

### Operations
- get
- update
```

--------------------------------

### Listing Resources with Filters

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Demonstrates how to list resources and apply filters for query operations. This is useful for retrieving specific sets of data based on criteria.

```python
from strongdm import Client

client = Client(config_path="/path/to/.strongdm")

# List resources with a filter
resources = client.list("some_resource", filter="name=my_service")
for resource in resources:
    print(resource.id)

```

--------------------------------

### Account Permissions Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to AccountPermission resources for listing and getting operations.

```APIDOC
## Service: account_permissions

### Description
Provides access to AccountPermission resources for listing and getting operations.

### Resource Type
AccountPermission

### Operations
- list
- get
```

--------------------------------

### Create a Role and Attach Account

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Create a new role and then attach an account to it. Requires a role name and an account ID.

```python
role = strongdm.Role(
    name="database-admins"
)
created = client.roles.create(role)

# Grant role to account
attachment = strongdm.AccountAttachment(
    role_id=created.id,
    account_id=account_id
)
client.account_attachments.create(attachment)
```

--------------------------------

### Workflows Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Workflow resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: workflows

### Description
Provides access to Workflow resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Workflow

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### ResourceType Enum Example

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Shows the structure of the ResourceType enum, which lists all supported connection types for resources within strongDM. This enum is used to identify the specific type of connection.

```python
class ResourceType(str, Enum):
    UNSPECIFIED = "RESOURCE_TYPE_UNSPECIFIED"
    AKS = "RESOURCE_TYPE_AKS"
    AZURE = "RESOURCE_TYPE_AZURE"
    AWS = "RESOURCE_TYPE_AWS"
    # ... 200+ resource types
```

--------------------------------

### List Resources with Python

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Lists all resources or filters them by type or health status. Ensure the client is initialized before use.

```python
# All resources
for resource in client.resources.list(''):
    print(f"{resource.name}: {resource.type}")

# Filter by type
postgres_dbs = client.resources.list("type == ?", "POSTGRES")

# Filter by health
healthy = client.resources.list("healthy == true")
```

--------------------------------

### Workflow Roles Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to WorkflowRole resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: workflow_roles

### Description
Provides access to WorkflowRole resources for listing, creating, getting, and deleting operations.

### Resource Type
WorkflowRole

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Workflow Approvers Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to WorkflowApprover resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: workflow_approvers

### Description
Provides access to WorkflowApprover resources for listing, creating, getting, and deleting operations.

### Resource Type
WorkflowApprover

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Initialize Client with Environment Variables

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Instantiate the strongDM client by reading API credentials from environment variables. This is the standard method for providing authentication details.

```python
import os
import strongdm

client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)
```

--------------------------------

### Resources Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Resource resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: resources

### Description
Provides access to Resource resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Resource

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Policies Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Policy resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: policies

### Description
Provides access to Policy resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Policy

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Initialize StrongDM Client

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Initialize the StrongDM client with your access key and secret key.

```python
client = strongdm.Client(access_key, secret_key)
```

--------------------------------

### Use StrongDM Client for Requests

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Demonstrates making requests using an initialized StrongDM client. Requests are sent on-demand as needed.

```python
# Requests are sent on-demand
for account in client.accounts.list(''):
    print(account.email)
```

--------------------------------

### Nodes Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Node resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: nodes

### Description
Provides access to Node resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Node

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Groups Roles Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to GroupRole resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: groups_roles

### Description
Provides access to GroupRole resources for listing, creating, getting, and deleting operations.

### Resource Type
GroupRole

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Integration and Deployment Patterns

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Discusses patterns for integrating and deploying the StrongDM SDK within applications. This includes considerations for production environments.

```python
# Integration examples would typically involve application-specific logic.
# A common pattern is to initialize the client once and reuse it throughout the application.
# from strongdm import Client
# 
# def get_strongdm_client():
#     return Client(config_path="/path/to/.strongdm")
# 
# # In another part of your application:
# # sdg_client = get_strongdm_client()
# # sdg_client.list("nodes")

```

--------------------------------

### Groups Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Group resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: groups

### Description
Provides access to Group resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Group

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Create an Account

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Instantiate and create a new account using the strongDM SDK. Requires an email, first name, and last name.

```python
account = strongdm.Account(
    email="user@example.com",
    first_name="John",
    last_name="Doe"
)
created = client.accounts.create(account)
print(f"Account ID: {created.id}")
```

--------------------------------

### Roles Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Role resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: roles

### Description
Provides access to Role resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Role

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Accounts Groups Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to AccountGroup resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: accounts_groups

### Description
Provides access to AccountGroup resources for listing, creating, getting, and deleting operations.

### Resource Type
AccountGroup

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Create a Policy

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Instantiate and create a new policy. Requires a name, description, and policy expression.

```python
policy = strongdm.Policy(
    name="mfa-required",
    description="Requires MFA for all access",
    policy="mfa.enabled == true"
)
created = client.policies.create(policy)
```

--------------------------------

### Accounts Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to Account resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: accounts

### Description
Provides access to Account resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
Account

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Create a Postgres Resource

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Instantiate and create a new Postgres resource. Requires name, hostname, port, and database name.

```python
postgres = strongdm.Postgres(
    name="prod-database",
    hostname="db.example.com",
    port=5432,
    database="myapp_db"
)
created = client.resources.create(postgres)
```

--------------------------------

### Account Grants Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to AccountGrant resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: account_grants

### Description
Provides access to AccountGrant resources for listing, creating, getting, and deleting operations.

### Resource Type
AccountGrant

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Account Attachments Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to AccountAttachment resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: account_attachments

### Description
Provides access to AccountAttachment resources for listing, creating, getting, and deleting operations.

### Resource Type
AccountAttachment

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Recommended Project Structure

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

A recommended project layout for applications integrating the strongDM SDK, organizing configuration, services, models, and main application files.

```text
my_app/
├── config/
│   ├── __init__.py
│   └── sdm_config.py          # strongDM configuration
├── services/
│   ├── __init__.py
│   ├── sdm_client.py          # Client initialization and helpers
│   └── resource_manager.py     # Resource management logic
├── models/
│   ├── __init__.py
│   └── schemas.py             # Data schemas
├── main.py
├── requirements.txt
└── .env                       # Environment variables (never commit)
```

--------------------------------

### Handling RateLimitError

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/02-errors.md

Example of how to catch and handle a RateLimitError when making API calls. The SDK can automatically retry if configured.

```python
try:
    for i in range(10000):
        client.accounts.list('')
except strongdm.RateLimitError as e:
    print(f"Rate limited: {e.msg}")
```

--------------------------------

### Secret Stores Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to SecretStore resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: secret_stores

### Description
Provides access to SecretStore resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
SecretStore

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Remote Identities Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to RemoteIdentity resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: remote_identities

### Description
Provides access to RemoteIdentity resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
RemoteIdentity

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Create Resource with Python

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Creates a new resource, such as a PostgreSQL database, by defining its properties and using the client's create method. The resource ID is returned upon successful creation.

```python
db = strongdm.Postgres(
    name="prod-database",
    hostname="db.example.com",
    port=5432,
    database="myapp"
)

created = client.resources.create(db)
print(f"Created: {created.id}")
```

--------------------------------

### Initialize SnapshotClient

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/01-client.md

The SnapshotClient is created by calling `Client.snapshot_at(snapshot_datetime)`. It cannot be instantiated directly.

```python
class SnapshotClient:
    def __init__(self, client: Client) -> None
```

--------------------------------

### Peering Groups Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to PeeringGroup resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: peering_groups

### Description
Provides access to PeeringGroup resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
PeeringGroup

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Peering Group Resources Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to PeeringGroupResource resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: peering_group_resources

### Description
Provides access to PeeringGroupResource resources for listing, creating, getting, and deleting operations.

### Resource Type
PeeringGroupResource

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Create New Account

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Creates a new user account with the provided email, first name, and last name. Prints the ID of the created user.

```python
new_user = strongdm.Account(
    email="newuser@example.com",
    first_name="John",
    last_name="Doe"
)

created = client.accounts.create(new_user)
print(f"Created user: {created.id}")
```

--------------------------------

### Create a Node

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Instantiate and create a new node. Requires a name and kind (e.g., 'gateway').

```python
node = strongdm.Node(
    name="us-west-gateway",
    kind="gateway"
)
created = client.nodes.create(node)
```

--------------------------------

### Peering Group Peers Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to PeeringGroupPeer resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: peering_group_peers

### Description
Provides access to PeeringGroupPeer resources for listing, creating, getting, and deleting operations.

### Resource Type
PeeringGroupPeer

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Peering Group Nodes Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to PeeringGroupNode resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: peering_group_nodes

### Description
Provides access to PeeringGroupNode resources for listing, creating, getting, and deleting operations.

### Resource Type
PeeringGroupNode

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Configure Logging with Dictionary

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

Set up detailed logging for the strongDM SDK using a Python dictionary configuration. This allows for custom formatting and routing logs to both the console and a file.

```python
# config/logging_config.py
import logging.config

LOGGING_CONFIG = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': {
        'default': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'standard',
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'sdm.log',
            'formatter': 'standard',
        },
    },
    'loggers': {
        'strongdm': {
            'handlers': ['default', 'file'],
            'level': 'INFO',
            'propagate': False
        },
        '': {
            'handlers': ['default', 'file'],
            'level': 'INFO',
        }
    }
}

logging.config.dictConfig(LOGGING_CONFIG)
```

--------------------------------

### Create a Workflow

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/04-models-resources.md

Instantiate and create a new workflow. Requires a name and description.

```python
workflow = strongdm.Workflow(
    name="prod-access-approval",
    description="Requires approval for production access"
)
created = client.workflows.create(workflow)
```

--------------------------------

### Identity Sets Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to IdentitySet resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: identity_sets

### Description
Provides access to IdentitySet resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
IdentitySet

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Configure Client with Connection Options

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Customize client behavior by specifying connection parameters such as host, security settings, retry logic, and pagination limits during initialization. The default production host is app.strongdm.com:443.

```python
import strongdm

client = strongdm.Client(
    api_access_key="your-key",
    api_secret="your-secret",
    host='app.strongdm.com:443',      # Default production host
    insecure=False,                    # Set to True for local/testing
    retry_rate_limit_errors=True,      # Auto-retry on rate limits
    page_limit=0                       # Pagination limit (0 = unlimited)
)
```

--------------------------------

### Identity Aliases Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to IdentityAlias resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: identity_aliases

### Description
Provides access to IdentityAlias resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
IdentityAlias

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Discovery Connectors Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to DiscoveryConnector resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: discovery_connectors

### Description
Provides access to DiscoveryConnector resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
DiscoveryConnector

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Client Constructor Parameters

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/01-client.md

Defines the parameters for initializing the strongDM Client, including authentication credentials, host, security settings, and retry configurations.

```python
class Client:
    def __init__(
        self,
        api_access_key: str,
        api_secret: str,
        host: str = 'app.strongdm.com:443',
        insecure: bool = False,
        retry_rate_limit_errors: bool = True,
        page_limit: int = 0
    ) -> None
```

--------------------------------

### Approval Workflows Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to ApprovalWorkflow resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: approval_workflows

### Description
Provides access to ApprovalWorkflow resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
ApprovalWorkflow

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### List All Resources

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Iterate through and print all available resources managed by StrongDM. An empty string as a filter lists all resources.

```python
for resource in client.resources.list(''):
    print(resource)
```

--------------------------------

### Using PermissionLevel in Account Creation

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/05-constants.md

Demonstrates how to assign a permission level when creating a new strongDM account object. Ensure the PermissionLevel constant is imported.

```python
from strongdm.constants import PermissionLevel

account = strongdm.Account(
    email="admin@example.com",
    first_name="Admin",
    permission_level=PermissionLevel.ADMIN
)
```

--------------------------------

### Approval Workflow Steps Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to ApprovalWorkflowStep resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: approval_workflow_steps

### Description
Provides access to ApprovalWorkflowStep resources for listing, creating, getting, and deleting operations.

### Resource Type
ApprovalWorkflowStep

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Initialize strongDM Client

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Initializes the strongDM client using API access key and secret key from environment variables. Ensure to close the client when done.

```python
import os
import strongdm

# Create client using environment variables
client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)

# Always close when done
try:
    # Use client
    pass
finally:
    client.close()
```

--------------------------------

### Approval Workflow Approvers Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to ApprovalWorkflowApprover resources for listing, creating, getting, and deleting operations.

```APIDOC
## Service: approval_workflow_approvers

### Description
Provides access to ApprovalWorkflowApprover resources for listing, creating, getting, and deleting operations.

### Resource Type
ApprovalWorkflowApprover

### Operations
- list
- create
- get
- delete
```

--------------------------------

### Create a Snapshot and Iterate Over Accounts

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Demonstrates how to create a read-only snapshot of data from a specific past timestamp and iterate through the accounts within that snapshot.

```python
snapshot = client.snapshot_at(datetime.now(timezone.utc) - timedelta(days=7))
for account in snapshot.accounts.list(''):
    pass  # Historical data from 7 days ago
```

--------------------------------

### Get Resource by ID

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Retrieves a single resource using its unique identifier. Handles NotFoundError, AuthenticationError, and PermissionError.

```python
try:
    account = client.accounts.get("account-id-12345")
    print(account.email)
except strongdm.NotFoundError:
    print("Account not found")
```

--------------------------------

### Create a Role

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Use this snippet to create a new role with a specified name and description.

```python
role = strongdm.Role(
    name="database-admins",
    description="Full database access"
)

created = client.roles.create(role)
print(f"Created role: {created.id}")
```

--------------------------------

### Initialize strongDM Client

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/01-client.md

Creates a new Client instance for interacting with the strongDM API. It's recommended to use environment variables for API keys.

```python
import strongdm
import os

# Create a client using environment variables
client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)
```

--------------------------------

### Client Constructor

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/01-client.md

Initializes a new Client instance for interacting with the strongDM API. It supports authentication via API access and secret keys, and offers configuration for host, security, retries, and pagination.

```APIDOC
## Client Constructor

### Description
Creates a new Client for interacting with the strongDM API.

### Method
__init__

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **api_access_key** (str) - Required - The access key for API authentication
- **api_secret** (str) - Required - The secret key for API authentication (base64-encoded)
- **host** (str) - Optional - The strongDM API server hostname and port. Defaults to 'app.strongdm.com:443'.
- **insecure** (bool) - Optional - If True, connects via unencrypted gRPC channel (insecure). Defaults to False.
- **retry_rate_limit_errors** (bool) - Optional - If True, automatically retries on rate limit errors. Defaults to True.
- **page_limit** (int) - Optional - Maximum number of items per page (0 means unlimited). Defaults to 0.

### Request Example
```python
import strongdm
import os

# Create a client using environment variables
client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)
```

### Response
#### Success Response (200)
None (constructor does not return a value)

#### Response Example
None
```

--------------------------------

### Remote Identity Groups Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to RemoteIdentityGroup resources for listing, creating, getting, updating, and deleting operations.

```APIDOC
## Service: remote_identity_groups

### Description
Provides access to RemoteIdentityGroup resources for listing, creating, getting, updating, and deleting operations.

### Resource Type
RemoteIdentityGroup

### Operations
- list
- create
- get
- update
- delete
```

--------------------------------

### Managed Secrets Service

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Provides access to ManagedSecret resources for listing, creating, getting, updating, deleting, and retrieving operations.

```APIDOC
## Service: managed_secrets

### Description
Provides access to ManagedSecret resources for listing, creating, getting, updating, deleting, and retrieving operations.

### Resource Type
ManagedSecret

### Operations
- list
- create
- get
- update
- delete
- retrieve
```

--------------------------------

### Test StrongDM Connection and List Accounts

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/10-integration-guide.md

Initialize the StrongDM client and perform a simple operation to test connectivity. Ensure the client is closed after use.

```python
# Test connectivity
try:
    client = strongdm.Client(access_key, secret_key)
    # Try simple operation
    accounts = list(client.accounts.list(''))
    print(f"Connected! Found {len(accounts)} accounts")
except Exception as e:
    print(f"Connection error: {e}")
finally:
    client.close()
```

--------------------------------

### Create MySQL Resource

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/07-examples.md

Creates a new MySQL resource configuration with specified connection details. Prints the ID of the created resource.

```python
mysql = strongdm.MySQL(
    name="analytics-db",
    hostname="mysql.example.com",
    port=3306,
    database="analytics",
    username="analytics_user"
)

created = client.resources.create(mysql)
```

--------------------------------

### Authenticate with Direct Credentials

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Configure authentication by directly providing your API key and hostname to the Client constructor.

```python
from strongdm import Client

client = Client(api_key="YOUR_API_KEY", api_hostname="YOUR_API_HOSTNAME")
```

--------------------------------

### Load Credentials using Python-Dotenv

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Load StrongDM API credentials from a .env file using the python-dotenv library and then initialize the StrongDM client.

```python
from dotenv import load_dotenv
import os
import strongdm

load_dotenv()  # Load from .env file

client = strongdm.Client(
    os.getenv("SDM_API_ACCESS_KEY"),
    os.getenv("SDM_API_SECRET_KEY")
)
```

--------------------------------

### Automatic Pagination for StrongDM Batch Operations

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Illustrates how the StrongDM SDK handles batch operations using automatic pagination. The SDK fetches subsequent pages of results as needed.

```python
# Process all accounts in batches
for account in client.accounts.list(''):
    # Process account
    print(account.email)
    
# Pagination is automatic; SDK fetches pages as needed
```

--------------------------------

### Using Predefined Constants

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/SUMMARY.txt

Illustrates the use of predefined constants, such as enums for permissions or states, to ensure consistency and avoid magic strings in your code.

```python
from strongdm import Client, Permission

client = Client(config_path="/path/to/.strongdm")

# Example using a permission constant
# This is a conceptual example, actual usage depends on the service
# For instance, when creating or updating a role:
# client.update("roles", role_id, {"permissions": [Permission.READ, Permission.WRITE]})
print(Permission.READ)

```

--------------------------------

### Initialize Client with Direct Credential Passing

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Provide API access and secret keys directly when creating the strongDM client instance. This method is useful for testing or when environment variables are not feasible.

```python
import strongdm

access_key = "your-access-key"
secret_key = "your-base64-encoded-secret"

client = strongdm.Client(access_key, secret_key)
```

--------------------------------

### Import StrongDM SDK Modules

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Import the necessary modules from the strongdm SDK for client initialization and accessing constants.

```python
import strongdm
from strongdm import errors
from strongdm.constants import PermissionLevel, NodeState
```

--------------------------------

### List Resources of a Specific Type

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/08-resource-types.md

Use this snippet to retrieve all resources of a particular type, such as PostgreSQL. Ensure you have initialized the strongdm client with your access and secret keys.

```python
import strongdm
from strongdm.models import ResourceType

client = strongdm.Client(access_key, secret_key)

# List all PostgreSQL resources
postgres_resources = client.resources.list(
    "type == ?",
    ResourceType.POSTGRES
)

for db in postgres_postgres_resources:
    print(f"{db.name}: {db.hostname}:{db.port}")
```

--------------------------------

### Get gRPC Metadata

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/01-client.md

Retrieves gRPC metadata headers required for strongDM API authentication, including signature, API version, and user agent.

```python
def get_metadata(self, method_name: str, req) -> list
```

--------------------------------

### Create a New PostgreSQL Resource

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Create a new PostgreSQL resource by defining its name and hostname. The `Postgres` class is used for this specific resource type.

```python
resource = strongdm.Postgres(name="db", hostname="host")
created = client.resources.create(resource)
```

--------------------------------

### Create StrongDM Client

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Initializes a StrongDM client with access and secret keys. The gRPC channel and TLS connection are established upon creation, but no requests are sent yet.

```python
import strongdm

client = strongdm.Client(access_key, secret_key)

# At this point:
# - gRPC channel is created
# - TLS connection is established (if secure)
# - No requests sent yet
```

--------------------------------

### Find All Resources of a Specific Type

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/09-filter-reference.md

List all resources that match a given type, such as 'POSTGRES' databases. This helps in managing and querying specific kinds of infrastructure.

```python
postgres_dbs = client.resources.list("type == ?", "POSTGRES")

for db in postgres_dbs:
    print(f"{db.name}: {db.hostname}:{db.port}")
```

--------------------------------

### Query Resources by Name Regex Match

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/INDEX.md

Use regular expressions in the filter syntax to match resource names that follow a specific pattern, like starting with 'prod-'.

```python
# Regex
prod = client.resources.list("name ~ '^prod-'")
```

--------------------------------

### Create Operation

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/03-services-crud.md

Creates a new resource with the specified properties.

```APIDOC
## Create Operation

### Description
Creates a new resource with the specified properties.

### Method
`create(resource: T, timeout: float = None)`

### Parameters
#### Request Body
- **resource** (T) - Required - Resource instance with properties set

#### Query Parameters
- **timeout** (float) - Optional - Request timeout in seconds

### Returns
The created resource with ID populated

### Throws
- `AlreadyExistsError`: Resource with same name/identifier already exists
- `BadRequestError`: Invalid resource configuration
- `PermissionError`: Insufficient permissions to create

#### Example
```python
new_account = strongdm.Account(
    email="newuser@example.com",
    first_name="John",
    last_name="Doe"
)
created = client.accounts.create(new_account)
print(f"Created account: {created.id}")
```
```

--------------------------------

### Create a Service Account Token

Source: https://github.com/strongdm/strongdm-sdk-python/blob/master/_autodocs/06-authentication.md

Create a StrongDM service account with limited permissions for automation purposes.

```python
# Create service account with limited permissions
service_account = strongdm.Account(
    email="automation@example.com",
    permission_level="service"
)
```
Tokens:
Raw