We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Empty file cant sync in pootle fs
if for some reason a file is empty - theres no way to get pootle fs to fill it again. All seems to work but it remains empty

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `pootle/apps/pootle_fs/files.py`
Content:
```
1 # -*- coding: utf-8 -*-
2 #
3 # Copyright (C) Pootle contributors.
4 #
5 # This file is a part of the Pootle project. It is distributed under the GPL3
6 # or later license. See the LICENSE file for a copy of the license and the
7 # AUTHORS file for copyright and authorship information.
8 
9 import logging
10 import os
11 
12 from translate.storage.factory import getclass
13 
14 from django.contrib.auth import get_user_model
15 from django.utils.functional import cached_property
16 
17 from pootle.core.models import Revision
18 from pootle.core.proxy import AttributeProxy
19 from pootle_statistics.models import SubmissionTypes
20 from pootle_store.constants import POOTLE_WINS, SOURCE_WINS
21 from pootle_store.models import Store
22 
23 
24 logger = logging.getLogger(__name__)
25 
26 User = get_user_model()
27 
28 
29 class FSFile(object):
30 
31     def __init__(self, store_fs):
32         """
33         :param store_fs: ``StoreFS`` object
34         """
35         from .models import StoreFS
36 
37         if not isinstance(store_fs, StoreFS):
38             raise TypeError(
39                 "pootle_fs.FSFile expects a StoreFS")
40         self.store_fs = store_fs
41         self.pootle_path = store_fs.pootle_path
42         self.path = store_fs.path
43 
44     def __str__(self):
45         return "<%s: %s::%s>" % (
46             self.__class__.__name__, self.pootle_path, self.path)
47 
48     def __hash__(self):
49         return hash(
50             "%s::%s::%s::%s"
51             % (self.path,
52                self.pootle_path,
53                self.store_fs.last_sync_hash,
54                self.store_fs.last_sync_revision))
55 
56     def __eq__(self, other):
57         return hash(other) == hash(self)
58 
59     @property
60     def file_exists(self):
61         return os.path.exists(self.file_path)
62 
63     @property
64     def store_exists(self):
65         return self.store is not None
66 
67     @property
68     def file_path(self):
69         return os.path.join(
70             self.store_fs.project.local_fs_path,
71             self.path.strip("/"))
72 
73     @property
74     def fs_changed(self):
75         return (
76             self.latest_hash
77             != self.store_fs.last_sync_hash)
78 
79     @property
80     def latest_hash(self):
81         if self.file_exists:
82             return str(os.stat(self.file_path).st_mtime)
83 
84     @property
85     def latest_author(self):
86         return None, None
87 
88     @property
89     def plugin(self):
90         return self.store_fs.plugin
91 
92     @property
93     def pootle_changed(self):
94         return bool(
95             self.store_exists
96             and (
97                 (self.store.data.max_unit_revision or 0)
98                 != self.store_fs.last_sync_revision))
99 
100     @cached_property
101     def store(self):
102         return self.store_fs.store
103 
104     def create_store(self):
105         """
106         Creates a ```Store``` and if necessary the ```TranslationProject```
107         parent ```Directories```
108         """
109         store = Store.objects.create_by_path(
110             self.pootle_path,
111             project=self.store_fs.project)
112         self.store_fs.store = store
113         self.store_fs.save()
114         self.__dict__["store"] = self.store_fs.store
115 
116     def delete(self):
117         """
118         Delete the file from FS and Pootle
119 
120         This does not commit/push
121         """
122         store = self.store
123         if store and store.pk:
124             store.makeobsolete()
125             del self.__dict__["store"]
126         if self.store_fs.pk:
127             self.store_fs.delete()
128         self.remove_file()
129 
130     def on_sync(self, last_sync_hash, last_sync_revision, save=True):
131         """
132         Called after FS and Pootle have been synced
133         """
134         self.store_fs.resolve_conflict = None
135         self.store_fs.staged_for_merge = False
136         self.store_fs.last_sync_hash = last_sync_hash
137         self.store_fs.last_sync_revision = last_sync_revision
138         if save:
139             self.store_fs.save()
140 
141     @property
142     def latest_user(self):
143         author, author_email = self.latest_author
144         if not author or not author_email:
145             return self.plugin.pootle_user
146         try:
147             return User.objects.get(email=author_email)
148         except User.DoesNotExist:
149             try:
150                 return User.objects.get(username=author)
151             except User.DoesNotExist:
152                 return self.plugin.pootle_user
153 
154     def pull(self, user=None, merge=False, pootle_wins=None):
155         """
156         Pull FS file into Pootle
157         """
158         if self.store_exists and not self.fs_changed:
159             return
160         logger.debug("Pulling file: %s", self.path)
161         if not self.store_exists:
162             self.create_store()
163         if self.store.obsolete:
164             self.store.resurrect()
165         return self._sync_to_pootle(
166             merge=merge, pootle_wins=pootle_wins)
167 
168     def push(self, user=None):
169         """
170         Push Pootle ``Store`` into FS
171         """
172         dont_push = (
173             not self.store_exists
174             or (self.file_exists and not self.pootle_changed))
175         if dont_push:
176             return
177         logger.debug("Pushing file: %s", self.path)
178         directory = os.path.dirname(self.file_path)
179         if not os.path.exists(directory):
180             logger.debug("Creating directory: %s", directory)
181             os.makedirs(directory)
182         return self._sync_from_pootle()
183 
184     def read(self):
185         if not self.file_exists:
186             return
187         with open(self.file_path) as f:
188             return f.read()
189 
190     def remove_file(self):
191         if self.file_exists:
192             os.unlink(self.file_path)
193 
194     def deserialize(self, create=False):
195         if not create and not self.file_exists:
196             return
197         if self.file_exists:
198             with open(self.file_path) as f:
199                 f = AttributeProxy(f)
200                 f.location_root = self.store_fs.project.local_fs_path
201                 store_file = (
202                     self.store.syncer.file_class(f)
203                     if self.store and self.store.syncer.file_class
204                     else getclass(f)(f.read()))
205             return store_file
206         if self.store_exists:
207             return self.store.deserialize(self.store.serialize())
208 
209     def serialize(self):
210         if not self.store_exists:
211             return
212         return self.store.serialize()
213 
214     def _sync_from_pootle(self):
215         """
216         Update FS file with the serialized content from Pootle ```Store```
217         """
218         disk_store = self.deserialize(create=True)
219         self.store.syncer.sync(disk_store, self.store.data.max_unit_revision)
220         with open(self.file_path, "w") as f:
221             f.write(str(disk_store))
222         logger.debug("Pushed file: %s", self.path)
223         return self.store.data.max_unit_revision
224 
225     def _sync_to_pootle(self, merge=False, pootle_wins=None):
226         """
227         Update Pootle ``Store`` with the parsed FS file.
228         """
229         tmp_store = self.deserialize()
230         if not tmp_store:
231             logger.warn("File staged for sync has disappeared: %s", self.path)
232             return
233         if pootle_wins is None:
234             resolve_conflict = (
235                 self.store_fs.resolve_conflict or SOURCE_WINS)
236         elif pootle_wins:
237             resolve_conflict = POOTLE_WINS
238         else:
239             resolve_conflict = SOURCE_WINS
240         if merge:
241             revision = self.store_fs.last_sync_revision or 0
242         else:
243             # We set the revision to *anything* higher than the Store's
244             # This is analogous to the `overwrite` option in
245             # Store.update_from_disk
246             revision = Revision.get() + 1
247         update_revision, __ = self.store.update(
248             tmp_store,
249             submission_type=SubmissionTypes.SYSTEM,
250             user=self.latest_user,
251             store_revision=revision,
252             resolve_conflict=resolve_conflict)
253         logger.debug("Pulled file: %s", self.path)
254         return update_revision
255
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/pootle/apps/pootle_fs/files.py b/pootle/apps/pootle_fs/files.py
--- a/pootle/apps/pootle_fs/files.py
+++ b/pootle/apps/pootle_fs/files.py
@@ -202,7 +202,8 @@
                     self.store.syncer.file_class(f)
                     if self.store and self.store.syncer.file_class
                     else getclass(f)(f.read()))
-            return store_file
+            if store_file.units:
+                return store_file
         if self.store_exists:
             return self.store.deserialize(self.store.serialize())

{"golden_diff": "diff --git a/pootle/apps/pootle_fs/files.py b/pootle/apps/pootle_fs/files.py\n--- a/pootle/apps/pootle_fs/files.py\n+++ b/pootle/apps/pootle_fs/files.py\n@@ -202,7 +202,8 @@\n                     self.store.syncer.file_class(f)\n                     if self.store and self.store.syncer.file_class\n                     else getclass(f)(f.read()))\n-            return store_file\n+            if store_file.units:\n+                return store_file\n         if self.store_exists:\n             return self.store.deserialize(self.store.serialize())\n", "issue": "Empty file cant sync in pootle fs\nif for some reason a file is empty - theres no way to get pootle fs to fill it again. All seems to work but it remains empty\n", "before_files": [{"content": "# -*- coding: utf-8 -*-\n#\n# Copyright (C) Pootle contributors.\n#\n# This file is a part of the Pootle project. It is distributed under the GPL3\n# or later license. See the LICENSE file for a copy of the license and the\n# AUTHORS file for copyright and authorship information.\n\nimport logging\nimport os\n\nfrom translate.storage.factory import getclass\n\nfrom django.contrib.auth import get_user_model\nfrom django.utils.functional import cached_property\n\nfrom pootle.core.models import Revision\nfrom pootle.core.proxy import AttributeProxy\nfrom pootle_statistics.models import SubmissionTypes\nfrom pootle_store.constants import POOTLE_WINS, SOURCE_WINS\nfrom pootle_store.models import Store\n\n\nlogger = logging.getLogger(__name__)\n\nUser = get_user_model()\n\n\nclass FSFile(object):\n\n    def __init__(self, store_fs):\n        \"\"\"\n        :param store_fs: ``StoreFS`` object\n        \"\"\"\n        from .models import StoreFS\n\n        if not isinstance(store_fs, StoreFS):\n            raise TypeError(\n                \"pootle_fs.FSFile expects a StoreFS\")\n        self.store_fs = store_fs\n        self.pootle_path = store_fs.pootle_path\n        self.path = store_fs.path\n\n    def __str__(self):\n        return \"<%s: %s::%s>\" % (\n            self.__class__.__name__, self.pootle_path, self.path)\n\n    def __hash__(self):\n        return hash(\n            \"%s::%s::%s::%s\"\n            % (self.path,\n               self.pootle_path,\n               self.store_fs.last_sync_hash,\n               self.store_fs.last_sync_revision))\n\n    def __eq__(self, other):\n        return hash(other) == hash(self)\n\n    @property\n    def file_exists(self):\n        return os.path.exists(self.file_path)\n\n    @property\n    def store_exists(self):\n        return self.store is not None\n\n    @property\n    def file_path(self):\n        return os.path.join(\n            self.store_fs.project.local_fs_path,\n            self.path.strip(\"/\"))\n\n    @property\n    def fs_changed(self):\n        return (\n            self.latest_hash\n            != self.store_fs.last_sync_hash)\n\n    @property\n    def latest_hash(self):\n        if self.file_exists:\n            return str(os.stat(self.file_path).st_mtime)\n\n    @property\n    def latest_author(self):\n        return None, None\n\n    @property\n    def plugin(self):\n        return self.store_fs.plugin\n\n    @property\n    def pootle_changed(self):\n        return bool(\n            self.store_exists\n            and (\n                (self.store.data.max_unit_revision or 0)\n                != self.store_fs.last_sync_revision))\n\n    @cached_property\n    def store(self):\n        return self.store_fs.store\n\n    def create_store(self):\n        \"\"\"\n        Creates a ```Store``` and if necessary the ```TranslationProject```\n        parent ```Directories```\n        \"\"\"\n        store = Store.objects.create_by_path(\n            self.pootle_path,\n            project=self.store_fs.project)\n        self.store_fs.store = store\n        self.store_fs.save()\n        self.__dict__[\"store\"] = self.store_fs.store\n\n    def delete(self):\n        \"\"\"\n        Delete the file from FS and Pootle\n\n        This does not commit/push\n        \"\"\"\n        store = self.store\n        if store and store.pk:\n            store.makeobsolete()\n            del self.__dict__[\"store\"]\n        if self.store_fs.pk:\n            self.store_fs.delete()\n        self.remove_file()\n\n    def on_sync(self, last_sync_hash, last_sync_revision, save=True):\n        \"\"\"\n        Called after FS and Pootle have been synced\n        \"\"\"\n        self.store_fs.resolve_conflict = None\n        self.store_fs.staged_for_merge = False\n        self.store_fs.last_sync_hash = last_sync_hash\n        self.store_fs.last_sync_revision = last_sync_revision\n        if save:\n            self.store_fs.save()\n\n    @property\n    def latest_user(self):\n        author, author_email = self.latest_author\n        if not author or not author_email:\n            return self.plugin.pootle_user\n        try:\n            return User.objects.get(email=author_email)\n        except User.DoesNotExist:\n            try:\n                return User.objects.get(username=author)\n            except User.DoesNotExist:\n                return self.plugin.pootle_user\n\n    def pull(self, user=None, merge=False, pootle_wins=None):\n        \"\"\"\n        Pull FS file into Pootle\n        \"\"\"\n        if self.store_exists and not self.fs_changed:\n            return\n        logger.debug(\"Pulling file: %s\", self.path)\n        if not self.store_exists:\n            self.create_store()\n        if self.store.obsolete:\n            self.store.resurrect()\n        return self._sync_to_pootle(\n            merge=merge, pootle_wins=pootle_wins)\n\n    def push(self, user=None):\n        \"\"\"\n        Push Pootle ``Store`` into FS\n        \"\"\"\n        dont_push = (\n            not self.store_exists\n            or (self.file_exists and not self.pootle_changed))\n        if dont_push:\n            return\n        logger.debug(\"Pushing file: %s\", self.path)\n        directory = os.path.dirname(self.file_path)\n        if not os.path.exists(directory):\n            logger.debug(\"Creating directory: %s\", directory)\n            os.makedirs(directory)\n        return self._sync_from_pootle()\n\n    def read(self):\n        if not self.file_exists:\n            return\n        with open(self.file_path) as f:\n            return f.read()\n\n    def remove_file(self):\n        if self.file_exists:\n            os.unlink(self.file_path)\n\n    def deserialize(self, create=False):\n        if not create and not self.file_exists:\n            return\n        if self.file_exists:\n            with open(self.file_path) as f:\n                f = AttributeProxy(f)\n                f.location_root = self.store_fs.project.local_fs_path\n                store_file = (\n                    self.store.syncer.file_class(f)\n                    if self.store and self.store.syncer.file_class\n                    else getclass(f)(f.read()))\n            return store_file\n        if self.store_exists:\n            return self.store.deserialize(self.store.serialize())\n\n    def serialize(self):\n        if not self.store_exists:\n            return\n        return self.store.serialize()\n\n    def _sync_from_pootle(self):\n        \"\"\"\n        Update FS file with the serialized content from Pootle ```Store```\n        \"\"\"\n        disk_store = self.deserialize(create=True)\n        self.store.syncer.sync(disk_store, self.store.data.max_unit_revision)\n        with open(self.file_path, \"w\") as f:\n            f.write(str(disk_store))\n        logger.debug(\"Pushed file: %s\", self.path)\n        return self.store.data.max_unit_revision\n\n    def _sync_to_pootle(self, merge=False, pootle_wins=None):\n        \"\"\"\n        Update Pootle ``Store`` with the parsed FS file.\n        \"\"\"\n        tmp_store = self.deserialize()\n        if not tmp_store:\n            logger.warn(\"File staged for sync has disappeared: %s\", self.path)\n            return\n        if pootle_wins is None:\n            resolve_conflict = (\n                self.store_fs.resolve_conflict or SOURCE_WINS)\n        elif pootle_wins:\n            resolve_conflict = POOTLE_WINS\n        else:\n            resolve_conflict = SOURCE_WINS\n        if merge:\n            revision = self.store_fs.last_sync_revision or 0\n        else:\n            # We set the revision to *anything* higher than the Store's\n            # This is analogous to the `overwrite` option in\n            # Store.update_from_disk\n            revision = Revision.get() + 1\n        update_revision, __ = self.store.update(\n            tmp_store,\n            submission_type=SubmissionTypes.SYSTEM,\n            user=self.latest_user,\n            store_revision=revision,\n            resolve_conflict=resolve_conflict)\n        logger.debug(\"Pulled file: %s\", self.path)\n        return update_revision\n", "path": "pootle/apps/pootle_fs/files.py"}], "after_files": [{"content": "# -*- coding: utf-8 -*-\n#\n# Copyright (C) Pootle contributors.\n#\n# This file is a part of the Pootle project. It is distributed under the GPL3\n# or later license. See the LICENSE file for a copy of the license and the\n# AUTHORS file for copyright and authorship information.\n\nimport logging\nimport os\n\nfrom translate.storage.factory import getclass\n\nfrom django.contrib.auth import get_user_model\nfrom django.utils.functional import cached_property\n\nfrom pootle.core.models import Revision\nfrom pootle.core.proxy import AttributeProxy\nfrom pootle_statistics.models import SubmissionTypes\nfrom pootle_store.constants import POOTLE_WINS, SOURCE_WINS\nfrom pootle_store.models import Store\n\n\nlogger = logging.getLogger(__name__)\n\nUser = get_user_model()\n\n\nclass FSFile(object):\n\n    def __init__(self, store_fs):\n        \"\"\"\n        :param store_fs: ``StoreFS`` object\n        \"\"\"\n        from .models import StoreFS\n\n        if not isinstance(store_fs, StoreFS):\n            raise TypeError(\n                \"pootle_fs.FSFile expects a StoreFS\")\n        self.store_fs = store_fs\n        self.pootle_path = store_fs.pootle_path\n        self.path = store_fs.path\n\n    def __str__(self):\n        return \"<%s: %s::%s>\" % (\n            self.__class__.__name__, self.pootle_path, self.path)\n\n    def __hash__(self):\n        return hash(\n            \"%s::%s::%s::%s\"\n            % (self.path,\n               self.pootle_path,\n               self.store_fs.last_sync_hash,\n               self.store_fs.last_sync_revision))\n\n    def __eq__(self, other):\n        return hash(other) == hash(self)\n\n    @property\n    def file_exists(self):\n        return os.path.exists(self.file_path)\n\n    @property\n    def store_exists(self):\n        return self.store is not None\n\n    @property\n    def file_path(self):\n        return os.path.join(\n            self.store_fs.project.local_fs_path,\n            self.path.strip(\"/\"))\n\n    @property\n    def fs_changed(self):\n        return (\n            self.latest_hash\n            != self.store_fs.last_sync_hash)\n\n    @property\n    def latest_hash(self):\n        if self.file_exists:\n            return str(os.stat(self.file_path).st_mtime)\n\n    @property\n    def latest_author(self):\n        return None, None\n\n    @property\n    def plugin(self):\n        return self.store_fs.plugin\n\n    @property\n    def pootle_changed(self):\n        return bool(\n            self.store_exists\n            and (\n                (self.store.data.max_unit_revision or 0)\n                != self.store_fs.last_sync_revision))\n\n    @cached_property\n    def store(self):\n        return self.store_fs.store\n\n    def create_store(self):\n        \"\"\"\n        Creates a ```Store``` and if necessary the ```TranslationProject```\n        parent ```Directories```\n        \"\"\"\n        store = Store.objects.create_by_path(\n            self.pootle_path,\n            project=self.store_fs.project)\n        self.store_fs.store = store\n        self.store_fs.save()\n        self.__dict__[\"store\"] = self.store_fs.store\n\n    def delete(self):\n        \"\"\"\n        Delete the file from FS and Pootle\n\n        This does not commit/push\n        \"\"\"\n        store = self.store\n        if store and store.pk:\n            store.makeobsolete()\n            del self.__dict__[\"store\"]\n        if self.store_fs.pk:\n            self.store_fs.delete()\n        self.remove_file()\n\n    def on_sync(self, last_sync_hash, last_sync_revision, save=True):\n        \"\"\"\n        Called after FS and Pootle have been synced\n        \"\"\"\n        self.store_fs.resolve_conflict = None\n        self.store_fs.staged_for_merge = False\n        self.store_fs.last_sync_hash = last_sync_hash\n        self.store_fs.last_sync_revision = last_sync_revision\n        if save:\n            self.store_fs.save()\n\n    @property\n    def latest_user(self):\n        author, author_email = self.latest_author\n        if not author or not author_email:\n            return self.plugin.pootle_user\n        try:\n            return User.objects.get(email=author_email)\n        except User.DoesNotExist:\n            try:\n                return User.objects.get(username=author)\n            except User.DoesNotExist:\n                return self.plugin.pootle_user\n\n    def pull(self, user=None, merge=False, pootle_wins=None):\n        \"\"\"\n        Pull FS file into Pootle\n        \"\"\"\n        if self.store_exists and not self.fs_changed:\n            return\n        logger.debug(\"Pulling file: %s\", self.path)\n        if not self.store_exists:\n            self.create_store()\n        if self.store.obsolete:\n            self.store.resurrect()\n        return self._sync_to_pootle(\n            merge=merge, pootle_wins=pootle_wins)\n\n    def push(self, user=None):\n        \"\"\"\n        Push Pootle ``Store`` into FS\n        \"\"\"\n        dont_push = (\n            not self.store_exists\n            or (self.file_exists and not self.pootle_changed))\n        if dont_push:\n            return\n        logger.debug(\"Pushing file: %s\", self.path)\n        directory = os.path.dirname(self.file_path)\n        if not os.path.exists(directory):\n            logger.debug(\"Creating directory: %s\", directory)\n            os.makedirs(directory)\n        return self._sync_from_pootle()\n\n    def read(self):\n        if not self.file_exists:\n            return\n        with open(self.file_path) as f:\n            return f.read()\n\n    def remove_file(self):\n        if self.file_exists:\n            os.unlink(self.file_path)\n\n    def deserialize(self, create=False):\n        if not create and not self.file_exists:\n            return\n        if self.file_exists:\n            with open(self.file_path) as f:\n                f = AttributeProxy(f)\n                f.location_root = self.store_fs.project.local_fs_path\n                store_file = (\n                    self.store.syncer.file_class(f)\n                    if self.store and self.store.syncer.file_class\n                    else getclass(f)(f.read()))\n            if store_file.units:\n                return store_file\n        if self.store_exists:\n            return self.store.deserialize(self.store.serialize())\n\n    def serialize(self):\n        if not self.store_exists:\n            return\n        return self.store.serialize()\n\n    def _sync_from_pootle(self):\n        \"\"\"\n        Update FS file with the serialized content from Pootle ```Store```\n        \"\"\"\n        disk_store = self.deserialize(create=True)\n        self.store.syncer.sync(disk_store, self.store.data.max_unit_revision)\n        with open(self.file_path, \"w\") as f:\n            f.write(str(disk_store))\n        logger.debug(\"Pushed file: %s\", self.path)\n        return self.store.data.max_unit_revision\n\n    def _sync_to_pootle(self, merge=False, pootle_wins=None):\n        \"\"\"\n        Update Pootle ``Store`` with the parsed FS file.\n        \"\"\"\n        tmp_store = self.deserialize()\n        if not tmp_store:\n            logger.warn(\"File staged for sync has disappeared: %s\", self.path)\n            return\n        if pootle_wins is None:\n            resolve_conflict = (\n                self.store_fs.resolve_conflict or SOURCE_WINS)\n        elif pootle_wins:\n            resolve_conflict = POOTLE_WINS\n        else:\n            resolve_conflict = SOURCE_WINS\n        if merge:\n            revision = self.store_fs.last_sync_revision or 0\n        else:\n            # We set the revision to *anything* higher than the Store's\n            # This is analogous to the `overwrite` option in\n            # Store.update_from_disk\n            revision = Revision.get() + 1\n        update_revision, __ = self.store.update(\n            tmp_store,\n            submission_type=SubmissionTypes.SYSTEM,\n            user=self.latest_user,\n            store_revision=revision,\n            resolve_conflict=resolve_conflict)\n        logger.debug(\"Pulled file: %s\", self.path)\n        return update_revision\n", "path": "pootle/apps/pootle_fs/files.py"}]}