a
    zn„f= ã                   @  sÔ  d Z ddlmZ ddlZddlZddlZddlZddlZddl	Z	ddl
ZddlZddlZddlZddlZddlZddlZddlZG dd„ dƒZG dd„ dƒZe d¡ZG d	d
„ d
eƒZG dd„ deƒZe d¡Ze d¡ZG dd„ deƒZG dd„ deƒZe d¡ZG dd„ deƒZG dd„ deƒZG dd„ deƒZ G dd„ deƒZ!G dd„ dƒZ"G dd„ deƒZ#G d d!„ d!eƒZ$G d"d#„ d#eƒZ%G d$d%„ d%e%ƒZ&G d&d'„ d'e%ƒZ'G d(d)„ d)eƒZ(G d*d+„ d+ƒZ)d,d-„ Z*d.d/„ Z+dS )0aÅ  
This is an internal module defining the "cascading" file writer, which is like a
reactive programming environment. A tree of data structures whose leaves are
:doc:`uproot.writing._cascade.CascadeLeaf` each control a part of the ROOT file,
and when a change is needed, they rewrite their section in an organized flow that
updates pointers after updating content, so that pointers are always valid.

Modifying data in a ROOT file has many non-local effects. For instance, if you add
a new object, the space for that object must be claimed from the FreeSegments record
at the end of the file, and the FreeSegments record may even need to be rewritten
because it has to move to make space for the new object. Then a pointer must be added
to a TDirectory to point to the new object, and that might exceed the space allocated
for the TDirectory, in which case it, too needs to claim space from FreeSegments
(possibly moving it). When a TDirectory moves, the pointer to it must be updated
as well, which might be in another TDirectory if it's a subdirectory, etc. If these
updates were not organized, redundant overwrites or even infinite cycles could occur.
Thus, the structure of the cascade tree must be carefully laid out.
é    )ÚannotationsNc                   @  sf   e Zd ZdZdd„ Zedd„ ƒZejdd„ ƒZedd„ ƒZed	d
„ ƒZ	dd„ Z
edd„ ƒZdd„ ZdS )ÚCascadeLeafaÝ  
    A leaf node in the tree of cascading, low-level writables.

    Only leaf nodes actually write to the file. The general strategy is that non-leaf
    nodes modify their children's attributes, and any modification causes a leaf's
    ``file_dirty`` property to become True. When all variables are updated, the
    writing process is triggered in a single pass, though a particular leaf will
    only actually write if its ``file_dirty`` is True.

    This is similar to the way that graphical elements update pixels in a graphical
    user interface: each item owns a region of pixels and only updates those pixels
    if they are marked as "dirty" (would change). The difference here is that a
    file is one-dimensional. Leaves own a one-dimensional interval from ``location``
    to ``location + num_bytes``. Some of these attributes might not be known (and
    therefore set to None) before it is time to write.

    See :doc:`uproot.writing._cascade` for a general overview.
    c                 C  s   || _ || _d| _d S ©NT)Ú	_locationÚ_allocationÚ_file_dirty)ÚselfÚlocationÚ
allocation© r   úZ/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/uproot/writing/_cascade.pyÚ__init__=   s    zCascadeLeaf.__init__c                 C  s   | j S ©N)r   ©r   r   r   r   r	   B   s    zCascadeLeaf.locationc                 C  s   | j |krd| _|| _ d S r   )r   r   ©r   Úvaluer   r   r   r	   F   s    
c                 C  s   | j d u r| j| _ | j S r   ©r   Ú	num_bytesr   r   r   r   r
   L   s    
zCascadeLeaf.allocationc                 C  s   t |  ¡ ƒS r   )ÚlenÚ	serializer   r   r   r   r   R   s    zCascadeLeaf.num_bytesc                 C  s   t dƒ‚d S )Nz7CascadeLeaf is abstract; 'serialize' must be overloaded©ÚAssertionErrorr   r   r   r   r   V   s    zCascadeLeaf.serializec                 C  s   t dƒ‚d S )Nz9CascadeLeaf is abstract; 'deserialize' must be overloadedr   )ÚclsÚ	raw_bytesr	   r   r   r   ÚdeserializeY   s    ÿzCascadeLeaf.deserializec                 C  s@   | j r<| jd u r tdt| ƒ ƒ‚|  ¡ }| | j|¡ d| _ d S ©Nz5can't write object because location is unknown:

    F)r   r   ÚRuntimeErrorÚreprr   Úwrite)r   ÚsinkÚtmpr   r   r   r   _   s    
ÿÿzCascadeLeaf.writeN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   Úpropertyr	   Úsetterr
   r   r   Úclassmethodr   r   r   r   r   r   r   )   s   




r   c                   @  s(   e Zd ZdZdd„ Zdd„ Zdd„ ZdS )	ÚCascadeNodea¨  
    A non-leaf node in the tree of cascading, low-level writables.

    Non-leaf nodes contain other nodes as attributes and propagate their information
    downward toward the leaves, which do the actual writing.

    A non-leaf node defines a ``dependencies`` order in which the writing is to take
    place. The order is such that referents are written before references. If writing
    is interrupted after writing a referent but before writing its references, the
    resulting file will contain unreachable data, but all references would be valid,
    providing some resilience against incomplete writes.

    See :doc:`uproot.writing._cascade` for a general overview.
    c                 G  s
   || _ d S r   ©Ú_dependencies©r   Údependenciesr   r   r   r   |   s    zCascadeNode.__init__c                 G  s   | j | | _ d S r   r)   r+   r   r   r   Úmore_dependencies   s    zCascadeNode.more_dependenciesc                 C  s   | j D ]}| |¡ qd S r   )r*   r   )r   r   Ú
dependencyr   r   r   r   ‚   s    
zCascadeNode.writeN)r!   r"   r#   r$   r   r-   r   r   r   r   r   r(   l   s   r(   z>Ic                      sP   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZdd	„ Zd
d„ Z	e
dd„ ƒZ‡  ZS )ÚStringu,  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing a string, such
    as a name, a title, or a class name.

    If the string's byte representation (UTF-8) has fewer than 255 bytes, it
    is preceded by a 1-byte length; otherwise, it is preceded by ``b'Ã¿'`` and a
    4-byte length.
    c                   s(   t ƒ  |d ¡ || _tj | j¡| _d S r   )Úsuperr   Ú_stringÚuprootÚserializationÚstringÚ_serialization)r   r	   r4   ©Ú	__class__r   r   r   ”   s    zString.__init__c                 C  s    t | ƒj› d| j› d| j›d�S ©Nú(ú, ú))Útyper!   r   r1   r   r   r   r   Ú__repr__™   s    zString.__repr__c                 C  s   | j S r   )r1   r   r   r   r   r4   œ   s    zString.stringc                 C  s   t || jƒS r   )r/   r1   ©r   r	   r   r   r   Úcopy_to    s    zString.copy_toc                 C  s   | j S r   ©r5   r   r   r   r   r   £   s    zString.serializec                 C  sb   t |d d… ƒ}d}|dkr4t |dd… ¡\}d}|||| … jdd�}t||ƒ|| | fS )Né   éÿ   é   Úsurrogateescape©Úerrors)ÚordÚ_string_size_format_4ÚunpackÚdecoder/   )r   r   r	   r   ÚpositionÚoutr   r   r   r   ¦   s    ÿzString.deserialize)r!   r"   r#   r$   r   r=   r%   r4   r?   r   r'   r   Ú__classcell__r   r   r6   r   r/   Š   s   	
