




import time
from dataclasses import dataclass
from multiprocessing import Pool
from unittest import TestCase
from unittest.mock import patch

import multiprocess
import numpy as np
import pytest

from datasets.utils.py_utils import (
    NestedDataStructure,
    asdict,
    iflatmap_unordered,
    map_nested,
    temp_seed,
    temporary_assignment,
    zip_dict,
)

from .utils import require_tf, require_torch




def 					lowerCamelCase__       (						A__       :					List[str]	):  # picklable for multiprocessing





       '''simple docstring'''



       return x.sum()




def 					lowerCamelCase__       (						A__       :					Dict	):  # picklable for multiprocessing





       '''simple docstring'''



       return i + 1





@dataclass
class     lowerCamelCase__:
      UpperCAmelCase__      :	int
      UpperCAmelCase__      :	str





class     lowerCamelCase__(					__lowerCamelCase):
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase   =						{}
             __lowerCamelCase   =						[]
             __lowerCamelCase   =						1
             __lowerCamelCase   =						[1, 2]
             __lowerCamelCase   =						{"""a""": 1, """b""": 2}
             __lowerCamelCase   =						{"""a""": [1, 2], """b""": [3, 4]}
             __lowerCamelCase   =						{"""a""": {"""1""": 1}, """b""": 2}
             __lowerCamelCase   =						{"""a""": 1, """b""": 2, """c""": 3, """d""": 4}
             __lowerCamelCase   =						{}
             __lowerCamelCase   =						[]
             __lowerCamelCase   =						2
             __lowerCamelCase   =						[2, 3]
             __lowerCamelCase   =						{"""a""": 2, """b""": 3}
             __lowerCamelCase   =						{"""a""": [2, 3], """b""": [4, 5]}
             __lowerCamelCase   =						{"""a""": {"""1""": 2}, """b""": 3}
             __lowerCamelCase   =						{"""a""": 2, """b""": 3, """c""": 4, """d""": 5}
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_   )    ,       UpperCamelCase_   )

             __lowerCamelCase   =						2
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )

             __lowerCamelCase   =						{"""a""": np.eye(2   ), """b""": np.zeros(3   ), """c""": np.ones(2   )}
             __lowerCamelCase   =						{"""a""": 2, """b""": 0, """c""": 2}
             __lowerCamelCase   =						{
                 """a""": np.eye(2   ).astype(UpperCamelCase_   ),
                 """b""": np.zeros(3   ).astype(UpperCamelCase_   ),
                 """c""": np.ones(2   ).astype(UpperCamelCase_   ),
             }
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       map_numpy=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(
                 {k: v.tolist() for k, v in map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       map_numpy=UpperCamelCase_   ).items()}    ,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}    ,       )
             self.assertEqual(map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       map_numpy=UpperCamelCase_    ,       num_proc=UpperCamelCase_   )    ,       UpperCamelCase_   )
             self.assertEqual(
                 {k: v.tolist() for k, v in map_nested(UpperCamelCase_    ,       UpperCamelCase_    ,       map_numpy=UpperCamelCase_    ,       num_proc=UpperCamelCase_   ).items()}    ,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}    ,       )
             with self.assertRaises(UpperCamelCase_   ):  # can't pickle a local lambda
                    map_nested(lambda UpperCamelCase_   : x + 1    ,       UpperCamelCase_    ,       num_proc=UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Union[str, Any]   ):
             __lowerCamelCase   =						{"""a""": 1, """b""": 2}
             __lowerCamelCase   =						{"""a""": 3, """b""": 4}
             __lowerCamelCase   =						{"""a""": 5, """b""": 6}
             __lowerCamelCase   =						sorted([("""a""", (1, 3, 5)), ("""b""", (2, 4, 6))]   )
             self.assertEqual(sorted(zip_dict(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_   )   )    ,       UpperCamelCase_   )




      def 			lowerCAmelCase__						(				self: int   ):





             class     lowerCamelCase__:
                   UpperCAmelCase__      :	Optional[int]    		=   'bar'



             __lowerCamelCase   =						Foo()
             self.assertEqual(foo.my_attr    ,       """bar"""   )
             with temporary_assignment(UpperCamelCase_    ,       """my_attr"""    ,       """BAR"""   ):
                    self.assertEqual(foo.my_attr    ,       """BAR"""   )
             self.assertEqual(foo.my_attr    ,       """bar"""   )




