MPT-14767 E2E seeding proof of concept

- Added seeding proof of concept
- Fix create product request

Run: docker compose run --rm bash python seed/main.py

Author: albertsola

.github/copilot-instructions.md

@@ -0,0 +1,26 @@
+# GitHub Copilot Instructions
+
+## Project Context
+This is the MPT API Python Client for SoftwareOne Marketplace Platform.
+
+## Primary Instructions Source
+**⚠️ IMPORTANT**: Always reference and follow the comprehensive guidelines in `/AGENTS.md` before writing any code or tests. This file contains detailed project-specific instructions, patterns, and best practices.
+
+## Quick Reference
+- **Main instructions**: Read `/AGENTS.md` first and follow all guidelines
+- **Testing patterns**: Use function-based tests (not class-based) with comprehensive coverage
+- **Code style**: Type hints required, use mixins, implement both sync/async variants
+- **Architecture**: Follow service patterns with proper HTTP client integration
+
+## File References
+- **🔑 Primary Instructions**: `/AGENTS.md` - Complete development guidelines
+- **Configuration**: `/pyproject.toml` - Build and dependency configuration
+- **Test examples**: `/tests/` - Established testing patterns
+
+## Key Workflow
+1. **Read** `/AGENTS.md` for complete instructions
+2. **Analyze** existing code patterns in the relevant modules
+3. **Follow** established architectural patterns (mixins, services, models)
+4. **Implement** both sync and async variants
+5. **Test** with comprehensive coverage using function-based tests
+6. **Validate** with type checking and linting standards

AGENTS.md

