
"""simple docstring"""



from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)




@flax.struct.dataclass
class 		a_						( _UpperCAmelCase	):
    a      :				jnp.ndarray







@flax_register_to_config
class 		a_						( nn.Module     ,						_UpperCAmelCase     ,						_UpperCAmelCase	):
    a      :				int     =				32
    a      :				int     =				4
    a      :				int     =				4
    a      :				Tuple[str]     =				(
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    a      :				Tuple[str]     =				("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
    a      :				Union[bool, Tuple[bool]]     =				False
    a      :				Tuple[int]     =				(320, 640, 1280, 1280)
    a      :				int     =				2
    a      :				Union[int, Tuple[int]]     =				8
    a      :				Optional[Union[int, Tuple[int]]]     =				None
    a      :				int     =				1280
    a      :				float     =				0.0
    a      :				bool     =				False
    a      :				jnp.dtype     =				jnp.floataa
    a      :				bool     =				True
    a      :				int     =				0
    a      :				bool     =				False







    def      _snake_case					(			self			:       Tuple     ,					__UpperCamelCase			:       jax.random.KeyArray     )		->FrozenDict:






        '''simple docstring'''






        _UpperCAmelCase          =   (1, self.in_channels, self.sample_size, self.sample_size)
        _UpperCAmelCase          =   jnp.zeros(__UpperCamelCase     ,					dtype=jnp.floataa     )
        _UpperCAmelCase          =   jnp.ones((1,)     ,					dtype=jnp.intaa     )
        _UpperCAmelCase          =   jnp.zeros((1, 1, self.cross_attention_dim)     ,					dtype=jnp.floataa     )

        _UpperCAmelCase    ,_UpperCAmelCase          =   jax.random.split(__UpperCamelCase     )
        _UpperCAmelCase          =   {"""params""": params_rng, """dropout""": dropout_rng}

        return self.init(__UpperCamelCase     ,					__UpperCamelCase     ,					__UpperCamelCase     ,					__UpperCamelCase     )["params"]







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






        '''simple docstring'''






        _UpperCAmelCase          =   self.block_out_channels
        _UpperCAmelCase          =   block_out_channels[0] * 4

        if self.num_attention_heads is not None:
            raise ValueError(
                """At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19."""     )

        # If `num_attention_heads` is not defined (which is the case for most models)
        # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
        # The reason for this behavior is to correct for incorrectly named variables that were introduced
        # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
        # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
        # which is why we correct for the naming here.
        _UpperCAmelCase          =   self.num_attention_heads or self.attention_head_dim

        # input
        _UpperCAmelCase          =   nn.Conv(
            block_out_channels[0]     ,					kernel_size=(3, 3)     ,					strides=(1, 1)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)

        # time
        _UpperCAmelCase          =   FlaxTimesteps(
            block_out_channels[0]     ,					flip_sin_to_cos=self.flip_sin_to_cos     ,					freq_shift=self.config.freq_shift     )
        _UpperCAmelCase          =   FlaxTimestepEmbedding(__UpperCamelCase     ,					dtype=self.dtype     )

        _UpperCAmelCase          =   self.only_cross_attention
        if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ):
            _UpperCAmelCase          =   (only_cross_attention,) * len(self.down_block_types     )

        if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ):
            _UpperCAmelCase          =   (num_attention_heads,) * len(self.down_block_types     )

        # down
        _UpperCAmelCase          =   []
        _UpperCAmelCase          =   block_out_channels[0]
        for i, down_block_type in enumerate(self.down_block_types     ):
            _UpperCAmelCase          =   output_channel
            _UpperCAmelCase          =   block_out_channels[i]
            _UpperCAmelCase          =   i == len(__UpperCamelCase     ) - 1

            if down_block_type == "CrossAttnDownBlock2D":
                _UpperCAmelCase          =   FlaxCrossAttnDownBlockaD(
                    in_channels=__UpperCamelCase     ,					out_channels=__UpperCamelCase     ,					dropout=self.dropout     ,					num_layers=self.layers_per_block     ,					num_attention_heads=num_attention_heads[i]     ,					add_downsample=not is_final_block     ,					use_linear_projection=self.use_linear_projection     ,					only_cross_attention=only_cross_attention[i]     ,					use_memory_efficient_attention=self.use_memory_efficient_attention     ,					dtype=self.dtype     ,					)
            else:
                _UpperCAmelCase          =   FlaxDownBlockaD(
                    in_channels=__UpperCamelCase     ,					out_channels=__UpperCamelCase     ,					dropout=self.dropout     ,					num_layers=self.layers_per_block     ,					add_downsample=not is_final_block     ,					dtype=self.dtype     ,					)

            down_blocks.append(__UpperCamelCase     )
        _UpperCAmelCase          =   down_blocks

        # mid
        _UpperCAmelCase          =   FlaxUNetMidBlockaDCrossAttn(
            in_channels=block_out_channels[-1]     ,					dropout=self.dropout     ,					num_attention_heads=num_attention_heads[-1]     ,					use_linear_projection=self.use_linear_projection     ,					use_memory_efficient_attention=self.use_memory_efficient_attention     ,					dtype=self.dtype     ,					)

        # up
        _UpperCAmelCase          =   []
        _UpperCAmelCase          =   list(reversed(__UpperCamelCase     )     )
        _UpperCAmelCase          =   list(reversed(__UpperCamelCase     )     )
        _UpperCAmelCase          =   list(reversed(__UpperCamelCase     )     )
        _UpperCAmelCase          =   reversed_block_out_channels[0]
        for i, up_block_type in enumerate(self.up_block_types     ):
            _UpperCAmelCase          =   output_channel
            _UpperCAmelCase          =   reversed_block_out_channels[i]
            _UpperCAmelCase          =   reversed_block_out_channels[min(i + 1     ,					len(__UpperCamelCase     ) - 1     )]

            _UpperCAmelCase          =   i == len(__UpperCamelCase     ) - 1

            if up_block_type == "CrossAttnUpBlock2D":
                _UpperCAmelCase          =   FlaxCrossAttnUpBlockaD(
                    in_channels=__UpperCamelCase     ,					out_channels=__UpperCamelCase     ,					prev_output_channel=__UpperCamelCase     ,					num_layers=self.layers_per_block + 1     ,					num_attention_heads=reversed_num_attention_heads[i]     ,					add_upsample=not is_final_block     ,					dropout=self.dropout     ,					use_linear_projection=self.use_linear_projection     ,					only_cross_attention=only_cross_attention[i]     ,					use_memory_efficient_attention=self.use_memory_efficient_attention     ,					dtype=self.dtype     ,					)
            else:
                _UpperCAmelCase          =   FlaxUpBlockaD(
                    in_channels=__UpperCamelCase     ,					out_channels=__UpperCamelCase     ,					prev_output_channel=__UpperCamelCase     ,					num_layers=self.layers_per_block + 1     ,					add_upsample=not is_final_block     ,					dropout=self.dropout     ,					dtype=self.dtype     ,					)

            up_blocks.append(__UpperCamelCase     )
            _UpperCAmelCase          =   output_channel
        _UpperCAmelCase          =   up_blocks

        # out
        _UpperCAmelCase          =   nn.GroupNorm(num_groups=32     ,					epsilon=1e-5     )
        _UpperCAmelCase          =   nn.Conv(
            self.out_channels     ,					kernel_size=(3, 3)     ,					strides=(1, 1)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)







    def __call__(			self			:       Tuple     ,					__UpperCamelCase			:       Union[str, Any]     ,					__UpperCamelCase			:       List[Any]     ,					__UpperCamelCase			:       Optional[Any]     ,					__UpperCamelCase			:       int=None     ,					__UpperCamelCase			:       Any=None     ,					__UpperCamelCase			:       bool = True     ,					__UpperCamelCase			:       bool = False     ,					)		->Union[FlaxUNetaDConditionOutput, Tuple]:






        '''simple docstring'''






        if not isinstance(__UpperCamelCase     ,					jnp.ndarray     ):
            _UpperCAmelCase          =   jnp.array([timesteps]     ,					dtype=jnp.intaa     )
        elif isinstance(__UpperCamelCase     ,					jnp.ndarray     ) and len(timesteps.shape     ) == 0:
            _UpperCAmelCase          =   timesteps.astype(dtype=jnp.floataa     )
            _UpperCAmelCase          =   jnp.expand_dims(__UpperCamelCase     ,					0     )

        _UpperCAmelCase          =   self.time_proj(__UpperCamelCase     )
        _UpperCAmelCase          =   self.time_embedding(__UpperCamelCase     )

        # 2. pre-process
        _UpperCAmelCase          =   jnp.transpose(__UpperCamelCase     ,					(0, 2, 3, 1)     )
        _UpperCAmelCase          =   self.conv_in(__UpperCamelCase     )

        # 3. down
        _UpperCAmelCase          =   (sample,)
        for down_block in self.down_blocks:
            if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ):
                _UpperCAmelCase    ,_UpperCAmelCase          =   down_block(__UpperCamelCase     ,					__UpperCamelCase     ,					__UpperCamelCase     ,					deterministic=not train     )
            else:
                _UpperCAmelCase    ,_UpperCAmelCase          =   down_block(__UpperCamelCase     ,					__UpperCamelCase     ,					deterministic=not train     )
            down_block_res_samples += res_samples

        if down_block_additional_residuals is not None:
            _UpperCAmelCase          =   ()

            for down_block_res_sample, down_block_additional_residual in zip(
                __UpperCamelCase     ,					__UpperCamelCase     ):
                down_block_res_sample += down_block_additional_residual
                new_down_block_res_samples += (down_block_res_sample,)

            _UpperCAmelCase          =   new_down_block_res_samples

        # 4. mid
        _UpperCAmelCase          =   self.mid_block(__UpperCamelCase     ,					__UpperCamelCase     ,					__UpperCamelCase     ,					deterministic=not train     )

        if mid_block_additional_residual is not None:
            sample += mid_block_additional_residual

        # 5. up
        for up_block in self.up_blocks:
            _UpperCAmelCase          =   down_block_res_samples[-(self.layers_per_block + 1) :]
            _UpperCAmelCase          =   down_block_res_samples[: -(self.layers_per_block + 1)]
            if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ):
                _UpperCAmelCase          =   up_block(
                    __UpperCamelCase     ,					temb=__UpperCamelCase     ,					encoder_hidden_states=__UpperCamelCase     ,					res_hidden_states_tuple=__UpperCamelCase     ,					deterministic=not train     ,					)
            else:
                _UpperCAmelCase          =   up_block(__UpperCamelCase     ,					temb=__UpperCamelCase     ,					res_hidden_states_tuple=__UpperCamelCase     ,					deterministic=not train     )

        # 6. post-process
        _UpperCAmelCase          =   self.conv_norm_out(__UpperCamelCase     )
        _UpperCAmelCase          =   nn.silu(__UpperCamelCase     )
        _UpperCAmelCase          =   self.conv_out(__UpperCamelCase     )
        _UpperCAmelCase          =   jnp.transpose(__UpperCamelCase     ,					(0, 3, 1, 2)     )

        if not return_dict:
            return (sample,)

        return FlaxUNetaDConditionOutput(sample=__UpperCamelCase     )