r/   c                      s  e Zd ZdZdZd)‡ fdd„	Zdd„ Zedd	„ ƒZed
d„ ƒZ	e	j
dd„ ƒZ	edd„ ƒZej
dd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZdd„ Zed d!„ ƒZed"d#„ ƒZd$d%„ Zed*d'd(„ƒZ‡  ZS )+ÚKeya4  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing a ROOT TKey.

    TKeys may have 4-byte pointers (small) or 8-byte pointers (big), which changes
    their size depending on where their referents are located (before or after the
    ``kStartBigFile`` boundary of 2 GB, not 2 GiB). Their size also depends on
    three strings: name, title, and class name, but these do not change as
    an object's position moves within the file.

    See `ROOT TKey specification <https://github.com/root-project/root/blob/master/io/doc/TFile/datarecord.md>`__.
    é   Nc                   s`   t ƒ  |d ¡ || _|| _|| _|| _|| _|| _|| _|	| _	|
d u rPt
j
 ¡ n|
| _|| _d S r   )r0   r   Ú_uncompressed_bytesÚ_compressed_bytesÚ
_classnameÚ_nameÚ_titleÚ_cycleÚ_parent_locationÚ_seek_locationÚdatetimeÚnowÚ_created_onÚ_big)r   r	   Úuncompressed_bytesÚcompressed_bytesÚ	classnameÚnameÚtitleÚcycleÚparent_locationÚseek_locationÚ
created_onÚbigr6   r   r   r   Â   s    zKey.__init__c                 C  sX   t | ƒj› d| j› d| j› d| j› d| j›d| j›d| j›d| j› d| j	› d| j
› d�S r8   )r<   r!   r   rP   rQ   rR   rS   rT   rU   rV   rW   r   r   r   r   r=   Ü   s    zKey.__repr__c                 C  s   | j S r   ©r   r   r   r   r   r
   ß   s    zKey.allocationc                 C  s   | j S r   )rP   r   r   r   r   r\   ã   s    zKey.uncompressed_bytesc                 C  s   | j |krd| _|| _ d S r   )rP   r   r   r   r   r   r\   ç   s    
c                 C  s   | j S r   )rQ   r   r   r   r   r]   í   s    zKey.compressed_bytesc                 C  s   | j |krd| _|| _ d S r   )rQ   r   r   r   r   r   r]   ñ   s    
c                 C  s   | j S r   )rR   r   r   r   r   r^   ÷   s    zKey.classnamec                 C  s   | j S r   ©rS   r   r   r   r   r_   û   s    zKey.namec                 C  s   | j S r   ©rT   r   r   r   r   r`   ÿ   s    z	Key.titlec                 C  s   | j S r   )rU   r   r   r   r   ra     s    z	Key.cyclec                 C  s   | j S r   ©rV   r   r   r   r   rb     s    zKey.parent_locationc                 C  s    | j |krd| _d | _|| _ d S r   )rV   r   r[   r   r   r   r   rb     s    
c                 C  s   | j S r   )rW   r   r   r   r   rc     s    zKey.seek_locationc                 C  s    | j |krd| _d | _|| _ d S r   )rW   r   r[   r   r   r   r   rc     s    
c                 C  s„   || j  }| j |¡}||j 7 }| j |¡}||j 7 }| j |¡}| jd urT| j}n| j}t|| j| j	|||| j
| j|| j| jd�S )N©rd   re   )r   rR   r?   rS   rT   rW   r   rN   rP   rQ   rU   rV   rZ   r[   )r   r	   rK   r^   r_   r`   r   r   r   r?     s,    



õzKey.copy_toc                 C  s`   | j d ur| j S | jd ur6| jtjjkp4| jtjjkS | jd u pZ| jtjjkpZ| jtjjkS d S r   )r[   rW   r2   ÚconstÚkStartBigFilerV   r   r   r   r   r   re   :  s    

þ
ÿýzKey.bigc                 C  sN   | j r(tjjj| jj | jj | jj S tjj	j| jj | jj | jj S d S r   )
re   r2   ÚreadingÚ_key_format_bigÚsizerR   r
   rS   rT   Ú_key_format_smallr   r   r   r   r   J  s"    ÿþýÿÿþýÿzKey.num_bytesc              
   C  s´   | j d u r$| jd u r$tdt| ƒ ƒ‚| jr>tjj}| jd }ntjj	}| j}| j d ur^| j }n| j}| 
| j| j || jtj | j¡| j| j|| j¡| j ¡  | j ¡  | j ¡  S )Nz6can't serialize key because location is unknown:

    éè  )rW   r   r   r   re   r2   rm   rn   Úclass_versionrp   ÚpackrQ   r   rP   Ú_utilÚdatetime_to_coderZ   rU   rV   rR   r   rS   rT   )r   ÚformatÚversionr	   r   r   r   r   [  s:    
ÿ

ø
öõôÿzKey.serializeFc                 C  sŽ  t jj |d t jjj… ¡\}}}}}	}
}}|t jjj }d}|dkrŒt jj |d t jjj… ¡\}}}}}	}
}}|d8 }|t jjj }d}|| jkr°td|› d| j› |› �ƒ‚d|  k rÈ|	| ksÎn J ‚|
dksÚJ ‚|sþ||ksúJ d|› d|› �ƒ‚d }t 	||| d … |¡\}}t 	||| d … |¡\}}t 	||| d … |¡\}}|	|| k�sdJ ‚t
||||	 ||||
||t j |¡|d	�S )
NFrq   TzUproot can't read TKey version ú for writing, only version r   z	fSeekKey z
 location rj   )r2   rm   rp   rI   ro   rn   rr   Ú
ValueErrorr/   r   rN   rt   Úcode_to_datetime)r   r   r	   Úin_pathÚis_directory_keyZfNbytesrw   ZfObjlenZfDatimeZfKeylenZfCycleZfSeekKeyZ	fSeekPdirrK   re   r^   r_   r`   r   r   r   r   }  st    ÿ÷
ÿ÷
ÿÿ
õzKey.deserialize)NN)F)r!   r"   r#   r$   rr   r   r=   r%   r
   r\   r&   r]   r^   r_   r`   ra   rb   rc   r?   re   r   r   r'   r   rM   r   r   r6   r   rN   ³   sP     ô














"rN   z>HIIz>HQQc                      sš   e Zd ZdZdZ‡ fdd„Zdd„ Zedd„ ƒZej	d	d„ ƒZed
d„ ƒZ
e
j	dd„ ƒZ
edd„ ƒZej	dd„ ƒZedd„ ƒZdd„ Zedd„ ƒZ‡  ZS )ÚFreeSegmentsDatazR
    A :doc:`uproot.writing._cascade.CascadeLeaf` for the FreeSegments record
    rA   c                   s   t ƒ  |d ¡ || _|| _d S r   )r0   r   Ú_slicesÚ_end)r   r	   ÚslicesÚendr6   r   r   r   Ì  s    zFreeSegmentsData.__init__c                 C  s(   t | ƒj› d| j› d| j› d| j› d�S r8   )r<   r!   r   r~   r   r   r   r   r   r=   Ñ  s    zFreeSegmentsData.__repr__c                 C  s   | j S r   )r~   r   r   r   r   r€   Ô  s    zFreeSegmentsData.slicesc                 C  s   | j |krd| _|| _ d S r   )r~   r   r   r   r   r   r€   Ø  s    
c                 C  s   | j S r   ©r   r   r   r   r   r�   Þ  s    zFreeSegmentsData.endc                 C  s   | j |krd| _|| _ d S r   ©r   r   r   r   r   r   r�   â  s    
c                 C  s   | j d u r| j| _ | j S r   r   r   r   r   r   r
   è  s    
zFreeSegmentsData.allocationc                 C  s   | j |krd| _|| _ d S r   ©r   r   r   r   r   r   r
   î  s    
c                 C  s–   d}| j D ].\}}|d tjjkr.|tj7 }q
|tj7 }q
| jd u rn|tj tjjkrb|tj7 }q’|tj7 }n$| jtjjkrˆ|tj7 }n
|tj7 }|S ©Nr   rA   )r~   r2   rk   rl   Ú_free_format_bigro   Ú_free_format_smallr   )r   ÚtotalÚ_Ústopr   r   r   r   ô  s    

zFreeSegmentsData.num_bytesc              	   C  sÌ   g }| j D ]R\}}|d tjjk r>| t | j||d ¡¡ q
| t | jd ||d ¡¡ q
| j	tjjk rŠ| t | j| j	tjj¡¡ n8tjj}| j	|k s¦|d9 }q’| t | jd | j	|¡¡ d 
|¡S )NrA   rq   é   ó    )r~   r2   rk   rl   Úappendr‡   rs   rr   r†   r   Újoin)r   ÚpairsÚstartrŠ   Úinfinityr   r   r   r   	  s,    ÿÿÿÿ

ÿzFreeSegmentsData.serializec                 C  sä   g }d}t |d ƒD ]œ}t |||tj … ¡\}	}
}|	dkrpt |||tj … ¡\}	}
}|	d8 }	|tj7 }n
|tj7 }|	| jkržtd|	› d| j› |› �ƒ‚| |
|d f¡ q| ¡ d }||ksÊJ ‚t	|t
|ƒ|ƒ}||_|S )Nr   rA   rq   z Uproot can't read TFree version rx   )Úranger‡   rI   ro   r†   rr   ry   r�   Úpopr}   Útupler   )r   r   r	   r   Z
num_slicesr{   r€   rK   r‰   rw   ZfFirstZfLastr�   rL   r   r   r   r   %  s.    ÿ
ÿ


ÿzFreeSegmentsData.deserialize)r!   r"   r#   r$   rr   r   r=   r%   r€   r&   r�   r
   r   r   r'   r   rM   r   r   r6   r   r}   Å  s*   






