U
    TZf%A                     @   s  d dl Z d dlmZ d dlZd dlmZ d dlmZ d dlmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZ edZedZed	ZG d
d de Z!e! Z"[!d<ddZ#e
 Z$e$e"d< e$e"d< e$e"d< e$e"d< i Z%ee%de"d< ee%dde"d< ee%de"d< ee%de"d< ee%de"d< e e"d< e e"d< e e"d< e e"d< e Z&e&e"d< e&e"d< e e"d < e e"d!< ee%de"d"< ee%d#d$e"d#< ee%d%d$e"d&< ee%d'd$e"d(< ee%dd)e"d*< ee%d+d)e"d,< e e"d-< e e"d.< dZ'ej()d/dZ*e*r\ze"+e* W n& e,k
rR   e,d0j-e*d1Y nX e*Z'n`ere. re'szd dl/Z0dZ'W n e1k
r   Y nX e'sej23d2rdZ'e'sd3ej(krdZ'e'sd4ej(krdZ'e'sd5ej(krdZ'e's
d6ej(kr
dZ'e's d7ej(kr dZ'e'sdd8ej(krdzd d9l4m5Z5 e5  d Z'W n e,k
rb   Y nX e'se. j6j7d:krd"Z'e'sd;Z'n0zd dl8Z8e8)  d"Z'W n e9k
r   Y nX de"_:e'e"_;dS )=    N)copy)Version)optional_imports)MimetypeRendererExternalRendererPlotlyRendererNotebookRendererKaggleRendererAzureRendererColabRendererJsonRendererPngRendererJpegRendererSvgRendererPdfRendererBrowserRendererIFrameRendererSphinxGalleryHtmlRendererSphinxGalleryOrcaRendererCoCalcRendererDatabricksRenderer)validate_coerce_fig_to_dictZIPythonzIPython.displaynbformatc                   @   s   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zi fddZedd Zejdd Zedd Zejdd ZefddZdd Zd d! Zd"d# Zd)d%d&Zd*d'd(Zd$S )+RenderersConfigzI
    Singleton object containing the current renderer configurations
    c                 C   s"   i | _ d | _g | _d| _g | _d S )NF)
_renderers_default_name_default_renderers_render_on_display_to_activateself r!   8/tmp/pip-unpacked-wheel-5ksk5baj/plotly/io/_renderers.py__init__+   s
    zRenderersConfig.__init__c                 C   s
   t | jS N)lenr   r   r!   r!   r"   __len__4   s    zRenderersConfig.__len__c                 C   s
   || j kS r$   r   )r    itemr!   r!   r"   __contains__7   s    zRenderersConfig.__contains__c                 C   s
   t | jS r$   )iterr   r   r!   r!   r"   __iter__:   s    zRenderersConfig.__iter__c                 C   s   | j | }|S r$   r'   )r    r(   rendererr!   r!   r"   __getitem__=   s    
zRenderersConfig.__getitem__c                 C   s0   t |ttfs"tdjt|d|| j|< d S )NzhRenderer must be a subclass of MimetypeRenderer or ExternalRenderer.
    Received value with type: {typ})typ)
isinstancer   r   
ValueErrorformattyper   )r    keyvaluer!   r!   r"   __setitem__A   s    zRenderersConfig.__setitem__c                 C   s   | j |= | j|krd | _d S r$   )r   _default)r    r3   r!   r!   r"   __delitem__M   s    
zRenderersConfig.__delitem__c                 C   s
   | j  S r$   )r   keysr   r!   r!   r"   r8   U   s    zRenderersConfig.keysc                 C   s
   | j  S r$   )r   itemsr   r!   r!   r"   r9   X   s    zRenderersConfig.itemsc                 K   s&   t |f| D ]\}}|| |< qdS )aj  
        Update one or more renderers from a dict or from input keyword
        arguments.

        Parameters
        ----------
        d: dict
            Dictionary from renderer names to new renderer objects.

        kwargs
            Named argument value pairs where the name is a renderer name
            and the value is a new renderer object
        N)dictr9   )r    dkwargskvr!   r!   r"   update[   s    zRenderersConfig.updatec                 C   s   | j S )a  
        The default renderer, or None if no there is no default

        If not None, the default renderer is used to render
        figures when the `plotly.io.show` function is called on a Figure.

        If `plotly.io.renderers.render_on_display` is True, then the default
        renderer will also be used to display Figures automatically when
        displayed in the Jupyter Notebook

        Multiple renderers may be registered by separating their names with
        '+' characters. For example, to specify rendering compatible with
        the classic Jupyter Notebook, JupyterLab, and PDF export:

        >>> import plotly.io as pio
        >>> pio.renderers.default = 'notebook+jupyterlab+pdf'

        The names of available renderers may be retrieved with:

        >>> import plotly.io as pio
        >>> list(pio.renderers)

        Returns
        -------
        str
        )r   r   r!   r!   r"   defaultm   s    zRenderersConfig.defaultc                    sH   |sd _ g  _d S  |}| _  fdd|D  _t j _d S )N c                    s   g | ]} | qS r!   r!   .0namer   r!   r"   
