def download_file(context,
download_url,
file_object,
chunk_downloaded=None,
chunk_size=1024 * 1024):
"""
:type context: office365.sharepoint.client_context.ClientContext
:type download_url: str
:type file_object: typing.IO
:type chunk_downloaded: (int)->None or None
:type chunk_size: int
"""
request = RequestOptions(
r"{0}web/getFileByServerRelativeUrl('{1}')/\$value".format(
ctx.service_root_url(), download_url))
request.stream = True
response = context.execute_request_direct(request)
response.raise_for_status()
bytes_read = 0
for chunk in response.iter_content(chunk_size=chunk_size):
bytes_read += len(chunk)
if callable(chunk_downloaded):
chunk_downloaded(bytes_read)
file_object.write(chunk)
def open_binary(ctx, server_relative_url):
url = r"{0}web/getfilebyserverrelativeurl('{1}')/\$value".format(
ctx.serviceRootUrl, server_relative_url)
request = RequestOptions(url)
request.method = HttpMethod.Get
response = ctx.execute_request_direct(request)
return response
def upload_file_to_sp(self, file_path, *remote_path):
folder_url = "/".join(["Shared Documents", "beta_builds"] +
list(remote_path))
target_folder = self.ctx.web.ensure_folder_path(folder_url)
size_chunk = 100 * 1024 * 1024 # MB
file_size = os.path.getsize(file_path)
if file_size > size_chunk:
result_file = target_folder.files.create_upload_session(
file_path, size_chunk, self.print_upload_progress, file_size)
else:
with open(file_path, 'rb') as content_file:
file_content = content_file.read()
name = os.path.basename(file_path)
result_file = target_folder.upload_file(name, file_content)
self.ctx.execute_query()
request = RequestOptions(
r"{0}web/getFileByServerRelativeUrl('{1}')/\$value".format(
self.ctx.service_root_url(), result_file.serverRelativeUrl))
request.stream = True
response = self.ctx.execute_request_direct(request)
remote_size = int(response.headers['Content-Length'])
if abs(file_size - remote_size) > 0.05 * file_size:
raise UploaderError("File size difference is more than 5%")
logging.info('File {0} has been uploaded successfully'.format(
result_file.serverRelativeUrl))
return folder_url
def execute(self, chunk_uploaded=None):
ctx = self._target_folder.context
file_name = os.path.basename(self._source_path)
# 1. create an empty file
target_item = self._target_folder.upload(file_name, None)
ctx.execute_query()
# 2. create upload session
item = DriveItemUploadableProperties()
item.name = file_name
session_result = target_item.create_upload_session(item)
ctx.execute_query()
# 3. start upload
fh = open(self._source_path, 'rb')
st = os.stat(self._source_path)
f_pos = 0
for piece in read_in_chunks(fh, chunk_size=self._chunk_size):
req = RequestOptions(session_result.value.uploadUrl)
req.method = HttpMethod.Put
req.set_header('Content-Length', str(len(piece)))
req.set_header(
'Content-Range',
'bytes {0}-{1}/{2}'.format(f_pos, (f_pos + len(piece) - 1),
st.st_size))
req.set_header('Accept', '*/*')
req.data = piece
resp = ctx.execute_request_direct(req)
f_pos += len(piece)
if chunk_uploaded is not None:
chunk_uploaded(f_pos)
return target_item
def request_form_digest(self):
"""Request Form Digest"""
request = RequestOptions("contextInfo")
request.method = HttpMethod.Post
response = self.execute_request_direct(request)
json = response.json()
json_format = JsonLightFormat()
json_format.function_tag_name = "GetContextWebInformation"
self.pending_request().map_json(json, self._contextWebInformation, json_format)
def request_form_digest(self):
"""Request Form Digest"""
request = RequestOptions(self.serviceRootUrl + "contextinfo")
request.method = HttpMethod.Post
response = self.execute_request_direct(request)
payload = response.json()
if self._pendingRequest.json_format.metadata == ODataMetadataLevel.Verbose:
payload = payload['d']['GetContextWebInformation']
self._contextWebInformation = ContextWebInformation()
self._contextWebInformation.from_json(payload)
def _create_doc_set():
url = r"{0}/_vti_bin/listdata.svc/{1}".format(
context.base_url,
parentFolder.properties["Name"].replace(" ", ""))
request = RequestOptions(url)
request.method = HttpMethod.Post
folder_url = parentFolder.serverRelativeUrl + '/' + name
request.set_header('Slug', '{0}|{1}'.format(folder_url, ctid))
response = context.execute_request_direct(request)
json = response.json()
context.pending_request().map_json(json, result)
def open_binary(ctx, server_relative_url):
"""
Returns the file object located at the specified server-relative URL.
:type ctx: ClientContext
:type server_relative_url: str
"""
url = r"{0}web/getfilebyserverrelativeurl('{1}')/\$value".format(
ctx.service_root_url, server_relative_url)
request = RequestOptions(url)
request.method = HttpMethod.Get
response = ctx.execute_request_direct(request)
return response
def _download_inner():
request = RequestOptions(
r"{0}web/getFileByServerRelativeUrl('{1}')/\$value".format(
self.context.service_root_url(), self.serverRelativeUrl))
request.stream = True
response = self.context.execute_request_direct(request)
response.raise_for_status()
bytes_read = 0
for chunk in response.iter_content(chunk_size=chunk_size):
bytes_read += len(chunk)
if callable(chunk_downloaded):
chunk_downloaded(bytes_read)
file_object.write(chunk)
def open_binary(ctx, server_relative_url):
"""
Returns the file object located at the specified server-relative URL.
:type ctx: ClientContext
:type server_relative_url: str
:return Response
"""
url = r"web/getFileByServerRelativePath(DecodedUrl='{0}')/\$value".format(
server_relative_url)
request = RequestOptions(url)
request.method = HttpMethod.Get
response = ctx.execute_request_direct(request)
return response
def _normalize_request(self, request):
"""
:type request: office365.runtime.http.request_options.RequestOptions or str
"""
if not isinstance(request, RequestOptions):
request = RequestOptions(request)
if not is_absolute_url(request.url):
url_parts = [self.service_root_url()]
if not request.url.startswith("/"):
url_parts.append("/")
url_parts.append(request.url)
request.url = "".join(url_parts)
return request
def get_context_web_information(self, request_options=None):
"""Returns an ContextWebInformation object that specifies metadata about the site"""
request = RequestOptions("contextInfo")
request.method = HttpMethod.Post
if request_options:
request.proxies = request_options.proxies
request.verify = request_options.verify
response = self.execute_request_direct(request)
json = response.json()
json_format = JsonLightFormat()
json_format.function_tag_name = "GetContextWebInformation"
return_value = ContextWebInformation()
self.pending_request().map_json(json, return_value, json_format)
return return_value
def _create_doc_set(target_list):
list_name = target_list.title.replace(" ", "")
request_url = r"{0}/_vti_bin/listdata.svc/{1}".format(
context.base_url, list_name)
request = RequestOptions(request_url)
request.method = HttpMethod.Post
folder_url = parent_folder.serverRelativeUrl + '/' + name
return_type._resource_path = ResourcePathServiceOperation(
"getFolderByServerRelativeUrl", [folder_url],
ResourcePath("Web"))
request.set_header('Slug', '{0}|{1}'.format(folder_url, ct_id))
response = context.execute_request_direct(request)
response.raise_for_status()
json = response.json()
context.pending_request().map_json(json, return_type)
def build_request(self):
url = "{0}/$batch".format(self.context.service_root_url())
request = RequestOptions(url)
request.method = HttpMethod.Post
request.ensure_header('Content-Type', "application/json")
request.ensure_header('Accept', "application/json")
request.data = self._prepare_payload()
return request
def getWebTitle(self):
request = RequestOptions("{0}/_api/files".format(self.__site_url))
response = self.__ctx.execute_request_direct(request)
js = json.loads(response.content)
web_title = js['d']['results']
return web_title
def load_web_by_absolute_url(client):
"""
:type client: ClientContext
"""
request = RequestOptions("{0}/_api/web/".format(test_site_url))
response = client.execute_request_direct(request)
response.raise_for_status()
return json.loads(response.content)
def _load_next_items(self):
request = RequestOptions(self.next_request_url)
response = self.context.execute_request_direct(request)
response.raise_for_status()
self.next_request_url = None
self.context.pending_request().map_json(response.json(), self)
self.page_loaded.notify(len(self._data))
self._page_index += 1
return self._data[self._page_size * self._page_index:]
def build_request(self, query):
"""
:type query: office365.runtime.queries.client_query.ClientQuery
"""
url = "{0}/$batch".format(self.context.service_root_url())
request = RequestOptions(url)
request.method = HttpMethod.Post
request.ensure_header('Content-Type', "application/json")
request.ensure_header('Accept', "application/json")
request.data = self._prepare_payload()
return request
def execute_request(self, url_or_options):
"""
Constructs and submits request directly
:type url_or_options: str or RequestOptions
"""
if not isinstance(url_or_options, RequestOptions):
url_or_options = RequestOptions("{0}/{1}".format(
self.__service_root_url, url_or_options))
return self.execute_request_direct(url_or_options)
def _load_next_items(self):
if self.next_request_url and not self.query_options.top:
items = ClientObjectCollection(self.context, self._item_type,
self.resource_path)
request = RequestOptions(self.next_request_url)
response = self.context.execute_request_direct(request)
json = response.json()
self.context.get_pending_request().map_json(json, items)
self.next_request_url = None
for item in items:
yield item
def _execute_upload_session(self, resp):
item = DriveItemUploadableProperties()
item.name = self._file_name
self._session_result = self._target_item.create_upload_session(item)
self.context.execute_query()
fh = open(self._source_path, 'rb')
st = os.stat(self._source_path)
f_pos = 0
for piece in read_in_chunks(fh, chunk_size=self._chunk_size):
req = RequestOptions(self._session_result.value.uploadUrl)
req.method = HttpMethod.Put
req.set_header('Content-Length', str(len(piece)))
req.set_header('Content-Range', 'bytes {0}-{1}/{2}'.format(f_pos, (f_pos + len(piece) - 1), st.st_size))
req.set_header('Accept', '*/*')
req.data = piece
self.context.execute_request_direct(req)
f_pos += len(piece)
if callable(self._chunk_uploaded):
self._chunk_uploaded(f_pos)
def build_request(self, query):
"""
:type query: office365.runtime.queries.client_query.ClientQuery
"""
self._current_query = query
if query.resource_path is not None:
request_url = query.service_root_url + str(query.resource_path)
else:
request_url = query.service_root_url + "/"
if isinstance(query,
ReadEntityQuery) and not query.query_options.is_empty:
request_url += "?" + query.query_options.to_url()
request = RequestOptions(request_url)
self.ensure_media_type(request)
# set method
request.method = HttpMethod.Get
if isinstance(query, DeleteEntityQuery):
request.method = HttpMethod.Post
elif isinstance(
query,
(CreateEntityQuery, UpdateEntityQuery, ServiceOperationQuery)):
request.method = HttpMethod.Post
if query.parameter_type is not None:
request.data = self._normalize_payload(query)
return request
def build_request(self):
qry = self.context.current_query
self.json_format.function_tag_name = None
if isinstance(qry, ServiceOperationQuery):
self.json_format.function_tag_name = qry.method_name
if qry.static:
request_url = self.context.service_root_url + '.'.join(
[qry.binding_type.entity_type_name, qry.method_url])
else:
request_url = '/'.join(
[qry.binding_type.resource_url, qry.method_url])
else:
request_url = qry.binding_type.resource_url
request = RequestOptions(request_url)
# set method
request.method = HttpMethod.Get
if isinstance(qry, DeleteEntityQuery):
request.method = HttpMethod.Post
elif isinstance(
qry,
(CreateEntityQuery, UpdateEntityQuery, ServiceOperationQuery)):
request.method = HttpMethod.Post
if qry.parameter_type is not None:
request.data = self._normalize_payload(qry.parameter_type)
return request
def build_request(self):
request_url = "{0}$batch".format(self.context.service_root_url)
request = RequestOptions(request_url)
request.method = HttpMethod.Post
request.ensure_header('Content-Type', self._content_type)
request.data = self._prepare_payload().as_bytes()
return request
def build_request(self):
qry = self._get_current_query()
request = RequestOptions(qry.bindingType.resourceUrl)
if isinstance(qry, ServiceOperationQuery):
request.url = '/'.join([qry.bindingType.resourceUrl, qry.methodUrl])
# set json format headers
media_type = self.json_format.get_media_type()
request.set_headers({'Content-Type': media_type, 'Accept': media_type})
# set method
request.method = HttpMethod.Get
if isinstance(qry, DeleteEntityQuery):
request.method = HttpMethod.Post
elif isinstance(qry, CreateEntityQuery) \
or isinstance(qry, UpdateEntityQuery) \
or isinstance(qry, ServiceOperationQuery):
request.method = HttpMethod.Post
if qry.parameterType is not None:
request.data = self._normalize_payload(qry.parameterType)
return request
def save_binary(ctx, server_relative_url, content):
"""Uploads a file"""
url = r"{0}web/getfilebyserverrelativeurl('{1}')/\$value".format(
ctx.serviceRootUrl, server_relative_url)
request = RequestOptions(url)
request.method = HttpMethod.Post
request.set_header('X-HTTP-Method', 'PUT')
request.data = content
response = ctx.execute_request_direct(request)
return response
def __iter__(self):
for _object in self._data:
yield _object
while self.__next_query_url:
# create a request with the __next_query_url
request = RequestOptions(self.__next_query_url)
response = self.context.execute_request_direct(request)
payload = response.json()
next_collection = ClientObjectCollection(self.context,
self._item_type)
next_collection.map_json(payload["collection"], payload["next"])
# add the new objects to the collection before yielding the results
for item in next_collection:
self.add_child(item)
yield item
def build_request(self):
url = "{0}$batch".format(self.context.service_root_url())
request = RequestOptions(url)
request.method = HttpMethod.Post
media_type = "multipart/mixed"
content_type = "; ".join([
media_type,
"boundary={0}".format(self._current_query.current_boundary)
])
request.ensure_header('Content-Type', content_type)
request.data = self._prepare_payload().as_bytes()
return request
def build_request(self):
qry = self.current_query
action_url = qry.build_url()
request = RequestOptions(action_url)
self.ensure_media_type(request)
# set method
request.method = HttpMethod.Get
if isinstance(qry, DeleteEntityQuery):
request.method = HttpMethod.Post
elif isinstance(qry, (CreateEntityQuery, UpdateEntityQuery, ServiceOperationQuery)):
request.method = HttpMethod.Post
if qry.parameter_type is not None:
request.data = self._normalize_payload(qry.parameter_type)
return request
def save_binary(ctx, server_relative_url, content):
"""Uploads a file
:type ctx: ClientContext
:type server_relative_url: str
:type content: str
"""
url = r"{0}web/getFileByServerRelativeUrl('{1}')/\$value".format(
ctx.service_root_url(), server_relative_url)
request = RequestOptions(url)
request.method = HttpMethod.Post
request.set_header('X-HTTP-Method', 'PUT')
request.data = content
response = ctx.execute_request_direct(request)
return response