r}   c                      sŽ   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
ddd„Zedd„ ƒZedd„ ƒZdd„ Z‡ fdd„Z‡  ZS )ÚFreeSegmentsaç  
    A :doc:`uproot.writing._cascade.CascadeNode` for writing a ROOT FreeSegments record.

    The FreeSegments describes which parts of the ROOT file are unused by valid objects;
    they may have been invalidated by moving/rewriting an object in a new space. Every
    request for a new allocation or release of an old one goes through this object: the
    disk I/O equivalent of malloc and free.

    Since allocation and release usually change the size of the FreeSegments record,
    forcing it to be rewritten and possibly requiring another allocation, our ``allocate``
    method attempts to keep the FreeSegments record at the end of the file, where it can
    grow freely without bumping into an object after it (which might itself invoke
    another allocation!). The exceptions to this rule are when we are updating an
    existing ROOT file, the FreeSegments record is not at the end of that file, and
    updating it does not require more space.

    This is different from ROOT's allocation algorithm, but compatible with it because
    Uproot and ROOT can both accept a FreeSegments record at any position in a file.

    See `ROOT TFree specification <https://github.com/root-project/root/blob/master/io/doc/TFile/freesegments.md>`__.
    c                   s&   t ƒ  |||¡ || _|| _|| _d S r   )r0   r   Ú_keyÚ_dataÚ_fileheader)r   ÚkeyÚdataÚ
fileheaderr6   r   r   r   ^  s    zFreeSegments.__init__c                 C  s(   t | ƒj› d| j› d| j› d| j› d�S r8   )r<   r!   r–   r—   r˜   r   r   r   r   r=   d  s    zFreeSegments.__repr__c                 C  s   | j S r   ©r–   r   r   r   r   r™   g  s    zFreeSegments.keyc                 C  s   | j S r   ©r—   r   r   r   r   rš   k  s    zFreeSegments.datac                 C  s   | j S r   ©r˜   r   r   r   r   r›   o  s    zFreeSegments.fileheaderc                 C  s4   | j j| j j | jj }|| jjks(J ‚|| jjkS r   )r–   r	   r   r—   r
   r�   )r   Zend_of_recordr   r   r   Úat_ends  s    zFreeSegments.at_endFc                   s  | j j‰tˆƒD ]Š\‰ \‰‰ˆˆ ˆkrX|sPt‡ ‡fdd„ttˆƒƒD ƒƒ| j _ˆ  S ˆˆ ˆkr|s’t‡ ‡‡‡‡fdd„ttˆƒƒD ƒƒ| j _ˆ  S q| jrÞ| jj}|sÚ| jjˆ | j_| jj| jj	 | j j	 | j _
|S | j j
}|sú| j j
ˆ | j _
|S d S )Nc                 3  s   | ]}ˆ |krˆ| V  qd S r   r   ©Ú.0Új)Úir€   r   r   Ú	<genexpr>€  s   z(FreeSegments.allocate.<locals>.<genexpr>c                 3  s*   | ]"}ˆ |krˆ| n
ˆˆ ˆfV  qd S r   r   r    ©r£   r   r€   r�   rŠ   r   r   r¤   ˆ  s   ÿ)r—   r€   Ú	enumerater”   r’   r   rŸ   r–   r	   r
   r�   )r   r   Údry_runrL   r   r¥   r   Úallocatey  s2    
ÿ
þ
ÿzFreeSegments.allocatec                   sh  ˆD ]X\‰‰ˆˆ  kr ˆk s:n ˆˆ  k r6ˆkrn qt dˆ› dˆ› dˆ› dˆ› d�	ƒ‚qttˆƒd ƒD ]f‰ ˆˆ  d ˆkrnˆˆˆ d  d krnˆd ˆ … ˆˆ  d ˆˆ d  d ff ˆˆ d d …    S qntˆƒD ]n\‰ \‰‰ˆˆk�rt‡ ‡‡‡fdd	„ttˆƒƒD ƒƒ  S ˆˆkrÞt‡ ‡‡‡fd
d	„ttˆƒƒD ƒƒ  S qÞttg ˆ¢ˆˆf‘R ƒƒS )NzKsegment of data to release overlaps one already marked as free: releasing [r:   z) but [z	) is freerA   r   r‹   c                 3  s&   | ]}ˆ |krˆ| nˆˆfV  qd S r   r   r    )r£   Úoriginal_stopr€   r�   r   r   r¤   ´  s   ÿz.FreeSegments._another_slice.<locals>.<genexpr>c                 3  s&   | ]}ˆ |krˆ| nˆˆfV  qd S r   r   r    )r£   Úoriginal_startr€   rŠ   r   r   r¤   »  s   ÿ)r   r’   r   r¦   r”   Úsorted)r€   rª   r©   r   )r£   rª   r©   r€   r�   rŠ   r   Ú_another_slice¡  s6    .ÿÿÿÿÿ$8ÿ

þ
þzFreeSegments._another_slicec                 C  s<   d}| D ].\}}|d t jjkr,|tj7 }q|tj7 }q|S r…   )r2   rk   rl   r†   ro   r‡   )r€   rˆ   r‰   rŠ   r   r   r   Ú_slices_bytesÃ  s    zFreeSegments._slices_bytesc                 C  s"  |   | jj||¡}| jr^|| j_d | j_| jj| j_| jj| j_| jj| jj | jj | j_	nÀ|  
|¡|  
| jj¡kr || j_d | j_| jj| j_| jj| j_n~|   || jj| jj| jj | jj ¡| j_d | j_| jj| j_| jj| j_| jj	| j_| jj| jj | j_| jj| jj | j_	d S r   )r¬   r—   r€   rŸ   r
   r–   r\   r]   r	   r�   r­   )r   r�   rŠ   Z
new_slicesr   r   r   ÚreleaseÍ  s0    ÿýzFreeSegments.releasec                   sx   | j j| j_| jj| j_| jj| jj | j _| jj| j_| jj| j j | j_t	| j j
ƒ| j_| j j| j_tƒ  |¡ d S r   )r—   r
   r–   r\   r]   r	   r˜   Úfree_locationÚfree_num_bytesr   r€   Úfree_num_slicesr�   r0   r   ©r   r   r6   r   r   r   ñ  s    zFreeSegments.write)F)r!   r"   r#   r$   r   r=   r%   r™   rš   r›   rŸ   r¨   Ústaticmethodr¬   r­   r®   r   rM   r   r   r6   r   r•   G  s$   




(
!
	$r•   z>IHHIIBIc                      st   e Zd ZdZdZ‡ fdd„Zdd„ Zedd„ ƒZej	d	d„ ƒZed
d„ ƒZ
e
j	dd„ ƒZ
edd„ ƒZdd„ Z‡  ZS )ÚTListHeaderz¯
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing a ROOT TList header.

    A TList contains the TStreamerInfo records, so it must be writable in the cascade.
    rC   c                   s    t ƒ  |tj¡ || _|| _d S r   )r0   r   Ú_tlistheader_formatro   Ú_data_bytesÚ_num_entries)r   r	   Ú
data_bytesÚnum_entriesr6   r   r   r     s    zTListHeader.__init__c                 C  s(   t | ƒj› d| j› d| j› d| j› d�S r8   )r<   r!   r   r¶   r·   r   r   r   r   r=     s    zTListHeader.__repr__c                 C  s   | j S r   )r¶   r   r   r   r   r¸     s    zTListHeader.data_bytesc                 C  s   | j |krd| _|| _ d S r   )r¶   r   r   r   r   r   r¸     s    
c                 C  s   | j S r   )r·   r   r   r   r   r¹     s    zTListHeader.num_entriesc                 C  s   | j |krd| _|| _ d S r   )r·   r   r   r   r   r   r¹     s    
c                 C  s   t jS r   )rµ   ro   r   r   r   r   r   $  s    zTListHeader.num_bytesc              	   C  s2   t  t | jd ¡tjjB | jddtjj	d| j
¡S )NrO   rA   r   )rµ   rs   ÚnumpyZuint32r¶   r2   rk   ZkByteCountMaskrr   ZkNotDeletedr·   r   r   r   r   r   (  s    ùzTListHeader.serialize)r!   r"   r#   r$   rr   r   r=   r%   r¸   r&   r¹   r   r   rM   r   r   r6   r   r´   ÿ  s   




r´   c                      sP   e Zd ZdZ‡ fdd„Zedd„ ƒZedd„ ƒZdd	„ Zd
d„ Z	dd„ Z
‡  ZS )ÚRawStreamerInfozÌ
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing a TStreamerInfo record
    defined by a raw byte stream, rather than a fully interpreted
    :doc:`uproot.streamers.Model_TStreamerInfo`.
    c                   s(   t ƒ  |t|ƒ¡ || _|| _|| _d S r   )r0   r   r   r5   rS   Ú_class_version)r   r	   r3   r_   rr   r6   r   r   r   ;  s    zRawStreamerInfo.__init__c                 C  s   | j S r   rg   r   r   r   r   r_   A  s    zRawStreamerInfo.namec                 C  s   | j S r   )r¼   r   r   r   r   rr   E  s    zRawStreamerInfo.class_versionc              
   C  s0   t | ƒj› d| j› d| j› d| j›d| j› d�
S r8   )r<   r!   r   r5   rS   r¼   r   r   r   r   r=   I  s    zRawStreamerInfo.__repr__c                 C  s   t || j| j| jƒS r   )r»   r5   rS   r¼   r>   r   r   r   r?   L  s    ÿzRawStreamerInfo.copy_toc                 C  s   | j S r   r@   r   r   r   r   r   Q  s    zRawStreamerInfo.serialize)r!   r"   r#   r$   r   r%   r_   rr   r=   r?   r   rM   r   r   r6   r   r»   4  s   

r»   c                      s8   e Zd ZdZ‡ fdd„Zdd„ Zdd„ Zdd	„ Z‡  ZS )
ÚRawTListOfStringsaK  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing a TList of ROOT TStrings.

    Sometimes, a TList of TStrings is included in a TList of TStreamerInfo to specify
    schema evolution rules as snippets of C++ code. Uproot can't interpret them, but it
    does need to pass them on when updating a preexisting file.
    c                   s   t ƒ  |t|ƒ¡ || _d S r   )r0   r   r   r5   )r   r	   r3   r6   r   r   r   ^  s    zRawTListOfStrings.__init__c                 C  s    t | ƒj› d| j› d| j› d�S r8   )r<   r!   r   r5   r   r   r   r   r=   b  s    zRawTListOfStrings.__repr__c                 C  s   t || jƒS r   )r½   r5   r>   r   r   r   r?   e  s    zRawTListOfStrings.copy_toc                 C  s   | j S r   r@   r   r   r   r   r   h  s    zRawTListOfStrings.serialize)	r!   r"   r#   r$   r   r=   r?   r   rM   r   r   r6   r   r½   U  s
   r½   c                      sŽ   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZddd„Zdd„ Z‡ fdd„Zedd„ ƒZ‡  ZS )ÚTListOfStreamerszÉ
    A :doc:`uproot.writing._cascade.CascadeNode` for writing a TList of ROOT TStreamerInfos.

    (And sometimes a nested TList of TStrings, see :doc:`uproot.writing._cascade.RawTListOfStrings`.)
    c                   sL   t ƒ j|||g|¢R Ž  || _|| _|| _|| _|| _dd„ | jD ƒ| _d S )Nc                 S  s"   h | ]}t |tƒs|j|jf’qS r   )Ú
isinstancer½   r_   rr   ©r¡   Úxr   r   r   Ú	<setcomp>z  s   
þz,TListOfStreamers.__init__.<locals>.<setcomp>)r0   r   r   r–   Ú_headerÚ_rawstreamersÚ_freesegmentsÚ_lookup)r   r
   r™   ÚheaderÚrawstreamersÚfreesegmentsr6   r   r   r   s  s    þzTListOfStreamers.__init__c                 C  s8   t | ƒj› d| j› d| j› d| j› d| j› d| j› d�S r8   )r<   r!   r   r–   rÃ   rÄ   rÅ   r   r   r   r   r=   €  s    zTListOfStreamers.__repr__c                 C  s   | j S r   )r   r   r   r   r   r
   ƒ  s    zTListOfStreamers.allocationc                 C  s   | j jtdd„ | jD ƒƒ S )Nc                 s  s   | ]}|j V  qd S r   rf   rÀ   r   r   r   r¤   ‰  rŒ   z-TListOfStreamers.num_bytes.<locals>.<genexpr>)rÃ   r   ÚsumrÄ   r   r   r   r   r   ‡  s    zTListOfStreamers.num_bytesc                 C  s   | j S r   rœ   r   r   r   r   r™   ‹  s    zTListOfStreamers.keyc                 C  s   | j S r   ©rÃ   r   r   r   r   rÇ   �  s    zTListOfStreamers.headerc                 C  s   | j S r   ©rÅ   r   r   r   r   rÉ   “  s    zTListOfStreamers.freesegmentsTc              	   C  sÎ   t | jƒ}|D ]�}|j|jf}|| jvr| j |¡ t|tjj	ƒrx| j 
t| jj| j tj ||j¡d |j|jƒ¡ qt|tƒr| j 
| | jj| j ¡¡ q| j| j|d … Ž  |rÊ|  |¡ | ¡  d S )Nó    )r   rÄ   r_   rr   rÆ   Úaddr¿   r2   Ú	streamersÚModel_TStreamerInfor�   r»   r–   r	   r   r3   Zserialize_object_anyr?   r-   r   Úflush)r   r   rÏ   rÑ   ÚwhereÚstreamerÚpairr   r   r   Úupdate_streamers—  s4    

ÿýùÿ
ÿ
z!TListOfStreamers.update_streamersc                 C  s^   | j j}| j j| j j | j }| j j| }| j |¡| j _| j j| j _|| _| j ||¡ d S r   )	r–   r	   r
   r   r   rÅ   r¨   rc   r®   )r   Úself_num_bytesrª   r©   Úrequested_num_bytesr   r   r   Ú_reallocate·  s    zTListOfStreamers._reallocatec                   sÀ   | j }|| jkr|  |¡ | jj| jj   }}|| j_|| jj 7 }| jD ]}||_||j 7 }qH|| | j_t| jƒ| j_	| j
| j_| jj| j_| jj| jj_| jj| j
 | jj_tƒ  |¡ d S r   )r   r
   rØ   r–   r	   rÃ   rÄ   r¸   r   r¹   r   r\   r]   rÅ   r›   Úinfo_locationÚinfo_num_bytesr0   r   )r   r   rÖ   rK   ZafterkeyZrawstreamerr6   r   r   r   Ã  s"    



ÿzTListOfStreamers.writec              
   C  s6  t ||ƒ}tjjj ||¡}|j|jkr.|}	n"tj 	|tjj
 d¡i |j|j¡}	tjjj |	tjj
jd|j d�i ||d ¡}
t||jt|
ƒƒ}g }t|
j|
ƒD ]€\\}}}t|tjjƒrè| t|| tj |	j||… ¡|j|jƒ¡ qžt|tjjjƒrž| t|| tj |	j||… ¡ƒ¡ qžt |j||||ƒ|
fS )Nr   )Úorigin)!Ú_ReadForUpdater2   ÚsourceÚchunkZChunkÚwrapr]   r\   ÚcompressionÚ
decompressÚcursorZCursorÚmodelsÚTListZModel_TListÚreadr   r´   r   ÚzipZbyte_rangesr¿   rÏ   rÐ   r�   r»   rt   ÚtobytesÚraw_datar_   rr   r½   r¾   )r   r   r	   r™   rÉ   Ú	file_pathÚuuidZreadforupdaterÞ   ZuncompressedZtlistrÇ   rÈ   r�   rŠ   rÓ   r   r   r   r   Ý  s^    
û
ú	üÿ	þÿûøzTListOfStreamers.deserialize)T)r!   r"   r#   r$   r   r=   r%   r
   r   r™   rÇ   rÉ   rÕ   rØ   r   r'   r   rM   r   r   r6   r   r¾   l  s$   





 r¾   c                   @  sR   e Zd Zddd„Zedd„ ƒZdd„ Zddd	„Zd
d„ Zddd„Z	edd„ ƒZ
dS )rÜ   Nc                 C  s(   || _ || _d | _|| _|| _d | _d S r   )ré   rê   Zobject_cacheÚ
_get_chunkÚ_tlist_of_streamersÚ_custom_classes)r   ré   rê   Z	get_chunkÚtlist_of_streamersr   r   r   r     s    z_ReadForUpdate.__init__c                 C  s   | S r   r   r   r   r   r   Údetached#  s    z_ReadForUpdate.detachedc                 C  s   |   ||¡S r   )rë   )r   r�   rŠ   r   r   r   rÞ   '  s    z_ReadForUpdate.chunkc                 C  s   t jjj| ||d�S )N)rw   )r2   rm   ZReadOnlyFileÚclass_named)r   r^   rw   r   r   r   rð   *  s    z_ReadForUpdate.class_namedc                   s&   | j d u rg S ‡ fdd„| j D ƒS d S )Nc                   s   g | ]}|j ˆ kr|‘qS r   )r_   rÀ   ©r^   r   r   Ú
<listcomp>1  rŒ   z2_ReadForUpdate.streamers_named.<locals>.<listcomp>©rì   )r   r^   r   rñ   r   Ústreamers_named-  s    
z_ReadForUpdate.streamers_namedÚmaxc                 C  s~   d }| j d urz| j D ]d}|j|kr|dkrD|d u s>|j|jkrx|}q|dkrf|d u s`|j|jk rx|}q|j|kr|  S q|S )Nrõ   Úmin)rì   r_   rr   )r   r^   rw   rL   rÁ   r   r   r   Ústreamer_named3  s    




z_ReadForUpdate.streamer_namedc                 C  s   | j S r   )rí   r   r   r   r   Úcustom_classesB  s    z_ReadForUpdate.custom_classes)NN)N)rõ   )r!   r"   r#   r   r%   rï   rÞ   rð   rô   r÷   rø   r   r   r   r   rÜ     s   



rÜ   c                      sâ   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZejdd„ ƒZd	d
„ Z	d+dd„Z
dd„ Zdd„ Zedd„ ƒZdd„ Zd,dd„Zedd„ ƒZedd„ ƒZedd„ ƒZdd „ Zed!d"„ ƒZed#d$„ ƒZd%d&„ Zd'd(„ Zed)d*„ ƒZ‡  ZS )-ÚDirectoryDataaÿ  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing the data part of a ROOT
    TDirectory.

    TDirectory (and TFileDirectory) objects have two parts: a fixed size header that
    does not move, providing a stable reference point, and a list of TKeys that would
    need to be rewritten if it grows beyond its initial allocation. This "data" part
    is the list of TKeys.

    See `ROOT TDirectory specification <https://github.com/root-project/root/blob/master/io/doc/TFile/tdirectory.md>`__.
    c                   sx   t ƒ  ||¡ g | _d | _tdd„ |D ƒƒ| _i | _|D ]4}|jj| jvrXg | j|jj< | j|jj  	|¡ q8|| _
