File size: 4,568 Bytes
8247f19 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | # Patch-overlapping Python context after the fix
## `rasa/model.py` — `function:unpack_model` (lines 210-239)
```python
def unpack_model(
model_file: Text, working_directory: Optional[Union[Path, Text]] = None
) -> TempDirectoryPath:
"""Unpack a zipped Rasa model.
Args:
model_file: Path to zipped model.
working_directory: Location where the model should be unpacked to.
If `None` a temporary directory will be created.
Returns:
Path to unpacked Rasa model.
"""
import tarfile
from tarsafe import TarSafe
if working_directory is None:
working_directory = tempfile.mkdtemp()
# All files are in a subdirectory.
try:
with TarSafe.open(model_file, mode="r:gz") as tar:
tar.extractall(working_directory)
logger.debug(f"Extracted model to '{working_directory}'.")
except (tarfile.TarError, ValueError) as e:
logger.error(f"Failed to extract model at {model_file}. Error: {e}")
raise
return TempDirectoryPath(working_directory)
```
## `rasa/nlu/persistor.py` — `class:Persistor` (lines 50-107)
```python
class Persistor(abc.ABC):
"""Store models in cloud and fetch them when needed."""
def persist(self, model_directory: Text, model_name: Text) -> None:
"""Uploads a model persisted in the `target_dir` to cloud storage."""
if not os.path.isdir(model_directory):
raise ValueError(f"Target directory '{model_directory}' not found.")
file_key, tar_path = self._compress(model_directory, model_name)
self._persist_tar(file_key, tar_path)
def retrieve(self, model_name: Text, target_path: Text) -> None:
"""Downloads a model that has been persisted to cloud storage."""
tar_name = model_name
if not model_name.endswith("tar.gz"):
# ensure backward compatibility
tar_name = self._tar_name(model_name)
self._retrieve_tar(tar_name)
self._decompress(os.path.basename(tar_name), target_path)
@abc.abstractmethod
def _retrieve_tar(self, filename: Text) -> Text:
"""Downloads a model previously persisted to cloud storage."""
raise NotImplementedError
@abc.abstractmethod
def _persist_tar(self, filekey: Text, tarname: Text) -> None: # noqa: F841
"""Uploads a model persisted in the `target_dir` to cloud storage."""
raise NotImplementedError
def _compress(self, model_directory: Text, model_name: Text) -> Tuple[Text, Text]:
"""Creates a compressed archive and returns key and tar."""
import tempfile
dirpath = tempfile.mkdtemp()
base_name = self._tar_name(model_name, include_extension=False)
tar_name = shutil.make_archive(
os.path.join(dirpath, base_name),
"gztar",
root_dir=model_directory,
base_dir=".",
)
file_key = os.path.basename(tar_name)
return file_key, tar_name
@staticmethod
def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
ext = ".tar.gz" if include_extension else ""
return f"{model_name}{ext}"
@staticmethod
def _decompress(compressed_path: Text, target_path: Text) -> None:
with TarSafe.open(compressed_path, "r:gz") as tar:
tar.extractall(target_path) # target dir will be created if it not exists
```
## `rasa/nlu/persistor.py` — `function:Persistor._decompress` (lines 103-107)
```python
def _decompress(compressed_path: Text, target_path: Text) -> None:
with TarSafe.open(compressed_path, "r:gz") as tar:
tar.extractall(target_path) # target dir will be created if it not exists
```
## `rasa/nlu/persistor.py` — `module:<module>@5` (lines 5-5)
```python
from tarsafe import TarSafe
```
## `rasa/utils/io.py` — `function:unarchive` (lines 85-99)
```python
def unarchive(byte_array: bytes, directory: Text) -> Text:
"""Tries to unpack a byte array interpreting it as an archive.
Tries to use tar first to unpack, if that fails, zip will be used."""
try:
tar = TarSafe.open(fileobj=IOReader(byte_array))
tar.extractall(directory)
tar.close()
return directory
except tarfile.TarError:
zip_ref = zipfile.ZipFile(IOReader(byte_array))
zip_ref.extractall(directory)
zip_ref.close()
return directory
```
## `rasa/utils/io.py` — `module:<module>@6` (lines 6-6)
```python
from tarsafe import TarSafe
```
|