SDK binary support for executions

appwrite/client.py

@@ -1,8 +1,7 @@
-import io
 import json
-import os
 import requests
-from .input_file import InputFile
+from .payload import Payload
+from .multipart import MultipartParser
 from .exception import AppwriteException
 from .encoders.value_class_encoder import ValueClassEncoder
 
@@ -13,11 +12,11 @@ def __init__(self):
         self._endpoint = 'https://cloud.appwrite.io/v1'
         self._global_headers = {
             'content-type': '',
-            'user-agent' : 'AppwritePythonSDK/6.1.0 (${os.uname().sysname}; ${os.uname().version}; ${os.uname().machine})',
+            'user-agent' : 'AppwritePythonSDK/7.0.0 (${os.uname().sysname}; ${os.uname().version}; ${os.uname().machine})',
             'x-sdk-name': 'Python',
             'x-sdk-platform': 'server',
             'x-sdk-language': 'python',
-            'x-sdk-version': '6.1.0',
+            'x-sdk-version': '7.0.0',
             'X-Appwrite-Response-Format' : '1.6.0',
         }
 
@@ -91,11 +90,15 @@ def call(self, method, path='', headers=None, params=None, response_type='json')
 
         if headers['content-type'].startswith('multipart/form-data'):
             del headers['content-type']
+            headers['accept'] = 'multipart/form-data'
             stringify = True
             for key in data.copy():
-                if isinstance(data[key], InputFile):
-                    files[key] = (data[key].filename, data[key].data)
-                    del data[key]
+                if isinstance(data[key], Payload):
+                    if data[key].filename:
+                        files[key] = (data[key].filename, data[key].to_binary())
+                        del data[key]
+                    else:
+                        data[key] = data[key].to_string()  
             data = self.flatten(data, stringify=stringify)
 
         response = None
@@ -126,6 +129,9 @@ def call(self, method, path='', headers=None, params=None, response_type='json')
             if content_type.startswith('application/json'):
                 return response.json()
 
+            if content_type.startswith('multipart/form-data'): 
+                return MultipartParser(response.content, content_type).to_dict()
+
             return response._content
         except Exception as e:
             if response != None:
@@ -146,20 +152,10 @@ def chunked_upload(
         on_progress = None,
         upload_id = ''
     ):
-        input_file = params[param_name]
-
-        if input_file.source_type == 'path':
-            size = os.stat(input_file.path).st_size
-            input = open(input_file.path, 'rb')
-        elif input_file.source_type == 'bytes':
-            size = len(input_file.data)
-            input = input_file.data
-
-        if size < self._chunk_size:
-            if input_file.source_type == 'path':
-                input_file.data = input.read()
+        payload = params[param_name]
+        size = params[param_name].size
 
