
    g                          d Z ddlZddlmZmZ ddlmZmZ  ee      Z	 eej                        Z G d dee	      Zd Z eej                        ZddZd	 Zd
 Zd ZdddddZddZd Zy)z@ Defines miscellaneous Qt-related helper classes and functions.
    N)QtCoreQtGui)	HasTraits	TraitTypec                       e Zd ZdZd Zd Zy)MetaQObjectHasTraitsa   A metaclass that inherits from the metaclasses of HasTraits and QObject.

    Using this metaclass allows a class to inherit from both HasTraits and
    QObject. Using SuperQObject instead of QObject is highly recommended. See
    QtKernelManager for an example.
    c                    t        |j                               D ]W  \  }}t        |t              r||_        t        j                  |      s4t        |t              sE |       }||_        |||<   Y t        j                  | |||      }|S N)
iteritems
isinstancer   nameinspectisclass
issubclassMetaQObject__new__)mclsr   bases	classdictkvvinstclss           .lib/python3.12/site-packages/qtconsole/util.pyr   zMetaQObjectHasTraits.__new__   sy     	)*CAa!Y'#a+CE!"EJ#(IaL + !!$eY?
    c                 d    t         j                  | |||       t        j                  | |||       y r
   )r   __init__MetaHasTraits)r   r   r   r   s       r   r   zMetaQObjectHasTraits.__init__&   s*    T4	:tT5)<r   N)__name__
__module____qualname____doc__r   r    r   r   r   r      s    =r   r   c                 &      G  fdd       S )a   Permits the use of super() in class hierarchies that contain Qt classes.

    Unlike QObject, SuperQObject does not accept a QObject parent. If it did,
    super could not be emulated properly (all other classes in the heierarchy
    would have to accept the parent argument--they don't, of course, because
    they don't inherit QObject.)

    This class is primarily useful for attaching signals to existing non-Qt
    classes. See QtKernelManagerMixin for an example.
    c                   $    e Zd Z fdZ fdZy)superQ.<locals>.SuperQClassc                 L    j                  |       }j                  |       |S r
   )r   r   )r   argskwinstQClasss       r   r   z#superQ.<locals>.SuperQClass.__new__<   s$     >>#&DOOD!Kr   c                     | j                   j                         }j                         D ]  }|j                  |        |j                        dz   }|t	        |      k  r ||   j
                  | g|i | y y )N   )	__class__mroremoveindexlenr   )selfr)   r*   r0   qt_class
next_indexr,   SuperQClasss         r   r   z$superQ.<locals>.SuperQClass.__init__C   ss    ..$$&C"JJL