<listcomp>   s     z+RenderersConfig.default.<locals>.<listcomp>)r   r   _validate_coerce_rendererslistr   )r    r4   renderer_namesr!   r   r"   r@      s    
c                 C   s   | j S )z
        If True, the default mimetype renderers will be used to render
        figures when they are displayed in an IPython context.

        Returns
        -------
        bool
        )r   r   r!   r!   r"   render_on_display   s    
z!RenderersConfig.render_on_displayc                 C   s   t || _d S r$   )boolr   )r    valr!   r!   r"   rI      s    c                    sF    fdd| j D }|r,|d}|  q fdd| j D | _ dS )z
        Activate all renderers that are waiting in the _to_activate list

        Parameters
        ----------
        cls
            Only activate renders that are subclasses of this class
        c                    s   g | ]} rt | r|qS r!   r/   rC   rclsr!   r"   rE      s     
 z?RenderersConfig._activate_pending_renderers.<locals>.<listcomp>r   c                    s   g | ]} rt | s|qS r!   rL   rM   rO   r!   r"   rE      s     
 N)r   popactivate)r    rP   Zto_activate_with_clsr,   r!   rO   r"   _activate_pending_renderers   s    	



z+RenderersConfig._activate_pending_renderersc                    sH   t |tstd|d} fdd|D }|rDtdt||S )a=  
        Input a string and validate that it contains the names of one or more
        valid renderers separated on '+' characters.  If valid, return
        a list of the renderer names

        Parameters
        ----------
        renderers_string: str

        Returns
        -------
        list of str
        z&Renderer must be specified as a string+c                    s   g | ]}| kr|qS r!   r!   rB   r   r!   r"   rE      s      z>RenderersConfig._validate_coerce_renderers.<locals>.<listcomp>z'
Invalid named renderer(s) received: {})r/   strr0   splitr1   )r    renderers_stringrH   invalidr!   r   r"   rF      s    

z*RenderersConfig._validate_coerce_renderersc                 C   s   dj t| j|  dS )NzuRenderers configuration
-----------------------
    Default renderer: {default}
    Available renderers:
{available}
)r@   	available)r1   reprr@   _available_renderers_strr   r!   r!   r"   __repr__   s     zRenderersConfig.__repr__c                 C   s$   d tjtt| dddd}|S )ze
        Return nicely wrapped string representation of all
        available renderer names
        
G   z        z	         )widthinitial_indentsubsequent_indent)jointextwrapwraprZ   rG   )r    rY   r!   r!   r"   r[      s    
z(RenderersConfig._available_renderers_strNc           
         s   |r>  |} fdd|D }|D ]}t|tr$|  q$n jtd  j}i }|D ]N}t|trXt|}| D ]\}}	t||rvt	|||	 qv|
|| qX|S )aY  
        Build a mime bundle dict containing a kev/value pair for each
        MimetypeRenderer specified in either the default renderer string,
        or in the supplied renderers_string argument.

        Note that this method skips any renderers that are not subclasses
        of MimetypeRenderer.

        Parameters
        ----------
        fig_dict: dict
            Figure dictionary
        renderers_string: str or None (default None)
            Renderer string to process rather than the current default
            renderer string

        Returns
        -------
        dict
        c                    s   g | ]} | qS r!   r!   rB   r   r!   r"   rE     s     z6RenderersConfig._build_mime_bundle.<locals>.<listcomp>rO   )rF   r/   r   rR   rS   r   r   r9   hasattrsetattrr?   Zto_mimebundle)
