ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f48cfc76750>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2024.04.1"),
        reason="Python 3.12 not available",
    )
    def test_restart(self):
        # create content
        content = self.client.content.create(name="example-flask-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-flask-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # restart
>       content.restart()

tests/posit/connect/test_content.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '25a0671b-ecc8-4eaa-a30e-0813bccdc865', 'name': 'example-flask-minimal', 'title': None, 'description': '', 'a...hboard_url': 'http://connect:3939/connect/#/apps/25a0671b-ecc8-4eaa-a30e-0813bccdc865', 'app_role': 'owner', 'id': '2'}

    def restart(self) -> None:
        """Mark for restart.
    
        Sends a restart request to the server for the content. Once submitted, the server performs an asynchronous process to restart the content. This is particularly useful when the content relies on external information loaded into application memory, such as datasets. Additionally, restarting can help clear memory leaks or reduce excessive memory usage that might build up over time.
    
        See Also
        --------
        render
    
        Examples
        --------
        >>> restart()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_interactive:
            unix_epoch_in_seconds = str(int(time.time()))
            key = f"_CONNECT_RESTART_TMP_{unix_epoch_in_seconds}"
            self.environment_variables.create(key, unix_epoch_in_seconds)
            self.environment_variables.delete(key)
            # GET via the base Connect URL to force create a new worker thread.
            url = posixpath.join(dirname(self._ctx.url), f"content/{self['guid']}")
            self._ctx.session.get(url)
            return None
        else:
>           raise ValueError(
                f"Restart not supported for this application mode: {self['app_mode']}. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:258: ValueError

ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f069a7ea750>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2024.04.1"),
        reason="Python 3.12 not available",
    )
    def test_restart(self):
        # create content
        content = self.client.content.create(name="example-flask-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-flask-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # restart
>       content.restart()

tests/posit/connect/test_content.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '07a85ed5-57a3-427e-a9ed-288200a03179', 'name': 'example-flask-minimal', 'title': None, 'description': '', 'a...hboard_url': 'http://connect:3939/connect/#/apps/07a85ed5-57a3-427e-a9ed-288200a03179', 'app_role': 'owner', 'id': '2'}

    def restart(self) -> None:
        """Mark for restart.
    
        Sends a restart request to the server for the content. Once submitted, the server performs an asynchronous process to restart the content. This is particularly useful when the content relies on external information loaded into application memory, such as datasets. Additionally, restarting can help clear memory leaks or reduce excessive memory usage that might build up over time.
    
        See Also
        --------
        render
    
        Examples
        --------
        >>> restart()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_interactive:
            unix_epoch_in_seconds = str(int(time.time()))
            key = f"_CONNECT_RESTART_TMP_{unix_epoch_in_seconds}"
            self.environment_variables.create(key, unix_epoch_in_seconds)
            self.environment_variables.delete(key)
            # GET via the base Connect URL to force create a new worker thread.
            url = posixpath.join(dirname(self._ctx.url), f"content/{self['guid']}")
            self._ctx.session.get(url)
            return None
        else:
>           raise ValueError(
                f"Restart not supported for this application mode: {self['app_mode']}. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:258: ValueError

ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7fb8165aa750>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2024.04.1"),
        reason="Python 3.12 not available",
    )
    def test_restart(self):
        # create content
        content = self.client.content.create(name="example-flask-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-flask-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # restart
>       content.restart()

tests/posit/connect/test_content.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '50ba0dc1-fd4d-42a8-8de3-4a97e4bfe5ad', 'name': 'example-flask-minimal', 'title': None, 'description': '', 'a...hboard_url': 'http://connect:3939/connect/#/apps/50ba0dc1-fd4d-42a8-8de3-4a97e4bfe5ad', 'app_role': 'owner', 'id': '3'}

    def restart(self) -> None:
        """Mark for restart.
    
        Sends a restart request to the server for the content. Once submitted, the server performs an asynchronous process to restart the content. This is particularly useful when the content relies on external information loaded into application memory, such as datasets. Additionally, restarting can help clear memory leaks or reduce excessive memory usage that might build up over time.
    
        See Also
        --------
        render
    
        Examples
        --------
        >>> restart()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_interactive:
            unix_epoch_in_seconds = str(int(time.time()))
            key = f"_CONNECT_RESTART_TMP_{unix_epoch_in_seconds}"
            self.environment_variables.create(key, unix_epoch_in_seconds)
            self.environment_variables.delete(key)
            # GET via the base Connect URL to force create a new worker thread.
            url = posixpath.join(dirname(self._ctx.url), f"content/{self['guid']}")
            self._ctx.session.get(url)
            return None
        else:
>           raise ValueError(
                f"Restart not supported for this application mode: {self['app_mode']}. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:258: ValueError

ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f4076a0e750>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2024.04.1"),
        reason="Python 3.12 not available",
    )
    def test_restart(self):
        # create content
        content = self.client.content.create(name="example-flask-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-flask-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # restart
>       content.restart()

tests/posit/connect/test_content.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'a3a1fe7e-7137-47f4-9382-fe8fd7780977', 'name': 'example-flask-minimal', 'title': None, 'description': '', 'a...hboard_url': 'http://connect:3939/connect/#/apps/a3a1fe7e-7137-47f4-9382-fe8fd7780977', 'app_role': 'owner', 'id': '3'}

    def restart(self) -> None:
        """Mark for restart.
    
        Sends a restart request to the server for the content. Once submitted, the server performs an asynchronous process to restart the content. This is particularly useful when the content relies on external information loaded into application memory, such as datasets. Additionally, restarting can help clear memory leaks or reduce excessive memory usage that might build up over time.
    
        See Also
        --------
        render
    
        Examples
        --------
        >>> restart()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_interactive:
            unix_epoch_in_seconds = str(int(time.time()))
            key = f"_CONNECT_RESTART_TMP_{unix_epoch_in_seconds}"
            self.environment_variables.create(key, unix_epoch_in_seconds)
            self.environment_variables.delete(key)
            # GET via the base Connect URL to force create a new worker thread.
            url = posixpath.join(dirname(self._ctx.url), f"content/{self['guid']}")
            self._ctx.session.get(url)
            return None
        else:
