U
    ,-e_                  %   @   s*  d 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m	Z	m
Z
mZmZmZmZmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZmZ ddlmZmZmZ dd	lm Z m!Z!m"Z"m#Z# dd
l$m%Z%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z: e a;eej<j=_>eej<j?_>ej<j?Z?de?_ e8e?d dd Z@e@e?_Ae%reBdddgZCndd ZCdeC_ dd ZDdd ZEdd  ZFG d!d" d"ZGG d#d$ d$eGZHG d%d& d&eIZJG d'd( d(ZKG d)d* d*eLZMd+d, ZNG d-d. d.ZOe6ePejQj/d/d0d1ZRe%rd2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMgZSG dNdO dOZTeSD ]ZUdPdQ ZVeWeTeUeV qG dRdS dSe/eJdTZXG dUdV dVeXZYeYjZ[ D ]L\Z\Z]e^e]se_e]e`sqe\adWsebeXe\rqeWeXe\e] qdXdY ZcdZd[d\d]d^d_d`dadbdcddddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}h%Zdd~d ZeecejQj/D ]N\Z\Zfe\adWse\gdrqe\eYjZkre\edkreWeYefjheee\ qn2G ddO dOZTG ddS dSejQj/ZXG ddV dVeXZYdd Zidd Zjdd ZkdddZldeee ee
ee f df dddZmdd Zndd Zodd Zpdd Zqdd Zrdd Zsej<jtZte8etd dePeueuePdddZvG dd dZwG dd dZxG dd dZydd Zzeezd eej{d ee1d ee2d ee3d dS )zTorchScript

This module contains functionality to support the JIT's scripting frontend, notably:
    - torch.jit.script

This is not intended to be imported directly; please use the exposed
functionalities in `torch.jit`.
    N)AnyCallableDictListSetTupleUnion)classes)_qualified_name)_register_builtin)
_graph_for_script_method_graph_for)JitTypeTraceConfigJitTypeTraceStoremonkeytype_trace)_compile_and_register_classinfer_methods_to_compileScriptMethodStubwrap_cpp_module)_enabled_set_jit_function_cache_set_jit_overload_cache_try_get_jit_cached_function_try_get_jit_cached_overloads)get_default_argsget_jit_class_defget_jit_def)Module)has_torch_functionhas_torch_function_unaryhas_torch_function_variadic)PackageExporterPackageImporter)
set_module   )validate_map_locationz
Functionally equivalent to a :class:`ScriptModule`, but represents a single
function and does not have any attributes or Parameters.
z	torch.jitc                 C   s   t dd S )Nz ScriptFunction cannot be pickledpicklePickleErrorcls r+   R/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/torch/jit/_script.py_reduceD   s    r-   	Attributevaluetypec                 C   s   | S Nr+   )r/   r0   r+   r+   r,   r.   O   s    a  
    This method is a pass-through function that returns `value`, mostly
    used to indicate to the TorchScript compiler that the left-hand side
    expression is a class instance attribute with type of `type`. Note that
    `torch.jit.Attribute` should only be used in `__init__` method of `jit.ScriptModule`
    subclasses.

    Though TorchScript can infer correct type for most Python expressions, there are some cases where
    type inference can be wrong, including:

    - Empty containers like `[]` and `{}`, which TorchScript assumes to be container of `Tensor`
    - Optional types like `Optional[T]` but assigned a valid value of type `T`, TorchScript would assume
      it is type `T` rather than `Optional[T]`

    In eager mode, it is simply a pass-through function that returns `value`
    without other implications.

    Example:

    .. testcode::

        import torch
        from typing import Dict

        class AttributeModule(torch.jit.ScriptModule):
            def __init__(self):
                super().__init__()
                self.foo = torch.jit.Attribute(0.1, float)

                # we should be able to use self.foo as a float here
                assert 0.0 < self.foo

                self.names_ages = torch.jit.Attribute({}, Dict[str, int])
                self.names_ages["someone"] = 20
                assert isinstance(self.names_ages["someone"], int)

        m = AttributeModule()
        # m will contain two attributes
        # 1. foo of type float
        # 2. names_ages of type Dict[str, int]

    .. testcleanup::

        del AttributeModule
        del m

    Note: it's now preferred to instead use type annotations instead of `torch.jit.Attribute`:

    .. testcode::

        import torch
        from typing import Dict

        class AttributeModule(torch.nn.Module):
            names: Dict[str, int]

            def __init__(self):
                super().__init__()
                self.names = {}

        m = AttributeModule()

    .. testcleanup::

        del AttributeModule
        del m

    Args:
        value: An initial value to be assigned to attribute.
        type: A Python type

    Returns:
        Returns `value`
c                   C   s   t S r1   )type_trace_dbr+   r+   r+   r,   _get_type_trace_db   s    r3   c                 C   s   t | |d S r1   )getattr)r*   namer+   r+   r,   _get_function_from_type   s    r6   c                 C   s$   t | dr dt| kpt | dS d S )N	__class____dict__	__slots__)hasattrdirr)   r+   r+   r,   _is_new_style_class   s    
r<   c                   @   sT   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd ZdS )OrderedDictWrapperc                 C   s
   || _ d S r1   )_c)selfr>   r+   r+   r,   __init__   s    zOrderedDictWrapper.__init__c                 C   s   dd |   D S )Nc                 S   s   g | ]\}}|qS r+   r+   .0kvr+   r+   r,   