"""simple docstring"""



import collections
import json
import math
import os
import re
import time
from fnmatch import fnmatch
from typing import Dict

import requests
from slack_sdk import WebClient


a					:	int							=		WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])


def  _UpperCamelCase	(						_A      )    ->  List[str]:





    """simple docstring"""

    _UpperCAmelCase          =   test_results.split(""" """      )

    _UpperCAmelCase          =   0
    _UpperCAmelCase          =   0

    # When the output is short enough, the output is surrounded by = signs: "== OUTPUT =="
    # When it is too long, those signs are not present.
    _UpperCAmelCase          =   expressions[-2] if """=""" in expressions[-1] else expressions[-1]

    for i, expression in enumerate(_A      ):
        if "failed" in expression:
            failed += int(expressions[i - 1]      )
        if "passed" in expression:
            success += int(expressions[i - 1]      )

    return failed, success, time_spent


def  _UpperCamelCase	(						_A      )    ->  int:





    """simple docstring"""

    _UpperCAmelCase          =   {}
    _UpperCAmelCase          =   None
    _UpperCAmelCase          =   False
    for line in failures_short_lines.split("""\n"""      ):
        if re.search(R"""_ \[doctest\]"""					,      _A      ):
            _UpperCAmelCase          =   True
            _UpperCAmelCase          =   line.split(""" """      )[2]
        elif in_error and not line.split(""" """      )[0].isdigit():
            _UpperCAmelCase          =   line
            _UpperCAmelCase          =   False

    return failures