@pytest.mark.parametrize(
    """iterable_length, num_proc, expected_num_proc"""  ,			[
        (1, None, 1),
        (1, 1, 1),
        (2, None, 1),
        (2, 1, 1),
        (2, 2, 1),
        (2, 3, 1),
        (3, 2, 1),
        (16, 16, 16),
        (16, 17, 16),
        (17, 16, 16),
    ]  ,			)
def 					lowerCamelCase__       (						A__       :					List[str]  ,			A__       :					Tuple  ,			A__       :					int	):





       '''simple docstring'''



       with patch("""datasets.utils.py_utils._single_map_nested"""	) as mock_single_map_nested, patch(
           """datasets.parallel.parallel.Pool"""	) as mock_multiprocessing_pool:
              __lowerCamelCase   =						{f'{i}': i for i in range(A__	)}
              __lowerCamelCase   =						map_nested(lambda A__	: x + 10  ,			A__  ,			num_proc=A__  ,			parallel_min_length=16	)
              if expected_num_proc == 1:
                     assert mock_single_map_nested.called
                     assert not mock_multiprocessing_pool.called
              else:
                     assert not mock_single_map_nested.called
                     assert mock_multiprocessing_pool.called
                     assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc





class     lowerCamelCase__(					__lowerCamelCase):
      @require_tf
      def 			lowerCAmelCase__						(				self: Any   ):
             import tensorflow as tf
             from tensorflow.keras import layers

             __lowerCamelCase   =						layers.Dense(2   )

             def gen_random_output():
                    __lowerCamelCase   =						tf.random.uniform((1, 3)   )
                    return model(UpperCamelCase_   ).numpy()

             with temp_seed(42    ,       set_tensorflow=UpperCamelCase_   ):
                    __lowerCamelCase   =						gen_random_output()
             with temp_seed(42    ,       set_tensorflow=UpperCamelCase_   ):
                    __lowerCamelCase   =						gen_random_output()
             __lowerCamelCase   =						gen_random_output()

             np.testing.assert_equal(UpperCamelCase_    ,       UpperCamelCase_   )
             self.assertGreater(np.abs(outa - outa   ).sum()    ,       0   )
      @require_torch
      def 			lowerCAmelCase__						(				self: Any   ):
             import torch

             def gen_random_output():
                    __lowerCamelCase   =						torch.nn.Linear(3    ,       2   )
                    __lowerCamelCase   =						torch.rand(1    ,       3   )
                    return model(UpperCamelCase_   ).detach().numpy()

             with temp_seed(42    ,       set_pytorch=UpperCamelCase_   ):
                    __lowerCamelCase   =						gen_random_output()
             with temp_seed(42    ,       set_pytorch=UpperCamelCase_   ):
                    __lowerCamelCase   =						gen_random_output()
             __lowerCamelCase   =						gen_random_output()

             np.testing.assert_equal(UpperCamelCase_    ,       UpperCamelCase_   )
             self.assertGreater(np.abs(outa - outa   ).sum()    ,       0   )




      def 			lowerCAmelCase__						(				self: Any   ):
             def gen_random_output():
                    return np.random.rand(1    ,       3   )

             with temp_seed(42   ):
                    __lowerCamelCase   =						gen_random_output()
             with temp_seed(42   ):
                    __lowerCamelCase   =						gen_random_output()
             __lowerCamelCase   =						gen_random_output()

             np.testing.assert_equal(UpperCamelCase_    ,       UpperCamelCase_   )
             self.assertGreater(np.abs(outa - outa   ).sum()    ,       0   )




@pytest.mark.parametrize("""input_data"""  ,			[{}]	)
def 					lowerCamelCase__       (						A__       :					Dict	):





       '''simple docstring'''



       __lowerCamelCase   =						NestedDataStructure(A__	).data
       assert output_data == input_data