<listcomp>   s     z+OrderedDictWrapper.keys.<locals>.<listcomp>itemsr?   r+   r+   r,   keys   s    zOrderedDictWrapper.keysc                 C   s   dd |   D S )Nc                 S   s   g | ]\}}|qS r+   r+   rA   r+   r+   r,   rE      s     z-OrderedDictWrapper.values.<locals>.<listcomp>rF   rH   r+   r+   r,   values   s    zOrderedDictWrapper.valuesc                 C   s   t |  S r1   )lenrJ   rH   r+   r+   r,   __len__   s    zOrderedDictWrapper.__len__c                 C   s   t dd S )Nz6cannot delete methods or parameters of a script moduleRuntimeErrorr?   rC   r+   r+   r,   __delitem__   s    zOrderedDictWrapper.__delitem__c                 C   s
   | j  S r1   )r>   rG   rH   r+   r+   r,   rG      s    zOrderedDictWrapper.itemsc                 C   s(   || krt d| | j|| d S )NzICan't add a new parameter after ScriptModule construction. Tried to add ')rN   r>   setattrr?   rC   rD   r+   r+   r,   __setitem__   s
    zOrderedDictWrapper.__setitem__c                 C   s   | j |S r1   )r>   containsrO   r+   r+   r,   __contains__   s    zOrderedDictWrapper.__contains__c                 C   s   || krt || j|S r1   )KeyErrorr>   r4   rO   r+   r+   r,   __getitem__   s    zOrderedDictWrapper.__getitem__N)__name__
__module____qualname__r@   rI   rJ   rL   rP   rG   rS   rU   rW   r+   r+   r+   r,   r=      s   r=   c                       s<   e Zd Z fddZdd Zdd Zdd Zd	d
 Z  ZS )OrderedModuleDictc                    s   t  tj| || _d S r1   )superr@   torch_C
ModuleDict_python_modules)r?   moduleZpython_dictr7   r+   r,   r@      s    zOrderedModuleDict.__init__c                 C   s   | j  }|S r1   )r`   rG   r?   rr+   r+   r,   rG      s    
zOrderedModuleDict.itemsc                 C   s
   || j kS r1   r`   rO   r+   r+   r,   rU      s    zOrderedModuleDict.__contains__c                 C   s<   t |tr$| j|| || j|< ntd| d| d S )NzgCannot re-assign modules in a ScriptModule with non-scripted module, tried to replace existing module 'z': )
