





from dataclasses import dataclass
from typing import Optional

import numpy as np
import torch
import torch.nn as nn

from ..utils import BaseOutput, is_torch_version, randn_tensor
from .attention_processor import SpatialNorm
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block

@dataclass
class 	UpperCamelCase__				(   lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			torch.FloatTensor

class 	UpperCamelCase__				(   nn.Module     ):



     '''simple docstring'''

     def __init__(							self		:					List[str]		,lowerCamelCase__		:					Optional[Any]=3		,lowerCamelCase__		:					int=3		,lowerCamelCase__		:					List[Any]=("DownEncoderBlock2D",)		,lowerCamelCase__		:					Optional[Any]=(64,)		,lowerCamelCase__		:					List[str]=2		,lowerCamelCase__		:					Any=32		,lowerCamelCase__		:					str="silu"		,lowerCamelCase__		:					List[Any]=True		,)  ->	int:




           '''simple docstring'''


           super().__init__()
           SCREAMING_SNAKE_CASE	=		layers_per_block

           SCREAMING_SNAKE_CASE	=		torch.nn.Convad(
               lowerCamelCase__		,block_out_channels[0]		,kernel_size=3		,stride=1		,padding=1		,)

           SCREAMING_SNAKE_CASE	=		None
           SCREAMING_SNAKE_CASE	=		nn.ModuleList([] )

           # down
           SCREAMING_SNAKE_CASE	=		block_out_channels[0]
           for i, down_block_type in enumerate(lowerCamelCase__ ):
                 SCREAMING_SNAKE_CASE	=		output_channel
                 SCREAMING_SNAKE_CASE	=		block_out_channels[i]
                 SCREAMING_SNAKE_CASE	=		i == len(lowerCamelCase__ ) - 1

                 SCREAMING_SNAKE_CASE	=		get_down_block(
                     lowerCamelCase__		,num_layers=self.layers_per_block		,in_channels=lowerCamelCase__		,out_channels=lowerCamelCase__		,add_downsample=not is_final_block		,resnet_eps=1e-6		,downsample_padding=0		,resnet_act_fn=lowerCamelCase__		,resnet_groups=lowerCamelCase__		,attention_head_dim=lowerCamelCase__		,temb_channels=lowerCamelCase__		,)
                 self.down_blocks.append(lowerCamelCase__ )

           # mid
           SCREAMING_SNAKE_CASE	=		UNetMidBlockaD(
               in_channels=block_out_channels[-1]		,resnet_eps=1e-6		,resnet_act_fn=lowerCamelCase__		,output_scale_factor=1		,resnet_time_scale_shift="""default"""		,attention_head_dim=block_out_channels[-1]		,resnet_groups=lowerCamelCase__		,temb_channels=lowerCamelCase__		,)

           # out
           SCREAMING_SNAKE_CASE	=		nn.GroupNorm(num_channels=block_out_channels[-1]		,num_groups=lowerCamelCase__		,eps=1e-6 )
           SCREAMING_SNAKE_CASE	=		nn.SiLU()

           SCREAMING_SNAKE_CASE	=		2 * out_channels if double_z else out_channels
           SCREAMING_SNAKE_CASE	=		nn.Convad(block_out_channels[-1]		,lowerCamelCase__		,3		,padding=1 )

           SCREAMING_SNAKE_CASE	=		False






     def        SCREAMING_SNAKE_CASE__						(							self		:					Union[str, Any]		,lowerCamelCase__		:					Any )  ->	Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		x
           SCREAMING_SNAKE_CASE	=		self.conv_in(lowerCamelCase__ )

           if self.training and self.gradient_checkpointing:

                 def create_custom_forward(lowerCamelCase__		:					int ):
                       def custom_forward(*lowerCamelCase__		:					str ):
                             return module(*lowerCamelCase__ )

                       return custom_forward

                 # down
                 if is_torch_version(""">="""		,"""1.11.0""" ):
                       for down_block in self.down_blocks:
                             SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(
                                 create_custom_forward(lowerCamelCase__ )		,lowerCamelCase__		,use_reentrant=lowerCamelCase__ )
                       # middle
                       SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(
                           create_custom_forward(self.mid_block )		,lowerCamelCase__		,use_reentrant=lowerCamelCase__ )
                 else:
                       for down_block in self.down_blocks:
                             SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(create_custom_forward(lowerCamelCase__ )		,lowerCamelCase__ )
                       # middle
                       SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block )		,lowerCamelCase__ )

           else:
                 # down
                 for down_block in self.down_blocks:
                       SCREAMING_SNAKE_CASE	=		down_block(lowerCamelCase__ )

                 # middle
                 SCREAMING_SNAKE_CASE	=		self.mid_block(lowerCamelCase__ )

           # post-process
           SCREAMING_SNAKE_CASE	=		self.conv_norm_out(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.conv_act(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.conv_out(lowerCamelCase__ )

           return sample

class 	UpperCamelCase__				(   nn.Module     ):



     '''simple docstring'''

     def __init__(							self		:					Optional[Any]		,lowerCamelCase__		:					Tuple=3		,lowerCamelCase__		:					Dict=3		,lowerCamelCase__		:					Any=("UpDecoderBlock2D",)		,lowerCamelCase__		:					Optional[int]=(64,)		,lowerCamelCase__		:					Tuple=2		,lowerCamelCase__		:					int=32		,lowerCamelCase__		:					Tuple="silu"		,lowerCamelCase__		:					int="group"		,)  ->	Dict:




           '''simple docstring'''


           super().__init__()
           SCREAMING_SNAKE_CASE	=		layers_per_block

           SCREAMING_SNAKE_CASE	=		nn.Convad(
               lowerCamelCase__		,block_out_channels[-1]		,kernel_size=3		,stride=1		,padding=1		,)

           SCREAMING_SNAKE_CASE	=		None
           SCREAMING_SNAKE_CASE	=		nn.ModuleList([] )

           SCREAMING_SNAKE_CASE	=		in_channels if norm_type == """spatial""" else None

           # mid
           SCREAMING_SNAKE_CASE	=		UNetMidBlockaD(
               in_channels=block_out_channels[-1]		,resnet_eps=1e-6		,resnet_act_fn=lowerCamelCase__		,output_scale_factor=1		,resnet_time_scale_shift="""default""" if norm_type == """group""" else norm_type		,attention_head_dim=block_out_channels[-1]		,resnet_groups=lowerCamelCase__		,temb_channels=lowerCamelCase__		,)

           # up
           SCREAMING_SNAKE_CASE	=		list(reversed(lowerCamelCase__ ) )
           SCREAMING_SNAKE_CASE	=		reversed_block_out_channels[0]
           for i, up_block_type in enumerate(lowerCamelCase__ ):
                 SCREAMING_SNAKE_CASE	=		output_channel
                 SCREAMING_SNAKE_CASE	=		reversed_block_out_channels[i]

                 SCREAMING_SNAKE_CASE	=		i == len(lowerCamelCase__ ) - 1

                 SCREAMING_SNAKE_CASE	=		get_up_block(
                     lowerCamelCase__		,num_layers=self.layers_per_block + 1		,in_channels=lowerCamelCase__		,out_channels=lowerCamelCase__		,prev_output_channel=lowerCamelCase__		,add_upsample=not is_final_block		,resnet_eps=1e-6		,resnet_act_fn=lowerCamelCase__		,resnet_groups=lowerCamelCase__		,attention_head_dim=lowerCamelCase__		,temb_channels=lowerCamelCase__		,resnet_time_scale_shift=lowerCamelCase__		,)
                 self.up_blocks.append(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		output_channel

           # out
           if norm_type == "spatial":
                 SCREAMING_SNAKE_CASE	=		SpatialNorm(block_out_channels[0]		,lowerCamelCase__ )
           else:
                 SCREAMING_SNAKE_CASE	=		nn.GroupNorm(num_channels=block_out_channels[0]		,num_groups=lowerCamelCase__		,eps=1e-6 )
           SCREAMING_SNAKE_CASE	=		nn.SiLU()
           SCREAMING_SNAKE_CASE	=		nn.Convad(block_out_channels[0]		,lowerCamelCase__		,3		,padding=1 )

           SCREAMING_SNAKE_CASE	=		False






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[str]		,lowerCamelCase__		:					List[str]		,lowerCamelCase__		:					Optional[Any]=None )  ->	Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		z
           SCREAMING_SNAKE_CASE	=		self.conv_in(lowerCamelCase__ )

           SCREAMING_SNAKE_CASE	=		next(iter(self.up_blocks.parameters() ) ).dtype
           if self.training and self.gradient_checkpointing:

                 def create_custom_forward(lowerCamelCase__		:					str ):
                       def custom_forward(*lowerCamelCase__		:					Union[str, Any] ):
                             return module(*lowerCamelCase__ )

                       return custom_forward

                 if is_torch_version(""">="""		,"""1.11.0""" ):
                       # middle
                       SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(
                           create_custom_forward(self.mid_block )		,lowerCamelCase__		,lowerCamelCase__		,use_reentrant=lowerCamelCase__ )
                       SCREAMING_SNAKE_CASE	=		sample.to(lowerCamelCase__ )

                       # up
                       for up_block in self.up_blocks:
                             SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(
                                 create_custom_forward(lowerCamelCase__ )		,lowerCamelCase__		,lowerCamelCase__		,use_reentrant=lowerCamelCase__ )
                 else:
                       # middle
                       SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(
                           create_custom_forward(self.mid_block )		,lowerCamelCase__		,lowerCamelCase__ )
                       SCREAMING_SNAKE_CASE	=		sample.to(lowerCamelCase__ )

                       # up
                       for up_block in self.up_blocks:
                             SCREAMING_SNAKE_CASE	=		torch.utils.checkpoint.checkpoint(create_custom_forward(lowerCamelCase__ )		,lowerCamelCase__		,lowerCamelCase__ )
           else:
                 # middle
                 SCREAMING_SNAKE_CASE	=		self.mid_block(lowerCamelCase__		,lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		sample.to(lowerCamelCase__ )

                 # up
                 for up_block in self.up_blocks:
                       SCREAMING_SNAKE_CASE	=		up_block(lowerCamelCase__		,lowerCamelCase__ )

        # post-process
           if latent_embeds is None:
                 SCREAMING_SNAKE_CASE	=		self.conv_norm_out(lowerCamelCase__ )
           else:
                 SCREAMING_SNAKE_CASE	=		self.conv_norm_out(lowerCamelCase__		,lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.conv_act(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.conv_out(lowerCamelCase__ )

           return sample

class 	UpperCamelCase__				(   nn.Module     ):



     '''simple docstring'''

     def __init__(							self		:					int		,lowerCamelCase__		:					Optional[Any]		,lowerCamelCase__		:					Optional[Any]		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					str=None		,lowerCamelCase__		:					str="random"		,lowerCamelCase__		:					List[Any]=False		,lowerCamelCase__		:					Any=True )  ->	List[Any]:




           '''simple docstring'''


           super().__init__()
           SCREAMING_SNAKE_CASE	=		n_e
           SCREAMING_SNAKE_CASE	=		vq_embed_dim
           SCREAMING_SNAKE_CASE	=		beta
           SCREAMING_SNAKE_CASE	=		legacy

           SCREAMING_SNAKE_CASE	=		nn.Embedding(self.n_e		,self.vq_embed_dim )
           self.embedding.weight.data.uniform_(-1.0 / self.n_e		,1.0 / self.n_e )

           SCREAMING_SNAKE_CASE	=		remap
           if self.remap is not None:
                 self.register_buffer("""used"""		,torch.tensor(np.load(self.remap ) ) )
                 SCREAMING_SNAKE_CASE	=		self.used.shape[0]
                 SCREAMING_SNAKE_CASE	=		unknown_index  # "random" or "extra" or integer
                 if self.unknown_index == "extra":
                       SCREAMING_SNAKE_CASE	=		self.re_embed
                       SCREAMING_SNAKE_CASE	=		self.re_embed + 1
                 print(
                     F"""Remapping {self.n_e} indices to {self.re_embed} indices. """
                     F"""Using {self.unknown_index} for unknown indices.""" )
           else:
                 SCREAMING_SNAKE_CASE	=		n_e

           SCREAMING_SNAKE_CASE	=		sane_index_shape






     def        SCREAMING_SNAKE_CASE__						(							self		:					Dict		,lowerCamelCase__		:					List[str] )  ->	Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		inds.shape
           assert len(lowerCamelCase__ ) > 1
           SCREAMING_SNAKE_CASE	=		inds.reshape(ishape[0]		,-1 )
           SCREAMING_SNAKE_CASE	=		self.used.to(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		(inds[:, :, None] == used[None, None, ...]).long()
           SCREAMING_SNAKE_CASE	=		match.argmax(-1 )
           SCREAMING_SNAKE_CASE	=		match.sum(2 ) < 1
           if self.unknown_index == "random":
                 SCREAMING_SNAKE_CASE	=		torch.randint(0		,self.re_embed		,size=new[unknown].shape ).to(device=new.device )
           else:
                 SCREAMING_SNAKE_CASE	=		self.unknown_index
           return new.reshape(lowerCamelCase__ )






     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple		,lowerCamelCase__		:					Optional[Any] )  ->	str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		inds.shape
           assert len(lowerCamelCase__ ) > 1
           SCREAMING_SNAKE_CASE	=		inds.reshape(ishape[0]		,-1 )
           SCREAMING_SNAKE_CASE	=		self.used.to(lowerCamelCase__ )
           if self.re_embed > self.used.shape[0]:  # extra token
                 SCREAMING_SNAKE_CASE	=		0  # simply set to zero
           SCREAMING_SNAKE_CASE	=		torch.gather(used[None, :][inds.shape[0] * [0], :]		,1		,lowerCamelCase__ )
           return back.reshape(lowerCamelCase__ )






     def        SCREAMING_SNAKE_CASE__						(							self		:					Any		,lowerCamelCase__		:					List[str] )  ->	int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		z.permute(0		,2		,3		,1 ).contiguous()
           SCREAMING_SNAKE_CASE	=		z.view(-1		,self.vq_embed_dim )

           # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
           SCREAMING_SNAKE_CASE	=		torch.argmin(torch.cdist(lowerCamelCase__		,self.embedding.weight )		,dim=1 )

           SCREAMING_SNAKE_CASE	=		self.embedding(lowerCamelCase__ ).view(z.shape )
           SCREAMING_SNAKE_CASE	=		None
           SCREAMING_SNAKE_CASE	=		None

           # compute loss for embedding
           if not self.legacy:
                 SCREAMING_SNAKE_CASE	=		self.beta * torch.mean((z_q.detach() - z) ** 2 ) + torch.mean((z_q - z.detach()) ** 2 )
           else:
                 SCREAMING_SNAKE_CASE	=		torch.mean((z_q.detach() - z) ** 2 ) + self.beta * torch.mean((z_q - z.detach()) ** 2 )

           # preserve gradients
           SCREAMING_SNAKE_CASE	=		z + (z_q - z).detach()

           # reshape back to match original input shape
           SCREAMING_SNAKE_CASE	=		z_q.permute(0		,3		,1		,2 ).contiguous()

           if self.remap is not None:
                 SCREAMING_SNAKE_CASE	=		min_encoding_indices.reshape(z.shape[0]		,-1 )  # add batch axis
                 SCREAMING_SNAKE_CASE	=		self.remap_to_used(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		min_encoding_indices.reshape(-1		,1 )  # flatten

           if self.sane_index_shape:
                 SCREAMING_SNAKE_CASE	=		min_encoding_indices.reshape(z_q.shape[0]		,z_q.shape[2]		,z_q.shape[3] )

           return z_q, loss, (perplexity, min_encodings, min_encoding_indices)






     def        SCREAMING_SNAKE_CASE__						(							self		:					int		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					Tuple )  ->	Any:




           '''simple docstring'''


           if self.remap is not None:
                 SCREAMING_SNAKE_CASE	=		indices.reshape(shape[0]		,-1 )  # add batch axis
                 SCREAMING_SNAKE_CASE	=		self.unmap_to_all(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		indices.reshape(-1 )  # flatten again

           # get quantized latent vectors
           SCREAMING_SNAKE_CASE	=		self.embedding(lowerCamelCase__ )

           if shape is not None:
                 SCREAMING_SNAKE_CASE	=		z_q.view(lowerCamelCase__ )
                 # reshape back to match original input shape
                 SCREAMING_SNAKE_CASE	=		z_q.permute(0		,3		,1		,2 ).contiguous()

           return z_q

class 	UpperCamelCase__				(   lowerCAmelCase_     ):



     '''simple docstring'''

     def __init__(							self		:					Any		,lowerCamelCase__		:					Dict		,lowerCamelCase__		:					int=False )  ->	Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		parameters
           SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		torch.chunk(lowerCamelCase__		,2		,dim=1 )
           SCREAMING_SNAKE_CASE	=		torch.clamp(self.logvar		,-30.0		,20.0 )
           SCREAMING_SNAKE_CASE	=		deterministic
           SCREAMING_SNAKE_CASE	=		torch.exp(0.5 * self.logvar )
           SCREAMING_SNAKE_CASE	=		torch.exp(self.logvar )
           if self.deterministic:
                 SCREAMING_SNAKE_CASE	=		SCREAMING_SNAKE_CASE	=		torch.zeros_like(
                     self.mean		,device=self.parameters.device		,dtype=self.parameters.dtype )






     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple		,lowerCamelCase__		:					Optional[torch.Generator] = None )  ->	torch.FloatTensor:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		randn_tensor(
               self.mean.shape		,generator=lowerCamelCase__		,device=self.parameters.device		,dtype=self.parameters.dtype )
           SCREAMING_SNAKE_CASE	=		self.mean + self.std * sample
           return x






     def        SCREAMING_SNAKE_CASE__						(							self		:					Any		,lowerCamelCase__		:					Union[str, Any]=None )  ->	List[Any]:




           '''simple docstring'''


           if self.deterministic:
                 return torch.Tensor([0.0] )
           else:
                 if other is None:
                       return 0.5 * torch.sum(torch.pow(self.mean		,2 ) + self.var - 1.0 - self.logvar		,dim=[1, 2, 3] )
                 else:
                       return 0.5 * torch.sum(
                           torch.pow(self.mean - other.mean		,2 ) / other.var
                           + self.var / other.var
                           - 1.0
                           - self.logvar
                           + other.logvar		,dim=[1, 2, 3]		,)






     def        SCREAMING_SNAKE_CASE__						(							self		:					str		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					Any=[1, 2, 3] )  ->	Any:




           '''simple docstring'''


           if self.deterministic:
                 return torch.Tensor([0.0] )
           SCREAMING_SNAKE_CASE	=		np.log(2.0 * np.pi )
           return 0.5 * torch.sum(logtwopi + self.logvar + torch.pow(sample - self.mean		,2 ) / self.var		,dim=lowerCamelCase__ )






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[Any] )  ->	int:




           '''simple docstring'''


           return self.mean









import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     str:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		[]
      for line in lines:
            SCREAMING_SNAKE_CASE	=		re.sub(r"""#.*"""				,		""""""				,		_SCREAMING_SNAKE_CASE			)  # remove comments
            if line:
                  filtered_lines.append(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		"""\n""".join(_SCREAMING_SNAKE_CASE			)

      # Make a hash from all this code
      SCREAMING_SNAKE_CASE	=		full_str.encode("""utf-8"""			)
      return shaaaa(_SCREAMING_SNAKE_CASE			).hexdigest()


# get importable module names and hash for caching
SCREAMING_SNAKE_CASE_		     = {
    """csv""": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    """json""": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    """pandas""": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    """parquet""": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    """arrow""": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    """text""": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    """imagefolder""": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    """audiofolder""": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
SCREAMING_SNAKE_CASE_		     = {
    """.csv""": ("""csv""", {}),
    """.tsv""": ("""csv""", {"""sep""": """\t"""}),
    """.json""": ("""json""", {}),
    """.jsonl""": ("""json""", {}),
    """.parquet""": ("""parquet""", {}),
    """.arrow""": ("""arrow""", {}),
    """.txt""": ("""text""", {}),
}
_EXTENSION_TO_MODULE.update({ext: ("""imagefolder""", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("""imagefolder""", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ("""audiofolder""", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("""audiofolder""", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
SCREAMING_SNAKE_CASE_		     = {"""imagefolder""", """audiofolder"""}

# Used to filter data files based on extensions given a module name
SCREAMING_SNAKE_CASE_		     = {}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
      _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append(""".zip""")



_MODULE_TO_EXTENSIONS["audiofolder"].append(""".zip""")


