miso-client 0.2.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

miso_client/utils/sensitive_fields_loader.py

@@ -0,0 +1,116 @@
+"""
+Sensitive fields configuration loader for ISO 27001 compliance.
+
+This module provides utilities to load and merge sensitive fields configuration
+from JSON files, supporting custom configuration paths and environment variables.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Default path to sensitive fields config relative to this file
+_DEFAULT_CONFIG_PATH = Path(__file__).parent / "sensitive_fields_config.json"
+
+
+def load_sensitive_fields_config(
+    config_path: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Load sensitive fields configuration from JSON file.
+
+    Supports custom path via:
+    1. config_path parameter
+    2. MISO_SENSITIVE_FIELDS_CONFIG environment variable
+    3. Default path: miso_client/utils/sensitive_fields_config.json
+
+    Args:
+        config_path: Optional custom path to JSON config file
+
+    Returns:
+        Dictionary with 'fields' and 'fieldPatterns' keys
+        Returns empty dict if file cannot be loaded
+
+    Example:
+        >>> config = load_sensitive_fields_config()
+        >>> fields = config.get('fields', {})
+    """
+    # Priority: parameter > environment variable > default
+    if config_path:
+        file_path = Path(config_path)
+    elif os.environ.get("MISO_SENSITIVE_FIELDS_CONFIG"):
+        file_path = Path(os.environ["MISO_SENSITIVE_FIELDS_CONFIG"])
+    else:
+        file_path = _DEFAULT_CONFIG_PATH
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+            # Validate structure
+            if isinstance(config, dict):
+                return config
+            return {}
+    except (FileNotFoundError, json.JSONDecodeError, IOError, OSError):
+        # File not found, invalid JSON, or permission error
+        # Return empty dict - fallback to hardcoded defaults
+        return {}
+
+
+def get_sensitive_fields_array(
+    config_path: Optional[str] = None,
+) -> List[str]:
+    """
+    Get flattened array of all sensitive field names from configuration.
+
+    Args:
+        config_path: Optional custom path to JSON config file
+
+    Returns:
+        Flattened list of all sensitive field names from all categories
+        Returns empty list if config cannot be loaded
+
+    Example:
+        >>> fields = get_sensitive_fields_array()
+        >>> assert 'password' in fields
+        >>> assert 'token' in fields
+    """
+    config = load_sensitive_fields_config(config_path)
+    fields_dict = config.get("fields", {})
+
+    # Flatten all categories into single list
+    all_fields: List[str] = []
+    if isinstance(fields_dict, dict):
+        for category_fields in fields_dict.values():
+            if isinstance(category_fields, list):
+                all_fields.extend(category_fields)
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_fields = []
+    for field in all_fields:
+        if field.lower() not in seen:
+            seen.add(field.lower())
+            unique_fields.append(field)
+
+    return unique_fields
+
+
+def get_field_patterns(config_path: Optional[str] = None) -> List[str]:
+    """
+    Get field pattern matching rules from configuration.
+
+    Args:
+        config_path: Optional custom path to JSON config file
+
+    Returns:
+        List of field pattern matching rules
+        Returns empty list if config cannot be loaded or no patterns defined
+
+    Example:
+        >>> patterns = get_field_patterns()
+        >>> # Patterns can be regex patterns or simple matching rules
+    """
+    config = load_sensitive_fields_config(config_path)
+    patterns = config.get("fieldPatterns", [])
+    return patterns if isinstance(patterns, list) else []

miso_client/utils/sort.py

