brynq-sdk-brynq 4.2.6.dev0__py3-none-any.whl

brynq_sdk_brynq/schemas/__init__.py

@@ -0,0 +1,52 @@
+from .credentials import CredentialsConfig, CredentialSource, CredentialData
+from .customers import CustomerSchema, CustomerUsers, CustomerContractDetailsSchema
+from .scenarios import Scenario, ScenarioMappingConfiguration, ScenarioDetail, SourceOrTargetField
+from .interfaces import Interface, InterfaceApps, InterfaceDetail, InterfaceConfig, Schedule, Scope, DevSettings, Frequency, TaskSchedule, MappingValue, MappingItem
+from .organization_chart import OrganizationChartNode, OrganizationLayerCreate, OrganizationLayerUpdate, OrganizationLayerGet, OrganizationNode, OrganizationNodeCreate, OrganizationNodeUpdate
+from .roles import DashboardRight, QlikDashboardRight, CreateRoleRequest, RoleUser, RoleSchema
+from .users import UserProducts, UserCreate, UserUpdate, UserInvite, QlikDashboardRight, QlikDashboardRightsPayload, DashboardRight, DashboardRightsPayload, UserEntitiesPayload, User, QlikAppUserAuthorization
+from .interfaces import MappingValue
+
+__all__ = [
+    "CredentialsConfig",
+    "CredentialSource",
+    "CredentialData",
+    "CustomerSchema",
+    "CustomerUsers",
+    "CustomerContractDetailsSchema",
+    "Interface",
+    "InterfaceApps",
+    "InterfaceDetail",
+    "InterfaceConfig",
+    "Schedule",
+    "Scope",
+    "DevSettings",
+    "Frequency",
+    "TaskSchedule",
+    "MappingValue",
+    "MappingItem",
+    "OrganizationChartNode",
+    "OrganizationLayerCreate",
+    "OrganizationLayerUpdate",
+    "OrganizationLayerGet",
+    "OrganizationNode",
+    "OrganizationNodeCreate",
+    "OrganizationNodeUpdate",
+    "DashboardRight",
+    "QlikDashboardRight",
+    "CreateRoleRequest",
+    "RoleUser",
+    "UserProducts",
+    "UserCreate",
+    "UserUpdate",
+    "UserInvite",
+    "QlikDashboardRight",
+    "QlikDashboardRightsPayload",
+    "DashboardRight",
+    "DashboardRightsPayload",
+    "UserEntitiesPayload",
+    "User",
+    "QlikAppUserAuthorization",
+    "MappingValue",
+    "Scenario",
+]

brynq_sdk_brynq/schemas/credentials.py

@@ -0,0 +1,37 @@
+from typing import Dict, Any, List
+from pydantic import BaseModel, Field, RootModel
+
+
+class CredentialData(RootModel[Dict[str, Any]]):
+    """Schema for credential data which can contain any key-value pairs"""
+    root: Dict[str, Any]
+
+    class Config:
+        frozen = True
+        strict = False
+
+
+class CredentialSource(BaseModel):
+    """Schema for a credential source or target"""
+    app: str = Field(..., description="Application identifier")
+    type: str = Field(..., description="Type of the credential source/target")
+    data: Dict[str, Any] = Field(..., description="Credential data key-value pairs")
+    direction: str = Field(..., description="Direction of the credential flow (source/target)")
+
+    class Config:
+        frozen = True
+        strict = False
+        populate_by_name = True
+        extra = 'allow'
+
+
+class CredentialsConfig(BaseModel):
+    """Schema for the complete credentials configuration"""
+    sources: List[CredentialSource] = Field(..., description="List of credential sources")
+    targets: List[CredentialSource] = Field(..., description="List of credential targets")
+
+    class Config:
+        frozen = True
+        strict = False
+        populate_by_name = True
+        extra = 'allow'