class 		a_						:







    def __init__(			self			:       Union[str, Any]     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       Dict     )		->Union[str, Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   title

        _UpperCAmelCase          =   doc_test_results["""time_spent"""].split(""","""     )[0]
        _UpperCAmelCase          =   doc_test_results["""success"""]
        _UpperCAmelCase          =   doc_test_results["""failures"""]
        _UpperCAmelCase          =   self.n_success + self.n_failures

        # Failures and success of the modeling tests
        _UpperCAmelCase          =   doc_test_results







    @property
    def      _snake_case					(			self			:       int     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   [self._time_spent]
        _UpperCAmelCase          =   0

        for time in time_spent:
            _UpperCAmelCase          =   time.split(""":"""     )

            # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute.
            if len(__UpperCamelCase     ) == 1:
                _UpperCAmelCase          =   [0, 0, time_parts[0]]

            _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase          =   int(time_parts[0]     ), int(time_parts[1]     ), float(time_parts[2]     )
            total_secs += hours * 36_00 + minutes * 60 + seconds

        _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase          =   total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60
        return f"""{int(__UpperCamelCase     )}h{int(__UpperCamelCase     )}m{int(__UpperCamelCase     )}s"""







    @property
    def      _snake_case					(			self			:       List[Any]     )		->Dict:






        '''simple docstring'''






        return {"type": "header", "text": {"type": "plain_text", "text": self.title}}







    @property
    def      _snake_case					(			self			:       Optional[Any]     )		->Dict:






        '''simple docstring'''






        return {
            "type": "section",
            "text": {
                "type": "plain_text",
                "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""",
                "emoji": True,
            },
            "accessory": {
                "type": "button",
                "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""",
            },
        }







    @property
    def      _snake_case					(			self			:       Union[str, Any]     )		->Dict:






        '''simple docstring'''






        return {
            "type": "section",
            "text": {
                "type": "plain_text",
                "text": (
                    f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in"""
                    f""" {self.time}."""
                ),
                "emoji": True,
            },
            "accessory": {
                "type": "button",
                "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""",
            },
        }







    @property
    def      _snake_case					(			self			:       List[str]     )		->Dict:






        '''simple docstring'''






        _UpperCAmelCase          =   40
        _UpperCAmelCase          =   {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase     ,					__UpperCamelCase     )}

        _UpperCAmelCase          =   """"""
        for category, failures in category_failures.items():
            if len(__UpperCamelCase     ) == 0:
                continue

            if report != "":
                report += "\n\n"

            report += f"""*{category} failures*:""".ljust(line_length // 2     ).rjust(line_length // 2     ) + "\n"
            report += "`"
            report += "`\n`".join(__UpperCamelCase     )
            report += "`"

        return {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"""The following examples had failures:\n\n\n{report}\n""",
            },
        }







    @property
    def      _snake_case					(			self			:       Union[str, Any]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   [self.header]

        if self.n_failures > 0:
            blocks.append(self.failures     )

        if self.n_failures > 0:
            blocks.extend([self.category_failures]     )

        if self.n_failures == 0:
            blocks.append(self.no_failures     )

        return json.dumps(__UpperCamelCase     )







    @staticmethod
    def      _snake_case					(			)		->Any:






        '''simple docstring'''






        _UpperCAmelCase          =   [
            {
                """type""": """section""",
                """text""": {
                    """type""": """plain_text""",
                    """text""": """There was an issue running the tests.""",
                },
                """accessory""": {
                    """type""": """button""",
                    """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True},
                    """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""",
                },
            }
        ]

        print("""Sending the following payload"""     )
        print(json.dumps({"""blocks""": json.loads(__UpperCamelCase     )}     )     )

        client.chat_postMessage(
            channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]     ,					text="""There was an issue running the tests."""     ,					blocks=__UpperCamelCase     ,					)







    def      _snake_case					(			self			:       Tuple     )		->Optional[Any]:






        '''simple docstring'''






        print("""Sending the following payload"""     )
        print(json.dumps({"""blocks""": json.loads(self.payload     )}     )     )

        _UpperCAmelCase          =   f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed."""

        _UpperCAmelCase          =   client.chat_postMessage(
            channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]     ,					blocks=self.payload     ,					text=__UpperCamelCase     ,					)







    def      _snake_case					(			self			:       List[Any]     ,					__UpperCamelCase			:       Optional[int]     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       List[str]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   """"""
        for key, value in failures.items():
            _UpperCAmelCase          =   value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase     ) > 2_50 else value
            failures_text += f"""*{key}*\n_{value}_\n\n"""

        _UpperCAmelCase          =   job_name
        _UpperCAmelCase          =   {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}}

        if job_link is not None:
            _UpperCAmelCase          =   {
                """type""": """button""",
                """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True},
                """url""": job_link,
            }

        return [
            {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}},
            content,
            {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}},
        ]







    def      _snake_case					(			self			:       int     )		->Optional[Any]:






        '''simple docstring'''






        if self.thread_ts is None:
            raise ValueError("""Can only post reply if a post has been made."""     )

        _UpperCAmelCase          =   self.doc_test_results.pop("""job_link"""     )
        self.doc_test_results.pop("""failures"""     )
        self.doc_test_results.pop("""success"""     )
        self.doc_test_results.pop("""time_spent"""     )

        _UpperCAmelCase          =   sorted(self.doc_test_results.items()     ,					key=lambda __UpperCamelCase     : t[0]     )
        for job, job_result in sorted_dict:
            if len(job_result["""failures"""]     ):
                _UpperCAmelCase          =   f"""*Num failures* :{len(job_result["failed"]     )} \n"""
                _UpperCAmelCase          =   job_result["""failures"""]
                _UpperCAmelCase          =   self.get_reply_blocks(__UpperCamelCase     ,					__UpperCamelCase     ,					__UpperCamelCase     ,					text=__UpperCamelCase     )

                print("""Sending the following reply"""     )
                print(json.dumps({"""blocks""": blocks}     )     )

                client.chat_postMessage(
                    channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]     ,					text=f"""Results for {job}"""     ,					blocks=__UpperCamelCase     ,					thread_ts=self.thread_ts["""ts"""]     ,					)

                time.sleep(1     )







def  _UpperCamelCase	(						)    ->  List[str]:





    """simple docstring"""

    _UpperCAmelCase          =   os.environ["""GITHUB_RUN_ID"""]
    _UpperCAmelCase          =   F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100"""
    _UpperCAmelCase          =   requests.get(_A      ).json()
    _UpperCAmelCase          =   {}

    try:
        jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]}      )
        _UpperCAmelCase          =   math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0      )

        for i in range(_A      ):
            _UpperCAmelCase          =   requests.get(url + F"""&page={i + 2}"""      ).json()
            jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]}      )

        return jobs
    except Exception as e:
        print("""Unknown error, could not fetch links."""					,      _A      )

    return {}


