





import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
		import faiss

@require_faiss
class 		snake_case_   (							a_						):







	'''simple docstring'''




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

			'''simple docstring'''




			__lowercase											=     tempfile.mkdtemp()
			__lowercase											=     8

			# DPR tok
			__lowercase											=     [
			    '[UNK]',
			    '[CLS]',
			    '[SEP]',
			    '[PAD]',
			    '[MASK]',
			    'want',
			    '##want',
			    '##ed',
			    'wa',
			    'un',
			    'runn',
			    '##ing',
			    ',',
			    'low',
			    'lowest',
			]
			__lowercase											=     os.path.join(self.tmpdirname					,      'dpr_tokenizer'   )
			os.makedirs(_SCREAMING_SNAKE_CASE					,      exist_ok=_SCREAMING_SNAKE_CASE   )
			__lowercase											=     os.path.join(_SCREAMING_SNAKE_CASE					,      DPR_VOCAB_FILES_NAMES['vocab_file']   )
			with open(self.vocab_file					,      'w'					,      encoding='utf-8'   ) as vocab_writer:
					vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )

			# BART tok
			__lowercase											=     [
			    'l',
			    'o',
			    'w',
			    'e',
			    'r',
			    's',
			    't',
			    'i',
			    'd',
			    'n',
			    '\u0120',
			    '\u0120l',
			    '\u0120n',
			    '\u0120lo',
			    '\u0120low',
			    'er',
			    '\u0120lowest',
			    '\u0120newer',
			    '\u0120wider',
			    '<unk>',
			]
			__lowercase											=     dict(zip(_SCREAMING_SNAKE_CASE					,      range(len(_SCREAMING_SNAKE_CASE   )   )   )   )
			__lowercase											=     ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
			__lowercase											=     {'unk_token': '<unk>'}

			__lowercase											=     os.path.join(self.tmpdirname					,      'bart_tokenizer'   )
			os.makedirs(_SCREAMING_SNAKE_CASE					,      exist_ok=_SCREAMING_SNAKE_CASE   )
			__lowercase											=     os.path.join(_SCREAMING_SNAKE_CASE					,      BART_VOCAB_FILES_NAMES['vocab_file']   )
			__lowercase											=     os.path.join(_SCREAMING_SNAKE_CASE					,      BART_VOCAB_FILES_NAMES['merges_file']   )
			with open(self.vocab_file					,      'w'					,      encoding='utf-8'   ) as fp:
					fp.write(json.dumps(_SCREAMING_SNAKE_CASE   ) + '\n'   )
			with open(self.merges_file					,      'w'					,      encoding='utf-8'   ) as fp:
					fp.write('\n'.join(_SCREAMING_SNAKE_CASE   )   )




	def    UpperCAmelCase			(						self							:     Dict   )       -> Dict:

			'''simple docstring'''




			return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname					,      'dpr_tokenizer'   )   )




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

			'''simple docstring'''




			return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname					,      'dpr_tokenizer'   )   )




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

			'''simple docstring'''




			return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname					,      'bart_tokenizer'   )   )




	def    UpperCAmelCase			(						self							:     Any   )       -> Optional[Any]:

			'''simple docstring'''




			shutil.rmtree(self.tmpdirname   )




	def    UpperCAmelCase			(						self							:     List[Any]   )       -> Optional[Any]:

			'''simple docstring'''




			__lowercase											=     Dataset.from_dict(
			    {
			        'id': ['0', '1'],
			        'text': ['foo', 'bar'],
			        'title': ['Foo', 'Bar'],
			        'embeddings': [np.ones(self.retrieval_vector_size   ), 2 * np.ones(self.retrieval_vector_size   )],
			    }   )
			dataset.add_faiss_index('embeddings'					,      string_factory='Flat'					,      metric_type=faiss.METRIC_INNER_PRODUCT   )
			return dataset




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

			'''simple docstring'''




			__lowercase											=     self.get_dummy_dataset()
			__lowercase											=     RagConfig(
			    retrieval_vector_size=self.retrieval_vector_size					,      question_encoder=DPRConfig().to_dict()					,      generator=BartConfig().to_dict()					,      )
			with patch('transformers.models.rag.retrieval_rag.load_dataset'   ) as mock_load_dataset:
					__lowercase											=     dataset
					__lowercase											=     RagRetriever(
					    _SCREAMING_SNAKE_CASE					,      question_encoder_tokenizer=self.get_dpr_tokenizer()					,      generator_tokenizer=self.get_bart_tokenizer()					,      )
			return retriever




	def    UpperCAmelCase			(						self							:     Optional[Any]					,      __lowerCamelCase							:     Union[str, Any]   )       -> Any:

			'''simple docstring'''




			__lowercase											=     self.get_dummy_dataset()
			__lowercase											=     RagConfig(
			    retrieval_vector_size=self.retrieval_vector_size					,      question_encoder=DPRConfig().to_dict()					,      generator=BartConfig().to_dict()					,      index_name='custom'					,      )
			if from_disk:
					__lowercase											=     os.path.join(self.tmpdirname					,      'dataset'   )
					__lowercase											=     os.path.join(self.tmpdirname					,      'index.faiss'   )
					dataset.get_index('embeddings'   ).save(os.path.join(self.tmpdirname					,      'index.faiss'   )   )
					dataset.drop_index('embeddings'   )
					dataset.save_to_disk(os.path.join(self.tmpdirname					,      'dataset'   )   )
					del dataset
					__lowercase											=     RagRetriever(
					    _SCREAMING_SNAKE_CASE					,      question_encoder_tokenizer=self.get_dpr_tokenizer()					,      generator_tokenizer=self.get_bart_tokenizer()					,      )
			else:
					__lowercase											=     RagRetriever(
					    _SCREAMING_SNAKE_CASE					,      question_encoder_tokenizer=self.get_dpr_tokenizer()					,      generator_tokenizer=self.get_bart_tokenizer()					,      index=CustomHFIndex(config.retrieval_vector_size					,      _SCREAMING_SNAKE_CASE   )					,      )
			return retriever




	def    UpperCAmelCase			(						self							:     List[str]   )       -> int:

			'''simple docstring'''




			__lowercase											=     Dataset.from_dict(
			    {
			        'id': ['0', '1'],
			        'text': ['foo', 'bar'],
			        'title': ['Foo', 'Bar'],
			        'embeddings': [np.ones(self.retrieval_vector_size + 1   ), 2 * np.ones(self.retrieval_vector_size + 1   )],
			    }   )
			dataset.add_faiss_index('embeddings'					,      string_factory='Flat'					,      metric_type=faiss.METRIC_INNER_PRODUCT   )

			__lowercase											=     os.path.join(self.tmpdirname					,      'hf_bert_base.hnswSQ8_correct_phi_128.c_index'   )
			dataset.save_faiss_index('embeddings'					,      index_file_name + '.index.dpr'   )
			pickle.dump(dataset['id']					,      open(index_file_name + '.index_meta.dpr'					,      'wb'   )   )

			__lowercase											=     os.path.join(self.tmpdirname					,      'psgs_w100.tsv.pkl'   )
			__lowercase											=     {sample['id']: [sample['text'], sample['title']] for sample in dataset}
			pickle.dump(_SCREAMING_SNAKE_CASE					,      open(_SCREAMING_SNAKE_CASE					,      'wb'   )   )

			__lowercase											=     RagConfig(
			    retrieval_vector_size=self.retrieval_vector_size					,      question_encoder=DPRConfig().to_dict()					,      generator=BartConfig().to_dict()					,      index_name='legacy'					,      index_path=self.tmpdirname					,      )
			__lowercase											=     RagRetriever(
			    _SCREAMING_SNAKE_CASE					,      question_encoder_tokenizer=self.get_dpr_tokenizer()					,      generator_tokenizer=self.get_bart_tokenizer()   )
			return retriever




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

			'''simple docstring'''




			__lowercase											=     1
			__lowercase											=     self.get_dummy_canonical_hf_index_retriever()
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase						,      __lowercase						,      __lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=_SCREAMING_SNAKE_CASE   )
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertEqual(len(_SCREAMING_SNAKE_CASE   )					,      2   )
			self.assertEqual(sorted(doc_dicts[0]   )					,      ['embeddings', 'id', 'text', 'title']   )
			self.assertEqual(len(doc_dicts[0]['id']   )					,      _SCREAMING_SNAKE_CASE   )
			self.assertEqual(doc_dicts[0]['id'][0]					,      '1'   )  # max inner product is reached with second doc
			self.assertEqual(doc_dicts[1]['id'][0]					,      '0'   )  # max inner product is reached with first doc
			self.assertListEqual(doc_ids.tolist()					,      [[1], [0]]   )




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

			'''simple docstring'''




			__lowercase											=     self.get_dummy_canonical_hf_index_retriever()
			with tempfile.TemporaryDirectory() as tmp_dirname:
					with patch('transformers.models.rag.retrieval_rag.load_dataset'   ) as mock_load_dataset:
							__lowercase											=     self.get_dummy_dataset()
							retriever.save_pretrained(_SCREAMING_SNAKE_CASE   )
							__lowercase											=     RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE   )
							self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
							__lowercase											=     np.array(
							    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
							__lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=1   )
							self.assertTrue(out is not None   )




	def    UpperCAmelCase			(						self							:     Dict   )       -> List[str]:

			'''simple docstring'''




			__lowercase											=     1
			__lowercase											=     self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE   )
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase						,      __lowercase						,      __lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=_SCREAMING_SNAKE_CASE   )
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertEqual(len(_SCREAMING_SNAKE_CASE   )					,      2   )
			self.assertEqual(sorted(doc_dicts[0]   )					,      ['embeddings', 'id', 'text', 'title']   )
			self.assertEqual(len(doc_dicts[0]['id']   )					,      _SCREAMING_SNAKE_CASE   )
			self.assertEqual(doc_dicts[0]['id'][0]					,      '1'   )  # max inner product is reached with second doc
			self.assertEqual(doc_dicts[1]['id'][0]					,      '0'   )  # max inner product is reached with first doc
			self.assertListEqual(doc_ids.tolist()					,      [[1], [0]]   )




	def    UpperCAmelCase			(						self							:     Dict   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE   )
			with tempfile.TemporaryDirectory() as tmp_dirname:
					retriever.save_pretrained(_SCREAMING_SNAKE_CASE   )
					__lowercase											=     RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE   )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
					__lowercase											=     np.array(
					    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
					__lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=1   )
					self.assertTrue(out is not None   )




	def    UpperCAmelCase			(						self							:     Tuple   )       -> Tuple:

			'''simple docstring'''




			__lowercase											=     1
			__lowercase											=     self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE   )
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase						,      __lowercase						,      __lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=_SCREAMING_SNAKE_CASE   )
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertEqual(len(_SCREAMING_SNAKE_CASE   )					,      2   )
			self.assertEqual(sorted(doc_dicts[0]   )					,      ['embeddings', 'id', 'text', 'title']   )
			self.assertEqual(len(doc_dicts[0]['id']   )					,      _SCREAMING_SNAKE_CASE   )
			self.assertEqual(doc_dicts[0]['id'][0]					,      '1'   )  # max inner product is reached with second doc
			self.assertEqual(doc_dicts[1]['id'][0]					,      '0'   )  # max inner product is reached with first doc
			self.assertListEqual(doc_ids.tolist()					,      [[1], [0]]   )




	def    UpperCAmelCase			(						self							:     Dict   )       -> List[str]:

			'''simple docstring'''




			__lowercase											=     self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE   )
			with tempfile.TemporaryDirectory() as tmp_dirname:
					retriever.save_pretrained(_SCREAMING_SNAKE_CASE   )
					__lowercase											=     RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE   )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
					__lowercase											=     np.array(
					    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
					__lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=1   )
					self.assertTrue(out is not None   )




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

			'''simple docstring'''




			__lowercase											=     1
			__lowercase											=     self.get_dummy_legacy_index_retriever()
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase						,      __lowercase						,      __lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=_SCREAMING_SNAKE_CASE   )
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertEqual(len(_SCREAMING_SNAKE_CASE   )					,      2   )
			self.assertEqual(sorted(doc_dicts[0]   )					,      ['text', 'title']   )
			self.assertEqual(len(doc_dicts[0]['text']   )					,      _SCREAMING_SNAKE_CASE   )
			self.assertEqual(doc_dicts[0]['text'][0]					,      'bar'   )  # max inner product is reached with second doc
			self.assertEqual(doc_dicts[1]['text'][0]					,      'foo'   )  # max inner product is reached with first doc
			self.assertListEqual(doc_ids.tolist()					,      [[1], [0]]   )




	def    UpperCAmelCase			(						self							:     Tuple   )       -> Any:

			'''simple docstring'''




			__lowercase											=     self.get_dummy_legacy_index_retriever()
			with tempfile.TemporaryDirectory() as tmp_dirname:
					retriever.save_pretrained(_SCREAMING_SNAKE_CASE   )
					__lowercase											=     RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE   )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
					__lowercase											=     np.array(
					    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
					__lowercase											=     retriever.retrieve(_SCREAMING_SNAKE_CASE					,      n_docs=1   )
					self.assertTrue(out is not None   )




	@require_torch
	@require_tokenizers
	@require_sentencepiece
	def    UpperCAmelCase			(						self							:     int   )       -> str:

			'''simple docstring'''




			import torch

			__lowercase											=     1
			__lowercase											=     self.get_dummy_canonical_hf_index_retriever()
			__lowercase											=     [[5, 7], [10, 11]]
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase											=     retriever(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE					,      prefix=retriever.config.generator.prefix					,      n_docs=_SCREAMING_SNAKE_CASE   )
			__lowercase						,      __lowercase						,      __lowercase											=     (
			    out['context_input_ids'],
			    out['context_attention_mask'],
			    out['retrieved_doc_embeds'],
			)
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      np.ndarray   )

			__lowercase											=     retriever(
			    _SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE					,      prefix=retriever.config.generator.prefix					,      n_docs=_SCREAMING_SNAKE_CASE					,      return_tensors='pt'					,      )
			__lowercase						,      __lowercase						,      __lowercase						,      __lowercase											=     (  # noqa: F841
			    out['context_input_ids'],
			    out['context_attention_mask'],
			    out['retrieved_doc_embeds'],
			    out['doc_ids'],
			)
			self.assertEqual(retrieved_doc_embeds.shape					,      (2, n_docs, self.retrieval_vector_size)   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      torch.Tensor   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      torch.Tensor   )
			self.assertIsInstance(_SCREAMING_SNAKE_CASE					,      torch.Tensor   )






	@require_torch
	@require_tokenizers
	@require_sentencepiece
	def    UpperCAmelCase			(						self							:     Tuple   )       -> Tuple:

			'''simple docstring'''




			__lowercase											=     self.get_dpr_ctx_encoder_tokenizer()
			__lowercase											=     1
			__lowercase											=     self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE   )
			retriever.set_ctx_encoder_tokenizer(_SCREAMING_SNAKE_CASE   )

			__lowercase											=     [[5, 7], [10, 11]]
			__lowercase											=     np.array(
			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]					,      dtype=np.floataa   )
			__lowercase											=     retriever(_SCREAMING_SNAKE_CASE					,      _SCREAMING_SNAKE_CASE					,      prefix=retriever.config.generator.prefix					,      n_docs=_SCREAMING_SNAKE_CASE   )

			self.assertEqual(
			    len(_SCREAMING_SNAKE_CASE   )					,      6   )  # check whether the retriever output consist of 6 attributes including tokenized docs
			self.assertEqual(
			    all(k in out for k in ('tokenized_doc_ids', 'tokenized_doc_attention_mask')   )					,      _SCREAMING_SNAKE_CASE   )  # check for doc token related keys in dictionary.