@pytest.mark.parametrize(
    """data, expected_output"""  ,			[
        ({}, []),
        ([], []),
        ("""foo""", ["""foo"""]),
        (["""foo""", """bar"""], ["""foo""", """bar"""]),
        ([["""foo""", """bar"""]], ["""foo""", """bar"""]),
        ([[["""foo"""], ["""bar"""]]], ["""foo""", """bar"""]),
        ([[["""foo"""], """bar"""]], ["""foo""", """bar"""]),
        ({"""a""": 1, """b""": 2}, [1, 2]),
        ({"""a""": [1, 2], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[1, 2]], """b""": [[3, 4]]}, [1, 2, 3, 4]),
        ({"""a""": [[1, 2]], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [[[3], [4]]]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [[3, 4]]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [3, [4]]}, [1, 2, 3, 4]),
        ({"""a""": {"""1""": 1}, """b""": 2}, [1, 2]),
        ({"""a""": {"""1""": [1]}, """b""": 2}, [1, 2]),
        ({"""a""": {"""1""": [1]}, """b""": [2]}, [1, 2]),
    ]  ,			)
def 					lowerCamelCase__       (						A__       :					Dict  ,			A__       :					Optional[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						NestedDataStructure(A__	).flatten()
       assert output == expected_output




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       __lowerCamelCase   =						A(x=1  ,			y="""foobar"""	)
       __lowerCamelCase   =						{"""x""": 1, """y""": """foobar"""}
       assert asdict(A__	) == expected_output

       __lowerCamelCase   =						{"""a""": {"""b""": A(x=10  ,			y="""foo"""	)}, """c""": [A(x=20  ,			y="""bar"""	)]}
       __lowerCamelCase   =						{"""a""": {"""b""": {"""x""": 10, """y""": """foo"""}}, """c""": [{"""x""": 20, """y""": """bar"""}]}
       assert asdict(A__	) == expected_output

       with pytest.raises(A__	):
              asdict([1, A(x=10  ,			y="""foo"""	)]	)




def 					lowerCamelCase__       (						A__       :					str	):





       '''simple docstring'''



       return text.split()




def 					lowerCamelCase__       (						A__       :					Any	):





       '''simple docstring'''



       yield (time.time(), content)
       time.sleep(2	)
       yield (time.time(), content)




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       with Pool(2	) as pool:
              __lowerCamelCase   =						list(iflatmap_unordered(A__  ,			_split_text  ,			kwargs_iterable=[{"""text""": """hello there"""}] * 10	)	)
              assert out.count("""hello"""	) == 10
              assert out.count("""there"""	) == 10
              assert len(A__	) == 20

       # check multiprocess from pathos (uses dill for pickling)
       with multiprocess.Pool(2	) as pool:
              __lowerCamelCase   =						list(iflatmap_unordered(A__  ,			_split_text  ,			kwargs_iterable=[{"""text""": """hello there"""}] * 10	)	)
              assert out.count("""hello"""	) == 10
              assert out.count("""there"""	) == 10
              assert len(A__	) == 20

       # check that we get items as fast as possible
       with Pool(2	) as pool:
              __lowerCamelCase   =						[]
              for yield_time, content in iflatmap_unordered(
                  A__  ,			_aseconds_generator_of_aitems_with_timing  ,			kwargs_iterable=[{"""content""": """a"""}, {"""content""": """b"""}]	):
                     assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded"
                     out.append(A__	)
              assert out.count("""a"""	) == 2
              assert out.count("""b"""	) == 2
              assert len(A__	) == 4







# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


UpperCAmelCase_									=	get_logger(__name__)





class     lowerCamelCase__:
      UpperCAmelCase__      :	List[Any]    		=   'dummy_data'
      UpperCAmelCase__      :	str    		=   'datasets'
      UpperCAmelCase__      :	Tuple    		=   False
      def __init__(				self: Optional[Any]    ,       UpperCamelCase_: str    ,       UpperCamelCase_: str    ,       UpperCamelCase_: Union[Version, str]    ,       UpperCamelCase_: Optional[str] = None    ,       UpperCamelCase_: bool = False    ,       UpperCamelCase_: bool = True    ,       UpperCamelCase_: Optional[List[Callable]] = None    ,       ):
             __lowerCamelCase   =						0
             __lowerCamelCase   =						dataset_name
             __lowerCamelCase   =						cache_dir
             __lowerCamelCase   =						use_local_dummy_data
             __lowerCamelCase   =						config
             # download_callbacks take a single url as input
             __lowerCamelCase   =						download_callbacks or []
             # if False, it doesn't load existing files and it returns the paths of the dummy files relative
             # to the dummy_data zip file root
             __lowerCamelCase   =						load_existing_dummy_data

             # TODO(PVP, QL) might need to make this more general
             __lowerCamelCase   =						str(UpperCamelCase_   )
             # to be downloaded
             __lowerCamelCase   =						None
             __lowerCamelCase   =						None
      @property
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             if self._dummy_file is None:
                    __lowerCamelCase   =						self.download_dummy_data()
             return self._dummy_file
      @property
      def 			lowerCAmelCase__						(				self: str   ):
             if self.config is not None:
                    # structure is dummy / config_name / version_name
                    return os.path.join("""dummy"""    ,       self.config.name    ,       self.version_name   )
             # structure is dummy / version_name
             return os.path.join("""dummy"""    ,       self.version_name   )
      @property
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             return os.path.join(self.dummy_data_folder    ,       """dummy_data.zip"""   )
      def 			lowerCAmelCase__						(				self: Any   ):
             __lowerCamelCase   =						(
                 self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
             )

             __lowerCamelCase   =						cached_path(
                 UpperCamelCase_    ,       cache_dir=self.cache_dir    ,       extract_compressed_file=UpperCamelCase_    ,       force_extract=UpperCamelCase_   )

             return os.path.join(UpperCamelCase_    ,       self.dummy_file_name   )
      @property
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             return os.path.join(self.datasets_scripts_dir    ,       self.dataset_name    ,       self.dummy_zip_file   )
      @property
      def 			lowerCAmelCase__						(				self: Tuple   ):
             if self._bucket_url is None:
                    __lowerCamelCase   =						hf_github_url(self.dataset_name    ,       self.dummy_zip_file.replace(os.sep    ,       """/"""   )   )
             return self._bucket_url
      @property
      def 			lowerCAmelCase__						(				self: str   ):
             # return full path if its a dir
             if os.path.isdir(self.dummy_file   ):
                    return self.dummy_file
             # else cut off path to file -> example `xsum`.
             return "/".join(self.dummy_file.replace(os.sep    ,       """/"""   ).split("""/"""   )[:-1]   )
      def 			lowerCAmelCase__						(				self: List[str]    ,       UpperCamelCase_: Dict    ,       *UpperCamelCase_: str   ):
             if self.load_existing_dummy_data:
                    # dummy data is downloaded and tested
                    __lowerCamelCase   =						self.dummy_file
             else:
                    # dummy data cannot be downloaded and only the path to dummy file is returned
                    __lowerCamelCase   =						self.dummy_file_name

             # special case when data_url is a dict
             if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                    return self.create_dummy_data_dict(UpperCamelCase_    ,       UpperCamelCase_   )
             elif isinstance(UpperCamelCase_    ,       (list, tuple)   ):
                    return self.create_dummy_data_list(UpperCamelCase_    ,       UpperCamelCase_   )
             else:
                    return self.create_dummy_data_single(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Any    ,       UpperCamelCase_: Optional[Any]    ,       *UpperCamelCase_: str   ):
             return self.download_and_extract(UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: List[Any]    ,       UpperCamelCase_: Tuple    ,       UpperCamelCase_: str   ):
             return self.download_and_extract(UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: str    ,       UpperCamelCase_: int    ,       *UpperCamelCase_: List[str]    ,       **UpperCamelCase_: str   ):
             return path
      def 			lowerCAmelCase__						(				self: Dict   ):
             return {}
      def 			lowerCAmelCase__						(				self: str    ,       UpperCamelCase_: List[Any]    ,       UpperCamelCase_: Union[str, Any]   ):
             __lowerCamelCase   =						{}
             for key, single_urls in data_url.items():
                    for download_callback in self.download_callbacks:
                           if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                                  for single_url in single_urls:
                                         download_callback(UpperCamelCase_   )
                           else:
                                  __lowerCamelCase   =						single_urls
                                  download_callback(UpperCamelCase_   )
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
                    if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                           __lowerCamelCase   =						[os.path.join(UpperCamelCase_    ,       urllib.parse.quote_plus(Path(UpperCamelCase_   ).name   )   ) for x in single_urls]
                    else:
                           __lowerCamelCase   =						single_urls
                           __lowerCamelCase   =						os.path.join(UpperCamelCase_    ,       urllib.parse.quote_plus(Path(UpperCamelCase_   ).name   )   )
                    __lowerCamelCase   =						value

             # make sure that values are unique
             if all(isinstance(UpperCamelCase_    ,       UpperCamelCase_   ) for i in dummy_data_dict.values()   ) and len(set(dummy_data_dict.values()   )   ) < len(
                 dummy_data_dict.values()   ):
                    # append key to value to make its name unique
                    __lowerCamelCase   =						{key: value + key for key, value in dummy_data_dict.items()}

             return dummy_data_dict
      def 			lowerCAmelCase__						(				self: Optional[Any]    ,       UpperCamelCase_: Optional[Any]    ,       UpperCamelCase_: Optional[int]   ):
             __lowerCamelCase   =						[]
             # trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
             __lowerCamelCase   =						all(bool(re.findall("""[0-9]{3,}-of-[0-9]{3,}"""    ,       UpperCamelCase_   )   ) for url in data_url   )
             __lowerCamelCase   =						all(
                 url.startswith("""https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed"""   ) for url in data_url   )
             if data_url and (is_tf_records or is_pubmed_records):
                    __lowerCamelCase   =						[data_url[0]] * len(UpperCamelCase_   )
             for single_url in data_url:
                    for download_callback in self.download_callbacks:
                           download_callback(UpperCamelCase_   )
                    # we force the name of each key to be the last file / folder name of the url path
                    # if the url has arguments, we need to encode them with urllib.parse.quote_plus
                    __lowerCamelCase   =						os.path.join(UpperCamelCase_    ,       urllib.parse.quote_plus(single_url.split("""/"""   )[-1]   )   )
                    dummy_data_list.append(UpperCamelCase_   )
             return dummy_data_list
      def 			lowerCAmelCase__						(				self: Tuple    ,       UpperCamelCase_: Optional[int]    ,       UpperCamelCase_: Optional[Any]   ):
             for download_callback in self.download_callbacks:
                    download_callback(UpperCamelCase_   )
             # we force the name of each key to be the last file / folder name of the url path
             # if the url has arguments, we need to encode them with urllib.parse.quote_plus
             __lowerCamelCase   =						os.path.join(UpperCamelCase_    ,       urllib.parse.quote_plus(data_url.split("""/"""   )[-1]   )   )
             if os.path.exists(UpperCamelCase_   ) or not self.load_existing_dummy_data:
                    return value
             else:
                    # Backward compatibility, maybe deprecate at one point.
                    # For many datasets with single url calls to dl_manager.download_and_extract,
                    # the dummy_data.zip file is actually the zipped downloaded file
                    # while now we expected the dummy_data.zip file to be a directory containing
                    # the downloaded file.
                    return path_to_dummy_data
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             pass
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             pass
      def 			lowerCAmelCase__						(				self: Any    ,       UpperCamelCase_: Dict   ):
             def _iter_archive_members(UpperCamelCase_: Any   ):
                    # this preserves the order of the members inside the ZIP archive
                    __lowerCamelCase   =						Path(self.dummy_file   ).parent
                    __lowerCamelCase   =						path.relative_to(UpperCamelCase_   )
                    with ZipFile(self.local_path_to_dummy_data   ) as zip_file:
                           __lowerCamelCase   =						zip_file.namelist()
                    for member in members:
                           if member.startswith(relative_path.as_posix()   ):
                                  yield dummy_parent_path.joinpath(UpperCamelCase_   )

             __lowerCamelCase   =						Path(UpperCamelCase_   )
             __lowerCamelCase   =						_iter_archive_members(UpperCamelCase_   ) if self.use_local_dummy_data else path.rglob("""*"""   )
             for file_path in file_paths:
                    if file_path.is_file() and not file_path.name.startswith((""".""", """__""")   ):
                           yield file_path.relative_to(UpperCamelCase_   ).as_posix(), file_path.open("""rb"""   )




      def 			lowerCAmelCase__						(				self: List[str]    ,       UpperCamelCase_: Dict   ):
             if not isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                    __lowerCamelCase   =						[paths]
             for path in paths:
                    if os.path.isfile(UpperCamelCase_   ):
                           if os.path.basename(UpperCamelCase_   ).startswith((""".""", """__""")   ):
                                  return
                           yield path
                    else:
                           for dirpath, dirnames, filenames in os.walk(UpperCamelCase_   ):
                                  if os.path.basename(UpperCamelCase_   ).startswith((""".""", """__""")   ):
                                         continue
                                  dirnames.sort()
                                  for filename in sorted(UpperCamelCase_   ):
                                         if filename.startswith((""".""", """__""")   ):
                                                continue
                                         yield os.path.join(UpperCamelCase_    ,       UpperCamelCase_   )