@@ -0,0 +1,225 @@
+# AI Agent Guidelines for MPT API Python Client
+
+This document provides guidelines for AI coding assistants working on the SoftwareOne Marketplace API Python Client. Following these guidelines ensures consistent, maintainable, and high-quality code contributions.
+
+## Project Overview
+
+The MPT API Python Client is a modern Python library that provides both synchronous and asynchronous interfaces for interacting with the SoftwareOne Marketplace Platform API. The project emphasizes:
+
+- **Type Safety**: Comprehensive type hints using modern Python typing features
+- **Async/Sync Duality**: Full support for both synchronous and asynchronous operations
+- **Code Quality**: Strict linting, formatting, and testing standards
+- **Developer Experience**: Clear APIs, comprehensive testing, and good documentation
+
+## Project Structure
+
+- Code: `mpt_api_client/`
+  - `mpt_api_client/http/` - HTTP client to interact with HTTP endpoints
+  - `mpt_api_client/models/` - Base models
+  - `mpt_api_client/resources/` - Services that interact with the API resources
+  - `mpt_api_client/rql/` - RQL query builder
+  - `mpt_api_client/mpt_client.py` - Main entrypoint for the client class for sync and async operations
+- Unit tests: `tests/unit`
+- E2E tests: `tests/e2e`
+- Tests seeding: `tests/seed`
+- Configuration: `pyproject.toml` `.env` `setup.cfg`
+- Docker: `docker-compose.yml` `dev.Dockerfile` `prod.Dockerfile`
+
+## Build, test, and development
+
+- Linting and formatting: `ruff format` and `ruff check`
+- Type checking: `mypy` and `flake8`
+- Dependencies: `uv lock --check`
+- Testing: `pytest tests/unit`
+
+## Code Standards and Conventions
+
+### Python Version and Features
+- **Target Python Version**: 3.12+
+- **Modern Python Features**: Use generics, type annotations, pattern matching, and other modern Python features
+- **Type Hints**: All functions, methods, and variables must have type annotations
+- **Strict Mode**: The project uses `mypy --strict` - ensure all code passes strict type checking
+
+### Code Style and Formatting
+
+- Follow PEP 8 and project-specific linting rules
+- Use meaningful variable and function names
+- Keep functions focused and single-purpose
+- Document complex logic with clear comments
+- Use docstrings for public APIs
+
+### Architecture Patterns
+
+#### Mixin-Based Design
+The project uses mixins to compose functionality:
+
+```python
+class ProductsService(
+    CreateMixin["Product"],
+    ReadMixin["Product"],
+    UpdateMixin["Product"],
+    DeleteMixin,
+    BaseService["Product"],
+):
+    """Synchronous Products service."""
+```
+
+**When adding new functionality:**
+1. Create appropriate mixins in `mpt_api_client/http/mixins.py`
+2. Apply mixins to both sync and async service classes
+3. Ensure type safety with proper generic type parameters
+
+#### Sync/Async Duality
+Every service must have both synchronous and asynchronous versions:
+
+```python
+# Synchronous service
+class ProductsService(BaseMixins, BaseService["Product"]):
+    pass
+
+# Asynchronous service
+class AsyncProductsService(AsyncBaseMixins, AsyncBaseService["Product"]):
+    pass
+```
+
+**Key principles:**
+- Maintain API parity between sync and async versions
+- Use the same method signatures (except `async`/`await`)
+- Share test patterns and documentation
+
+### Testing Standards
+
+#### Test Structure
+- **Unit Tests**: Located in `tests/unit/` with parallel structure to source code
+- **Integration Tests**: Use `respx` for HTTP mocking
+- **Test Markers**: Use `pytest.mark.dataseed` for data seeding tests
+- **Async Testing**: Do not use `pytest.mark.asyncio` mark on async tests.
+
+#### Test Requirements
+1. **Both Sync and Async**: Every feature must have tests for both sync and async variants
+2. **Comprehensive Coverage**: Aim for 99% test coverage on new code
+3. **Mock External Calls**: Use `respx` to mock HTTP requests
+4. **Temporary Files**: Use `tmp_path` fixture for file operations
+
+Example test pattern:
+```python
+def test_feature_sync(service, tmp_path):
+    """Test synchronous feature."""
+    with respx.mock:
+        mock_route = respx.post("https://api.example.com/endpoint").mock(
+            return_value=httpx.Response(200, json=expected_response)
+        )
+
+        result = service.feature(data)
+
+
+    assert mock_route.call_count == 1
+    assert result.to_dict() == expected_response
+
+async def test_feature_sync(service, tmp_path):
+    """Test async feature."""
+    with respx.mock:
+        mock_route = respx.post("https://api.example.com/endpoint").mock(
+            return_value=httpx.Response(200, json=expected_response)
+        )
+
+        result = await service.feature(data)
+
+
+    assert mock_route.call_count == 1
+    assert result.to_dict() == expected_response
+```
+
+### Error Handling
+
+- **Custom Exceptions**: Use exceptions from `mpt_api_client.exceptions`
+- **HTTP Errors**: Let the HTTP client handle HTTP status codes
+- **Type Safety**: Ensure exceptions are properly typed and documented
+
+### Documentation Standards
+
+#### Docstrings
+- **Style**: Google docstring format
+- **Coverage**: All public classes, methods, and functions must have docstrings
+- **Type Information**: Include parameter and return types in docstrings
+- **Examples**: Provide usage examples where helpful
+
+#### Code Comments
+- **Purpose**: Explain why, not what
+- **Complex Logic**: Document non-obvious business logic
+- **TODO Items**: Use `# TODO:` for future improvements
+
+## Common Patterns and Best Practices
+
+### Resource Services Pattern
+```python
+class ResourceService(
+    CreateMixin["Resource"],
+    ReadMixin["Resource"],
+    UpdateMixin["Resource"],
+    DeleteMixin,
+    BaseService["Resource"],
+):
+    """Service for managing resources."""
+
+    _model_class = Resource
+    _path = "/endpoint/path"
+
+    def custom_action(self, resource_id: str, data: dict) -> Resource:
+        """Custom resource action."""
+        response = self._resource_do_request(
+            resource_id, "POST", path_suffix="/action", json=data
+        )
+        return self._model_class.from_response(response)
+```
+
+### Model Definition Pattern
+```python
+from mpt_api_client.models import Model
+
+class Resource(Model):
+    """Resource model."""
+
+    @property
+    def computed_field(self) -> str:
+        """Computed field based on other attributes."""
+        return f"{self.name}-{self.id}"
+```
+
+### Type Safety Guidelines
+- Use generics for reusable components
+- Prefer `typing.Self` for methods returning instance type
+- Use union types (`|`) over `Union` for Python 3.10+
+- Avoid `Any` type - use proper type constraints
+
+### Performance Considerations
+- Use async methods for I/O-bound operations
+- Implement proper streaming for large responses
+- Cache expensive computations appropriately
+- Use lazy loading patterns where beneficial
+
+## Testing Anti-Patterns to Avoid
+
+1. **Don't test implementation details** - test behavior, not internal structure
+2. **Don't use real HTTP calls** - always mock external dependencies
+3. **Don't ignore async variants** - every sync test needs an async equivalent
+4. **Don't skip error cases** - test both success and failure scenarios
+5. **Don't use hardcoded values** - use fixtures and parameterized tests
+
+## Security Considerations
+
+- **No secrets in code**: Use environment variables or secure vaults
+- **Input validation**: Validate all inputs, especially from external sources
+- **Path traversal**: Be careful with file operations and path handling
+- **Dependency scanning**: Regular updates and security scanning
+
+## Contributing Guidelines
+
+When adding new features:
+
+1. **Plan the API**: Design both sync and async interfaces
+2. **Implement mixins first**: Create reusable mixin components
+3. **Add comprehensive tests**: Unit tests for both sync and async
+4. **Update documentation**: Include docstrings and examples
+5. **Check type safety**: Ensure `mypy --strict` passes
+6. **Validate with linters**: Run `ruff check` and `ruff format`