isinstanceScriptModuler>   rQ   r`   rN   rR   r+   r+   r,   rS      s    

zOrderedModuleDict.__setitem__c                 C   s
   | j | S r1   re   rO   r+   r+   r,   rW     s    zOrderedModuleDict.__getitem__)	rX   rY   rZ   r@   rG   rU   rS   rW   __classcell__r+   r+   rb   r,   r[      s
   
r[   c                       s   e Zd Z fddZ  ZS )
ScriptMetac           	         s   i  _ tt dd _t|D ]D}t|di  D ]\}}| j |< q4t|dt } j| _q t| D ]*\}}t|t	rrt
 | | j |jj< qrt ddrt |||S t ddd	 t fd
d}| _t ||| d S )NZ__constants__r+   _methods_constants_set_disable_script_metaFr@   c                 S   s   d S r1   r+   rH   r+   r+   r,   <lambda>*      z%ScriptMeta.__init__.<locals>.<lambda>c           	         s   t  j}| f|| t  j|k}t|  krdd }tjjj| || d| jd< | jj	}|
 D ]}t| | qh| D ]\}}t| | qdD ]}t| | qd S )Nc                 S   s6   t | }t|dr*dd t|j D S t| S d S )Nrj   c                 S   s   g | ]\}}|qS r+   r+   rA   r+   r+   r,   rE   7  s     zUScriptMeta.__init__.<locals>.init_then_script.<locals>.make_stubs.<locals>.<listcomp>)r0   r:   sortedrj   rG   r   )ra   r*   r+   r+   r,   
make_stubs4  s    
zAScriptMeta.__init__.<locals>.init_then_script.<locals>.make_stubs)Zshare_types_actual_script_module)_parameters_buffers_modules)rK   rj   r0   r]   jit
_recursivecreate_script_moduler8   rq   _concrete_typeZget_attributesdelattrZget_modules)	r?   argskwargsZnum_methodsZadded_methods_in_initrp   Zconcrete_typer5   _r*   Zoriginal_initr+   r,   init_then_script,  s(    
	  	z-ScriptMeta.__init__.<locals>.init_then_script)rj   setr4   rk   reversedrG   unionro   rf   r   ry   Zoriginal_methodrX   r\   r@   	functoolswraps)	r*   r5   basesattrsbaserC   rD   Zbase_constantsr~   rb   r}   r,   r@     s$    

zScriptMeta.__init__rX   rY   rZ   r@   rh   r+   r+   rb   r,   ri     s   ri   c                   @   s   e Zd Zdd ZdS )_CachedForwardc                 C   s
   |  dS )Nforward)__getattr__)r?   objr*   r+   r+   r,   __get__Q  s    z_CachedForward.__get__N)rX   rY   rZ   r   r+   r+   r+   r,   r   P  s   r   c                   @   s   e Zd ZdS )ScriptWarningNrX   rY   rZ   r+   r+   r+   r,   r   U  s   r   c                 C   s0   t s| S tjdd}t| | jdd}t||| S )N   Z	frames_uprg   )	self_name)r   _jit_internal!createResolutionCallbackFromFramer   rX   r   )fn_rcbastr+   r+   r,   script_methodY  s
    r   c                   @   s   e Zd Zdd Zdd ZdS )ConstMapc                 C   s
   || _ d S r1   const_mapping)r?   r   r+   r+   r,   r@   n  s    zConstMap.__init__c                 C   s
   | j | S r1   r   r?   attrr+   r+   r,   r   q  s    zConstMap.__getattr__N)rX   rY   rZ   r@   r   r+   r+   r+   r,   r   m  s   r   )importerscript_module_idreturnc                 C   sH   t | jtjjstdtj }tj|| j| jt	| j
|}t|S )z
    Called by ``torch.package.PackageImporter``'s Pickler's ``persistent_load`` function.
    Performs work of loading and returning a ScriptModule from a ``torch.package`` archive.
    z{Loading ScriptObjects from a PackageImporter created from a directory is not supported. Use a package archive file instead.)rf   Z
zip_readerr]   r^   ZPyTorchFileReaderrN   CompilationUnitZ_import_ir_module_from_packageZstorage_contextr%   Zlast_map_locationr   )r   r   cu
cpp_moduler+   r+   r,   unpackage_script_moduleu  s    
r   __iter__rL   __neg____mul__rU   __add____sub____pow____truediv____mod____ne____eq____lt____gt____le____ge____and____or____xor__rW   rS   __call____int__	__float____bool____str__	__enter____exit__c                       sP   e Zd ZdZ fddZ fddZ fddZdd	 Zd
d Zdd Z	  Z
S )RecursiveScriptClassa  
        An analogue of RecursiveScriptModule for regular objects that are not modules.
        This class is a wrapper around a torch._C.ScriptObject that represents an instance
        of a TorchScript class and allows it to be used in Python.

        Attributes:
            _c [torch._C.ScriptObject]: The C++ object to which attribute lookups and method
                calls are forwarded.
            _props [Dict[str, property]]: A dictionary of properties fetched from self._c and
                exposed on this wrppaer.
        c                    s>   t    d| jd< || _dd | j D | _d| jd< d S )NT_initializingc                 S   s   i | ]}|j t|j|jqS r+   )r5   propertygettersetter)rB   propr+   r+   r,   
<dictcomp>  s    z1RecursiveScriptClass.__init__.<locals>.<dictcomp>F)r\   r@   r8   r>   Z_properties_props)r?   Z	cpp_classrb   r+   r,   r@     s    

zRecursiveScriptClass.__init__c                    sD   d| j kr | j d r t |S || jkr8| j|  S t| j|S Nr   )r8   r\   r   r   fgetr4   r>   r   rb   r+   r,   r     s
    
z RecursiveScriptClass.__getattr__c                    sN   d| j kr"| j d r"t ||S || jkr<| j| |S t| j|| d S r   )r8   r\   __setattr__r   fsetrQ   r>   r?   r   r/   rb   r+   r,   r     s
    
z RecursiveScriptClass.__setattr__c                 O   s&   | j |st | |}|||S r1   )r>   _has_method	TypeErrorr   r?   method_namerz   r{   self_methodr+   r+   r,   forward_magic_method  s    
z)RecursiveScriptClass.forward_magic_methodc                 C   s   t dd S )NzScriptClasses cannot be pickledr&   rH   r+   r+   r,   __getstate__  s    z!RecursiveScriptClass.__getstate__c                 C   s(   | j dr| d|S | d|S d S )N__iadd__r   )r>   r   r   )r?   otherr+   r+   r,   r     s    zRecursiveScriptClass.__iadd__)rX   rY   rZ   __doc__r@   r   r   r   r   r   rh   r+   r+   rb   r,   r     s   	r   c                 O   s   | j tf||S r1   )r   r   r?   rz   r{   r+   r+   r,   method_template  s    r   c                       s|   e Zd ZU dZdddddgZ fddZe Zed	e	f e
d
<  fddZ fddZdd Zdd ZedddZ  ZS )rg   z
        A wrapper around C++ ``torch::jit::Module``. ``ScriptModule``\s
        contain methods, attributes, parameters, and
        constants. These can be accessed the same way as on a normal ``nn.Module``.
        codecode_with_constantsgraphinlined_graphoriginal_namec                    s   t    d S r1   r\   r@   rH   rb   r+   r,   r@     s    ScriptModule.__init__.r   c                    s"   d| j krt |S t| j|S )Nrq   )r8   r\   r   r4   rq   r   rb   r+   r,   r     s    
zScriptModule.__getattr__c                    sZ   d| j krHt|tr:d| jj kr(i | j_|j| j|< |j}t ||S t	| j
|| d S )Nrq   __annotations__)r8   rf   r.   r7   r   r0   r/   r\   r   rQ   rq   r   rb   r+   r,   r     s    

zScriptModule.__setattr__c                 C   sJ   d| j kr| j|S tjdd}tj|}t||d | j	|
 j
< d S )Nrq   r$   r   )r8   rq   definer   r   r]   r^   Z_parse_source_defr   rj   r5   )r?   srcrcbr   r+   r+   r,   r   %  s
    
zScriptModule.definec                 C   s
   | j  S r1   )rq   _replicate_for_data_parallelrH   r+   r+   r,   r   ;  s    z)ScriptModule._replicate_for_data_parallel)exporterc                 C   s&   |  }|j| jt| t|ffS )a}  
            Called by ``torch.package.PackageExporter``'s Pickler's ``persistent_id`` when
            saving TorchScript objects. Performs act of saving a ScriptModule inside of
            a ``torch.package`` archive.

            Returns method to load the ScriptModule from a ``torch.package.PackageImporter``'s
            Pickler's ``persistent_load`` function.
            )Zget_unique_idZscript_module_serializer	serializer>   intr   )r?   r   r   r+   r+   r,   __reduce_package__>  s    	zScriptModule.__reduce_package__)rX   rY   rZ   r   Z__jit_unused_properties__r@   r   r   r   r   r   r   r   r   r   r!   r   rh   r+   r+   rb   r,   rg     s   
rg   )	metaclassc                       s,  e Zd ZdZdZ fddZedd Zedd Zd	d
 Z	e
dd Ze
dd Ze
dd Ze
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Ze
d!d" Zd#d$ Z fd%d&Z fd'd(Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Z  fd7d8Z!d9d: Z"d;d< Z#  Z$S )=RecursiveScriptModulea#  
        The core data structure in TorchScript is the ``ScriptModule``. It is an
        analogue of torch's ``nn.Module`` and represents an entire model as a tree of
        submodules. Like normal modules, each individual module in a ``ScriptModule`` can
        have submodules, parameters, and methods. In ``nn.Module``\s methods are implemented
        as Python functions, but in ``ScriptModule``\s methods are implemented as
        TorchScript functions, a statically-typed subset of Python that contains all
        of PyTorch's built-in Tensor operations. This difference allows your
        ``ScriptModule``\s code to run without the need for a Python interpreter.

        ``ScriptModule``\s should not be created manually, instead use
        either :func:`tracing <torch.jit.trace>` or :func:`scripting <torch.jit.script>`.
        Tracing and scripting can be applied incrementally and :ref:`composed as necessary <Types>`.

        * Tracing records the tensor operations as executed with a set of example inputs and uses these
          operations to construct a computation graph. You can use the full dynamic behavior of Python with tracing,
          but values other than Tensors and control flow aren't captured in the graph.

        * Scripting inspects the Python code of the model
          and compiles it to TorchScript. Scripting allows the use of many `types`_ of values and supports dynamic control flow.
          Many, but not all features of Python are supported by the compiler, so changes to the source code may be necessary.
        Tc                    s(   d| j d< || _t   t| d d S )NTr   Ztraining)r8   r>   r\   r@   ry   )r?   r   rb   r+   r,   r@   g  s    

RecursiveScriptModule.__init__c                 C   s   t | }|| t | |S )a  
            Construct a RecursiveScriptModule that's ready for use. PyTorch
            code should use this to construct a RecursiveScriptModule instead
            of instead of calling `__init__` directly, as it makes sure the
            object is properly finalized (and in the future, we may take
            control of how the RecursiveScriptModule instance is created).

            Args:
                cpp_module:  The C++ Module that will hold the actual state of
                             this RecursiveScriptModule instance.
                init_fn:  Lambda that initializes the RecursiveScriptModule passed to it.
            )r   _finalize_scriptmodule)r   init_fnscript_moduler+   r+   r,   
_constructp  s    
z RecursiveScriptModule._constructc                 C   sB   t tj| j| _t tj| j| _t| j| j	| _	d| _
d S )NF)r=   r]   r^   ParameterDictr>   rr   
BufferDictrs   r[   rt   r   r   r+   r+   r,   r     s     z,RecursiveScriptModule._finalize_scriptmodulec                 C   s   |  | tjj| j | _i }tj| j	 D ]\}}t
|||< q6t| j|| _ttj| j| _ttj| j| _dd | j	 D | _d| jd< dS )z
            Re-construct an instance of RecursiveScriptModule using an instance of a C++ module.

            Args:
                cpp_module: The C++ module that this RecursiveScriptModule will be rebuilt around.
            c                 S   s$   i | ]\}}t |tjjs||qS r+   )rf   r]   r^   ScriptMethodrA   r+   r+   r,   r     s    z6RecursiveScriptModule._reconstruct.<locals>.<dictcomp>Fr   N)r@   r]   r^   ZConcreteModuleTypeZfrom_jit_typer>   _typerx   r_   rG   r   r[   rt   r=   r   rr   r   rs   r8   )r?   r   modulesr5   r+   r+   r,   _reconstruct  s    
z"RecursiveScriptModule._reconstructc                 C   s   | j djS )z
            Returns a string representation of the internal graph for the
            ``forward`` method. See :ref:`interpreting-graphs` for details.
            r   )r>   _get_methodr   rH   r+   r+   r,   r     s    zRecursiveScriptModule.graphc                 C   s   | j jS )z
            Returns a string representation of the internal graph for the
            ``forward`` method. This graph will be preprocessed to inline all function and method calls.
            See :ref:`interpreting-graphs` for details.
            )r   r   rH   r+   r+   r,   r     s    z#RecursiveScriptModule.inlined_graphc                 C   s   | j jS )z
            Returns a pretty-printed representation (as valid Python syntax) of
            the internal graph for the ``forward`` method. See
            :ref:`inspecting-code` for details.
            )r   r   rH   r+   r+   r,   r     s    zRecursiveScriptModule.codec                 C   s   | j j}|d t|d fS )a  
            Returns a tuple of:

            [0] a pretty-printed representation (as valid Python syntax) of
            the internal graph for the ``forward`` method. See `code`.
            [1] a ConstMap following the CONSTANT.cN format of the output in [0].
            The indices in the [0] output are keys to the underlying constant's values.

            See :ref:`inspecting-code` for details.
            r   r$   )r   r   r   rc   r+   r+   r,   r     s    z)RecursiveScriptModule.code_with_constantsc                 K   s   | j jt|f|S )aO  
            save(f, _extra_files={})

            See :func:`torch.jit.save <torch.jit.save>` witch accepts a file-like object.
            This function, torch.save(), converts the object to a string, treating it as a path.
            DO NOT confuse these two functions when it comes to the 'f' parameter functionality.
            )r>   savestr)r?   fr{   r+   r+   r,   r     s    zRecursiveScriptModule.savec                 O   s   | j j||S )az  
            _save_for_lite_interpreter(f)

            Add (or update) the bytecode session to the script model. The updated model is used
            in lite interpreter for mobile applications.

            Args:
                f: a string containing a file name.
                _extra_files: Map from filename to contents which will be stored as part of 'f'.

            )r>   Z_save_for_mobiler   r+   r+   r,   _save_for_lite_interpreter  s    z0RecursiveScriptModule._save_for_lite_interpreterc                 O   s   | j j||S r1   )r>   Z_save_to_buffer_for_mobiler   r+   r+   r,   $_save_to_buffer_for_lite_interpreter  s    z:RecursiveScriptModule._save_to_buffer_for_lite_interpreterc                 O   s   | j j||S r1   )r>   save_to_bufferr   r+   r+   r,   r     s    z$RecursiveScriptModule.save_to_bufferc                 O   s
   | j  S r1   )r>   get_debug_stater   r+   r+   r,   r     s    z%RecursiveScriptModule.get_debug_statec                 C   s   d| j  S )Nzoriginal_name=)r   rH   r+   r+   r,   
extra_repr  s    z RecursiveScriptModule.extra_reprc                 O   s   | j j| f||S r1   )r   	graph_forr   r+   r+   r,   r      s    zRecursiveScriptModule.graph_forc                 C   s0   t | t| j  krdS t| j  S )N )r0   r   r>   r   r5   rH   r+   r+   r,   r     s    z#RecursiveScriptModule.original_namec                 C   s"   t jdd}| j| j|| d S )Nr$   r   )r   r   r>   Z_definerx   )r?   r   r   r+   r+   r,   r   	  s    	zRecursiveScriptModule.definec                    s   d| j krtd| jr$t |S || jkr8| j| S | j|rP| j|S | j	|rv| j
|}|| j |< |S t |S )Nr   zKScriptModule has not been initialized, did you forget to call super's init?)r8   rN   r   r\   r   rt   r>   r:   r4   r   r   )r?   r   r   rb   r+   r,   r     s    



z!RecursiveScriptModule.__getattr__c                    s   | j rt ||S || jkr*|| j|< n^| j|rF| j|| nBt| drz|| j 	 krzt
d| d| dnt ||S d S )Nrx   z+Cannot mutate TorchScript constant value: 'z'. Value: '')r   r\   r   rt   r>   r:   rQ   rx   Zget_constantsrI   AttributeErrorr   rb   r+   r,   r   -  s    
z!RecursiveScriptModule.__setattr__c                 C   s   t jjt| jS r1   )r]   ru   rv   r   copyr>   rH   r+   r+   r,   __copy__H  s    zRecursiveScriptModule.__copy__c                 C   s   t jjt| j|S r1   )r]   ru   rv   r   r   deepcopyr>   )r?   memor+   r+   r,   __deepcopy__K  s    z"RecursiveScriptModule.__deepcopy__c                 O   s0   t | |}t |dd t t|kr&t |||S )N__func__)r4   r   NotImplementedErrorr   r+   r+   r,   r   R  s    
 z*RecursiveScriptModule.forward_magic_methodc                 C   s
   |  dS )Nr   r   rH   r+   r+   r,   r   Z  s    zRecursiveScriptModule.__iter__c                 C   s   |  d|S )NrW   r  )r?   idxr+   r+   r,   rW   ]  s    z!RecursiveScriptModule.__getitem__c                 C   s
   |  dS )NrL   r  rH   r+   r+   r,   rL   `  s    zRecursiveScriptModule.__len__c                 C   s   |  d|S )NrU   r  )r?   keyr+   r+   r,   rU   c  s    z"RecursiveScriptModule.__contains__c                    s&   | j }|jttdkr t   S | S )N__dir__)r
  r  r6   r   r\   r?   r   rb   r+   r,   r
  h  s    