r    fig_dictrW   r<   rH   renderers_listr,   bundler=   r>   r!   r   r"   _build_mime_bundle   s"    



z"RenderersConfig._build_mime_bundlec           	         s   |r>  |} fdd|D }|D ]}t|tr$|  q$n jtd  j}|D ]H}t|trTt|}| D ]\}}t||rrt	||| qr|
| qTdS )a?  
        Perform external rendering for each ExternalRenderer specified
        in either the default renderer string, or in the supplied
        renderers_string argument.

        Note that this method skips any renderers that are not subclasses
        of ExternalRenderer.

        Parameters
        ----------
        fig_dict: dict
            Figure dictionary
        renderers_string: str or None (default None)
            Renderer string to process rather than the current default
            renderer string

        Returns
        -------
        None
        c                    s   g | ]} | qS r!   r!   rB   r   r!   r"   rE   A  s     z?RenderersConfig._perform_external_rendering.<locals>.<listcomp>rO   N)rF   r/   r   rR   rS   r   r   r9   re   rf   render)	r    rg   rW   r<   rH   rh   r,   r=   r>   r!   r   r"   _perform_external_rendering*  s    



z+RenderersConfig._perform_external_rendering)N)N)__name__
__module____qualname____doc__r#   r&   r)   r+   r-   r5   r7   r8   r9   r?   propertyr@   setterrI   objectrS   rF   r\   r[   rj   rl   r!   r!   r!   r"   r   &   s2   	




.r   Tc                 K   sv   t | |}tj|fd|i|}|r\ts0tdtrFttjtdk rNtdtj|dd tj	|fd|i| dS )a#  
    Show a figure using either the default renderer(s) or the renderer(s)
    specified by the renderer argument

    Parameters
    ----------
    fig: dict of Figure
        The Figure object or figure dict to display

    renderer: str or None (default None)
        A string containing the names of one or more registered renderers
        (separated by '+' characters) or None.  If None, then the default
        renderers specified in plotly.io.renderers.default are used.

    validate: bool (default True)
        True if the figure should be validated before being shown,
        False otherwise.

    width: int or float
        An integer or float that determines the number of pixels wide the
        plot is. The default is set in plotly.js.

    height: int or float
        An integer or float that determines the number of pixels wide the
        plot is. The default is set in plotly.js.

    config: dict
        A dict of parameters to configure the figure. The defaults are set
        in plotly.js.

    Returns
    -------
    None
    rW   z<Mime type rendering requires ipython but it is not installedz4.2.0zDMime type rendering requires nbformat>=4.2.0 but it is not installedT)rawN)
r   	renderersrj   ipython_displayr0   r   r   __version__Zdisplayrl   )Zfigr,   validater<   rg   ri   r!   r!   r"   show\  s    #
ry   Zplotly_mimetypeZ
jupyterlabZnteractZvscode)configZnotebook)rz   	connectedZnotebook_connectedZkaggleZazureZcolabZcocalcZ
databricksjsonZpngZjpegZjpgsvgZpdfZbrowserZfirefox)rz   Zusing)chromezgoogle-chromer~   )chromiumzchromium-browserr   )rz   Zinclude_plotlyjsiframeZcdnZiframe_connectedZsphinx_galleryZsphinx_gallery_pngZPLOTLY_RENDERERzb
Invalid named renderer(s) specified in the 'PLOTLY_RENDERER'
environment variable: {env_renderer})env_rendererz/kaggle/inputZAZURE_NOTEBOOKS_HOSTZ
VSCODE_PIDZNTERACT_EXEZCOCALC_PROJECT_IDZDATABRICKS_RUNTIME_VERSIONZSPYDER_ARGS)validate_executableZTerminalInteractiveShellzplotly_mimetype+notebook)NT)<rc   r   osZpackaging.versionr   Zplotlyr   Zplotly.io._base_renderersr   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   Zplotly.io._utilsr   Z
get_moduleZipythonrv   r   rs   r   ru   ry   Zplotly_rendererrz   Zjpeg_rendererZdefault_rendererenvirongetr   rF   r0   r1   Zget_ipythonZgoogle.colabZgoogleImportErrorpathexistsZplotly.io.orcar   	__class__rm   Z
webbrowser	ExceptionrI   r@   r!   r!   r!   r"   <module>   s   P


  3
<





 



