





from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
          TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
          TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
          TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
          TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
          LayoutLMvaConfig,
          TFLayoutLMvaForQuestionAnswering,
          TFLayoutLMvaForSequenceClassification,
          TFLayoutLMvaForTokenClassification,
          TFLayoutLMvaModel,
      )

if is_vision_available():
      from PIL import Image

      from transformers import LayoutLMvaImageProcessor
class        SCREAMING_SNAKE_CASE     :


   def __init__(					self    :       Dict    ,  a    :       Union[str, Any]    ,  a    :       int=2    ,  a    :       Optional[int]=3    ,  a    :       Optional[int]=4    ,  a    :       Dict=2    ,  a    :       List[Any]=7    ,  a    :       Optional[int]=True    ,  a    :       Dict=True    ,  a    :       Optional[int]=True    ,  a    :       List[Any]=True    ,  a    :       List[Any]=99    ,  a    :       Optional[Any]=36    ,  a    :       int=2    ,  a    :       Optional[int]=4    ,  a    :       Tuple=37    ,  a    :       Any="gelu"    ,  a    :       Optional[int]=0.1    ,  a    :       Any=0.1    ,  a    :       Dict=512    ,  a    :       Optional[Any]=16    ,  a    :       List[str]=2    ,  a    :       List[Any]=0.02    ,  a    :       Any=6    ,  a    :       Tuple=6    ,  a    :       List[Any]=3    ,  a    :       Tuple=4    ,  a    :       Tuple=None    ,  a    :       List[str]=1_000    ,  )->     List[str]:





     """simple docstring"""







     lowercase__			    =						parent
     lowercase__			    =						batch_size
     lowercase__			    =						num_channels
     lowercase__			    =						image_size
     lowercase__			    =						patch_size
     lowercase__			    =						is_training
     lowercase__			    =						use_input_mask
     lowercase__			    =						use_token_type_ids
     lowercase__			    =						use_labels
     lowercase__			    =						vocab_size
     lowercase__			    =						hidden_size
     lowercase__			    =						num_hidden_layers
     lowercase__			    =						num_attention_heads
     lowercase__			    =						intermediate_size
     lowercase__			    =						hidden_act
     lowercase__			    =						hidden_dropout_prob
     lowercase__			    =						attention_probs_dropout_prob
     lowercase__			    =						max_position_embeddings
     lowercase__			    =						type_vocab_size
     lowercase__			    =						type_sequence_label_size
     lowercase__			    =						initializer_range
     lowercase__			    =						coordinate_size
     lowercase__			    =						shape_size
     lowercase__			    =						num_labels
     lowercase__			    =						num_choices
     lowercase__			    =						scope
     lowercase__			    =						range_bbox

     # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
     lowercase__			    =						text_seq_length
     lowercase__			    =						(image_size // patch_size) ** 2 + 1
     lowercase__			    =						self.text_seq_length + self.image_seq_length


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Optional[int]:





     """simple docstring"""







     lowercase__			    =						ids_tensor([self.batch_size, self.text_seq_length]    ,  self.vocab_size )

     lowercase__			    =						ids_tensor([self.batch_size, self.text_seq_length, 4]    ,  self.range_bbox )
     lowercase__			    =						bbox.numpy()
     # Ensure that bbox is legal
     for i in range(bbox.shape[0] ):
       for j in range(bbox.shape[1] ):
         if bbox[i, j, 3] < bbox[i, j, 1]:
           lowercase__			    =						bbox[i, j, 3]
           lowercase__			    =						bbox[i, j, 1]
           lowercase__			    =						tmp_coordinate
         if bbox[i, j, 2] < bbox[i, j, 0]:
           lowercase__			    =						bbox[i, j, 2]
           lowercase__			    =						bbox[i, j, 0]
           lowercase__			    =						tmp_coordinate
     lowercase__			    =						tf.constant(a )

     lowercase__			    =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

     lowercase__			    =						None
     if self.use_input_mask:
       lowercase__			    =						random_attention_mask([self.batch_size, self.text_seq_length] )

     lowercase__			    =						None
     if self.use_token_type_ids:
       lowercase__			    =						ids_tensor([self.batch_size, self.text_seq_length]    ,  self.type_vocab_size )

     lowercase__			    =						None
     lowercase__			    =						None
     if self.use_labels:
       lowercase__			    =						ids_tensor([self.batch_size]    ,  self.type_sequence_label_size )
       lowercase__			    =						ids_tensor([self.batch_size, self.text_seq_length]    ,  self.num_labels )

     lowercase__			    =						LayoutLMvaConfig(
         vocab_size=self.vocab_size    ,  hidden_size=self.hidden_size    ,  num_hidden_layers=self.num_hidden_layers    ,  num_attention_heads=self.num_attention_heads    ,  intermediate_size=self.intermediate_size    ,  hidden_act=self.hidden_act    ,  hidden_dropout_prob=self.hidden_dropout_prob    ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,  max_position_embeddings=self.max_position_embeddings    ,  type_vocab_size=self.type_vocab_size    ,  initializer_range=self.initializer_range    ,  coordinate_size=self.coordinate_size    ,  shape_size=self.shape_size    ,  input_size=self.image_size    ,  patch_size=self.patch_size    ,  )

     return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels


   def  SCREAMING_SNAKE_CASE_							(					self    :       str    ,  a    :       Optional[Any]    ,  a    :       Optional[Any]    ,  a    :       Optional[Any]    ,  a    :       Optional[Any]    ,  a    :       Union[str, Any]    ,  a    :       Any )->     Tuple:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMvaModel(config=a )

     # text + image
     lowercase__			    =						model(a    ,  pixel_values=a    ,  training=a )
     lowercase__			    =						model(
         a    ,  bbox=a    ,  pixel_values=a    ,  attention_mask=a    ,  token_type_ids=a    ,  training=a    ,  )
     lowercase__			    =						model(a    ,  bbox=a    ,  pixel_values=a    ,  training=a )

     self.parent.assertEqual(result.last_hidden_state.shape    ,  (self.batch_size, self.seq_length, self.hidden_size) )

     # text only
     lowercase__			    =						model(a    ,  training=a )
     self.parent.assertEqual(
         result.last_hidden_state.shape    ,  (self.batch_size, self.text_seq_length, self.hidden_size) )

     # image only
     lowercase__			    =						model({'pixel_values': pixel_values}    ,  training=a )
     self.parent.assertEqual(
         result.last_hidden_state.shape    ,  (self.batch_size, self.image_seq_length, self.hidden_size) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       Union[str, Any]    ,  a    :       List[Any]    ,  a    :       int    ,  a    :       str    ,  a    :       str    ,  a    :       Any    ,  a    :       Optional[Any] )->     Tuple:





     """simple docstring"""







     lowercase__			    =						self.num_labels
     lowercase__			    =						TFLayoutLMvaForSequenceClassification(config=a )
     lowercase__			    =						model(
         a    ,  bbox=a    ,  pixel_values=a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=a    ,  training=a    ,  )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.num_labels) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       int    ,  a    :       Dict    ,  a    :       Tuple    ,  a    :       str    ,  a    :       List[Any]    ,  a    :       str    ,  a    :       Any    ,  a    :       Union[str, Any] )->     Tuple:





     """simple docstring"""







     lowercase__			    =						self.num_labels
     lowercase__			    =						TFLayoutLMvaForTokenClassification(config=a )
     lowercase__			    =						model(
         a    ,  bbox=a    ,  pixel_values=a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=a    ,  training=a    ,  )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.text_seq_length, self.num_labels) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any    ,  a    :       List[Any]    ,  a    :       Tuple    ,  a    :       Union[str, Any]    ,  a    :       Tuple    ,  a    :       List[str]    ,  a    :       Union[str, Any]    ,  a    :       Union[str, Any] )->     Union[str, Any]:





     """simple docstring"""







     lowercase__			    =						2
     lowercase__			    =						TFLayoutLMvaForQuestionAnswering(config=a )
     lowercase__			    =						model(
         a    ,  bbox=a    ,  pixel_values=a    ,  attention_mask=a    ,  token_type_ids=a    ,  start_positions=a    ,  end_positions=a    ,  training=a    ,  )
     self.parent.assertEqual(result.start_logits.shape    ,  (self.batch_size, self.seq_length) )
     self.parent.assertEqual(result.end_logits.shape    ,  (self.batch_size, self.seq_length) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						self.prepare_config_and_inputs()
     ((lowercase__)    ,					(lowercase__)    ,					(lowercase__)    ,					(lowercase__)    ,					(lowercase__)    ,					(lowercase__)    ,					(lowercase__)    ,					(lowercase__))			    =						config_and_inputs
     lowercase__			    =						{
         'input_ids': input_ids,
         'bbox': bbox,
         'pixel_values': pixel_values,
         'token_type_ids': token_type_ids,
         'attention_mask': input_mask,
     }
     return config, inputs_dict






@require_tf
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	Tuple				      = (
       (
           TFLayoutLMvaModel,
           TFLayoutLMvaForQuestionAnswering,
           TFLayoutLMvaForSequenceClassification,
           TFLayoutLMvaForTokenClassification,
       )
       if is_tf_available()
       else ()
   )
   _UpperCamelCase					:	List[Any]				      = (
       {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
       if is_tf_available()
       else {}
   )

   _UpperCamelCase					:	Dict				      = False
   _UpperCamelCase					:	str				      = False
   _UpperCamelCase					:	str				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any]    ,  a    :       Optional[int]    ,  a    :       Optional[int]    ,  a    :       Union[str, Any]    ,  a    :       str    ,  a    :       List[Any] )->     List[Any]:





     """simple docstring"""







     return True


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       str    ,  a    :       Tuple    ,  a    :       Optional[Any]=False )->     dict:





     """simple docstring"""







     lowercase__			    =						copy.deepcopy(a )

     if model_class in get_values(a ):
       lowercase__			    =						{
           k: tf.tile(tf.expand_dims(a    ,  1 )    ,  (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1) )
           if isinstance(a    ,  tf.Tensor ) and v.ndim > 0
           else v
           for k, v in inputs_dict.items()
       }

     if return_labels:
       if model_class in get_values(a ):
         lowercase__			    =						tf.ones(self.model_tester.batch_size    ,  dtype=tf.intaa )
       elif model_class in get_values(a ):
         lowercase__			    =						tf.zeros(self.model_tester.batch_size    ,  dtype=tf.intaa )
         lowercase__			    =						tf.zeros(self.model_tester.batch_size    ,  dtype=tf.intaa )
       elif model_class in get_values(a ):
         lowercase__			    =						tf.zeros(self.model_tester.batch_size    ,  dtype=tf.intaa )
       elif model_class in get_values(a ):
         lowercase__			    =						tf.zeros(
             (self.model_tester.batch_size, self.model_tester.text_seq_length)    ,  dtype=tf.intaa )

     return inputs_dict


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Tuple:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMvaModelTester(self )
     lowercase__			    =						ConfigTester(self    ,  config_class=a    ,  hidden_size=37 )


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





     """simple docstring"""







     self.config_tester.run_common_tests()


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





     """simple docstring"""







     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes:
       lowercase__			    =						model_class(a )
       if getattr(a    ,  'hf_compute_loss'    ,  a ):
         # The number of elements in the loss should be the same as the number of elements in the label
         lowercase__			    =						self._prepare_for_class(inputs_dict.copy()    ,  a    ,  return_labels=a )
         lowercase__			    =						prepared_for_class[
             sorted(prepared_for_class.keys() - inputs_dict.keys()    ,  reverse=a )[0]
         ]
         lowercase__			    =						added_label.shape.as_list()[:1]

         # Test that model correctly compute the loss with kwargs
         lowercase__			    =						self._prepare_for_class(inputs_dict.copy()    ,  a    ,  return_labels=a )
         lowercase__			    =						prepared_for_class.pop('input_ids' )

         lowercase__			    =						model(a    ,  **a )[0]
         self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

         # Test that model correctly compute the loss when we mask some positions
         lowercase__			    =						self._prepare_for_class(inputs_dict.copy()    ,  a    ,  return_labels=a )
         lowercase__			    =						prepared_for_class.pop('input_ids' )
         if "labels" in prepared_for_class:
           lowercase__			    =						prepared_for_class['labels'].numpy()
           if len(labels.shape ) > 1 and labels.shape[1] != 1:
             lowercase__			    =						-100
             lowercase__			    =						tf.convert_to_tensor(a )
             lowercase__			    =						model(a    ,  **a )[0]
             self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )
             self.assertTrue(not np.any(np.isnan(loss.numpy() ) ) )

                # Test that model correctly compute the loss with a dict
         lowercase__			    =						self._prepare_for_class(inputs_dict.copy()    ,  a    ,  return_labels=a )
         lowercase__			    =						model(a )[0]
         self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

         # Test that model correctly compute the loss with a tuple
         lowercase__			    =						self._prepare_for_class(inputs_dict.copy()    ,  a    ,  return_labels=a )

         # Get keys that were added with the _prepare_for_class function
         lowercase__			    =						prepared_for_class.keys() - inputs_dict.keys()
         lowercase__			    =						inspect.signature(model.call ).parameters
         lowercase__			    =						list(signature.keys() )

         # Create a dictionary holding the location of the tensors in the tuple
         lowercase__			    =						{0: 'input_ids'}
         for label_key in label_keys:
           lowercase__			    =						signature_names.index(a )
           lowercase__			    =						label_key
         lowercase__			    =						sorted(tuple_index_mapping.items() )
         # Initialize a list with their default values, update the values and convert to a tuple
         lowercase__			    =						[]

         for name in signature_names:
           if name != "kwargs":
             list_input.append(signature[name].default )

         for index, value in sorted_tuple_index_mapping:
           lowercase__			    =						prepared_for_class[value]

         lowercase__			    =						tuple(a )

         # Send to model
         lowercase__			    =						model(tuple_input[:-1] )[0]

         self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Tuple:





     """simple docstring"""







     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(a    ,  a    ,  a    ,  a    ,  a    ,  a )


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





     """simple docstring"""







     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
       lowercase__			    =						type
       self.model_tester.create_and_check_model(a    ,  a    ,  a    ,  a    ,  a    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Any:





     """simple docstring"""







     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(
         a    ,  a    ,  a    ,  a    ,  a    ,  a    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     List[str]:





     """simple docstring"""







     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(
         a    ,  a    ,  a    ,  a    ,  a    ,  a    ,  a )


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





     """simple docstring"""







     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(
         a    ,  a    ,  a    ,  a    ,  a    ,  a    ,  a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     int:





     """simple docstring"""







     for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowercase__			    =						TFLayoutLMvaModel.from_pretrained(a )
       self.assertIsNotNone(a )






def     __UpperCamelCase						()       ->     Optional[Any]:
  lowercase__			    =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
  return image


@require_tf
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):


   @cached_property
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     List[Any]:





     """simple docstring"""







     return LayoutLMvaImageProcessor(apply_ocr=a ) if is_vision_available() else None


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base' )

     lowercase__			    =						self.default_image_processor
     lowercase__			    =						prepare_img()
     lowercase__			    =						image_processor(images=a    ,  return_tensors='tf' ).pixel_values

     lowercase__			    =						tf.constant([[1, 2]] )
     lowercase__			    =						tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]] )    ,  axis=0 )

     # forward pass
     lowercase__			    =						model(input_ids=a    ,  bbox=a    ,  pixel_values=a    ,  training=a )

     # verify the logits
     lowercase__			    =						(1, 199, 768)
     self.assertEqual(outputs.last_hidden_state.shape    ,  a )

     lowercase__			    =						tf.constant(
         [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]] )

     self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]    ,  a    ,  atol=1E-4 ) )









