"""simple docstring"""


import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        LayoutLMForMaskedLM,
        LayoutLMForQuestionAnswering,
        LayoutLMForSequenceClassification,
        LayoutLMForTokenClassification,
        LayoutLMModel,
    )




class 					UpperCamelCase   :







       def __init__(					self,				lowerCAmelCase__,				lowerCAmelCase__=13,				lowerCAmelCase__=7,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=99,				lowerCAmelCase__=32,				lowerCAmelCase__=5,				lowerCAmelCase__=4,				lowerCAmelCase__=37,				lowerCAmelCase__="gelu",				lowerCAmelCase__=0.1,				lowerCAmelCase__=0.1,				lowerCAmelCase__=512,				lowerCAmelCase__=16,				lowerCAmelCase__=2,				lowerCAmelCase__=0.02,				lowerCAmelCase__=3,				lowerCAmelCase__=4,				lowerCAmelCase__=None,				lowerCAmelCase__=1000,				) -> Tuple:
            snake_case_   			=   parent
            snake_case_   			=   batch_size
            snake_case_   			=   seq_length
            snake_case_   			=   is_training
            snake_case_   			=   use_input_mask
            snake_case_   			=   use_token_type_ids
            snake_case_   			=   use_labels
            snake_case_   			=   vocab_size
            snake_case_   			=   hidden_size
            snake_case_   			=   num_hidden_layers
            snake_case_   			=   num_attention_heads
            snake_case_   			=   intermediate_size
            snake_case_   			=   hidden_act
            snake_case_   			=   hidden_dropout_prob
            snake_case_   			=   attention_probs_dropout_prob
            snake_case_   			=   max_position_embeddings
            snake_case_   			=   type_vocab_size
            snake_case_   			=   type_sequence_label_size
            snake_case_   			=   initializer_range
            snake_case_   			=   num_labels
            snake_case_   			=   num_choices
            snake_case_   			=   scope
            snake_case_   			=   range_bbox







       def 						a_		(					self) -> Union[str, Any]:
            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.vocab_size)

            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length, 4],				self.range_bbox)
            # 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]:
                           snake_case_   			=   bbox[i, j, 3]
                           snake_case_   			=   bbox[i, j, 1]
                           snake_case_   			=   t
                      if bbox[i, j, 2] < bbox[i, j, 0]:
                           snake_case_   			=   bbox[i, j, 2]
                           snake_case_   			=   bbox[i, j, 0]
                           snake_case_   			=   t

            snake_case_   			=   None
            if self.use_input_mask:
                 snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				vocab_size=2)

            snake_case_   			=   None
            if self.use_token_type_ids:
                 snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.type_vocab_size)

            snake_case_   			=   None
            snake_case_   			=   None
            snake_case_   			=   None
            if self.use_labels:
                 snake_case_   			=   ids_tensor([self.batch_size],				self.type_sequence_label_size)
                 snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.num_labels)
                 snake_case_   			=   ids_tensor([self.batch_size],				self.num_choices)

            snake_case_   			=   self.get_config()

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







       def 						a_		(					self) -> Any:
            return LayoutLMConfig(
                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,				)







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__) -> Tuple:
            snake_case_   			=   LayoutLMModel(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()
            snake_case_   			=   model(lowerCAmelCase__,				lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__)
            snake_case_   			=   model(lowerCAmelCase__,				lowerCAmelCase__,				token_type_ids=lowerCAmelCase__)
            snake_case_   			=   model(lowerCAmelCase__,				lowerCAmelCase__)
            self.parent.assertEqual(result.last_hidden_state.shape,				(self.batch_size, self.seq_length, self.hidden_size))
            self.parent.assertEqual(result.pooler_output.shape,				(self.batch_size, self.hidden_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__) -> str:
            snake_case_   			=   LayoutLMForMaskedLM(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()
            snake_case_   			=   model(lowerCAmelCase__,				lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				labels=lowerCAmelCase__)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   self.num_labels
            snake_case_   			=   LayoutLMForSequenceClassification(lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()
            snake_case_   			=   model(
                lowerCAmelCase__,				lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				labels=lowerCAmelCase__)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_labels))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   self.num_labels
            snake_case_   			=   LayoutLMForTokenClassification(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()
            snake_case_   			=   model(lowerCAmelCase__,				lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				labels=lowerCAmelCase__)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.num_labels))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   LayoutLMForQuestionAnswering(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()
            snake_case_   			=   model(
                lowerCAmelCase__,				bbox=lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				start_positions=lowerCAmelCase__,				end_positions=lowerCAmelCase__,				)
            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 						a_		(					self) -> Optional[int]:
            snake_case_   			=   self.prepare_config_and_inputs()
            (
                (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      (
                snake_case_
            )			,      
            )   			=   config_and_inputs
            snake_case_   			=   {
                'input_ids': input_ids,
                'bbox': bbox,
                'token_type_ids': token_type_ids,
                'attention_mask': input_mask,
            }
            return config, inputs_dict




@require_torch
class 					UpperCamelCase   (							lowerCAmelCase__       ,						lowerCAmelCase__       ,						unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_						      = (
           (
               LayoutLMModel,
               LayoutLMForMaskedLM,
               LayoutLMForSequenceClassification,
               LayoutLMForTokenClassification,
               LayoutLMForQuestionAnswering,
           )
           if is_torch_available()
           else None
       )
       SCREAMING_SNAKE_CASE_						      = (
           {
               "document-question-answering": LayoutLMForQuestionAnswering,
               "feature-extraction": LayoutLMModel,
               "fill-mask": LayoutLMForMaskedLM,
               "text-classification": LayoutLMForSequenceClassification,
               "token-classification": LayoutLMForTokenClassification,
               "zero-shot": LayoutLMForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       SCREAMING_SNAKE_CASE_						      = True







       def 						a_		(					self) -> Optional[int]:
            snake_case_   			=   LayoutLMModelTester(self)
            snake_case_   			=   ConfigTester(self,				config_class=lowerCAmelCase__,				hidden_size=37)







       def 						a_		(					self) -> Tuple:
            self.config_tester.run_common_tests()







       def 						a_		(					self) -> Union[str, Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__)







       def 						a_		(					self) -> Union[str, Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
                 snake_case_   			=   type
                 self.model_tester.create_and_check_model(*lowerCAmelCase__)







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__)







       def 						a_		(					self) -> Union[str, Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__)







       def 						a_		(					self) -> Optional[int]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__)







       def 						a_		(					self) -> Tuple:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__)







       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
       def 						a_		(					self) -> Dict:
            pass







def    UpperCAmelCase       (						)							-> Tuple:
     # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
     # fmt: off
     snake_case_   			=   torch.tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]		,   device=UpperCAmelCase   )  # noqa: E231
     snake_case_   			=   torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]		,   device=UpperCAmelCase   )  # noqa: E231
     snake_case_   			=   torch.tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]]		,   device=UpperCAmelCase   )  # noqa: E231
     snake_case_   			=   torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]		,   device=UpperCAmelCase   )  # noqa: E231
     # these are sequence labels (i.e. at the token level)
     snake_case_   			=   torch.tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]		,   device=UpperCAmelCase   )  # noqa: E231
     # fmt: on

     return input_ids, attention_mask, bbox, token_type_ids, labels




