
    c A                        d dl mZmZ 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	j        d          Z  e	j        d	          Z! e	j        d
          Z" G d de#          Z$ e$            Z%[$d<dZ& e            Z'e'e%d<   e'e%d<   e'e%d<   e'e%d<   i Z( ee(          e%d<    ee(d          e%d<    ee(          e%d<    ee(          e%d<    ee(          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(          e%d"<    ee(d#$          e%d#<    ee(d%$          e%d&<    ee(d'$          e%d(<    ee(d)          e%d*<    ee(d+)          e%d,<    e            e%d-<    e            e%d.<   dZ*ej+        ,                    d/d          Z-e-rC	 e%.                    e-           n(# e/$ r   e/d00                    e-1                    w xY we-Z*ne re 1                                re*s	 d dl2Z3dZ*n# e4$ r Y nw xY we*sej5        6                    d2          rdZ*e*sd3ej+        v rdZ*e*sd4ej+        v rdZ*e*sd5ej+        v rdZ*e*sd6ej+        v rdZ*e*sd7ej+        v rdZ*e*s(d8ej+        v r	 d d9l7m8Z8  e8             d Z*n# e/$ r Y nw xY we*s$e 1                                j9        j:        d:k    rd"Z*e*sd;Z*n'd dl;Z;	  e;j,                     d"Z*n# e;j<        $ r Y nw xY wde%_=        e*e%_>        dS )=    )absolute_importdivisionN)copy)LooseVersion)optional_imports)MimetypeRendererExternalRendererPlotlyRendererNotebookRendererKaggleRendererAzureRendererColabRendererJsonRendererPngRendererJpegRendererSvgRendererPdfRendererBrowserRendererIFrameRendererSphinxGalleryHtmlRendererSphinxGalleryOrcaRendererCoCalcRendererDatabricksRenderer)validate_coerce_fig_to_dictIPythonzIPython.displaynbformatc                       e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zi fdZed             Zej        d             Zed             Zej        d             ZefdZd Zd Zd ZddZddZdS )RenderersConfigzI
    Singleton object containing the current renderer configurations
    c                 L    i | _         d | _        g | _        d| _        g | _        d S )NF)
_renderers_default_name_default_renderers_render_on_display_to_activateselfs    4lib/python3.11/site-packages/plotly/io/_renderers.py__init__zRenderersConfig.__init__-   s/    !"$"'    c                 *    t          | j                  S N)lenr    r%   s    r'   __len__zRenderersConfig.__len__6   s    4?###r)   c                     || j         v S r+   r    )r&   items     r'   __contains__zRenderersConfig.__contains__9   s    t&&r)   c                 *    t          | j                  S r+   )iterr    r%   s    r'   __iter__zRenderersConfig.__iter__<   s    DO$$$r)   c                      | j         |         }|S r+   r/   )r&   r0   renderers      r'   __getitem__zRenderersConfig.__getitem__?   s    ?4(r)   c                     t          |t          t          f          s0t          d                    t          |                              || 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values      r'   __setitem__zRenderersConfig.__setitem__C   sc    %"24D!EFF 	''-vU (. ( (    %r)   c                 >    | j         |= | j        |k    r	d | _        d S d S r+   )r    _default)r&   r>   s     r'   __delitem__zRenderersConfig.__delitem__O   s2    OC  =C 	! DMMM	! 	!r)   c                 4    | j                                         S r+   )r    keysr%   s    r'   rE   zRenderersConfig.keysW   s    ##%%%r)   c                 4    | j                                         S r+   )r    itemsr%   s    r'   rG   zRenderersConfig.itemsZ   s    $$&&&r)   c                 Z    t          |fi |                                D ]
\  }}|| |<   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)dictrG   )r&   dkwargskvs        r'   updatezRenderersConfig.update]   sH     %%f%%++-- 	 	DAqDGG	 	r)   c                     | 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%   s    r'   defaultzRenderersConfig.defaulto   s    8 !!r)   c                      |sd _         g  _        d S                      |          }| _          fd|D              _        t           j                   _        d S )N c                      g | ]
}|         S  rT   .0namer&   s     r'   
<listcomp>z+RenderersConfig.default.<locals>.<listcomp>   s    "I"I"I$4:"I"I"Ir)   )r!   r"   _validate_coerce_rendererslistr$   )r&   r?   renderer_namess   `  r'   rP   zRenderersConfig.default   sx      	 "$D&(D#F 88??""I"I"I"I."I"I"I !!899r)   c                     | 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%   s    r'   render_on_displayz!RenderersConfig.render_on_display   s     &&r)   c                 .    t          |          | _        d S r+   )boolr#   )r&   vals     r'   r]   z!RenderersConfig.render_on_display   s    "&s))r)   c                     fd| j         D             }|r+|                    d          }|                                 |+f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                 8    g | ]}t          |          |S rT   r:   rV   rclss     r'   rX   z?RenderersConfig._activate_pending_renderers.<locals>.<listcomp>   s@      
  
  
C 
4>q#4F4F 
 
  
  
r)   r   c                 8    g | ]}rt          |          |S rT   rc   rd   s     r'   rX   z?RenderersConfig._activate_pending_renderers.<locals>.<listcomp>   s@     
 
 

