(jsonapi) Fix mutability issue with collections

Here is the problem: Lets assume you have a paginated collection:

```python
organization = transifex_api.Organization.get(...)
first_page = organization.fetch("projects")
first_page._params  # <<< {}
for project in first_page:
    do_something_with(project)
```

Now lets suppose that you get the next page:

```python
next_page = first_page.next()
for project in next_page:
    do_something_with(project)
```

Now, lets inspect the params of the first page:

```python
first_page._params  # <<< {'page[cursor]': "..."}
```

Here is the problem: `next` does this

```python
def next(self):
    return self.__class__(self.API, self.next_url, self._params)
```

`self.__class__()` will call `__init__` which will do:

```python
def __init__(self, API, url, params=None):
    ...
    query_params = ...
    params.update(query_params)
    ...
```

There are two problems here:

- The first one is that the `params.update(...)` call will modify the
  params variable which is a reference to the `._params` attribute of the
  **first** page. This explains the bug. We should make sure that the
  initializer modifies a copy of the parameters to protect from this
  issue.

- The second problem is that the first page's `.next()` call has no
  business providing (a copy of) its parameters to the initializer; it's
  the job of the server to include any parameters in the pagination URL
  itself.

This can also occur if you use `.all()` or `.all_pages()` (and if there
are more than one pages) before using the parameters of the first page
again, for example if you want to apply a filter to the collection.

Author: Konstantinos Bairaktaris

transifex/api/jsonapi/collections.py

@@ -8,6 +8,8 @@ class Collection(abc.MutableSequence):
     def __init__(self, API, url, params=None):
         if params is None:
             params = {}
+        else:
+            params = dict(params)
 
         parsed = urlparse(url)
         path, query = parsed.path, parsed.query
@@ -55,8 +57,7 @@ def _evaluate(self, response_body=None):
             return
 
         if response_body is None:
-            response_body = self.API.request(
-                "get", self._url, params=self._params)
+            response_body = self.API.request("get", self._url, params=self._params)
         included = {}
         if "included" in response_body:
             included = {
@@ -69,14 +70,12 @@ def _evaluate(self, response_body=None):
             for (name, relationship) in item.get("relationships", {}).items():
                 if relationship is None or "data" not in relationship:
                     continue
-                key = (relationship["data"]["type"],
-                       relationship["data"]["id"])
+                key = (relationship["data"]["type"], relationship["data"]["id"])
                 if key in included:
                     related[name] = self.API.new(included[key])
             relationships = item.pop("relationships", {})
             relationships.update(related)
-            self._data.append(self.API.new(
-                relationships=relationships, **item))
+            self._data.append(self.API.new(relationships=relationships, **item))
 
         self._next_url = response_body.get("links", {}).get("next")
         self._previous_url = response_body.get("links", {}).get("previous")
@@ -104,8 +103,7 @@ def to_dict(self):
         self_url = self._url
         if self._params:
             self_url += "?" + "&".join(
-                ("{}={}".format(key, value)
-                 for key, value in self._params.items())
+                ("{}={}".format(key, value) for key, value in self._params.items())
             )
 
         links = {"self": self_url}
@@ -125,13 +123,13 @@ def has_next(self):
         return bool(self.next_url)
 
     def next(self):
-        return self.__class__(self.API, self.next_url, self._params)
+        return self.__class__(self.API, self.next_url)
 
     def has_previous(self):
         return bool(self.previous_url)
 
     def previous(self):
-        return self.__class__(self.API, self.previous_url, self._params)
+        return self.__class__(self.API, self.previous_url)
 
     def all_pages(self):
         if self.data:
@@ -153,8 +151,7 @@ def filter(self, **filters):
         params = dict(self._params)
 
         for key, value in filters.items():
-            key = "filter" + "".join(("[{}]".format(part)
-                                      for part in key.split("__")))
+            key = "filter" + "".join(("[{}]".format(part) for part in key.split("__")))
             if isinstance(value, Resource):
                 value = value.id