etrade-python 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

etrade_python/__init__.py

@@ -20,6 +20,7 @@ from etrade_python.alerts import (
 )
 from etrade_python.auth import (
     AuthorizationUrl,
+    CoordinatedCredentialStore,
     CredentialStore,
     ETradeCredentials,
     KeyringCredentialStore,
@@ -38,6 +39,7 @@ from etrade_python.enums import Environment
 from etrade_python.exceptions import (
     AuthenticationRequired,
     AuthorizationExpired,
+    CredentialCoordinationError,
     ETradeApiError,
     ETradeAuthenticationError,
     ETradeError,
@@ -201,6 +203,7 @@ __all__ = [
     "CancelOrderResponse",
     "CancelOrderRequest",
     "AuthenticationRequired",
+    "CredentialCoordinationError",
     "Account",
     "AccountBalanceRequest",
     "AccountBalanceResponse",
@@ -208,6 +211,7 @@ __all__ = [
     "AccountsService",
     "AuthorizationUrl",
     "AuthorizationExpired",
+    "CoordinatedCredentialStore",
     "CredentialStore",
     "ETradeApiError",
     "ETradeAuthenticationError",

etrade_python/_version.py

@@ -1,3 +1,3 @@
 """Runtime version shared by the public package and HTTP transport."""
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"

etrade_python/auth/__init__.py

@@ -10,6 +10,7 @@ from etrade_python.auth.credentials import (
 from etrade_python.auth.oauth import OAuthClient
 from etrade_python.auth.session import SessionAuthenticator, SessionManager, TokenStatus
 from etrade_python.auth.stores import (
+    CoordinatedCredentialStore,
     CredentialStore,
     KeyringCredentialStore,
     MemoryCredentialStore,
@@ -17,6 +18,7 @@ from etrade_python.auth.stores import (
 
 __all__ = [
     "AuthorizationUrl",
+    "CoordinatedCredentialStore",
     "CredentialStore",
     "ETradeCredentials",
     "KeyringCredentialStore",

etrade_python/auth/session.py

@@ -2,7 +2,8 @@
 
 import asyncio
 import hashlib
-from collections.abc import Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from contextlib import asynccontextmanager
 from datetime import UTC, datetime, timedelta
 from enum import StrEnum
 from zoneinfo import ZoneInfo
@@ -11,7 +12,7 @@ import httpx
 
 from etrade_python.auth.credentials import ETradeCredentials
 from etrade_python.auth.oauth import OAuthClient
-from etrade_python.auth.stores.base import CredentialStore
+from etrade_python.auth.stores.base import CoordinatedCredentialStore, CredentialStore
 from etrade_python.config import ETradeSettings
 from etrade_python.exceptions import AuthenticationRequired, AuthorizationExpired
 
@@ -48,10 +49,23 @@ class SessionManager:
         self._clock = clock or (lambda: datetime.now(UTC))
         self._renewal_lock = asyncio.Lock()
 
-    async def ensure_active(self) -> ETradeCredentials:
+    @asynccontextmanager
+    async def _transaction(self) -> AsyncGenerator[None]:
         async with self._renewal_lock:
+            if isinstance(self._credential_store, CoordinatedCredentialStore):
+                async with self._credential_store.lock(self._storage_key):
+                    yield
+            else:
+                # Preserve the original contract for existing custom stores.
+                yield
+
+    async def _load(self) -> ETradeCredentials | None:
+        return await self._credential_store.load(self._storage_key)
+
+    async def ensure_active(self) -> ETradeCredentials:
+        async with self._transaction():
             now = self._now()
-            credentials = await self.load()
+            credentials = await self._load()
             status = self.status(credentials, now=now)
             if status is TokenStatus.MISSING:
                 raise AuthenticationRequired("E*TRADE authorization is required")
@@ -65,8 +79,8 @@ class SessionManager:
 
     async def renew(self) -> ETradeCredentials:
         """Renew same-day credentials with the broker, even when locally active."""
-        async with self._renewal_lock:
-            credentials = await self.load()
+        async with self._transaction():
+            credentials = await self._load()
             if credentials is None:
                 raise AuthenticationRequired("E*TRADE authorization is required")
             if self.status(credentials) is TokenStatus.EXPIRED:
@@ -76,34 +90,56 @@ class SessionManager:
     async def _renew(self, credentials: ETradeCredentials) -> ETradeCredentials:
         """Perform renewal while the caller holds the renewal lock."""
         result = await self._oauth_client.renew_access_token(credentials)
-        renewed = result.credentials.with_renewal(self._now())
+        renewed = result.credentials.with_renewal(max(self._now(), credentials.last_used_at))
+        if credentials.renewed_at is not None and (
+            renewed.renewed_at is None or credentials.renewed_at > renewed.renewed_at
+        ):
+            renewed = renewed.model_copy(update={"renewed_at": credentials.renewed_at})
         await self._save(renewed)
         return renewed
 
     async def save(self, credentials: ETradeCredentials) -> None:
-        async with self._renewal_lock:
+        async with self._transaction():
+            current = await self._load()
+            if current is not None and _same_credentials(current, credentials):
+                renewed = [t for t in (current.renewed_at, credentials.renewed_at) if t is not None]
+                credentials = credentials.model_copy(
+                    update={
+                        "last_used_at": max(current.last_used_at, credentials.last_used_at),
+                        "renewed_at": max(renewed) if renewed else None,
+                    }
+                )
             await self._save(credentials)
 
     async def _save(self, credentials: ETradeCredentials) -> None:
         await self._credential_store.save(self._storage_key, credentials)
 
     async def load(self) -> ETradeCredentials | None:
-        return await self._credential_store.load(self._storage_key)
+        async with self._transaction():
+            return await self._load()
 
     async def delete(self) -> None:
-        async with self._renewal_lock:
+        async with self._transaction():
             await self._credential_store.delete(self._storage_key)
 
+    async def revoke(self) -> None:
+        """Revoke current credentials and delete locally only after broker success.
+
+        This coordinates lifecycle updates, not already-dispatched API requests.
+        Missing credentials are a no-op. Broker errors preserve local credentials.
+        """
+        async with self._transaction():
+            credentials = await self._load()
+            if credentials is not None:
+                await self._oauth_client.revoke_access_token(credentials)
+                await self._credential_store.delete(self._storage_key)
+
     async def record_usage(self, credentials: ETradeCredentials) -> None:
         """Record confirmed usage without overwriting newer or replaced credentials."""
         used_at = self._now()
-        async with self._renewal_lock:
-            current = await self.load()
-            if current is None or (
-                current.access_token != credentials.access_token
-                or current.access_token_secret != credentials.access_token_secret
-                or current.acquired_at != credentials.acquired_at
-            ):
+        async with self._transaction():
+            current = await self._load()
+            if current is None or not _same_credentials(current, credentials):
                 return
             if used_at > current.last_used_at:
                 await self._save(current.with_last_used(used_at))
@@ -137,6 +173,14 @@ class SessionManager:
         return value.astimezone(UTC)
 
 
+def _same_credentials(left: ETradeCredentials, right: ETradeCredentials) -> bool:
+    return (
+        left.access_token == right.access_token
+        and left.access_token_secret == right.access_token_secret
+        and left.acquired_at == right.acquired_at
+    )
+
+
 class SessionAuthenticator:
     """Transport authenticator backed by SessionManager credentials."""
 

etrade_python/auth/stores/__init__.py

@@ -1,7 +1,12 @@
 """Credential store implementations."""
 
-from etrade_python.auth.stores.base import CredentialStore
+from etrade_python.auth.stores.base import CoordinatedCredentialStore, CredentialStore
 from etrade_python.auth.stores.keyring import KeyringCredentialStore
 from etrade_python.auth.stores.memory import MemoryCredentialStore
 
-__all__ = ["CredentialStore", "KeyringCredentialStore", "MemoryCredentialStore"]
+__all__ = [
+    "CoordinatedCredentialStore",
+    "CredentialStore",
+    "KeyringCredentialStore",
+    "MemoryCredentialStore",
+]

etrade_python/auth/stores/_workers.py

@@ -0,0 +1,44 @@
+"""Wait for keyring and lock workers before relinquishing transaction ownership."""
+
+import asyncio
+import contextvars
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+async def run_worker(function: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    """Defer cancellation until a worker finishes, including repeated cancellation.
+
+    A worker thread cannot be stopped by cancelling its awaiter. Releasing a
+    namespace lock first would allow its late write to race with the next owner.
+    """
+    context = contextvars.copy_context()
+    # Use an executor Future, not a Task: asyncio.run() cancels all Tasks during
+    # shutdown, including a shielded to_thread Task. This Future stays alive until
+    # the actual thread finishes, so the transaction cannot unlock prematurely.
+    worker = asyncio.get_running_loop().run_in_executor(
+        None, lambda: context.run(function, *args, **kwargs)
+    )
+    cancelled = False
+    while True:
+        try:
+            result = await asyncio.shield(worker)
+        except asyncio.CancelledError:
+            cancelled = True
+            if not worker.done():
+                continue
+            # Retrieve worker exceptions even when cancellation wins.
+            if not worker.cancelled():
+                worker.exception()
+            raise
+        except Exception:
+            if cancelled:
+                raise asyncio.CancelledError from None
+            raise
+        else:
+            if cancelled:
+                raise asyncio.CancelledError
+            return result

etrade_python/auth/stores/base.py

@@ -1,6 +1,7 @@
 """Credential store protocol."""
 
-from typing import Protocol
+from contextlib import AbstractAsyncContextManager
+from typing import Protocol, runtime_checkable
 
 from etrade_python.auth.credentials import ETradeCredentials
 
@@ -16,3 +17,17 @@ class CredentialStore(Protocol):
 
     async def delete(self, profile: str) -> None:
         """Delete credentials for a profile."""
+
+
+@runtime_checkable
+class CoordinatedCredentialStore(CredentialStore, Protocol):
+    """Optional transaction lock shared by all users of a credential namespace.
+
+    SessionManager holds this lock across complete lifecycle operations. Store
+    methods must not reacquire it. Direct store users must explicitly acquire it
+    around read/modify/write sequences. Locks need not be reentrant.
+    """
+
+    def lock(self, namespace: str) -> AbstractAsyncContextManager[None]:
+        """Exclusively coordinate a namespace, releasing ownership on exit."""
+        ...

etrade_python/auth/stores/keyring.py

@@ -1,24 +1,100 @@
 """Keyring-backed credential store."""
 
 import asyncio
+import hashlib
 import json
+import math
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import cast
 
 import keyring
+from filelock import BaseFileLock, FileLock, SoftFileLock, Timeout
 from keyring.errors import PasswordDeleteError
+from platformdirs import user_cache_path
 from pydantic import ValidationError
 
 from etrade_python.auth.credentials import ETradeCredentials
-from etrade_python.exceptions import ETradeValidationError
+from etrade_python.auth.stores._workers import run_worker
+from etrade_python.exceptions import CredentialCoordinationError, ETradeValidationError
 
 
 class KeyringCredentialStore:
     """Store credentials in the user's configured system keyring."""
 
-    def __init__(self, *, service_name: str = "etrade-python") -> None:
+    def __init__(
+        self,
+        *,
+        service_name: str = "etrade-python",
+        lock_directory: Path | None = None,
+        lock_timeout_seconds: float = 60.0,
+    ) -> None:
+        if (
+            isinstance(lock_timeout_seconds, bool)
+            or not math.isfinite(lock_timeout_seconds)
+            or lock_timeout_seconds < 0
+        ):
+            raise ETradeValidationError("Credential lock timeout must be finite and nonnegative")
         self._service_name = service_name
+        self._lock_directory = (
+            lock_directory
+            if lock_directory is not None
+            else user_cache_path("etrade-python") / "credential-locks"
+        )
+        self._lock_timeout_seconds = lock_timeout_seconds
+
+    @asynccontextmanager
+    async def lock(self, namespace: str) -> AsyncGenerator[None]:
+        """Hold an OS-backed namespace lock; no credential values are written to disk."""
+        digest = hashlib.sha256(
+            json.dumps([self._service_name, namespace]).encode("utf-8")
+        ).hexdigest()
+        # FileLock's runtime alias may select a soft lock on unsupported systems.
+        lock_class = cast(type[BaseFileLock], FileLock)
+        if issubclass(lock_class, SoftFileLock):
+            raise CredentialCoordinationError("OS credential locks are unavailable")
+        lock = lock_class(
+            self._lock_directory / f"{digest}.lock",
+            thread_local=False,
+            mode=0o600,
+            fallback_to_soft=False,
+            preserve_lock_file=True,
+        )
+        deadline = asyncio.get_running_loop().time() + self._lock_timeout_seconds
+        try:
+            try:
+                await run_worker(
+                    self._lock_directory.mkdir, mode=0o700, parents=True, exist_ok=True
+                )
+                while True:
+                    try:
+                        await run_worker(lock.acquire, timeout=0)
+                        break
+                    except Timeout:
+                        remaining = deadline - asyncio.get_running_loop().time()
+                        if remaining <= 0:
+                            raise CredentialCoordinationError(
+                                "Timed out coordinating credential access"
+                            ) from None
+                        await asyncio.sleep(min(0.05, remaining))
+            except (OSError, NotImplementedError):
+                raise CredentialCoordinationError(
+                    "Could not coordinate credential access"
+                ) from None
+            yield
+        finally:
+            # Acquisition may finish in a worker after its caller is cancelled.
+            if lock.is_locked:
+                try:
+                    await run_worker(lock.release)
+                except OSError:
+                    raise CredentialCoordinationError(
+                        "Could not release credential coordination lock"
+                    ) from None
 
     async def load(self, profile: str) -> ETradeCredentials | None:
-        raw = await asyncio.to_thread(keyring.get_password, self._service_name, profile)
+        raw = await run_worker(keyring.get_password, self._service_name, profile)
         if raw is None:
             return None
         try:
@@ -40,10 +116,10 @@ class KeyringCredentialStore:
             },
             separators=(",", ":"),
         )
-        await asyncio.to_thread(keyring.set_password, self._service_name, profile, payload)
+        await run_worker(keyring.set_password, self._service_name, profile, payload)
 
     async def delete(self, profile: str) -> None:
         try:
-            await asyncio.to_thread(keyring.delete_password, self._service_name, profile)
+            await run_worker(keyring.delete_password, self._service_name, profile)
         except PasswordDeleteError:
             return

etrade_python/auth/stores/memory.py

@@ -1,5 +1,8 @@
 """In-memory credential store."""
 
+import asyncio
+from contextlib import AbstractAsyncContextManager
+
 from etrade_python.auth.credentials import ETradeCredentials
 
 
@@ -8,6 +11,11 @@ class MemoryCredentialStore:
 
     def __init__(self) -> None:
         self._credentials: dict[str, ETradeCredentials] = {}
+        self._locks: dict[str, asyncio.Lock] = {}
+
+    def lock(self, namespace: str) -> AbstractAsyncContextManager[None]:
+        """Coordinate managers sharing this store instance and event loop."""
+        return self._locks.setdefault(namespace, asyncio.Lock())
 
     async def load(self, profile: str) -> ETradeCredentials | None:
         return self._credentials.get(profile)

etrade_python/cli/app.py

@@ -142,10 +142,7 @@ def revoke(profile: str = typer.Option("default", "--profile", "-p")) -> None:
 
     async def command() -> None:
         async with ETradeClient(_settings(), profile=profile) as client:
-            credentials = await client.session.load()
-            if credentials is not None:
-                await client.oauth.revoke_access_token(credentials)
-            await client.session.delete()
+            await client.session.revoke()
             typer.echo(f"Credentials removed for profile '{profile}'.")
 
     _handle(command())

etrade_python/exceptions.py

@@ -9,6 +9,10 @@ class ETradeAuthenticationError(ETradeError):
     """Authentication failed or is unavailable."""
 
 
+class CredentialCoordinationError(ETradeAuthenticationError):
+    """Credential transaction ownership could not be obtained or released."""
+
+
 class AuthenticationRequired(ETradeAuthenticationError):
     """Human authorization or an authentication provider is required."""
 

etrade_python/transport/http.py

@@ -17,6 +17,7 @@ from etrade_python.config import ETradeSettings
 from etrade_python.exceptions import (
     AuthenticationRequired,
     AuthorizationExpired,
+    CredentialCoordinationError,
     ETradeAuthenticationError,
     ETradeTransportError,
     ETradeValidationError,
@@ -145,6 +146,8 @@ class ApiTransport:
                 raise AuthenticationRequired("Authorization is required") from None
             except AuthorizationExpired:
                 raise AuthorizationExpired("Authorization has expired") from None
+            except CredentialCoordinationError:
+                raise
             except Exception:
                 raise ETradeAuthenticationError("Request authentication failed") from None
             if (

{etrade_python-1.0.0.dist-info → etrade_python-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etrade-python
-Version: 1.0.0
+Version: 1.1.0
 Summary: An unofficial, typed, async-first E*TRADE API client
 Project-URL: Repository, https://github.com/kevinrider/etrade-python
 Project-URL: Issues, https://github.com/kevinrider/etrade-python/issues
@@ -17,8 +17,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
+Requires-Dist: filelock<4,>=3.32.7
 Requires-Dist: httpx<1,>=0.28
 Requires-Dist: keyring<26,>=25
+Requires-Dist: platformdirs<5,>=4
 Requires-Dist: pydantic-settings<3,>=2.7
 Requires-Dist: pydantic<3,>=2.10
 Requires-Dist: typer<1,>=0.20
@@ -32,7 +34,16 @@ Requires-Dist: ruff<1,>=0.11; extra == 'dev'
 Requires-Dist: twine<7,>=6; extra == 'dev'
 Description-Content-Type: text/markdown
 
-# etrade-python
+<div align="center">
+<img src="https://repository-images.githubusercontent.com/1391295794/76df490d-7ec2-48f4-87e8-d4945d37f722" alt="E*TRADE and Python logos above the etrade-python title" width="640">
+</div>
+
+<div align="center">
+<a href="https://github.com/kevinrider/etrade-python/releases"><img src="https://img.shields.io/github/release/kevinrider/etrade-python.svg?style=flat-square" alt="Latest Version"></a>
+<a href="https://github.com/kevinrider/etrade-python/actions/workflows/ci.yml"><img src="https://github.com/kevinrider/etrade-python/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+<a href="https://github.com/kevinrider/etrade-python/issues"><img src="https://img.shields.io/github/issues/kevinrider/etrade-python" alt="GitHub issues"></a>
+<a href="https://github.com/kevinrider/etrade-python/blob/main/LICENSE"><img src="https://img.shields.io/github/license/kevinrider/etrade-python" alt="License"></a>
+</div>
 
 An unofficial, typed, async-first Python client for the E*TRADE REST API.
 
@@ -40,9 +51,6 @@ An unofficial, typed, async-first Python client for the E*TRADE REST API.
 management, and shared async networking for Python applications, CLIs, background
 workers, web services, workflow engines, and notebooks. Requires Python 3.11+.
 
-The package is prepared for its first stable release, **1.0.0**. The PyPI
-installation instructions below apply once the release is published.
-
 ## Features
 
 - Namespaced Accounts, Portfolio, Transactions, Market, Orders, and Alerts services.
@@ -60,16 +68,16 @@ inspection through Pydantic.
 
 ## Installation
 
-From a source checkout, install into an activated Python 3.11+ virtual environment:
+Install from PyPI into an activated Python 3.11+ virtual environment:
 
 ```sh
-python -m pip install .
+python -m pip install etrade-python
 ```
 
-Once published on PyPI:
+Alternatively, install from a source checkout:
 
 ```sh
-python -m pip install etrade-python
+python -m pip install .
 ```
 
 The distribution name is `etrade-python`; the import package is `etrade_python`.
@@ -141,6 +149,11 @@ contacts the broker even when the token appears active locally.
 
 `auth status` reports a local lifecycle estimate, not broker verification.
 
+`await client.session.revoke()` coordinates broker revocation and local deletion.
+The CLI's `etrade auth revoke` uses this method. Missing credentials are a no-op;
+broker failure preserves the local credentials. Revocation cannot recall an
+already signed or dispatched brokerage request.
+
 ## Accounts and Portfolio
 
 After logging in with the CLI, save this as a Python script and run it with the
@@ -375,6 +388,60 @@ application-managed authorization, then `await client.session.save(credentials)`
 Always close the client after use. Applications can implement the async
 `CredentialStore` protocol for other persistence systems.
 
+### Sharing a profile across local processes
+
+Starting in 1.1.0, session lifecycle operations use namespace transaction locks
+when the store implements `CoordinatedCredentialStore`. The built-in keyring store
+coordinates cooperating SDK/CLI processes using OS-backed file locks. The keyring
+credential format and existing environment/consumer-key/profile namespaces are
+unchanged. Ordinary brokerage HTTP requests remain concurrent; only lifecycle
+transactions are serialized. Automatic inactivity renewal reloads the stored
+credentials after locking, avoiding duplicate renewal by waiting processes.
+Explicit `session.renew()` still contacts the broker on every invocation.
+
+Lock files contain no credentials. They use hashed keyring-service and namespace
+identities in the per-user cache directory `etrade-python/credential-locks` selected
+by platformdirs. Files remain after release to preserve lock identity; OS ownership
+is released when a process exits. Do not delete lock files or clear this cache
+while cooperating processes are running. Use a local filesystem supporting OS
+locks, the same OS user, and the same lock directory for all cooperating processes.
+Older clients and direct uncoordinated store access do not participate.
+
+The keyring lock acquisition timeout defaults to 60 seconds. A timeout, unsupported
+locking, or filesystem failure raises `CredentialCoordinationError` without
+credential/namespace/path details. To configure storage coordination explicitly:
+
+```python
+from pathlib import Path
+from etrade_python import ETradeClient, ETradeSettings, KeyringCredentialStore
+
+store = KeyringCredentialStore(
+    lock_directory=Path("/private/local/path/credential-locks"),
+    lock_timeout_seconds=30,
+)
+client = ETradeClient(ETradeSettings(), credential_store=store, profile="personal")
+```
+
+Every process sharing those credentials must use that same configuration. The
+existing CLI uses the default lock directory. The directory is created on first
+use, with private permissions on POSIX; provision custom directories with
+appropriate access controls. No plaintext credential fallback is introduced.
+
+`MemoryCredentialStore` coordinates managers sharing one store instance within
+one event loop. Existing custom stores implementing only `CredentialStore` remain
+compatible with the earlier per-manager locking guarantee. Custom stores can add
+`lock(namespace) -> AbstractAsyncContextManager[None]` to implement the exported
+`CoordinatedCredentialStore` protocol. Hold that lock across the complete
+read/check/update operation; its `load`, `save`, and `delete` methods must not
+reacquire the non-reentrant lock. Direct store users must explicitly acquire the
+lock themselves. Distributed stores must provide their own appropriate locking.
+
+Cancelled keyring operations finish their worker before releasing transaction
+ownership. This can delay cancellation if the keyring backend is blocked. A process
+crash releases OS lock ownership but does not prove the outcome of an interrupted
+broker renewal or revocation. Recheck/re-authorize as necessary; this mechanism
+does not journal OAuth operations or prevent duplicate trading submissions.
+
 ## Diagnostic CLI and Orders Demo
 
 Use `etrade --help` or `etrade COMMAND --help` to inspect available commands.
@@ -455,7 +522,7 @@ uv run python -m twine check dist/*
 CI checks Python 3.11–3.14, enforces at least 90% combined statement/branch coverage,
 and verifies wheel installation outside the checkout. Push and pull-request CI
 does not publish. A separate release workflow publishes stable GitHub releases
-using PyPI Trusted Publishing once the publisher is configured. See
+using PyPI Trusted Publishing. See
 [CONTRIBUTING.md](CONTRIBUTING.md) for contribution and package verification instructions.
 
 ## API Coverage

{etrade_python-1.0.0.dist-info → etrade_python-1.1.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-etrade_python/__init__.py,sha256=YeTxdrXY3kz_W_njtE5_z4td7wCpUVFavZA2kZyxdsY,5963
+etrade_python/__init__.py,sha256=a1Yr3dxfsESf60KViI-vPlxTuEDZ87QwVyViRo9Z4Ko,6097
 etrade_python/_dates.py,sha256=6I7QmElS3e5jipJSVkY0lrBNed1i9eCIjsMhFPicTlU,4614
-etrade_python/_version.py,sha256=wVzvdZEqZCvsp3GrIZI-Oh8FDnb35FkUIcgt3r4K1U4,94
+etrade_python/_version.py,sha256=IPd7E5iUFG2-pfvcaBsXlVPOc6sKuVUkhpkhdQbEd0k,94
 etrade_python/client.py,sha256=5I5frcyDDnPfIfmYRYMBnHxsQbqJh1mPufegbDHEe70,3439
 etrade_python/config.py,sha256=JbuPHoGijKHO9eN37WIrWNZaGpxspNBcNj9wIab8oHY,1699
 etrade_python/enums.py,sha256=ashvh8PXge21mUeGj7cJfYuQlxZp5V_vGuiIF4hCjiw,519
-etrade_python/exceptions.py,sha256=2qIZExdQj1VlGCEzUrLCGD6kTwM5Yb02khMiFJiwyg4,1896
+etrade_python/exceptions.py,sha256=mgU94Ip_zXl-tJnwKUb1T3NXuGfp2FLq7n50uzo-Ryg,2038
 etrade_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 etrade_python/accounts/__init__.py,sha256=0KtBaDl7UVin-Gl-qnwKhjBaWpiKU2XsIoLakCv60JM,657
 etrade_python/accounts/models.py,sha256=9gILGHLW6V_8TOoVtgBk-TMRblpog8aC09ma2vNNM8c,9753
@@ -12,16 +12,17 @@ etrade_python/accounts/service.py,sha256=dbs8C_qavZCtGhkPuwSkAa-bK1thwd3viYoA0r1
 etrade_python/alerts/__init__.py,sha256=aZ3fwW4iKyWFFki6pq5BmSEHkD7he70KnyzI7W0bEuY,473
 etrade_python/alerts/models.py,sha256=-hLI_0WO7wymOIWF3dWjq3royq6minN_Bx_32DM-Te8,5646
 etrade_python/alerts/service.py,sha256=96y9KwMsyMJVipenicS0NlIQ6mgziQv9bnUuDbzcQ_I,5084
-etrade_python/auth/__init__.py,sha256=vtXjjZw8rAP2MBLhBj0csw422DLMUVo-k8YqK3TPiNU,750
+etrade_python/auth/__init__.py,sha256=ubYydeK8C5eQwW_wzQ8MuW9vH5d_EgIBdR7gzP5jUIg,816
 etrade_python/auth/credentials.py,sha256=1yF2lr6Qj2xuBBBnWiZdn2QUIs3qOjSO4NNgC-N27Gc,2873
 etrade_python/auth/oauth.py,sha256=kFrLH83uf-cDe8MJycKNHCaUw8dXpuAn8GJzLNTK4F0,10494
-etrade_python/auth/session.py,sha256=2WdfWkHt6UGgKO6Jn4teDkXwTQJ4fp2dK_kC5258oA8,6226
-etrade_python/auth/stores/__init__.py,sha256=d2cCDnDxeXsBOqmLa0A1lDaQWr_GEzXrTlLqDuVYvmM,318
-etrade_python/auth/stores/base.py,sha256=XXbWAoYUf-MumiPybpAd-jv_8pMZMYxPRlu-FwdQctA,591
-etrade_python/auth/stores/keyring.py,sha256=QWEgEKg-41fbTYMu9RtrdsEFmgO9jAxkMRMCb12LfXI,1909
-etrade_python/auth/stores/memory.py,sha256=lnzjQe-rJgJIL4t-6_QHSizVhFJQv1DFilC8EVKNO3g,645
+etrade_python/auth/session.py,sha256=6LqrQ6t2xEGKjCtjY8OOJYkbdS9_pg3KHFmtvmKSFGo,8304
+etrade_python/auth/stores/__init__.py,sha256=ftUbEjP5tlsWPLPJwZy_NarveRqQ59AfeHhmMk-HR-w,395
+etrade_python/auth/stores/_workers.py,sha256=MqJPqTLJpDeY8fAdOt--f984ZiDQrNQPCcbzcnu6Yh0,1607
+etrade_python/auth/stores/base.py,sha256=z8GQinmFJO0lmPis3c-pgxE4Iva7hVN8ObNnEvROTFA,1226
+etrade_python/auth/stores/keyring.py,sha256=hTOKlt-MQ2f7K9tU43BC12TsbiPUcllK_3bDfvVG_10,5079
+etrade_python/auth/stores/memory.py,sha256=fPsgJ8JAeyRhumm2MvtbANsblhl9gEngSZ1No3aa3pU,979
 etrade_python/cli/__init__.py,sha256=0ouz55BJFQtDyuOsMAIaI-RI0vCWqZfos6OF1lDc_js,38
-etrade_python/cli/app.py,sha256=Hxs1iDI4hMgC6hWyEplgYdKulB1tLpHG_NUfbvpdag0,64833
+etrade_python/cli/app.py,sha256=rYDhh0xxO0Rwa8Yv-XsnNEshPPKR4GlxK2LJXoiGnOo,64671
 etrade_python/market/__init__.py,sha256=uEfAqe1ff4tkpbSk-YNMEhwLn-oVQUK6-_gSFkqM5iU,1296
 etrade_python/market/models.py,sha256=Qumrafwxi5qDymdsU5_idJZHkL50YUVQPI-mlHmGc1g,32501
 etrade_python/market/service.py,sha256=q3vQNzaVo4LG6TiIw_seexvPqJrhMI9HeNGTXZ3cph8,6683
@@ -38,12 +39,12 @@ etrade_python/transactions/models.py,sha256=u1mBMVBzPy4cvKOCsjRQaLWY2xnylWBZb1X_
 etrade_python/transactions/service.py,sha256=A5k_LLAzioqgmrGR-OH228RBk21BKHUSKJBo3W7clLA,5495
 etrade_python/transport/__init__.py,sha256=VaGqhPNrNnskVEwAgllywxW4pHE_9Kk0K8j5rf7o_T4,342
 etrade_python/transport/auth.py,sha256=eLXwnwdD7K5URBuyf9cdV-I4o2s-EYM7PUXic5sFGXs,669
-etrade_python/transport/http.py,sha256=O56r0q589CE-AoHlOJcykrzq9cvfxtVhg5Ri7R4nwV8,10204
+etrade_python/transport/http.py,sha256=jSs9U2PvCcDDIhMqsqYxTN_mb9cXGs1bjAnF3r7jVUA,10307
 etrade_python/transport/logging.py,sha256=743RBiSJPxLVM1aacs-nGWP_bV8SvPsBfOoHXTwir28,1129
 etrade_python/transport/response.py,sha256=BxOlKtphuwsdTEpjO-OkEL-Y-0GEaIShHtkMNNQKEPI,8905
 etrade_python/transport/retry.py,sha256=L7KzV-AoLPrnnttfIRGzhSh3U5rpuU8a8mnB_p4v_Z0,2627
-etrade_python-1.0.0.dist-info/METADATA,sha256=U3dh0vFjg9wN05QACd1P8nQyMIo4_2OipsYEJzgkyL4,21795
-etrade_python-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-etrade_python-1.0.0.dist-info/entry_points.txt,sha256=f4i6DI09N1yZdkyEiE48FA9ErB_FcvHCZd4Pm6TKukQ,53
-etrade_python-1.0.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-etrade_python-1.0.0.dist-info/RECORD,,
+etrade_python-1.1.0.dist-info/METADATA,sha256=guJIBSWElVQzh87e92P6flgZ0RXf-222JkW9moloJwI,26062
+etrade_python-1.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+etrade_python-1.1.0.dist-info/entry_points.txt,sha256=f4i6DI09N1yZdkyEiE48FA9ErB_FcvHCZd4Pm6TKukQ,53
+etrade_python-1.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+etrade_python-1.1.0.dist-info/RECORD,,