brynq_sdk_brynq/schemas/customers.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, Field, ValidationError
+from typing import Optional, Union, List, Dict, Any, Tuple, Type
+from datetime import date
+from pydantic.functional_validators import BeforeValidator
+from typing_extensions import Annotated
+
+
+def parse_date(value: Union[str, None]) -> Optional[date]:
+    """Convert string date to date object or return None"""
+    if value is None:
+        return None
+    if isinstance(value, date):
+        return value
+    return date.fromisoformat(value)
+
+
+def convert_to_str(value: Union[str, int]) -> str:
+    """Convert integer or string value to string"""
+    return str(value)
+
+
+DateField = Annotated[Union[date, None], BeforeValidator(parse_date)]
+StringOrInt = Annotated[str, BeforeValidator(convert_to_str)]
+
+
+def validate_data(data: List[Dict[str, Any]], schema: Type[BaseModel], debug: bool = False) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Validate a list of dictionaries using a Pydantic schema and separate valid and invalid data.
+    
+    Args:
+        data (List[Dict[str, Any]]): List of dictionaries to validate
+        schema (Type[BaseModel]): Pydantic schema class to use for validation
+        debug (bool, optional): Whether to print debug information. Defaults to False.
+    
+    Returns:
+        Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]: Tuple of (valid_data, invalid_data)
+            - valid_data: List of validated dictionaries that conform to the schema
+            - invalid_data: List of dictionaries that failed validation, with error details
+    """
+    valid_data = []
+    invalid_data = []
+    
+    for idx, item in enumerate(data):
+        try:
+            validated = schema(**item).model_dump()
+            valid_data.append(validated)
+        except ValidationError as e:
+            if debug:
+                print(f"Validation error at index {idx}:")
+                print(e.json(indent=2))
+            
+            # Add error information to the invalid item
+            invalid_item = item.copy()
+            invalid_item['_validation_errors'] = [
+                {
+                    'loc': ' -> '.join(str(loc) for loc in error['loc']),
+                    'msg': error['msg'],
+                    'type': error['type']
+                }
+                for error in e.errors()
+            ]
+            invalid_data.append(invalid_item)
+    
+    return valid_data, invalid_data
+
+
+class CustomerSchema(BaseModel):
+    """Schema for basic customer data validation"""
+    name: str = Field(..., description="Name of the customer")
+    domain: str = Field(..., description="Domain identifier for the customer")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class CustomerUsers(BaseModel):
+    """Schema for customer users counts"""
+    global_: StringOrInt = Field(..., alias="global", description="Number of global users")
+    qlik_analyzer: StringOrInt = Field(..., alias="qlikAnalyzer", description="Number of Qlik Analyzer users")
+    qlik_pro: StringOrInt = Field(..., alias="qlikPro", description="Number of Qlik Pro users")
+    jira: int = Field(..., description="Number of Jira users")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class CustomerContractDetailsSchema(BaseModel):
+    """Schema for customer contract details"""
+    id: int = Field(..., description="Unique identifier for the customer", gt=0)
+    name: str = Field(..., description="Name of the customer")
+    profit_subscription: Optional[str] = Field(None, alias="profitSubscription", description="Profit subscription identifier")
+    subscription_cost: float = Field(..., alias="subscriptionCost", description="Cost of the subscription")
+    subscription_cost_mutation: Optional[float] = Field(None, alias="subscriptionCostMutation", description="Change in subscription cost")
+    effective_date: DateField = Field(..., alias="effectiveDate", description="Start date of the contract")
+    expiration_date: DateField = Field(None, alias="expirationDate", description="End date of the contract")
+    payment_term: str = Field(..., alias="paymentTerm", description="Payment term (e.g., annual)")
+    subscription_type: str = Field(..., alias="subscriptionType", description="Type of subscription")
+    referred_by: Optional[str] = Field(None, alias="referredBy", description="Referral source")
+    users: CustomerUsers = Field(..., description="User counts by type")
+    apps: int = Field(..., description="Number of apps")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True

brynq_sdk_brynq/schemas/interfaces.py

@@ -0,0 +1,237 @@
+from typing import Dict, List, Any, Optional, Union, Annotated
+from datetime import datetime
+from enum import Enum
+import re
+from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict, StringConstraints
+
+SDK_PREFIX = "brynq_sdk_"
+VERSION_PATTERN = r'^\d+\.\d+\.\d+$'
+
+# strips whitespace from strings before validation
+CleanStr = Annotated[str, StringConstraints(strip_whitespace=True)]
+
+
+class InterfaceType(str, Enum):
+    """Enumeration of interface types."""
+    TEMPLATE = "TEMPLATE"
+    ADVANCED = "ADVANCED"
+
+class Frequency(BaseModel):
+    """Schema for task schedule frequency"""
+    day: int = Field(..., description="Day of frequency")
+    hour: int = Field(..., description="Hour of frequency")
+    month: int = Field(..., description="Month of frequency")
+    minute: int = Field(..., description="Minute of frequency")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class TaskSchedule(BaseModel):
+    """Schema for interface task schedule"""
+    id: int = Field(..., description="Task schedule ID")
+    task_type: str = Field(..., alias="taskType", description="Type of task")
+    trigger_type: str = Field(..., alias="triggerType", description="Type of trigger")
+    trigger_pattern: str = Field(..., alias="triggerPattern", description="Pattern of trigger")
+    timezone: str = Field(..., description="Timezone for the task")
+    next_reload: Optional[str] = Field(None, alias="nextReload", description="Next reload time")
+    frequency: Frequency = Field(..., description="Frequency settings")
+    variables: Dict[str, Any] = Field(default_factory=dict, description="Task variables")
+    start_after_preceding_task: Optional[bool] = Field(None, alias="startAfterPrecedingTask", description="Whether to start after preceding task")
+    start_after_task_id: Optional[int] = Field(None, alias="startAfterTaskId", description="ID of task to start after")
+    last_reload: str = Field(..., alias="lastReload", description="Last reload time")
+    last_error_message: str = Field(..., alias="lastErrorMessage", description="Last error message")
+    status: str = Field(..., description="Current status")
+    disabled: bool = Field(..., description="Whether task is disabled")
+    run_instant: bool = Field(..., alias="runInstant", description="Whether to run instantly")
+    stopped_by_user: bool = Field(..., alias="stoppedByUser", description="Whether stopped by user")
+    stepnr: int = Field(..., description="Step number")
+    created_at: str = Field(..., alias="createdAt", description="Creation time")
+    updated_at: str = Field(..., alias="updatedAt", description="Last update time")
+
+    @field_validator('last_reload', 'created_at', 'updated_at', 'next_reload')
+    def validate_datetime(cls, v: Optional[str]) -> Optional[str]:
+        """Validate that the string is a valid ISO format datetime"""
+        if v is None:
+            return v
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+            return v
+        except (ValueError, AttributeError) as e:
+            raise ValueError(f"Invalid datetime format: {str(e)}")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class Interface(BaseModel):
+    """Schema for interface data"""
+    id: int = Field(..., description="Interface ID")
+    name: str = Field(..., description="Interface name")
+    description: str = Field(..., description="Interface description")
+    source_systems: List[int] = Field(..., alias="sourceSystems", description="List of source system IDs")
+    target_systems: List[int] = Field(..., alias="targetSystems", description="List of target system IDs")
+    task_schedule: TaskSchedule = Field(..., alias="taskSchedule", description="Task schedule details")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class InterfaceAppConfig(BaseModel):
+    """Schema for individual app configuration within interface apps.
+
+    Attributes:
+        app: Application name
+        sdk: SDK package name (must start with "brynq_sdk_")
+        sdk_version: SDK version in format digits.digits.digits (aliased as "sdkVersion" in API)
+    """
+    model_config = ConfigDict(frozen=True, strict=True, populate_by_name=True)
+
+    app: CleanStr = Field(..., description="Application name")
+    sdk: CleanStr = Field(default="", description="SDK package name (may be empty for ADVANCED interfaces)")
+    sdk_version: CleanStr = Field(default="", alias="sdkVersion", description="SDK version (may be empty for ADVANCED interfaces)")
+
+    @field_validator('sdk')
+    @classmethod
+    def validate_sdk_prefix(cls, v: str) -> str:
+        """Validate that SDK name starts with 'brynq_sdk_' or is empty."""
+        if v and not v.startswith(SDK_PREFIX):
+            raise ValueError(f"SDK name must start with '{SDK_PREFIX}' or be empty, got: {v}")
+        return v
+
+    @field_validator('sdk_version')
+    @classmethod
+    def validate_version_format(cls, v: str) -> str:
+        """Validate that version follows digits.digits.digits format or is empty."""
+        if v and not re.match(VERSION_PATTERN, v):
+            raise ValueError(f"SDK version must be 'digits.digits.digits' (e.g., '2.8.2'), got: {v}")
+        return v
+
+
+class InterfaceApps(BaseModel):
+    """Schema for interface apps configuration"""
+    source: InterfaceAppConfig = Field(..., description="Source application configuration")
+    target: InterfaceAppConfig = Field(..., description="Target application configuration")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class InterfaceDetail(BaseModel):
+    """Schema for detailed interface information"""
+    model_config = ConfigDict(frozen=True, strict=False, populate_by_name=True)
+
+    id: int = Field(..., description="Interface id")
+    uuid: str = Field(..., description="Interace uid")
+    name: str = Field(..., description="Interface name")
+    type: InterfaceType = Field(..., description="Interface type (TEMPLATE or ADVANCED)")
+    in_development: bool = Field(..., description="Whether interface is in development.", alias="inDevelopment")
+    apps: InterfaceApps = Field(..., description="Interface applications configuration")
+
+    @model_validator(mode='after')
+    def validate_apps_for_type(self) -> 'InterfaceDetail':
+        """Validate that sdk and sdk_version are non-empty unless type is ADVANCED."""
+        if self.type == InterfaceType.TEMPLATE:
+            for app_name in ['source', 'target']:
+                config = getattr(self.apps, app_name)
+                if not config.sdk:
+                    raise ValueError(f"{app_name}.sdk must be non-empty for interface type {self.type.value}")
+                if not config.sdk_version:
+                    raise ValueError(f"{app_name}.sdk_version must be non-empty for interface type {self.type.value}")
+        return self
+
+
+class MappingValue(BaseModel):
+    """Schema for a single mapping value"""
+    input: Dict[Any, Any] = Field(..., description="Input mapping key-value pairs")
+    output: Dict[Any, Any] = Field(..., description="Output mapping key-value pairs")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class MappingItem(BaseModel):
+    """Schema for a single mapping configuration"""
+    guid: str = Field(..., description="Unique identifier for the mapping")
+    name: str = Field(..., description="Name of the mapping")
+    values: List[MappingValue] = Field(default_factory=list, description="List of mapping values")
+    default_value: Optional[str] = Field(None, alias="defaultValue", description="Default value if no mapping matches")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class InterfaceConfig(BaseModel):
+    """Schema for interface configuration"""
+    mapping: List[Dict[str, Any]] = Field(default_factory=list, description="List of mappings")
+    variables: Dict[str, Any] = Field(default_factory=dict, description="Configuration variables")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class Schedule(BaseModel):
+    """Schema for interface schedule configuration"""
+    id: int = Field(..., description="Schedule ID")
+    trigger_type: str = Field(..., alias="triggerType", description="Type of trigger")
+    trigger_pattern: str = Field(..., alias="triggerPattern", description="Pattern for the trigger")
+    timezone: str = Field(..., description="Timezone setting")
+    next_reload: Optional[str] = Field(None, alias="nextReload", description="Next scheduled reload time")
+    frequency: Frequency = Field(..., description="Frequency settings")
+    start_after_preceding_task: Optional[bool] = Field(None, alias="startAfterPrecedingTask", description="Whether to start after preceding task")
+    last_reload: str = Field(..., alias="lastReload", description="Last reload time")
+    last_error_message: str = Field(..., alias="lastErrorMessage", description="Last error message")
+
+    @field_validator('last_reload', 'next_reload')
+    def validate_datetime(cls, v: Optional[str]) -> Optional[str]:
+        """Validate that the string is a valid ISO format datetime"""
+        if v is None:
+            return v
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+            return v
+        except (ValueError, AttributeError) as e:
+            raise ValueError(f"Invalid datetime format: {str(e)}")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class Scope(BaseModel):
+    """Schema for interface scope data"""
+    live: Optional[Dict[str, Any]] = Field(None, description="Live scope configuration")
+    draft: Optional[Dict[str, Any]] = Field(None, description="Draft scope configuration")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class DevSettings(BaseModel):
+    """Schema for interface dev settings"""
+    docker_image: str = Field(..., alias="dockerImage", description="Docker image name")
+    sftp_mapping: List[dict] = Field(..., alias="sftpMapping", description="SFTP mapping configuration")
+    runfile_path: str = Field(..., alias="runfilePath", description="Path to the runfile")
+    stop_is_allowed: bool = Field(..., alias="stopIsAllowed", description="Whether stopping is allowed")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True

brynq_sdk_brynq/schemas/organization_chart.py

@@ -0,0 +1,70 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class OrganizationChartNode(BaseModel):
+    """Schema for organization chart node"""
+    id: int = Field(..., description="Node ID")
+    name: str = Field(..., description="Node name")
+    drop_index: int = Field(..., alias="dropIndex", description="Drop index for ordering")
+    parent_id: Optional[int] = Field(None, alias="parent_id", description="Parent node ID, null for root nodes")
+    source_system_entities: List[str] = Field(default_factory=list, alias="source_system_entities", description="List of source system entities")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class OrganizationLayerCreate(BaseModel):
+    """Schema for organization layer input"""
+    name: str = Field(..., description="Layer name")
+    level: int = Field(..., ge=0, description="Layer level in hierarchy")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class OrganizationLayerUpdate(BaseModel):
+    """Schema for organization layer response"""
+    id: int = Field(..., description="Layer ID")
+    level: int = Field(None, ge=0, description="Layer level in hierarchy")
+    name: str = Field(None, description="Layer name")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class OrganizationLayerGet(OrganizationLayerUpdate):
+    pass
+
+
+class OrganizationNode(BaseModel):
+    """Schema for organization chart node"""
+    id: int = Field(..., description="Node ID")
+    name: str = Field(..., description="Node name")
+    parent_id: Optional[int] = Field(None, alias="parentId", description="Parent node ID")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class OrganizationNodeCreate(BaseModel):
+    """Schema for creating organization chart node"""
+    name: str = Field(..., description="Node name")
+    parent_id: Optional[int] = Field(None, alias="parentId", description="Parent node ID")
+    position: Optional[int] = Field(None, description="Position among siblings")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+class OrganizationNodeUpdate(OrganizationNodeCreate):
+    id: int = Field(..., description="Node ID")

brynq_sdk_brynq/schemas/roles.py

@@ -0,0 +1,95 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import List, Optional, Any, Dict
+
+class DashboardRight(BaseModel):
+    """Schema for dashboard rights"""
+    dashboard_id: int = Field(..., alias="dashboardId", description="ID of the dashboard")
+    editable: bool = Field(..., description="Whether the dashboard is editable")
+    entities: List[int] = Field(default_factory=list, description="List of entity IDs")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class QlikDashboardRight(BaseModel):
+    """Schema for Qlik dashboard rights"""
+    guid: str = Field(..., description="Dashboard GUID")
+    data_model_editable: bool = Field(..., alias="dataModelEditable", description="Whether the data model is editable")
+    editable: bool = Field(..., description="Whether the dashboard is editable")
+    entities: List[int] = Field(default_factory=list, description="List of entity IDs")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class CreateRoleRequest(BaseModel):
+    """Schema for creating a new role"""
+    name: str = Field(..., description="Name of the role")
+    dashboards: List[DashboardRight] = Field(default_factory=list, description="List of dashboard rights")
+    qlik_dashboards: List[QlikDashboardRight] = Field(default_factory=list, alias="qlikDashboards", description="List of Qlik dashboard rights")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class RoleUser(BaseModel):
+    """Schema for users assigned to a role"""
+    id: int = Field(..., description="User ID")
+    name: str = Field(..., description="User name")
+    email: str = Field(..., description="User email")
+    active: bool = Field(..., description="Whether the user is active")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class RoleSchema(BaseModel):
+    """Schema for role data"""
+    id: int = Field(..., description="Unique identifier for the role")
+    name: str = Field(..., description="Name of the role")
+    permissions: Optional[Dict[str, Any]] = Field(None, description="Role permissions")
+    dashboards: List[Dict[str, Any]] = Field(default_factory=list, description="List of dashboard rights")
+    qlik_dashboards: List[Dict[str, Any]] = Field(default_factory=list, alias="qlikDashboards", description="List of Qlik dashboard rights")
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
+class RoleSchema(BaseModel):
+    """Schema for role data validation"""
+    id: int = Field(..., description="Unique identifier for the role", gt=0)
+    name: str = Field(None, description="Name of the role")
+    dashboards: List[Any] = Field(default_factory=list, description="List of dashboards associated with the role")
+    permissions: Optional[Any] = Field(default=None, description="Role permissions")
+    qlik_dashboards: List[Any] = Field(default_factory=list, description="List of Qlik dashboards associated with the role")
+
+    @field_validator('name')
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Validate that the name is not empty or just whitespace"""
+        if not v.strip():
+            raise ValueError("Role name cannot be empty or just whitespace")
+        return v.strip()
+
+    @field_validator('dashboards', 'qlik_dashboards')
+    @classmethod
+    def validate_dashboard_lists(cls, v: List[Any]) -> List[Any]:
+        """Ensure dashboard lists are always lists, even if empty"""
+        if v is None:
+            return []
+        return v
+
+    class Config:
+        frozen = True  # Makes the model immutable
+        strict = True  # Ensures strict type checking
+        populate_by_name = True  # Allows both camelCase and snake_case access