zRecursiveScriptModule.__dir__c                 C   s    | j }|jttdkrdS | S )Nr   T)r   r  r6   r   r  r+   r+   r,   r   t  s    zRecursiveScriptModule.__bool__c                 C   s   dd }t | j |S )Nc                 S   s   d S r1   r+   r   r+   r+   r,   r     s    zCRecursiveScriptModule._replicate_for_data_parallel.<locals>.init_fn)r   r   r>   r   )r?   r   r+   r+   r,   r   }  s
     z2RecursiveScriptModule._replicate_for_data_parallel)%rX   rY   rZ   r   rl   r@   staticmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r   r   rW   rL   rU   r
  r   r   rh   r+   r+   rb   r,   r   K  sL   	

 





	r   __c                    s   dd l   j|  fdddS )Nr   c                    s     | p | S r1   )
isfunctionismethodxinspectr+   r,   rm     rn   z_get_methods.<locals>.<lambda>)	predicate)r  
getmembersr)   r+   r  r,   _get_methods  s
     
r  r   Zregister_bufferZregister_parameterZregister_moduleZ
add_module_applyapplycudacputofloatdoubleZhalfZ
state_dictZ_save_to_state_dictZload_state_dictZ_load_from_state_dictZ_named_members
parametersZnamed_parametersbuffersZnamed_bufferschildrenZnamed_childrenr   Znamed_modulesZ	zero_gradZshare_memoryZ	_get_namer   Z_slow_forwardZ_tracing_nameevaltrainZget_extra_stateZset_extra_statec                    s    fdd}|S )Nc                    s   t  d d S )Nz" is not supported on ScriptModulesrM   r   r5   r+   r,   fail  s    z_make_fail.<locals>.failr+   )r5   r$  r+   r#  r,   
_make_fail  s    r%  Z
_call_implc                   @   s   e Zd ZdS )r   Nr   r+   r+   r+   r,   r     s   c                       s   e Zd Zd fdd	Z  ZS )rg   Nc                    s   t    d S r1   r   r?   argrb   r+   r,   r@     s    r   )Nr   r+   r+   rb   r,   rg     s   c                       s   e Zd Zd fdd	Z  ZS )r   Nc                    s   t    d S r1   r   r&  rb   r+   r,   r@     s    r   )Nr   r+   r+   rb   r,   r     s   c                 C   s   t | tjjs| S t| }||kr.|t|  S t| dr@|  n| } | ||< i }| j D ]j\}}|dkr| D ]\}}t	||||< qr|||< qZt |tjjrt |t
st	||||< qZ|||< qZ| D ]\}}|| j|< q| S )N__prepare_scriptable__rt   )rf   r]   nnr   idr:   r(  r8   rG   !call_prepare_scriptable_func_implrg   )r   r  obj_idZnew_obj_dictr5   Z
sub_modulerC   rD   r+   r+   r,   r+    s,    
 
