From 37a4e6c2d86f85a01088828e7b4404f7c69a4c16 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Mon, 19 Mar 2018 05:27:14 +0300
Subject: [PATCH 01/14] Fix for VkTools.get_all_slow method (stripping first
 elements)

---
 vk_api/tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 8e69cc9f..821675df 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -136,7 +136,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
         count = response['count']
         items_count = 0
 
-        for offset in range(max_count, count + 1, max_count):
+        for offset in range(0, count + 1, max_count):
             values['offset'] = offset
 
             response = self.vk.method(method, values)

From 101777b63c3466fb0ffa18887d005f29ba7f37c3 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Mon, 19 Mar 2018 06:51:50 +0300
Subject: [PATCH 02/14] Reworked VkTools.get_all_slow_iter method

---
 vk_api/tools.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 821675df..53371e6a 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -131,16 +131,14 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
         values = values.copy() if values else {}
 
         values['count'] = max_count
-
-        response = self.vk.method(method, values)
-        count = response['count']
+        values['offset'] = 0
         items_count = 0
-
-        for offset in range(0, count + 1, max_count):
-            values['offset'] = offset
-
+        count = None
+        while values['offset'] < (count or 1):
             response = self.vk.method(method, values)
-            items = response[key]
+            new_count = response['count']
+            count_diff = new_count-(count or new_count)
+            items = response[key][count_diff:]
             items_count += len(items)
 
             for item in items:
@@ -152,6 +150,9 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             if stop_fn and stop_fn(items):
                 break
 