@@ -0,0 +1,116 @@
+"""
+Sort utilities for MisoClient SDK.
+
+This module provides reusable sort utilities for parsing sort parameters
+and building sort query strings.
+"""
+
+from typing import List
+from urllib.parse import quote
+
+from ..models.sort import SortOption
+
+
+def parse_sort_params(params: dict) -> List[SortOption]:
+    """
+    Parse sort query parameters into SortOption list.
+
+    Parses `?sort=-field` format into SortOption objects.
+    Supports multiple sort parameters (array of sort strings).
+    Prefix with '-' for descending order, otherwise ascending.
+
+    Args:
+        params: Dictionary with query parameters (e.g., {'sort': '-updated_at'} or {'sort': ['-updated_at', 'created_at']})
+
+    Returns:
+        List of SortOption objects
+
+    Examples:
+        >>> parse_sort_params({'sort': '-updated_at'})
+        [SortOption(field='updated_at', order='desc')]
+        >>> parse_sort_params({'sort': ['-updated_at', 'created_at']})
+        [SortOption(field='updated_at', order='desc'), SortOption(field='created_at', order='asc')]
+    """
+    sort_options: List[SortOption] = []
+
+    # Get sort parameter (can be string or list)
+    sort_param = params.get("sort")
+    if not sort_param:
+        return sort_options
+
+    # Normalize to list
+    if isinstance(sort_param, str):
+        sort_strings = [sort_param]
+    elif isinstance(sort_param, list):
+        sort_strings = sort_param
+    else:
+        return sort_options
+
+    # Parse each sort string
+    for sort_str in sort_strings:
+        if not isinstance(sort_str, str):
+            continue
+
+        sort_str = sort_str.strip()
+        if not sort_str:
+            continue
+
+        # Check for descending order (prefix with '-')
+        if sort_str.startswith("-"):
+            field = sort_str[1:].strip()
+            order = "desc"
+        else:
+            field = sort_str.strip()
+            order = "asc"
+
+        if field:
+            sort_options.append(SortOption(field=field, order=order))
+
+    return sort_options
+
+
+def build_sort_string(sort_options: List[SortOption]) -> str:
+    """
+    Convert SortOption list to query string format.
+
+    Converts SortOption objects to sort query string format.
+    Descending order fields are prefixed with '-'.
+
+    Args:
+        sort_options: List of SortOption objects
+
+    Returns:
+        Sort query string (e.g., '-updated_at,created_at' or single value '-updated_at')
+
+    Examples:
+        >>> from miso_client.models.sort import SortOption
+        >>> sort_options = [SortOption(field='updated_at', order='desc')]
+        >>> build_sort_string(sort_options)
+        '-updated_at'
+        >>> sort_options = [
+        ...     SortOption(field='updated_at', order='desc'),
+        ...     SortOption(field='created_at', order='asc')
+        ... ]
+        >>> build_sort_string(sort_options)
+        '-updated_at,created_at'
+    """
+    if not sort_options:
+        return ""
+
+    sort_strings: List[str] = []
+    for sort_option in sort_options:
+        field = sort_option.field
+        order = sort_option.order
+
+        # URL encode field name
+        field_encoded = quote(field)
+
+        # Add '-' prefix for descending order
+        if order == "desc":
+            sort_strings.append(f"-{field_encoded}")
+        else:
+            sort_strings.append(field_encoded)
+
+    # Join multiple sorts with comma (if needed for single sort param)
+    # Or return as comma-separated string
+    return ",".join(sort_strings)