r+  c                 C   s   i }t | |S r1   )r+  )r   r  r+   r+   r,   call_prepare_scriptable_func	  s    r-  c                 C   s   t j| S )a  
    Create a ``torch._C.ScriptDict`` instance with the data from ``obj``.

    Args:
        obj (dict): The Python dictionary that is used to initialize the ``ScriptDict``
                    returned by this function.

    Returns:
        An instance of ``torch._C.ScriptDict`` that has the same data as ``obj``
        and can be passed between Python and TorchScript with reference semantics and
        zero copy overhead.
    )r]   r^   Z
ScriptDict)r   r+   r+   r,   create_script_dict  s    r.  c                 C   s   t j| S )a  
    Create a ``torch._C.ScriptList`` instance with the data from ``obj``.
    Args:
        obj (dict): The Python list that is used to initialize the ``ScriptList``
                    returned by this function.
    Returns:
        An instance of ``torch._C.ScriptList`` that has the same data as ``obj``
        and can be passed between Python and TorchScript with reference semantics and
        zero copy overhead.
    )r]   r^   Z
ScriptList)r   Z	type_hintr+   r+   r,   create_script_list  s    r/  )example_inputsc              	   C   s  t s| S |dk	rtd t| tr(| S t| tr6| S t| trD| S |rt at	rt
t}t	|\ t|tr| D ]\}}|D ]}||  qqvn&t|tr|D ]}	| |	  qntdW 5 Q R X n
td t| tjjrt| } tjj| tjjjS t| dr|  n| } t| tr(t| S t| tr<t| S t| rt| }
t | tjjrpt!d|  dt | t"j#r| S t$| st!dt%| & d	krt!d
|dkrt'(|d }t)| ||
 | S t*| st+| rt| }