+            values['offset'] += max_count + count_diff
+            count = new_count
+
     def get_all_slow(self, method, max_count, values=None, key='items',
                      limit=None, stop_fn=None):
         """ Использовать только если нужно загрузить все объекты в память.
@@ -164,7 +165,7 @@ def get_all_slow(self, method, max_count, values=None, key='items',
         """
 
         items = list(
-            self.get_all_slow_iter(method, max_count, values, key, limit, 
+            self.get_all_slow_iter(method, max_count, values, key, limit,
                                    stop_fn)
         )
         return {'count': len(items), key: items}

From 02116fbfbce180cb90611cb8e8b75efb98644f4b Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Mon, 19 Mar 2018 07:08:05 +0300
Subject: [PATCH 03/14] get_all_slow: result count could also decrease

---
 vk_api/tools.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 53371e6a..46250d15 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -138,6 +138,15 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             response = self.vk.method(method, values)
             new_count = response['count']
             count_diff = new_count-(count or new_count)
+
+            if new_count == 0:
+                break
+
+            if count_diff < 0:
+                values['offset'] += count_diff
+                count = new_count
+                continue
+
             items = response[key][count_diff:]
             items_count += len(items)
 

From 4d21d5c90e05704fed4ba0c602225cdcd63f2550 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Tue, 20 Mar 2018 11:32:07 +0300
Subject: [PATCH 04/14] Get all offset fix for execute version

---
 vk_api/tools.py | 79 +++++++++++++++++++++++++++++--------------------
 1 file changed, 47 insertions(+), 32 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 46250d15..92e976c4 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -58,34 +58,41 @@ def get_all_iter(self, method, max_count, values=None, key='items',
 
         values = values.copy() if values else {}
 
+        values['count'] = max_count
+        values['offset'] = 0
         items_count = 0
-        offset = 0
+        count = None
 
-        while True:
+        while values['offset'] < (count or 1):
             response = vk_get_all_items(
-                self.vk, method, values, key, max_count, offset
+                self.vk, method=method, key=key, values=values
             )
+            new_count = response['count']
+            count_diff = new_count-(count or new_count)
 
-            items = response.get('items')
-            offset = response.get('offset')
+            if new_count == 0:
+                break
 
-            if items is None or response.get('count') is None:
-                break  # Error
+            if count_diff < 0:
+                values['offset'] += count_diff
+                count = new_count
+                continue
 
+            items = response[key][count_diff:]
             items_count += len(items)
 
             for item in items:
                 yield item
 
-            if offset >= response['count']:
-                break
-
             if limit and items_count >= limit:
                 break
 
             if stop_fn and stop_fn(items):
                 break
 
+            values['offset'] += len(items) + count_diff
+            count = new_count
+
     def get_all(self, method, max_count, values=None, key='items', limit=None,
                 stop_fn=None):
         """ Использовать только если нужно загрузить все объекты в память.
@@ -137,7 +144,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
         while values['offset'] < (count or 1):
             response = self.vk.method(method, values)
             new_count = response['count']
-            count_diff = new_count-(count or new_count)
+            count_diff = new_count - (count or new_count)
 
             if new_count == 0:
                 break
@@ -159,7 +166,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             if stop_fn and stop_fn(items):
                 break
 
-            values['offset'] += max_count + count_diff
+            values['offset'] += len(items) + count_diff
             count = new_count
 
     def get_all_slow(self, method, max_count, values=None, key='items',
@@ -181,27 +188,35 @@ def get_all_slow(self, method, max_count, values=None, key='items',
 
 
 vk_get_all_items = VkFunction(
-    args=('method', 'values', 'key', 'max_count', 'start_offset'),
-    clean_args=('method', 'max_count', 'start_offset'),
+    args=('method', 'key', 'values'),
+    clean_args=('method', 'key'),
     code='''
-    var max_count = %(max_count)s,
-        offset = %(start_offset)s,
-        key = %(key)s;
-
-    var params = {count: max_count, offset: offset} + %(values)s;
-
-    var r = API.%(method)s(params),
-        items = r[key],
-        i = 1;
-
-    while(i < 25 && offset + max_count <= r.count) {
-        offset = offset + max_count;
-        params.offset = offset;
-
-        items = items + API.%(method)s(params)[key];
-
-        i = i + 1;
+    var params = %(values)s,
+        calls = 0,
+        items = [],
+        count, new_count, count_diff, response;
+
+    while(calls < 25 && (count == null || params.offset < count)) {
+        calls = calls + 1;
+        response = API.%(method)s(params);
+        new_count = response.count;
+
+        if (count == null) {
+            count = new_count;
+        }
+        count_diff = new_count - count;
+
+        if (new_count == 0) {
+            calls = 25;
+        } else if (count_diff < 0) {
+            params.offset = params.offset + count_diff;
+            count = new_count;
+        } else {
+            items = items + response.%(key)s.slice(count_diff);
+            params.offset = params.offset+  params.count + count_diff;
+            count = new_count;
+        }
     };
 
-    return {count: r.count, items: items, offset: offset + max_count};
+    return {count: count, items: items};
 ''')

From 060da63fc8fab319f2d8238a0734ff35f61ebf8c Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Tue, 20 Mar 2018 13:18:54 +0300
Subject: [PATCH 05/14] Make old count count

---
 vk_api/tools.py | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 92e976c4..ae91a928 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -65,7 +65,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
 
         while values['offset'] < (count or 1):
             response = vk_get_all_items(
-                self.vk, method=method, key=key, values=values
+                self.vk, method=method, key=key, values=values, count = count
             )
             new_count = response['count']
             count_diff = new_count-(count or new_count)
@@ -188,23 +188,19 @@ def get_all_slow(self, method, max_count, values=None, key='items',
 
 
 vk_get_all_items = VkFunction(
-    args=('method', 'key', 'values'),
+    args=('method', 'key', 'values', 'count'),
     clean_args=('method', 'key'),
     code='''
     var params = %(values)s,
         calls = 0,
         items = [],
-        count, new_count, count_diff, response;
+        count = %(count)s;
 
     while(calls < 25 && (count == null || params.offset < count)) {
         calls = calls + 1;
-        response = API.%(method)s(params);
-        new_count = response.count;
-
-        if (count == null) {
-            count = new_count;
-        }
-        count_diff = new_count - count;
+        var response = API.%(method)s(params), 
+            new_count = response.count,
+            count_diff = (count == null : 0 ? new_count - count);
 
         if (new_count == 0) {
             calls = 25;

From ca539fcf0e8f11d0055a036baf9bec51e857ace4 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Tue, 20 Mar 2018 14:33:29 +0300
Subject: [PATCH 06/14] js's ternary op whoops

---
 vk_api/tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index ae91a928..5aca3cde 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -200,7 +200,7 @@ def get_all_slow(self, method, max_count, values=None, key='items',
         calls = calls + 1;
         var response = API.%(method)s(params), 
             new_count = response.count,
-            count_diff = (count == null : 0 ? new_count - count);
+            count_diff = (count == null ? 0 : new_count - count);
 
         if (new_count == 0) {
             calls = 25;

From 1ad309074d42f348bffe10bcde3b95dce991fbc5 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Tue, 20 Mar 2018 15:07:48 +0300
Subject: [PATCH 07/14] Move out count diff logic from VkTools.get_all_iter to
 remote function

---
 vk_api/tools.py | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 5aca3cde..4a5de94e 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -65,20 +65,11 @@ def get_all_iter(self, method, max_count, values=None, key='items',
 
         while values['offset'] < (count or 1):
             response = vk_get_all_items(
-                self.vk, method=method, key=key, values=values, count = count
+                self.vk, method=method, key=key, values=values, count=count
             )
-            new_count = response['count']
-            count_diff = new_count-(count or new_count)
-
-            if new_count == 0:
-                break
+            count = response['count']
 
-            if count_diff < 0:
-                values['offset'] += count_diff
-                count = new_count
-                continue
-
-            items = response[key][count_diff:]
+            items = response[key]
             items_count += len(items)
 
             for item in items:
@@ -90,8 +81,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
             if stop_fn and stop_fn(items):
                 break
 
-            values['offset'] += len(items) + count_diff
-            count = new_count
+            values['offset'] = response['offset']
 
     def get_all(self, method, max_count, values=None, key='items', limit=None,
                 stop_fn=None):
@@ -201,7 +191,6 @@ def get_all_slow(self, method, max_count, values=None, key='items',
         var response = API.%(method)s(params), 
             new_count = response.count,
             count_diff = (count == null ? 0 : new_count - count);
-
         if (new_count == 0) {
             calls = 25;
         } else if (count_diff < 0) {
@@ -209,10 +198,10 @@ def get_all_slow(self, method, max_count, values=None, key='items',
             count = new_count;
         } else {
             items = items + response.%(key)s.slice(count_diff);
-            params.offset = params.offset+  params.count + count_diff;
+            params.offset = params.offset + params.count + count_diff;
             count = new_count;
         }
     };
 
-    return {count: count, items: items};
+    return {count: count, items: items, offset: params.offset};
 ''')

From 54c6312bd7b425eaa62758038dbdf383e49c348c Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Wed, 21 Mar 2018 08:56:51 +0300
Subject: [PATCH 08/14] Negative offset for get_all_slow

---
 vk_api/tools.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 4a5de94e..8a9e5231 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -100,7 +100,7 @@ def get_all(self, method, max_count, values=None, key='items', limit=None,
         return {'count': len(items), key: items}
 
     def get_all_slow_iter(self, method, max_count, values=None, key='items',
-                          limit=None, stop_fn=None):
+                          limit=None, stop_fn=None, negative_offset=False):
         """ Получить все элементы (без использования execute)
         Работает в методах, где в ответе есть count и items или users
 
@@ -126,13 +126,16 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
         """
 
         values = values.copy() if values else {}
-
         values['count'] = max_count
         values['offset'] = 0
+
+        offset_mul = -1 if negative_offset else 1
         items_count = 0
         count = None
         while values['offset'] < (count or 1):
+            values['offset'] *= offset_mul
             response = self.vk.method(method, values)
+            values['offset'] *= offset_mul
             new_count = response['count']
             count_diff = new_count - (count or new_count)
 
@@ -145,6 +148,8 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
                 continue
 
             items = response[key][count_diff:]
+            if not items:
+                break
             items_count += len(items)
 
             for item in items:

From 1fc3fb54636dd93b6613a734be1a91afaefa787c Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Wed, 21 Mar 2018 10:07:30 +0300
Subject: [PATCH 09/14] Negative offset and break condition

---
 vk_api/tools.py | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 8a9e5231..575f0d39 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -30,7 +30,7 @@ def __init__(self, vk):
         self.vk = vk
 
     def get_all_iter(self, method, max_count, values=None, key='items',
-                     limit=None, stop_fn=None):
+                     limit=None, stop_fn=None, negative_offset=False):
         """ Получить все элементы.
         Работает в методах, где в ответе есть count и items или users.
         За один запрос получает max_count * 25 элементов
@@ -62,10 +62,12 @@ def get_all_iter(self, method, max_count, values=None, key='items',
         values['offset'] = 0
         items_count = 0
         count = None
+        have_more = True
 
-        while values['offset'] < (count or 1):
+        while have_more:
             response = vk_get_all_items(
-                self.vk, method=method, key=key, values=values, count=count
+                self.vk, method=method, key=key, values=values, count=count,
+                offset_mul=-1 if negative_offset else 1
             )
             count = response['count']
 
@@ -82,6 +84,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
                 break
 
             values['offset'] = response['offset']
+            have_more = response['have_more']
 
     def get_all(self, method, max_count, values=None, key='items', limit=None,
                 stop_fn=None):
@@ -148,8 +151,6 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
                 continue
 
             items = response[key][count_diff:]
-            if not items:
-                break
             items_count += len(items)
 
             for item in items:
@@ -161,6 +162,9 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             if stop_fn and stop_fn(items):
                 break
 
+            if len(items) < max_count:
+                break
+
             values['offset'] += len(items) + count_diff
             count = new_count
 
@@ -183,30 +187,39 @@ def get_all_slow(self, method, max_count, values=None, key='items',
 
 
 vk_get_all_items = VkFunction(
-    args=('method', 'key', 'values', 'count'),
-    clean_args=('method', 'key'),
+    args=('method', 'key', 'values', 'count', 'offset_mul'),
+    clean_args=('method', 'key', 'offset_mul'),
     code='''
     var params = %(values)s,
         calls = 0,
         items = [],
         count = %(count)s;
 
-    while(calls < 25 && (count == null || params.offset < count)) {
+    while(calls < 25) {
         calls = calls + 1;
+        params.offset = params.offset * %(offset_mul)s;
         var response = API.%(method)s(params), 
             new_count = response.count,
             count_diff = (count == null ? 0 : new_count - count);
+        params.offset = params.offset * %(offset_mul)s;
         if (new_count == 0) {
-            calls = 25;
+            calls = 99;
         } else if (count_diff < 0) {
             params.offset = params.offset + count_diff;
             count = new_count;
         } else {
-            items = items + response.%(key)s.slice(count_diff);
+            var r_items = response.%(key)s.slice(count_diff);
+            if (r_items.length < params.count) {
+                calls = 99;
+            }
+            items = items + r_items;
             params.offset = params.offset + params.count + count_diff;
             count = new_count;
         }
+        if (count != null && params.offset >= count) {
+            calls = 99;
+        }
     };
 
-    return {count: count, items: items, offset: params.offset};
+    return {count: count, items: items, offset: params.offset, have_more: calls != 99};
 ''')

From 62430f4ee82ddf5fedcb330bd5b2c9c80160efda Mon Sep 17 00:00:00 2001
From: python273 <iam@python273.pw>
Date: Thu, 22 Mar 2018 14:40:35 +0300
Subject: [PATCH 10/14] Refactor&Fix VkTools methods

---
 vk_api/exceptions.py |   4 ++
 vk_api/tools.py      | 120 ++++++++++++++++++++++++++-----------------
 2 files changed, 76 insertions(+), 48 deletions(-)

diff --git a/vk_api/exceptions.py b/vk_api/exceptions.py
index 648dc5ea..ce0406c4 100644
--- a/vk_api/exceptions.py
+++ b/vk_api/exceptions.py
@@ -155,3 +155,7 @@ class VkAudioException(Exception):
 
 class VkAudioUrlDecodeError(VkAudioException):
     pass
+
+
+class VkToolsException(VkApiError):
+    pass
diff --git a/vk_api/tools.py b/vk_api/tools.py
index 575f0d39..ded9be59 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -9,6 +9,7 @@
 
 import sys
 
+from .exceptions import ApiError, VkToolsException
 from .execute import VkFunction
 
 
@@ -54,37 +55,46 @@ def get_all_iter(self, method, max_count, values=None, key='items',
 
         :param stop_fn: функция, отвечающая за выход из цикла
         :type stop_fn: func
+
+        :param negative_offset: True если offset должен быть отрицательный
+        :type negative_offset: bool
         """
 
         values = values.copy() if values else {}
-
         values['count'] = max_count
-        values['offset'] = 0
+
+        offset = 0
         items_count = 0
         count = None
-        have_more = True
-
-        while have_more:
-            response = vk_get_all_items(
-                self.vk, method=method, key=key, values=values, count=count,
-                offset_mul=-1 if negative_offset else 1
-            )
-            count = response['count']
 
-            items = response[key]
+        while True:
+            try:
+                response = vk_get_all_items(
+                    self.vk, method, key, values, count, offset,
+                    offset_mul=-1 if negative_offset else 1
+                )
+            except ApiError:
+                raise VkToolsException(
+                    'Can\'t load items. Check access to requested items'
+                )
+
+            items = response['items']
             items_count += len(items)
 
             for item in items:
                 yield item
 
+            if not response['more']:
+                break
+
             if limit and items_count >= limit:
                 break
 
             if stop_fn and stop_fn(items):
                 break
 
-            values['offset'] = response['offset']
-            have_more = response['have_more']
+            count = response['count']
+            offset = response['offset']
 
     def get_all(self, method, max_count, values=None, key='items', limit=None,
                 stop_fn=None):
@@ -97,8 +107,9 @@ def get_all(self, method, max_count, values=None, key='items', limit=None,
             все данные в память
         """
 
-        items = list(self.get_all_iter(method, max_count, values, key, limit,
-                                       stop_fn))
+        items = list(
+            self.get_all_iter(method, max_count, values, key, limit, stop_fn)
+        )
 
         return {'count': len(items), key: items}
 
@@ -126,46 +137,51 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
 
         :param stop_fn: функция, отвечающая за выход из цикла
         :type stop_fn: func
+
+        :param negative_offset: True если offset должен быть отрицательный
+        :type negative_offset: bool
         """
 
         values = values.copy() if values else {}
         values['count'] = max_count
-        values['offset'] = 0
 
         offset_mul = -1 if negative_offset else 1
-        items_count = 0
+
+        offset = 0
         count = None
-        while values['offset'] < (count or 1):
-            values['offset'] *= offset_mul
+
+        items_count = 0
+
+        while count is None or offset < count:
+            values['offset'] = offset * offset_mul
             response = self.vk.method(method, values)
-            values['offset'] *= offset_mul
+
             new_count = response['count']
-            count_diff = new_count - (count or new_count)
 
-            if new_count == 0:
-                break
+            count_diff = (new_count - count) if count is not None else 0
 
             if count_diff < 0:
-                values['offset'] += count_diff
+                offset += count_diff
                 count = new_count
                 continue
 
-            items = response[key][count_diff:]
+            response_items = response[key]
+            items = response_items[count_diff:]
             items_count += len(items)
 
             for item in items:
                 yield item
 
-            if limit and items_count >= limit:
+            if len(response_items) < max_count:
                 break
 
-            if stop_fn and stop_fn(items):
+            if limit and items_count >= limit:
                 break
 
-            if len(items) < max_count:
+            if stop_fn and stop_fn(items):
                 break
 
-            values['offset'] += len(items) + count_diff
+            offset += max_count
             count = new_count
 
     def get_all_slow(self, method, max_count, values=None, key='items',
@@ -180,46 +196,54 @@ def get_all_slow(self, method, max_count, values=None, key='items',
         """
 
         items = list(
-            self.get_all_slow_iter(method, max_count, values, key, limit,
-                                   stop_fn)
+            self.get_all_slow_iter(
+                method, max_count, values, key, limit, stop_fn
+            )
         )
         return {'count': len(items), key: items}
 
 
 vk_get_all_items = VkFunction(
-    args=('method', 'key', 'values', 'count', 'offset_mul'),
-    clean_args=('method', 'key', 'offset_mul'),
+    args=('method', 'key', 'values', 'count', 'offset', 'offset_mul'),
+    clean_args=('method', 'key', 'offset', 'offset_mul'),
     code='''
     var params = %(values)s,
         calls = 0,
         items = [],
-        count = %(count)s;
+        count = %(count)s,
+        offset = %(offset)s,
+        ri;
 
     while(calls < 25) {
         calls = calls + 1;
-        params.offset = params.offset * %(offset_mul)s;
+
+        params.offset = offset * %(offset_mul)s;
         var response = API.%(method)s(params), 
             new_count = response.count,
             count_diff = (count == null ? 0 : new_count - count);
-        params.offset = params.offset * %(offset_mul)s;
-        if (new_count == 0) {
-            calls = 99;
-        } else if (count_diff < 0) {
-            params.offset = params.offset + count_diff;
-            count = new_count;
+
+        if (count_diff < 0) {
+            offset = offset + count_diff;
         } else {
-            var r_items = response.%(key)s.slice(count_diff);
-            if (r_items.length < params.count) {
+            ri = response.%(key)s.slice(count_diff);
+            items = items + ri;
+            offset = offset + params.count + count_diff;
+            if (ri.length < params.count) {
                 calls = 99;
             }
-            items = items + r_items;
-            params.offset = params.offset + params.count + count_diff;
-            count = new_count;
         }
-        if (count != null && params.offset >= count) {
+
+        count = new_count;
+
+        if (count != null && offset >= count) {
             calls = 99;
         }
     };
 
-    return {count: count, items: items, offset: params.offset, have_more: calls != 99};
+    return {
+        count: count,
+        items: items,
+        offset: offset,
+        more: calls != 99
+    };
 ''')

From aaedb78417c8a9e4a03d96c7a78bba1dfb0ab08e Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Thu, 22 Mar 2018 15:21:25 +0300
Subject: [PATCH 11/14] Break condition fix

---
 vk_api/tools.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index ded9be59..e0e41d6b 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -78,7 +78,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
                     'Can\'t load items. Check access to requested items'
                 )
 
-            items = response['items']
+            items = response[key]
             items_count += len(items)
 
             for item in items:
@@ -172,7 +172,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             for item in items:
                 yield item
 
-            if len(response_items) < max_count:
+            if len(response_items) < max_count - count_diff:
                 break
 
             if limit and items_count >= limit:
@@ -228,7 +228,7 @@ def get_all_slow(self, method, max_count, values=None, key='items',
             ri = response.%(key)s.slice(count_diff);
             items = items + ri;
             offset = offset + params.count + count_diff;
-            if (ri.length < params.count) {
+            if (ri.length < params.count - count_diff) {
                 calls = 99;
             }
         }

From aa1d7a3ae85a390c3771b49914d2b1ba2f11d144 Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Thu, 22 Mar 2018 15:58:58 +0300
Subject: [PATCH 12/14] Changed initial negative offset

---
 vk_api/tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index e0e41d6b..5606e81e 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -147,7 +147,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
 
         offset_mul = -1 if negative_offset else 1
 
-        offset = 0
+        offset = max_count if negative_offset else 0
         count = None
 
         items_count = 0

From a0ee22d48cde11deb0e868f81ae06070af6249bb Mon Sep 17 00:00:00 2001
From: hdk5 <humandk55@gmail.com>
Date: Fri, 23 Mar 2018 08:32:52 +0300
Subject: [PATCH 13/14] Fixed get_all_iter response key

---
 vk_api/tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 5606e81e..48a3b8c0 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -78,7 +78,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
                     'Can\'t load items. Check access to requested items'
                 )
 
-            items = response[key]
+            items = response["items"]
             items_count += len(items)
 
             for item in items:

From aed5b6ebf05b9f2302571052200c032865c33ef5 Mon Sep 17 00:00:00 2001
From: python273 <iam@python273.pw>
Date: Fri, 23 Mar 2018 10:44:18 +0300
Subject: [PATCH 14/14] Refactor VkTools methods

---
 vk_api/tools.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/vk_api/tools.py b/vk_api/tools.py
index 48a3b8c0..d50d8efd 100644
--- a/vk_api/tools.py
+++ b/vk_api/tools.py
@@ -97,7 +97,7 @@ def get_all_iter(self, method, max_count, values=None, key='items',
             offset = response['offset']
 
     def get_all(self, method, max_count, values=None, key='items', limit=None,
-                stop_fn=None):
+                stop_fn=None, negative_offset=False):
         """ Использовать только если нужно загрузить все объекты в память.
 
             Eсли вы можете обрабатывать объекты по частям, то лучше
@@ -108,7 +108,9 @@ def get_all(self, method, max_count, values=None, key='items', limit=None,
         """
 
         items = list(
-            self.get_all_iter(method, max_count, values, key, limit, stop_fn)
+            self.get_all_iter(
+                method, max_count, values, key, limit, stop_fn, negative_offset
+            )
         )
 
         return {'count': len(items), key: items}
@@ -185,7 +187,7 @@ def get_all_slow_iter(self, method, max_count, values=None, key='items',
             count = new_count
 
     def get_all_slow(self, method, max_count, values=None, key='items',
-                     limit=None, stop_fn=None):
+                     limit=None, stop_fn=None, negative_offset=False):
         """ Использовать только если нужно загрузить все объекты в память.
 
             Eсли вы можете обрабатывать объекты по частям, то лучше
@@ -197,7 +199,7 @@ def get_all_slow(self, method, max_count, values=None, key='items',
 
         items = list(
             self.get_all_slow_iter(
-                method, max_count, values, key, limit, stop_fn
+                method, max_count, values, key, limit, stop_fn, negative_offset
             )
         )
         return {'count': len(items), key: items}
@@ -225,10 +227,10 @@ def get_all_slow(self, method, max_count, values=None, key='items',
         if (count_diff < 0) {
             offset = offset + count_diff;
         } else {
-            ri = response.%(key)s.slice(count_diff);
-            items = items + ri;
+            ri = response.%(key)s;
+            items = items + ri.slice(count_diff);
             offset = offset + params.count + count_diff;
-            if (ri.length < params.count - count_diff) {
+            if (ri.length < params.count) {
                 calls = 99;
             }
         }