






"""simple docstring"""







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

import pytest
import zstandard as zstd

from datasets.download.download_config import DownloadConfig
from datasets.utils.file_utils import (
    OfflineModeIsEnabled,
    cached_path,
    fsspec_get,
    fsspec_head,
    ftp_get,
    ftp_head,
    get_from_cache,
    http_get,
    http_head,
)


_UpperCamelCase					      =  """\
    Text data.
    Second line of data."""

_UpperCamelCase					      =  """file"""

@pytest.fixture(scope="""session"""							)
def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	tmp_path_factory.mktemp("""data"""							) / (FILE_PATH + """.zstd""")
      UpperCAmelCase          =	bytes(_snake_case				,	"""utf-8"""							)
      with zstd.open(_snake_case				,	"""wb"""							) as f:
            f.write(_snake_case							)
      return path

@pytest.fixture
def _a			(		_snake_case							):







      """simple docstring"""






      with open(os.path.join(tmpfs.local_root_dir				,	_snake_case							)				,	"""w"""							) as f:
            f.write(_snake_case							)
      return FILE_PATH

@pytest.mark.parametrize("""compression_format"""				,	["""gzip""", """xz""", """zstd"""]							)
def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	{"""gzip""": gz_file, """xz""": xz_file, """zstd""": zstd_path}
      UpperCAmelCase          =	input_paths[compression_format]
      UpperCAmelCase          =	tmp_path / """cache"""
      UpperCAmelCase          =	DownloadConfig(cache_dir=_snake_case				,	extract_compressed_file=_snake_case							)
      UpperCAmelCase          =	cached_path(_snake_case				,	download_config=_snake_case							)
      with open(_snake_case							) as f:
            UpperCAmelCase          =	f.read()
      with open(_snake_case							) as f:
            UpperCAmelCase          =	f.read()
      assert extracted_file_content == expected_file_content

@pytest.mark.parametrize("""default_extracted"""				,	[True, False]							)
@pytest.mark.parametrize("""default_cache_dir"""				,	[True, False]							)
def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	"""custom_cache"""
      UpperCAmelCase          =	"""custom_extracted_dir"""
      UpperCAmelCase          =	tmp_path / """custom_extracted_path"""
      if default_extracted:
            UpperCAmelCase          =	("""downloads""" if default_cache_dir else custom_cache_dir, """extracted""")
      else:
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_DIR"""				,	_snake_case							)
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_PATH"""				,	str(_snake_case							)							)
            UpperCAmelCase          =	custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

      UpperCAmelCase          =	xz_file
      UpperCAmelCase          =	(
          DownloadConfig(extract_compressed_file=_snake_case							)
          if default_cache_dir
          else DownloadConfig(cache_dir=tmp_path / custom_cache_dir				,	extract_compressed_file=_snake_case							)
      )
      UpperCAmelCase          =	cached_path(_snake_case				,	download_config=_snake_case							)
      assert Path(_snake_case							).parent.parts[-2:] == expected

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	str(Path(_snake_case							).resolve()							)
      assert cached_path(_snake_case							) == text_file
      # relative path
      UpperCAmelCase          =	str(Path(_snake_case							).resolve().relative_to(Path(os.getcwd()							)							)							)
      assert cached_path(_snake_case							) == text_file

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	str(tmp_path.resolve() / """__missing_file__.txt"""							)
      with pytest.raises(_snake_case							):
            cached_path(_snake_case							)
      # relative path
      UpperCAmelCase          =	"""./__missing_file__.txt"""
      with pytest.raises(_snake_case							):
            cached_path(_snake_case							)

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	get_from_cache(F'''tmp://{tmpfs_file}'''							)
      with open(_snake_case							) as f:
            UpperCAmelCase          =	f.read()
      assert output_file_content == FILE_CONTENT

@patch("""datasets.config.HF_DATASETS_OFFLINE"""				,	_snake_case							)
def _a			(		):







      """simple docstring"""






      with pytest.raises(_snake_case							):
            cached_path("""https://huggingface.co"""							)