9CAs9K9K

 
 
r)   N)r$   popactivate)r&   rf   to_activate_with_clsr6   s    `  r'   _activate_pending_renderersz+RenderersConfig._activate_pending_renderers   s     
  
  
  
( 
  
  
 # 	  ,//22H	 # 	 
 
 
 
(
 
 
r)   c                      t          |t                    st          d          |                    d          } fd|D             }|r/t          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                     g | ]}|v|	S rT   rT   rU   s     r'   rX   z>RenderersConfig._validate_coerce_renderers.<locals>.<listcomp>   s#    GGGDd$6FG4GGGr)   z'
Invalid named renderer(s) received: {})r:   strr;   splitr<   )r&   renderers_stringr[   invalids   `   r'   rY   z*RenderersConfig._validate_coerce_renderers   s     *C00 	GEFFF)//44GGGGNGGG 	**0&LL+ +   r)   c                 x    d                     t          | j                  |                                           S )NzuRenderers configuration
-----------------------
    Default renderer: {default}
    Available renderers:
{available}
)rP   	available)r<   reprrP   _available_renderers_strr%   s    r'   __repr__zRenderersConfig.__repr__   s=     F&&$2O2O2Q2Q  
 
	
r)   c           	          d                     t          j        t          t	          |                     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wrapru   rZ   )r&   rt   s     r'   rv   z(RenderersConfig._available_renderers_str   sM    
 IIMT$ZZ  &")	  
 
	 r)   Nc                     |rR                      |          } fd|D             }|D ]+}t          |t                    r|                                 ,n"                     t                      j        }i }|D ]}t          |t                    rrt          |          }|                                D ]&\  }}	t          ||          rt          |||	           '|
                    |                    |                     |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                      g | ]
}|         S rT   rT   rU   s     r'   rX   z6RenderersConfig._build_mime_bundle.<locals>.<listcomp>      DDDTd4jDDDr)   rf   )rY   r:   r   ri   rk   r"   r   rG   hasattrsetattrrN   to_mimebundle)
r&   fig_dictrq   rK   r[   renderers_listr6   bundlerL   rM   s
   `         r'   _build_mime_bundlez"RenderersConfig._build_mime_bundle   s3   *  	5!<<=MNNNDDDD^DDDN + ( (h(899 (%%'''(
 ,,1A,BBB!4N& 	@ 	@H($455 @>>"LLNN 0 0DAqx++ 0!Q///h44X>>???r)   c                     |rR                      |          } fd|D             }|D ]+}t          |t                    r|                                 ,n"                     t                      j        }|D ]v}t          |t                    r_t          |          }|                                D ]&\  }}t          ||          rt          |||           '|
                    |           wd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                      g | ]
}|         S rT   rT   rU   s     r'   rX   z?RenderersConfig._perform_external_rendering.<locals>.<listcomp>C  r   r)   r   N)rY   r:   r	   ri   rk   r"   r   rG   r   r   render)	r&   r   rq   rK   r[   r   r6   rL   rM   s	   `        r'   _perform_external_renderingz+RenderersConfig._perform_external_rendering,  s"   *  
	5!<<=MNNNDDDD^DDDN + ( (h(899 (%%'''( ,,1A,BBB!4N& 	* 	*H($455 *>>"LLNN 0 0DAqx++ 0!Q///)))	* 	*r)   r+   )__name__
__module____qualname____doc__r(   r-   r1   r4   r7   r@   rC   rE   rG   rN   propertyrP   setterr]   objectrk   rY   rw   rv   r   r   rT   r)   r'   r   r   (   s          $ $ $' ' '% % %  
% 
% 
%! ! !& & &' ' '     $ " " X": ^: : ^:" 	' 	' X	' , , , /5 
 
 
 
.  <	
 	
 	
  , , , ,\(* (* (* (* (* (*r)   r   Tc                 ^   t          | |          }t          j        |fd|i|}|rrt          st	          d          t
          r*t          t
          j                  t          d          k     rt	          d          t                              |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
    rq   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   	renderersr   ipython_displayr;   r   r   __version__displayr   )figr6   validaterK   r   r   s         r'   showr   ^  s    F +399H )(XXXXQWXXF 2 	N    	<(<==W@U@UU 	V   	D111 )(XXXXQWXXXXXr)   plotly_mimetype
jupyterlabnteractvscode)confignotebook)r   	connectednotebook_connectedkaggleazurecolabcocalc
databricksjsonpngjpegjpgsvgpdfbrowserfirefox)r   using)chromezgoogle-chromer   )chromiumzchromium-browserr   )r   include_plotlyjsiframecdniframe_connectedsphinx_gallerysphinx_gallery_pngPLOTLY_RENDERERzb
Invalid named renderer(s) specified in the 'PLOTLY_RENDERER'
environment variable: {env_renderer})env_rendererz/kaggle/inputAZURE_NOTEBOOKS_HOST
VSCODE_PIDNTERACT_EXECOCALC_PROJECT_IDDATABRICKS_RUNTIME_VERSIONSPYDER_ARGS)validate_executableTerminalInteractiveShellzplotly_mimetype+notebook)NT)?
__future__r   r   r   r   osdistutils.versionr   plotlyr   plotly.io._base_renderersr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   plotly.io._utilsr   
get_moduleipythonr   r   r   r   r   r   plotly_rendererr   jpeg_rendererdefault_rendererenvirongetr   rY   r;   r<   get_ipythongoogle.colabgoogleImportErrorpathexistsplotly.io.orcar   	__class__r   
webbrowserErrorr]   rP   rT   r)   r'   <module>r      s   0 0 0 0 0 0 0 0        				 * * * * * * # # # # # #                                       ( 9 8 8 8 8 8
%

%i
0
0-"-.?@@&&z22
l* l* l* l* l*f l* l* l*b	 O	5Y 5Y 5Y 5Yx !."".	
 )	, &	) %	(  
((777	* "2"2&D"Q"Q"Q	
 $nF333	( "]&111	' "]&111	' $n&&	( ,,..	,  !LNN	&  ;==	% !	&  	% ;==	% ;==	%  'f555	) &fYHHH	) %oV;VWWW	( '9  	*  %nFTJJJ	(  .fu U U U	
 7799	
 ";";"="=	
 
   z~~/66 O	
,,\:::: 
 
 
j((.) )/ ) )
 
 	

 $ B$$&& B  	& 	 	 	D	  $ ? ? $#  # 6"* D #"  $
 : $#  % ; %$  $ 3rz A $# ( <
 J ('   ; 	::::::!!!$ 	 	 	D	
  %'04NN% %
  65 
$    #	 $	   sB   H %I  I' 'I/.I/K0 0K87K8+L= =
M
	M