import os
import zipfile

import requests
from get_ci_error_statistics import download_artifact, get_artifacts_links




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=7	)       ->     List[Any]:
  lowercase__			    =						None
  if token is not None:
    lowercase__			    =						{'Accept': 'application/vnd.github+json', 'Authorization': F"""Bearer {token}"""}

  # The id of a workflow (not of a workflow run)
  lowercase__			    =						'636036'

  lowercase__			    =						F"""https://api.github.com/repos/huggingface/transformers/actions/workflows/{workflow_id}/runs"""
  # On `main` branch + event being `schedule` + not returning PRs + only `num_runs` results
  url += F"""?branch=main&event=schedule&exclude_pull_requests=true&per_page={num_runs}"""

  lowercase__			    =						requests.get(_SCREAMING_SNAKE_CASE	,		headers=_SCREAMING_SNAKE_CASE	).json()

  return result["workflow_runs"]




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     Union[str, Any]:
  lowercase__			    =						get_daily_ci_runs(_SCREAMING_SNAKE_CASE	)
  lowercase__			    =						None
  for workflow_run in workflow_runs:
    if workflow_run["status"] == "completed":
      lowercase__			    =						workflow_run['id']
      break

  return workflow_run_id




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     Tuple:
  lowercase__			    =						get_last_daily_ci_runs(_SCREAMING_SNAKE_CASE	)
  if workflow_run_id is not None:
    lowercase__			    =						get_artifacts_links(worflow_run_id=_SCREAMING_SNAKE_CASE	,		token=_SCREAMING_SNAKE_CASE	)
    for artifact_name in artifact_names:
      if artifact_name in artifacts_links:
        lowercase__			    =						artifacts_links[artifact_name]
        download_artifact(
            artifact_name=_SCREAMING_SNAKE_CASE	,		artifact_url=_SCREAMING_SNAKE_CASE	,		output_dir=_SCREAMING_SNAKE_CASE	,		token=_SCREAMING_SNAKE_CASE	)




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     Dict:
  get_last_daily_ci_artifacts(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)

  lowercase__			    =						{}
  for artifact_name in artifact_names:
    lowercase__			    =						os.path.join(_SCREAMING_SNAKE_CASE	,		F"""{artifact_name}.zip"""	)
    if os.path.isfile(_SCREAMING_SNAKE_CASE	):
      lowercase__			    =						{}
      with zipfile.ZipFile(_SCREAMING_SNAKE_CASE	) as z:
        for filename in z.namelist():
          if not os.path.isdir(_SCREAMING_SNAKE_CASE	):
            # read the file
            with z.open(_SCREAMING_SNAKE_CASE	) as f:
              lowercase__			    =						f.read().decode('UTF-8'	)

  return results


