| Current File : //usr/lib/python3/dist-packages/twisted/python/__pycache__/_textattributes.cpython-312.pyc |
�
Ϫ�f�# � � � d Z ddlmZmZmZ ddlmZ G d� de� Z G d� de� Z G d� d e� Z G d
� d e� Z
G d � d
e
� Z G d� de
� Z G d� d� Z
G d� d� Z G d� de� Z G d� de� Zdd�Zg d�Zy) am
This module provides some common functionality for the manipulation of
formatting states.
Defining the mechanism by which text containing character attributes is
constructed begins by subclassing L{CharacterAttributesMixin}.
Defining how a single formatting state is to be serialized begins by
subclassing L{_FormattingStateMixin}.
Serializing a formatting structure is done with L{flatten}.
@see: L{twisted.conch.insults.helper._FormattingState}
@see: L{twisted.conch.insults.text._CharacterAttributes}
@see: L{twisted.words.protocols.irc._FormattingState}
@see: L{twisted.words.protocols.irc._CharacterAttributes}
� )�ClassVar�List�Sequence)� FancyEqMixinc �L � e Zd ZU dZdZeee ed< d� Z defd�Z
d� Z d
d �Z y) �
_Attributea1
A text attribute.
Indexing a text attribute with a C{str} or another text attribute adds that
object as a child, indexing with a C{list} or C{tuple} adds the elements as
children; in either case C{self} is returned.
@type children: C{list}
@ivar children: Child attributes.
��children�compareAttributesc � � g | _ y �Nr ��selfs �@/usr/lib/python3/dist-packages/twisted/python/_textattributes.py�__init__z_Attribute.__init__+ s � ���
� �returnc �L � dt | � j � dt | � �d�S )N�<� �>)�type�__name__�varsr s r �__repr__z_Attribute.__repr__. s& � ��4��:�&�&�'�q��d���a�8�8r c �� � t |t t t t f� sJ �t |t t f� r | j
j
|� | S | j
j |� | S r
)�
isinstance�list�tupler �strr
�extend�append)r �items r � __getitem__z_Attribute.__getitem__1 s[ � ��$��u�j�#� >�?�?�?� �d�T�5�M� *� �M�M� � �� &� � �
�M�M� � �� &�� r Nc �� � |�
t � }| j D ]U }t |t � r"|j ||j � |� �5t
||� } | |� � ||� �W y)a
Serialize the text attribute and its children.
@param write: C{callable}, taking one C{str} argument, called to output
a single text attribute at a time.
@param attrs: A formatting state instance used to determine how to
serialize the attribute children.
@type attributeRenderer: C{str}
@param attributeRenderer: Name of the method on I{attrs} that should be
called to render the attributes during serialization. Defaults to
C{'toVT102'}.
N)�DefaultFormattingStater
r r � serialize�copy�getattr)r �write�attrs�attributeRenderer�ch�
renderMeths r r' z_Attribute.serialize9 sc � � �=�*�,�E��-�-� �B��"�j�)�� � �U�E�J�J�L�2C�D� $�U�,=� >�
��j�l�#��b� �
r )N�toVT102)
r �
__module__� __qualname__�__doc__r r r r �__annotations__r r r$ r' � r r r r s8 � � � 2?��x���
�.�>��9�#� 9��r r c � � e Zd ZdZd� Zy)� _NormalAttrz+
A text attribute for normal text.
c �T � |j � t j | |||� y r
)r r r' �r r* r+ r, s r r' z_NormalAttr.serializeX s! � �
����� � �T�5�%�1B�Cr N)r r0 r1 r2 r' r4 r r r6 r6 S s
� ��Dr r6 c �& � e Zd ZdZdZd� Zd� Zd� Zy)�
_OtherAttra
A text attribute for text with formatting attributes.
The unary minus operator returns the inverse of this attribute, where that
makes sense.
@type attrname: C{str}
@ivar attrname: Text attribute name.
@ivar attrvalue: Text attribute value.
)�attrname� attrvaluer
c �J � t j | � || _ || _ y r
)r r r; r< )r r; r< s r r z_OtherAttr.__init__l s � ����D�!� ��
�"��r c � � t | j | j � }|j j | j � |S r
)r: r; r< r
r! )r �results r �__neg__z_OtherAttr.__neg__q s4 � ��D�M�M�t�~�~�+=�>����� � �t�}�}�-��
r c � � |j | j | j � }t j | |||� y r
)�_withAttributer; r< r r' r8 s r r' z_OtherAttr.serializev s1 � ��$�$�T�]�]�D�N�N�C��� � �T�5�%�1B�Cr N)r r0 r1 r2 r r r@ r' r4 r r r: r: ] s � �
� >��#�
�
Dr r: c � � e Zd ZdZdZd� Zd� Zy)�
_ColorAttrz
Generic color attribute.
@param color: Color value.
@param ground: Foreground or background attribute name.
)�color�groundr
c �J � t j | � || _ || _ y r
)r r rE rF )r rE rF s r r z_ColorAttr.__init__� s � ����D�!���
� �� r c � � |j | j | j � }t j | |||� y r
)rB rF rE r r' r8 s r r' z_ColorAttr.serialize� s1 � ��$�$�T�[�[�$�*�*�=��� � �T�5�%�1B�Cr N)r r0 r1 r2 r r r' r4 r r rD rD { s � �� 8�� �
Dr rD c � � e Zd ZdZd� Zy)�_ForegroundColorAttrz%
Foreground color attribute.
c �2 � t j | |d� y )N�
foreground�rD r �r rE s r r z _ForegroundColorAttr.__init__� � � ����D�%� �6r N�r r0 r1 r2 r r4 r r rJ rJ � � � ��7r rJ c � � e Zd ZdZd� Zy)�_BackgroundColorAttrz%
Background color attribute.
c �2 � t j | |d� y )N�
backgroundrM rN s r r z _BackgroundColorAttr.__init__� rO r NrP r4 r r rS rS � rQ r rS c � � e Zd ZdZd� Zd� Zy)�_ColorAttributeab
A color text attribute.
Attribute access results in a color value lookup, by name, in
I{_ColorAttribute.attrs}.
@type ground: L{_ColorAttr}
@param ground: Foreground or background color attribute to look color names
up from.
@param attrs: Mapping of color names to color values.
@type attrs: Dict like object.
c � � || _ || _ y r
)rF r+ )r rF r+ s r r z_ColorAttribute.__init__� s � � �� ���
r c �p � | j | j | � S # t $ r t |� �w xY wr
)rF r+ �KeyError�AttributeError�r �names r � __getattr__z_ColorAttribute.__getattr__� s9 � � '��;�;�t�z�z�$� /�0� 0��� '� ��&� &� '�s � �5N)r r0 r1 r2 r r^ r4 r r rW rW � s � � � �'r rW c � � e Zd ZdZd� Zy)�CharacterAttributesMixina
Mixin for character attributes that implements a C{__getattr__} method
returning a new C{_NormalAttr} instance when attempting to access
a C{'normal'} attribute; otherwise a new C{_OtherAttr} instance is returned
for names that appears in the C{'attrs'} attribute.
c �j � |dk( r
t � S || j v r t |d� S t |� �)N�normalT)r6 r+ r: r[ r\ s r r^ z$CharacterAttributesMixin.__getattr__� s6 � � �8� � �=� � �4�:�:� � �d�D�)� )� �T�"�"r N)r r0 r1 r2 r^ r4 r r r` r` � s � ��#r r` c �B � e Zd ZU dZdZeee ed< dZ d� Z
d� Z d� Z y) r& z[
A character attribute that does nothing, thus applying no attributes to
text.
)�_dummyr r c �" � t | � � S )zf
Make a copy of this formatting state.
@return: A formatting state instance.
)r r s r r( zDefaultFormattingState.copy� s � � �t�D�z�|�r c �" � | j � S )a
Add a character attribute to a copy of this formatting state.
@param name: Attribute name to be added to formatting state.
@param value: Attribute value.
@return: A formatting state instance with the new attribute.
)r( )r r] �values r rB z%DefaultFormattingState._withAttribute� s � � �y�y�{�r c � � y)z�
Emit a VT102 control sequence that will set up all the attributes this
formatting state has set.
@return: A string containing VT102 control sequences that mimic this
formatting state.
� r4 r s r r/ z DefaultFormattingState.toVT102� s � � r N)
r r0 r1 r2 r r r r r3 rd r( rB r/ r4 r r r& r& � s1 � ��
2=��x���
�.�<�
�F� �
�r r& c � � e Zd ZdZd� Zd� Zy)�_FormattingStateMixinzJ
Mixin for the formatting state/attributes of a single character.
c �x � t j | � }|j j t | � � |S r
)r& r( �__dict__�updater )r �cs r r( z_FormattingStateMixin.copy� s- � � "� '� '�� -�� �
�
���$�t�*�%��r c � � t | |� |k7 r'| j � }| |_ t |||� |S | j � S r
)r) r( � _subtracting�setattr)r r] rg �attrs r rB z$_FormattingStateMixin._withAttribute� sC � � �4�� �%� '��9�9�;�D�$)� �D� � �D�$�� &��K��9�9�;� r N)r r0 r1 r2 r( rB r4 r r rk rk � s � ���
r rk c �b � g }| j |j ||� dj |� S )a�
Serialize a sequence of characters with attribute information
The resulting string can be interpreted by compatible software so that the
contained characters are displayed and, for those attributes which are
supported by the software, the attributes expressed. The exact result of
the serialization depends on the behavior of the method specified by
I{attributeRenderer}.
For example, if your terminal is VT102 compatible, you might run
this for a colorful variation on the "hello world" theme::
from twisted.conch.insults.text import flatten, attributes as A
from twisted.conch.insults.helper import CharacterAttribute
print(flatten(
A.normal[A.bold[A.fg.red['He'], A.fg.green['ll'], A.fg.magenta['o'], ' ',
A.fg.yellow['Wo'], A.fg.blue['rl'], A.fg.cyan['d!']]],
CharacterAttribute()))
@param output: Object returned by accessing attributes of the
module-level attributes object.
@param attrs: A formatting state instance used to determine how to
serialize C{output}.
@type attributeRenderer: C{str}
@param attributeRenderer: Name of the method on I{attrs} that should be
called to render the attributes during serialization. Defaults to
C{'toVT102'}.
@return: A string expressing the text and display attributes specified by
L{output}.
ri )r' r" �join)�outputr+ r, � flatteneds r �flattenrx s2 � �D �I�
���Y�%�%�u�.?�@�
�7�7�9� � r )rx r& r` N)r/ )r2 �typingr r r �twisted.python.utilr r r6 r: rD rJ rS rW r` r& rk rx �__all__r4 r r �<module>r| s� ��
�& ,� +� ,�3� � 3�lD�*� D�D�� D�<D�� D�*7�:� 7�7�:� 7�'� '�4
#�
#� &�\� &�R � 2� �($ �N L�r