'''simple docstring'''



import colorsys

from PIL import Image  # type: ignore


def       snake_case   (	snake_case      : float					,		snake_case      : float					,		snake_case      : int			) ->  float:


    """simple docstring"""


    lowerCAmelCase 						=							x
    lowerCAmelCase 						=							y
    for step in range(snake_case			):  # noqa: B007
        lowerCAmelCase 						=							a * a - b * b + x
        lowerCAmelCase 						=							2 * a * b + y
        lowerCAmelCase 						=							a_new

        # divergence happens for all complex number with an absolute value
        # greater than 4
        if a * a + b * b > 4:
            break
    return step / (max_step - 1)


def       snake_case   (	snake_case      : float			) ->  tuple:


    """simple docstring"""


    if distance == 1:
        return (0, 0, 0)
    else:
        return (255, 255, 255)


def       snake_case   (	snake_case      : float			) ->  tuple:


    """simple docstring"""


    if distance == 1:
        return (0, 0, 0)
    else:
        return tuple(round(i * 255			) for i in colorsys.hsv_to_rgb(snake_case					,		1					,		1			)			)


def       snake_case   (	snake_case      : int = 800					,		snake_case      : int = 600					,		snake_case      : float = -0.6					,		snake_case      : float = 0					,		snake_case      : float = 3.2					,		snake_case      : int = 50					,		snake_case      : bool = True					,		) ->  Image.Image:


    """simple docstring"""


    lowerCAmelCase 						=							Image.new('RGB'					,		(image_width, image_height)			)
    lowerCAmelCase 						=							img.load()

    # loop through the image-coordinates
    for image_x in range(snake_case			):
        for image_y in range(snake_case			):
            # determine the figure-coordinates based on the image-coordinates
            lowerCAmelCase 						=							figure_width / image_width * image_height
            lowerCAmelCase 						=							figure_center_x + (image_x / image_width - 0.5) * figure_width
            lowerCAmelCase 						=							figure_center_y + (image_y / image_height - 0.5) * figure_height

            lowerCAmelCase 						=							get_distance(snake_case					,		snake_case					,		snake_case			)

            # color the corresponding pixel based on the selected coloring-function
            if use_distance_color_coding:
                lowerCAmelCase 						=							get_color_coded_rgb(snake_case			)
            else:
                lowerCAmelCase 						=							get_black_and_white_rgb(snake_case			)

    return img


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # colored version, full figure
     _UpperCamelCase						:  Dict							       =				get_image()

     # uncomment for colored version, different section, zoomed in
     # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4,
     # figure_width = 0.8)

     # uncomment for black and white version, full figure
     # img = get_image(use_distance_color_coding = False)

     # uncomment to save the image
     # img.save("mandelbrot.png")

     img.show()