@patch("""datasets.config.HF_DATASETS_OFFLINE"""				,	_snake_case							)
def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	tmp_path_factory.mktemp("""data"""							) / """file.html"""
      with pytest.raises(_snake_case							):
            http_get("""https://huggingface.co"""				,	temp_file=_snake_case							)
      with pytest.raises(_snake_case							):
            http_head("""https://huggingface.co"""							)

@patch("""datasets.config.HF_DATASETS_OFFLINE"""				,	_snake_case							)
def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	tmp_path_factory.mktemp("""data"""							) / """file.html"""
      with pytest.raises(_snake_case							):
            ftp_get("""ftp://huggingface.co"""				,	temp_file=_snake_case							)
      with pytest.raises(_snake_case							):
            ftp_head("""ftp://huggingface.co"""							)






@patch("""datasets.config.HF_DATASETS_OFFLINE"""				,	_snake_case							)
def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	tmp_path_factory.mktemp("""data"""							) / """file.html"""
      with pytest.raises(_snake_case							):
            fsspec_get("""s3://huggingface.co"""				,	temp_file=_snake_case							)
      with pytest.raises(_snake_case							):
            fsspec_head("""s3://huggingface.co"""							)











"""simple docstring"""







from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

_UpperCamelCase					      =  {"""UserAgent""": UserAgent().random}

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	script.contents[0]
      UpperCAmelCase          =	json.loads(data[data.find("""{\"config\""""							) : -1]							)
      return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]







class  lowerCamelCase__ :






    def __init__(			self     ,A ):
          UpperCAmelCase          =	F'''https://www.instagram.com/{username}/'''
          UpperCAmelCase          =	self.get_json()






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	requests.get(self.url     ,headers=A ).text
          UpperCAmelCase          =	BeautifulSoup(A     ,"""html.parser""" ).find_all("""script""" )
          try:
                return extract_user_profile(scripts[4] )
          except (json.decoder.JSONDecodeError, KeyError):
                return extract_user_profile(scripts[3] )






    def __repr__(			self ):
          return F'''{self.__class__.__name__}(\'{self.username}\')'''






    def __str__(			self ):
          return F'''{self.fullname} ({self.username}) is {self.biography}'''






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["username"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["full_name"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["biography"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["business_email"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["external_url"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["edge_followed_by"]["count"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["edge_follow"]["count"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["edge_owner_to_timeline_media"]["count"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["profile_pic_url_hd"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["is_verified"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["is_private"]







def _a			(		_snake_case = "github"							):







      """simple docstring"""






      import os

      if os.environ.get("""CI"""							):
            return  # test failing on GitHub Actions
      UpperCAmelCase          =	InstagramUser(_snake_case							)
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data				,	_snake_case							)
      assert instagram_user.username == username
      if username != "github":
            return
      assert instagram_user.fullname == "GitHub"
      assert instagram_user.biography == "Built for developers."
      assert instagram_user.number_of_posts > 150
      assert instagram_user.number_of_followers > 12_0000
      assert instagram_user.number_of_followings > 15
      assert instagram_user.email == "support@github.com"
      assert instagram_user.website == "https://github.com/readme"
      assert instagram_user.profile_picture_url.startswith("""https://instagram."""							)
      assert instagram_user.is_verified is True
      assert instagram_user.is_private is False


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  _UpperCamelCase					      =  InstagramUser("""github""")
  print(instagram_user)
  print(F"""{instagram_user.number_of_posts = }""")
  print(F"""{instagram_user.number_of_followers = }""")
  print(F"""{instagram_user.number_of_followings = }""")
  print(F"""{instagram_user.email = }""")
  print(F"""{instagram_user.website = }""")
  print(F"""{instagram_user.profile_picture_url = }""")
  print(F"""{instagram_user.is_verified = }""")
  print(F"""{instagram_user.is_private = }""")



