Merge pull request #704 from atlanhq/bump-to-release-8.0.0

[release] Bump to release `8.0.0`

Author: Aryamanz29

HISTORY.md

@@ -1,3 +1,83 @@
+## 8.0.0 (August 20, 2025)
+
+### New Features
+
+#### Full `async/await` support
+
+- Added `async/await` support to the SDK. All existing `clients` and `caches` now have async variants, plus new models (mainly search result models that require `async` iteration). Following `aio` directory convention for all async components.
+- Implemented `AsyncAtlanClient` for all async operations (extends `AtlanClient` for reusability).
+- For methods that accept client parameters, we've added corresponding `*_async()` variants:
+
+| sync method | async method |
+|------------|--------------|
+| `Connection.creator()` | `Connection.creator_async()` |
+| `Badge.creator()` | `Badge.creator_async()` |
+| `FluentSearch.execute()` | `FluentSearch.execute_async()` |
+| `AtlanTag.of()` | `AtlanTag.of_async()` |
+| `SourceTagAttachment.by_name()` | `SourceTagAttachment.by_name_async()` |
+| `CompoundQuery.tagged_with_value()` | `CompoundQuery.tagged_with_value_async()` |
+| `Referenceable.json()` | `Referenceable.json_async()` |
+| `Referenceable.get_custom_metadata()` | `Referenceable.get_custom_metadata_async()` |
+| `Referenceable.set_custom_metadata()` | `Referenceable.set_custom_metadata_async()` |
+| `Referenceable.flush_custom_metadata()` | `Referenceable.flush_custom_metadata_async()` |
+
+#### Shared business logic architecture
+
+- Extracted common functionality (request preparation and response processing) into a separate `common` sub-package. This enables reuse across both sync and async operations - only the middle layer (API calling with respective clients) differs.
+
+Example:
+```python
+from pyatlan.client.common import FindPurposesByName
+
+@validate_arguments
+async def find_purposes_by_name(
+    self,
+    name: str,
+    attributes: Optional[List[str]] = None,
+) -> List[Purpose]:
+    """
+    Async find purposes by name using shared business logic.
+    :param name: of the purpose
+    :param attributes: (optional) collection of attributes to retrieve for the purpose
+    :returns: all purposes with that name, if found
+    :raises NotFoundError: if no purpose with the provided name exists
+    """
+    search_request = FindPurposesByName.prepare_request(name, attributes)
+    search_results = await self.search(search_request)
+    return FindPurposesByName.process_response(
+        search_results, name, allow_multiple=True
+    )
+```
+
+### Documentation
+
+- **Asynchronous SDK operations**: https://developer.atlan.com/sdks/python/#asynchronous-sdk-operations
+
+### Breaking Changes
+
+While these aren't direct breaking changes to the SDK API, they may affect your code if you depend on these libraries:
+
+- **Migrated from [`requests`](https://requests.readthedocs.io/en/latest) to [`httpx`](https://www.python-httpx.org)**: Completely removed support for `requests` library and migrated to `httpx`, which provides similar API for `sync` operations plus `async` client support for async operations.
+- **Replaced [`urllib3`](https://urllib3.readthedocs.io/en/stable) with [`httpx-retries`](https://will-ockmore.github.io/httpx-retries)**: Removed support for `urllib3` retry mechanism and implemented retries using `httpx-retries` library (API remains similar).
+
+### QOL Improvements
+
+- Generated latest typedef models.
+- Removed redundant requirements files (no longer needed since migration to `uv` in previous releases).
+- Updated GitHub workflows for Docker image builds to use `uv sync` (without dev dependencies).
+- Added unit and integration tests for `async` SDK.
+- Added `x-atlan-client-type: sync` or `x-atlan-client-type: async` to SDK headers and logging for better observability.
+- Added `async-integration-tests` job to `pyatlan-pr.yaml` workflow. Triggers when there are changes to async SDK code or can be triggered manually via `run-async-tests` label on PR.
+- Async SDK unit tests run by default on every commit push as they have minimal time impact on test suite.
+- Used module-scoped asyncio test fixtures similar to sync integration tests:
+  ```toml
+  # pyproject.toml
+  asyncio_mode = "auto"
+  asyncio_default_test_loop_scope = "module"
+  asyncio_default_fixture_loop_scope = "module"
+  ```
+- Used `token_client` fixtures when creating/deleting API tokens with `retry=0` to avoid token overpopulation in test tenants.
+
 ## 7.2.0 (August 13, 2025)
 
 ### New Features

README.md

@@ -206,6 +206,98 @@ This will:
 - 🎨 Format code automatically
 - ⚡ Support incremental updates
 
+## 📁 Project Structure
+
+Understanding the codebase layout will help you navigate and contribute effectively:
+
+```
+atlan-python/
+├── pyatlan/                          # 🐍 Main Python package
+│   ├── __init__.py                   # Package initialization
+│   ├── cache/                        # 💾 Caching mechanisms
+│   │   ├── atlan_tag_cache.py       # Tag name ↔ GUID mapping
+│   │   ├── custom_metadata_cache.py  # Custom metadata definitions
+│   │   ├── enum_cache.py            # Enum value caching
+│   │   └── aio/                     # Async versions of caches
+│   ├── client/                       # 🌐 HTTP client implementations
+│   │   ├── atlan.py                 # Main synchronous client
+│   │   ├── asset.py                 # Asset operations (CRUD, search)
+│   │   ├── admin.py                 # Administrative operations
+│   │   ├── audit.py                 # Audit log operations
+│   │   ├── common/                  # Shared client logic
+│   │   └── aio/                     # Async client implementations
+│   ├── model/                        # 📊 Data models and assets
+│   │   ├── assets/                  # Asset type definitions
+│   │   │   ├── core/                # Core asset types (Table, Database, etc.)
+│   │   │   └── relations/           # Relationship models
+│   │   ├── fields/                  # Search field definitions
+│   │   ├── open_lineage/            # OpenLineage specification models
+│   │   ├── packages/                # Package/workflow models
+│   │   └── aio/                     # Async model variants
+│   ├── generator/                    # 🏗️ Code generation tools
+│   │   ├── templates/               # Jinja2 templates for generation
+│   │   └── class_generator.py       # Main generation logic
+│   ├── pkg/                         # 📦 Package creation utilities
+│   ├── events/                      # 🔔 Event handling (webhooks, lambdas)
+│   ├── samples/                     # 💡 Example code and scripts
+│   └── test_utils/                  # 🧪 Testing utilities
+├── tests/                            # 🧪 Test suite
+│   ├── unit/                        # Unit tests (fast, no external deps)
+│   ├── integration/                 # Integration tests (require Atlan instance)
+│   └── data/                        # Test fixtures and mock data
+├── docs/                            # 📚 Sphinx documentation
+│   ├── conf.py                      # Sphinx configuration
+│   └── *.rst                       # Documentation source files
+├── pyproject.toml                   # 📋 Project configuration (deps, tools)
+├── uv.lock                          # 🔒 Locked dependencies
+├── qa-checks                        # ✅ Quality assurance script
+├── formatter                        # 🎨 Code formatting script
+└── generator                        # 🏗️ Model generation script
+```
+
+### Key Components
+
+#### 🌐 **Client Layer** (`pyatlan/client/`)
+- **Synchronous**: Direct HTTP operations using `httpx`
+- **Asynchronous**: Async/await operations using `httpx.AsyncClient`
+- **Common**: Shared business logic between sync/async clients
+- **Specialized**: Domain-specific clients (admin, audit, lineage, etc.)
+
+#### 📊 **Model Layer** (`pyatlan/model/`)
+- **Assets**: 400+ asset types (tables, dashboards, pipelines, etc.)
+- **Core Models**: Base classes, requests, responses
+- **Fields**: Search and filtering field definitions
+- **OpenLineage**: Data lineage specification compliance
+
+#### 💾 **Cache Layer** (`pyatlan/cache/`)
+- **Tag Cache**: Maps human-readable tag names to internal GUIDs
+- **Custom Metadata**: Caches custom attribute definitions
+- **Connection Cache**: Stores connector and connection metadata
+- **Async Variants**: Full async implementations for all caches
+
+#### 🏗️ **Generation System** (`pyatlan/generator/`)
+- **Templates**: Jinja2 templates for assets, enums, documentation
+- **Generator**: Retrieves typedefs and generates Python models
+- **Incremental**: Only regenerates changed models for efficiency
+
+#### 🧪 **Testing Strategy**
+- **Unit Tests**: Fast, isolated tests with mocks/fixtures
+- **Integration Tests**: Real API calls (requires credentials)
+- **VCR Cassettes**: Record/replay HTTP interactions for consistent testing
+
+#### 📦 **Package System** (`pyatlan/pkg/`)
+- **Custom Packages**: Framework for building Atlan-deployable packages
+- **Templates**: Pre-built package structures and configurations
+- **Utilities**: Helper functions for package development
+
+### Development Workflow
+
+1. **Models**: Generated from your Atlan instance's typedefs
+2. **Clients**: Hand-crafted for optimal developer experience  
+3. **Tests**: Mix of unit (fast iteration) and integration (real validation)
+4. **Quality**: Automated formatting, linting, and type checking
+5. **Documentation**: Auto-generated from docstrings and examples
+
 ## 📄 License
 
 This project is licensed under the **Apache License 2.0** - see the [LICENSE](LICENSE) file for details.

pyatlan/version.txt

@@ -1 +1 @@
-7.2.0
+8.0.0

pyproject.toml

@@ -30,7 +30,6 @@ dependencies = [
     "pydantic~=2.11.7",
     "jinja2~=3.1.6",
     "tenacity~=9.1.2",
-    "urllib3>=1.26.0,<3",
     "lazy_loader~=0.4",
     "nanoid~=2.0.0",
     "pytz~=2025.2",
@@ -114,5 +113,4 @@ asyncio_default_test_loop_scope = "module"
 asyncio_default_fixture_loop_scope = "module"
 filterwarnings = [
     "ignore::DeprecationWarning",
-    "ignore:urllib3 v2 only supports OpenSSL 1.1.1+",
 ]