rapidata 1.10.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

rapidata/rapidata_client/validation/validation_set_manager.py

@@ -0,0 +1,338 @@
+from rapidata.rapidata_client.validation._validation_set_builder import ValidationSetBuilder
+from rapidata.rapidata_client.validation.rapidata_validation_set import RapidataValidationSet
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.assets.data_type_enum import RapidataDataTypes
+from rapidata.rapidata_client.validation.rapids.rapids_manager import RapidsManager
+from rapidata.rapidata_client.validation.rapids.rapids import Rapid
+from rapidata.rapidata_client.metadata import PromptMetadata
+
+from rapidata.api_client.models.page_info import PageInfo
+from rapidata.api_client.models.root_filter import RootFilter
+from rapidata.api_client.models.filter import Filter
+from rapidata.api_client.models.sort_criterion import SortCriterion
+from rapidata.api_client.exceptions import BadRequestException
+from urllib3._collections import HTTPHeaderDict
+
+from rapidata.rapidata_client.validation.rapids.box import Box
+
+from rapidata.api_client.models.query_validation_set_model import QueryValidationSetModel
+
+from typing import Sequence
+
+
+class ValidationSetManager:
+    """
+    Responsible for everything related to validation sets. From creation to retrieval.
+
+    Attributes:
+        rapid (RapidsManager): The RapidsManager instance.
+    """
+    def __init__(self, openapi_service: OpenAPIService) -> None:
+        self.__openapi_service = openapi_service
+        self.rapid = RapidsManager()
+
+    def create_classification_set(self,
+        name: str,
+        instruction: str,
+        answer_options: list[str],
+        datapoints: list[str],
+        truths: list[list[str]],
+        data_type: str = RapidataDataTypes.MEDIA,
+        contexts: list[str] | None = None,
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a classification validation set.
+        
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            instruction (str): The instruction by which the labeler will answer.
+            answer_options (list[str]): The options to choose from when answering.
+            datapoints (list[str]): The datapoints that will be used for validation.
+            truths (list[list[str]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+                example:
+                    options: ["yes", "no", "maybe"]
+                    datapoints: ["datapoint1", "datapoint2"]
+                    truths: [["yes"], ["no", "maybe"]] -> first datapoint correct answer is "yes", second datapoint is "no" or "maybe"
+            data_type (str, optional): The type of data. Defaults to RapidataDataTypes.MEDIA. Other option: RapidataDataTypes.TEXT ("text").
+            contexts (list[str], optional): The contexts for each datapoint. Defaults to None.\n
+                If provided has to be the same length as datapoints and will be shown in addition to the instruction and answer options. (Therefore will be different for each datapoint)
+                Will be match up with the datapoints using the list index.
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+        """
+        
+        if len(datapoints) != len(truths):
+            raise ValueError("The number of datapoints and truths must be equal")
+        if contexts and len(contexts) != len(datapoints):
+            raise ValueError("The number of contexts and datapoints must be equal")
+        
+        rapids = []
+        for i in range(len(datapoints)):
+            rapids.append(
+                self.rapid.classification_rapid(
+                    instruction=instruction,
+                    answer_options=answer_options,
+                    datapoint=datapoints[i],
+                    truths=truths[i],
+                    data_type=data_type,
+                    metadata=[PromptMetadata(contexts[i])] if contexts else []
+                )
+            )
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def create_compare_set(self,
+        name: str,
+        instruction: str,
+        datapoints: list[list[str]],
+        truths: list[str],
+        data_type: str = RapidataDataTypes.MEDIA,
+        contexts: list[str] | None = None,
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a comparison validation set.
+
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            instruction (str): The instruction to compare against.
+            truths (list[str]): The truths for each comparison. List is for each comparison.\n
+                example:
+                    instruction: "Which image has a cat?"
+                    datapoints = [["image1.jpg", "image2.jpg"], ["image3.jpg", "image4.jpg"]]
+                    truths: ["image1.jpg", "image4.jpg"] -> first comparison image1.jpg has a cat, second comparison image4.jpg has a cat
+            datapoints (list[list[str]]): The compare datapoints to create the validation set with. 
+                Outer list is for each comparison, inner list the two images/texts that will be compared.
+            data_type (str, optional): The type of data. Defaults to RapidataDataTypes.MEDIA. Other option: RapidataDataTypes.TEXT ("text").
+            contexts (list[str], optional): The contexts for each datapoint. Defaults to None.\n
+                If provided has to be the same length as datapoints and will be shown in addition to the instruction and truth. (Therefore will be different for each datapoint)
+                Will be match up with the datapoints using the list index.
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+        """
+        
+        if len(datapoints) != len(truths):
+            raise ValueError("The number of datapoints and truths must be equal")
+        
+        if contexts and len(contexts) != len(datapoints):
+            raise ValueError("The number of contexts and datapoints must be equal")
+        
+        rapids = []
+        for i in range(len(datapoints)):
+            rapids.append(
+                self.rapid.compare_rapid(
+                    instruction=instruction,
+                    truth=truths[i],
+                    datapoint=datapoints[i],
+                    data_type=data_type,
+                    metadata=[PromptMetadata(contexts[i])] if contexts else []
+                )
+            )
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def create_select_words_set(self,
+        name: str,
+        instruction: str,
+        truths: list[list[int]],
+        datapoints: list[str],
+        sentences: list[str],
+        strict_grading: bool = True,
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a select words validation set.
+
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            instruction (str): The instruction to show to the labeler.
+            truths (list[list[int]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+                example:
+                    datapoints: ["datapoint1", "datapoint2"]
+                    sentences: ["this example 1", "this example 2"]
+                    truths: [[0, 1], [2]] -> first datapoint correct words are "this" and "example", second datapoint is "2"
+            datapoints (list[str]): The datapoints that will be used for validation.
+            sentences (list[str]): The sentences that will be used for validation. The sentece will be split up by spaces to be selected by the labeler.
+                Must be the same length as datapoints.
+            strict_grading (bool, optional): Whether to grade strictly. Defaults to True.\n
+                If True, the labeler must select all correct words to be graded as correct. (and no wrong words)
+                If False, the labeler must select at least one correct word to be graded as correct. (and no wrong words)
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+            """
+        
+        if len(datapoints) != len(truths) or len(datapoints) != len(sentences):
+            raise ValueError("The number of datapoints, truths, and sentences must be equal")
+        
+        rapids = []
+        for i in range(len(datapoints)):
+            rapids.append(
+                self.rapid.select_words_rapid(
+                    instruction=instruction,
+                    truths=truths[i],
+                    datapoint=datapoints[i],
+                    sentence=sentences[i],
+                    strict_grading=strict_grading
+                )
+            )
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def create_locate_set(self,
+        name: str,
+        instruction: str,
+        truths: list[list[Box]],
+        datapoints: list[str],
+        contexts: list[str] | None = None,
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a locate validation set.
+
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            instruction (str): The instruction to show to the labeler.
+            truths (list[list[Box]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+                example:
+                    datapoints: ["datapoint1", "datapoint2"]
+                    truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
+            datapoints (list[str]): The datapoints that will be used for validation.
+            contexts (list[str], optional): The contexts for each datapoint. Defaults to None.
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+        """
+        
+        if len(datapoints) != len(truths):
+            raise ValueError("The number of datapoints and truths must be equal")
+        
+        if contexts and len(contexts) != len(datapoints):
+            raise ValueError("The number of contexts and datapoints must be equal")
+        
+        rapids = []
+        for i in range(len(datapoints)):
+            rapids.append(
+                self.rapid.locate_rapid(
+                    instruction=instruction,
+                    truths=truths[i],
+                    datapoint=datapoints[i],
+                    metadata=[PromptMetadata(contexts[i])] if contexts else []
+                )
+            )
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def create_draw_set(self,
+        name: str,
+        instruction: str,
+        truths: list[list[Box]],
+        datapoints: list[str],
+        contexts: list[str] | None = None,
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a draw validation set.
+
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            instruction (str): The instruction to show to the labeler.
+            truths (list[list[Box]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+                example:
+                    datapoints: ["datapoint1", "datapoint2"]
+                    truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
+            datapoints (list[str]): The datapoints that will be used for validation.
+            contexts (list[str], optional): The contexts for each datapoint. Defaults to None.
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+        """
+        
+        if len(datapoints) != len(truths):
+            raise ValueError("The number of datapoints and truths must be equal")
+        
+        if contexts and len(contexts) != len(datapoints):
+            raise ValueError("The number of contexts and datapoints must be equal")
+        
+        rapids = []
+        for i in range(len(datapoints)):
+            rapids.append(
+                self.rapid.draw_rapid(
+                    instruction=instruction,
+                    truths=truths[i],
+                    datapoint=datapoints[i],
+                    metadata=[PromptMetadata(contexts[i])] if contexts else []
+                )
+            )
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def create_mixed_set(self,
+        name: str,
+        rapids: Sequence[Rapid],
+        print_confirmation: bool = True
+    ) -> RapidataValidationSet:
+        """Create a validation set with a list of rapids.
+
+        Args:
+            name (str): The name of the validation set. (will not be shown to the labeler)
+            rapids (Sequence[Rapid]): The list of rapids to add to the validation set.
+            print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
+        """
+
+        validation_set_builder = ValidationSetBuilder(name, self.__openapi_service)
+        for rapid in rapids:
+            validation_set_builder._add_rapid(rapid)
+
+        return validation_set_builder._submit(print_confirmation)
+    
+    def get_validation_set_by_id(self, validation_set_id: str) -> RapidataValidationSet:
+        """Get a validation set by ID.
+
+        Args:
+            validation_set_id (str): The ID of the validation set.
+
+        Returns:
+            RapidataValidationSet: The ValidationSet instance.
+        """
+        try:
+            validation_set = self.__openapi_service.validation_api.validation_get_by_id_get(id=validation_set_id)
+        except Exception:
+            raise ValueError(f"ValidationSet with ID {validation_set_id} not found.")
+        
+        return RapidataValidationSet(validation_set_id, self.__openapi_service, validation_set.name)
+    
+    def find_validation_sets(self, name: str = "", amount: int = 1) -> list[RapidataValidationSet]:
+        """Find validation sets by name.
+
+        Args:
+            name (str, optional): The name to search for. Defaults to "" to match with any set.
+            amount (int, optional): The amount of validation sets to return. Defaults to 1.
+
+        Returns:
+            list[RapidataValidationSet]: The list of validation sets.
+        """
+        try:
+            validation_page_result = self.__openapi_service.validation_api.validation_query_validation_sets_get(QueryValidationSetModel(
+                pageInfo=PageInfo(index=1, size=amount),
+                filter=RootFilter(filters=[Filter(field="Name", operator="Contains", value=name)]),
+                sortCriteria=[SortCriterion(direction="Desc", propertyName="CreatedAt")]
+                ))
+
+        except BadRequestException as e:
+            raise ValueError(f"Error occured during request. \nError: {e.body} \nTraceid: {e.headers.get('X-Trace-Id') if isinstance(e.headers, HTTPHeaderDict) else 'Unknown'}")
+
+        except Exception as e:
+            raise ValueError(f"Unknown error occured: {e}")
+
+        validation_sets = [self.get_validation_set_by_id(validation_set.id) for validation_set in validation_page_result.items]
+        return validation_sets
+

rapidata/rapidata_client/workflow/__init__.py

@@ -1,6 +1,8 @@
-from .base_workflow import Workflow 
-from .classify_workflow import ClassifyWorkflow
-from .compare_workflow import CompareWorkflow
-from .free_text_workflow import FreeTextWorkflow
-from .select_words_workflow import SelectWordsWorkflow
-from .evaluation_workflow import EvaluationWorkflow
+from ._locate_workflow import LocateWorkflow
+from ._draw_workflow import DrawWorkflow
+from ._base_workflow import Workflow 
+from ._classify_workflow import ClassifyWorkflow
+from ._compare_workflow import CompareWorkflow
+from ._free_text_workflow import FreeTextWorkflow
+from ._select_words_workflow import SelectWordsWorkflow
+from ._evaluation_workflow import EvaluationWorkflow

rapidata/rapidata_client/workflow/_base_workflow.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
+from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
+from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
+from rapidata.rapidata_client.referee._base_referee import Referee
+
+
+class Workflow(ABC):
+
+    def __init__(self, type: str):
+        self._type = type
+        self._target_country_codes: list[str] = []
+
+    def _to_dict(self) -> dict[str, Any]:
+        return {
+            "_t": self._type,
+        }
+
+    @abstractmethod
+    def _to_model(
+        self,
+    ) -> SimpleWorkflowModel | CompareWorkflowModel | EvaluationWorkflowModel:
+        pass

rapidata/rapidata_client/workflow/{classify_workflow.py → _classify_workflow.py}

@@ -21,14 +21,14 @@ class ClassifyWorkflow(Workflow):
         _options (list[str]): The list of classification options.
     """
 
-    def __init__(self, question: str, options: list[str]):
+    def __init__(self, instruction: str, answer_options: list[str]):
         super().__init__(type="SimpleWorkflowConfig")
-        self._question = question
-        self._options = options
+        self._question = instruction
+        self._options = answer_options
 
-    def to_dict(self) -> dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return {
-            **super().to_dict(),
+            **super()._to_dict(),
             "blueprint": {
                 "_t": "ClassifyBlueprint",
                 "title": self._question,
@@ -36,7 +36,7 @@ class ClassifyWorkflow(Workflow):
             }
         }
 
-    def to_model(self) -> SimpleWorkflowModel:
+    def _to_model(self) -> SimpleWorkflowModel:
         blueprint = AttachCategoryRapidBlueprint(
             _t="ClassifyBlueprint",
             title=self._question,

rapidata/rapidata_client/workflow/{compare_workflow.py → _compare_workflow.py}

@@ -10,35 +10,29 @@ class CompareWorkflow(Workflow):
     A workflow for comparison tasks.
 
     This class represents a comparison workflow where items are compared based on
-    specified criteria.
+    specified instruction.
 
     Attributes:
-        _criteria (str): The criteria used for comparison.
+        _instruction (str): The instruction used for comparison.
 
     Args:
-        criteria (str): The criteria to be used for comparison.
+        instruction (str): The instruction to be used for comparison.
     """
 
-    def __init__(self, criteria: str):
-        """
-        Initialize a CompareWorkflow instance.
-
-        Args:
-            criteria (str): The criteria to be used for comparison.
-        """
+    def __init__(self, instruction: str):
         super().__init__(type="CompareWorkflowConfig")
-        self._criteria = criteria
+        self._instruction = instruction
 
-    def to_dict(self) -> dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return {
-            **super().to_dict(),
-            "criteria": self._criteria,
+            **super()._to_dict(),
+            "criteria": self._instruction,
         }
 
-    def to_model(self) -> SimpleWorkflowModel:
+    def _to_model(self) -> SimpleWorkflowModel:
         blueprint = CompareRapidBlueprint(
             _t="CompareBlueprint",
-            criteria=self._criteria,
+            criteria=self._instruction,
         )
 
         return SimpleWorkflowModel(

rapidata/rapidata_client/workflow/_draw_workflow.py

@@ -0,0 +1,22 @@
+from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
+from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
+from rapidata.api_client.models.line_rapid_blueprint import LineRapidBlueprint
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+
+
+class DrawWorkflow(Workflow):
+
+    def __init__(self, target: str):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._target = target
+
+    def _to_model(self) -> SimpleWorkflowModel:
+        blueprint = LineRapidBlueprint(
+            _t="LineBlueprint",
+            target=self._target
+        )
+
+        return SimpleWorkflowModel(
+            _t="SimpleWorkflow",
+            blueprint=SimpleWorkflowModelBlueprint(blueprint)
+        )

rapidata/rapidata_client/workflow/_evaluation_workflow.py

@@ -0,0 +1,26 @@
+from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+
+
+class EvaluationWorkflow(Workflow):
+    """
+    A workflow to run evaluation orders.
+
+    This is used internally only and should not be necessary to be used by clients.
+    
+    Args:
+        validation_set_id (str): a source for the tasks that will be sent to the user
+        should_accept_incorrect (bool): indicates if the user should get feedback on their answers if they answer wrong. If set to true the user will not notice that he was tested.
+    """
+
+    def __init__(self, validation_set_id: str, should_accept_incorrect: bool):
+        super().__init__("EvaluationWorkflow")
+        self.validation_set_id = validation_set_id
+        self.should_accept_incorrect = should_accept_incorrect
+
+    def _to_model(self):
+        return EvaluationWorkflowModel(
+            _t="EvaluationWorkflow",
+            validationSetId=self.validation_set_id,
+            shouldAcceptIncorrect=self.should_accept_incorrect,
+        )

rapidata/rapidata_client/workflow/{free_text_workflow.py → _free_text_workflow.py}

@@ -10,38 +10,32 @@ class FreeTextWorkflow(Workflow):
     A workflow for free text input tasks.
 
     This class represents a workflow where users can provide free-form text responses
-    to a given question.
+    to a given instruction.
 
     Attributes:
-        _question (str): The question to be answered with free text.
+        _instruction (str): The instruction to be answered with free text.
 
     Args:
-        question (str): The question to be presented for free text input.
+        instruction (str): The instruction to be presented for free text input.
     """
 
-    def __init__(self, question: str):
-        """
-        Initialize a FreeTextWorkflow instance.
-
-        Args:
-            question (str): The question to be presented for free text input.
-        """
+    def __init__(self, instruction: str):
         super().__init__(type="SimpleWorkflowConfig")
-        self._question = question
+        self._instruction = instruction
 
-    def to_dict(self) -> dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return {
-            **super().to_dict(),
+            **super()._to_dict(),
             "blueprint": {
                 "_t": "FreeTextBlueprint",
-                "question": self._question,
+                "question": self._instruction,
             },
         }
 
-    def to_model(self) -> SimpleWorkflowModel:
+    def _to_model(self) -> SimpleWorkflowModel:
         blueprint = FreeTextRapidBlueprint(
             _t="FreeTextBlueprint",
-            question=self._question,
+            question=self._instruction,
         )
 
         return SimpleWorkflowModel(

rapidata/rapidata_client/workflow/_locate_workflow.py

@@ -0,0 +1,22 @@
+from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
+from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
+from rapidata.api_client.models.locate_rapid_blueprint import LocateRapidBlueprint
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+
+
+class LocateWorkflow(Workflow):
+
+    def __init__(self, target: str):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._target = target
+
+    def _to_model(self) -> SimpleWorkflowModel:
+        blueprint = LocateRapidBlueprint(
+            _t="LocateBlueprint",
+            target=self._target
+        )
+
+        return SimpleWorkflowModel(
+            _t="SimpleWorkflow",
+            blueprint=SimpleWorkflowModelBlueprint(blueprint)
+        )

rapidata/rapidata_client/workflow/{select_words_workflow.py → _select_words_workflow.py}

@@ -1,7 +1,7 @@
 from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
 from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
 from rapidata.api_client.models.transcription_rapid_blueprint import TranscriptionRapidBlueprint
-from rapidata.rapidata_client.workflow.base_workflow import Workflow
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
 
 
 class SelectWordsWorkflow(Workflow):
@@ -19,16 +19,10 @@ class SelectWordsWorkflow(Workflow):
     """
 
     def __init__(self, instruction: str):
-        """
-        Initialize a SelectWordsWorkflow instance.
-
-        Args:
-            instruction (str): The instruction to be provided for the select words task.
-        """
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction
 
-    def to_model(self) -> SimpleWorkflowModel:
+    def _to_model(self) -> SimpleWorkflowModel:
         blueprint = TranscriptionRapidBlueprint(
             _t="TranscriptionBlueprint",
             title=self._instruction

rapidata/service/credential_manager.py

@@ -1,6 +1,7 @@
 import json
 import os
 import time
+import urllib.parse
 import webbrowser
 from datetime import datetime, timezone
 from pathlib import Path
@@ -8,6 +9,7 @@ from socket import gethostname
 from typing import Dict, List, Optional, Tuple
 
 import requests
+from colorama import Fore
 from pydantic import BaseModel
 
 
@@ -206,7 +208,15 @@ class CredentialManager:
             return None
 
         auth_url = f"{self.endpoint}/connect/authorize/external?clientId=rapidata-cli&scope=openid profile email roles&writeKey={bridge_endpoint.write_key}"
-        webbrowser.open(auth_url)
+        could_open_browser = webbrowser.open(auth_url)
+
+        if not could_open_browser:
+            encoded_url = urllib.parse.quote(auth_url, safe="%/:=&?~#+!$,;'@()*[]")
+            print(
+                Fore.RED
+                + f'Please open the following URL in your browser to log in: "{encoded_url}"'
+                + Fore.RESET
+            )
 
         access_token = self._poll_read_key(bridge_endpoint.read_key)
         if not access_token: