o i@sdZddlmZmZmZddlmZddlmZddl m Z ddl m Z m Z mZddlmZddlZdd lmZdd lmZmZmZdd lmZmZmZdd lmZmZmZdd lm Z m!Z!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEddlFmGZGejHrddlIZIhdZJhdZKddeLdddDZMdedeNedeOdefd d!ZP dwdeeBd"edeOdeNedBdeeBf d#d$ZQ dwd"edeOdeNedBdefd%d&ZRd'e"ded(eSddfd)d*ZTd'e"deddfd+d,ZUd'e"deddfd-d.ZVd'e"deddfd/d0ZWd1e deOfd2d3ZXd1eSeeSBdeSfd4d5ZY dwd'e"ded6eNeSdBddfd7d8ZZdxd'e"ded:eSddfd;d<Z[ dwd'e"ded6eNeSdBddfd=d>Z\d'e"deddfd?d@Z]d1e?dBdeSfdAdBZ^d'e"deddfdCdDZ_d1e@dBdeSfdEdFZ`d'e"deddfdGdHZad1eAdBdeSfdIdJZbd'e"deddfdKdLZc dwd'e"deeBd6eSeNeSBdBddfdMdNZdeeeOdBeOdBfZfefd'e"dOedPeSeNeSBdegfdQdRZhd'e"ded6eNeSddfdSdTZid'e"dOed6eNeSddfdUdVZjd'e"deddfdWdXZkd'e"deddfdYdZZl [dyd'e"d\ed]eOddfd^d_Zmd"ed`e8dBdaeOdBdbeOdBdceOdeeeOeOff dddeZn dwdddfdfd[dgdheOdBdie&e Be#BdOedaeOdBdbeOdBdjeOdceOdkeOdle ddfdmdnZoieCjpe[dfeCjqe[dfeCjreldfeCjse[dfeCj?e_dfeCjte]dfeCj@eadfeCjueTdofeCjveTdpfeCj=e]dfeCjwe\dfeCjxe\dfeCjyeUdfeCjzeVdfeCj{eVdfeCj|eVdfeCj}eVdfieCj~eVdfeCjeZdfeCje\dfeCjeTdqfeCjeidfeCjeTdrfeCje\dfeCjeTdsfeCjAecdfeCje\dfeCjeWdfeCjeTdtfeCjekdfeCje[dfeCjeTdufeCje\dfeCjeTdvfeCjeVdfeCjeVdfeCjeVdfeCjeUdfiZdS)zz(Functions related to writing DICOM data.)SequenceMutableSequenceIterable)deepcopy)BufferedIOBase)pack)BinaryIOAnycast)CallableN)config)default_encodingconvert_encodings encode_string)convert_raw_data_element DataElementRawDataElement)Datasetvalidate_file_metaFileMetaDataset) DicomFile DicomBytesIODicomIOWriteableBuffer)path_from_pathlikePathTypebuffer_remaining read_bufferreset_buffer_position) warn_and_log) MultiValue)TagBaseTagItemTagItemDelimiterTagSequenceDelimiterTagtag_in_exception_LUT_DESCRIPTOR_TAGS)DeflatedExplicitVRLittleEndianUIDImplicitVRLittleEndianExplicitVRBigEndian) PersonNameISDSclassDADTTMEXPLICIT_VR_LENGTH_32VR AMBIGUOUS_VRCUSTOMIZABLE_CHARSET_VR)convert_numbers>((0(((0`((0`(( (((@@ (!(R"> TTTTcCsh|]}|d>dBqS)i0.0xrPrPH/mnt/sdb/aimis/docanh/lib/python3.10/site-packages/pydicom/filewriter.py irUi`i`elem ancestorsis_little_endianreturncCs&|d}|jdkr.|jrtj|_|S|jdrtj|_|Stt|jdkr(tjntj|_|S|jt vrt dd|Dd}|durKt dd|Dd}|dur`d}d |vrYd |vs^|j dkr`d}|dkrgtj ntj |_|dkrqd nd }|jdkrz|S|jdkr|jn ttt|jd}t|tsttt|j|||_|S|jtvr|jdrtj|_|Stt|jdkrtjntj|_|S|jd krttt|jddkrtj |_|jdkr|S|jdkr|jn ttt|jd}t|tsttt|j|d |_|Stj|_|S|jtvrtj|_|S)zoImplementation for `correct_ambiguous_vr_element`. See `correct_ambiguous_vr_element` for description. rcss,|]}t|dddurtt|jVqdS)PixelRepresentationN)getattrr intr^rQrPrPrT s z0_correct_ambiguous_vr_element..Ncss |] }t|dr|jVqdS) _pixel_repN)hasattrrbrQrPrPrTrasr^ PixelDataHhi0()tagis_undefined_lengthr3OBoriginal_encodingOWr r` BitsAllocated_AMBIGUOUS_US_SS_TAGSnextr^USSSVMvaluerr isinstancer6bytes_AMBIGUOUS_OB_OW_TAGSWaveformBitsAllocated LUTDescriptor_OVERLAY_DATA_TAGS)rXrYrZds pixel_rep byte_type elem_valuerPrPrT_correct_ambiguous_vr_elementlsz e aX     $ (   "   r~rzc Cs|dur|gn|}|jtvrAt|tr t||d}||j|z t|||W|Sty@}z td|jd|d}~ww|S)aAttempt to correct the ambiguous VR element `elem`. When it's not possible to correct the VR, the element will be returned unchanged. Currently the only ambiguous VR elements not corrected for are all retired or part of DICONDE. If the VR is corrected and is 'US' or 'SS' then the value will be updated using the :func:`~pydicom.values.convert_numbers` function. .. versionchanged:: 3.0 The `ancestors` keyword argument was added. Parameters ---------- elem : dataelem.DataElement or dataelem.RawDataElement The element with an ambiguous VR. ds : dataset.Dataset The dataset containing `elem`. is_little_endian : bool The byte ordering of the values in the dataset. ancestors : list[pydicom.dataset.Dataset] | None A list of the ancestor datasets to look through when trying to find the relevant element value to use in VR correction. Should be ordered from closest to furthest. If ``None`` then will build itself automatically starting at `ds` (default). Returns ------- dataelem.DataElement or dataelem.RawDataElement The corrected element N)rzz'Failed to resolve ambiguous VR for tag z: ) r3r4rtrr __setitem__rhr~AttributeError)rXrzrZrYerPrPrTcorrect_ambiguous_vr_elements&   rcCs|dur|gn|}|D]1}|jtjkr2||j}ttd|jD]}|d|t|||q"q |jt vr>t ||||q |d=|S)aIterate through `ds` correcting ambiguous VR elements (if possible). When it's not possible to correct the VR, the element will be returned unchanged. Currently the only ambiguous VR elements not corrected for are all retired or part of DICONDE. If the VR is corrected and is 'US' or 'SS' then the value will be updated using the :func:`~pydicom.values.convert_numbers` function. .. versionchanged:: 3.0 The `ancestors` keyword argument was added. Parameters ---------- ds : pydicom.dataset.Dataset The dataset containing ambiguous VR elements. is_little_endian : bool The byte ordering of the values in the dataset. ancestors : list[pydicom.dataset.Dataset] | None A list of the ancestor datasets to look through when trying to find the relevant element value to use in VR correction. Should be ordered from closest to furthest. If ``None`` then will build itself automatically starting at `ds` (default). Returns ------- ds : dataset.Dataset The corrected dataset Raises ------ AttributeError If a tag is missing in `ds` that is required to resolve the ambiguity. Nrr) elementsr3SQrhr rrsinsertcorrect_ambiguous_vrr4r)rzrZrYrXitemrPrPrTrs*     rfp struct_formatc Cs|j}|dus |dkr dSd|j}||}zMz|jWnty/|t||YWdSw|dkrN|jtvrN|rN|t|d|d|dd}|t|t||g|RWdSt yx}z t |d|d}~ww) aaWrite a "value" of type struct_format from the dicom file. "Value" can be more than one number. Parameters ---------- fp : file-like The file-like to write the encoded data to. elem : dataelem.DataElement The element to encode. struct_format : str The character format as used by the struct module. Nz>zwrite_PN..rWr ) r rrr r,rsrrrr)rrXrrencrPrrTwrite_PNs r paddingcCs^tttttB|j}|dur-t|ddkr||7}t|tr&|t}| |dSdS)z+Write a single or multivalued ASCII string.NrWr) rr rrrsrrtrr r)rrXrrrPrPrTrs  rcsptg|j}|durlt|rHtttttB|}t|dtr6ttt|}dfdd|D}n#ttt|}ddd|D}ntttB|}t|trYt |}t |ddkre|d}| |dSdS) z*Write a single or multivalued text string.Nrrcsg|]}t|qSrP)rrRrrrPrTrrzwrite_text..cSsg|]}|qSrPrPrrPrPrTrsrWr) r rsrr rrurrtrrrr)rrXrrrPrrT write_texts"   rcCs|j}t|rtttttB|}ddd|D}ntttB|}t|dr-|j}nt |}t |ddkr=|d}t |t }| |dS) zAHandle IS or DS VR - write a number stored as a string of digits.rcss(|]}t|dr |jnt|VqdS)original_stringN)rcrrrQrPrPrTras z&write_number_string..rrWrrN)rsrr rr-r.rrcrrrrur rrrXrrPrPrTwrite_number_strings    rcCs&|durdSt|dr|jS|dS)Nrrz%Y%m%d)rcrstrftimerrPrPrT _format_DA s   rcC|j}t|trt||dSt|r%ttt|}ddd|D}nt tt|}t |ddkr8|d}t|trB| t }| |dS)Nrcs&|]}t|tr |nt|VqdSN)rtrrrQrPrPrTra$zwrite_DA..rWrr)rsrtrrrr rr/rrrrr rrrPrPrTwrite_DA   rcC:|durdSt|dr|jS|jdkr|dS|dS)Nrrrz%Y%m%d%H%M%S.%f%zz%Y%m%d%H%M%S%zrcr microsecondrrrPrPrT _format_DT)    rcCr)Nrcsrr)rtrrrQrPrPrTra=rzwrite_DT..rWrr)rsrtrrrr rr0rrrrr rrrPrPrTwrite_DT6rrcCr)Nrrrz %H%M%S.%fz%H%M%SrrrPrPrT _format_TMJrrcCr)Nrcsrr)rtrrrQrPrPrTra^rzwrite_TM..rWrr)rsrtrrrr rr1rrrrr rrrPrPrTwrite_TMWrrc Cs||jt}|j|_|j|_|j}|js-|r-t|dkr-d|d|jd}t||jrDt t |}| t t |j |jdk}nMt t|}|tvrUtd|d|pYtg}t|}tt t|\}}|j}|js|tvsv|tjkr~||||dn|d ur||||n|js||||r|jd kr|jrt t|j } t|  | d } Wd n1swYn t t |j d d } |jrd nd } | | std|js|ntt t|j } |js|tvr|s| dkrt d|jd|dtj!}|jst t"|}| t |t|tvr|#d|js1|tvr1|s1|#| n |$|r8dn| |jrE|||n| |%|r[|t&|$dd Sd S)zRWrite the data_element to file fp according to dicom media storage rules. rWzCannot write ambiguous VR of 'z' for data element with tag zJ. Set the correct VR before writing, or use an implicit VR transfer syntaxz2write_data_element: unknown Value Representation ''rNr\sszThe (7FE0,0010) 'Pixel Data' element value hasn't been encapsulated as required for a compressed transfer syntax - see pydicom.encaps.encapsulate() for more informationizThe value for the data element zy exceeds the size of 64 kByte and cannot be written in an explicit transfer syntax. The data element VR is changed from 'z#' to 'UN' to allow saving the data.r)' write_tagrhrrZis_implicit_VRr3r ValueErroris_rawr rrrurslengthrwritersNotImplementedErrorr rriis_emptyr5rrrrread startswithtellrr2rUNrwrite_USwrite_ULgetvaluer%) rrXrrvrmsgrifnparamrspixel_data_bytesrh value_lengthrPrPrTwrite_data_elementks                      rdatasetparent_encodingc CsNt|ddt|ddf}d}tjs|j|jf}|j}d|vr*d|vr*d|vr*tdd|vr;d|vr5|}nd|vr;|}ttt t f|\|_|_|j }||ksU|j |j kr^t ||j}|j}tdtBttB|d|}|}t|D])} | jdkr| jdkrqwt| t||| |Wdn1swYqw||S) aEncode `dataset` and write the encoded data to `fp`. *Encoding* The `dataset` is encoded as specified by (in order of priority): * ``fp.is_implicit_VR`` and ``fp.is_little_endian``. * ``dataset.is_implicit_VR`` and ``dataset.is_little_endian`` * If `dataset` has been decoded from a file or buffer then :attr:`~pydicom.dataset.Dataset.original_encoding`. Parameters ---------- fp : pydicom.filebase.DicomIO The file-like to write the encoded dataset to. dataset : pydicom.dataset.Dataset The dataset to be encoded. parent_encoding : str | List[str], optional The character set to use for encoding strings, defaults to ``"iso8859"``. Returns ------- int The number of bytes written to `fp`. _implicit_vrN_little_endianNNzF'fp.is_implicit_VR' and 'fp.is_little_endian' attributes are required SpecificCharacterSetr)r_r _use_futurerrZrkrr rboolget_itemoriginal_character_set_character_setr __getitem__rrgetrsortedkeyselementgroupr&r) rrr fp_encoding ds_encoding or_encodingrdataset_encodingfpStartrhrPrPrT write_datasetsD      rcCs&ttt|jD]}t|||qdS)aXWrite a sequence contained in `data_element` to the file-like `fp`. Parameters ---------- fp : file-like The file-like to write the encoded data to. data_element : dataelem.DataElement The sequence element to write to `fp`. encodings : list of str The character encodings to use on text values. N)r rrrswrite_sequence_item)rrXrrzrPrPrTwrite_sequence?srcCs|t|}|dt|||dt|ddr'|t|ddS|}|||||d||dS)aWrite a `dataset` in a sequence to the file-like `fp`. This is similar to writing a data_element, but with a specific tag for Sequence Item. See DICOM Standard, Part 5, :dcm:`Section 7.5`. Parameters ---------- fp : file-like The file-like to write the encoded data to. dataset : Dataset The :class:`Dataset` to write to `fp`. encodings : list of str The character encodings to use on text values. r)r!is_undefined_length_sequence_itemFrrN)rr#rrrr_r$seek)rrrlength_locationlocationrPrPrTrQs     rcCs|tt|jdS)z?Write a byte string for an DataElement of value 'UN' (unknown).N)rr rursrrPrPrTwrite_UNqsrcCszz tttt|jWnty#ttt|j}||YdSwddttt|jD}|D]}||q3dS)z#Write a data_element tag to a file.cSsg|]}t|qSrP)r!)rRrhrPrPrTrsz!write_ATvalue..N) iterr rr rs TypeErrorr!r`r)rrXrhtagsrPrPrT write_ATvaluevs  r T file_metaenforce_standardcCsxt|||rd|vrd|_t}d|_d|_t||d|vr3|d|_|dt||d| | dS)aJ Write the File Meta Information elements in `file_meta` to `fp`. If `enforce_standard` is ``True`` then the file-like `fp` should be positioned past the 128 byte preamble + 4 byte prefix (which should already have been written). **DICOM File Meta Information Group Elements** From the DICOM standard, Part 10, :dcm:`Section 7.1`, any DICOM file shall contain a 128-byte preamble, a 4-byte DICOM prefix 'DICM' and (at a minimum) the following Type 1 DICOM Elements (from :dcm:`Table 7.1-1`): * (0002,0000) *File Meta Information Group Length*, UL, 4 * (0002,0001) *File Meta Information Version*, OB, 2 * (0002,0002) *Media Storage SOP Class UID*, UI, N * (0002,0003) *Media Storage SOP Instance UID*, UI, N * (0002,0010) *Transfer Syntax UID*, UI, N * (0002,0012) *Implementation Class UID*, UI, N If `enforce_standard` is ``True`` then (0002,0000) will be added/updated, (0002,0001) and (0002,0012) will be added if not already present and the other required elements will be checked to see if they exist. If `enforce_standard` is ``False`` then `file_meta` will be written as is after minimal validation checking. The following Type 3/1C Elements may also be present: * (0002,0013) *Implementation Version Name*, SH, N * (0002,0016) *Source Application Entity Title*, AE, N * (0002,0017) *Sending Application Entity Title*, AE, N * (0002,0018) *Receiving Application Entity Title*, AE, N * (0002,0102) *Private Information*, OB, N * (0002,0100) *Private Information Creator UID*, UI, N If `enforce_standard` is ``True`` then (0002,0013) will be added/updated. *Encoding* The encoding of the *File Meta Information* shall be *Explicit VR Little Endian*. Parameters ---------- fp : file-like The file-like to write the File Meta Information to. file_meta : pydicom.dataset.Dataset The File Meta Information elements. enforce_standard : bool If ``False``, then only the *File Meta Information* elements already in `file_meta` will be written to `fp`. If ``True`` (default) then a DICOM Standards conformant File Meta will be written to `fp`. Raises ------ ValueError If `enforce_standard` is ``True`` and any of the required *File Meta Information* elements are missing from `file_meta`, with the exception of (0002,0000), (0002,0001) and (0002,0012). ValueError If any non-Group 2 Elements are present in `file_meta`. FileMetaInformationGroupLengthrTF iN) rr rrZrrrrrrr)rr r rrPrPrTwrite_file_meta_infos B   rtsyntax implicit_vr little_endianforce_encodingcCsP||f}|rd|vrtdttttf|S|dur#|dur#|df}d}tjs.|j|jf}d}d|vr7|}nd|vr>|}nd|jvrF|j}|dur[d|vrWttttf|Std|j rr|j srd|vritdttttf|S|j s~td|j d|dur||jkrtd |j d |dur||jkrtd |j d |j|jfS) aReturn the encoding to use for `ds`. If `force_encoding` isn't ``True`` the priority is: 1. The encoding corresponding to `tsyntax` 2. The encoding set by `implicit_vr` and `little_endian` 3. `Dataset.is_implicit_VR` and `Dataset.is_little_endian` 4. `Dataset.original_encoding` If none of those are valid, raise an exception. If `force_encoding` is ``True`` then `implicit_vr` and `little_endian` are required. Parameters ---------- ds : pydicom.dataset.Dataset The dataset that is to be encoded. tsyntax : pydicom.uid.UID | None The dataset's public or private transfer syntax (if any). Private transfer syntaxes require `implicit_vr` and `little_endian` be used. implicit_vr : bool | None The VR encoding method (if supplied) little_endian : bool | None The encoding endianness (if supplied). force_encoding : bool If ``True`` then force the encoding to use `implicit_vr` and `little_endian`. Default ``False``. Returns ------- tuple[bool, bool] The encoding to use as ``[use implicit VR, use little endian]``. Raises ------ ValueError If unable to determine the encoding to use, if `transfer_syntax` is not a transfer syntax, or if there's an inconsistency between `transfer_syntax` and `implicit_vr` or `little_endian`. NzJ'implicit_vr' and 'little_endian' are required if 'force_encoding' is usedTrzUnable to determine the encoding to use for writing the dataset, please set the file meta's Transfer Syntax UID or use the 'implicit_vr' and 'little_endian' argumentszaThe 'implicit_vr' and 'little_endian' arguments are required when using a private transfer syntaxzThe Transfer Syntax UID 'z ' is not a valid transfer syntaxzQThe 'implicit_vr' value is not consistent with the required VR encoding for the 'z' transfer syntaxzRThe 'little_endian' value is not consistent with the required endianness for the ') rr rrr rrrZrk is_privateis_transfer_syntaxname)rzrrrr arg_encodingrfallback_encodingrPrPrT_determine_encodings`0     rF)rrenforce_file_formatr overwrite__write_like_originalfilenamerrkwargsc Ks|dd} d|| fvrtjrtdtd| dur|} | dur0tjr(tdtdt| }dd|D} | rEtdd | |jj } d d|j D} | rcd | vr[t d t d | d|rk|rkt dt } t |drxt|j} | dd}t|||||}|s|dkrt dt|dd}|rt|dkrt d| d|r|dur|dkrt| _n|dkrt| _| dd}| dd}|dd}|dus|r||kr|| _| dd}|dd}|dus|r||kr|| _t| dd|sd }|r|js|jrd!|vr|j|d!_d}t|}t|tr.|s$d"nd#}t ||}d$}n(t|t!r7|}nzt!|}Wnt"yU}z td%t#|j |d}~ww|\|_$|_%zd|rj|&||&d&| rtt'|| |d|t(krt)}|\|_$|_%t*||t+j,t+j- d'}t.|/|0}||17}|&|t|d(r|&d)nt*||W|s|2dSdS|s|2ww)*aWrite `dataset` to `filename`, which can be a path, a file-like or a writeable buffer. .. versionchanged:: 3.0 Added the `enforce_file_format` and `overwrite` keyword arguments. .. deprecated:: 3.0 `write_like_original` is deprecated and will be removed in v4.0, use `enforce_file_format` instead. If `enforce_file_format` is ``True`` then an attempt will be made to write `dataset` using the :dcm:`DICOM File Format `, or raise an exception if unable to do so. If `enforce_file_format` is ``False`` (default) then `dataset` will be written as-is (after minimal validation checking) and may or may not contain all or parts of the *File Meta Information* and hence may or may not be conformant with the DICOM File Format. **DICOM File Format** The *DICOM File Format* consists of a 128-byte preamble, a 4 byte ``b'DICM'`` prefix, the *File Meta Information Group* elements and finally the encoded `dataset`. **Preamble and Prefix** The ``dataset.preamble`` attribute shall be 128-bytes long or ``None``. The actual preamble written depends on `enforce_file_format` and ``dataset.preamble`` (see the table below). +------------------+------------------------------+ | | enforce_file_format | +------------------+-------------+----------------+ | dataset.preamble | False | True | +==================+=============+================+ | None | no preamble | 128 0x00 bytes | +------------------+-------------+----------------+ | 128 bytes | dataset.preamble | +------------------+------------------------------+ The prefix shall be the bytestring ``b'DICM'`` and will be written if and only if the preamble is present. **File Meta Information Group Elements** The preamble and prefix are followed by a set of DICOM elements from the (0002,eeee) group. Some of these elements are required (Type 1) while others are optional (Type 3/1C). If `enforce_file_format` is ``False`` then the *File Meta Information Group* elements are all optional, otherwise an attempt will be made to add the required elements using `dataset`. See :func:`~pydicom.filewriter.write_file_meta_info` for more information on which elements are required. The *File Meta Information Group* elements must be included within their own :class:`~pydicom.dataset.FileMetaDataset` in the ``dataset.file_meta`` attribute. *Encoding* The preamble and prefix are encoding independent. The *File Meta Information Group* elements are encoded as *Explicit VR Little Endian* as required by the DICOM Standard. **Dataset** A DICOM Dataset representing a SOP Instance related to a DICOM Information Object Definition (IOD). It's up to the user to ensure `dataset` conforms to the requirements of the IOD. *Encoding* .. versionchanged:: 3.0 Added the `implicit_vr` and `little_endian` arguments. The `dataset` is encoded as specified by (in order of priority): * The encoding corresponding to the set *Transfer Syntax UID* in :attr:`~pydicom.dataset.FileDataset.file_meta`. * The `implicit_vr` and `little_endian` arguments * :attr:`~pydicom.dataset.Dataset.is_implicit_VR` and :attr:`~pydicom.dataset.Dataset.is_little_endian` * :attr:`~pydicom.dataset.Dataset.original_encoding` .. warning:: This function does not automatically convert `dataset` from little to big endian encoding (or vice versa). The endianness of values for elements with a VR of **OD**, **OF**, **OL**, **OW**, **OV** and **UN** must be converted manually prior to calling :func:`~pydicom.filewriter.dcmwrite`. Parameters ---------- filename : str, PathLike, file-like or writeable buffer File path, file-like or writeable buffer to write the encoded `dataset` to. If using a writeable buffer it must have ``write()``, ``seek()`` and ``tell()`` methods. dataset : pydicom.dataset.FileDataset The dataset to be encoded. write_like_original : bool, optional If ``True`` (default) then write `dataset` as-is, otherwise ensure that `dataset` is written in the DICOM File Format or raise an exception if that isn't possible. This parameter is deprecated, please use `enforce_file_format` instead. implicit_vr : bool, optional Required if `dataset` has no valid public *Transfer Syntax UID* set in the file meta and `dataset` has been created from scratch. If ``True`` then encode `dataset` using implicit VR, otherwise use explicit VR. little_endian : bool, optional Required if `dataset` has no valid public *Transfer Syntax UID* set in the file meta and `dataset` has been created from scratch. If ``True`` (default) then use little endian byte order when encoding `dataset`, otherwise use big endian. enforce_file_format : bool, optional If ``True`` then ensure `dataset` is written in the DICOM File Format or raise an exception if that isn't possible. If ``False`` (default) then write `dataset` as-is, preserving the following - which may result in a non-conformant file: - ``dataset.preamble``: if `dataset` has no preamble then none will be written - ``dataset.file_meta``: if `dataset` is missing any required *File Meta Information Group* elements then they will not be written. force_encoding : bool, optional If ``True`` then force the encoding to follow `implicit_vr` and `little_endian`. Cannot be used with `enforce_file_format`. Default ``False``. overwrite : bool, optional If ``False`` and `filename` is a :class:`str` or PathLike, then raise a :class:`FileExistsError` if a file already exists with the given filename (default ``True``). Raises ------ ValueError * If group ``0x0000`` *Command Set* elements are present in `dataset`. * If group ``0x0002`` *File Meta Information Group* elements are present in `dataset`. * If ``dataset.preamble`` exists but is not 128 bytes long. See Also -------- pydicom.dataset.Dataset Dataset class with relevant attributes and information. pydicom.dataset.Dataset.save_as Encode a dataset and write it to file, wraps ``dcmwrite()``. write_like_originalNzr'write_like_original' is no longer accepted as a positional or keyword argument, use 'enforce_file_format' insteadzN'write_like_original' cannot be used as both a positional and keyword argumentzi'write_like_original' is deprecated and will be removed in v4.0, please use 'enforce_file_format' insteadcSsg|]}|dkr|qS)rrPrQrPrPrTr'rVzdcmwrite..z,Invalid keyword argument(s) for dcmwrite(): z, cSs g|] }|d?dvr|d?qS)rO)rrWrPrQrPrPrTr0s rzcCommand Set elements (0000,eeee) are not allowed when using dcmwrite(), use write_dataset() insteadz_File Meta Information Group elements (0002,eeee) must be in a FileMetaDataset instance in the 'z.file_meta' attributez:'force_encoding' cannot be used with 'enforce_file_format'r TransferSyntaxUID)TFz>Implicit VR and big endian is not a valid encoding combinationpreamblerz!.preamble' must be 128-bytes long)TT)FFMediaStorageSOPClassUID SOPClassUIDMediaStorageSOPInstanceUIDSOPInstanceUIDT)r srexbwbFzGdcmwrite: Expected a file path, file-like or writeable buffer, but got sDICM)wbitsrWr)3rr rrrDeprecationWarningrr __class____name___dictrrrcrr rr_rr*rr+r"r$rrr is_compressedrirrtrrrrtyperrZrrr(rrzlib compressobj MAX_WBITS bytearraycompressrflushclose)rrrrrrrrrrrcls_namebad_tagsr rencodingr  meta_classds_class meta_instance ds_instancecaller_owns_file file_moderrr compressordeflatedrPrPrTdcmwrite[s ,                              rAdflrgqLrfQr)r)T)__doc__collections.abcrrrcopyriorstructrtypingrr r r r/pydicomr pydicom.charsetr rrpydicom.dataelemrrrpydicom.datasetrrrpydicom.filebaserrrrpydicom.fileutilrrrrr pydicom.miscrpydicom.multivalr pydicom.tagr!r"r#r$r%r&r' pydicom.uidr(r)r*r+pydicom.valuerepr,r-r.r/r0r1r2r3r4r5pydicom.valuesr6rrrnrvrangeryrrr~rrrrrrrrrrrrrrrrrrrrr EncodingTyper`rrrrr rrrAAEASATCSDSFDFLLOLTrjODOFOLrlOVPNSHSLrrqSTSVUCUIULrURrpUTUVUS_SSUS_OWUS_SS_OWOB_OWrrPrPrPrTs       $ 0  }  ;  <'         |  U  `  y     `                                 ! " #