d S )Nc                 s  s   | ]}|j V  qd S r   )r
   rÀ   r   r   r   r¤   Y  rŒ   z)DirectoryData.__init__.<locals>.<genexpr>)r0   r   Ú_dirty_keysÚ_dirty_keys_startrÊ   Ú_keys_num_bytesÚ_keys_by_namer_   r4   r�   Ú_keys)r   r	   r
   Úkeysr™   r6   r   r   r   T  s    zDirectoryData.__init__c                 C  s(   t | ƒj› d| j› d| j› d| j› d�S r8   )r<   r!   r   r   rþ   r   r   r   r   r=   a  s    &ÿzDirectoryData.__repr__c                 C  s   | j d u r| j| _ | j S r   r   r   r   r   r   r
   f  s    
zDirectoryData.allocationc                 C  s   | j |krd| _|| _ d S r   r„   r   r   r   r   r
   l  s    
c                 C  s,   d}| j  |g ¡D ]}t||jd ƒ}q|S )NrA   )rý   Úgetrõ   ra   )r   r_   ra   r™   r   r   r   Ú
next_cycler  s    zDirectoryData.next_cycleFc                 C  sl   |r| j  |¡ nd| _|  j|j7  _| j |jj¡}|d u rRg  }| j|jj< | |¡ | j	 |¡ d S r   )
rú   r�   r   rü   r
   rý   r   r_   r4   rþ   )r   r™   Úincrementalrÿ   r   r   r   Úadd_keyx  s    
zDirectoryData.add_keyc                 C  s®   d| _ tt| jƒƒD ]�}| j| }|jj|jjkr|j|jkr|  j|j|j 7  _| j	|jj }tt|ƒƒD ]}|| j|jkrn||= qn| 
|¡ || j|<  d S qt‚d S r   )r   r’   r   rþ   r_   r4   ra   rü   r
   rý   r�   r   ©r   r™   r£   Úoldrÿ   r¢   r   r   r   Úreplace_key…  s    


zDirectoryData.replace_keyc                 C  sœ   d| _ tt| jƒƒD ]~}| j| }|jj|jjkr|j|jkr|  j|j8  _| j	|jj }tt|ƒƒD ]}|| j|jkrh||= qh| j|=  d S qt
‚d S r   )r   r’   r   rþ   r_   r4   ra   rü   r
   rý   r   r  r   r   r   Ú
remove_key•  s    
zDirectoryData.remove_keyc                 C  s
   t | jƒS r   )r   rþ   r   r   r   r   Únum_keys¤  s    zDirectoryData.num_keysc                 C  s
   || j v S r   )rý   )r   r_   r   r   r   Úhaskey¨  s    zDirectoryData.haskeyNc                 C  s\   | j  |g ¡}|d u r8t|ƒdkr&d S t|dd„ d�S n |D ]}|j|kr<|  S q<d S d S )Nr   c                 S  s   | j S r   ©ra   ©rÁ   r   r   r   Ú<lambda>±  rŒ   z'DirectoryData.get_key.<locals>.<lambda>©r™   )rý   r   r   rõ   ra   )r   r_   ra   rÿ   r™   r   r   r   Úget_key«  s    

zDirectoryData.get_keyc                 C  s   dd„ | j D ƒS )Nc                 S  s   g | ]}|j j‘qS r   )r_   r4   rÀ   r   r   r   rò   »  rŒ   z+DirectoryData.key_names.<locals>.<listcomp>©rþ   r   r   r   r   Ú	key_names¹  s    zDirectoryData.key_namesc                 C  s   dd„ | j D ƒS )Nc                 S  s    g | ]}|j j|j|jjf‘qS r   )r_   r4   ra   r^   rÀ   r   r   r   rò   ¿  rŒ   z-DirectoryData.key_triples.<locals>.<listcomp>r  r   r   r   r   Úkey_triples½  s    zDirectoryData.key_triplesc                 C  s   dd„ | j D ƒS )Nc                 S  s,   g | ]$}|j jd ks |j jdkr|jj‘qS )Ú
TDirectoryZTDirectoryFile)r^   r4   r_   rÀ   r   r   r   rò   Ã  s   ýz+DirectoryData.dir_names.<locals>.<listcomp>r  r   r   r   r   Ú	dir_namesÁ  s    þzDirectoryData.dir_namesc                 C  s6   | j  |g ¡}t|ƒdkrd S t|dd„ d�jjS d S )Nr   c                 S  s   | j S r   r
  r  r   r   r   r  Ï  rŒ   z,DirectoryData.classname_of.<locals>.<lambda>r  )rý   r   r   rõ   r^   r4   )r   r_   rÿ   r   r   r   Úclassname_ofÊ  s    zDirectoryData.classname_ofc                 C  s   t jjj| j S r   )r2   rm   Ú_directory_format_num_keysro   rü   r   r   r   r   r   Ñ  s    zDirectoryData.num_bytesc                 C  s   | j | j S r   )r   r   r   r   r   r   Únext_locationÕ  s    zDirectoryData.next_locationc                 C  s´   | j rN| jd u r tdt| ƒ ƒ‚|  ¡ }| jt|ƒ | _| | j|¡ d| _ n\tj	j
 t| jƒ¡}| | j|¡ | jD ]2}| | j¡}| j|_| |¡ |  j|j7  _qvg | _d S r   )r   r   r   r   r   r   rû   r   r2   rm   r  rs   rþ   rú   r?   r	   r   )r   r   r    Únumr™   Úcopiedr   r   r   r   Ù  s&    
ÿÿ

zDirectoryData.writec                 C  s:   t jj t| jƒ¡g}| jD ]}| | ¡ ¡ qd |¡S )NrŒ   )	r2   rm   r  rs   r   rþ   r�   r   rŽ   )r   rL   r™   r   r   r   r   ó  s    
zDirectoryData.serializec              	   C  st   t jj |d d… ¡\}|d }g }t|ƒD ]6}| tj||| d … ||dd�¡ ||d j7 }q,t	|t
|ƒ|ƒS )NrO   T)r|   éÿÿÿÿ)r2   rm   r  rI   r’   r�   rN   r   r   rù   r   )r   r   r	   r{   r  rK   rÿ   r‰   r   r   r   r   ù  s    üÿzDirectoryData.deserialize)F)N)r!   r"   r#   r$   r   r=   r%   r
   r&   r  r  r  r  r  r	  r  r  r  r  r  r   r  r   r   r'   r   rM   r   r   r6   r   rù   G  s<   









rù   c                      sò   e Zd ZdZdZ‡ fdd„Zdd„ Zedd„ ƒZej	d	d„ ƒZed
d„ ƒZ
e
j	dd„ ƒZ
edd„ ƒZej	dd„ ƒZedd„ ƒZej	dd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZej	dd„ ƒZedd„ ƒZedd„ ƒZdd„ Zed d!„ ƒZ‡  ZS )"ÚDirectoryHeaderaõ  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing the header part of a ROOT
    TDirectory.

    TDirectory (and TFileDirectory) objects have two parts: a fixed size header that
    does not move, providing a stable reference point, and a list of TKeys that would
    need to be rewritten if it grows beyond its initial allocation. This is the "header"
    part.

    See `ROOT TDirectory specification <https://github.com/root-project/root/blob/master/io/doc/TFile/tdirectory.md>`__.
    rC   c                   s^   t ƒ  |tjjjd t|jƒ ¡ || _|| _	|| _