@require_torch
class 					UpperCamelCase   (							unittest.TestCase  ):







       @slow
       def 						a_		(					self) -> Tuple:
            snake_case_   			=   LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased').to(lowerCAmelCase__)

            snake_case_			,      snake_case_			,      snake_case_			,      snake_case_			,      snake_case_   			=   prepare_layoutlm_batch_inputs()

            # forward pass
            snake_case_   			=   model(input_ids=lowerCAmelCase__,				bbox=lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__)

            # test the sequence output on [0, :3, :3]
            snake_case_   			=   torch.tensor(
                [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]],				device=lowerCAmelCase__,				)

            self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3],				lowerCAmelCase__,				atol=1e-3))

            # test the pooled output on [1, :3]
            snake_case_   			=   torch.tensor([-0.6580, -0.0214, 0.8552],				device=lowerCAmelCase__)

            self.assertTrue(torch.allclose(outputs.pooler_output[1, :3],				lowerCAmelCase__,				atol=1e-3))







       @slow
       def 						a_		(					self) -> Union[str, Any]:
            # initialize model with randomly initialized sequence classification head
            snake_case_   			=   LayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased',				num_labels=2).to(
                lowerCAmelCase__)

            snake_case_			,      snake_case_			,      snake_case_			,      snake_case_			,      snake_case_   			=   prepare_layoutlm_batch_inputs()

            # forward pass
            snake_case_   			=   model(
                input_ids=lowerCAmelCase__,				bbox=lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				labels=torch.tensor([1, 1],				device=lowerCAmelCase__),				)

            # test whether we get a loss as a scalar
            snake_case_   			=   outputs.loss
            snake_case_   			=   torch.Size([])
            self.assertEqual(loss.shape,				lowerCAmelCase__)

            # test the shape of the logits
            snake_case_   			=   outputs.logits
            snake_case_   			=   torch.Size((2, 2))
            self.assertEqual(logits.shape,				lowerCAmelCase__)







       @slow
       def 						a_		(					self) -> List[str]:
            # initialize model with randomly initialized token classification head
            snake_case_   			=   LayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased',				num_labels=13).to(
                lowerCAmelCase__)

            snake_case_			,      snake_case_			,      snake_case_			,      snake_case_			,      snake_case_   			=   prepare_layoutlm_batch_inputs()

            # forward pass
            snake_case_   			=   model(
                input_ids=lowerCAmelCase__,				bbox=lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__,				labels=lowerCAmelCase__)

            # test the loss calculation to be around 2.65
            # expected_loss = torch.tensor(2.65, device=torch_device)

            # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
            # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

            # test the shape of the logits
            snake_case_   			=   outputs.logits
            snake_case_   			=   torch.Size((2, 25, 13))
            self.assertEqual(logits.shape,				lowerCAmelCase__)







       @slow
       def 						a_		(					self) -> Union[str, Any]:
            # initialize model with randomly initialized token classification head
            snake_case_   			=   LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased').to(lowerCAmelCase__)

            snake_case_			,      snake_case_			,      snake_case_			,      snake_case_			,      snake_case_   			=   prepare_layoutlm_batch_inputs()

            # forward pass
            snake_case_   			=   model(input_ids=lowerCAmelCase__,				bbox=lowerCAmelCase__,				attention_mask=lowerCAmelCase__,				token_type_ids=lowerCAmelCase__)

            # test the shape of the logits
            snake_case_   			=   torch.Size((2, 25))
            self.assertEqual(outputs.start_logits.shape,				lowerCAmelCase__)
            self.assertEqual(outputs.end_logits.shape,				lowerCAmelCase__)