{miso_client-0.2.0.dist-info → miso_client-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: miso-client
-Version: 0.2.0
+Version: 0.5.0
 Summary: Python client SDK for AI Fabrix authentication, authorization, and logging
 Home-page: https://github.com/aifabrix/miso-client-python
 Author: AI Fabrix Team
@@ -80,10 +80,13 @@ The **AI Fabrix Miso Client SDK** provides authentication, authorization, and lo
 ### 📊 Compliance & Audit
 
 **ISO 27001 Compliance**
-- Comprehensive audit trails for all user actions
+- Comprehensive audit trails for all user actions and HTTP requests
+- Automatic data masking for all sensitive information in logs
+- HTTP request/response audit logging with masked sensitive data
 - Data access logging and monitoring
 - Security event tracking
 - Accountability and non-repudiation
+- Configurable sensitive fields via JSON configuration
 
 **Regulatory Compliance**
 - GDPR-ready data protection
@@ -134,9 +137,13 @@ The **AI Fabrix Miso Client SDK** provides authentication, authorization, and lo
 
 **Observability**
 - Centralized logging with correlation IDs
+- Automatic HTTP request/response audit logging (ISO 27001 compliant)
+- Debug logging with detailed request/response information (when `log_level='debug'`)
 - Performance tracking and metrics
 - Error tracking and debugging
 - Health monitoring
+- Automatic data masking for sensitive information in logs
+- Configurable sensitive fields via JSON configuration
 
 ---
 
@@ -262,7 +269,7 @@ if is_admin:
 
 ### Step 5: Activate Logging
 
-**What happens:** Application logs are sent to the Miso Controller with client token authentication.
+**What happens:** Application logs are sent to the Miso Controller with client token authentication. All HTTP requests are automatically audited with ISO 27001 compliant data masking.
 
 ```python
 from miso_client import MisoClient, load_config
@@ -278,10 +285,17 @@ user = await client.get_user(token)
 await client.log.info('User accessed dashboard', {'userId': user.id if user else None})
 await client.log.error('Operation failed', {'error': str(err)})
 await client.log.warn('Unusual activity', {'details': '...'})
+
+# HTTP requests are automatically audited
+# All sensitive data is automatically masked before logging
+result = await client.http_client.get('/api/users')
+# This automatically creates an audit log: http.request.GET with masked sensitive data
 ```
 
 **What happens to logs?** They're sent to the Miso Controller for centralized monitoring and analysis. Client token is automatically included.
 
+**ISO 27001 Compliance:** All HTTP requests are automatically audited with sensitive data masked. Set `log_level='debug'` to enable detailed request/response logging (all sensitive data is still masked).
+
 → [Complete logging example](examples/step-5-logging.py)  
 → [Logging Reference](docs/api-reference.md#logger-service)
 
@@ -414,6 +428,7 @@ config = MisoClientConfig(
         port=6379,
     ),
     log_level="info",                         # Optional: 'debug' | 'info' | 'warn' | 'error'
+                                              # Set to 'debug' for detailed HTTP request/response logging
     api_key="your-test-api-key",              # Optional: API key for testing (bypasses OAuth2)
     cache={                                   # Optional: Cache TTL settings
         "role_ttl": 900,       # Role cache TTL (default: 900s)
@@ -424,6 +439,18 @@ config = MisoClientConfig(
 
 **Recommended:** Use `load_config()` to load from `.env` file automatically.
 
+**ISO 27001 Data Masking Configuration:**
+
+Sensitive fields are configured via `miso_client/utils/sensitive_fields_config.json`. You can customize this by:
+
+1. Setting `MISO_SENSITIVE_FIELDS_CONFIG` environment variable to point to a custom JSON file
+2. Using `DataMasker.set_config_path()` to set a custom path programmatically
+
+The default configuration includes ISO 27001 compliant sensitive fields:
+- Authentication: password, token, secret, key, auth, authorization
+- PII: ssn, creditcard, cc, cvv, pin, otp
+- Security: apikey, accesstoken, refreshtoken, privatekey, secretkey, cookie, session
+
 → [Complete Configuration Reference](docs/configuration.md)
 
 ---
@@ -448,6 +475,28 @@ The SDK consists of five core services:
 - **LoggerService** - Centralized logging with API key authentication
 - **RedisService** - Caching and queue management (optional)
 
+### HTTP Client Architecture
+
+The SDK uses a two-layer HTTP client architecture for ISO 27001 compliance:
+
+- **InternalHttpClient** - Core HTTP functionality with automatic client token management (internal)
+- **HttpClient** - Public wrapper that adds automatic ISO 27001 compliant audit and debug logging
+
+**Features:**
+- Automatic audit logging for all HTTP requests (`http.request.{METHOD}`)
+- Debug logging when `log_level === 'debug'` with detailed request/response information
+- Automatic data masking using `DataMasker` before logging (ISO 27001 compliant)
+- Sensitive endpoints (`/api/logs`, `/api/auth/token`) are excluded from audit logging to prevent infinite loops
+- All sensitive data (headers, bodies, query params) is automatically masked before logging
+
+**ISO 27001 Compliance:**
+- All request headers are masked (Authorization, x-client-token, Cookie, etc.)
+- All request bodies are recursively masked for sensitive fields (password, token, secret, SSN, etc.)
+- All response bodies are masked (limited to first 1000 characters)
+- Query parameters are automatically masked
+- Error messages are masked if they contain sensitive data
+- Sensitive fields configuration can be customized via `sensitive_fields_config.json`
+
 → [Architecture Details](docs/api-reference.md#architecture)
 
 ---
@@ -485,6 +534,302 @@ The SDK consists of five core services:
 - [Flask Decorators](docs/examples.md#flask-decorators) - Decorator-based auth
 - [Error Handling](docs/examples.md#error-handling) - Best practices
 
+---
+
+### Structured Error Responses
+
+**What happens:** The SDK automatically parses structured error responses from the API (RFC 7807-style format) and makes them available through the `MisoClientError` exception.
+
+```python
+from miso_client import MisoClient, MisoClientError, ErrorResponse, load_config
+
+client = MisoClient(load_config())
+await client.initialize()
+
+try:
+    result = await client.http_client.get("/api/some-endpoint")
+except MisoClientError as e:
+    # Check if structured error response is available
+    if e.error_response:
+        print(f"Error Type: {e.error_response.type}")
+        print(f"Error Title: {e.error_response.title}")
+        print(f"Status Code: {e.error_response.statusCode}")
+        print(f"Errors: {e.error_response.errors}")
+        print(f"Instance: {e.error_response.instance}")
+    else:
+        # Fallback to traditional error handling
+        print(f"Error: {e.message}")
+        print(f"Status Code: {e.status_code}")
+        print(f"Error Body: {e.error_body}")
+```
+
+**Error Response Structure:**
+
+The `ErrorResponse` model follows RFC 7807-style format:
+
+```json
+{
+   "errors": [
+      "The user has provided input that the browser is unable to convert.",
+      "There are multiple rows in the database for the same value"
+   ],
+   "type": "/Errors/Bad Input",
+   "title": "Bad Request",
+   "statusCode": 400,
+   "instance": "/OpenApi/rest/Xzy"
+}
+```
+
+**Features:**
+
+- **Automatic Parsing**: Structured error responses are automatically parsed from HTTP responses
+- **Backward Compatible**: Falls back to traditional error handling when structured format is not available
+- **Type Safety**: Full type hints with Pydantic models for reliable error handling
+- **Generic Interface**: `ErrorResponse` model can be reused across different applications
+- **Instance URI**: Automatically extracted from request URL if not provided in response
+
+**Using ErrorResponse directly:**
+
+```python
+from miso_client import ErrorResponse
+
+# Create ErrorResponse from dict
+error_data = {
+    "errors": ["Validation failed"],
+    "type": "/Errors/Validation",
+    "title": "Validation Error",
+    "statusCode": 422,
+    "instance": "/api/endpoint"
+}
+error_response = ErrorResponse(**error_data)
+
+# Access fields
+print(error_response.errors)  # ["Validation failed"]
+print(error_response.type)    # "/Errors/Validation"
+print(error_response.title)   # "Validation Error"
+print(error_response.statusCode)  # 422
+print(error_response.instance)   # "/api/endpoint"
+```
+
+---
+
+### Pagination, Filtering, and Sorting Utilities
+
+**What happens:** The SDK provides reusable utilities for pagination, filtering, sorting, and error handling that work with any API endpoint.
+
+#### Pagination
+
+**Pagination Parameters:**
+- `page`: Page number (1-based, defaults to 1)
+- `page_size`: Number of items per page (defaults to 25)
+
+```python
+from miso_client import (
+    parse_pagination_params,
+    create_paginated_list_response,
+    PaginatedListResponse,
+)
+
+# Parse pagination from query parameters
+params = {"page": "1", "page_size": "25"}
+current_page, page_size = parse_pagination_params(params)
+
+# Create paginated response
+items = [{"id": 1}, {"id": 2}]
+response = create_paginated_list_response(
+    items,
+    total_items=120,
+    current_page=1,
+    page_size=25,
+    type="item"
+)
+
+# Response structure:
+# {
+#   "meta": {
+#     "total_items": 120,
+#     "current_page": 1,
+#     "page_size": 25,
+#     "type": "item"
+#   },
+#   "data": [{"id": 1}, {"id": 2}]
+# }
+```
+
+#### Filtering
+
+**Filter Operators:** `eq`, `neq`, `in`, `nin`, `gt`, `lt`, `gte`, `lte`, `contains`, `like`
+
+**Filter Format:** `field:op:value` (e.g., `status:eq:active`)
+
+```python
+from miso_client import FilterBuilder, parse_filter_params, build_query_string
+
+# Dynamic filter building with FilterBuilder
+filter_builder = FilterBuilder() \
+    .add('status', 'eq', 'active') \
+    .add('region', 'in', ['eu', 'us']) \
+    .add('created_at', 'gte', '2024-01-01')
+
+# Get query string
+query_string = filter_builder.to_query_string()
+# Returns: "filter=status:eq:active&filter=region:in:eu,us&filter=created_at:gte:2024-01-01"
+
+# Parse existing filter parameters
+params = {'filter': ['status:eq:active', 'region:in:eu,us']}
+filters = parse_filter_params(params)
+# Returns: [FilterOption(field='status', op='eq', value='active'), ...]
+
+# Use with HTTP client
+response = await client.http_client.get_with_filters(
+    '/api/items',
+    filter_builder=filter_builder
+)
+```
+
+**Building Complete Filter Queries:**
+
+```python
+from miso_client import FilterQuery, FilterOption, build_query_string
+
+# Create filter query with filters, sort, pagination, and fields
+filter_query = FilterQuery(
+    filters=[
+        FilterOption(field='status', op='eq', value='active'),
+        FilterOption(field='region', op='in', value=['eu', 'us'])
+    ],
+    sort=['-updated_at', 'created_at'],
+    page=1,
+    page_size=25,
+    fields=['id', 'name', 'status']
+)
+
+# Build query string
+query_string = build_query_string(filter_query)
+```
+
+#### Sorting
+
+**Sort Format:** `-field` for descending, `field` for ascending (e.g., `-updated_at`, `created_at`)
+
+```python
+from miso_client import parse_sort_params, build_sort_string, SortOption
+
+# Parse sort parameters
+params = {'sort': '-updated_at'}
+sort_options = parse_sort_params(params)
+# Returns: [SortOption(field='updated_at', order='desc')]
+
+# Parse multiple sorts
+params = {'sort': ['-updated_at', 'created_at']}
+sort_options = parse_sort_params(params)
+# Returns: [
+#   SortOption(field='updated_at', order='desc'),
+#   SortOption(field='created_at', order='asc')
+# ]
+
+# Build sort string
+sort_options = [
+    SortOption(field='updated_at', order='desc'),
+    SortOption(field='created_at', order='asc')
+]
+sort_string = build_sort_string(sort_options)
+# Returns: "-updated_at,created_at"
+```
+
+#### Combined Usage
+
+**Pagination + Filter + Sort:**
+
+```python
+from miso_client import (
+    FilterBuilder,
+    FilterQuery,
+    build_query_string,
+    parse_pagination_params,
+)
+
+# Build filters
+filter_builder = FilterBuilder() \
+    .add('status', 'eq', 'active') \
+    .add('region', 'in', ['eu', 'us'])
+
+# Parse pagination
+params = {'page': '1', 'page_size': '25'}
+current_page, page_size = parse_pagination_params(params)
+
+# Create complete query
+filter_query = FilterQuery(
+    filters=filter_builder.build(),
+    sort=['-updated_at'],
+    page=current_page,
+    page_size=page_size
+)
+
+# Build query string
+query_string = build_query_string(filter_query)
+
+# Use with HTTP client
+response = await client.http_client.get_with_filters(
+    '/api/items',
+    filter_builder=filter_builder,
+    params={'page': current_page, 'page_size': page_size}
+)
+```
+
+**Or use pagination helper:**
+
+```python
+# Get paginated response
+response = await client.http_client.get_paginated(
+    '/api/items',
+    page=1,
+    page_size=25
+)
+
+# Response is automatically parsed as PaginatedListResponse
+print(response.meta.total_items)  # 120
+print(response.meta.current_page)  # 1
+print(len(response.data))  # 25
+```
+
+#### Metadata Filter Integration
+
+**Working with `/metadata/filter` endpoint:**
+
+```python
+# Get metadata filters from endpoint
+metadata_response = await client.http_client.post(
+    "/api/v1/metadata/filter",
+    {"documentStorageKey": "my-doc-storage"}
+)
+
+# Convert AccessFieldFilter to FilterBuilder
+filter_builder = FilterBuilder()
+for access_filter in metadata_response.mandatoryFilters:
+    filter_builder.add(access_filter.field, 'in', access_filter.values)
+
+# Use with query utilities
+query_string = filter_builder.to_query_string()
+
+# Apply to API requests
+response = await client.http_client.get_with_filters(
+    '/api/items',
+    filter_builder=filter_builder
+)
+```
+
+**Features:**
+
+- **Snake_case Convention**: All utilities use snake_case to match Miso/Dataplane API
+- **Type Safety**: Full type hints with Pydantic models
+- **Dynamic Filtering**: FilterBuilder supports method chaining for complex filters
+- **Local Testing**: `apply_filters()` and `apply_pagination_to_array()` for local filtering/pagination in tests
+- **URL Encoding**: Automatic URL encoding for field names and values
+- **Backward Compatible**: Works alongside existing HTTP client methods
+
+---
+
 ### Common Tasks
 
 **Add authentication middleware (FastAPI):**

miso_client-0.5.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+miso_client/__init__.py,sha256=iDpRsYBbBDrLQFNJdtDlv4yrg1pvwNZpD2C3TYAyOSo,15595
+miso_client/errors.py,sha256=uyS5j-_bUCA5gbINPYQd0wMpGsaEH0tJRK0obQTq2oo,1976
+miso_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+miso_client/models/__init__.py,sha256=lMnzU7j2Z5_UehvOeIrbJIo3MH4j5KINGfU1vJTzTyU,139
+miso_client/models/config.py,sha256=TLckmwajrdnJpMTsjCtaFkz8wFAXcEQJfKjXQ8ww6vM,8024
+miso_client/models/error_response.py,sha256=YBQkchdWOo6NjdNpLlOvGaIhOwA1MJzkTS2oeU0e2Mk,1694
+miso_client/models/filter.py,sha256=3XWVxAjtUP78KPocd4-Ko9SijeRXm3jWVVBCXDPnXuI,4111
+miso_client/models/pagination.py,sha256=f-YbspLrQH3ZhDYzbMCTloeKF2EyaSi7zjFLgh6dhBQ,2078
+miso_client/models/sort.py,sha256=CutVQnYC4uRgesJ8zgd4OmPGZIop1KzvtgiTjNproSM,621
+miso_client/services/__init__.py,sha256=2ok62Z9kaS0Zze-OxRkxEJ4JidzN9jL_pzGMOxpZppQ,489
+miso_client/services/auth.py,sha256=hYnHEoTNgeH_g0ItoVDq99fBZCZX0o-0o-9gRxqZYmw,5465
+miso_client/services/cache.py,sha256=lXcLcRm56snOX3AQiEKi-j7FIikCLYnEK2HXxBkxm2M,6510
+miso_client/services/encryption.py,sha256=8512ACLt0P8t3W_CGzmG0JRSvzDinvjPRvkifdDxIRs,3022
+miso_client/services/logger.py,sha256=dopKQeBZpz9S3iX9vw8xcPsS1oyMASOUQ4-OvCdElTw,16772
+miso_client/services/permission.py,sha256=GOGRAaXSfPKTXqEqbR0XP8hrA-YQgVFbHPxD-gGBUyA,6853
+miso_client/services/redis.py,sha256=BWfgXoSOyyGrB9cf_kTY0lZwfbjUWQhkiOyFFSp590M,5348
+miso_client/services/role.py,sha256=qmxhk54QUGCjCuCWm_ruDlTq7iT9yOicfUvdRVkFKUI,5517
+miso_client/utils/__init__.py,sha256=HArSxVKrmCqFkqFOPwe1i3B2IBHJ1vRqYu98c_KASV0,366
+miso_client/utils/config_loader.py,sha256=yZk4pXNIBu3i61KqxM8QwsjraM0xhqUcH2THl8-DMu0,3027
+miso_client/utils/data_masker.py,sha256=D7AEyViGxoShLa5UUZHYhRCPQMPKqX7qNilTK9h87OM,7035
+miso_client/utils/error_utils.py,sha256=B-BXmDTTj6II1HwjC_DE6o9QKOMs6B3bzFXkOiPhf20,3274
+miso_client/utils/filter.py,sha256=obkdQ3FFD69Qg0VviFMoM8y6zAP5JYBaIujmOT9diU8,8984
+miso_client/utils/http_client.py,sha256=H386RsKjiw-JG7XhrTn8gCRDMWMvp8s7bC1jqa7qvGk,23807
+miso_client/utils/internal_http_client.py,sha256=jgiaO94EiIUbMQWUKN4FhYqOQ9r0BZea0_grRcOepL4,16078
+miso_client/utils/jwt_tools.py,sha256=-pvz5nk5BztEnhFnL-dtOv8Q5E0G2oh4RwFrVk2rVpg,1981
+miso_client/utils/pagination.py,sha256=_sUzAGSCiUujVa9W3nedVRaCx18_9MuT_9bBlWmVc9o,4449
+miso_client/utils/sensitive_fields_loader.py,sha256=EHODxyM1Gw7hgKXCvJ1B4Hf4LZqcEqWEXu4q5CPFaic,3667
+miso_client/utils/sort.py,sha256=_bCLRCGevgNkXYqsgXasc3vaDQwkXV76kgHIyw-dato,3438
+miso_client-0.5.0.dist-info/licenses/LICENSE,sha256=3hoU8LdT9_EIFIx6FjMk5sQnVCBMX3FRIOzqqy5im4c,1076
+miso_client-0.5.0.dist-info/METADATA,sha256=ZzmZZNHxnv4n3P95ZJgMAPFKRE3gLTgYUhCG9sh20C4,28396
+miso_client-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+miso_client-0.5.0.dist-info/top_level.txt,sha256=8i_FNeRn8PRy6scnXOpVr-IJYsArkqIvxRMTZPtik9E,12
+miso_client-0.5.0.dist-info/RECORD,,