|| _|| _|| _tj ¡ | _| j| _d S )Nr‹   )r0   r   r2   rm   Ú_directory_format_bigro   r   ÚbytesÚ_begin_locationÚ_begin_num_bytesÚ_data_locationÚ_data_num_bytesrV   Ú_uuidrX   rY   rZ   Ú_modified_on)r   r	   Úbegin_locationÚbegin_num_bytesÚdata_locationÚdata_num_bytesrb   rê   r6   r   r   r     s    
ÿzDirectoryHeader.__init__c                 C  sH   t | ƒj› d| j› d| j› d| j› d| j› d| j› d| j› d| j›d�S r8   )	r<   r!   r   r  r  r  r   rV   r!  r   r   r   r   r=   2  s    zDirectoryHeader.__repr__c                 C  s   | j S r   )r  r   r   r   r   r#  5  s    zDirectoryHeader.begin_locationc                 C  s   | j |krd| _|| _ d S r   )r  r   r   r   r   r   r#  9  s    
c                 C  s   | j S r   ©r  r   r   r   r   r$  ?  s    zDirectoryHeader.begin_num_bytesc                 C  s   | j |krd| _|| _ d S r   ©r  r   r   r   r   r   r$  C  s    
c                 C  s   | j S r   )r  r   r   r   r   r%  I  s    zDirectoryHeader.data_locationc                 C  s   | j |krd| _|| _ d S r   )r  r   r   r   r   r   r%  M  s    
c                 C  s   | j S r   )r   r   r   r   r   r&  S  s    zDirectoryHeader.data_num_bytesc                 C  s   | j |krd| _|| _ d S r   )r   r   r   r   r   r   r&  W  s    
c                 C  s   | j S r   ri   r   r   r   r   rb   ]  s    zDirectoryHeader.parent_locationc                 C  s   | j S r   ©r!  r   r   r   r   rê   a  s    zDirectoryHeader.uuidc                 C  s   | j S r   )r"  r   r   r   r   Úmodified_one  s    zDirectoryHeader.modified_onc                 C  s   | j |krd| _|| _ d S r   )r"  r   r   r   r   r   r*  i  s    
c                 C  s*   | j tjjkp(| jtjjkp(| jtjjkS r   )r  r2   rk   rl   r  rV   r   r   r   r   re   o  s
    ÿýzDirectoryHeader.bigc                 C  s   | j rtjjjS tjjjS d S r   )re   r2   rm   r  ro   Ú_directory_format_smallr   r   r   r   r   w  s    
zDirectoryHeader.num_bytesc              
   C  sv   | j rtjj}| jd }d}ntjj}| j}d}| |tj | j	¡tj | j
¡| j| j| j| j| j¡d | jj | S )Nrq   rŒ   s               ó    )re   r2   rm   r  rr   r+  rs   rt   ru   rZ   r"  r   r  r  rV   r  r!  r  )r   rv   rw   Úextrar   r   r   r   ~  s0    
ø
öõôÿzDirectoryHeader.serializec              
   C  s   t jj |d t jjj… ¡\}}}}}}	}
}|t jjj }|dkr„t jj |d t jjj… ¡\}}}}}}	}
}|d8 }|t jjj }|| jkr¨td|› d| j› |› �ƒ‚||| || d … dksÈJ ‚||| d || d … }t||	||||
t	j
|d�ƒ}t j |¡|_t j |¡|_|S )Nrq   z%Uproot can't read TDirectory version rx   r‹   r,  é   ©r  )r2   rm   r+  rI   ro   r  rr   ry   r  rê   ÚUUIDrt   rz   rZ   r"  )r   r   r	   r{   rw   ZfDatimeCZfDatimeMZfNbytesKeysZfNbytesNameZfSeekDirZfSeekParentZ	fSeekKeysrK   Ú
uuid_bytesrL   r   r   r   r   —  s\    ÿ÷
ÿ÷
ÿ 
ù	zDirectoryHeader.deserialize)r!   r"   r#   r$   rr   r   r=   r%   r#  r&   r$  r%  r&  rb   rê   r*  re   r   r   r'   r   rM   r   r   r6   r   r    sF   













r  c                   @  s<   e Zd ZdZdd„ Zddd„Zddd	„Zd
d„ Zdd„ ZdS )Ú	Directorya…  
    A :doc:`uproot.writing._cascade.CascadeNode` for writing a TDirectory.

    TDirectory (and TFileDirectory) objects have two parts: a fixed size header that
    does not move, providing a stable reference point, and a list of TKeys that would
    need to be rewritten if it grows beyond its initial allocation. This node manages
    both parts.

    See `ROOT TDirectory specification <https://github.com/root-project/root/blob/master/io/doc/TFile/tdirectory.md>`__.

    This class is an abstract superclass; the concrete subclasses are
    :doc:`uproot.writing._cascade.RootDirectory` and :doc:`uproot.writing._cascade.SubDirectory`.
    c                 C  s†   | j j}|| j j | jj }d | j _| j j| }| j |¡| j _| j j| j_| j j| j j | j_|| j j }|| j_| j 	||¡ d S r   )
Ú_datakeyr	   r   r—   r
   rÅ   r¨   rÃ   r%  r®   )r   Znew_data_sizerª   r©   r×   Úmight_be_slightly_morer   r   r   Ú_reallocate_dataÝ  s    zDirectory._reallocate_dataNc	                 C  s8  |d u r| j  |¡n|j}	|jdd�}
|jdd�}|jdd�}d}|t|
ƒdk rTdndt|
ƒ 7 }|t|ƒdk rtdndt|ƒ 7 }|t|ƒdk r”dndt|ƒ 7 }| jj}d }|�s|tjj	k �rtj
jj| t|ƒ }| jj|dd�}|tj
jj }|tjj	k �r| jj|d	d� nd }|d u �rXtj
jj| t|ƒ }| jj|d	d�}|tj
jj }t||ƒ}||j7 }t||ƒ}||j7 }t||ƒ}||j7 }t||t|ƒ||||	|||d
�
}|d u �r8| | j j¡}| j j|j | j jk�rtt d| j j|j d  ¡ƒ}|  |¡ | | j j¡}| j j|_| j j|dd� n°| j  |jj|j¡}|d u�sZJ ‚| |j¡}| j j|j |j | j jk�rÜtt d| j j|j d  ¡ƒ}|  |¡ | j  |jj|j¡}|d u�sÐJ ‚| |j¡}| j  |¡ t j  !¡ | j"_#| $|¡ | $||j |¡ |  $|¡ | %| jj&j'¡ | (¡  |S )NrD   rE   r   rB   rA   rC   T)r§   F)re   ç      ø?é   ©r  ))r—   r  ra   Úencoder   r–   r	   r2   rk   rl   rm   rp   ro   rÅ   r¨   rn   r/   r   rN   r?   r  r
   ÚintÚmathÚceilr5  r   r  r  r_   r4   r  rX   rY   rÃ   r*  r   Úset_file_lengthr›   r�   rÑ   )r   r   r^   r_   r`   rè   r\   Zreplacesre   ra   Zclassname_asbytesZname_asbytesZtitle_asbytesZstrings_sizerb   r	   Zrequested_bytesrK   Zwritable_classnameZwritable_nameZwritable_titler™   Únext_keyr×   Zoriginal_keyZnew_keyr   r   r   Ú
add_objectë  s–    ÿ  ÿ
ÿ





ö
ÿ

ÿÿÿ


zDirectory.add_objectTc              
   C  s¶  | j  |¡}td d d td dƒtd |ƒtd |ƒ|| jjd ƒ	}td d d d d | jj|ƒ}td d d td dƒtd |ƒtd |ƒ|| jjd ƒ	}	|j|j |	j | }
| j	 
|
¡|_|j|j |j |	_|
|j|j |	j  }td |g ƒ}t|||	|| | j	ƒ}|j|_|j|_| | j j¡}| j j|j | j jk�rX|  tt d| j j|j d  ¡ƒ¡ | | j j¡}| j j|_| j j|dd� tj ¡ | j_|�r²| |¡ |  |¡ | | j	jj¡ | ¡  |S )Nr  r6  r7  Tr8  ) r—   r  rN   r/   r–   r	   r  r   r
   rÅ   r¨   rù   ÚSubDirectoryr\   r]   r?   r  r5  r:  r;  r<  r   r  rX   rY   rÃ   r*  r   r=  r›   r�   rÑ   )r   r   r_   Úinitial_directory_bytesrê   rÑ   ra   Zsubdirectory_keyZsubdirectory_headerZsubdirectory_datakeyr×   r4  Zsubdirectory_dataÚsubdirectoryr>  r   r   r   Úadd_directoryS  s     ÷ù	÷ÿþýÿÿþÿÿþÿú	ÿ


zDirectory.add_directoryc	                 C  s6   dd l }	|	jj | |||| j||||¡	}
|
 |¡ |
S )Nr   )Zuproot.writing._cascadetreeÚwritingZ_cascadetreeZTreerÅ   Z
write_anew)r   r   r_   r`   Zbranch_typesZcounter_nameÚ
field_nameZinitial_basket_capacityZresize_factorr2   Útreer   r   r   Úadd_tree§  s    ÷
zDirectory.add_treec                 C  sÐ   dd l }|jj d dddd d d d d d d¡}|jj d |d|¡}|jj d d|j|¡}tjg d¢tj	d�}	| j
 d¡}