def  _UpperCamelCase	(						_A      )    ->  Optional[int]:





    """simple docstring"""

    _UpperCAmelCase          =   {}

    if os.path.exists(_A      ):
        _UpperCAmelCase          =   os.listdir(_A      )
        for file in files:
            try:
                with open(os.path.join(_A					,      _A      )					,      encoding="""utf-8"""      ) as f:
                    _UpperCAmelCase          =   f.read()
            except UnicodeDecodeError as e:
                raise ValueError(F"""Could not open {os.path.join(_A					,      _A      )}."""      ) from e

    return _artifact


def  _UpperCamelCase	(						)    ->  int:





    """simple docstring"""

    class 		a_						:







        def __init__(			self			:       List[Any]     ,					__UpperCamelCase			:       str     )		->Tuple:






            '''simple docstring'''






            _UpperCAmelCase          =   name
            _UpperCAmelCase          =   []







        def __str__(			self			:       int     )		->Optional[Any]:






            '''simple docstring'''






            return self.name







        def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       str     )		->int:






            '''simple docstring'''






            self.paths.append({"""name""": self.name, """path""": path}     )







    _UpperCAmelCase          =   {}

    _UpperCAmelCase          =   filter(os.path.isdir					,      os.listdir()      )
    for directory in directories:
        _UpperCAmelCase          =   directory
        if artifact_name not in _available_artifacts:
            _UpperCAmelCase          =   Artifact(_A      )

            _available_artifacts[artifact_name].add_path(_A      )

    return _available_artifacts


