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

brynq_sdk_brynq/source_systems.py

@@ -0,0 +1,175 @@
+import requests
+from typing import Dict, Any, List, Optional
+
+
+class SourceSystems:
+    """
+    Handles all source system related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize SourceSystems manager.
+        
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+
+    def get(self) -> List[Dict[str, Any]]:
+        """
+        Get all source systems.
+        
+        Returns:
+            List[Dict[str, Any]]: List of all source systems
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}source-systems',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def create(self, name: str, entities: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """
+        Create new source systems.
+        
+        Args:
+            name: Name of the source system
+            entities: Optional list of entities to assign. Each entity should have 'name' and 'code' keys
+            
+        Returns:
+            Dict[str, Any]: Created source system details
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+        """
+        data = {
+            'name': name,
+            'entities': entities or []
+        }
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}source-systems',
+            json=data,
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def delete(self, system_id: int) -> None:
+        """
+        Delete a source system.
+        
+        Args:
+            system_id: ID of the source system to delete
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.delete(
+            url=f'{self._brynq.url}source-systems/{system_id}',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+    def update(self, system_id: int, name: str, entities: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """
+        Update a source system by overwriting its name and entities.
+        
+        Args:
+            system_id: ID of the source system to update
+            name: New name for the source system
+            entities: Optional list of entities to replace existing ones. Each entity should have 'name' and 'code' keys
+            
+        Returns:
+            Dict[str, Any]: Updated source system details
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            requests.exceptions.HTTPError: If source system is not found (404)
+        """
+        data = {
+            'name': name,
+            'entities': entities or []
+        }
+        response = self._brynq.brynq_session.put(
+            url=f'{self._brynq.url}source-systems/{system_id}',
+            json=data,
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_entities(self, system_id: int) -> requests.Response:
+        """
+        Get all entities from a source system in BrynQ
+        
+        Args:
+            system_id: The ID of the source system
+            
+        Returns:
+            List[Dict[str, Any]]: List of entities from the source system
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}source-systems/{system_id}/entities',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def create_entities(self, system_id: int, entities: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        Create new entities for a source system.
+        
+        Args:
+            system_id: ID of the source system
+            entities: List of entities to create. Each entity should have 'name' and 'code' keys
+            
+        Returns:
+            Dict[str, Any]: Result of the creation operation
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            requests.exceptions.HTTPError: If source system is not found (404)
+        """
+        data = {'entities': entities}
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}source-systems/{system_id}/entities',
+            json=data,
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def update_entity(self, entity_id: int, name: str, code: str) -> Dict[str, Any]:
+        """
+        Update a specific source system entity.
+        
+        Args:
+            entity_id: ID of the entity to update
+            name: New name for the entity
+            code: New code for the entity
+            
+        Returns:
+            Dict[str, Any]: Updated entity details
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            requests.exceptions.HTTPError: If entity is not found (404)
+        """
+        data = {
+            'name': name,
+            'code': code
+        }
+        response = self._brynq.brynq_session.put(
+            url=f'{self._brynq.url}source-systems/entities/{entity_id}',
+            json=data,
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()

brynq_sdk_brynq/users.py

@@ -0,0 +1,405 @@
+import requests
+from typing import List, Dict, Any
+from .schemas.users import (
+    User, UserUpdate, UserInvite,
+    QlikDashboardRightsPayload, DashboardRightsPayload, QlikAppUserAuthorization, UserEntitiesPayload
+)
+from brynq_sdk_functions import Functions
+
+
+class Users:
+    """
+    Handles all user-related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize Users manager.
+
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+
+    def get(self) -> List[Dict[str, Any]]:
+        """Get all users from BrynQ
+
+        Returns:
+            List[Dict[str, Any]]: List of users with their details:
+                - id (int): User ID
+                - name (str): First name
+                - email (str): User email
+                - roles (List[dict]): User roles
+                - organization_chart_entities (List[dict]): Organization chart entities
+                - qlik_dashboards (List[dict]): Qlik dashboards
+                - dashboards (List[dict]): Standard dashboards
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the response data is invalid
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}users',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        valid_data, _ = Functions.validate_pydantic_data(response.json(), schema=User)
+        return valid_data
+
+    def get_by_id(self, user_id: int) -> Dict[str, Any]:
+        """
+        Get a specific user by ID.
+
+        Args:
+            user_id: The ID of the user to retrieve
+
+        Returns:
+            Dict[str, Any]: User details
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}users/{user_id}',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        valid_data, _ = Functions.validate_pydantic_data(response.json(), schema=User)
+        return valid_data[0]
+
+    def invite(self, user_data: dict) -> requests.Response:
+        """Invite a new user to BrynQ
+
+        Args:
+            user_data: Dictionary containing user details. Example:
+                {
+                    "email": "user@example.com",
+                    "products": {
+                        "qlikSenseAnalyzer": true,
+                        "qlikSenseProfessional": false
+                    }
+                }
+                Note: products field is optional
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+        """
+        valid_data, _ = Functions.validate_pydantic_data(user_data, schema=UserInvite)
+
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}users',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def update(self, user_id: str, user_data: dict) -> requests.Response:
+        """Update a user in BrynQ
+
+        Args:
+            user_id: The ID of the user to update
+            user_data: Dictionary containing user details to update. Example:
+                {
+                    "name": "John Doe",
+                    "username": "johndoe",
+                    "email": "john@example.com",
+                    "language": "en",
+                    "roles": [1, 2, 3],
+                    "products": {
+                        "qlikSenseAnalyzer": true,
+                        "qlikSenseProfessional": false
+                    }
+                }
+                All fields are optional.
+
+        Returns:
+            Dict[str, Any]: Updated user data
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, str):
+            raise ValueError("user_id must be a string")
+
+        valid_data, _ = Functions.validate_pydantic_data(user_data, schema=UserUpdate)
+
+        response = self._brynq.brynq_session.put(
+            url=f'{self._brynq.url}users/{user_id}',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        return response
+
+    def delete(self, user_id: str) -> requests.Response:
+        """
+        Delete a user in BrynQ
+        :param user_id: The id of the user in BrynQ
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+        response = self._brynq.brynq_session.delete(
+            url=f'{self._brynq.url}users/{user_id}',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def assign_dashboard_rights(self, user_id: int, dashboard_rights: List[Dict[str, Any]]) -> None:
+        """Assign or update dashboard rights to a user by ID
+
+        Args:
+            user_id: Numeric ID of the user
+            dashboard_rights: List of dashboard rights. Example:
+                [
+                    {
+                        "dashboardId": 123,
+                        "editable": true,
+                        "organigrams": [1, 2, 3]
+                    }
+                ]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+
+        payload = {
+            "dashboardRights": dashboard_rights
+        }
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=DashboardRightsPayload)
+
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}users/{user_id}/dashboards',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def assign_roles(self, user_id: int, roles: List[int]) -> None:
+        """Assign roles to a user by ID
+
+        Args:
+            user_id: Numeric ID of the user
+            roles: List of role IDs to assign. Example:
+                [1, 2, 3]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        import warnings
+        warnings.warn("This method is deprecated. Use update() instead.", DeprecationWarning)
+        response = self.update(user_id, {"roles": roles})
+        response.raise_for_status()
+        return response
+
+    def assign_organigram_entities(self, user_id: int, organigram_entities: list) -> dict:
+        """Assign organigrams to a user by ID.
+
+        Args:
+            user_id (int): Numeric ID of the user
+            organigram_entities (list): List of organigram entity objects
+
+        Returns:
+            dict: Response from the API
+
+        Raises:
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+        payload = {"organigramEntities": organigram_entities}
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=UserEntitiesPayload)
+        response = self._brynq.brynq_session.post(
+            url=f"{self._brynq.url}users/{user_id}/organigram-entities",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def assign_dashboard_qlik(self, user_id: int, qlik_dashboard_rights: list) -> dict:
+        """Assign or update Qlik dashboard rights to a user by ID.
+
+        Args:
+            user_id (int): Numeric ID of the user
+            qlik_dashboard_rights (list): List of Qlik dashboard rights objects
+
+        Returns:
+            dict: Response from the API
+
+        Raises:
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+        payload = {"qlikDashboardRights": qlik_dashboard_rights}
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=QlikDashboardRightsPayload)
+        response = self._brynq.brynq_session.post(
+            url=f"{self._brynq.url}users/{user_id}/dashboards/qlik",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def assign_qlik_dashboard_rights(self, user_id: int, dashboard_rights: List[Dict[str, Any]]) -> None:
+        """Assign or update Qlik dashboard rights to a user by ID
+
+        Args:
+            user_id: Numeric ID of the user
+            dashboard_rights: List of dashboard rights. Example:
+                [
+                    {
+                        "guid": "dashboard-guid",
+                        "dataModelEdit": true,
+                        "editable": true,
+                        "organigrams": [1, 2, 3]
+                    }
+                ]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+
+        payload = {
+            "dashboardRights": dashboard_rights
+        }
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=QlikDashboardRightsPayload)
+
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}users/{user_id}/dashboards/qlik',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def get_user_authorization_qlik_app(self, guid: str) -> List[Dict[str, Any]]:
+        """Get all users who have access to a Qlik dashboard with their entities
+
+        Args:
+            guid: GUID of the Qlik dashboard
+
+        Returns:
+            List[Dict[str, Any]]: List of users and their entities. Example:
+                [
+                    {
+                        "username": null,
+                        "userId": 420687,
+                        "entityCodes": []
+                    }
+                ]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}/qlik/{guid}/users',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        # Wrap response in authorizations field to match schema
+        valid_data, _ = Functions.validate_pydantic_data(response.json(), schema=QlikAppUserAuthorization)
+        return valid_data
+
+    def assign_user_entities(self, user_id: int, entity_ids: List[int]) -> requests.Response:
+        """Assign organization entities to a user
+
+        Args:
+            user_id: Numeric ID of the user
+            entity_ids: List of entity IDs to assign. Example:
+                [1, 2, 3]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+
+        payload = {"entities": entity_ids}
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=UserEntitiesPayload)
+
+        response = self._brynq.brynq_session.post(
+            url=f'{self._brynq.url}users/{user_id}/organigram-entities',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def update_user_entities(self, user_id: int, entity_ids: List[int]) -> None:
+        """Overwrite organization entities for a user
+
+        Args:
+            user_id: Numeric ID of the user
+            entity_ids: List of entity IDs to set. Example:
+                [1, 2, 3]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+
+        payload = {"entities": entity_ids}
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=UserEntitiesPayload)
+
+        response = self._brynq.brynq_session.put(
+            url=f'{self._brynq.url}users/{user_id}/organigram-entities',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def delete_user_entities(self, user_id: int, entity_ids: List[int]) -> None:
+        """Delete organization entities from a user
+
+        Args:
+            user_id: Numeric ID of the user
+            entity_ids: List of entity IDs to delete. Example:
+                [1, 2, 3]
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If user_id is not an integer or input data is invalid
+            requests.exceptions.HTTPError: If user is not found (404)
+        """
+        if not isinstance(user_id, int):
+            raise ValueError("user_id must be an integer")
+
+        payload = {"entities": entity_ids}
+        valid_data, _ = Functions.validate_pydantic_data(payload, schema=UserEntitiesPayload)
+
+        response = self._brynq.brynq_session.delete(
+            url=f'{self._brynq.url}users/{user_id}/organigram-entities',
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response

brynq_sdk_brynq-4.2.6.dev0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: brynq_sdk_brynq
+Version: 4.2.6.dev0
+Summary: BrynQ SDK for the BrynQ.com platform
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Requires-Dist: requests<=3,>=2
+Requires-Dist: pydantic[email]
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+BrynQ SDK for the BrynQ.com platform

brynq_sdk_brynq-4.2.6.dev0.dist-info/RECORD

@@ -0,0 +1,23 @@
+brynq_sdk_brynq/__init__.py,sha256=7Sz8dmyk0PMMPl-8y56eZEeP09qQ3O6Fo-Xvz-_oDH8,24
+brynq_sdk_brynq/brynq.py,sha256=jNx_9nM-0PIYiqy2gTfDabQWB72xLQ6_Fbu8jofN7sI,12010
+brynq_sdk_brynq/credentials.py,sha256=tDJ_tnOWTJ5yCrc39NFvMvWH-di0i8c1GknH-gE5XmI,7026
+brynq_sdk_brynq/customers.py,sha256=l3z6MAfOmghJIu0uBcqqv9mGgSN4akwSkXv1gzvm-l0,3388
+brynq_sdk_brynq/interfaces.py,sha256=SRT4ZbsMjIN11moCf_eHLTrwx9VlQWnLOL-asAqHRig,9526
+brynq_sdk_brynq/mappings.py,sha256=Us9iKCW1bMMJZ8LFy3lZ4_F0DMsWaklylHHIOeFrCWA,4300
+brynq_sdk_brynq/organization_chart.py,sha256=CqGz1T_B7UCAncikQwYp3svC3Q_kXvkxOskvttmXs4k,9003
+brynq_sdk_brynq/roles.py,sha256=cDTmDPV3zMGbOSFJvAbXxgMV1yZg_sMK_tNTfXn-HXI,10750
+brynq_sdk_brynq/scenarios.py,sha256=kAn8jiTE8QtKl4FtaxDOyPLj8yW9Bn7BdTeX8U1jB78,157289
+brynq_sdk_brynq/source_systems.py,sha256=XCMXPLKz6w43n4_HPD7CiiQCJkzkNJkYhy4D-gA_d5w,5815
+brynq_sdk_brynq/users.py,sha256=TIeCse-7epG_VpGxOFj3Qb2EZZYmdkgHeqnYDDKrYl4,14836
+brynq_sdk_brynq/schemas/__init__.py,sha256=IrHXkOXEnkVWx3BmHm2HaaL6TOSa0OeV1gBV1AkvFc4,1917
+brynq_sdk_brynq/schemas/credentials.py,sha256=RJe2jjsCklCWv6DOgqFqG23SfZRO-_cmFFZC1uoBQF0,1231
+brynq_sdk_brynq/schemas/customers.py,sha256=dcQFkTlEZMC67kE-3G3qiVNkb8AsxkpwyFMebbNjhV4,4608
+brynq_sdk_brynq/schemas/interfaces.py,sha256=0IwtPxJFBT9P7HO79mMgAgqATbjB96F5_v_s5G4wVZk,10544
+brynq_sdk_brynq/schemas/organization_chart.py,sha256=cWmsOZI-htRzeaV_WdazBadZaYaYO8HQfcCo-rnQsv0,2332
+brynq_sdk_brynq/schemas/roles.py,sha256=R0xUMZmvkMRpioXLlsi8TlycDDt3X9Vn1_PFYjLJJV8,3847
+brynq_sdk_brynq/schemas/scenarios.py,sha256=GmQdfWmJd7vNbU_D1gCO36yzqQP1iI9zvc9csDG7ZCk,16747
+brynq_sdk_brynq/schemas/users.py,sha256=dbrfzgfD_t3m6GpAMbw5X8h3Ff2epxh6-LEVEnvB_bE,4740
+brynq_sdk_brynq-4.2.6.dev0.dist-info/METADATA,sha256=Z_E-DjmSm1H6cMHKoGD1mTQdFZLtdLZ67wBztH4hvMs,395
+brynq_sdk_brynq-4.2.6.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+brynq_sdk_brynq-4.2.6.dev0.dist-info/top_level.txt,sha256=CFsh8XAR_vNM0GEchao42bnpaeqYy64AVK2eARymew4,16
+brynq_sdk_brynq-4.2.6.dev0.dist-info/RECORD,,

brynq_sdk_brynq-4.2.6.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brynq_sdk_brynq-4.2.6.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk_brynq