mpt_api_client/http/async_service.py

@@ -31,19 +31,20 @@ async def _resource_do_request(  # noqa: WPS211
     ) -> Response:
         """Perform an action on a specific resource using.
 
-        Request with action: `HTTP_METHOD /endpoint/{resource_id}/{action}`.
-        Request without action: `HTTP_METHOD /endpoint/{resource_id}`.
+        :Loading parameter group
+                Request with action: `HTTP_METHOD /endpoint/{resource_id}/{action}`.
+                Request without action: `HTTP_METHOD /endpoint/{resource_id}`.
 
         Args:
-            resource_id: The resource ID to operate on.
-            method: The HTTP method to use.
-            action: The action name to use.
-            json: The updated resource data.
-            query_params: Additional query parameters.
-            headers: Additional headers.
+                    resource_id: The resource ID to operate on.
+                    method: The HTTP method to use.
+                    action: The action name to use.
+                    json: The updated resource data.
+                    query_params: Additional query parameters.
+                    headers: Additional headers.
 
         Raises:
-            HTTPError: If the action fails.
+                    HTTPError: If the action fails.
         """
         resource_url = urljoin(f"{self.path}/", resource_id)
         url = urljoin(f"{resource_url}/", action) if action else resource_url

mpt_api_client/http/client.py

@@ -49,7 +49,6 @@ def __init__(
         base_headers = {
             "User-Agent": "swo-marketplace-client/1.0",
             "Authorization": f"Bearer {api_token}",
-            "content-type": "application/json",
         }
         self.httpx_client = Client(
             base_url=base_url,

mpt_api_client/http/mixins.py

@@ -86,7 +86,6 @@ def create(
                 _json_to_file_payload(resource_data),
                 "application/json",
             )
-
         response = self.http_client.request("post", self.path, files=files)  # type: ignore[attr-defined]
 
         return self._model_class.from_response(response)  # type: ignore[attr-defined, no-any-return]

mpt_api_client/models/model.py

@@ -52,6 +52,11 @@ def from_response(cls, response: Response) -> Self:
         meta = Meta.from_response(response)
         return cls.new(response_data, meta)
 
+    @property
+    def id(self) -> str:
+        """Returns the resource ID."""
+        return str(self._resource_data.get("id", ""))  # type: ignore[no-untyped-call]
+
     def to_dict(self) -> dict[str, Any]:
         """Returns the resource as a dictionary."""
         return self._resource_data.to_dict()