>           raise ValueError(
                f"Restart not supported for this application mode: {self['app_mode']}. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Restart not supported for this application mode: unknown. Did you need to use the 'render()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:258: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f48cfc76950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '6a27bbf1-8516-46c4-bc32-70694bfad201', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/6a27bbf1-8516-46c4-bc32-70694bfad201', 'app_role': 'owner', 'id': '3'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f8c0f2be950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'bc3afe97-3f44-453c-aa3c-71eefb421953', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/bc3afe97-3f44-453c-aa3c-71eefb421953', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f069a7ea950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'e954e010-4d0d-4356-a9c2-f625c92c0e60', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/e954e010-4d0d-4356-a9c2-f625c92c0e60', 'app_role': 'owner', 'id': '3'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7fbf5fc86950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'c5a0b42f-3161-43dc-9cf9-32363b0dd4bf', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/c5a0b42f-3161-43dc-9cf9-32363b0dd4bf', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7fb8165aa950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '2019bed4-5fa3-4bc1-85f7-1ca046ed81c8', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/2019bed4-5fa3-4bc1-85f7-1ca046ed81c8', 'app_role': 'owner', 'id': '4'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f11f7fe6950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '22b84ca7-9a87-4ac0-a346-0632972dfd5f', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/22b84ca7-9a87-4ac0-a346-0632972dfd5f', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f4076a0e950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'f2ce2387-33f9-4b8e-be27-3b9cdaadcc83', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/f2ce2387-33f9-4b8e-be27-3b9cdaadcc83', 'app_role': 'owner', 'id': '4'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7ff8a6542950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'adc74e75-8a3a-4390-9435-1df91b4ae4ad', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/adc74e75-8a3a-4390-9435-1df91b4ae4ad', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f20532fe950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '32badf69-5c41-455a-b988-d87f257beb73', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/32badf69-5c41-455a-b988-d87f257beb73', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f9800626950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'ad2a36d3-775a-4664-a3a4-fcdbfcfe60ff', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/ad2a36d3-775a-4664-a3a4-fcdbfcfe60ff', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f2ebcc1e950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '97ea9543-44ef-403e-ba1c-20a01d05d5c6', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/97ea9543-44ef-403e-ba1c-20a01d05d5c6', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f306070a950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': 'bc81b03c-3dc1-4d6e-977e-859ac70c90cf', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/bc81b03c-3dc1-4d6e-977e-859ac70c90cf', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7efd805a6950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '6e2fff8d-c462-4aea-aea0-44d790c893c0', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/6e2fff8d-c462-4aea-aea0-44d790c893c0', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f01d21e2950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '9615f4d4-b3fe-4be1-b049-72330a15e10e', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/9615f4d4-b3fe-4be1-b049-72330a15e10e', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError

ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.
self = <connect.test_content.TestContent object at 0x7f0d448ba950>

    @pytest.mark.skipif(
        CONNECT_VERSION <= version.parse("2023.01.1"),
        reason="Quarto not available",
    )
    def test_render(self):
        # create content
        content = self.client.content.create(name="example-quarto-minimal")
        # create bundle
        path = Path("../../../resources/connect/bundles/example-quarto-minimal/bundle.tar.gz")
        path = (Path(__file__).parent / path).resolve()
        bundle = content.bundles.create(str(path))
        # deploy bundle
        task = bundle.deploy()
        task.wait_for()
        # render
>       task = content.render()

tests/posit/connect/test_content.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'guid': '856ce48a-8edb-48ea-bdc7-7cd8c2c308ad', 'name': 'example-quarto-minimal', 'title': None, 'description': '', '...hboard_url': 'http://connect:3939/connect/#/apps/856ce48a-8edb-48ea-bdc7-7cd8c2c308ad', 'app_role': 'owner', 'id': '2'}

    def render(self) -> Task:
        """Render the content.
    
        Submit a render request to the server for the content. After submission, the server executes an asynchronous process to render the content. This is useful when content is dependent on external information, such as a dataset.
    
        See Also
        --------
        restart
    
        Examples
        --------
        >>> render()
        """
        self.update()  # pyright: ignore[reportCallIssue]
    
        if self.is_rendered:
            variants = self._variants.find()
            variants = [variant for variant in variants if variant["is_default"]]
            if len(variants) != 1:
                raise RuntimeError(
                    f"Found {len(variants)} default variants. Expected 1. Without a single default variant, the content cannot be refreshed. This is indicative of a corrupted state.",
                )
            variant = variants[0]
            return variant.render()
        else:
>           raise ValueError(
                f"Render not supported for this application mode: {self['app_mode']}. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.",
            )
E           ValueError: Render not supported for this application mode: unknown. Did you need to use the 'restart()' method instead? Note that some application modes do not support 'render()' or 'restart()'.

../src/posit/connect/content.py:229: ValueError