|jj d|
¡|jd j_|jj | |||| j
||g |¡	}| |
|	¡ | |¡ | ¡  |S )Nr   é0   Ú )rA   r   rA   r   éø   rB   rB   rB   r   r   r   r   é±   éÈ   éª   éŸ   )Zdtypeé   )Zuproot.writing._cascadentuplerD  Z_cascadentupleZNTuple_AnchorZNTuple_HeaderZNTuple_FooterZ_crc32rº   ÚarrayZuint8rÅ   r¨   ZNTuple_LocatorZcluster_group_record_framesZpage_list_envlinkÚlocatorZNTupler   rÑ   )r   r   r_   r`   Zakformr2   ÚanchorrÇ   ÚfooterZempty_page_list_bytesÚoffsetZntupler   r   r   Úadd_rntupleÂ  s,    ÿ
ÿ þÿÿ
zDirectory.add_rntuple)NN)T)	r!   r"   r#   r$   r5  r?  rC  rG  rU  r   r   r   r   r2  Î  s     ÷
h
Tr2  c                      s    e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZ‡ fdd„Z‡  ZS )ÚRootDirectoryzõ
    A :doc:`uproot.writing._cascade.Directory` for the root (first) directory in a file.

    Subdirectories are :doc:`uproot.writing._cascade.SubDirectory` objects. Two classes
    are needed because their structure is slightly different.
    c              	     sF   t ƒ  |||||||¡ || _|| _|| _|| _|| _|| _|| _d S r   )	r0   r   r–   rS   rT   rÃ   r3  r—   rÅ   )r   r™   r_   r`   rÇ   Údatakeyrš   rÉ   r6   r   r   r     s    zRootDirectory.__init__c                 C  sH   t | ƒj› d| j› d| j› d| j› d| j› d| j› d| j› d| j› d�S r8   )	r<   r!   r–   rS   rT   rÃ   r3  r—   rÅ   r   r   r   r   r=     s    zRootDirectory.__repr__c                 C  s   | j S r   rœ   r   r   r   r   r™     s    zRootDirectory.keyc                 C  s   | j S r   rg   r   r   r   r   r_     s    zRootDirectory.namec                 C  s   | j S r   rh   r   r   r   r   r`     s    zRootDirectory.titlec                 C  s   | j S r   rË   r   r   r   r   rÇ     s    zRootDirectory.headerc                 C  s   | j S r   ©r3  r   r   r   r   rW  #  s    zRootDirectory.datakeyc                 C  s   | j S r   r�   r   r   r   r   rš   '  s    zRootDirectory.datac                 C  s   | j S r   rÌ   r   r   r   r   rÉ   +  s    zRootDirectory.freesegmentsc                 C  s   | j jS r   ©r–   r	   r   r   r   r   r	   /  s    zRootDirectory.locationc                 C  s   | j j| jj | jj S r   )r–   r
   rS   rT   r   r   r   r   r$  3  s    zRootDirectory.begin_num_bytesc                   sâ   | j j| jj | jj | j_| jj| j_| jj| jj | j _| j j| j j | j_| jj| jj | j_| jj| j_| j	| j_	| j
j| j_| j
j| jj | j_| jj| j
_| j
j| j
_| j
j| j
j | j_| j	| jj_	tƒ  |¡ d S r   )rS   r
   rT   rÃ   r–   r\   r]   r	   r#  r$  r3  r%  r—   r&  rÅ   r›   r0   r   r²   r6   r   r   r   7  s    ÿ
zRootDirectory.write)r!   r"   r#   r$   r   r=   r%   r™   r_   r`   rÇ   rW  rš   rÉ   r	   r$  r   rM   r   r   r6   r   rV  þ  s,   









rV  c                      sˆ   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZedd„ ƒZ‡ fdd„Z‡  ZS )r@  zú
    A :doc:`uproot.writing._cascade.Directory` for any subdirectories in a file.

    The root (first) directory is a :doc:`uproot.writing._cascade.RootDirectory` object.
    Two classes are needed because their structure is slightly different.
    c                   s>   t ƒ  ||||||¡ || _|| _|| _|| _|| _|| _d S r   )r0   r   r–   rÃ   r3  r—   Ú_parentrÅ   )r   r™   rÇ   rW  rš   ÚparentrÉ   r6   r   r   r   R  s    zSubDirectory.__init__c                 C  s@   t | ƒj› d| j› d| j› d| j› d| j› d| j› d| j› d�S r8   )r<   r!   r–   rÃ   r3  r—   rZ  rÅ   r   r   r   r   r=   [  s    zSubDirectory.__repr__c                 C  s   | j S r   rœ   r   r   r   r   r™   ^  s    zSubDirectory.keyc                 C  s   | j S r   rË   r   r   r   r   rÇ   b  s    zSubDirectory.headerc                 C  s   | j S r   rX  r   r   r   r   rW  f  s    zSubDirectory.datakeyc                 C  s   | j S r   r�   r   r   r   r   rš   j  s    zSubDirectory.datac                 C  s   | j S r   )rZ  r   r   r   r   r[  n  s    zSubDirectory.parentc                 C  s   | j S r   rÌ   r   r   r   r   rÉ   r  s    zSubDirectory.freesegmentsc                 C  s   | j jS r   rY  r   r   r   r   r	   v  s    zSubDirectory.locationc                   s    | j j| j_| jj| j_| jj| jj | j _| jj| j _| jj| j _| j	j| j _
| j	j| jj | j _| jj| j	_| j	j| j	_| j	j| j	j | j_tƒ  |¡ d S r   )rÃ   r
   r–   r\   r]   r	   r#  r   r$  r3  r%  r—   r&  r0   r   r²   r6   r   r   r   z  s    zSubDirectory.write)r!   r"   r#   r$   r   r=   r%   r™   rÇ   rW  rš   r[  rÉ   r	   r   rM   r   r   r6   r   r@  J  s$   	






r@  c                      s^  e Zd ZdZdZdZ‡ fdd„Zdd„ Zedd	„ ƒZ	e	j
d
d	„ ƒZ	edd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZedd„ ƒZej
dd„ ƒZed d!„ ƒZej
d"d!„ ƒZed#d$„ ƒZed%d&„ ƒZed'd(„ ƒZed)d*„ ƒZd+d,„ Zed-d.„ ƒZ‡  ZS )/Ú
FileHeadera  
    A :doc:`uproot.writing._cascade.CascadeLeaf` for writing the header of a ROOT file.

    The header is in the first 100 bytes of the ROOT file, starting with the magic
    ``b'root'`` sequence. It contains a pointer to the root (first) directory (:doc:`uproot.writing._cascade.RootDirectory`),
    the FreeSegments (:doc:`uproot.writing._cascade.FreeSegments`) record, the list of
    TStreamerInfos (:doc:`uproot.writing._cascade.TListOfStreamers`), preferred compression
    codec, UUID, and the version of ROOT used to make the file.

    Uproot declares its ROOT version to be 6.24/00 and versions of all self-generated
    classes are consistent with that version.

    See `ROOT header specification <https://github.com/root-project/root/blob/master/io/doc/TFile/header.md>`__.
    ó   rootiÀó  c
           
        sT   t ƒ  dd¡ || _|| _|| _|| _|| _|| _|| _|| _	|	| _