-            params[param_name] = input_file
+        if size < self._chunk_size:    
             return self.call(
                 'post',
                 path,
@@ -182,16 +178,10 @@ def chunked_upload(
             input.seek(offset)
 
         while offset < size:
-            if input_file.source_type == 'path':
-                input_file.data = input.read(self._chunk_size) or input.read(size - offset)
-            elif input_file.source_type == 'bytes':
-                if offset + self._chunk_size < size:
-                    end = offset + self._chunk_size
-                else:
-                    end = size - offset
-                input_file.data = input[offset:end]
-
-            params[param_name] = input_file
+            params[param_name] = Payload.from_binary(
+                payload.to_binary(offset, min(self._chunk_size, size - offset)),
+                payload.filename
+            )
             headers["content-range"] = f'bytes {offset}-{min((offset + self._chunk_size) - 1, size - 1)}/{size}'
 
             result = self.call(

appwrite/enums/image_format.py

@@ -6,3 +6,4 @@ class ImageFormat(Enum):
     GIF = "gif"
     PNG = "png"
     WEBP = "webp"
+    AVIF = "avif"

appwrite/enums/runtime.py

@@ -21,6 +21,9 @@ class Runtime(Enum):
     PYTHON_3_11 = "python-3.11"
     PYTHON_3_12 = "python-3.12"
     PYTHON_ML_3_11 = "python-ml-3.11"
+    DENO_1_21 = "deno-1.21"
+    DENO_1_24 = "deno-1.24"
+    DENO_1_35 = "deno-1.35"
     DENO_1_40 = "deno-1.40"
     DART_2_15 = "dart-2.15"
     DART_2_16 = "dart-2.16"

appwrite/multipart.py

@@ -0,0 +1,49 @@
+from email.parser import BytesParser
+from email.policy import default
+from .payload import Payload
+import json
+
+class MultipartParser:
+    def __init__(self, multipart_bytes, content_type):
+        self.multipart_bytes = multipart_bytes
+        self.content_type = content_type
+        self.parts = {}
+        self.parse()
+
+    def parse(self):
+        # Create a message object
+        headers = f'Content-Type: {self.content_type}\r\n\r\n'.encode('ascii')
+        msg = BytesParser(policy=default).parsebytes(headers + self.multipart_bytes)
+
+        # Process each part
+        for part in msg.walk():
+            if part.is_multipart():
+                continue
+
+            # Get the name from Content-Disposition
+            content_disposition = part.get("Content-Disposition", "")
+            name = part.get_param("name", header="content-disposition")
+            if not name:
+                name = f"unnamed_part_{len(self.parts)}"
+
+            # Store the parsed data
+            self.parts[name] = {
+                "contents": part.get_payload(decode=True),
+                "headers": dict(part.items())
+            }
+
+    def to_dict(self):
+        result = {}
+        for name, part in self.parts.items():
+            if name == "responseBody":
+                result[name] = Payload.from_binary(part["contents"])
+            elif name == "responseHeaders":
+                headers_str = part["contents"].decode('utf-8', errors='replace')
+                result[name] = json.loads(headers_str)
+            elif name == "responseStatusCode":
+                result[name] = int(part["contents"])
+            elif name == "duration":
+                result[name] = float(part["contents"])
+            else:
+                result[name] = part["contents"].decode('utf-8', errors='replace')
+        return result

appwrite/payload.py

@@ -0,0 +1,72 @@
+from typing import Optional, Dict, Any
+import os, json
+
+class Payload:
+    filename: Optional[str] = None
+
+    _path: Optional[str] = None 
+    _data: Optional[bytes] = None
+    _size: int = 0
+
+    @property
+    def size(self) -> int:
+        return self._size
+
+    def __init__(self, path: Optional[str] = None, data: Optional[bytes] = None, filename: Optional[str] = None):
+        if path is None and data is None:
+            raise ValueError("One of path or data must be provided")
+
+        self._path = path
+        self._data = data
+
+        self.filename = filename
+        if self._data is None:
+            self._size = os.path.getsize(self._path)
+        else:
+            self._size = len(self._data)
+
+    def to_binary(self, offset: Optional[int] = 0, length: Optional[int] = None) -> bytes:
+        if length is None:
+            length = self._size
+
+        if self._data is None:
+            with open(self._path, 'rb') as f:
+                f.seek(offset)
+                return f.read(length)
+
+        return self._data[offset:offset + length]
+
+    def to_string(self, encoding="utf-8") -> str:
+        return self.to_binary().decode(encoding)
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def to_json(self) -> Dict[str, Any]:
+        return json.loads(self.to_string())
+
+    def to_file(self, path: str) -> None:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        with open(path, 'wb') as f:
+            return f.write(self.to_binary())
+
+    @classmethod
+    def from_binary(cls, data: bytes, filename: Optional[str] = None) -> 'Payload':
+        return cls(data=data, filename=filename)
+
+    @classmethod
+    def from_string(cls, data: str) -> 'Payload':
+        return cls(data=data.encode())
+
+    @classmethod
+    def from_file(cls, path: str, filename: Optional[str] = None) -> 'Payload':
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"File {path} not found")
+        if not filename:
+            filename = os.path.basename(path)
+        return cls(path=path, filename=filename)
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> 'Payload':
+        return cls.from_string(json.dumps(data))