From 534a7b7280493119b189cb659b20f4a0a8ad9477 Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Fri, 4 Oct 2019 15:40:11 +0800 Subject: [PATCH 01/11] implement new iter_by_chunks() in items --- scrapinghub/client/items.py | 27 +++++++++++++++++++++++++++ tests/client/test_items.py | 17 +++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index 669ea1af..243b9df2 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -59,3 +59,30 @@ def _modify_iter_params(self, params): if offset: params['start'] = '{}/{}'.format(self.key, offset) return params + + def iter_by_chunks(self, chunksize=10000, *args, **kwargs): + """An alternative for reading and processing items by returning a + generator of item chunks. + + This is a convenient method for cases when processing a large amount of + items from a job isn't ideal in one go due to the large memory needed. + Instead, this allows you to process it chunk by chunk. + + You can improve I/O overheads by increasing the chunk value but that + would also increase the memory consumption. + + :return: an iterator over a list of elements. + :rtype: :class:`collections.Iterable` + """ + + processed = 0 + while True: + next_key = self.key + '/' + str(processed) + items = [ + item for item in self.iter( + count=chunksize, start=next_key, *args, **kwargs) + ] + yield items + processed += len(items) + if len(items) < chunksize: + break diff --git a/tests/client/test_items.py b/tests/client/test_items.py index ea19d1bc..44775bf3 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -36,3 +36,20 @@ def test_items_list(spider, json_and_msgpack): assert o[0] == {'id': 0, 'data': 'data0'} assert o[1] == {'id': 1, 'data': 'data1'} assert o[2] == {'id': 2, 'data': 'data2'} + + +def test_items_iter_by_chunks(spider, json_and_msgpack): + job = spider.jobs.run(meta={'state': 'running'}) + _add_test_items(job) + + o = job.items.iter_by_chunks(2) + assert next(o) == [ + {'id': 0, 'data': 'data0'}, + {'id': 1, 'data': 'data1'}, + ] + assert next(o) == [ + {'id': 2, 'data': 'data2'}, + ] + next(o) + with pytest.raises(StopIteration): + next(o) From 25cd4dc8b70c987b12d96ab6029a5a5cc7e8db64 Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Sat, 5 Oct 2019 13:41:08 +0800 Subject: [PATCH 02/11] rename 'iter_by_chunks' to 'list_iter' --- scrapinghub/client/items.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index 243b9df2..f3b102bd 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -60,7 +60,7 @@ def _modify_iter_params(self, params): params['start'] = '{}/{}'.format(self.key, offset) return params - def iter_by_chunks(self, chunksize=10000, *args, **kwargs): + def list_iter(self, chunksize=10000, *args, **kwargs): """An alternative for reading and processing items by returning a generator of item chunks. From 62cab36dd591f1c2fc3cbec85183ac2f31cc45ba Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Sat, 5 Oct 2019 13:59:09 +0800 Subject: [PATCH 03/11] update docstring of 'list_iter()' to be more clear --- scrapinghub/client/items.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index f3b102bd..39909b6e 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -61,8 +61,8 @@ def _modify_iter_params(self, params): return params def list_iter(self, chunksize=10000, *args, **kwargs): - """An alternative for reading and processing items by returning a - generator of item chunks. + """An alternative interface for reading items by returning them + as a generator which yields lists of items sized as `chunksize`. This is a convenient method for cases when processing a large amount of items from a job isn't ideal in one go due to the large memory needed. @@ -71,7 +71,7 @@ def list_iter(self, chunksize=10000, *args, **kwargs): You can improve I/O overheads by increasing the chunk value but that would also increase the memory consumption. - :return: an iterator over a list of elements. + :return: an iterator over items, yielding lists of items. :rtype: :class:`collections.Iterable` """ From 15d647d44c5ed8259a4c9507ddb24897f523361c Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Sat, 5 Oct 2019 14:01:45 +0800 Subject: [PATCH 04/11] add new docstring example to 'jobs.items' class for list_iter() --- scrapinghub/client/items.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index 39909b6e..d946193d 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -37,6 +37,20 @@ class Items(_DownloadableProxyMixin, _ItemsResourceProxy): 'size': 100000, }] + - retrieve items via a generator of lists. This is most useful in cases + where the job has a huge amount of items and it needs to be broken down + into chunks when consumed. This example shows a job with 3 items:: + + >>> gen = job.items.list_iter(chunksize=2) + >>> next(gen) + [{'name': 'Item #1'}, {'name': 'Item #2'}] + >>> next(gen) + [{'name': 'Item #3'}] + >>> next(gen) + Traceback (most recent call last): + File "", line 1, in + StopIteration + - retrieve 1 item with multiple filters:: >>> filters = [("size", ">", [30000]), ("size", "<", [40000])] From 90315bcb1f7048cdc575b5ef2a4098e7032b4a26 Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Sat, 5 Oct 2019 14:38:22 +0800 Subject: [PATCH 05/11] fix tests --- tests/client/test_items.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/client/test_items.py b/tests/client/test_items.py index 44775bf3..cc28461d 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -38,11 +38,11 @@ def test_items_list(spider, json_and_msgpack): assert o[2] == {'id': 2, 'data': 'data2'} -def test_items_iter_by_chunks(spider, json_and_msgpack): +def test_items_list_iter(spider, json_and_msgpack): job = spider.jobs.run(meta={'state': 'running'}) _add_test_items(job) - o = job.items.iter_by_chunks(2) + o = job.items.list_iter(2) assert next(o) == [ {'id': 0, 'data': 'data0'}, {'id': 1, 'data': 'data1'}, @@ -50,6 +50,5 @@ def test_items_iter_by_chunks(spider, json_and_msgpack): assert next(o) == [ {'id': 2, 'data': 'data2'}, ] - next(o) with pytest.raises(StopIteration): next(o) From 4aa0112414fc3c5d83fcdaa31293a6c708bd4f5f Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Wed, 16 Oct 2019 18:04:01 +0800 Subject: [PATCH 06/11] lower default chunksize of list_iter() from 10k to 1k --- scrapinghub/client/items.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index d946193d..d30bbe6b 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -74,7 +74,7 @@ def _modify_iter_params(self, params): params['start'] = '{}/{}'.format(self.key, offset) return params - def list_iter(self, chunksize=10000, *args, **kwargs): + def list_iter(self, chunksize=1000, *args, **kwargs): """An alternative interface for reading items by returning them as a generator which yields lists of items sized as `chunksize`. From ee4007150416b1830aa0e7a461dd25167eeff81a Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Wed, 16 Oct 2019 19:33:54 +0800 Subject: [PATCH 07/11] add support for 'start' and 'count' params --- scrapinghub/client/items.py | 29 ++++++++++++++++++++++++++++- tests/client/test_items.py | 30 +++++++++++++++++++++++++++--- 2 files changed, 55 insertions(+), 4 deletions(-) diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index d30bbe6b..83e10420 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -1,5 +1,7 @@ from __future__ import absolute_import +import sys + from .proxy import _ItemsResourceProxy, _DownloadableProxyMixin @@ -51,6 +53,20 @@ class Items(_DownloadableProxyMixin, _ItemsResourceProxy): File "", line 1, in StopIteration + - retrieving via meth::`list_iter` also supports the `start` and `count`. + params. This is useful when you want to only retrieve a subset of items in + a job. The example below belongs to a job with 10 items:: + + >>> gen = job.items.list_iter(chunksize=2, start=5, size=3) + >>> next(gen) + [{'name': 'Item #5'}, {'name': 'Item #6'}] + >>> next(gen) + [{'name': 'Item #7'}] + >>> next(gen) + Traceback (most recent call last): + File "", line 1, in + StopIteration + - retrieve 1 item with multiple filters:: >>> filters = [("size", ">", [30000]), ("size", "<", [40000])] @@ -85,18 +101,29 @@ def list_iter(self, chunksize=1000, *args, **kwargs): You can improve I/O overheads by increasing the chunk value but that would also increase the memory consumption. + :param chunksize: size of list to be returned per iteration + :param start: offset to specify the start of the item iteration + :param count: overall number of items to be returned, which is broken + down by `chunksize`. + :return: an iterator over items, yielding lists of items. :rtype: :class:`collections.Iterable` """ + start = kwargs.pop("start", 0) + count = kwargs.pop("count", sys.maxsize) processed = 0 + while True: - next_key = self.key + '/' + str(processed) + next_key = self.key + "/" + str(start) items = [ item for item in self.iter( count=chunksize, start=next_key, *args, **kwargs) ] yield items processed += len(items) + start += len(items) + if processed >= count: + break if len(items) < chunksize: break diff --git a/tests/client/test_items.py b/tests/client/test_items.py index cc28461d..5e71f0f3 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -2,8 +2,8 @@ from six.moves import range -def _add_test_items(job): - for i in range(3): +def _add_test_items(job, size=3): + for i in range(size): job.items.write({'id': i, 'data': 'data' + str(i)}) job.items.flush() job.items.close() @@ -41,8 +41,9 @@ def test_items_list(spider, json_and_msgpack): def test_items_list_iter(spider, json_and_msgpack): job = spider.jobs.run(meta={'state': 'running'}) _add_test_items(job) + job.finish() - o = job.items.list_iter(2) + o = job.items.list_iter(chunksize=2) assert next(o) == [ {'id': 0, 'data': 'data0'}, {'id': 1, 'data': 'data1'}, @@ -52,3 +53,26 @@ def test_items_list_iter(spider, json_and_msgpack): ] with pytest.raises(StopIteration): next(o) + + +def test_items_list_iter_with_start_and_count(spider, json_and_msgpack): + job = spider.jobs.run(meta={'state': 'running'}) + _add_test_items(job, size=10) + job.finish() + + o = job.items.list_iter(chunksize=3, start=3, size=7) + assert next(o) == [ + {'id': 3, 'data': 'data3'}, + {'id': 4, 'data': 'data4'}, + {'id': 5, 'data': 'data5'}, + ] + assert next(o) == [ + {'id': 6, 'data': 'data6'}, + {'id': 7, 'data': 'data7'}, + {'id': 8, 'data': 'data8'}, + ] + assert next(o) == [ + {'id': 9, 'data': 'data9'}, + ] + with pytest.raises(StopIteration): + next(o) From 7dc57d10075afac59579504f8394fb3ed540d8bd Mon Sep 17 00:00:00 2001 From: Viktor Shlapakov Date: Fri, 18 Oct 2019 13:08:51 +0300 Subject: [PATCH 08/11] Normalize Job instances in tests --- tests/client/test_items.py | 4 ++++ tests/client/utils.py | 27 +++++++++++++++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/tests/client/test_items.py b/tests/client/test_items.py index 5e71f0f3..bdf4028e 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -1,6 +1,8 @@ import pytest from six.moves import range +from .utils import normalize_job_for_tests + def _add_test_items(job, size=3): for i in range(size): @@ -28,6 +30,7 @@ def test_items_iter(spider, json_and_msgpack): def test_items_list(spider, json_and_msgpack): job = spider.jobs.run(meta={'state': 'running'}) + job = normalize_job_for_tests(job) _add_test_items(job) o = job.items.list() @@ -40,6 +43,7 @@ def test_items_list(spider, json_and_msgpack): def test_items_list_iter(spider, json_and_msgpack): job = spider.jobs.run(meta={'state': 'running'}) + job = normalize_job_for_tests(job) _add_test_items(job) job.finish() diff --git a/tests/client/utils.py b/tests/client/utils.py index 8e60cb39..4e490de0 100644 --- a/tests/client/utils.py +++ b/tests/client/utils.py @@ -13,3 +13,30 @@ def validate_default_meta(meta, state='pending', units=1, assert meta.get('units') == units assert meta.get('api_url') == TEST_DASH_ENDPOINT assert meta.get('portia_url') + + +def normalize_job_for_tests(job): + """A temporary workaround to deal with VCR.py cassettes(snapshots). + + The existing tests highly rely on VCR.py which creates snapshots of real + HTTP requests and responses, and during the test process tries to match + requests with the snapshots. Sometimes it's hard to run an appropriate test + environment locally, so we allow to use our servers to create snapshots + for new tests, by "normalizing" the snapshots via patching hosts/credentials + on-the-fly before saving it (see #112). + + The problem here is that we patch only requests data and not responses data, + which is pretty difficult to unify over the whole client. It means that if + some test gets data from API (say, a new job ID) and uses it to form another + requests (get the job data), it will form the HTTP requests differently, + thus it won't match with the snapshots during the test process and the tests + will fail. + + As a temporary workaround, the helper gets a Job instance, extracts its key, + replaces the project ID part with TEST_PROJECT_ID, and returns a new Job. + So, the other requests done via the new job instance (updating job items, + accessing job logs, etc) will be done using proper URLs matching with + existing snapshots. + """ + normalized_key = '{}/{}'.format(TEST_PROJECT_ID, job.key.split('/', 1)[1]) + return job._client.get_job(normalized_key) \ No newline at end of file From c4ef768d3dda78a6de3fa119db0652ec891e84fa Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Mon, 21 Oct 2019 20:02:53 +0800 Subject: [PATCH 09/11] update tests with normalize_job_for_tests() workaround --- tests/client/cassetes/test_items/test_items_list_iter-json.gz | 1 + tests/client/cassetes/test_items/test_items_list_iter.gz | 1 + .../test_items/test_items_list_iter_with_start_and_count-json.gz | 1 + .../test_items/test_items_list_iter_with_start_and_count.gz | 1 + tests/client/test_items.py | 1 + 5 files changed, 5 insertions(+) create mode 100644 tests/client/cassetes/test_items/test_items_list_iter-json.gz create mode 100644 tests/client/cassetes/test_items/test_items_list_iter.gz create mode 100644 tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz create mode 100644 tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz diff --git a/tests/client/cassetes/test_items/test_items_list_iter-json.gz b/tests/client/cassetes/test_items/test_items_list_iter-json.gz new file mode 100644 index 00000000..7ee6fcda --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter-json.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter.gz b/tests/client/cassetes/test_items/test_items_list_iter.gz new file mode 100644 index 00000000..dc1f8810 --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz new file mode 100644 index 00000000..7b0d612d --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz new file mode 100644 index 00000000..e4b614a8 --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/test_items.py b/tests/client/test_items.py index bdf4028e..a5fe8dca 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -61,6 +61,7 @@ def test_items_list_iter(spider, json_and_msgpack): def test_items_list_iter_with_start_and_count(spider, json_and_msgpack): job = spider.jobs.run(meta={'state': 'running'}) + job = normalize_job_for_tests(job) _add_test_items(job, size=10) job.finish() From 6bc35ad305b9dd8642e813caf4ec175040fb84d8 Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Tue, 22 Oct 2019 13:17:12 +0800 Subject: [PATCH 10/11] fix test_items_list_iter_with_start_and_count() to use correct param --- .../test_items_list_iter_with_start_and_count-json.gz | 2 +- .../test_items/test_items_list_iter_with_start_and_count.gz | 2 +- tests/client/test_items.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz index 7b0d612d..404b03d1 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz @@ -1 +1 @@ -eJy11gl4VMUdAPAQECWcFhSNWpdU4gp5e7zNbnZDIwZCAkkgd3hSpnHydjbvkd23+39HQoJpBS3llIarotUCihxWW1JRaSu083rY+77v+77v6/s6b95CQtg0Ej43+d4xb3Zn3szv/595IH8A8rzStXl5eT1EN9S0BpPqJkkz2L2qmUTHssnKDMhHMNk7AFPcqjoBixgmXDMAU73SVFaSIqaSjsO10hR209jQ0grXSZPZpaWrME26g10pppkp9/tDIZ/7Hw6WRwPRgB9nVL9uab4NBmu7gH+/Mx3vg+lSPbvM6OkNRDYrQsGAGBSLjYwaJ3qFYggma19wb4tZ47hiYdmyhaJomNgk7LwwVLmYndgPa6rW5RSUVcEM3nmFYPYlA2YOwCyvVMBK2gyiC5VdRDNhNoI50k1Ow33shTTBkHXWQa1LsTr9ok/0BeF6LM1mzytlmWRMYYUmp+PsObwOwVxpJnvQ1a9mSjxxkkiynsA8zIfHrQ03ILiRD8si/yKYj3njy9OaRvgow00IbuZl3YRkBJxUewgUuj+wPJ3uVgncguBWqY7dy4aeMNPdRBMrMo1SuL6rLyOqta0N3eu6I2SlGJOk4NpgdW3TajHWjxvwuu62BGlfppbVldaRMKkM9NZnGus6sRZtaoHbsDTL7YjJhkCoJ1qXqcDrEdwu5bPysgh4MBdxoUZrX4bAAgRF0gJWijOZpCpj5w38G4Xe3l4hkdZTgqUniTM4JA5vwHxkKi02pLraz6vCHZLIypZhQ5U961Kv9u/eCCy0LOk6jtDIMJoEigfgTlehM/uWAQzqXV4uyWkfFtW9wic+RQwDdxFYzF+roQ5KLIUhELzSNc5rJJPpXvAh8PPOOoZLPA2Nrasa1rRAwJ2FFqKzKIEgApEPiNalahv9QV/QgRHC0pwRg3RRRimCMO+MIwMimF/3YL0PyhBER85uzBUhCW0Zw9QJTkE5giXS9awsjg1FSGGDhWQHA9kThDdexqcCwd2j+Sx1m6tyLN6DoFK6jd2tTmslHjHoaZBNjxgIxjzBYHlprDwc8dSsboVlOSZ7OYIq/nYjJ5tH7ApsKdMHoDo7/rrzxjVyhzPwslHgCiiAlVI7e3w73elMHPtMpqfaF/lWldwltNOhZnuHvafd3tvEzjsa7B31k3S6a+ZMumsG3W0/P9PeLdhn6G66ix7YMIl91z5vn5+cZ9LjdM+cO9k9rOJts3BTtSDUboW6Zqg3LGsAVnsVlqHWeJURaalBmSbdPZyODDOtMxO+npRvRKj75HTKr5okZfhF9+MPlsX8YmgpE6abFQFoVKYrK6UtF14qQR+jz6J8+zyyt8cK8hbMm2IP3r9mwdJIpsN+OkK30O30LD1k77IfrylV7BP0RIH9BN1rD9rH2qoX2ydT9AX6Mj1eTc91ITpUdaP9FN12q71tbl+jp4AeXjmvkm730s1i09Qb6NF8eqrKsvfNpo8G6c7iWWxEoElhb93cDC0O59bLclobgvb/n9PWYoXlLylH/roXKyxprVPmY4VlpzcphS5yOYuDXEC+HgEaRv5mrLD00cHjLFYK92FlwtGOLUthAd7pVVhUy16FBbNyMYDjPICJV7rZCU6GT2ZedayxxKCbQguR2fJj9kECQZckOBkAbxTYbLPVJByKBAKBJR5Vk5NWnLRYnVXpFFY1Y4kno5NkGseXgJIzL6oINkiOwwB0Y+mWbHI3DMGpp6eTQqWTSIQGXWXJAZIIUrz2ItByxFUaQYZ33iQbTX8myXqwxCMrWDeIWdHWWi1EAdwA05UayYkcMDhtk9O2LqHdw2iHXxXtDelOuCjbysSdme5VpvMx2lTE19Cick9RQtVUQyHxohJPUTfpc4rcdTgbDUUDsNGZgD6vwoz1Ky6jTYqL5v4smgGGxuHwFj5rpWF461VweMDlsJlz2DKKw4Ocw0PeXNP2NgRb3Q5E4e2XZPNtCLZfns134HFQ7USwawKodmOezyXBaV2VidCe3XY9jGCP5GWPRNIZKJWxHBJDYkzEZdGEKEajoRgJBBIJMYhJIBwVxYAM7xif3yCCvYp22bKyD8F+votxIFxYVnpJJxwYsVwcRPDOMZeLcKA8EODLxSM5WB9C8Kg0/7K9gbNgJFWNGPCYi/pdDHWAm8vJi7Fj49Zz0WN2N8fYPc6D4AkeBO92gsDZVNWsaIXDLAaSV5ves4ULxWpWzI5iiB1CxYbaTyrKiuW0pbENqbvr7GAdhyPK9DWOvKM8Dp7MxsFT2Tg4lo2Dp504mDD84y78Exz+yVHwT3H4z+SE/x4Ez/J60Qg8Nx7q9yJ43wRQnx5j6zOE4P3Dq8Lz43s9g+AFJVeifBHBS1Lx2KJGZ82zLrAPKDVsme6/ZO+RR59pZ5uMJjok2gebaleVrGqlQ/kt9tba8lr7tH2InqQH7qHP0dP0CN1MB9lxkJ5jx7P0GDsPsvJz9HSzsDYs0Qen0R1T564vrLcPF9Y3ldJH7KP23vsK7P15edWK/aRK9zkZ+4PO8vyhZniZoz3H0Z4fifbDrxnayNhoP5JFSzlaO4v2o1m0H8ui/fhVof2Ei/YVjvaTo9B+iqP9dE60n0Hw2QtoPzce2s8j+MIE0H5xDLRfQvDlYbRfGR/tVxF8LSfaryP4xpWg/aaL9lsc7aYx0e4bRpu4ArOHsmZjzKyxvpBtRo8UljSWSvZhZnaSY9Z+qZGeoS+6ar/tqP1OM3yXq/0eV/v9kWp/8JqpjY2t9odZtT/ian+cVfuTrNqfZtX+7KrU/txV+wuu9pej1P6Kq/11TrW/QfBbXi9SCr8bT+3vEfxhAmr/OIbaPyH487Dav4yv9q8I/pZT7d8R/ONK1P7TVfsvrrZjDLV0yN4/zJYevAK3x5qF+XmS/bC9jz4UdGT+25H5n2b4L5NJLN//AC8uXVc= \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz index e4b614a8..0c5516d7 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/client/test_items.py b/tests/client/test_items.py index a5fe8dca..e488c480 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -65,7 +65,7 @@ def test_items_list_iter_with_start_and_count(spider, json_and_msgpack): _add_test_items(job, size=10) job.finish() - o = job.items.list_iter(chunksize=3, start=3, size=7) + o = job.items.list_iter(chunksize=3, start=3, count=7) assert next(o) == [ {'id': 3, 'data': 'data3'}, {'id': 4, 'data': 'data4'}, From 9a6737339543fc1ac5549a95c5bf9b92bcc544c9 Mon Sep 17 00:00:00 2001 From: Kevin Lloyd Bernal Date: Wed, 23 Oct 2019 20:05:21 +0800 Subject: [PATCH 11/11] fix cases when there are extra items than the specified 'count' --- scrapinghub/client/items.py | 4 +++- .../test_items/test_items_list_iter-json.gz | 2 +- .../test_items/test_items_list_iter.gz | 2 +- ...ems_list_iter_with_start_and_count-json.gz | 2 +- ...st_items_list_iter_with_start_and_count.gz | 2 +- ...s_list_iter_with_start_and_count_2-json.gz | 1 + ..._items_list_iter_with_start_and_count_2.gz | 1 + tests/client/test_items.py | 22 +++++++++++++++++++ 8 files changed, 31 insertions(+), 5 deletions(-) create mode 100644 tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2-json.gz create mode 100644 tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2.gz diff --git a/scrapinghub/client/items.py b/scrapinghub/client/items.py index 83e10420..d22e2701 100644 --- a/scrapinghub/client/items.py +++ b/scrapinghub/client/items.py @@ -57,7 +57,7 @@ class Items(_DownloadableProxyMixin, _ItemsResourceProxy): params. This is useful when you want to only retrieve a subset of items in a job. The example below belongs to a job with 10 items:: - >>> gen = job.items.list_iter(chunksize=2, start=5, size=3) + >>> gen = job.items.list_iter(chunksize=2, start=5, count=3) >>> next(gen) [{'name': 'Item #5'}, {'name': 'Item #6'}] >>> next(gen) @@ -116,6 +116,8 @@ def list_iter(self, chunksize=1000, *args, **kwargs): while True: next_key = self.key + "/" + str(start) + if processed + chunksize > count: + chunksize = count - processed items = [ item for item in self.iter( count=chunksize, start=next_key, *args, **kwargs) diff --git a/tests/client/cassetes/test_items/test_items_list_iter-json.gz b/tests/client/cassetes/test_items/test_items_list_iter-json.gz index 7ee6fcda..daed6b94 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter-json.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter-json.gz @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter.gz b/tests/client/cassetes/test_items/test_items_list_iter.gz index dc1f8810..df48fd73 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter.gz @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz index 404b03d1..13ed2f72 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count-json.gz @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz index 0c5516d7..2ba3d904 100644 --- a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count.gz @@ -1 +1 @@ -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 \ No newline at end of file +eJy11glYFNcdAHC8A3gkRmOM2qxE6IrMHrOwsBhqQOQICMrlhORJH7MPZmB3dv9zcJjQGmujaGzUGJvLmKSJMTZtjU1sbBNt3/RI7/u+7/u+z69v3iyCsAQ//LKwOzNvjvfmvd///97OmUOQ4ZXmZWRk9BHdUBMazKibIc1nx6pmEh3LJiszYCaCWd4hmO1eqhOwiGHCnCGY65XmspI4MZVEFOZJs9nBlsbmFrhKmsV2LV2FTGkN21NMM1nq94dCPve/KFhaEigJ+HFS9euW5usxWN1Z/P7ORHQQsqV6tpvUEz1ENssKg2IwWJJnJNUo0csUQzBZ/YJ7mMcqx2W5xRW5omiY2CRsmxsqX8c27MGaqnU7BcWVMJ83XiGY3WTAgiFY6JWyWEmrQXShvJtoJixCcLV0vVPxIHshTTBknTVQ61asTr/oE31BuAZLi9j5clkmSVPYpMmJKDsPixFcKy1gJ7p3qMkCT5R0xVhLYAnm3eNeDUsRXMe7Jd+fD8swr3xjQtMI72W4HsFyXtZLSFLAMbWPwA3uAzYmEr0qgRUIVkp17Fg29C4z0Us0sax9SzjW3t7WWhfvG+zpr+pVdiRJkyaLvUXh2lqI1m9sKWntuXWHEt7WuU2qI8a2iupIeUtNMlDbGRvo7OuDVVha6DbEZF0g1BOt21TgDQhulGay8uIweDAXMXJFy2CSwGoEOdJqVoqTyZgqY+cN/ANCf3+/0JXQ44Klx4jTOSQKN2HeM+UW61Jd3cEvhTWSyMoqsKHKnvb45f7dFoZcy5Ku4giNJKNJIG8I3ugqdEbfMoBBXevlkpz6Ib/uVT7wcWIYuJvAOv5ajXVQYCkMgeCV5jivEYsl+sGHwM8b6xgu8DRuaaltbGiGgDtWktCaNEyd4DgEEYjSNawsig1FiGODBUsHo9IXhBDmdVc641+IoEhaxY62kWiBRwx5GmXTIwaCEU9QLA0ESwMBT/XmFghPsFCMoGS8hQiWrh4zDBftlSJYz6t07MHNaQarDMGb+L1jB4tH3Aa3sX1YH4RbEJSP1Vbh2msmOssNsBFBJX+y1q1qA/6gL+iEwyZsKdlDUJXqf91pT7Xc4XS8bGS5ArKgRtrKTt9I9zsDxz6z6Km2fF9twVqhjZ5psvfZ97XZh7ey7b5Ge1/9DL1+Pj0wf4Fgv2AfEOwXN9MjPTPYXfYF+8KsDHun/YB9oCiXFUAtr5ZFmqoF4dZ7oK4J6g3LGoLNXoUlpwavMiYjNSqZ0s2jmcgwEzrj4OuL+8ZEuU9OxP2qSeKGX3Q//uKIv3ADo6WbZQHYomQrNdKukbexz99CT6OZ9gVkD0eyMlYvmW0fuqth9YZwssM+Eaa76DA9Rx+y77WPVRcq9kl6Mst+jB62D9lPt1ats5+N07P0FfpMFT3fjeiZyuvsp+jelfbeawe3eLLo4zVLyumwl94tbp27lD45k56qtOz7F9GHg3R/3kLWIbBVYe/c1ATNjuOWCcmsFUHbayezbVhhiUtKk7huwwrLVu3KMqywtHS7coNrT06pIiP27kCARu1txwrLGx08wCKF8GasTDvMsWUpLLI7vQoLZ9mrsChWLkZulEcu8U6U3oWgW1rOSk0yYPqTMaxq6z2ygnWDmGWtLVVCCShp852KoEdylAWgF/MnNDPNMnusjjWWaXRTaCYym8/MQYghiEuCk1LwgMAMlYWCRaFwIBBY71E1OWZFSbPVWZmIs8qN9Z6kTmIJHF0PGpZWpCYDwxCc+vVETCh3Eo/QqKssrCCBIMlbkQ/gRpauVEtOyIDBYZsctnUJ7D4Gu+iyYPckOuGiaysZdUa6X8mW1rG778zhk2dOqSenS9VUQyHRnAJPTi8ZdIrcCZjHQs4QDDjdP+hVmLAdiovoTsUlc1eKzBAj42B4Cx+zwhC89Qow7HQx3M0x7BqH4W0cw25vulF9O4J73AaEYc+EJL4XwTCfzZ1+GUni/aQT9mGe2yXByX2qTIS21OJoP4J7JS87JZLOQKGM5ZAYEiMiLi7pEsWSklCEBAJdXWIQk0BRiSgGZDgwZjZ4B4L7XnM2KOSzwcE0GfwQgsPSsgnTrZPDY6pGDLj/kmR9BMEDE5P10algvxPBg9OA/dDUsB9G8IiSIv0oI+3j4tLgYuTYc/suWkwt4Ri6YzwAHuMBcNwJAGclVb2pBR5n/vGVJfZUUa5YVRxhP4XsG8qTE5ZmloXc9WUHays8oWQ3ONie5PTflaL/VIr+09LSCQMUN7qTWO6FEzwonnGCYtpRcNKNgmd5FJwaFwXv5lHwXNooeA+C97prORHelwbXaQTP80V62raPz59nJlmGvB/BC6NTwYtTWTuL4APTsPbS1NbOIfjgiLUPKdVsvu66ZPWR0budHmGz8i768ppc+vwaWEv3BrYvpsfpsXZ6zj5q77YP2nvZ92CFfdx+tMk+Xmkfpy8tpyfp7jn0CXv37GY6nFmTua6CDq+lJxY3Z4j2Hnq0QXXS9MvOnPxKE5znWi9wrR8eq/Ujr4vWcBqtNKXV5lo/mtL6sZTWjyuuyU9ckclXXZOf5CY/Nc7kp7nJz6Q1+VkEnxsx+fk0Jr+A4IuXb/JLk5j8MoKvjJr86lQmv4bg69Mw+Y2pTX4TwbdGTH6bm4xOYvLsqMnbpzL5HDe5yjG5kpmM1GTOYybnMJPZGStWdiznIr/jiPxuE3yPi/w+F/mDsSJ/+LqIjKREBseI/FFK5I+5yJ+kRP40JfJnKZE/vyKRv3BF/pKL/NU4kb/mIn+TVuRvEfyOX1cUgt+nEfkHBH+8fJF/mkTknxH8ZVTkX6cS+TcEf5+GyH9MLfKfCP41IvLfXGTdJCLPXRRJT98xBcnFGfICumfZTQ68/zjw/tsE/2PwiOX7P3+bLlM= \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2-json.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2-json.gz new file mode 100644 index 00000000..b1b8e3b7 --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2-json.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2.gz b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2.gz new file mode 100644 index 00000000..e7dcaf37 --- /dev/null +++ b/tests/client/cassetes/test_items/test_items_list_iter_with_start_and_count_2.gz @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/client/test_items.py b/tests/client/test_items.py index e488c480..79f68c33 100644 --- a/tests/client/test_items.py +++ b/tests/client/test_items.py @@ -81,3 +81,25 @@ def test_items_list_iter_with_start_and_count(spider, json_and_msgpack): ] with pytest.raises(StopIteration): next(o) + + +def test_items_list_iter_with_start_and_count_2(spider, json_and_msgpack): + """2nd version from the test above but this case makes sure that the total + number of items returned would be equal to `count`. + """ + + job = spider.jobs.run(meta={'state': 'running'}) + job = normalize_job_for_tests(job) + _add_test_items(job, size=10) + job.finish() + + o = job.items.list_iter(chunksize=2, start=3, count=3) + assert next(o) == [ + {'id': 3, 'data': 'data3'}, + {'id': 4, 'data': 'data4'}, + ] + assert next(o) == [ + {'id': 5, 'data': 'data5'}, + ] + with pytest.raises(StopIteration): + next(o)