class product_DatasetNotFound(Exception):
    """Thrown when the requested dataset does not exist
    """

    ERROR_CODE = "NOT_FOUND"
    ERROR_NAMESPACE = "Datasets"
    ERROR_NAME = "Datasets:DatasetNotFound"

    def __init__(self, dataset_rid: str, available_datasets: List[str], error_instance_id: Optional[str] = None) -> None:
        self._dataset_rid = dataset_rid
        self._available_datasets = available_datasets
        self.error_instance_id = error_instance_id if error_instance_id is not None else str(uuid.uuid4())
        super().__init__(self.ERROR_NAME)

    @builtins.property
    def dataset_rid(self) -> str:
        return self._dataset_rid

    @builtins.property
    def available_datasets(self) -> List[str]:
        return self._available_datasets

    def encode(self) -> Dict[str, Any]:
        return {
            'errorCode': self.ERROR_CODE,
            'errorName': self.ERROR_NAME,
            'errorInstanceId': self.error_instance_id,
            'parameters': {
                'datasetRid': ConjureEncoder.do_encode(self.dataset_rid),
                'availableDatasets': ConjureEncoder.do_encode(self.available_datasets)
            }
        }

    @builtins.staticmethod
    def _decode_parameter(decoder: ConjureDecoder, value: Any, conjure_type: Any) -> Any:
        if isinstance(value, str) and conjure_type is not str:
            try:
                value = json.loads(value)
            except (ValueError, TypeError):
                pass
        return decoder.decode(value, conjure_type)

    @builtins.classmethod
    def decode(cls, error: Dict[str, Any]) -> 'product_DatasetNotFound':
        if error.get('errorName') != cls.ERROR_NAME:
            raise ValueError(f"Error '{error.get('errorName')}' is not a {cls.ERROR_NAME}")
        decoder = ConjureDecoder()
        parameters = error.get('parameters', {})
        return cls(
            dataset_rid=cls._decode_parameter(decoder, parameters.get('datasetRid'), str),
            available_datasets=cls._decode_parameter(decoder, parameters.get('availableDatasets'), List[str]),
            error_instance_id=error.get('errorInstanceId')
        )


product_DatasetNotFound.__name__ = "DatasetNotFound"
product_DatasetNotFound.__qualname__ = "DatasetNotFound"
product_DatasetNotFound.__module__ = "package_name.product"

from my_package.product import DatasetNotFound

# raise it like any other exception
raise DatasetNotFound(
    dataset_rid="ri.foundry.main.dataset.123",
    available_datasets=["ri.foundry.main.dataset.456"],
)

# or serialize to the Conjure SerializableError envelope
payload = DatasetNotFound(
    dataset_rid="ri.foundry.main.dataset.123",
    available_datasets=["ri.foundry.main.dataset.456"],
).encode()
# {
#   'errorCode': 'NOT_FOUND',
#   'errorName': 'Datasets:DatasetNotFound',
#   'errorInstanceId': '<uuid>',
#   'parameters': {
#       'datasetRid': 'ri.foundry.main.dataset.123',
#       'availableDatasets': ['ri.foundry.main.dataset.456'],
#   },
# }

from my_package.product import DatasetNotFound

# `payload` is a Conjure SerializableError (e.g. an error response body)
error = DatasetNotFound.decode(payload)
error.dataset_rid         # 'ri.foundry.main.dataset.123'
error.available_datasets  # ['ri.foundry.main.dataset.456']
error.error_instance_id   # '<uuid>'

# decode() raises ValueError if the payload's errorName doesn't match
# and tolerates the legacy stringified parameter format