d | _d| _d S )Nr   éd   )r0   r   r   Ú_free_locationÚ_free_num_bytesÚ_free_num_slicesr  Ú_compressionÚ_info_locationÚ_info_num_bytesr!  Ú_versionÚ_begin)
r   r�   r¯   r°   r±   r$  rà   rÙ   rÚ   rê   r6   r   r   r   ›  s    zFileHeader.__init__c                 C  sX   t | ƒj› d| j› d| j› d| j› d| j› d| j› d| j›d| j› d| j	› d| j
›d�S r8   )r<   r!   r   r_  r`  ra  r  rb  rc  rd  r!  r   r   r   r   r=   ´  s    zFileHeader.__repr__c                 C  s   | j S r   r‚   r   r   r   r   r�   ·  s    zFileHeader.endc                 C  s   | j |krd| _|| _ d S r   rƒ   r   r   r   r   r�   »  s    
c                 C  s   | j S r   )r_  r   r   r   r   r¯   Á  s    zFileHeader.free_locationc                 C  s   | j |krd| _|| _ d S r   )r_  r   r   r   r   r   r¯   Å  s    
c                 C  s   | j S r   )r`  r   r   r   r   r°   Ë  s    zFileHeader.free_num_bytesc                 C  s   | j |krd| _|| _ d S r   )r`  r   r   r   r   r   r°   Ï  s    
c                 C  s   | j S r   )ra  r   r   r   r   r±   Õ  s    zFileHeader.free_num_slicesc                 C  s   | j |krd| _|| _ d S r   )ra  r   r   r   r   r   r±   Ù  s    
c                 C  s   | j S r   r'  r   r   r   r   r$  ß  s    zFileHeader.begin_num_bytesc                 C  s   | j |krd| _|| _ d S r   r(  r   r   r   r   r$  ã  s    
c                 C  s   | j S r   )rb  r   r   r   r   rà   é  s    zFileHeader.compressionc                 C  s   | j |krd| _|| _ d S r   )rb  r   r   r   r   r   rà   í  s    
c                 C  s   | j S r   )rc  r   r   r   r   rÙ   ó  s    zFileHeader.info_locationc                 C  s   | j |krd| _|| _ d S r   )rc  r   r   r   r   r   rÙ   ÷  s    
c                 C  s   | j S r   )rd  r   r   r   r   rÚ   ý  s    zFileHeader.info_num_bytesc                 C  s   | j |krd| _|| _ d S r   )rd  r   r   r   r   r   rÚ     s    
c                 C  s   | j S r   r)  r   r   r   r   rê     s    zFileHeader.uuidc                 C  s   | j |krd| _|| _ d S r   )r!  r   r   r   r   r   rê     s    
c                 C  s   | j d u r| jS | j S d S r   )re  rr   r   r   r   r   rw     s    
zFileHeader.versionc                 C  s   | j S r   )rf  r   r   r   r   Úbegin  s    zFileHeader.beginc                 C  s4   | j d u p2| j tjjkp2| jtjjkp2| jtjjkS r   )r   r2   rk   rl   r_  rc  r   r   r   r   re     s    
ÿþüzFileHeader.bigc                 C  s   | j rtjjjS tjjjS d S r   )re   r2   rm   Ú_file_header_fields_bigro   Ú_file_header_fields_smallr   r   r   r   r   %  s    
zFileHeader.num_bytesc                 C  s�   | j rtjj}| jd }d}ntjj}| j}d}| jd u rJtj d¡j	}n| jj	}| 
| j|| j| j| j| j| jd | j||| j| jd| jj¡S )Né@B r7  rO   r   rA   )re   r2   rm   rh  rw   ri  rb  rà   ZZLIBÚcoders   Úmagicrg  r   r_  r`  ra  r  rc  rd  r!  r  )r   rv   rw   ÚunitsZ	fCompressr   r   r   r   ,  s4    

òzFileHeader.serializec                 C  sB  t jj |d t jjj… ¡\}}}}}}}	}
}}}}}}|dkr€t jj |¡\}}}}}}}	}
}}}}}}|dksvJ ‚|d }n|dksŒJ ‚|}|t jjjks¢J ‚|dks®J ‚|dksºJ ‚|	dksÆJ ‚|
dksÒJ ‚|dksÞJ ‚|dksêJ ‚|dksöJ ‚|dk�sJ ‚t||||	d |
t jj 	|¡||t
j|d�ƒ	}||_||_|S )Nrj  r7  rO   r   rA   r/  )r2   rm   ri  rI   ro   rh  r\  rà   ZCompressionZ	from_coderê   r0  re  rf  )r   r   r	   rl  rw   rg  r�   r¯   r°   Zfree_num_slices_plus_1r$  rm  Zcompression_coderÙ   rÚ   Zuuid_versionr1  Z
outversionrL   r   r   r   r   L  s|    ÿññ

÷zFileHeader.deserialize)r!   r"   r#   r$   rl  rr   r   r=   r%   r�   r&   r¯   r°   r±   r$  rà   rÙ   rÚ   rê   rw   rg  re   r   r   r'   r   rM   r   r   r6   r   r\  ˆ  sh   





















 r\  c                   @  s\   e Zd ZdZdd„ Zdd„ Zedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZdS )ÚCascadingFilez˜
    An object that represents an entire file, the root of the cascading-node tree.

    See :doc:`uproot.writing._cascade` for a general overview.
    c                 C  s"   || _ || _|| _|| _|| _d S r   )r˜   Ú
_streamersrÅ   Ú_rootdirectoryrì   )r   r›   rÏ   rÉ   Úrootdirectoryrî   r   r   r   r   ˜  s
    zCascadingFile.__init__c              
   C  s0   t | ƒj› d| j› d| j› d| j› d| j› d�
S r8   )r<   r!   r˜   ro  rÅ   rp  r   r   r   r   r=   ¦  s    zCascadingFile.__repr__c                 C  s   | j S r   rž   r   r   r   r   r›   ©  s    zCascadingFile.fileheaderc                 C  s   | j S r   )ro  r   r   r   r   rÏ   ­  s    zCascadingFile.streamersc                 C  s   | j S r   rÌ   r   r   r   r   rÉ   ±  s    zCascadingFile.freesegmentsc                 C  s   | j S r   )rp  r   r   r   r   rq  µ  s    zCascadingFile.rootdirectoryc                 C  s   | j S r   ró   r   r   r   r   rî   ¹  s    z CascadingFile.tlist_of_streamersN)r!   r"   r#   r$   r   r=   r%   r›   rÏ   rÉ   rq  rî   r   r   r   r   rn  ‘  s   



rn  c              
   C  s$  | j }|du rdntj |¡d }t|ƒdkr6tdƒ‚tddddd|dd|ƒ ƒ	}tdddtddƒtd|ƒtddƒd|j	dƒ	}t
dd	dƒ}t|||ƒ}	tdddtdd
ƒtddƒtddƒd|j	dƒ	}
tdddƒ}t||
|g |	ƒ}tdddtddƒtd|ƒtddƒdddƒ	}td|ƒ}tddƒ}td|j	dddd|ƒ ƒ}tdddtddƒtd|ƒtddƒd|j	dƒ	}td|g ƒ}t|||||||	ƒ}|j	|_|j|j |j |j |j |
_|
j|
j |j |_|j|j |_|j|j |_|j|j |j |_|
j|_|
j|j |_| | ¡ | | ¡ t|||	|dƒS )zj
    Function to create an empty ROOT file, returning a :doc:`uproot.writing._cascade.CascadingFile`.
    Nzdynamic.rootr  é   z+ROOT file names must be less than 256 bytesZTFilerI  rA   r   rä   ZStreamerInfozDoubly linked listr   )ré   ÚosÚpathÚsplitr   ry   r\  rN   r/   rg  r}   r•   r´   r¾   r  rù   rV  r	   r
   r�   rÙ   rÚ   r   rn  )r   rà   rA  Zinitial_streamers_bytesÚuuid_functionÚfilenamer›   Úfreesegments_keyÚfreesegments_datarÉ   Ústreamers_keyZstreamers_headerrÏ   Údirectory_keyÚdirectory_nameÚdirectory_titleÚdirectory_headerÚdirectory_datakeyÚdirectory_datarq  r   r   r   Úcreate_empty¾  sÔ    
÷÷÷
ÿ÷

ÿ÷ù
ÿþýüÿÿÿþÿ

r�  c                 C  s\  | j dtjjjtjjjd�}|dd… dkrHtd|dd… ›| j› �ƒ‚t 	|d¡}|   |j
|j¡}t 	||j
| j¡}t 	||jd… |j
|j |j|j |j| j¡}t|||ƒ}|   |j|j¡}t 	||j| j¡}t 	||jd… |j|j ||| j|j¡\}	}
|   |j|jtjjj d ¡}t 	||j| j¡}|j|j }t 	|||j d… |¡\}}t 	|||j d… |¡\}}|j||j k�s�J ‚t 	|||j d… || j¡}|j|jk�sÀJ ‚|j|jk�sÒJ ‚|jdk�sâJ ‚|   |j|j¡}t 	||j| j¡}t 	||jd… |j|j | j¡}t |||||||ƒ}|	 !| ¡ |  "¡  t#||	|||
ƒS )z²
    Function to derive a :doc:`uproot.writing._cascade.CascadingFile` from an existing
    file.

    This function *does* write to the file, overwriting the TStreamerInfo.
    r   )ZinsistNrO   r]  z&not a ROOT file: first four bytes are r.  )$rå   r2   rm   rh  ro   ri  ry   r{   r\  r   r¯   r°   rN   r}   r   r±   r•   rÙ   rÚ   r¾   ré   rê   rg  r$  r  r/   r  r#  rb   r%  r&  rù   rV  r   rÑ   rn  )r   rA  rv  r   r›   rx  ry  rÉ   rz  rÏ   rî   r{  rK   r|  r}  r~  r  r€  rq  r   r   r   Úupdate_existing8	  s˜    ýÿ
ÿ

û
ú	þÿÿÿÿ
ÿ
ýù


ÿr‚  ),r$   Ú
__future__r   rX   r;  Úos.pathrs  Ústructrê   rº   Zuproot.compressionr2   Zuproot.constZuproot.models.TListZuproot.readingZuproot.serializationZuproot.source.chunkZuproot.source.cursorZuproot.streamersr   r(   ÚStructrH   r/   rN   r‡   r†   r}   r•   rµ   r´   r»   r½   r¾   rÜ   rù   r  r2  rV  r@  r\  rn  r�  r‚  r   r   r   r   Ú<module>   sd   C
)  

  6
5! /- G B  2L>  -z