





def   a_    ( lowerCAmelCase_      :			int	):
   __lowerCAmelCase								=	[[0 for _ in range(lowerCAmelCase_	)] for _ in range(m + 1	)]
   for i in range(m + 1	):
      __lowerCAmelCase								=	1

   for n in range(m + 1	):
      for k in range(1,	lowerCAmelCase_	):
         memo[n][k] += memo[n][k - 1]
         if n - k > 0:
            memo[n][k] += memo[n - k - 1][k]

   return memo[m][m - 1]


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          try:
               _snake_case  :    List[str]						    =  int(input('Enter a number: ').strip())
               print(partition(n))
          except ValueError:
               print('Please enter a number.')
     else:
          try:
               _snake_case  :    Optional[Any]						    =  int(sys.argv[1])
               print(partition(n))
          except ValueError:
               print('Please pass a number.')








import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


_snake_case  :    Dict						    =  pytest.mark.integration



@require_faiss
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		List[Any]     )							->						Optional[Any]:
     __lowerCAmelCase								=	Dataset.from_dict({'filename': ['my_name-train' + '_' + str(lowerCAmelCase_     ) for x in np.arange(3_0     ).tolist()]}     )
     return dset






  def 				lowercase		(				self :		List[str]     )							->						Tuple:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     __lowerCAmelCase								=	dset.map(
         lambda lowerCAmelCase_					,  lowerCAmelCase_     : {"vecs": i * np.ones(5					,  dtype=np.floataa     )}					,  with_indices=lowerCAmelCase_					,  keep_in_memory=lowerCAmelCase_     )
     __lowerCAmelCase								=	dset.add_faiss_index('vecs'					,  batch_size=1_0_0					,  metric_type=faiss.METRIC_INNER_PRODUCT     )
     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )
     dset.drop_index('vecs'     )






  def 				lowercase		(				self :		Optional[Any]     )							->						str:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'					,  batch_size=1_0_0					,  metric_type=faiss.METRIC_INNER_PRODUCT					,  )
     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )






  def 				lowercase		(				self :		int     )							->						Optional[Any]:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'					,  metric_type=faiss.METRIC_INNER_PRODUCT					,  )

     # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
     # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
     # see https://bugs.python.org/issue14243 and
     # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
     with tempfile.NamedTemporaryFile(delete=lowerCAmelCase_     ) as tmp_file:
        dset.save_faiss_index('vecs'					,  tmp_file.name     )
        dset.load_faiss_index('vecs2'					,  tmp_file.name     )
     os.unlink(tmp_file.name     )

     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs2'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						List[Any]:
     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'     )
     dset.drop_index('vecs'     )
     self.assertRaises(lowerCAmelCase_					,  partial(dset.get_nearest_examples					,  'vecs2'					,  np.ones(5					,  dtype=np.floataa     )     )     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						Tuple:
     from elasticsearch import Elasticsearch

     __lowerCAmelCase								=	self._create_dummy_dataset()
     with patch('elasticsearch.Elasticsearch.search'     ) as mocked_search, patch(
         'elasticsearch.client.IndicesClient.create'     ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'     ) as mocked_bulk:
        __lowerCAmelCase								=	{'acknowledged': True}
        mocked_bulk.return_value([(True, None)] * 3_0     )
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 2_9}]}}
        __lowerCAmelCase								=	Elasticsearch()

        dset.add_elasticsearch_index('filename'					,  es_client=lowerCAmelCase_     )
        __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('filename'					,  'my_name-train_29'     )
        self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )





@require_faiss
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		str     )							->						int:
     import faiss

     __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT     )

     # add vectors
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsNotNone(index.faiss_index     )
     self.assertEqual(index.faiss_index.ntotal					,  5     )
     index.add_vectors(np.zeros((5, 5)					,  dtype=np.floataa     )     )
     self.assertEqual(index.faiss_index.ntotal					,  1_0     )

     # single query
     __lowerCAmelCase								=	np.zeros(5					,  dtype=np.floataa     )
     __lowerCAmelCase								=	1
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
     self.assertRaises(lowerCAmelCase_					,  index.search					,  query.reshape(-1					,  1     )     )
     self.assertGreater(scores[0]					,  0     )
     self.assertEqual(indices[0]					,  1     )

     # batched queries
     __lowerCAmelCase								=	np.eye(5					,  dtype=np.floataa     )[::-1]
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_     )
     self.assertRaises(lowerCAmelCase_					,  index.search_batch					,  queries[0]     )
     __lowerCAmelCase								=	[scores[0] for scores in total_scores]
     __lowerCAmelCase								=	[indices[0] for indices in total_indices]
     self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
     self.assertListEqual([4, 3, 2, 1, 0]					,  lowerCAmelCase_     )






  def 				lowercase		(				self :		List[Any]     )							->						List[str]:
     import faiss

     __lowerCAmelCase								=	FaissIndex(string_factory='Flat'     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexFlat     )
     __lowerCAmelCase								=	FaissIndex(string_factory='LSH'     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexLSH     )
     with self.assertRaises(lowerCAmelCase_     ):
        __lowerCAmelCase								=	FaissIndex(string_factory='Flat'					,  custom_index=faiss.IndexFlat(5     )     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						Dict:
     import faiss

     __lowerCAmelCase								=	faiss.IndexFlat(5     )
     __lowerCAmelCase								=	FaissIndex(custom_index=lowerCAmelCase_     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexFlat     )






  def 				lowercase		(				self :		str     )							->						Any:
     import faiss

     __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )

     # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
     # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
     # see https://bugs.python.org/issue14243 and
     # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
     with tempfile.NamedTemporaryFile(delete=lowerCAmelCase_     ) as tmp_file:
        index.save(tmp_file.name     )
        __lowerCAmelCase								=	FaissIndex.load(tmp_file.name     )
     os.unlink(tmp_file.name     )

     __lowerCAmelCase								=	np.zeros(5					,  dtype=np.floataa     )
     __lowerCAmelCase								=	1
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
     self.assertGreater(scores[0]					,  0     )
     self.assertEqual(indices[0]					,  1     )





@require_faiss
def   a_    ( lowerCAmelCase_      :			Union[str, Any]	):
   import faiss

   __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT	)
   index.add_vectors(np.eye(5,	dtype=np.floataa	)	)

   __lowerCAmelCase								=	'index.faiss'
   __lowerCAmelCase								=	F"""mock://{index_name}"""
   index.save(lowerCAmelCase_,	storage_options=mockfs.storage_options	)
   __lowerCAmelCase								=	FaissIndex.load(lowerCAmelCase_,	storage_options=mockfs.storage_options	)

   __lowerCAmelCase								=	np.zeros(5,	dtype=np.floataa	)
   __lowerCAmelCase								=	1
   __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_	)
   assert scores[0] > 0
   assert indices[0] == 1




@require_elasticsearch
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		Any     )							->						int:
     from elasticsearch import Elasticsearch

     with patch('elasticsearch.Elasticsearch.search'     ) as mocked_search, patch(
         'elasticsearch.client.IndicesClient.create'     ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'     ) as mocked_bulk:
        __lowerCAmelCase								=	Elasticsearch()
        __lowerCAmelCase								=	{'acknowledged': True}
        __lowerCAmelCase								=	ElasticSearchIndex(es_client=lowerCAmelCase_     )
        mocked_bulk.return_value([(True, None)] * 3     )
        index.add_documents(['foo', 'bar', 'foobar']     )

        # single query
        __lowerCAmelCase								=	'foo'
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 0}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
        self.assertEqual(scores[0]					,  1     )
        self.assertEqual(indices[0]					,  0     )

        # single query with timeout
        __lowerCAmelCase								=	'foo'
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 0}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_					,  request_timeout=3_0     )
        self.assertEqual(scores[0]					,  1     )
        self.assertEqual(indices[0]					,  0     )

        # batched queries
        __lowerCAmelCase								=	['foo', 'bar', 'foobar']
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 1}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_     )
        __lowerCAmelCase								=	[scores[0] for scores in total_scores]
        __lowerCAmelCase								=	[indices[0] for indices in total_indices]
        self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
        self.assertListEqual([1, 1, 1]					,  lowerCAmelCase_     )

        # batched queries with timeout
        __lowerCAmelCase								=	['foo', 'bar', 'foobar']
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 1}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_					,  request_timeout=3_0     )
        __lowerCAmelCase								=	[scores[0] for scores in total_scores]
        __lowerCAmelCase								=	[indices[0] for indices in total_indices]
        self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
        self.assertListEqual([1, 1, 1]					,  lowerCAmelCase_     )