t| dr| j,} t'-| }t| dr,t!d| j. t/|  t0| }|rF|S t1| | j2}|dkrft'-| }tj34|
||t5| }| j6|_6| |_7t8| | |S tjj9| S dS )a  
    Scripting a function or ``nn.Module`` will inspect the source code, compile
    it as TorchScript code using the TorchScript compiler, and return a :class:`ScriptModule` or
    :class:`ScriptFunction`. TorchScript itself is a subset of the Python language, so not all
    features in Python work, but we provide enough functionality to compute on
    tensors and do control-dependent operations. For a complete guide, see the
    :ref:`language-reference`.

    Scripting a dictionary or list copies the data inside it into a TorchScript instance than can be
    subsequently passed by reference between Python and TorchScript with zero copy overhead.

    ``torch.jit.script`` can be used as a function for modules, functions, dictionaries and lists
     and as a decorator ``@torch.jit.script`` for :ref:`torchscript-classes` and functions.

    Args:
        obj (Callable, class, or nn.Module):  The ``nn.Module``, function, class type,
                                                  dictionary, or list to compile.
        example_inputs (Union[List[Tuple], Dict[Callable, List[Tuple]], None]): Provide example inputs
            to annotate the arguments for a function or ``nn.Module``.

    Returns:
        If ``obj`` is ``nn.Module``, ``script`` returns
        a :class:`ScriptModule` object. The returned :class:`ScriptModule` will
        have the same set of sub-modules and parameters as the
        original ``nn.Module``. If ``obj`` is a standalone function,
        a :class:`ScriptFunction` will be returned. If ``obj`` is a ``dict``, then
        ``script`` returns an instance of `torch._C.ScriptDict`. If ``obj`` is a ``list``,
        then ``script`` returns an instance of `torch._C.ScriptList`.

    **Scripting a function**
        The ``@torch.jit.script`` decorator will construct a :class:`ScriptFunction`
        by compiling the body of the function.

        Example (scripting a function):

        .. testcode::

            import torch

            @torch.jit.script
            def foo(x, y):
                if x.max() > y.max():
                    r = x
                else:
                    r = y
                return r

            print(type(foo))  # torch.jit.ScriptFunction

            # See the compiled graph as Python code
            print(foo.code)

            # Call the function using the TorchScript interpreter
            foo(torch.ones(2, 2), torch.ones(2, 2))

        .. testoutput::
            :hide:

            ...

    ****Scripting a function using example_inputs**
        Example inputs can be used to annotate a function arguments.

        Example (annotating a function before scripting):

        .. testcode::

            import torch

            def test_sum(a, b):
                return a + b

            # Annotate the arguments to be int
            scripted_fn = torch.jit.script(test_sum, example_inputs=[(3, 4)])

            print(type(scripted_fn))  # torch.jit.ScriptFunction

            # See the compiled graph as Python code
            print(scripted_fn.code)

            # Call the function using the TorchScript interpreter
            scripted_fn(20, 100)

        .. testoutput::
            :hide:

            ...

    **Scripting an nn.Module**
        Scripting an ``nn.Module`` by default will compile the ``forward`` method and recursively
        compile any methods, submodules, and functions called by ``forward``. If a ``nn.Module`` only uses
        features supported in TorchScript, no changes to the original module code should be necessary. ``script``
        will construct :class:`ScriptModule` that has copies of the attributes, parameters, and methods of
        the original module.

        Example (scripting a simple module with a Parameter):

        .. testcode::

            import torch

            class MyModule(torch.nn.Module):
                def __init__(self, N, M):
                    super().__init__()
                    # This parameter will be copied to the new ScriptModule
                    self.weight = torch.nn.Parameter(torch.rand(N, M))

                    # When this submodule is used, it will be compiled
                    self.linear = torch.nn.Linear(N, M)

                def forward(self, input):
                    output = self.weight.mv(input)

                    # This calls the `forward` method of the `nn.Linear` module, which will
                    # cause the `self.linear` submodule to be compiled to a `ScriptModule` here
                    output = self.linear(output)
                    return output

            scripted_module = torch.jit.script(MyModule(2, 3))

        Example (scripting a module with traced submodules):

        .. testcode::

            import torch
            import torch.nn as nn
            import torch.nn.functional as F

            class MyModule(nn.Module):
                def __init__(self):
                    super().__init__()
                    # torch.jit.trace produces a ScriptModule's conv1 and conv2
                    self.conv1 = torch.jit.trace(nn.Conv2d(1, 20, 5), torch.rand(1, 1, 16, 16))
                    self.conv2 = torch.jit.trace(nn.Conv2d(20, 20, 5), torch.rand(1, 20, 16, 16))

                def forward(self, input):
                    input = F.relu(self.conv1(input))
                    input = F.relu(self.conv2(input))
                    return input

            scripted_module = torch.jit.script(MyModule())

        To compile a method other than ``forward`` (and recursively compile anything it calls), add
        the :func:`@torch.jit.export <torch.jit.export>` decorator to the method. To opt out of compilation
        use :func:`@torch.jit.ignore <torch.jit.ignore>` or :func:`@torch.jit.unused <torch.jit.unused>`.

        Example (an exported and ignored method in a module)::

            import torch
            import torch.nn as nn

            class MyModule(nn.Module):
                def __init__(self):
                    super().__init__()

                @torch.jit.export
                def some_entry_point(self, input):
                    return input + 10

                @torch.jit.ignore
                def python_only_fn(self, input):
                    # This function won't be compiled, so any
                    # Python APIs can be used
                    import pdb
                    pdb.set_trace()

                def forward(self, input):
                    if self.training:
                        self.python_only_fn(input)
                    return input * 99

            scripted_module = torch.jit.script(MyModule())
            print(scripted_module.some_entry_point(torch.randn(2, 2)))
            print(scripted_module(torch.randn(2, 2)))

        Example ( Annotating forward of nn.Module using example_inputs)::

            import torch
            import torch.nn as nn
            from typing import NamedTuple

            class MyModule(NamedTuple):
            result: List[int]

            class TestNNModule(torch.nn.Module):
                def forward(self, a) -> MyModule:
                    result = MyModule(result=a)
                    return result

            pdt_model = TestNNModule()

            # Runs the pdt_model in eager model with the inputs provided and annotates the arguments of forward
            scripted_model = torch.jit.script(pdt_model, example_inputs={pdt_model: [([10, 20, ], ), ], })

            # Run the scripted_model with actual inputs
            print(scripted_model([20]))
    Nz]`optimize` is deprecated and has no effect. Use `with torch.jit.optimized_execution() insteadzError: Unable to infer types. Please format the inputs to type `List[Tuple]` or `Dict[Callable, List[Tuple]]` to be run with MonkeyType.zWarning: monkeytype is not installed. Please install https://github.com/Instagram/MonkeyType to enable Profile-Directed Typing in TorchScript. Refer to https://github.com/Instagram/MonkeyType/blob/master/README.rst to install MonkeyType. r(  zType 'zO' cannot be compiled since it inherits from nn.Module, pass an instance insteadzLTorchScript classes must be new-style classes. Please inherit from 'object'.r   z\TorchScript classes does not support inheritance yet. Please directly inherit from 'object'.r$   Z__script_if_tracing_wrapper__script_unsupportedzTorchScript error: ):r   warningswarnrf   r   rg   ScriptFunctionr   r2   r   r   r   rG   r   
ValueErrorr]   r)  r   r-  ru   rv   rw   r   r:   r(  dictr.  listr/  r  isclassr
   
issubclassrN   enumEnumr<   rK   mror   r   r   r  r  Z__original_fn#createResolutionCallbackFromClosurer1  "_check_directly_compile_overloadedr   r   rX   r^   Z_jit_script_compiler   r   Z_torchdynamo_inliner   Zcreate_script_class)r   optimizeZ
_frames_upr   r0  Zmonkeytype_configra   Zexample_inputZexampleZexamplesqualified_nameZmaybe_already_compiled_fnr   r   r+   r+   r,   script,  s     N





 





   
rA  c                 C   s@   |  D ]2\}}|| ks$| | |krtjj|d| qd S )NzDefault parameters on overloads do not affect the runtime so they must equal to the default parameter on the implementation function. Found on parameter )rG   r]   ru   ZfrontendZFrontendError)Zimpl_defaultsoverload_defaultslocr5   Zoverload_valuer+   r+   r,   _check_overload_defaultsv  s    rD  c           
      C   sz   t | | j }tjj| d d t| }t ||j}t	| }t	|}t
|}t|||  tj||||||}	|	S r1   )r   rX   declr]   ru   annotationsZget_signaturer  r  r   r   r=  rD  ranger^   Z_jit_script_compile_overload)
overload_fn	qual_nameZimpl_fnZoverload_declZoverload_signatureZimpl_astrB  Zimplementation_defaultsr   r   r+   r+   r,   _compile_function_with_overload  s2       
  rJ  c                 C   s   t | }t| }t|}|d kr&|S | |kr>ttd| g }|D ]}|t|||  qF|rj|| }t| | t	| |S )Nfunction)
r   r
   r   _get_fn_overloadsrN   Z,get_overload_no_implementation_error_messageappendrJ  r   Z_clear_fn_overloads)r   Zexisting_compiled_fnsrI  Zuncompiled_overloadsZcompiled_fnsrH  r+   r+   r,   _get_overloads  s&    




rN  c                 C   s.   t | }t|st| r*td| dd S )Nz	Function z cannot be directly compiled because it is overloaded. It must be used in a context of a function where its inputs can determine which overload to call.)r
   r   rL  r   rN   )r   rI  r+   r+   r,   r>    s
    
r>  c                 C   s   t | stdt| s"tdt| tjjo>t| 	 dk}|s\t| 	 dkr\tdt
| }td}t| | j}tj||||}|| _| S )Nz$interface must be applied to a classz1TorchScript interfaces must inherit from 'object'   r   zmTorchScript interface does not support inheritance yet. Please directly inherit from 'object' or 'nn.Module'.r$   )r  r8  rN   r<   r9  r]   r)  r   rK   r<  r
   r   r   r   rX   r^   Z_jit_script_interface_compileZ__torch_script_interface__)r   Zis_module_interfacer@  r   r   Zmangled_classnamer+   r+   r,   	interface  s(    

   rP  c                 C   s,   t | }tj||}t| }t| ||S r1   )r
   r]   r^   Z	CallStackr   Z'createResolutionCallbackForClassMethodsr   )r   rC  Z
_qual_nameZerror_stackr   r+   r+   r,   _recursive_compile_class  s    
rQ   spaddingoffsetcharc                    s<   |t | kr|t | 8 }d fddt|| D |  S )Nr   c                    s   g | ]} qS r+   r+   )rB   r|   rW  r+   r,   rE     s     zpad.<locals>.<listcomp>)rK   joinrG  rS  r+   rX  r,   pad  s    rZ  c                   @   s8   e Zd ZdeeedddZeedddZd	d
 ZdS )_ScriptProfileColumn   r   )header	alignmentrV  c                 C   s   || _ || _|| _i | _d S r1   )r]  r^  rV  rows)r?   r]  r^  rV  r+   r+   r,   r@     s    z_ScriptProfileColumn.__init__)linenor/   c                 C   s   || j |< d S r1   )r_  )r?   r`  r/   r+   r+   r,   add_row  s    z_ScriptProfileColumn.add_rowc                    s   t j}g }j D ],\}}t|}|||f tt ||}qjdkrj|j    j 8  nd  fdd|D }tj j	|fS )Nr   c                    s"   g | ]\}}|t | jfqS r+   )rZ  rV  )rB   r	  cellrU  r?   r+   r,   rE     s     z4_ScriptProfileColumn.materialize.<locals>.<listcomp>)