if __name__ == "__main__":
 a					:	Dict							=		get_job_links()
 a					:	Dict							=		retrieve_available_artifacts()

 a					:	Optional[int]							=		collections.OrderedDict(
     [
         ('''*.py''', '''API Examples'''),
         ('''*.md''', '''MD Examples'''),
     ]
 )

 # This dict will contain all the information relative to each doc test category:
 # - failed: list of failed tests
 # - failures: dict in the format 'test': 'error_message'
 a					:	Dict							=		{
     v: {
         '''failed''': [],
         '''failures''': {},
     }
     for v in docs.values()
 }

 # Link to the GitHub Action job
 a					:	int							=		github_actions_job_links.get('''run_doctests''')

 a					:	Tuple							=		available_artifacts['''doc_tests_gpu_test_reports'''].paths[0]
 a					:	Optional[Any]							=		retrieve_artifact(artifact_path['''name'''])
 if "stats" in artifact:
  a		, a		, a					:	str							=		handle_test_results(artifact['''stats'''])
  a					:	Tuple							=		failed
  a					:	int							=		success
  a					:	Any							=		time_spent[1:-1] + ''', '''

  a					:	Dict							=		extract_first_line_failure(artifact['''failures_short'''])
  for line in artifact["summary_short"].split('''\n'''):
   if re.search('''FAILED''', line):
    a					:	List[Any]							=		line.replace('''FAILED ''', '''''')
    a					:	Tuple							=		line.split()[0].replace('''\n''', '''''')

    if "::" in line:
     a		, a					:	Union[str, Any]							=		line.split('''::''')
    else:
     a		, a					:	Optional[Any]							=		line, line

    for file_regex in docs.keys():
     if fnmatch(file_path, file_regex):
      a					:	List[Any]							=		docs[file_regex]
      doc_test_results[category]["failed"].append(test)

      a					:	Optional[Any]							=		all_failures[test] if test in all_failures else '''N/A'''
      a					:	List[str]							=		failure
      break

 a					:	List[Any]							=		Message('''🤗 Results of the doc tests.''', doc_test_results)
 message.post()
 message.post_reply()