"""simple docstring"""


import posixpath
from pathlib import Path
from unittest.mock import patch

import pytest
from fsspec.implementations.local import AbstractFileSystem, LocalFileSystem, stringify_path
from fsspec.registry import _registry as _fsspec_registry




class 					UpperCamelCase   (							lowerCAmelCase__  ):
       SCREAMING_SNAKE_CASE_						      = "mock"







       def __init__(					self,				*lowerCAmelCase__,				lowerCAmelCase__,				**lowerCAmelCase__) -> Dict:
            super().__init__()
            snake_case_   			=   LocalFileSystem(*lowerCAmelCase__,				**lowerCAmelCase__)
            snake_case_   			=   Path(lowerCAmelCase__).resolve().as_posix() + '/'







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> Any:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.mkdir(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> str:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.makedirs(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__) -> Union[str, Any]:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.rmdir(lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__=True,				*lowerCAmelCase__,				**lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            snake_case_   			=   self._fs.ls(lowerCAmelCase__,				detail=lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)
            if detail:
                 return [{**info, "name": info["name"][len(self.local_root_dir) :]} for info in out]
            else:
                 return [name[len(self.local_root_dir) :] for name in out]







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> Dict:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            snake_case_   			=   dict(self._fs.info(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__))
            snake_case_   			=   out['name'][len(self.local_root_dir) :]
            return out







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> str:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.cp_file(lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> Union[str, Any]:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.rm_file(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> List[Any]:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.rm(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs._open(lowerCAmelCase__,				*lowerCAmelCase__,				**lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__) -> Tuple:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.created(lowerCAmelCase__)







       def 						a_		(					self,				lowerCAmelCase__) -> int:
            snake_case_   			=   posixpath.join(self.local_root_dir,				self._strip_protocol(lowerCAmelCase__))
            return self._fs.modified(lowerCAmelCase__)







       @classmethod
       def 						a_		(					cls,				lowerCAmelCase__) -> Any:
            snake_case_   			=   stringify_path(lowerCAmelCase__)
            if path.startswith('mock://'):
                 snake_case_   			=   path[7:]
            return path




class 					UpperCamelCase   (							lowerCAmelCase__  ):
       SCREAMING_SNAKE_CASE_						      = "tmp"
       SCREAMING_SNAKE_CASE_						      = None







       def __init__(					self,				*lowerCAmelCase__,				**lowerCAmelCase__) -> str:
            assert self.tmp_dir is not None, "TmpDirFileSystem.tmp_dir is not set"
            super().__init__(*lowerCAmelCase__,				**lowerCAmelCase__,				local_root_dir=self.tmp_dir,				auto_mkdir=lowerCAmelCase__)







       @classmethod
       def 						a_		(					cls,				lowerCAmelCase__) -> List[str]:
            snake_case_   			=   stringify_path(lowerCAmelCase__)
            if path.startswith('tmp://'):
                 snake_case_   			=   path[6:]
            return path







@pytest.fixture
def    UpperCAmelCase       (						)							-> Tuple:
     snake_case_   			=   MockFileSystem
     snake_case_   			=   TmpDirFileSystem
     yield
     del _fsspec_registry["mock"]
     del _fsspec_registry["tmp"]







@pytest.fixture
def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> Tuple:
     snake_case_   			=   tmp_path_factory.mktemp('mockfs'   )
     return MockFileSystem(local_root_dir=UpperCAmelCase		,   auto_mkdir=UpperCAmelCase   )







@pytest.fixture
def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> int:
     snake_case_   			=   tmp_path_factory.mktemp('tmpfs'   )
     with patch.object(UpperCAmelCase		,   'tmp_dir'		,   UpperCAmelCase   ):
          yield TmpDirFileSystem()