rK   r]  r_  rG   r   rM  maxr^  rZ  rV  )r?   
max_lengthr_  r	  r/   rb  r+   rc  r,   materialize  s    


z _ScriptProfileColumn.materializeN)r\  r   )	rX   rY   rZ   r   r   r@   r   ra  rf  r+   r+   r+   r,   r[    s   r[  c                   @   s,   e Zd Zee ee dddZdd ZdS )_ScriptProfileTablecolssource_rangec                 C   s   || _ || _d S r1   rh  )r?   ri  rj  r+   r+   r,   r@     s    z_ScriptProfileTable.__init__c           
      C   s   g }g }d}| j D ]*}| \}}||7 }||t|f q|| |tdt|dd | jD ]N}d}|D ]6\}}||}	|	d kr|tdt|7 }qr||	7 }qr|| qfd|S )Nr   r   =
)	ri  rf  rM  r6  rZ  rK   rj  getrY  )
r?   outputscellsZheader_buffercolr]  r_  lineZ
row_bufferrb  r+   r+   r,   dump_string  s$    




z_ScriptProfileTable.dump_stringN)rX   rY   rZ   r   r[  r   r@   rr  r+   r+   r+   r,   rg    s   rg  c                   @   s:   e Zd Zdd Zdd Zdd Zeddd	Zd
d ZdS )_ScriptProfilec                 C   s   t j | _d S r1   )r	   Z	profilingrs  profilerH   r+   r+   r,   r@   )  s    z_ScriptProfile.__init__c                 C   s   | j   d S r1   )rt  enablerH   r+   r+   r,   ru  ,  s    z_ScriptProfile.enablec                 C   s   | j   d S r1   )rt  disablerH   r+   r+   r,   rv  /  s    z_ScriptProfile.disable)r   c                    s"  g }| j  D ]}| }|  }tdd |D   fdd|D }| }|t| }t||}t	d}t	d}	t	d}
t	ddd	}|
 }|D ]V}||| |||||   ||}|d k	r|	||  |
