Update to use configclass

Author: mattjacksoncello

README.md

@@ -41,47 +41,50 @@ Check the [Python Connect SDK Example](example/README.md) to see an example of i
 
 3. Use the SDK:
 
-   - Read a secret:
-
-     ```python
-     from onepasswordconnectsdk.client import (
-         Client,
-         new_client_from_environment,
-     )
-
-     connect_client: Client = new_client_from_environment()
-
-     client.get_item("{item_id}", "{vault_id}")
-     ```
-
-   - Write a secret:
-
-     ```python
-     from onepasswordconnectsdk.client import (
-         Client,
-         new_client_from_environment,
-     }
-
-     from onepasswordconnectsdk.models import (
-         Item,
-         ItemVault,
-         Field
-     )
-
-     connect_client: Client = new_client_from_environment()
-
-     # Example item creation. Create an item with your desired arguments.
-     item = Item(
-         vault=ItemVault(id=op_vault),
-         id="custom_id",
-         title="newtitle",
-         category="LOGIN",
-         tags=["1password-connect"],
-         fields=[Field(value="new_user", purpose="USERNAME")],
-     )
-
-     new_item = connect_client.create_item(op_vault, item)
-     ```
+   Choose between synchronous or asynchronous clients:
+
+   ```python
+   # Synchronous client
+   from onepasswordconnectsdk.client import Client, new_client_from_environment
+
+   # Create client using environment variables
+   client: Client = new_client_from_environment()
+
+   # Read a secret
+   item = client.get_item("{item_id}", "{vault_id}")
+
+   # Write a secret
+   from onepasswordconnectsdk.models import Item, ItemVault, Field
+
+   new_item = Item(
+       vault=ItemVault(id=vault_id),
+       title="Example Login",
+       category="LOGIN",
+       fields=[Field(value="username123", purpose="USERNAME")]
+   )
+   created_item = client.create_item(vault_id, new_item)
+   ```
+
+   ```python
+   # Asynchronous client
+   import asyncio
+   from onepasswordconnectsdk.async_client import AsyncClient, new_async_client_from_environment
+
+   async def main():
+       # Create client using environment variables
+       client: AsyncClient = new_async_client_from_environment()
+       
+       try:
+           # Read and write secrets asynchronously
+           item = await client.get_item("{item_id}", "{vault_id}")
+           created_item = await client.create_item(vault_id, new_item)
+       finally:
+           await client.session.aclose()
+
+   asyncio.run(main())
+   ```
+
+   Both client types support additional configuration through [httpx client options](https://www.python-httpx.org/api/#client).
 
 For more examples of how to use the SDK, check out [USAGE.md](USAGE.md).
 

USAGE.md

@@ -2,10 +2,9 @@
 
 ## Creating a Connect API Client
 
-There are two methods available for creating a client:
+The SDK provides both synchronous and asynchronous clients. Each type has two creation methods:
 
-- `new_client_from_environment`: Builds a new client for interacting with 1Password Connect using the `OP_CONNECT_TOKEN` and `OP_CONNECT_HOST` environment variables.
-- `new_client`: Builds a new client for interacting with 1Password Connect. Accepts the hostname of 1Password Connect and the API token generated for the application.
+### Synchronous Client
 
 ```python
 from onepasswordconnectsdk.client import (
@@ -14,21 +13,51 @@ from onepasswordconnectsdk.client import (
     new_client
 )
 
-# creating client using OP_CONNECT_TOKEN and OP_CONNECT_HOST environment variables
-connect_client_from_env: Client = new_client_from_environment()
+# Create client using environment variables
+connect_client: Client = new_client_from_environment()
 
-# creates a client by supplying hostname and 1Password Connect API token
-connect_client_from_token: Client = new_client(
+# Create client with explicit configuration
+connect_client: Client = new_client(
     "{1Password_Connect_Host}",
     "{1Password_Connect_API_Token}")
 
-# creates async client
-connect_async_client: Client = new_client(
+# Create client with additional httpx options
+connect_client: Client = new_client(
     "{1Password_Connect_Host}",
     "{1Password_Connect_API_Token}",
-    True)
+    verify="path/to/certificate.pem",  # SSL certificate
+    timeout=30.0,                      # Custom timeout
+    proxies={"http://": "http://proxy.example.com"})  # Proxy configuration
 ```
 
+### Asynchronous Client
+
+```python
+from onepasswordconnectsdk.async_client import (
+    AsyncClient,
+    new_async_client_from_environment,
+    new_async_client
+)
+
+# Create async client using environment variables
+async_client: AsyncClient = new_async_client_from_environment()
+
+# Create async client with explicit configuration
+async_client: AsyncClient = new_async_client(
+    "{1Password_Connect_Host}",
+    "{1Password_Connect_API_Token}")
+
+# Create async client with additional httpx options
+async_client: AsyncClient = new_async_client(
+    "{1Password_Connect_Host}",
+    "{1Password_Connect_API_Token}",
+    verify="path/to/certificate.pem",  # SSL certificate
+    timeout=30.0,                      # Custom timeout
+    proxies={"http://": "http://proxy.example.com"})  # Proxy configuration
+```
+
+Both client types support all [httpx client options](https://www.python-httpx.org/api/#client) through their respective configuration classes.
+
 ## Environment Variables
 
 - **OP_CONNECT_TOKEN** – The token to be used to authenticate with the 1Password Connect API.
@@ -38,9 +67,6 @@ connect_async_client: Client = new_client(
   - `http://localhost:8080` if the Connect server is running in Docker on the same host.
   - `http(s)://<ip>:8080` or `http(s)://<hostname>:8080` if the Connect server is running on another host.
 - **OP_VAULT** - The default vault to fetch items from if not specified.
-- **OP_CONNECT_CLIENT_ASYNC** - Whether to use async client or not. Possible values are:
-     - True - to use async client
-     - False - to use synchronous client (this is used by default)
 
 
 ## Working with Vaults
@@ -147,23 +173,32 @@ CONFIG = Config()
 values_object = onepasswordconnectsdk.load(connect_client, CONFIG)
 ```
 
-## Async client
+## Using the Async Client
+
+The async client provides the same functionality as the sync client but with async/await syntax:
 
-All the examples above can work using an async client.
 ```python
 import asyncio
-
-# initialize async client by passing `is_async = True`
-async_client: Client = new_client(
-    "{1Password_Connect_Host}",
-    "{1Password_Connect_API_Token}",
-    True)
+from onepasswordconnectsdk.async_client import AsyncClient, new_async_client
 
 async def main():
-    vaults = await async_client.get_vaults()
-    item = await async_client.get_item("{item_id}", "{vault_id}")
-    # do something with vaults and item
-    await async_client.session.aclose()  # close the client gracefully when you are done
+    # Create async client with optional httpx configuration
+    async_client: AsyncClient = new_async_client(
+        "{1Password_Connect_Host}",
+        "{1Password_Connect_API_Token}",
+        timeout=30.0  # Optional httpx configuration
+    )
+
+    try:
+        # Use the client
+        vaults = await async_client.get_vaults()
+        item = await async_client.get_item("{item_id}", "{vault_id}")
+        # Do something with vaults and item
+    finally:
+        # Always close the client when done
+        await async_client.session.aclose()
 
 asyncio.run(main())
-```
+```
+
+All the examples shown above for the sync client work the same way with the async client, just with async/await syntax.

src/onepasswordconnectsdk/async_client.py

@@ -21,15 +21,24 @@
 class AsyncClient:
     """Python Async Client Class"""
 
-    def __init__(self, url: str, token: str) -> None:
-        """Initialize async client"""
-        self.url = url
-        self.token = token
-        self.session = self.create_session(url, token)
+    def __init__(self, config: 'AsyncClientConfig') -> None:
+        """Initialize async client
+        
+        Args:
+            config: AsyncClientConfig instance containing all client configuration
+        """
+        self.url = config.url
+        self.token = config.token
+        self.session = self.create_session(config)
         self.serializer = Serializer()
 
-    def create_session(self, url: str, token: str) -> httpx.AsyncClient:
-        return httpx.AsyncClient(base_url=url, headers=self.build_headers(token), timeout=get_timeout())
+    def create_session(self, config: 'AsyncClientConfig') -> httpx.AsyncClient:
+        """Create an HTTP session using the provided configuration"""
+        # Update headers in the existing config
+        headers = config.headers or {}
+        headers.update(self.build_headers(config.token))
+        config.headers = headers
+        return config
 
     def build_headers(self, token: str) -> Dict[str, str]:
         return build_headers(token)
@@ -378,27 +387,32 @@ def sanitize_for_serialization(self, obj):
         return self.serializer.sanitize_for_serialization(obj)
 
 
-def new_async_client(url: str, token: str) -> AsyncClient:
+def new_async_client(url: str, token: str, **kwargs) -> AsyncClient:
     """Builds a new client for interacting with 1Password Connect
-    Parameters:
-    url: The url of the 1Password Connect API
-    token: The 1Password Service Account token
+    
+    Args:
+        url: The url of the 1Password Connect API
+        token: The 1Password Service Account token
+        **kwargs: Additional httpx.AsyncClient configuration options
 
     Returns:
-    AsyncClient: The 1Password Connect client
+        AsyncClient: The 1Password Connect client
     """
-    return AsyncClient(url, token)
+    from onepasswordconnectsdk.config import AsyncClientConfig
+    config = AsyncClientConfig(url=url, token=token, **kwargs)
+    return AsyncClient(config)
 
 
-def new_async_client_from_environment(url: str = None) -> AsyncClient:
+def new_async_client_from_environment(url: str = None, **kwargs) -> AsyncClient:
     """Builds a new client for interacting with 1Password Connect
     using the OP_CONNECT_TOKEN environment variable
 
-    Parameters:
-    url: The url of the 1Password Connect API
+    Args:
+        url: The url of the 1Password Connect API
+        **kwargs: Additional httpx.AsyncClient configuration options
 
     Returns:
-    AsyncClient: The 1Password Connect client
+        AsyncClient: The 1Password Connect client
     """
     token = os.environ.get(ENV_SERVICE_ACCOUNT_JWT_VARIABLE)
 
@@ -415,4 +429,4 @@ def new_async_client_from_environment(url: str = None) -> AsyncClient:
             f"{ENV_SERVICE_ACCOUNT_JWT_VARIABLE} variable"
         )
 
-    return new_async_client(url, token)
+    return new_async_client(url, token, certificate, **kwargs)

src/onepasswordconnectsdk/client.py

@@ -22,15 +22,24 @@
 class Client:
     """Python Client Class"""
 
-    def __init__(self, url: str, token: str) -> None:
-        """Initialize client"""
-        self.url = url
-        self.token = token
-        self.session = self.create_session(url, token)
+    def __init__(self, config: 'ClientConfig') -> None:
+        """Initialize client
+        
+        Args:
+            config: ClientConfig instance containing all client configuration
+        """
+        self.url = config.url
+        self.token = config.token
+        self.session = self.create_session(config)
         self.serializer = Serializer()
 
-    def create_session(self, url: str, token: str) -> httpx.Client:
-        return httpx.Client(base_url=url, headers=self.build_headers(token), timeout=get_timeout())
+    def create_session(self, config: 'ClientConfig') -> httpx.Client:
+        """Create an HTTP session using the provided configuration"""
+        # Update headers in the existing config
+        headers = config.headers or {}
+        headers.update(self.build_headers(config.token))
+        config.headers = headers
+        return config
 
     def build_headers(self, token: str) -> Dict[str, str]:
         return build_headers(token)
@@ -379,27 +388,32 @@ def sanitize_for_serialization(self, obj):
         return self.serializer.sanitize_for_serialization(obj)
 
 
-def new_client(url: str, token: str) -> Client:
+def new_client(url: str, token: str, **kwargs) -> Client:
     """Builds a new client for interacting with 1Password Connect
-    Parameters:
-    url: The url of the 1Password Connect API
-    token: The 1Password Service Account token
+    
+    Args:
+        url: The url of the 1Password Connect API
+        token: The 1Password Service Account token
+        **kwargs: Additional httpx.Client configuration options
 
     Returns:
-    Client: The 1Password Connect client
+        Client: The 1Password Connect client
     """
-    return Client(url, token)
+    from onepasswordconnectsdk.config import ClientConfig
+    config = ClientConfig(url=url, token=token, **kwargs)
+    return Client(config)
 
 
-def new_client_from_environment(url: str = None) -> Client:
+def new_client_from_environment(url: str = None, **kwargs) -> Client:
     """Builds a new client for interacting with 1Password Connect
     using the OP_CONNECT_TOKEN environment variable
 
-    Parameters:
-    url: The url of the 1Password Connect API
+    Args:
+        url: The url of the 1Password Connect API
+        **kwargs: Additional httpx.Client configuration options
 
     Returns:
-    Client: The 1Password Connect client
+        Client: The 1Password Connect client
     """
     token = os.environ.get(ENV_SERVICE_ACCOUNT_JWT_VARIABLE)
 
@@ -416,4 +430,4 @@ def new_client_from_environment(url: str = None) -> Client:
             f"{ENV_SERVICE_ACCOUNT_JWT_VARIABLE} variable"
         )
 
-    return new_client(url, token)
+    return new_client(url, token, certificate, **kwargs)