8$ );/!3JCH$(J((;;; %r   N)r    r!   r"   r   r   r,   r7   s   r   r7   r'   :   s    		<r   r7   r$   r8   s   `@r   superQr9   /   s    <f <$ r   c                     t        j                  |       }t        j                  |      }|(|j                         | k7  rt        j                  |      }|S )a  Return a font of the requested family, using fallback as alternative.

    If a fallback is provided, it is used in case the requested family isn't
    found.  If no fallback is given, no alternative is chosen and Qt's internal
    algorithms may automatically choose a fallback font.

    Parameters
    ----------
    family : str
      A font name.
    fallback : str
      A font name.

    Returns
    -------
    font : QFont object
    )r   QFont	QFontInfofamily)r=   fallbackfont	font_infos       r   get_fontrA   T   sK    $ ;;vD %I	 0 0 2f <{{8$Kr   c              #   V   K   t        dt        |       |      D ]  }| |||z      yw)z'Yield successive n-sized chunks from l.r   N)ranger3   )lnis      r   _chunksrG   r   s-     1c!fa AEl !s   ')c          
          t        dt        |       dz         D ]K  }t        t        t        t        | |                  }t        |      }t        |      }|||dz
  z  z   |k  sK n dS )z5Calculate optimal info to columnize a list of stringsr.   )columns_numbersrows_numberscolumns_width)rC   r3   listmapmaxrG   sum)rlistseparator_sizedisplaywidthnrowchk	sumlengthncolss          r   _find_optimalrW   x   ss    aUa(3sGE4012H	C~33|C ) ! r   c                ,    |t        |       k\  r|S | |   S )z2return list item number, or default if don't exist)r3   )mylistrF   defaults      r   _get_or_defaultr[      s    CKayr      P   rQ   rR   c                   t        | D cg c]  }t        |       c}||      }|d   |d   }}t        |      D 	cg c]-  }t        |      D 	cg c]  }	t        | |	|z  |z   |       c}	/ c}	}|fS c c}w c c}	w c c}	}w )a  Returns a nested list, and info to columnize items

    Parameters
    ----------
    items
        list of strings to columnize
    empty : (default None)
        Default value to fill list if needed
    separator_size : int (default=2)
        How much characters will be used as a separation between each column.
    displaywidth : int (default=80)
        The width of the area onto which the columns should enter

    Returns
    -------

    strings_matrix

        nested list of strings, the outer most list contains as many list as
        rows, the innermost lists have each as many element as column. If the
        total number of elements in `items` does not equal the product of
        rows*columns, the last element of some lists are filled with `None`.

    dict_info
        Some info to make columnize easier:

        columns_numbers
          number of columns
        rows_numbers
          number of rows
        columns_width
          list of width of each columns

    Examples
    --------
    ::

        In [1]: l = ['aaa','b','cc','d','eeeee','f','g','h','i','j','k','l']
           ...: compute_item_matrix(l,displaywidth=12)
        Out[1]:
            ([['aaa', 'f', 'k'],
            ['b', 'g', 'l'],
            ['cc', 'h', None],
            ['d', 'i', None],
            ['eeeee', 'j', None]],
            {'columns_numbers': 3,
            'columns_width': [5, 1, 1],
            'rows_numbers': 5})
    r^   rJ   rI   )rZ   )rW   r3   rC   r[   )
r   emptyrQ   rR   itinforS   ncolrF   cs
             r   compute_item_matrixre      s    d  !5RR5!.|D n%t,='>$D 4[	
  KPPT+V+Q_UAHqL%@+V 	
 	  	"
 W	
s   A6B A;+B ;B c                     | syt        | t              |      \  }|D cg c]  }t        d|       }}fd}dj                  t	        ||            dz   S c c}w )zTransform a list of strings into a single string with columns.

    Parameters
    ----------
    items : sequence of strings
        The strings to process.

    Returns
    -------
    The formatted string.
    
r^   Nc           
          j                  t        | d         D cg c]  \  }}|j                  |d       c}}      S c c}}w )NrK    )joinzipljust)xywrb   	separators      r   <lambda>zcolumnize.<locals>.<lambda>   s?    inn%(D,A%BC%BTQC%BCCs   A
)re   r3   filterrj   rM   )r   rp   rR   matrixrm   fmatrixsjoinrb   s    `     @r   	columnizerv      si     &c)n<LFD )//1vdAG/E 99S()D00	 0s   Ac                     | j                  dd      }t        |      dk(  r"|\  }}t        ||g      }	 t        ||      }|S t        |d         S # t        $ r t        d|z        w xY w)a  Import and return ``bar`` given the string ``foo.bar``.

    Calling ``bar = import_item("foo.bar")`` is the functional equivalent of
    executing the code ``from foo import bar``.

    Parameters
    ----------
    name : string
      The fully qualified name of the module/package being imported.

    Returns
    -------
    mod : module object
       The module that was imported.
    .r.   r\   )fromlistzNo module named %sr   )rsplitr3   
__import__getattrAttributeErrorImportError)r   partspackageobjmodulepaks         r   import_itemr      s      KKQE
5zQGse4	:&#&C 
 %(##  	:2S899	:s   A A)r
   )z  r]   )r#   r   qtpyr   r   	traitletsr   r   typer   QObjectr   r   r9   SuperQObjectrA   rG   rW   r[   re   rv   r   r$   r   r   <module>r      s~      * Y6>>"=; =<> fnn%< <QR <~10$r   