||  qt||	|
|gt|}||  qd
|S )Nc                 S   s"   g | ]}t |t |d  qS )rR  )rK   lstriprB   rq  r+   r+   r,   rE   7  s     z._ScriptProfile.dump_string.<locals>.<listcomp>c                    s   g | ]}| d  qS r1   r+   rx  dedentr+   r,   rE   8  s     zLine #ZHitsz	Time (ns)zLine Contentsr   r$   z

)rt  Z_dump_statssourcetext
splitlinesminZstarting_linenorK   rG  r[  Zline_mapra  rm  countZduration_nsrg  r7  rM  rr  rY  )r?   rn  source_statsZ
source_refZsource_lines
start_lineend_linerj  r`  hitstime_nsZline_contentsstatsrq  stattabler+   ry  r,   rr  2  s6    


 z_ScriptProfile.dump_stringc                 C   s   t |   d S r1   )printrr  rH   r+   r+   r,   dumpP  s    z_ScriptProfile.dumpN)	rX   rY   rZ   r@   ru  rv  r   rr  r  r+   r+   r+   r,   rs  (  s
   rs  c                 C   s   | d k	st d| S )NzUnwrapping null optional)AssertionErrorr  r+   r+   r,   _unwrap_optionalT  s    r  zaten::_unwrap_optionalzaten::is_scriptingzaten::has_torch_function)N)Nr   NN)r   rR  )|r   collectionsr   r:  r   r  r'   r2  typingr   r   r   r   r   r   r   r]   Ztorch._jit_internalr   Ztorch._classesr	   r
   Ztorch.jit._builtinsr   Ztorch.jit._fuserr   r   Ztorch.jit._monkeytype_configr   r   r   Ztorch.jit._recursiver   r   r   r   Ztorch.jit._stater   r   r   r   r   Ztorch.jit.frontendr   r   r   Ztorch.nnr   Ztorch.overridesr   r   r    Ztorch.packager!   r"   Ztorch.utilsr#   Z_serializationr%   r2   r^   r   r   r4  r-   
__reduce__
namedtupler.   r3   r6   r<   r=   r[   r0   ri   r   Warningr   r   r   r   r)  r   Z_magic_methodsr   r   r   rQ   rg   r   r8   rG   r5   itemcallablerf   r   
startswithr:   r  Z_compiled_methods_allowlistr%  methodendswithrX   r+  r-  r.  r/  rA  rD  rJ  rN  r>  rP  rQ  r   r   rZ  r[  rg  rs  r  Zis_scriptingr+   r+   r+   r,   <module>   s^  $


L#1=	 >
R  D	($
      L
	
,


