id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,800
|
twoolie/NBT
|
nbt/nbt.py
|
NBTFile.write_file
|
def write_file(self, filename=None, buffer=None, fileobj=None):
"""Write this NBT file to a file."""
closefile = True
if buffer:
self.filename = None
self.file = buffer
closefile = False
elif filename:
self.filename = filename
self.file = GzipFile(filename, "wb")
elif fileobj:
self.filename = None
self.file = GzipFile(fileobj=fileobj, mode="wb")
elif self.filename:
self.file = GzipFile(self.filename, "wb")
elif not self.file:
raise ValueError(
"NBTFile.write_file(): Need to specify either a "
"filename or a file object"
)
# Render tree to file
TAG_Byte(self.id)._render_buffer(self.file)
TAG_String(self.name)._render_buffer(self.file)
self._render_buffer(self.file)
# make sure the file is complete
try:
self.file.flush()
except (AttributeError, IOError):
pass
if closefile:
try:
self.file.close()
except (AttributeError, IOError):
pass
|
python
|
def write_file(self, filename=None, buffer=None, fileobj=None):
"""Write this NBT file to a file."""
closefile = True
if buffer:
self.filename = None
self.file = buffer
closefile = False
elif filename:
self.filename = filename
self.file = GzipFile(filename, "wb")
elif fileobj:
self.filename = None
self.file = GzipFile(fileobj=fileobj, mode="wb")
elif self.filename:
self.file = GzipFile(self.filename, "wb")
elif not self.file:
raise ValueError(
"NBTFile.write_file(): Need to specify either a "
"filename or a file object"
)
# Render tree to file
TAG_Byte(self.id)._render_buffer(self.file)
TAG_String(self.name)._render_buffer(self.file)
self._render_buffer(self.file)
# make sure the file is complete
try:
self.file.flush()
except (AttributeError, IOError):
pass
if closefile:
try:
self.file.close()
except (AttributeError, IOError):
pass
|
[
"def",
"write_file",
"(",
"self",
",",
"filename",
"=",
"None",
",",
"buffer",
"=",
"None",
",",
"fileobj",
"=",
"None",
")",
":",
"closefile",
"=",
"True",
"if",
"buffer",
":",
"self",
".",
"filename",
"=",
"None",
"self",
".",
"file",
"=",
"buffer",
"closefile",
"=",
"False",
"elif",
"filename",
":",
"self",
".",
"filename",
"=",
"filename",
"self",
".",
"file",
"=",
"GzipFile",
"(",
"filename",
",",
"\"wb\"",
")",
"elif",
"fileobj",
":",
"self",
".",
"filename",
"=",
"None",
"self",
".",
"file",
"=",
"GzipFile",
"(",
"fileobj",
"=",
"fileobj",
",",
"mode",
"=",
"\"wb\"",
")",
"elif",
"self",
".",
"filename",
":",
"self",
".",
"file",
"=",
"GzipFile",
"(",
"self",
".",
"filename",
",",
"\"wb\"",
")",
"elif",
"not",
"self",
".",
"file",
":",
"raise",
"ValueError",
"(",
"\"NBTFile.write_file(): Need to specify either a \"",
"\"filename or a file object\"",
")",
"# Render tree to file",
"TAG_Byte",
"(",
"self",
".",
"id",
")",
".",
"_render_buffer",
"(",
"self",
".",
"file",
")",
"TAG_String",
"(",
"self",
".",
"name",
")",
".",
"_render_buffer",
"(",
"self",
".",
"file",
")",
"self",
".",
"_render_buffer",
"(",
"self",
".",
"file",
")",
"# make sure the file is complete",
"try",
":",
"self",
".",
"file",
".",
"flush",
"(",
")",
"except",
"(",
"AttributeError",
",",
"IOError",
")",
":",
"pass",
"if",
"closefile",
":",
"try",
":",
"self",
".",
"file",
".",
"close",
"(",
")",
"except",
"(",
"AttributeError",
",",
"IOError",
")",
":",
"pass"
] |
Write this NBT file to a file.
|
[
"Write",
"this",
"NBT",
"file",
"to",
"a",
"file",
"."
] |
b06dd6cc8117d2788da1d8416e642d58bad45762
|
https://github.com/twoolie/NBT/blob/b06dd6cc8117d2788da1d8416e642d58bad45762/nbt/nbt.py#L673-L706
|
10,801
|
argaen/aiocache
|
aiocache/serializers/serializers.py
|
MsgPackSerializer.loads
|
def loads(self, value):
"""
Deserialize value using ``msgpack.loads``.
:param value: bytes
:returns: obj
"""
raw = False if self.encoding == "utf-8" else True
if value is None:
return None
return msgpack.loads(value, raw=raw, use_list=self.use_list)
|
python
|
def loads(self, value):
"""
Deserialize value using ``msgpack.loads``.
:param value: bytes
:returns: obj
"""
raw = False if self.encoding == "utf-8" else True
if value is None:
return None
return msgpack.loads(value, raw=raw, use_list=self.use_list)
|
[
"def",
"loads",
"(",
"self",
",",
"value",
")",
":",
"raw",
"=",
"False",
"if",
"self",
".",
"encoding",
"==",
"\"utf-8\"",
"else",
"True",
"if",
"value",
"is",
"None",
":",
"return",
"None",
"return",
"msgpack",
".",
"loads",
"(",
"value",
",",
"raw",
"=",
"raw",
",",
"use_list",
"=",
"self",
".",
"use_list",
")"
] |
Deserialize value using ``msgpack.loads``.
:param value: bytes
:returns: obj
|
[
"Deserialize",
"value",
"using",
"msgpack",
".",
"loads",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/serializers/serializers.py#L178-L188
|
10,802
|
argaen/aiocache
|
aiocache/base.py
|
API.aiocache_enabled
|
def aiocache_enabled(cls, fake_return=None):
"""
Use this decorator to be able to fake the return of the function by setting the
``AIOCACHE_DISABLE`` environment variable
"""
def enabled(func):
@functools.wraps(func)
async def _enabled(*args, **kwargs):
if os.getenv("AIOCACHE_DISABLE") == "1":
return fake_return
return await func(*args, **kwargs)
return _enabled
return enabled
|
python
|
def aiocache_enabled(cls, fake_return=None):
"""
Use this decorator to be able to fake the return of the function by setting the
``AIOCACHE_DISABLE`` environment variable
"""
def enabled(func):
@functools.wraps(func)
async def _enabled(*args, **kwargs):
if os.getenv("AIOCACHE_DISABLE") == "1":
return fake_return
return await func(*args, **kwargs)
return _enabled
return enabled
|
[
"def",
"aiocache_enabled",
"(",
"cls",
",",
"fake_return",
"=",
"None",
")",
":",
"def",
"enabled",
"(",
"func",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"func",
")",
"async",
"def",
"_enabled",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"os",
".",
"getenv",
"(",
"\"AIOCACHE_DISABLE\"",
")",
"==",
"\"1\"",
":",
"return",
"fake_return",
"return",
"await",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"_enabled",
"return",
"enabled"
] |
Use this decorator to be able to fake the return of the function by setting the
``AIOCACHE_DISABLE`` environment variable
|
[
"Use",
"this",
"decorator",
"to",
"be",
"able",
"to",
"fake",
"the",
"return",
"of",
"the",
"function",
"by",
"setting",
"the",
"AIOCACHE_DISABLE",
"environment",
"variable"
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L50-L65
|
10,803
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.add
|
async def add(self, key, value, ttl=SENTINEL, dumps_fn=None, namespace=None, _conn=None):
"""
Stores the value in the given key with ttl if specified. Raises an error if the
key already exists.
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key is inserted
:raises:
- ValueError if key already exists
- :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
ns_key = self.build_key(key, namespace=namespace)
await self._add(ns_key, dumps(value), ttl=self._get_ttl(ttl), _conn=_conn)
logger.debug("ADD %s %s (%.4f)s", ns_key, True, time.monotonic() - start)
return True
|
python
|
async def add(self, key, value, ttl=SENTINEL, dumps_fn=None, namespace=None, _conn=None):
"""
Stores the value in the given key with ttl if specified. Raises an error if the
key already exists.
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key is inserted
:raises:
- ValueError if key already exists
- :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
ns_key = self.build_key(key, namespace=namespace)
await self._add(ns_key, dumps(value), ttl=self._get_ttl(ttl), _conn=_conn)
logger.debug("ADD %s %s (%.4f)s", ns_key, True, time.monotonic() - start)
return True
|
[
"async",
"def",
"add",
"(",
"self",
",",
"key",
",",
"value",
",",
"ttl",
"=",
"SENTINEL",
",",
"dumps_fn",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"dumps",
"=",
"dumps_fn",
"or",
"self",
".",
"_serializer",
".",
"dumps",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"await",
"self",
".",
"_add",
"(",
"ns_key",
",",
"dumps",
"(",
"value",
")",
",",
"ttl",
"=",
"self",
".",
"_get_ttl",
"(",
"ttl",
")",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"ADD %s %s (%.4f)s\"",
",",
"ns_key",
",",
"True",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"True"
] |
Stores the value in the given key with ttl if specified. Raises an error if the
key already exists.
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key is inserted
:raises:
- ValueError if key already exists
- :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Stores",
"the",
"value",
"in",
"the",
"given",
"key",
"with",
"ttl",
"if",
"specified",
".",
"Raises",
"an",
"error",
"if",
"the",
"key",
"already",
"exists",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L140-L166
|
10,804
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.get
|
async def get(self, key, default=None, loads_fn=None, namespace=None, _conn=None):
"""
Get a value from the cache. Returns default if not found.
:param key: str
:param default: obj to return when key is not found
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: obj loaded
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
loads = loads_fn or self._serializer.loads
ns_key = self.build_key(key, namespace=namespace)
value = loads(await self._get(ns_key, encoding=self.serializer.encoding, _conn=_conn))
logger.debug("GET %s %s (%.4f)s", ns_key, value is not None, time.monotonic() - start)
return value if value is not None else default
|
python
|
async def get(self, key, default=None, loads_fn=None, namespace=None, _conn=None):
"""
Get a value from the cache. Returns default if not found.
:param key: str
:param default: obj to return when key is not found
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: obj loaded
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
loads = loads_fn or self._serializer.loads
ns_key = self.build_key(key, namespace=namespace)
value = loads(await self._get(ns_key, encoding=self.serializer.encoding, _conn=_conn))
logger.debug("GET %s %s (%.4f)s", ns_key, value is not None, time.monotonic() - start)
return value if value is not None else default
|
[
"async",
"def",
"get",
"(",
"self",
",",
"key",
",",
"default",
"=",
"None",
",",
"loads_fn",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"loads",
"=",
"loads_fn",
"or",
"self",
".",
"_serializer",
".",
"loads",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"value",
"=",
"loads",
"(",
"await",
"self",
".",
"_get",
"(",
"ns_key",
",",
"encoding",
"=",
"self",
".",
"serializer",
".",
"encoding",
",",
"_conn",
"=",
"_conn",
")",
")",
"logger",
".",
"debug",
"(",
"\"GET %s %s (%.4f)s\"",
",",
"ns_key",
",",
"value",
"is",
"not",
"None",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"value",
"if",
"value",
"is",
"not",
"None",
"else",
"default"
] |
Get a value from the cache. Returns default if not found.
:param key: str
:param default: obj to return when key is not found
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: obj loaded
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Get",
"a",
"value",
"from",
"the",
"cache",
".",
"Returns",
"default",
"if",
"not",
"found",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L175-L195
|
10,805
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.multi_get
|
async def multi_get(self, keys, loads_fn=None, namespace=None, _conn=None):
"""
Get multiple values from the cache, values not found are Nones.
:param keys: list of str
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: list of objs
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
loads = loads_fn or self._serializer.loads
ns_keys = [self.build_key(key, namespace=namespace) for key in keys]
values = [
loads(value)
for value in await self._multi_get(
ns_keys, encoding=self.serializer.encoding, _conn=_conn
)
]
logger.debug(
"MULTI_GET %s %d (%.4f)s",
ns_keys,
len([value for value in values if value is not None]),
time.monotonic() - start,
)
return values
|
python
|
async def multi_get(self, keys, loads_fn=None, namespace=None, _conn=None):
"""
Get multiple values from the cache, values not found are Nones.
:param keys: list of str
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: list of objs
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
loads = loads_fn or self._serializer.loads
ns_keys = [self.build_key(key, namespace=namespace) for key in keys]
values = [
loads(value)
for value in await self._multi_get(
ns_keys, encoding=self.serializer.encoding, _conn=_conn
)
]
logger.debug(
"MULTI_GET %s %d (%.4f)s",
ns_keys,
len([value for value in values if value is not None]),
time.monotonic() - start,
)
return values
|
[
"async",
"def",
"multi_get",
"(",
"self",
",",
"keys",
",",
"loads_fn",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"loads",
"=",
"loads_fn",
"or",
"self",
".",
"_serializer",
".",
"loads",
"ns_keys",
"=",
"[",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"for",
"key",
"in",
"keys",
"]",
"values",
"=",
"[",
"loads",
"(",
"value",
")",
"for",
"value",
"in",
"await",
"self",
".",
"_multi_get",
"(",
"ns_keys",
",",
"encoding",
"=",
"self",
".",
"serializer",
".",
"encoding",
",",
"_conn",
"=",
"_conn",
")",
"]",
"logger",
".",
"debug",
"(",
"\"MULTI_GET %s %d (%.4f)s\"",
",",
"ns_keys",
",",
"len",
"(",
"[",
"value",
"for",
"value",
"in",
"values",
"if",
"value",
"is",
"not",
"None",
"]",
")",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
",",
")",
"return",
"values"
] |
Get multiple values from the cache, values not found are Nones.
:param keys: list of str
:param loads_fn: callable alternative to use as loads function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: list of objs
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Get",
"multiple",
"values",
"from",
"the",
"cache",
"values",
"not",
"found",
"are",
"Nones",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L204-L233
|
10,806
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.set
|
async def set(
self, key, value, ttl=SENTINEL, dumps_fn=None, namespace=None, _cas_token=None, _conn=None
):
"""
Stores the value in the given key with ttl if specified
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if the value was set
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
ns_key = self.build_key(key, namespace=namespace)
res = await self._set(
ns_key, dumps(value), ttl=self._get_ttl(ttl), _cas_token=_cas_token, _conn=_conn
)
logger.debug("SET %s %d (%.4f)s", ns_key, True, time.monotonic() - start)
return res
|
python
|
async def set(
self, key, value, ttl=SENTINEL, dumps_fn=None, namespace=None, _cas_token=None, _conn=None
):
"""
Stores the value in the given key with ttl if specified
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if the value was set
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
ns_key = self.build_key(key, namespace=namespace)
res = await self._set(
ns_key, dumps(value), ttl=self._get_ttl(ttl), _cas_token=_cas_token, _conn=_conn
)
logger.debug("SET %s %d (%.4f)s", ns_key, True, time.monotonic() - start)
return res
|
[
"async",
"def",
"set",
"(",
"self",
",",
"key",
",",
"value",
",",
"ttl",
"=",
"SENTINEL",
",",
"dumps_fn",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"_cas_token",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"dumps",
"=",
"dumps_fn",
"or",
"self",
".",
"_serializer",
".",
"dumps",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"res",
"=",
"await",
"self",
".",
"_set",
"(",
"ns_key",
",",
"dumps",
"(",
"value",
")",
",",
"ttl",
"=",
"self",
".",
"_get_ttl",
"(",
"ttl",
")",
",",
"_cas_token",
"=",
"_cas_token",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"SET %s %d (%.4f)s\"",
",",
"ns_key",
",",
"True",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"res"
] |
Stores the value in the given key with ttl if specified
:param key: str
:param value: obj
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if the value was set
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Stores",
"the",
"value",
"in",
"the",
"given",
"key",
"with",
"ttl",
"if",
"specified"
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L242-L269
|
10,807
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.multi_set
|
async def multi_set(self, pairs, ttl=SENTINEL, dumps_fn=None, namespace=None, _conn=None):
"""
Stores multiple values in the given keys.
:param pairs: list of two element iterables. First is key and second is value
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
tmp_pairs = []
for key, value in pairs:
tmp_pairs.append((self.build_key(key, namespace=namespace), dumps(value)))
await self._multi_set(tmp_pairs, ttl=self._get_ttl(ttl), _conn=_conn)
logger.debug(
"MULTI_SET %s %d (%.4f)s",
[key for key, value in tmp_pairs],
len(pairs),
time.monotonic() - start,
)
return True
|
python
|
async def multi_set(self, pairs, ttl=SENTINEL, dumps_fn=None, namespace=None, _conn=None):
"""
Stores multiple values in the given keys.
:param pairs: list of two element iterables. First is key and second is value
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
dumps = dumps_fn or self._serializer.dumps
tmp_pairs = []
for key, value in pairs:
tmp_pairs.append((self.build_key(key, namespace=namespace), dumps(value)))
await self._multi_set(tmp_pairs, ttl=self._get_ttl(ttl), _conn=_conn)
logger.debug(
"MULTI_SET %s %d (%.4f)s",
[key for key, value in tmp_pairs],
len(pairs),
time.monotonic() - start,
)
return True
|
[
"async",
"def",
"multi_set",
"(",
"self",
",",
"pairs",
",",
"ttl",
"=",
"SENTINEL",
",",
"dumps_fn",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"dumps",
"=",
"dumps_fn",
"or",
"self",
".",
"_serializer",
".",
"dumps",
"tmp_pairs",
"=",
"[",
"]",
"for",
"key",
",",
"value",
"in",
"pairs",
":",
"tmp_pairs",
".",
"append",
"(",
"(",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
",",
"dumps",
"(",
"value",
")",
")",
")",
"await",
"self",
".",
"_multi_set",
"(",
"tmp_pairs",
",",
"ttl",
"=",
"self",
".",
"_get_ttl",
"(",
"ttl",
")",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"MULTI_SET %s %d (%.4f)s\"",
",",
"[",
"key",
"for",
"key",
",",
"value",
"in",
"tmp_pairs",
"]",
",",
"len",
"(",
"pairs",
")",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
",",
")",
"return",
"True"
] |
Stores multiple values in the given keys.
:param pairs: list of two element iterables. First is key and second is value
:param ttl: int the expiration time in seconds. Due to memcached
restrictions if you want compatibility use int. In case you
need miliseconds, redis and memory support float ttls
:param dumps_fn: callable alternative to use as dumps function
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Stores",
"multiple",
"values",
"in",
"the",
"given",
"keys",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L278-L308
|
10,808
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.delete
|
async def delete(self, key, namespace=None, _conn=None):
"""
Deletes the given key.
:param key: Key to be deleted
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: int number of deleted keys
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._delete(ns_key, _conn=_conn)
logger.debug("DELETE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
python
|
async def delete(self, key, namespace=None, _conn=None):
"""
Deletes the given key.
:param key: Key to be deleted
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: int number of deleted keys
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._delete(ns_key, _conn=_conn)
logger.debug("DELETE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
[
"async",
"def",
"delete",
"(",
"self",
",",
"key",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"ret",
"=",
"await",
"self",
".",
"_delete",
"(",
"ns_key",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"DELETE %s %d (%.4f)s\"",
",",
"ns_key",
",",
"ret",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Deletes the given key.
:param key: Key to be deleted
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: int number of deleted keys
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Deletes",
"the",
"given",
"key",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L317-L332
|
10,809
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.exists
|
async def exists(self, key, namespace=None, _conn=None):
"""
Check key exists in the cache.
:param key: str key to check
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key exists otherwise False
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._exists(ns_key, _conn=_conn)
logger.debug("EXISTS %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
python
|
async def exists(self, key, namespace=None, _conn=None):
"""
Check key exists in the cache.
:param key: str key to check
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key exists otherwise False
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._exists(ns_key, _conn=_conn)
logger.debug("EXISTS %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
[
"async",
"def",
"exists",
"(",
"self",
",",
"key",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"ret",
"=",
"await",
"self",
".",
"_exists",
"(",
"ns_key",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"EXISTS %s %d (%.4f)s\"",
",",
"ns_key",
",",
"ret",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Check key exists in the cache.
:param key: str key to check
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if key exists otherwise False
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Check",
"key",
"exists",
"in",
"the",
"cache",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L341-L356
|
10,810
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.expire
|
async def expire(self, key, ttl, namespace=None, _conn=None):
"""
Set the ttl to the given key. By setting it to 0, it will disable it
:param key: str key to expire
:param ttl: int number of seconds for expiration. If 0, ttl is disabled
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if set, False if key is not found
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._expire(ns_key, ttl, _conn=_conn)
logger.debug("EXPIRE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
python
|
async def expire(self, key, ttl, namespace=None, _conn=None):
"""
Set the ttl to the given key. By setting it to 0, it will disable it
:param key: str key to expire
:param ttl: int number of seconds for expiration. If 0, ttl is disabled
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if set, False if key is not found
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ns_key = self.build_key(key, namespace=namespace)
ret = await self._expire(ns_key, ttl, _conn=_conn)
logger.debug("EXPIRE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
return ret
|
[
"async",
"def",
"expire",
"(",
"self",
",",
"key",
",",
"ttl",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ns_key",
"=",
"self",
".",
"build_key",
"(",
"key",
",",
"namespace",
"=",
"namespace",
")",
"ret",
"=",
"await",
"self",
".",
"_expire",
"(",
"ns_key",
",",
"ttl",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"EXPIRE %s %d (%.4f)s\"",
",",
"ns_key",
",",
"ret",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Set the ttl to the given key. By setting it to 0, it will disable it
:param key: str key to expire
:param ttl: int number of seconds for expiration. If 0, ttl is disabled
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True if set, False if key is not found
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Set",
"the",
"ttl",
"to",
"the",
"given",
"key",
".",
"By",
"setting",
"it",
"to",
"0",
"it",
"will",
"disable",
"it"
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L392-L408
|
10,811
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.clear
|
async def clear(self, namespace=None, _conn=None):
"""
Clears the cache in the cache namespace. If an alternative namespace is given, it will
clear those ones instead.
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._clear(namespace, _conn=_conn)
logger.debug("CLEAR %s %d (%.4f)s", namespace, ret, time.monotonic() - start)
return ret
|
python
|
async def clear(self, namespace=None, _conn=None):
"""
Clears the cache in the cache namespace. If an alternative namespace is given, it will
clear those ones instead.
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._clear(namespace, _conn=_conn)
logger.debug("CLEAR %s %d (%.4f)s", namespace, ret, time.monotonic() - start)
return ret
|
[
"async",
"def",
"clear",
"(",
"self",
",",
"namespace",
"=",
"None",
",",
"_conn",
"=",
"None",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ret",
"=",
"await",
"self",
".",
"_clear",
"(",
"namespace",
",",
"_conn",
"=",
"_conn",
")",
"logger",
".",
"debug",
"(",
"\"CLEAR %s %d (%.4f)s\"",
",",
"namespace",
",",
"ret",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Clears the cache in the cache namespace. If an alternative namespace is given, it will
clear those ones instead.
:param namespace: str alternative namespace to use
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: True
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Clears",
"the",
"cache",
"in",
"the",
"cache",
"namespace",
".",
"If",
"an",
"alternative",
"namespace",
"is",
"given",
"it",
"will",
"clear",
"those",
"ones",
"instead",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L417-L431
|
10,812
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.raw
|
async def raw(self, command, *args, _conn=None, **kwargs):
"""
Send the raw command to the underlying client. Note that by using this CMD you
will lose compatibility with other backends.
Due to limitations with aiomcache client, args have to be provided as bytes.
For rest of backends, str.
:param command: str with the command.
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: whatever the underlying client returns
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._raw(
command, *args, encoding=self.serializer.encoding, _conn=_conn, **kwargs
)
logger.debug("%s (%.4f)s", command, time.monotonic() - start)
return ret
|
python
|
async def raw(self, command, *args, _conn=None, **kwargs):
"""
Send the raw command to the underlying client. Note that by using this CMD you
will lose compatibility with other backends.
Due to limitations with aiomcache client, args have to be provided as bytes.
For rest of backends, str.
:param command: str with the command.
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: whatever the underlying client returns
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._raw(
command, *args, encoding=self.serializer.encoding, _conn=_conn, **kwargs
)
logger.debug("%s (%.4f)s", command, time.monotonic() - start)
return ret
|
[
"async",
"def",
"raw",
"(",
"self",
",",
"command",
",",
"*",
"args",
",",
"_conn",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ret",
"=",
"await",
"self",
".",
"_raw",
"(",
"command",
",",
"*",
"args",
",",
"encoding",
"=",
"self",
".",
"serializer",
".",
"encoding",
",",
"_conn",
"=",
"_conn",
",",
"*",
"*",
"kwargs",
")",
"logger",
".",
"debug",
"(",
"\"%s (%.4f)s\"",
",",
"command",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Send the raw command to the underlying client. Note that by using this CMD you
will lose compatibility with other backends.
Due to limitations with aiomcache client, args have to be provided as bytes.
For rest of backends, str.
:param command: str with the command.
:param timeout: int or float in seconds specifying maximum timeout
for the operations to last
:returns: whatever the underlying client returns
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Send",
"the",
"raw",
"command",
"to",
"the",
"underlying",
"client",
".",
"Note",
"that",
"by",
"using",
"this",
"CMD",
"you",
"will",
"lose",
"compatibility",
"with",
"other",
"backends",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L440-L459
|
10,813
|
argaen/aiocache
|
aiocache/base.py
|
BaseCache.close
|
async def close(self, *args, _conn=None, **kwargs):
"""
Perform any resource clean up necessary to exit the program safely.
After closing, cmd execution is still possible but you will have to
close again before exiting.
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._close(*args, _conn=_conn, **kwargs)
logger.debug("CLOSE (%.4f)s", time.monotonic() - start)
return ret
|
python
|
async def close(self, *args, _conn=None, **kwargs):
"""
Perform any resource clean up necessary to exit the program safely.
After closing, cmd execution is still possible but you will have to
close again before exiting.
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
"""
start = time.monotonic()
ret = await self._close(*args, _conn=_conn, **kwargs)
logger.debug("CLOSE (%.4f)s", time.monotonic() - start)
return ret
|
[
"async",
"def",
"close",
"(",
"self",
",",
"*",
"args",
",",
"_conn",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"start",
"=",
"time",
".",
"monotonic",
"(",
")",
"ret",
"=",
"await",
"self",
".",
"_close",
"(",
"*",
"args",
",",
"_conn",
"=",
"_conn",
",",
"*",
"*",
"kwargs",
")",
"logger",
".",
"debug",
"(",
"\"CLOSE (%.4f)s\"",
",",
"time",
".",
"monotonic",
"(",
")",
"-",
"start",
")",
"return",
"ret"
] |
Perform any resource clean up necessary to exit the program safely.
After closing, cmd execution is still possible but you will have to
close again before exiting.
:raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
|
[
"Perform",
"any",
"resource",
"clean",
"up",
"necessary",
"to",
"exit",
"the",
"program",
"safely",
".",
"After",
"closing",
"cmd",
"execution",
"is",
"still",
"possible",
"but",
"you",
"will",
"have",
"to",
"close",
"again",
"before",
"exiting",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/base.py#L465-L476
|
10,814
|
argaen/aiocache
|
aiocache/factory.py
|
CacheHandler.get
|
def get(self, alias: str):
"""
Retrieve cache identified by alias. Will return always the same instance
If the cache was not instantiated yet, it will do it lazily the first time
this is called.
:param alias: str cache alias
:return: cache instance
"""
try:
return self._caches[alias]
except KeyError:
pass
config = self.get_alias_config(alias)
cache = _create_cache(**deepcopy(config))
self._caches[alias] = cache
return cache
|
python
|
def get(self, alias: str):
"""
Retrieve cache identified by alias. Will return always the same instance
If the cache was not instantiated yet, it will do it lazily the first time
this is called.
:param alias: str cache alias
:return: cache instance
"""
try:
return self._caches[alias]
except KeyError:
pass
config = self.get_alias_config(alias)
cache = _create_cache(**deepcopy(config))
self._caches[alias] = cache
return cache
|
[
"def",
"get",
"(",
"self",
",",
"alias",
":",
"str",
")",
":",
"try",
":",
"return",
"self",
".",
"_caches",
"[",
"alias",
"]",
"except",
"KeyError",
":",
"pass",
"config",
"=",
"self",
".",
"get_alias_config",
"(",
"alias",
")",
"cache",
"=",
"_create_cache",
"(",
"*",
"*",
"deepcopy",
"(",
"config",
")",
")",
"self",
".",
"_caches",
"[",
"alias",
"]",
"=",
"cache",
"return",
"cache"
] |
Retrieve cache identified by alias. Will return always the same instance
If the cache was not instantiated yet, it will do it lazily the first time
this is called.
:param alias: str cache alias
:return: cache instance
|
[
"Retrieve",
"cache",
"identified",
"by",
"alias",
".",
"Will",
"return",
"always",
"the",
"same",
"instance"
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/factory.py#L158-L176
|
10,815
|
argaen/aiocache
|
aiocache/factory.py
|
CacheHandler.create
|
def create(self, alias=None, cache=None, **kwargs):
"""
Create a new cache. Either alias or cache params are required. You can use
kwargs to pass extra parameters to configure the cache.
.. deprecated:: 0.11.0
Only creating a cache passing an alias is supported. If you want to
create a cache passing explicit cache and kwargs use ``aiocache.Cache``.
:param alias: str alias to pull configuration from
:param cache: str or class cache class to use for creating the
new cache (when no alias is used)
:return: New cache instance
"""
if alias:
config = self.get_alias_config(alias)
elif cache:
warnings.warn(
"Creating a cache with an explicit config is deprecated, use 'aiocache.Cache'",
DeprecationWarning,
)
config = {"cache": cache}
else:
raise TypeError("create call needs to receive an alias or a cache")
cache = _create_cache(**{**config, **kwargs})
return cache
|
python
|
def create(self, alias=None, cache=None, **kwargs):
"""
Create a new cache. Either alias or cache params are required. You can use
kwargs to pass extra parameters to configure the cache.
.. deprecated:: 0.11.0
Only creating a cache passing an alias is supported. If you want to
create a cache passing explicit cache and kwargs use ``aiocache.Cache``.
:param alias: str alias to pull configuration from
:param cache: str or class cache class to use for creating the
new cache (when no alias is used)
:return: New cache instance
"""
if alias:
config = self.get_alias_config(alias)
elif cache:
warnings.warn(
"Creating a cache with an explicit config is deprecated, use 'aiocache.Cache'",
DeprecationWarning,
)
config = {"cache": cache}
else:
raise TypeError("create call needs to receive an alias or a cache")
cache = _create_cache(**{**config, **kwargs})
return cache
|
[
"def",
"create",
"(",
"self",
",",
"alias",
"=",
"None",
",",
"cache",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"alias",
":",
"config",
"=",
"self",
".",
"get_alias_config",
"(",
"alias",
")",
"elif",
"cache",
":",
"warnings",
".",
"warn",
"(",
"\"Creating a cache with an explicit config is deprecated, use 'aiocache.Cache'\"",
",",
"DeprecationWarning",
",",
")",
"config",
"=",
"{",
"\"cache\"",
":",
"cache",
"}",
"else",
":",
"raise",
"TypeError",
"(",
"\"create call needs to receive an alias or a cache\"",
")",
"cache",
"=",
"_create_cache",
"(",
"*",
"*",
"{",
"*",
"*",
"config",
",",
"*",
"*",
"kwargs",
"}",
")",
"return",
"cache"
] |
Create a new cache. Either alias or cache params are required. You can use
kwargs to pass extra parameters to configure the cache.
.. deprecated:: 0.11.0
Only creating a cache passing an alias is supported. If you want to
create a cache passing explicit cache and kwargs use ``aiocache.Cache``.
:param alias: str alias to pull configuration from
:param cache: str or class cache class to use for creating the
new cache (when no alias is used)
:return: New cache instance
|
[
"Create",
"a",
"new",
"cache",
".",
"Either",
"alias",
"or",
"cache",
"params",
"are",
"required",
".",
"You",
"can",
"use",
"kwargs",
"to",
"pass",
"extra",
"parameters",
"to",
"configure",
"the",
"cache",
"."
] |
fdd282f37283ca04e22209f4d2ae4900f29e1688
|
https://github.com/argaen/aiocache/blob/fdd282f37283ca04e22209f4d2ae4900f29e1688/aiocache/factory.py#L178-L203
|
10,816
|
Azure/msrest-for-python
|
msrest/polling/async_poller.py
|
async_poller
|
async def async_poller(client, initial_response, deserialization_callback, polling_method):
"""Async Poller for long running operations.
:param client: A msrest service client. Can be a SDK client and it will be casted to a ServiceClient.
:type client: msrest.service_client.ServiceClient
:param initial_response: The initial call response
:type initial_response: msrest.universal_http.ClientResponse or msrest.pipeline.ClientRawResponse
:param deserialization_callback: A callback that takes a Response and return a deserialized object. If a subclass of Model is given, this passes "deserialize" as callback.
:type deserialization_callback: callable or msrest.serialization.Model
:param polling_method: The polling strategy to adopt
:type polling_method: msrest.polling.PollingMethod
"""
try:
client = client if isinstance(client, ServiceClientAsync) else client._client
except AttributeError:
raise ValueError("Poller client parameter must be a low-level msrest Service Client or a SDK client.")
response = initial_response.response if isinstance(initial_response, ClientRawResponse) else initial_response
if isinstance(deserialization_callback, type) and issubclass(deserialization_callback, Model):
deserialization_callback = deserialization_callback.deserialize
# Might raise a CloudError
polling_method.initialize(client, response, deserialization_callback)
await polling_method.run()
return polling_method.resource()
|
python
|
async def async_poller(client, initial_response, deserialization_callback, polling_method):
"""Async Poller for long running operations.
:param client: A msrest service client. Can be a SDK client and it will be casted to a ServiceClient.
:type client: msrest.service_client.ServiceClient
:param initial_response: The initial call response
:type initial_response: msrest.universal_http.ClientResponse or msrest.pipeline.ClientRawResponse
:param deserialization_callback: A callback that takes a Response and return a deserialized object. If a subclass of Model is given, this passes "deserialize" as callback.
:type deserialization_callback: callable or msrest.serialization.Model
:param polling_method: The polling strategy to adopt
:type polling_method: msrest.polling.PollingMethod
"""
try:
client = client if isinstance(client, ServiceClientAsync) else client._client
except AttributeError:
raise ValueError("Poller client parameter must be a low-level msrest Service Client or a SDK client.")
response = initial_response.response if isinstance(initial_response, ClientRawResponse) else initial_response
if isinstance(deserialization_callback, type) and issubclass(deserialization_callback, Model):
deserialization_callback = deserialization_callback.deserialize
# Might raise a CloudError
polling_method.initialize(client, response, deserialization_callback)
await polling_method.run()
return polling_method.resource()
|
[
"async",
"def",
"async_poller",
"(",
"client",
",",
"initial_response",
",",
"deserialization_callback",
",",
"polling_method",
")",
":",
"try",
":",
"client",
"=",
"client",
"if",
"isinstance",
"(",
"client",
",",
"ServiceClientAsync",
")",
"else",
"client",
".",
"_client",
"except",
"AttributeError",
":",
"raise",
"ValueError",
"(",
"\"Poller client parameter must be a low-level msrest Service Client or a SDK client.\"",
")",
"response",
"=",
"initial_response",
".",
"response",
"if",
"isinstance",
"(",
"initial_response",
",",
"ClientRawResponse",
")",
"else",
"initial_response",
"if",
"isinstance",
"(",
"deserialization_callback",
",",
"type",
")",
"and",
"issubclass",
"(",
"deserialization_callback",
",",
"Model",
")",
":",
"deserialization_callback",
"=",
"deserialization_callback",
".",
"deserialize",
"# Might raise a CloudError",
"polling_method",
".",
"initialize",
"(",
"client",
",",
"response",
",",
"deserialization_callback",
")",
"await",
"polling_method",
".",
"run",
"(",
")",
"return",
"polling_method",
".",
"resource",
"(",
")"
] |
Async Poller for long running operations.
:param client: A msrest service client. Can be a SDK client and it will be casted to a ServiceClient.
:type client: msrest.service_client.ServiceClient
:param initial_response: The initial call response
:type initial_response: msrest.universal_http.ClientResponse or msrest.pipeline.ClientRawResponse
:param deserialization_callback: A callback that takes a Response and return a deserialized object. If a subclass of Model is given, this passes "deserialize" as callback.
:type deserialization_callback: callable or msrest.serialization.Model
:param polling_method: The polling strategy to adopt
:type polling_method: msrest.polling.PollingMethod
|
[
"Async",
"Poller",
"for",
"long",
"running",
"operations",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/polling/async_poller.py#L62-L88
|
10,817
|
Azure/msrest-for-python
|
msrest/pipeline/requests.py
|
RequestsPatchSession.send
|
def send(self, request, **kwargs):
"""Patch the current session with Request level operation config.
This is deprecated, we shouldn't patch the session with
arguments at the Request, and "config" should be used.
"""
session = request.context.session
old_max_redirects = None
if 'max_redirects' in kwargs:
warnings.warn("max_redirects in operation kwargs is deprecated, use config.redirect_policy instead",
DeprecationWarning)
old_max_redirects = session.max_redirects
session.max_redirects = int(kwargs['max_redirects'])
old_trust_env = None
if 'use_env_proxies' in kwargs:
warnings.warn("use_env_proxies in operation kwargs is deprecated, use config.proxies instead",
DeprecationWarning)
old_trust_env = session.trust_env
session.trust_env = bool(kwargs['use_env_proxies'])
old_retries = {}
if 'retries' in kwargs:
warnings.warn("retries in operation kwargs is deprecated, use config.retry_policy instead",
DeprecationWarning)
max_retries = kwargs['retries']
for protocol in self._protocols:
old_retries[protocol] = session.adapters[protocol].max_retries
session.adapters[protocol].max_retries = max_retries
try:
return self.next.send(request, **kwargs)
finally:
if old_max_redirects:
session.max_redirects = old_max_redirects
if old_trust_env:
session.trust_env = old_trust_env
if old_retries:
for protocol in self._protocols:
session.adapters[protocol].max_retries = old_retries[protocol]
|
python
|
def send(self, request, **kwargs):
"""Patch the current session with Request level operation config.
This is deprecated, we shouldn't patch the session with
arguments at the Request, and "config" should be used.
"""
session = request.context.session
old_max_redirects = None
if 'max_redirects' in kwargs:
warnings.warn("max_redirects in operation kwargs is deprecated, use config.redirect_policy instead",
DeprecationWarning)
old_max_redirects = session.max_redirects
session.max_redirects = int(kwargs['max_redirects'])
old_trust_env = None
if 'use_env_proxies' in kwargs:
warnings.warn("use_env_proxies in operation kwargs is deprecated, use config.proxies instead",
DeprecationWarning)
old_trust_env = session.trust_env
session.trust_env = bool(kwargs['use_env_proxies'])
old_retries = {}
if 'retries' in kwargs:
warnings.warn("retries in operation kwargs is deprecated, use config.retry_policy instead",
DeprecationWarning)
max_retries = kwargs['retries']
for protocol in self._protocols:
old_retries[protocol] = session.adapters[protocol].max_retries
session.adapters[protocol].max_retries = max_retries
try:
return self.next.send(request, **kwargs)
finally:
if old_max_redirects:
session.max_redirects = old_max_redirects
if old_trust_env:
session.trust_env = old_trust_env
if old_retries:
for protocol in self._protocols:
session.adapters[protocol].max_retries = old_retries[protocol]
|
[
"def",
"send",
"(",
"self",
",",
"request",
",",
"*",
"*",
"kwargs",
")",
":",
"session",
"=",
"request",
".",
"context",
".",
"session",
"old_max_redirects",
"=",
"None",
"if",
"'max_redirects'",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"\"max_redirects in operation kwargs is deprecated, use config.redirect_policy instead\"",
",",
"DeprecationWarning",
")",
"old_max_redirects",
"=",
"session",
".",
"max_redirects",
"session",
".",
"max_redirects",
"=",
"int",
"(",
"kwargs",
"[",
"'max_redirects'",
"]",
")",
"old_trust_env",
"=",
"None",
"if",
"'use_env_proxies'",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"\"use_env_proxies in operation kwargs is deprecated, use config.proxies instead\"",
",",
"DeprecationWarning",
")",
"old_trust_env",
"=",
"session",
".",
"trust_env",
"session",
".",
"trust_env",
"=",
"bool",
"(",
"kwargs",
"[",
"'use_env_proxies'",
"]",
")",
"old_retries",
"=",
"{",
"}",
"if",
"'retries'",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"\"retries in operation kwargs is deprecated, use config.retry_policy instead\"",
",",
"DeprecationWarning",
")",
"max_retries",
"=",
"kwargs",
"[",
"'retries'",
"]",
"for",
"protocol",
"in",
"self",
".",
"_protocols",
":",
"old_retries",
"[",
"protocol",
"]",
"=",
"session",
".",
"adapters",
"[",
"protocol",
"]",
".",
"max_retries",
"session",
".",
"adapters",
"[",
"protocol",
"]",
".",
"max_retries",
"=",
"max_retries",
"try",
":",
"return",
"self",
".",
"next",
".",
"send",
"(",
"request",
",",
"*",
"*",
"kwargs",
")",
"finally",
":",
"if",
"old_max_redirects",
":",
"session",
".",
"max_redirects",
"=",
"old_max_redirects",
"if",
"old_trust_env",
":",
"session",
".",
"trust_env",
"=",
"old_trust_env",
"if",
"old_retries",
":",
"for",
"protocol",
"in",
"self",
".",
"_protocols",
":",
"session",
".",
"adapters",
"[",
"protocol",
"]",
".",
"max_retries",
"=",
"old_retries",
"[",
"protocol",
"]"
] |
Patch the current session with Request level operation config.
This is deprecated, we shouldn't patch the session with
arguments at the Request, and "config" should be used.
|
[
"Patch",
"the",
"current",
"session",
"with",
"Request",
"level",
"operation",
"config",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/pipeline/requests.py#L105-L147
|
10,818
|
Azure/msrest-for-python
|
msrest/service_client.py
|
_ServiceClientCore._request
|
def _request(self, method, url, params, headers, content, form_content):
# type: (str, str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create ClientRequest object.
:param str url: URL for the request.
:param dict params: URL query parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = ClientRequest(method, self.format_url(url))
if params:
request.format_parameters(params)
if headers:
request.headers.update(headers)
# All requests should contain a Accept.
# This should be done by Autorest, but wasn't in old Autorest
# Force it for now, but might deprecate it later.
if "Accept" not in request.headers:
_LOGGER.debug("Accept header absent and forced to application/json")
request.headers['Accept'] = 'application/json'
if content is not None:
request.add_content(content)
if form_content:
request.add_formdata(form_content)
return request
|
python
|
def _request(self, method, url, params, headers, content, form_content):
# type: (str, str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create ClientRequest object.
:param str url: URL for the request.
:param dict params: URL query parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = ClientRequest(method, self.format_url(url))
if params:
request.format_parameters(params)
if headers:
request.headers.update(headers)
# All requests should contain a Accept.
# This should be done by Autorest, but wasn't in old Autorest
# Force it for now, but might deprecate it later.
if "Accept" not in request.headers:
_LOGGER.debug("Accept header absent and forced to application/json")
request.headers['Accept'] = 'application/json'
if content is not None:
request.add_content(content)
if form_content:
request.add_formdata(form_content)
return request
|
[
"def",
"_request",
"(",
"self",
",",
"method",
",",
"url",
",",
"params",
",",
"headers",
",",
"content",
",",
"form_content",
")",
":",
"# type: (str, str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest",
"request",
"=",
"ClientRequest",
"(",
"method",
",",
"self",
".",
"format_url",
"(",
"url",
")",
")",
"if",
"params",
":",
"request",
".",
"format_parameters",
"(",
"params",
")",
"if",
"headers",
":",
"request",
".",
"headers",
".",
"update",
"(",
"headers",
")",
"# All requests should contain a Accept.",
"# This should be done by Autorest, but wasn't in old Autorest",
"# Force it for now, but might deprecate it later.",
"if",
"\"Accept\"",
"not",
"in",
"request",
".",
"headers",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Accept header absent and forced to application/json\"",
")",
"request",
".",
"headers",
"[",
"'Accept'",
"]",
"=",
"'application/json'",
"if",
"content",
"is",
"not",
"None",
":",
"request",
".",
"add_content",
"(",
"content",
")",
"if",
"form_content",
":",
"request",
".",
"add_formdata",
"(",
"form_content",
")",
"return",
"request"
] |
Create ClientRequest object.
:param str url: URL for the request.
:param dict params: URL query parameters.
:param dict headers: Headers
:param dict form_content: Form content
|
[
"Create",
"ClientRequest",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L99-L128
|
10,819
|
Azure/msrest-for-python
|
msrest/service_client.py
|
_ServiceClientCore.format_url
|
def format_url(self, url, **kwargs):
# type: (str, Any) -> str
"""Format request URL with the client base URL, unless the
supplied URL is already absolute.
:param str url: The request URL to be formatted if necessary.
"""
url = url.format(**kwargs)
parsed = urlparse(url)
if not parsed.scheme or not parsed.netloc:
url = url.lstrip('/')
base = self.config.base_url.format(**kwargs).rstrip('/')
url = urljoin(base + '/', url)
return url
|
python
|
def format_url(self, url, **kwargs):
# type: (str, Any) -> str
"""Format request URL with the client base URL, unless the
supplied URL is already absolute.
:param str url: The request URL to be formatted if necessary.
"""
url = url.format(**kwargs)
parsed = urlparse(url)
if not parsed.scheme or not parsed.netloc:
url = url.lstrip('/')
base = self.config.base_url.format(**kwargs).rstrip('/')
url = urljoin(base + '/', url)
return url
|
[
"def",
"format_url",
"(",
"self",
",",
"url",
",",
"*",
"*",
"kwargs",
")",
":",
"# type: (str, Any) -> str",
"url",
"=",
"url",
".",
"format",
"(",
"*",
"*",
"kwargs",
")",
"parsed",
"=",
"urlparse",
"(",
"url",
")",
"if",
"not",
"parsed",
".",
"scheme",
"or",
"not",
"parsed",
".",
"netloc",
":",
"url",
"=",
"url",
".",
"lstrip",
"(",
"'/'",
")",
"base",
"=",
"self",
".",
"config",
".",
"base_url",
".",
"format",
"(",
"*",
"*",
"kwargs",
")",
".",
"rstrip",
"(",
"'/'",
")",
"url",
"=",
"urljoin",
"(",
"base",
"+",
"'/'",
",",
"url",
")",
"return",
"url"
] |
Format request URL with the client base URL, unless the
supplied URL is already absolute.
:param str url: The request URL to be formatted if necessary.
|
[
"Format",
"request",
"URL",
"with",
"the",
"client",
"base",
"URL",
"unless",
"the",
"supplied",
"URL",
"is",
"already",
"absolute",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L144-L157
|
10,820
|
Azure/msrest-for-python
|
msrest/service_client.py
|
_ServiceClientCore.get
|
def get(self, url, params=None, headers=None, content=None, form_content=None):
# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create a GET request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = self._request('GET', url, params, headers, content, form_content)
request.method = 'GET'
return request
|
python
|
def get(self, url, params=None, headers=None, content=None, form_content=None):
# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create a GET request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = self._request('GET', url, params, headers, content, form_content)
request.method = 'GET'
return request
|
[
"def",
"get",
"(",
"self",
",",
"url",
",",
"params",
"=",
"None",
",",
"headers",
"=",
"None",
",",
"content",
"=",
"None",
",",
"form_content",
"=",
"None",
")",
":",
"# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest",
"request",
"=",
"self",
".",
"_request",
"(",
"'GET'",
",",
"url",
",",
"params",
",",
"headers",
",",
"content",
",",
"form_content",
")",
"request",
".",
"method",
"=",
"'GET'",
"return",
"request"
] |
Create a GET request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
|
[
"Create",
"a",
"GET",
"request",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L159-L170
|
10,821
|
Azure/msrest-for-python
|
msrest/service_client.py
|
_ServiceClientCore.put
|
def put(self, url, params=None, headers=None, content=None, form_content=None):
# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create a PUT request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = self._request('PUT', url, params, headers, content, form_content)
return request
|
python
|
def put(self, url, params=None, headers=None, content=None, form_content=None):
# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
"""Create a PUT request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
"""
request = self._request('PUT', url, params, headers, content, form_content)
return request
|
[
"def",
"put",
"(",
"self",
",",
"url",
",",
"params",
"=",
"None",
",",
"headers",
"=",
"None",
",",
"content",
"=",
"None",
",",
"form_content",
"=",
"None",
")",
":",
"# type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest",
"request",
"=",
"self",
".",
"_request",
"(",
"'PUT'",
",",
"url",
",",
"params",
",",
"headers",
",",
"content",
",",
"form_content",
")",
"return",
"request"
] |
Create a PUT request object.
:param str url: The request URL.
:param dict params: Request URL parameters.
:param dict headers: Headers
:param dict form_content: Form content
|
[
"Create",
"a",
"PUT",
"request",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L172-L182
|
10,822
|
Azure/msrest-for-python
|
msrest/service_client.py
|
ServiceClient.send_formdata
|
def send_formdata(self, request, headers=None, content=None, **config):
"""Send data as a multipart form-data request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
This method is deprecated, and shouldn't be used anymore.
:param ClientRequest request: The request object to be sent.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
:param config: Any specific config overrides.
"""
request.headers = headers
request.add_formdata(content)
return self.send(request, **config)
|
python
|
def send_formdata(self, request, headers=None, content=None, **config):
"""Send data as a multipart form-data request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
This method is deprecated, and shouldn't be used anymore.
:param ClientRequest request: The request object to be sent.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
:param config: Any specific config overrides.
"""
request.headers = headers
request.add_formdata(content)
return self.send(request, **config)
|
[
"def",
"send_formdata",
"(",
"self",
",",
"request",
",",
"headers",
"=",
"None",
",",
"content",
"=",
"None",
",",
"*",
"*",
"config",
")",
":",
"request",
".",
"headers",
"=",
"headers",
"request",
".",
"add_formdata",
"(",
"content",
")",
"return",
"self",
".",
"send",
"(",
"request",
",",
"*",
"*",
"config",
")"
] |
Send data as a multipart form-data request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
This method is deprecated, and shouldn't be used anymore.
:param ClientRequest request: The request object to be sent.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
:param config: Any specific config overrides.
|
[
"Send",
"data",
"as",
"a",
"multipart",
"form",
"-",
"data",
"request",
".",
"We",
"only",
"deal",
"with",
"file",
"-",
"like",
"objects",
"or",
"strings",
"at",
"this",
"point",
".",
"The",
"requests",
"is",
"not",
"yet",
"streamed",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L302-L316
|
10,823
|
Azure/msrest-for-python
|
msrest/service_client.py
|
ServiceClient.add_header
|
def add_header(self, header, value):
# type: (str, str) -> None
"""Add a persistent header - this header will be applied to all
requests sent during the current client session.
.. deprecated:: 0.5.0
Use config.headers instead
:param str header: The header name.
:param str value: The header value.
"""
warnings.warn("Private attribute _client.add_header is deprecated. Use config.headers instead.",
DeprecationWarning)
self.config.headers[header] = value
|
python
|
def add_header(self, header, value):
# type: (str, str) -> None
"""Add a persistent header - this header will be applied to all
requests sent during the current client session.
.. deprecated:: 0.5.0
Use config.headers instead
:param str header: The header name.
:param str value: The header value.
"""
warnings.warn("Private attribute _client.add_header is deprecated. Use config.headers instead.",
DeprecationWarning)
self.config.headers[header] = value
|
[
"def",
"add_header",
"(",
"self",
",",
"header",
",",
"value",
")",
":",
"# type: (str, str) -> None",
"warnings",
".",
"warn",
"(",
"\"Private attribute _client.add_header is deprecated. Use config.headers instead.\"",
",",
"DeprecationWarning",
")",
"self",
".",
"config",
".",
"headers",
"[",
"header",
"]",
"=",
"value"
] |
Add a persistent header - this header will be applied to all
requests sent during the current client session.
.. deprecated:: 0.5.0
Use config.headers instead
:param str header: The header name.
:param str value: The header value.
|
[
"Add",
"a",
"persistent",
"header",
"-",
"this",
"header",
"will",
"be",
"applied",
"to",
"all",
"requests",
"sent",
"during",
"the",
"current",
"client",
"session",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/service_client.py#L375-L388
|
10,824
|
Azure/msrest-for-python
|
msrest/authentication.py
|
ApiKeyCredentials.signed_session
|
def signed_session(self, session=None):
# type: (Optional[requests.Session]) -> requests.Session
"""Create requests session with ApiKey.
If a session object is provided, configure it directly. Otherwise,
create a new session and return it.
:param session: The session to configure for authentication
:type session: requests.Session
:rtype: requests.Session
"""
session = super(ApiKeyCredentials, self).signed_session(session)
session.headers.update(self.in_headers)
try:
# params is actually Union[bytes, MutableMapping[Text, Text]]
session.params.update(self.in_query) # type: ignore
except AttributeError: # requests.params can be bytes
raise ValueError("session.params must be a dict to be used in ApiKeyCredentials")
return session
|
python
|
def signed_session(self, session=None):
# type: (Optional[requests.Session]) -> requests.Session
"""Create requests session with ApiKey.
If a session object is provided, configure it directly. Otherwise,
create a new session and return it.
:param session: The session to configure for authentication
:type session: requests.Session
:rtype: requests.Session
"""
session = super(ApiKeyCredentials, self).signed_session(session)
session.headers.update(self.in_headers)
try:
# params is actually Union[bytes, MutableMapping[Text, Text]]
session.params.update(self.in_query) # type: ignore
except AttributeError: # requests.params can be bytes
raise ValueError("session.params must be a dict to be used in ApiKeyCredentials")
return session
|
[
"def",
"signed_session",
"(",
"self",
",",
"session",
"=",
"None",
")",
":",
"# type: (Optional[requests.Session]) -> requests.Session",
"session",
"=",
"super",
"(",
"ApiKeyCredentials",
",",
"self",
")",
".",
"signed_session",
"(",
"session",
")",
"session",
".",
"headers",
".",
"update",
"(",
"self",
".",
"in_headers",
")",
"try",
":",
"# params is actually Union[bytes, MutableMapping[Text, Text]]",
"session",
".",
"params",
".",
"update",
"(",
"self",
".",
"in_query",
")",
"# type: ignore",
"except",
"AttributeError",
":",
"# requests.params can be bytes",
"raise",
"ValueError",
"(",
"\"session.params must be a dict to be used in ApiKeyCredentials\"",
")",
"return",
"session"
] |
Create requests session with ApiKey.
If a session object is provided, configure it directly. Otherwise,
create a new session and return it.
:param session: The session to configure for authentication
:type session: requests.Session
:rtype: requests.Session
|
[
"Create",
"requests",
"session",
"with",
"ApiKey",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/authentication.py#L197-L215
|
10,825
|
Azure/msrest-for-python
|
msrest/pipeline/universal.py
|
RawDeserializer.deserialize_from_text
|
def deserialize_from_text(cls, data, content_type=None):
# type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any
"""Decode data according to content-type.
Accept a stream of data as well, but will be load at once in memory for now.
If no content-type, will return the string version (not bytes, not stream)
:param data: Input, could be bytes or stream (will be decoded with UTF8) or text
:type data: str or bytes or IO
:param str content_type: The content type.
"""
if hasattr(data, 'read'):
# Assume a stream
data = cast(IO, data).read()
if isinstance(data, bytes):
data_as_str = data.decode(encoding='utf-8-sig')
else:
# Explain to mypy the correct type.
data_as_str = cast(str, data)
# Remove Byte Order Mark if present in string
data_as_str = data_as_str.lstrip(_BOM)
if content_type is None:
return data
if content_type in cls.JSON_MIMETYPES:
try:
return json.loads(data_as_str)
except ValueError as err:
raise DeserializationError("JSON is invalid: {}".format(err), err)
elif "xml" in (content_type or []):
try:
return ET.fromstring(data_as_str)
except ET.ParseError:
# It might be because the server has an issue, and returned JSON with
# content-type XML....
# So let's try a JSON load, and if it's still broken
# let's flow the initial exception
def _json_attemp(data):
try:
return True, json.loads(data)
except ValueError:
return False, None # Don't care about this one
success, json_result = _json_attemp(data)
if success:
return json_result
# If i'm here, it's not JSON, it's not XML, let's scream
# and raise the last context in this block (the XML exception)
# The function hack is because Py2.7 messes up with exception
# context otherwise.
_LOGGER.critical("Wasn't XML not JSON, failing")
raise_with_traceback(DeserializationError, "XML is invalid")
raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
|
python
|
def deserialize_from_text(cls, data, content_type=None):
# type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any
"""Decode data according to content-type.
Accept a stream of data as well, but will be load at once in memory for now.
If no content-type, will return the string version (not bytes, not stream)
:param data: Input, could be bytes or stream (will be decoded with UTF8) or text
:type data: str or bytes or IO
:param str content_type: The content type.
"""
if hasattr(data, 'read'):
# Assume a stream
data = cast(IO, data).read()
if isinstance(data, bytes):
data_as_str = data.decode(encoding='utf-8-sig')
else:
# Explain to mypy the correct type.
data_as_str = cast(str, data)
# Remove Byte Order Mark if present in string
data_as_str = data_as_str.lstrip(_BOM)
if content_type is None:
return data
if content_type in cls.JSON_MIMETYPES:
try:
return json.loads(data_as_str)
except ValueError as err:
raise DeserializationError("JSON is invalid: {}".format(err), err)
elif "xml" in (content_type or []):
try:
return ET.fromstring(data_as_str)
except ET.ParseError:
# It might be because the server has an issue, and returned JSON with
# content-type XML....
# So let's try a JSON load, and if it's still broken
# let's flow the initial exception
def _json_attemp(data):
try:
return True, json.loads(data)
except ValueError:
return False, None # Don't care about this one
success, json_result = _json_attemp(data)
if success:
return json_result
# If i'm here, it's not JSON, it's not XML, let's scream
# and raise the last context in this block (the XML exception)
# The function hack is because Py2.7 messes up with exception
# context otherwise.
_LOGGER.critical("Wasn't XML not JSON, failing")
raise_with_traceback(DeserializationError, "XML is invalid")
raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
|
[
"def",
"deserialize_from_text",
"(",
"cls",
",",
"data",
",",
"content_type",
"=",
"None",
")",
":",
"# type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any",
"if",
"hasattr",
"(",
"data",
",",
"'read'",
")",
":",
"# Assume a stream",
"data",
"=",
"cast",
"(",
"IO",
",",
"data",
")",
".",
"read",
"(",
")",
"if",
"isinstance",
"(",
"data",
",",
"bytes",
")",
":",
"data_as_str",
"=",
"data",
".",
"decode",
"(",
"encoding",
"=",
"'utf-8-sig'",
")",
"else",
":",
"# Explain to mypy the correct type.",
"data_as_str",
"=",
"cast",
"(",
"str",
",",
"data",
")",
"# Remove Byte Order Mark if present in string",
"data_as_str",
"=",
"data_as_str",
".",
"lstrip",
"(",
"_BOM",
")",
"if",
"content_type",
"is",
"None",
":",
"return",
"data",
"if",
"content_type",
"in",
"cls",
".",
"JSON_MIMETYPES",
":",
"try",
":",
"return",
"json",
".",
"loads",
"(",
"data_as_str",
")",
"except",
"ValueError",
"as",
"err",
":",
"raise",
"DeserializationError",
"(",
"\"JSON is invalid: {}\"",
".",
"format",
"(",
"err",
")",
",",
"err",
")",
"elif",
"\"xml\"",
"in",
"(",
"content_type",
"or",
"[",
"]",
")",
":",
"try",
":",
"return",
"ET",
".",
"fromstring",
"(",
"data_as_str",
")",
"except",
"ET",
".",
"ParseError",
":",
"# It might be because the server has an issue, and returned JSON with",
"# content-type XML....",
"# So let's try a JSON load, and if it's still broken",
"# let's flow the initial exception",
"def",
"_json_attemp",
"(",
"data",
")",
":",
"try",
":",
"return",
"True",
",",
"json",
".",
"loads",
"(",
"data",
")",
"except",
"ValueError",
":",
"return",
"False",
",",
"None",
"# Don't care about this one",
"success",
",",
"json_result",
"=",
"_json_attemp",
"(",
"data",
")",
"if",
"success",
":",
"return",
"json_result",
"# If i'm here, it's not JSON, it's not XML, let's scream",
"# and raise the last context in this block (the XML exception)",
"# The function hack is because Py2.7 messes up with exception",
"# context otherwise.",
"_LOGGER",
".",
"critical",
"(",
"\"Wasn't XML not JSON, failing\"",
")",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"\"XML is invalid\"",
")",
"raise",
"DeserializationError",
"(",
"\"Cannot deserialize content-type: {}\"",
".",
"format",
"(",
"content_type",
")",
")"
] |
Decode data according to content-type.
Accept a stream of data as well, but will be load at once in memory for now.
If no content-type, will return the string version (not bytes, not stream)
:param data: Input, could be bytes or stream (will be decoded with UTF8) or text
:type data: str or bytes or IO
:param str content_type: The content type.
|
[
"Decode",
"data",
"according",
"to",
"content",
"-",
"type",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/pipeline/universal.py#L140-L195
|
10,826
|
Azure/msrest-for-python
|
msrest/pipeline/universal.py
|
RawDeserializer.deserialize_from_http_generics
|
def deserialize_from_http_generics(cls, body_bytes, headers):
# type: (Optional[Union[AnyStr, IO]], Mapping) -> Any
"""Deserialize from HTTP response.
Use bytes and headers to NOT use any requests/aiohttp or whatever
specific implementation.
Headers will tested for "content-type"
"""
# Try to use content-type from headers if available
content_type = None
if 'content-type' in headers:
content_type = headers['content-type'].split(";")[0].strip().lower()
# Ouch, this server did not declare what it sent...
# Let's guess it's JSON...
# Also, since Autorest was considering that an empty body was a valid JSON,
# need that test as well....
else:
content_type = "application/json"
if body_bytes:
return cls.deserialize_from_text(body_bytes, content_type)
return None
|
python
|
def deserialize_from_http_generics(cls, body_bytes, headers):
# type: (Optional[Union[AnyStr, IO]], Mapping) -> Any
"""Deserialize from HTTP response.
Use bytes and headers to NOT use any requests/aiohttp or whatever
specific implementation.
Headers will tested for "content-type"
"""
# Try to use content-type from headers if available
content_type = None
if 'content-type' in headers:
content_type = headers['content-type'].split(";")[0].strip().lower()
# Ouch, this server did not declare what it sent...
# Let's guess it's JSON...
# Also, since Autorest was considering that an empty body was a valid JSON,
# need that test as well....
else:
content_type = "application/json"
if body_bytes:
return cls.deserialize_from_text(body_bytes, content_type)
return None
|
[
"def",
"deserialize_from_http_generics",
"(",
"cls",
",",
"body_bytes",
",",
"headers",
")",
":",
"# type: (Optional[Union[AnyStr, IO]], Mapping) -> Any",
"# Try to use content-type from headers if available",
"content_type",
"=",
"None",
"if",
"'content-type'",
"in",
"headers",
":",
"content_type",
"=",
"headers",
"[",
"'content-type'",
"]",
".",
"split",
"(",
"\";\"",
")",
"[",
"0",
"]",
".",
"strip",
"(",
")",
".",
"lower",
"(",
")",
"# Ouch, this server did not declare what it sent...",
"# Let's guess it's JSON...",
"# Also, since Autorest was considering that an empty body was a valid JSON,",
"# need that test as well....",
"else",
":",
"content_type",
"=",
"\"application/json\"",
"if",
"body_bytes",
":",
"return",
"cls",
".",
"deserialize_from_text",
"(",
"body_bytes",
",",
"content_type",
")",
"return",
"None"
] |
Deserialize from HTTP response.
Use bytes and headers to NOT use any requests/aiohttp or whatever
specific implementation.
Headers will tested for "content-type"
|
[
"Deserialize",
"from",
"HTTP",
"response",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/pipeline/universal.py#L198-L219
|
10,827
|
Azure/msrest-for-python
|
msrest/pipeline/universal.py
|
RawDeserializer.on_response
|
def on_response(self, request, response, **kwargs):
# type: (Request, Response, Any) -> None
"""Extract data from the body of a REST response object.
This will load the entire payload in memory.
Will follow Content-Type to parse.
We assume everything is UTF8 (BOM acceptable).
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
:raises xml.etree.ElementTree.ParseError: If bytes is not valid XML
"""
# If response was asked as stream, do NOT read anything and quit now
if kwargs.get("stream", True):
return
http_response = response.http_response
response.context[self.CONTEXT_NAME] = self.deserialize_from_http_generics(
http_response.text(),
http_response.headers
)
|
python
|
def on_response(self, request, response, **kwargs):
# type: (Request, Response, Any) -> None
"""Extract data from the body of a REST response object.
This will load the entire payload in memory.
Will follow Content-Type to parse.
We assume everything is UTF8 (BOM acceptable).
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
:raises xml.etree.ElementTree.ParseError: If bytes is not valid XML
"""
# If response was asked as stream, do NOT read anything and quit now
if kwargs.get("stream", True):
return
http_response = response.http_response
response.context[self.CONTEXT_NAME] = self.deserialize_from_http_generics(
http_response.text(),
http_response.headers
)
|
[
"def",
"on_response",
"(",
"self",
",",
"request",
",",
"response",
",",
"*",
"*",
"kwargs",
")",
":",
"# type: (Request, Response, Any) -> None",
"# If response was asked as stream, do NOT read anything and quit now",
"if",
"kwargs",
".",
"get",
"(",
"\"stream\"",
",",
"True",
")",
":",
"return",
"http_response",
"=",
"response",
".",
"http_response",
"response",
".",
"context",
"[",
"self",
".",
"CONTEXT_NAME",
"]",
"=",
"self",
".",
"deserialize_from_http_generics",
"(",
"http_response",
".",
"text",
"(",
")",
",",
"http_response",
".",
"headers",
")"
] |
Extract data from the body of a REST response object.
This will load the entire payload in memory.
Will follow Content-Type to parse.
We assume everything is UTF8 (BOM acceptable).
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
:raises xml.etree.ElementTree.ParseError: If bytes is not valid XML
|
[
"Extract",
"data",
"from",
"the",
"body",
"of",
"a",
"REST",
"response",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/pipeline/universal.py#L221-L245
|
10,828
|
Azure/msrest-for-python
|
msrest/pipeline/__init__.py
|
ClientRawResponse.add_headers
|
def add_headers(self, header_dict):
# type: (Dict[str, str]) -> None
"""Deserialize a specific header.
:param dict header_dict: A dictionary containing the name of the
header and the type to deserialize to.
"""
if not self.response:
return
for name, data_type in header_dict.items():
value = self.response.headers.get(name)
value = self._deserialize(data_type, value)
self.headers[name] = value
|
python
|
def add_headers(self, header_dict):
# type: (Dict[str, str]) -> None
"""Deserialize a specific header.
:param dict header_dict: A dictionary containing the name of the
header and the type to deserialize to.
"""
if not self.response:
return
for name, data_type in header_dict.items():
value = self.response.headers.get(name)
value = self._deserialize(data_type, value)
self.headers[name] = value
|
[
"def",
"add_headers",
"(",
"self",
",",
"header_dict",
")",
":",
"# type: (Dict[str, str]) -> None",
"if",
"not",
"self",
".",
"response",
":",
"return",
"for",
"name",
",",
"data_type",
"in",
"header_dict",
".",
"items",
"(",
")",
":",
"value",
"=",
"self",
".",
"response",
".",
"headers",
".",
"get",
"(",
"name",
")",
"value",
"=",
"self",
".",
"_deserialize",
"(",
"data_type",
",",
"value",
")",
"self",
".",
"headers",
"[",
"name",
"]",
"=",
"value"
] |
Deserialize a specific header.
:param dict header_dict: A dictionary containing the name of the
header and the type to deserialize to.
|
[
"Deserialize",
"a",
"specific",
"header",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/pipeline/__init__.py#L293-L305
|
10,829
|
Azure/msrest-for-python
|
msrest/http_logger.py
|
log_request
|
def log_request(_, request, *_args, **_kwargs):
# type: (Any, ClientRequest, str, str) -> None
"""Log a client request.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
"""
if not _LOGGER.isEnabledFor(logging.DEBUG):
return
try:
_LOGGER.debug("Request URL: %r", request.url)
_LOGGER.debug("Request method: %r", request.method)
_LOGGER.debug("Request headers:")
for header, value in request.headers.items():
if header.lower() == 'authorization':
value = '*****'
_LOGGER.debug(" %r: %r", header, value)
_LOGGER.debug("Request body:")
# We don't want to log the binary data of a file upload.
if isinstance(request.body, types.GeneratorType):
_LOGGER.debug("File upload")
else:
_LOGGER.debug(str(request.body))
except Exception as err: # pylint: disable=broad-except
_LOGGER.debug("Failed to log request: %r", err)
|
python
|
def log_request(_, request, *_args, **_kwargs):
# type: (Any, ClientRequest, str, str) -> None
"""Log a client request.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
"""
if not _LOGGER.isEnabledFor(logging.DEBUG):
return
try:
_LOGGER.debug("Request URL: %r", request.url)
_LOGGER.debug("Request method: %r", request.method)
_LOGGER.debug("Request headers:")
for header, value in request.headers.items():
if header.lower() == 'authorization':
value = '*****'
_LOGGER.debug(" %r: %r", header, value)
_LOGGER.debug("Request body:")
# We don't want to log the binary data of a file upload.
if isinstance(request.body, types.GeneratorType):
_LOGGER.debug("File upload")
else:
_LOGGER.debug(str(request.body))
except Exception as err: # pylint: disable=broad-except
_LOGGER.debug("Failed to log request: %r", err)
|
[
"def",
"log_request",
"(",
"_",
",",
"request",
",",
"*",
"_args",
",",
"*",
"*",
"_kwargs",
")",
":",
"# type: (Any, ClientRequest, str, str) -> None",
"if",
"not",
"_LOGGER",
".",
"isEnabledFor",
"(",
"logging",
".",
"DEBUG",
")",
":",
"return",
"try",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Request URL: %r\"",
",",
"request",
".",
"url",
")",
"_LOGGER",
".",
"debug",
"(",
"\"Request method: %r\"",
",",
"request",
".",
"method",
")",
"_LOGGER",
".",
"debug",
"(",
"\"Request headers:\"",
")",
"for",
"header",
",",
"value",
"in",
"request",
".",
"headers",
".",
"items",
"(",
")",
":",
"if",
"header",
".",
"lower",
"(",
")",
"==",
"'authorization'",
":",
"value",
"=",
"'*****'",
"_LOGGER",
".",
"debug",
"(",
"\" %r: %r\"",
",",
"header",
",",
"value",
")",
"_LOGGER",
".",
"debug",
"(",
"\"Request body:\"",
")",
"# We don't want to log the binary data of a file upload.",
"if",
"isinstance",
"(",
"request",
".",
"body",
",",
"types",
".",
"GeneratorType",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\"File upload\"",
")",
"else",
":",
"_LOGGER",
".",
"debug",
"(",
"str",
"(",
"request",
".",
"body",
")",
")",
"except",
"Exception",
"as",
"err",
":",
"# pylint: disable=broad-except",
"_LOGGER",
".",
"debug",
"(",
"\"Failed to log request: %r\"",
",",
"err",
")"
] |
Log a client request.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
|
[
"Log",
"a",
"client",
"request",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/http_logger.py#L39-L65
|
10,830
|
Azure/msrest-for-python
|
msrest/http_logger.py
|
log_response
|
def log_response(_, _request, response, *_args, **kwargs):
# type: (Any, ClientRequest, ClientResponse, str, Any) -> Optional[ClientResponse]
"""Log a server response.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
:param requests.Response response: The response object.
"""
if not _LOGGER.isEnabledFor(logging.DEBUG):
return None
try:
_LOGGER.debug("Response status: %r", response.status_code)
_LOGGER.debug("Response headers:")
for res_header, value in response.headers.items():
_LOGGER.debug(" %r: %r", res_header, value)
# We don't want to log binary data if the response is a file.
_LOGGER.debug("Response content:")
pattern = re.compile(r'attachment; ?filename=["\w.]+', re.IGNORECASE)
header = response.headers.get('content-disposition')
if header and pattern.match(header):
filename = header.partition('=')[2]
_LOGGER.debug("File attachments: %s", filename)
elif response.headers.get("content-type", "").endswith("octet-stream"):
_LOGGER.debug("Body contains binary data.")
elif response.headers.get("content-type", "").startswith("image"):
_LOGGER.debug("Body contains image data.")
else:
if kwargs.get('stream', False):
_LOGGER.debug("Body is streamable")
else:
_LOGGER.debug(response.text())
return response
except Exception as err: # pylint: disable=broad-except
_LOGGER.debug("Failed to log response: %s", repr(err))
return response
|
python
|
def log_response(_, _request, response, *_args, **kwargs):
# type: (Any, ClientRequest, ClientResponse, str, Any) -> Optional[ClientResponse]
"""Log a server response.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
:param requests.Response response: The response object.
"""
if not _LOGGER.isEnabledFor(logging.DEBUG):
return None
try:
_LOGGER.debug("Response status: %r", response.status_code)
_LOGGER.debug("Response headers:")
for res_header, value in response.headers.items():
_LOGGER.debug(" %r: %r", res_header, value)
# We don't want to log binary data if the response is a file.
_LOGGER.debug("Response content:")
pattern = re.compile(r'attachment; ?filename=["\w.]+', re.IGNORECASE)
header = response.headers.get('content-disposition')
if header and pattern.match(header):
filename = header.partition('=')[2]
_LOGGER.debug("File attachments: %s", filename)
elif response.headers.get("content-type", "").endswith("octet-stream"):
_LOGGER.debug("Body contains binary data.")
elif response.headers.get("content-type", "").startswith("image"):
_LOGGER.debug("Body contains image data.")
else:
if kwargs.get('stream', False):
_LOGGER.debug("Body is streamable")
else:
_LOGGER.debug(response.text())
return response
except Exception as err: # pylint: disable=broad-except
_LOGGER.debug("Failed to log response: %s", repr(err))
return response
|
[
"def",
"log_response",
"(",
"_",
",",
"_request",
",",
"response",
",",
"*",
"_args",
",",
"*",
"*",
"kwargs",
")",
":",
"# type: (Any, ClientRequest, ClientResponse, str, Any) -> Optional[ClientResponse]",
"if",
"not",
"_LOGGER",
".",
"isEnabledFor",
"(",
"logging",
".",
"DEBUG",
")",
":",
"return",
"None",
"try",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Response status: %r\"",
",",
"response",
".",
"status_code",
")",
"_LOGGER",
".",
"debug",
"(",
"\"Response headers:\"",
")",
"for",
"res_header",
",",
"value",
"in",
"response",
".",
"headers",
".",
"items",
"(",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\" %r: %r\"",
",",
"res_header",
",",
"value",
")",
"# We don't want to log binary data if the response is a file.",
"_LOGGER",
".",
"debug",
"(",
"\"Response content:\"",
")",
"pattern",
"=",
"re",
".",
"compile",
"(",
"r'attachment; ?filename=[\"\\w.]+'",
",",
"re",
".",
"IGNORECASE",
")",
"header",
"=",
"response",
".",
"headers",
".",
"get",
"(",
"'content-disposition'",
")",
"if",
"header",
"and",
"pattern",
".",
"match",
"(",
"header",
")",
":",
"filename",
"=",
"header",
".",
"partition",
"(",
"'='",
")",
"[",
"2",
"]",
"_LOGGER",
".",
"debug",
"(",
"\"File attachments: %s\"",
",",
"filename",
")",
"elif",
"response",
".",
"headers",
".",
"get",
"(",
"\"content-type\"",
",",
"\"\"",
")",
".",
"endswith",
"(",
"\"octet-stream\"",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Body contains binary data.\"",
")",
"elif",
"response",
".",
"headers",
".",
"get",
"(",
"\"content-type\"",
",",
"\"\"",
")",
".",
"startswith",
"(",
"\"image\"",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Body contains image data.\"",
")",
"else",
":",
"if",
"kwargs",
".",
"get",
"(",
"'stream'",
",",
"False",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Body is streamable\"",
")",
"else",
":",
"_LOGGER",
".",
"debug",
"(",
"response",
".",
"text",
"(",
")",
")",
"return",
"response",
"except",
"Exception",
"as",
"err",
":",
"# pylint: disable=broad-except",
"_LOGGER",
".",
"debug",
"(",
"\"Failed to log response: %s\"",
",",
"repr",
"(",
"err",
")",
")",
"return",
"response"
] |
Log a server response.
:param _: Unused in current version (will be None)
:param requests.Request request: The request object.
:param requests.Response response: The response object.
|
[
"Log",
"a",
"server",
"response",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/http_logger.py#L68-L105
|
10,831
|
Azure/msrest-for-python
|
msrest/universal_http/__init__.py
|
HTTPSenderConfiguration._clear_config
|
def _clear_config(self):
# type: () -> None
"""Clearout config object in memory."""
for section in self._config.sections():
self._config.remove_section(section)
|
python
|
def _clear_config(self):
# type: () -> None
"""Clearout config object in memory."""
for section in self._config.sections():
self._config.remove_section(section)
|
[
"def",
"_clear_config",
"(",
"self",
")",
":",
"# type: () -> None",
"for",
"section",
"in",
"self",
".",
"_config",
".",
"sections",
"(",
")",
":",
"self",
".",
"_config",
".",
"remove_section",
"(",
"section",
")"
] |
Clearout config object in memory.
|
[
"Clearout",
"config",
"object",
"in",
"memory",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/__init__.py#L120-L124
|
10,832
|
Azure/msrest-for-python
|
msrest/universal_http/__init__.py
|
ClientRequest.format_parameters
|
def format_parameters(self, params):
# type: (Dict[str, str]) -> None
"""Format parameters into a valid query string.
It's assumed all parameters have already been quoted as
valid URL strings.
:param dict params: A dictionary of parameters.
"""
query = urlparse(self.url).query
if query:
self.url = self.url.partition('?')[0]
existing_params = {
p[0]: p[-1]
for p in [p.partition('=') for p in query.split('&')]
}
params.update(existing_params)
query_params = ["{}={}".format(k, v) for k, v in params.items()]
query = '?' + '&'.join(query_params)
self.url = self.url + query
|
python
|
def format_parameters(self, params):
# type: (Dict[str, str]) -> None
"""Format parameters into a valid query string.
It's assumed all parameters have already been quoted as
valid URL strings.
:param dict params: A dictionary of parameters.
"""
query = urlparse(self.url).query
if query:
self.url = self.url.partition('?')[0]
existing_params = {
p[0]: p[-1]
for p in [p.partition('=') for p in query.split('&')]
}
params.update(existing_params)
query_params = ["{}={}".format(k, v) for k, v in params.items()]
query = '?' + '&'.join(query_params)
self.url = self.url + query
|
[
"def",
"format_parameters",
"(",
"self",
",",
"params",
")",
":",
"# type: (Dict[str, str]) -> None",
"query",
"=",
"urlparse",
"(",
"self",
".",
"url",
")",
".",
"query",
"if",
"query",
":",
"self",
".",
"url",
"=",
"self",
".",
"url",
".",
"partition",
"(",
"'?'",
")",
"[",
"0",
"]",
"existing_params",
"=",
"{",
"p",
"[",
"0",
"]",
":",
"p",
"[",
"-",
"1",
"]",
"for",
"p",
"in",
"[",
"p",
".",
"partition",
"(",
"'='",
")",
"for",
"p",
"in",
"query",
".",
"split",
"(",
"'&'",
")",
"]",
"}",
"params",
".",
"update",
"(",
"existing_params",
")",
"query_params",
"=",
"[",
"\"{}={}\"",
".",
"format",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"params",
".",
"items",
"(",
")",
"]",
"query",
"=",
"'?'",
"+",
"'&'",
".",
"join",
"(",
"query_params",
")",
"self",
".",
"url",
"=",
"self",
".",
"url",
"+",
"query"
] |
Format parameters into a valid query string.
It's assumed all parameters have already been quoted as
valid URL strings.
:param dict params: A dictionary of parameters.
|
[
"Format",
"parameters",
"into",
"a",
"valid",
"query",
"string",
".",
"It",
"s",
"assumed",
"all",
"parameters",
"have",
"already",
"been",
"quoted",
"as",
"valid",
"URL",
"strings",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/__init__.py#L231-L249
|
10,833
|
Azure/msrest-for-python
|
msrest/universal_http/__init__.py
|
ClientRequest._format_data
|
def _format_data(data):
# type: (Union[str, IO]) -> Union[Tuple[None, str], Tuple[Optional[str], IO, str]]
"""Format field data according to whether it is a stream or
a string for a form-data request.
:param data: The request field data.
:type data: str or file-like object.
"""
if hasattr(data, 'read'):
data = cast(IO, data)
data_name = None
try:
if data.name[0] != '<' and data.name[-1] != '>':
data_name = os.path.basename(data.name)
except (AttributeError, TypeError):
pass
return (data_name, data, "application/octet-stream")
return (None, cast(str, data))
|
python
|
def _format_data(data):
# type: (Union[str, IO]) -> Union[Tuple[None, str], Tuple[Optional[str], IO, str]]
"""Format field data according to whether it is a stream or
a string for a form-data request.
:param data: The request field data.
:type data: str or file-like object.
"""
if hasattr(data, 'read'):
data = cast(IO, data)
data_name = None
try:
if data.name[0] != '<' and data.name[-1] != '>':
data_name = os.path.basename(data.name)
except (AttributeError, TypeError):
pass
return (data_name, data, "application/octet-stream")
return (None, cast(str, data))
|
[
"def",
"_format_data",
"(",
"data",
")",
":",
"# type: (Union[str, IO]) -> Union[Tuple[None, str], Tuple[Optional[str], IO, str]]",
"if",
"hasattr",
"(",
"data",
",",
"'read'",
")",
":",
"data",
"=",
"cast",
"(",
"IO",
",",
"data",
")",
"data_name",
"=",
"None",
"try",
":",
"if",
"data",
".",
"name",
"[",
"0",
"]",
"!=",
"'<'",
"and",
"data",
".",
"name",
"[",
"-",
"1",
"]",
"!=",
"'>'",
":",
"data_name",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"data",
".",
"name",
")",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"pass",
"return",
"(",
"data_name",
",",
"data",
",",
"\"application/octet-stream\"",
")",
"return",
"(",
"None",
",",
"cast",
"(",
"str",
",",
"data",
")",
")"
] |
Format field data according to whether it is a stream or
a string for a form-data request.
:param data: The request field data.
:type data: str or file-like object.
|
[
"Format",
"field",
"data",
"according",
"to",
"whether",
"it",
"is",
"a",
"stream",
"or",
"a",
"string",
"for",
"a",
"form",
"-",
"data",
"request",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/__init__.py#L275-L292
|
10,834
|
Azure/msrest-for-python
|
msrest/universal_http/__init__.py
|
ClientRequest.add_formdata
|
def add_formdata(self, content=None):
# type: (Optional[Dict[str, str]]) -> None
"""Add data as a multipart form-data request to the request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
"""
if content is None:
content = {}
content_type = self.headers.pop('Content-Type', None) if self.headers else None
if content_type and content_type.lower() == 'application/x-www-form-urlencoded':
# Do NOT use "add_content" that assumes input is JSON
self.data = {f: d for f, d in content.items() if d is not None}
else: # Assume "multipart/form-data"
self.files = {f: self._format_data(d) for f, d in content.items() if d is not None}
|
python
|
def add_formdata(self, content=None):
# type: (Optional[Dict[str, str]]) -> None
"""Add data as a multipart form-data request to the request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
"""
if content is None:
content = {}
content_type = self.headers.pop('Content-Type', None) if self.headers else None
if content_type and content_type.lower() == 'application/x-www-form-urlencoded':
# Do NOT use "add_content" that assumes input is JSON
self.data = {f: d for f, d in content.items() if d is not None}
else: # Assume "multipart/form-data"
self.files = {f: self._format_data(d) for f, d in content.items() if d is not None}
|
[
"def",
"add_formdata",
"(",
"self",
",",
"content",
"=",
"None",
")",
":",
"# type: (Optional[Dict[str, str]]) -> None",
"if",
"content",
"is",
"None",
":",
"content",
"=",
"{",
"}",
"content_type",
"=",
"self",
".",
"headers",
".",
"pop",
"(",
"'Content-Type'",
",",
"None",
")",
"if",
"self",
".",
"headers",
"else",
"None",
"if",
"content_type",
"and",
"content_type",
".",
"lower",
"(",
")",
"==",
"'application/x-www-form-urlencoded'",
":",
"# Do NOT use \"add_content\" that assumes input is JSON",
"self",
".",
"data",
"=",
"{",
"f",
":",
"d",
"for",
"f",
",",
"d",
"in",
"content",
".",
"items",
"(",
")",
"if",
"d",
"is",
"not",
"None",
"}",
"else",
":",
"# Assume \"multipart/form-data\"",
"self",
".",
"files",
"=",
"{",
"f",
":",
"self",
".",
"_format_data",
"(",
"d",
")",
"for",
"f",
",",
"d",
"in",
"content",
".",
"items",
"(",
")",
"if",
"d",
"is",
"not",
"None",
"}"
] |
Add data as a multipart form-data request to the request.
We only deal with file-like objects or strings at this point.
The requests is not yet streamed.
:param dict headers: Any headers to add to the request.
:param dict content: Dictionary of the fields of the formdata.
|
[
"Add",
"data",
"as",
"a",
"multipart",
"form",
"-",
"data",
"request",
"to",
"the",
"request",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/__init__.py#L294-L312
|
10,835
|
Azure/msrest-for-python
|
msrest/exceptions.py
|
raise_with_traceback
|
def raise_with_traceback(exception, message="", *args, **kwargs):
# type: (Callable, str, Any, Any) -> None
"""Raise exception with a specified traceback.
This MUST be called inside a "except" clause.
:param Exception exception: Error type to be raised.
:param str message: Message to include with error, empty by default.
:param args: Any additional args to be included with exception.
"""
exc_type, exc_value, exc_traceback = sys.exc_info()
# If not called inside a "except", exc_type will be None. Assume it will not happen
exc_msg = "{}, {}: {}".format(message, exc_type.__name__, exc_value) # type: ignore
error = exception(exc_msg, *args, **kwargs)
try:
raise error.with_traceback(exc_traceback)
except AttributeError:
error.__traceback__ = exc_traceback
raise error
|
python
|
def raise_with_traceback(exception, message="", *args, **kwargs):
# type: (Callable, str, Any, Any) -> None
"""Raise exception with a specified traceback.
This MUST be called inside a "except" clause.
:param Exception exception: Error type to be raised.
:param str message: Message to include with error, empty by default.
:param args: Any additional args to be included with exception.
"""
exc_type, exc_value, exc_traceback = sys.exc_info()
# If not called inside a "except", exc_type will be None. Assume it will not happen
exc_msg = "{}, {}: {}".format(message, exc_type.__name__, exc_value) # type: ignore
error = exception(exc_msg, *args, **kwargs)
try:
raise error.with_traceback(exc_traceback)
except AttributeError:
error.__traceback__ = exc_traceback
raise error
|
[
"def",
"raise_with_traceback",
"(",
"exception",
",",
"message",
"=",
"\"\"",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# type: (Callable, str, Any, Any) -> None",
"exc_type",
",",
"exc_value",
",",
"exc_traceback",
"=",
"sys",
".",
"exc_info",
"(",
")",
"# If not called inside a \"except\", exc_type will be None. Assume it will not happen",
"exc_msg",
"=",
"\"{}, {}: {}\"",
".",
"format",
"(",
"message",
",",
"exc_type",
".",
"__name__",
",",
"exc_value",
")",
"# type: ignore",
"error",
"=",
"exception",
"(",
"exc_msg",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"try",
":",
"raise",
"error",
".",
"with_traceback",
"(",
"exc_traceback",
")",
"except",
"AttributeError",
":",
"error",
".",
"__traceback__",
"=",
"exc_traceback",
"raise",
"error"
] |
Raise exception with a specified traceback.
This MUST be called inside a "except" clause.
:param Exception exception: Error type to be raised.
:param str message: Message to include with error, empty by default.
:param args: Any additional args to be included with exception.
|
[
"Raise",
"exception",
"with",
"a",
"specified",
"traceback",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/exceptions.py#L36-L54
|
10,836
|
Azure/msrest-for-python
|
msrest/universal_http/requests.py
|
_patch_redirect
|
def _patch_redirect(session):
# type: (requests.Session) -> None
"""Whether redirect policy should be applied based on status code.
HTTP spec says that on 301/302 not HEAD/GET, should NOT redirect.
But requests does, to follow browser more than spec
https://github.com/requests/requests/blob/f6e13ccfc4b50dc458ee374e5dba347205b9a2da/requests/sessions.py#L305-L314
This patches "requests" to be more HTTP compliant.
Note that this is super dangerous, since technically this is not public API.
"""
def enforce_http_spec(resp, request):
if resp.status_code in (301, 302) and \
request.method not in ['GET', 'HEAD']:
return False
return True
redirect_logic = session.resolve_redirects
def wrapped_redirect(resp, req, **kwargs):
attempt = enforce_http_spec(resp, req)
return redirect_logic(resp, req, **kwargs) if attempt else []
wrapped_redirect.is_msrest_patched = True # type: ignore
session.resolve_redirects = wrapped_redirect
|
python
|
def _patch_redirect(session):
# type: (requests.Session) -> None
"""Whether redirect policy should be applied based on status code.
HTTP spec says that on 301/302 not HEAD/GET, should NOT redirect.
But requests does, to follow browser more than spec
https://github.com/requests/requests/blob/f6e13ccfc4b50dc458ee374e5dba347205b9a2da/requests/sessions.py#L305-L314
This patches "requests" to be more HTTP compliant.
Note that this is super dangerous, since technically this is not public API.
"""
def enforce_http_spec(resp, request):
if resp.status_code in (301, 302) and \
request.method not in ['GET', 'HEAD']:
return False
return True
redirect_logic = session.resolve_redirects
def wrapped_redirect(resp, req, **kwargs):
attempt = enforce_http_spec(resp, req)
return redirect_logic(resp, req, **kwargs) if attempt else []
wrapped_redirect.is_msrest_patched = True # type: ignore
session.resolve_redirects = wrapped_redirect
|
[
"def",
"_patch_redirect",
"(",
"session",
")",
":",
"# type: (requests.Session) -> None",
"def",
"enforce_http_spec",
"(",
"resp",
",",
"request",
")",
":",
"if",
"resp",
".",
"status_code",
"in",
"(",
"301",
",",
"302",
")",
"and",
"request",
".",
"method",
"not",
"in",
"[",
"'GET'",
",",
"'HEAD'",
"]",
":",
"return",
"False",
"return",
"True",
"redirect_logic",
"=",
"session",
".",
"resolve_redirects",
"def",
"wrapped_redirect",
"(",
"resp",
",",
"req",
",",
"*",
"*",
"kwargs",
")",
":",
"attempt",
"=",
"enforce_http_spec",
"(",
"resp",
",",
"req",
")",
"return",
"redirect_logic",
"(",
"resp",
",",
"req",
",",
"*",
"*",
"kwargs",
")",
"if",
"attempt",
"else",
"[",
"]",
"wrapped_redirect",
".",
"is_msrest_patched",
"=",
"True",
"# type: ignore",
"session",
".",
"resolve_redirects",
"=",
"wrapped_redirect"
] |
Whether redirect policy should be applied based on status code.
HTTP spec says that on 301/302 not HEAD/GET, should NOT redirect.
But requests does, to follow browser more than spec
https://github.com/requests/requests/blob/f6e13ccfc4b50dc458ee374e5dba347205b9a2da/requests/sessions.py#L305-L314
This patches "requests" to be more HTTP compliant.
Note that this is super dangerous, since technically this is not public API.
|
[
"Whether",
"redirect",
"policy",
"should",
"be",
"applied",
"based",
"on",
"status",
"code",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/requests.py#L145-L170
|
10,837
|
Azure/msrest-for-python
|
msrest/universal_http/requests.py
|
RequestsHTTPSender._init_session
|
def _init_session(self, session):
# type: (requests.Session) -> None
"""Init session level configuration of requests.
This is initialization I want to do once only on a session.
"""
_patch_redirect(session)
# Change max_retries in current all installed adapters
max_retries = self.config.retry_policy()
for protocol in self._protocols:
session.adapters[protocol].max_retries = max_retries
|
python
|
def _init_session(self, session):
# type: (requests.Session) -> None
"""Init session level configuration of requests.
This is initialization I want to do once only on a session.
"""
_patch_redirect(session)
# Change max_retries in current all installed adapters
max_retries = self.config.retry_policy()
for protocol in self._protocols:
session.adapters[protocol].max_retries = max_retries
|
[
"def",
"_init_session",
"(",
"self",
",",
"session",
")",
":",
"# type: (requests.Session) -> None",
"_patch_redirect",
"(",
"session",
")",
"# Change max_retries in current all installed adapters",
"max_retries",
"=",
"self",
".",
"config",
".",
"retry_policy",
"(",
")",
"for",
"protocol",
"in",
"self",
".",
"_protocols",
":",
"session",
".",
"adapters",
"[",
"protocol",
"]",
".",
"max_retries",
"=",
"max_retries"
] |
Init session level configuration of requests.
This is initialization I want to do once only on a session.
|
[
"Init",
"session",
"level",
"configuration",
"of",
"requests",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/requests.py#L218-L229
|
10,838
|
Azure/msrest-for-python
|
msrest/universal_http/requests.py
|
RequestsHTTPSender._configure_send
|
def _configure_send(self, request, **kwargs):
# type: (ClientRequest, Any) -> Dict[str, str]
"""Configure the kwargs to use with requests.
See "send" for kwargs details.
:param ClientRequest request: The request object to be sent.
:returns: The requests.Session.request kwargs
:rtype: dict[str,str]
"""
requests_kwargs = {} # type: Any
session = kwargs.pop('session', self.session)
# If custom session was not create here
if session is not self.session:
self._init_session(session)
session.max_redirects = int(self.config.redirect_policy())
session.trust_env = bool(self.config.proxies.use_env_settings)
# Initialize requests_kwargs with "config" value
requests_kwargs.update(self.config.connection())
requests_kwargs['allow_redirects'] = bool(self.config.redirect_policy)
requests_kwargs['headers'] = self.config.headers.copy()
proxies = self.config.proxies()
if proxies:
requests_kwargs['proxies'] = proxies
# Replace by operation level kwargs
# We allow some of them, since some like stream or json are controled by msrest
for key in kwargs:
if key in self._REQUESTS_KWARGS:
requests_kwargs[key] = kwargs[key]
# Hooks. Deprecated, should be a policy
def make_user_hook_cb(user_hook, session):
def user_hook_cb(r, *args, **kwargs):
kwargs.setdefault("msrest", {})['session'] = session
return user_hook(r, *args, **kwargs)
return user_hook_cb
hooks = []
for user_hook in self.config.hooks:
hooks.append(make_user_hook_cb(user_hook, self.session))
if hooks:
requests_kwargs['hooks'] = {'response': hooks}
# Configuration callback. Deprecated, should be a policy
output_kwargs = self.config.session_configuration_callback(
session,
self.config,
kwargs,
**requests_kwargs
)
if output_kwargs is not None:
requests_kwargs = output_kwargs
# If custom session was not create here
if session is not self.session:
requests_kwargs['session'] = session
### Autorest forced kwargs now ###
# If Autorest needs this response to be streamable. True for compat.
requests_kwargs['stream'] = kwargs.get('stream', True)
if request.files:
requests_kwargs['files'] = request.files
elif request.data:
requests_kwargs['data'] = request.data
requests_kwargs['headers'].update(request.headers)
return requests_kwargs
|
python
|
def _configure_send(self, request, **kwargs):
# type: (ClientRequest, Any) -> Dict[str, str]
"""Configure the kwargs to use with requests.
See "send" for kwargs details.
:param ClientRequest request: The request object to be sent.
:returns: The requests.Session.request kwargs
:rtype: dict[str,str]
"""
requests_kwargs = {} # type: Any
session = kwargs.pop('session', self.session)
# If custom session was not create here
if session is not self.session:
self._init_session(session)
session.max_redirects = int(self.config.redirect_policy())
session.trust_env = bool(self.config.proxies.use_env_settings)
# Initialize requests_kwargs with "config" value
requests_kwargs.update(self.config.connection())
requests_kwargs['allow_redirects'] = bool(self.config.redirect_policy)
requests_kwargs['headers'] = self.config.headers.copy()
proxies = self.config.proxies()
if proxies:
requests_kwargs['proxies'] = proxies
# Replace by operation level kwargs
# We allow some of them, since some like stream or json are controled by msrest
for key in kwargs:
if key in self._REQUESTS_KWARGS:
requests_kwargs[key] = kwargs[key]
# Hooks. Deprecated, should be a policy
def make_user_hook_cb(user_hook, session):
def user_hook_cb(r, *args, **kwargs):
kwargs.setdefault("msrest", {})['session'] = session
return user_hook(r, *args, **kwargs)
return user_hook_cb
hooks = []
for user_hook in self.config.hooks:
hooks.append(make_user_hook_cb(user_hook, self.session))
if hooks:
requests_kwargs['hooks'] = {'response': hooks}
# Configuration callback. Deprecated, should be a policy
output_kwargs = self.config.session_configuration_callback(
session,
self.config,
kwargs,
**requests_kwargs
)
if output_kwargs is not None:
requests_kwargs = output_kwargs
# If custom session was not create here
if session is not self.session:
requests_kwargs['session'] = session
### Autorest forced kwargs now ###
# If Autorest needs this response to be streamable. True for compat.
requests_kwargs['stream'] = kwargs.get('stream', True)
if request.files:
requests_kwargs['files'] = request.files
elif request.data:
requests_kwargs['data'] = request.data
requests_kwargs['headers'].update(request.headers)
return requests_kwargs
|
[
"def",
"_configure_send",
"(",
"self",
",",
"request",
",",
"*",
"*",
"kwargs",
")",
":",
"# type: (ClientRequest, Any) -> Dict[str, str]",
"requests_kwargs",
"=",
"{",
"}",
"# type: Any",
"session",
"=",
"kwargs",
".",
"pop",
"(",
"'session'",
",",
"self",
".",
"session",
")",
"# If custom session was not create here",
"if",
"session",
"is",
"not",
"self",
".",
"session",
":",
"self",
".",
"_init_session",
"(",
"session",
")",
"session",
".",
"max_redirects",
"=",
"int",
"(",
"self",
".",
"config",
".",
"redirect_policy",
"(",
")",
")",
"session",
".",
"trust_env",
"=",
"bool",
"(",
"self",
".",
"config",
".",
"proxies",
".",
"use_env_settings",
")",
"# Initialize requests_kwargs with \"config\" value",
"requests_kwargs",
".",
"update",
"(",
"self",
".",
"config",
".",
"connection",
"(",
")",
")",
"requests_kwargs",
"[",
"'allow_redirects'",
"]",
"=",
"bool",
"(",
"self",
".",
"config",
".",
"redirect_policy",
")",
"requests_kwargs",
"[",
"'headers'",
"]",
"=",
"self",
".",
"config",
".",
"headers",
".",
"copy",
"(",
")",
"proxies",
"=",
"self",
".",
"config",
".",
"proxies",
"(",
")",
"if",
"proxies",
":",
"requests_kwargs",
"[",
"'proxies'",
"]",
"=",
"proxies",
"# Replace by operation level kwargs",
"# We allow some of them, since some like stream or json are controled by msrest",
"for",
"key",
"in",
"kwargs",
":",
"if",
"key",
"in",
"self",
".",
"_REQUESTS_KWARGS",
":",
"requests_kwargs",
"[",
"key",
"]",
"=",
"kwargs",
"[",
"key",
"]",
"# Hooks. Deprecated, should be a policy",
"def",
"make_user_hook_cb",
"(",
"user_hook",
",",
"session",
")",
":",
"def",
"user_hook_cb",
"(",
"r",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"kwargs",
".",
"setdefault",
"(",
"\"msrest\"",
",",
"{",
"}",
")",
"[",
"'session'",
"]",
"=",
"session",
"return",
"user_hook",
"(",
"r",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"user_hook_cb",
"hooks",
"=",
"[",
"]",
"for",
"user_hook",
"in",
"self",
".",
"config",
".",
"hooks",
":",
"hooks",
".",
"append",
"(",
"make_user_hook_cb",
"(",
"user_hook",
",",
"self",
".",
"session",
")",
")",
"if",
"hooks",
":",
"requests_kwargs",
"[",
"'hooks'",
"]",
"=",
"{",
"'response'",
":",
"hooks",
"}",
"# Configuration callback. Deprecated, should be a policy",
"output_kwargs",
"=",
"self",
".",
"config",
".",
"session_configuration_callback",
"(",
"session",
",",
"self",
".",
"config",
",",
"kwargs",
",",
"*",
"*",
"requests_kwargs",
")",
"if",
"output_kwargs",
"is",
"not",
"None",
":",
"requests_kwargs",
"=",
"output_kwargs",
"# If custom session was not create here",
"if",
"session",
"is",
"not",
"self",
".",
"session",
":",
"requests_kwargs",
"[",
"'session'",
"]",
"=",
"session",
"### Autorest forced kwargs now ###",
"# If Autorest needs this response to be streamable. True for compat.",
"requests_kwargs",
"[",
"'stream'",
"]",
"=",
"kwargs",
".",
"get",
"(",
"'stream'",
",",
"True",
")",
"if",
"request",
".",
"files",
":",
"requests_kwargs",
"[",
"'files'",
"]",
"=",
"request",
".",
"files",
"elif",
"request",
".",
"data",
":",
"requests_kwargs",
"[",
"'data'",
"]",
"=",
"request",
".",
"data",
"requests_kwargs",
"[",
"'headers'",
"]",
".",
"update",
"(",
"request",
".",
"headers",
")",
"return",
"requests_kwargs"
] |
Configure the kwargs to use with requests.
See "send" for kwargs details.
:param ClientRequest request: The request object to be sent.
:returns: The requests.Session.request kwargs
:rtype: dict[str,str]
|
[
"Configure",
"the",
"kwargs",
"to",
"use",
"with",
"requests",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/universal_http/requests.py#L231-L305
|
10,839
|
Azure/msrest-for-python
|
msrest/serialization.py
|
full_restapi_key_transformer
|
def full_restapi_key_transformer(key, attr_desc, value):
"""A key transformer that returns the full RestAPI key path.
:param str _: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: A list of keys using RestAPI syntax.
"""
keys = _FLATTEN.split(attr_desc['key'])
return ([_decode_attribute_map_key(k) for k in keys], value)
|
python
|
def full_restapi_key_transformer(key, attr_desc, value):
"""A key transformer that returns the full RestAPI key path.
:param str _: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: A list of keys using RestAPI syntax.
"""
keys = _FLATTEN.split(attr_desc['key'])
return ([_decode_attribute_map_key(k) for k in keys], value)
|
[
"def",
"full_restapi_key_transformer",
"(",
"key",
",",
"attr_desc",
",",
"value",
")",
":",
"keys",
"=",
"_FLATTEN",
".",
"split",
"(",
"attr_desc",
"[",
"'key'",
"]",
")",
"return",
"(",
"[",
"_decode_attribute_map_key",
"(",
"k",
")",
"for",
"k",
"in",
"keys",
"]",
",",
"value",
")"
] |
A key transformer that returns the full RestAPI key path.
:param str _: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: A list of keys using RestAPI syntax.
|
[
"A",
"key",
"transformer",
"that",
"returns",
"the",
"full",
"RestAPI",
"key",
"path",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L98-L107
|
10,840
|
Azure/msrest-for-python
|
msrest/serialization.py
|
last_restapi_key_transformer
|
def last_restapi_key_transformer(key, attr_desc, value):
"""A key transformer that returns the last RestAPI key.
:param str key: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: The last RestAPI key.
"""
key, value = full_restapi_key_transformer(key, attr_desc, value)
return (key[-1], value)
|
python
|
def last_restapi_key_transformer(key, attr_desc, value):
"""A key transformer that returns the last RestAPI key.
:param str key: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: The last RestAPI key.
"""
key, value = full_restapi_key_transformer(key, attr_desc, value)
return (key[-1], value)
|
[
"def",
"last_restapi_key_transformer",
"(",
"key",
",",
"attr_desc",
",",
"value",
")",
":",
"key",
",",
"value",
"=",
"full_restapi_key_transformer",
"(",
"key",
",",
"attr_desc",
",",
"value",
")",
"return",
"(",
"key",
"[",
"-",
"1",
"]",
",",
"value",
")"
] |
A key transformer that returns the last RestAPI key.
:param str key: The attribute name
:param dict attr_desc: The attribute metadata
:param object value: The value
:returns: The last RestAPI key.
|
[
"A",
"key",
"transformer",
"that",
"returns",
"the",
"last",
"RestAPI",
"key",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L109-L118
|
10,841
|
Azure/msrest-for-python
|
msrest/serialization.py
|
_create_xml_node
|
def _create_xml_node(tag, prefix=None, ns=None):
"""Create a XML node."""
if prefix and ns:
ET.register_namespace(prefix, ns)
if ns:
return ET.Element("{"+ns+"}"+tag)
else:
return ET.Element(tag)
|
python
|
def _create_xml_node(tag, prefix=None, ns=None):
"""Create a XML node."""
if prefix and ns:
ET.register_namespace(prefix, ns)
if ns:
return ET.Element("{"+ns+"}"+tag)
else:
return ET.Element(tag)
|
[
"def",
"_create_xml_node",
"(",
"tag",
",",
"prefix",
"=",
"None",
",",
"ns",
"=",
"None",
")",
":",
"if",
"prefix",
"and",
"ns",
":",
"ET",
".",
"register_namespace",
"(",
"prefix",
",",
"ns",
")",
"if",
"ns",
":",
"return",
"ET",
".",
"Element",
"(",
"\"{\"",
"+",
"ns",
"+",
"\"}\"",
"+",
"tag",
")",
"else",
":",
"return",
"ET",
".",
"Element",
"(",
"tag",
")"
] |
Create a XML node.
|
[
"Create",
"a",
"XML",
"node",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L134-L141
|
10,842
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model._create_xml_node
|
def _create_xml_node(cls):
"""Create XML node from "_xml_map".
"""
try:
xml_map = cls._xml_map
except AttributeError:
raise ValueError("This model has no XML definition")
return _create_xml_node(
xml_map.get('name', cls.__name__),
xml_map.get("prefix", None),
xml_map.get("ns", None)
)
|
python
|
def _create_xml_node(cls):
"""Create XML node from "_xml_map".
"""
try:
xml_map = cls._xml_map
except AttributeError:
raise ValueError("This model has no XML definition")
return _create_xml_node(
xml_map.get('name', cls.__name__),
xml_map.get("prefix", None),
xml_map.get("ns", None)
)
|
[
"def",
"_create_xml_node",
"(",
"cls",
")",
":",
"try",
":",
"xml_map",
"=",
"cls",
".",
"_xml_map",
"except",
"AttributeError",
":",
"raise",
"ValueError",
"(",
"\"This model has no XML definition\"",
")",
"return",
"_create_xml_node",
"(",
"xml_map",
".",
"get",
"(",
"'name'",
",",
"cls",
".",
"__name__",
")",
",",
"xml_map",
".",
"get",
"(",
"\"prefix\"",
",",
"None",
")",
",",
"xml_map",
".",
"get",
"(",
"\"ns\"",
",",
"None",
")",
")"
] |
Create XML node from "_xml_map".
|
[
"Create",
"XML",
"node",
"from",
"_xml_map",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L191-L203
|
10,843
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model.validate
|
def validate(self):
"""Validate this model recursively and return a list of ValidationError.
:returns: A list of validation error
:rtype: list
"""
validation_result = []
for attr_name, value in [(attr, getattr(self, attr)) for attr in self._attribute_map]:
attr_desc = self._attribute_map[attr_name]
if attr_name == "additional_properties" and attr_desc["key"] == '':
# Do NOT validate additional_properties
continue
attr_type = attr_desc['type']
try:
debug_name = "{}.{}".format(self.__class__.__name__, attr_name)
Serializer.validate(value, debug_name, **self._validation.get(attr_name, {}))
except ValidationError as validation_error:
validation_result.append(validation_error)
validation_result += _recursive_validate(attr_name, attr_type, value)
return validation_result
|
python
|
def validate(self):
"""Validate this model recursively and return a list of ValidationError.
:returns: A list of validation error
:rtype: list
"""
validation_result = []
for attr_name, value in [(attr, getattr(self, attr)) for attr in self._attribute_map]:
attr_desc = self._attribute_map[attr_name]
if attr_name == "additional_properties" and attr_desc["key"] == '':
# Do NOT validate additional_properties
continue
attr_type = attr_desc['type']
try:
debug_name = "{}.{}".format(self.__class__.__name__, attr_name)
Serializer.validate(value, debug_name, **self._validation.get(attr_name, {}))
except ValidationError as validation_error:
validation_result.append(validation_error)
validation_result += _recursive_validate(attr_name, attr_type, value)
return validation_result
|
[
"def",
"validate",
"(",
"self",
")",
":",
"validation_result",
"=",
"[",
"]",
"for",
"attr_name",
",",
"value",
"in",
"[",
"(",
"attr",
",",
"getattr",
"(",
"self",
",",
"attr",
")",
")",
"for",
"attr",
"in",
"self",
".",
"_attribute_map",
"]",
":",
"attr_desc",
"=",
"self",
".",
"_attribute_map",
"[",
"attr_name",
"]",
"if",
"attr_name",
"==",
"\"additional_properties\"",
"and",
"attr_desc",
"[",
"\"key\"",
"]",
"==",
"''",
":",
"# Do NOT validate additional_properties",
"continue",
"attr_type",
"=",
"attr_desc",
"[",
"'type'",
"]",
"try",
":",
"debug_name",
"=",
"\"{}.{}\"",
".",
"format",
"(",
"self",
".",
"__class__",
".",
"__name__",
",",
"attr_name",
")",
"Serializer",
".",
"validate",
"(",
"value",
",",
"debug_name",
",",
"*",
"*",
"self",
".",
"_validation",
".",
"get",
"(",
"attr_name",
",",
"{",
"}",
")",
")",
"except",
"ValidationError",
"as",
"validation_error",
":",
"validation_result",
".",
"append",
"(",
"validation_error",
")",
"validation_result",
"+=",
"_recursive_validate",
"(",
"attr_name",
",",
"attr_type",
",",
"value",
")",
"return",
"validation_result"
] |
Validate this model recursively and return a list of ValidationError.
:returns: A list of validation error
:rtype: list
|
[
"Validate",
"this",
"model",
"recursively",
"and",
"return",
"a",
"list",
"of",
"ValidationError",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L205-L226
|
10,844
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model.serialize
|
def serialize(self, keep_readonly=False):
"""Return the JSON that would be sent to azure from this model.
This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
:param bool keep_readonly: If you want to serialize the readonly attributes
:returns: A dict JSON compatible object
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
return serializer._serialize(self, keep_readonly=keep_readonly)
|
python
|
def serialize(self, keep_readonly=False):
"""Return the JSON that would be sent to azure from this model.
This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
:param bool keep_readonly: If you want to serialize the readonly attributes
:returns: A dict JSON compatible object
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
return serializer._serialize(self, keep_readonly=keep_readonly)
|
[
"def",
"serialize",
"(",
"self",
",",
"keep_readonly",
"=",
"False",
")",
":",
"serializer",
"=",
"Serializer",
"(",
"self",
".",
"_infer_class_models",
"(",
")",
")",
"return",
"serializer",
".",
"_serialize",
"(",
"self",
",",
"keep_readonly",
"=",
"keep_readonly",
")"
] |
Return the JSON that would be sent to azure from this model.
This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
:param bool keep_readonly: If you want to serialize the readonly attributes
:returns: A dict JSON compatible object
:rtype: dict
|
[
"Return",
"the",
"JSON",
"that",
"would",
"be",
"sent",
"to",
"azure",
"from",
"this",
"model",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L228-L238
|
10,845
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model.as_dict
|
def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer):
"""Return a dict that can be JSONify using json.dump.
Advanced usage might optionaly use a callback as parameter:
.. code::python
def my_key_transformer(key, attr_desc, value):
return key
Key is the attribute name used in Python. Attr_desc
is a dict of metadata. Currently contains 'type' with the
msrest type and 'key' with the RestAPI encoded key.
Value is the current value in this object.
The string returned will be used to serialize the key.
If the return type is a list, this is considered hierarchical
result dict.
See the three examples in this file:
- attribute_transformer
- full_restapi_key_transformer
- last_restapi_key_transformer
:param function key_transformer: A key transformer function.
:returns: A dict JSON compatible object
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly)
|
python
|
def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer):
"""Return a dict that can be JSONify using json.dump.
Advanced usage might optionaly use a callback as parameter:
.. code::python
def my_key_transformer(key, attr_desc, value):
return key
Key is the attribute name used in Python. Attr_desc
is a dict of metadata. Currently contains 'type' with the
msrest type and 'key' with the RestAPI encoded key.
Value is the current value in this object.
The string returned will be used to serialize the key.
If the return type is a list, this is considered hierarchical
result dict.
See the three examples in this file:
- attribute_transformer
- full_restapi_key_transformer
- last_restapi_key_transformer
:param function key_transformer: A key transformer function.
:returns: A dict JSON compatible object
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly)
|
[
"def",
"as_dict",
"(",
"self",
",",
"keep_readonly",
"=",
"True",
",",
"key_transformer",
"=",
"attribute_transformer",
")",
":",
"serializer",
"=",
"Serializer",
"(",
"self",
".",
"_infer_class_models",
"(",
")",
")",
"return",
"serializer",
".",
"_serialize",
"(",
"self",
",",
"key_transformer",
"=",
"key_transformer",
",",
"keep_readonly",
"=",
"keep_readonly",
")"
] |
Return a dict that can be JSONify using json.dump.
Advanced usage might optionaly use a callback as parameter:
.. code::python
def my_key_transformer(key, attr_desc, value):
return key
Key is the attribute name used in Python. Attr_desc
is a dict of metadata. Currently contains 'type' with the
msrest type and 'key' with the RestAPI encoded key.
Value is the current value in this object.
The string returned will be used to serialize the key.
If the return type is a list, this is considered hierarchical
result dict.
See the three examples in this file:
- attribute_transformer
- full_restapi_key_transformer
- last_restapi_key_transformer
:param function key_transformer: A key transformer function.
:returns: A dict JSON compatible object
:rtype: dict
|
[
"Return",
"a",
"dict",
"that",
"can",
"be",
"JSONify",
"using",
"json",
".",
"dump",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L240-L270
|
10,846
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model.deserialize
|
def deserialize(cls, data, content_type=None):
"""Parse a str using the RestAPI syntax and return a model.
:param str data: A str using RestAPI structure. JSON by default.
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
"""
deserializer = Deserializer(cls._infer_class_models())
return deserializer(cls.__name__, data, content_type=content_type)
|
python
|
def deserialize(cls, data, content_type=None):
"""Parse a str using the RestAPI syntax and return a model.
:param str data: A str using RestAPI structure. JSON by default.
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
"""
deserializer = Deserializer(cls._infer_class_models())
return deserializer(cls.__name__, data, content_type=content_type)
|
[
"def",
"deserialize",
"(",
"cls",
",",
"data",
",",
"content_type",
"=",
"None",
")",
":",
"deserializer",
"=",
"Deserializer",
"(",
"cls",
".",
"_infer_class_models",
"(",
")",
")",
"return",
"deserializer",
"(",
"cls",
".",
"__name__",
",",
"data",
",",
"content_type",
"=",
"content_type",
")"
] |
Parse a str using the RestAPI syntax and return a model.
:param str data: A str using RestAPI structure. JSON by default.
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
|
[
"Parse",
"a",
"str",
"using",
"the",
"RestAPI",
"syntax",
"and",
"return",
"a",
"model",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L286-L295
|
10,847
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model.from_dict
|
def from_dict(cls, data, key_extractors=None, content_type=None):
"""Parse a dict using given key extractor return a model.
By default consider key
extractors (rest_key_case_insensitive_extractor, attribute_key_case_insensitive_extractor
and last_rest_key_case_insensitive_extractor)
:param dict data: A dict using RestAPI structure
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
"""
deserializer = Deserializer(cls._infer_class_models())
deserializer.key_extractors = [
rest_key_case_insensitive_extractor,
attribute_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor
] if key_extractors is None else key_extractors
return deserializer(cls.__name__, data, content_type=content_type)
|
python
|
def from_dict(cls, data, key_extractors=None, content_type=None):
"""Parse a dict using given key extractor return a model.
By default consider key
extractors (rest_key_case_insensitive_extractor, attribute_key_case_insensitive_extractor
and last_rest_key_case_insensitive_extractor)
:param dict data: A dict using RestAPI structure
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
"""
deserializer = Deserializer(cls._infer_class_models())
deserializer.key_extractors = [
rest_key_case_insensitive_extractor,
attribute_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor
] if key_extractors is None else key_extractors
return deserializer(cls.__name__, data, content_type=content_type)
|
[
"def",
"from_dict",
"(",
"cls",
",",
"data",
",",
"key_extractors",
"=",
"None",
",",
"content_type",
"=",
"None",
")",
":",
"deserializer",
"=",
"Deserializer",
"(",
"cls",
".",
"_infer_class_models",
"(",
")",
")",
"deserializer",
".",
"key_extractors",
"=",
"[",
"rest_key_case_insensitive_extractor",
",",
"attribute_key_case_insensitive_extractor",
",",
"last_rest_key_case_insensitive_extractor",
"]",
"if",
"key_extractors",
"is",
"None",
"else",
"key_extractors",
"return",
"deserializer",
"(",
"cls",
".",
"__name__",
",",
"data",
",",
"content_type",
"=",
"content_type",
")"
] |
Parse a dict using given key extractor return a model.
By default consider key
extractors (rest_key_case_insensitive_extractor, attribute_key_case_insensitive_extractor
and last_rest_key_case_insensitive_extractor)
:param dict data: A dict using RestAPI structure
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
|
[
"Parse",
"a",
"dict",
"using",
"given",
"key",
"extractor",
"return",
"a",
"model",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L298-L316
|
10,848
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Model._classify
|
def _classify(cls, response, objects):
"""Check the class _subtype_map for any child classes.
We want to ignore any inherited _subtype_maps.
Remove the polymorphic key from the initial data.
"""
for subtype_key in cls.__dict__.get('_subtype_map', {}).keys():
subtype_value = None
rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
if subtype_value:
# Try to match base class. Can be class name only
# (bug to fix in Autorest to support x-ms-discriminator-name)
if cls.__name__ == subtype_value:
return cls
flatten_mapping_type = cls._flatten_subtype(subtype_key, objects)
try:
return objects[flatten_mapping_type[subtype_value]]
except KeyError:
_LOGGER.warning(
"Subtype value %s has no mapping, use base class %s.",
subtype_value,
cls.__name__,
)
break
else:
_LOGGER.warning(
"Discriminator %s is absent or null, use base class %s.",
subtype_key,
cls.__name__
)
break
return cls
|
python
|
def _classify(cls, response, objects):
"""Check the class _subtype_map for any child classes.
We want to ignore any inherited _subtype_maps.
Remove the polymorphic key from the initial data.
"""
for subtype_key in cls.__dict__.get('_subtype_map', {}).keys():
subtype_value = None
rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
if subtype_value:
# Try to match base class. Can be class name only
# (bug to fix in Autorest to support x-ms-discriminator-name)
if cls.__name__ == subtype_value:
return cls
flatten_mapping_type = cls._flatten_subtype(subtype_key, objects)
try:
return objects[flatten_mapping_type[subtype_value]]
except KeyError:
_LOGGER.warning(
"Subtype value %s has no mapping, use base class %s.",
subtype_value,
cls.__name__,
)
break
else:
_LOGGER.warning(
"Discriminator %s is absent or null, use base class %s.",
subtype_key,
cls.__name__
)
break
return cls
|
[
"def",
"_classify",
"(",
"cls",
",",
"response",
",",
"objects",
")",
":",
"for",
"subtype_key",
"in",
"cls",
".",
"__dict__",
".",
"get",
"(",
"'_subtype_map'",
",",
"{",
"}",
")",
".",
"keys",
"(",
")",
":",
"subtype_value",
"=",
"None",
"rest_api_response_key",
"=",
"cls",
".",
"_get_rest_key_parts",
"(",
"subtype_key",
")",
"[",
"-",
"1",
"]",
"subtype_value",
"=",
"response",
".",
"pop",
"(",
"rest_api_response_key",
",",
"None",
")",
"or",
"response",
".",
"pop",
"(",
"subtype_key",
",",
"None",
")",
"if",
"subtype_value",
":",
"# Try to match base class. Can be class name only",
"# (bug to fix in Autorest to support x-ms-discriminator-name)",
"if",
"cls",
".",
"__name__",
"==",
"subtype_value",
":",
"return",
"cls",
"flatten_mapping_type",
"=",
"cls",
".",
"_flatten_subtype",
"(",
"subtype_key",
",",
"objects",
")",
"try",
":",
"return",
"objects",
"[",
"flatten_mapping_type",
"[",
"subtype_value",
"]",
"]",
"except",
"KeyError",
":",
"_LOGGER",
".",
"warning",
"(",
"\"Subtype value %s has no mapping, use base class %s.\"",
",",
"subtype_value",
",",
"cls",
".",
"__name__",
",",
")",
"break",
"else",
":",
"_LOGGER",
".",
"warning",
"(",
"\"Discriminator %s is absent or null, use base class %s.\"",
",",
"subtype_key",
",",
"cls",
".",
"__name__",
")",
"break",
"return",
"cls"
] |
Check the class _subtype_map for any child classes.
We want to ignore any inherited _subtype_maps.
Remove the polymorphic key from the initial data.
|
[
"Check",
"the",
"class",
"_subtype_map",
"for",
"any",
"child",
"classes",
".",
"We",
"want",
"to",
"ignore",
"any",
"inherited",
"_subtype_maps",
".",
"Remove",
"the",
"polymorphic",
"key",
"from",
"the",
"initial",
"data",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L328-L360
|
10,849
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.body
|
def body(self, data, data_type, **kwargs):
"""Serialize data intended for a request body.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: dict
:raises: SerializationError if serialization fails.
:raises: ValueError if data is None
"""
if data is None:
raise ValidationError("required", "body", True)
# Just in case this is a dict
internal_data_type = data_type.strip('[]{}')
internal_data_type = self.dependencies.get(internal_data_type, None)
if internal_data_type and not isinstance(internal_data_type, Enum):
try:
deserializer = Deserializer(self.dependencies)
# Since it's on serialization, it's almost sure that format is not JSON REST
# We're not able to deal with additional properties for now.
deserializer.additional_properties_detection = False
if issubclass(internal_data_type, Model) and internal_data_type.is_xml_model():
deserializer.key_extractors = [
attribute_key_case_insensitive_extractor,
]
else:
deserializer.key_extractors = [
rest_key_case_insensitive_extractor,
attribute_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor
]
data = deserializer._deserialize(data_type, data)
except DeserializationError as err:
raise_with_traceback(
SerializationError, "Unable to build a model: "+str(err), err)
if self.client_side_validation:
errors = _recursive_validate(data_type, data_type, data)
if errors:
raise errors[0]
return self._serialize(data, data_type, **kwargs)
|
python
|
def body(self, data, data_type, **kwargs):
"""Serialize data intended for a request body.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: dict
:raises: SerializationError if serialization fails.
:raises: ValueError if data is None
"""
if data is None:
raise ValidationError("required", "body", True)
# Just in case this is a dict
internal_data_type = data_type.strip('[]{}')
internal_data_type = self.dependencies.get(internal_data_type, None)
if internal_data_type and not isinstance(internal_data_type, Enum):
try:
deserializer = Deserializer(self.dependencies)
# Since it's on serialization, it's almost sure that format is not JSON REST
# We're not able to deal with additional properties for now.
deserializer.additional_properties_detection = False
if issubclass(internal_data_type, Model) and internal_data_type.is_xml_model():
deserializer.key_extractors = [
attribute_key_case_insensitive_extractor,
]
else:
deserializer.key_extractors = [
rest_key_case_insensitive_extractor,
attribute_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor
]
data = deserializer._deserialize(data_type, data)
except DeserializationError as err:
raise_with_traceback(
SerializationError, "Unable to build a model: "+str(err), err)
if self.client_side_validation:
errors = _recursive_validate(data_type, data_type, data)
if errors:
raise errors[0]
return self._serialize(data, data_type, **kwargs)
|
[
"def",
"body",
"(",
"self",
",",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"data",
"is",
"None",
":",
"raise",
"ValidationError",
"(",
"\"required\"",
",",
"\"body\"",
",",
"True",
")",
"# Just in case this is a dict",
"internal_data_type",
"=",
"data_type",
".",
"strip",
"(",
"'[]{}'",
")",
"internal_data_type",
"=",
"self",
".",
"dependencies",
".",
"get",
"(",
"internal_data_type",
",",
"None",
")",
"if",
"internal_data_type",
"and",
"not",
"isinstance",
"(",
"internal_data_type",
",",
"Enum",
")",
":",
"try",
":",
"deserializer",
"=",
"Deserializer",
"(",
"self",
".",
"dependencies",
")",
"# Since it's on serialization, it's almost sure that format is not JSON REST",
"# We're not able to deal with additional properties for now.",
"deserializer",
".",
"additional_properties_detection",
"=",
"False",
"if",
"issubclass",
"(",
"internal_data_type",
",",
"Model",
")",
"and",
"internal_data_type",
".",
"is_xml_model",
"(",
")",
":",
"deserializer",
".",
"key_extractors",
"=",
"[",
"attribute_key_case_insensitive_extractor",
",",
"]",
"else",
":",
"deserializer",
".",
"key_extractors",
"=",
"[",
"rest_key_case_insensitive_extractor",
",",
"attribute_key_case_insensitive_extractor",
",",
"last_rest_key_case_insensitive_extractor",
"]",
"data",
"=",
"deserializer",
".",
"_deserialize",
"(",
"data_type",
",",
"data",
")",
"except",
"DeserializationError",
"as",
"err",
":",
"raise_with_traceback",
"(",
"SerializationError",
",",
"\"Unable to build a model: \"",
"+",
"str",
"(",
"err",
")",
",",
"err",
")",
"if",
"self",
".",
"client_side_validation",
":",
"errors",
"=",
"_recursive_validate",
"(",
"data_type",
",",
"data_type",
",",
"data",
")",
"if",
"errors",
":",
"raise",
"errors",
"[",
"0",
"]",
"return",
"self",
".",
"_serialize",
"(",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")"
] |
Serialize data intended for a request body.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: dict
:raises: SerializationError if serialization fails.
:raises: ValueError if data is None
|
[
"Serialize",
"data",
"intended",
"for",
"a",
"request",
"body",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L540-L580
|
10,850
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.url
|
def url(self, name, data, data_type, **kwargs):
"""Serialize data intended for a URL path.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
"""
if self.client_side_validation:
data = self.validate(data, name, required=True, **kwargs)
try:
output = self.serialize_data(data, data_type, **kwargs)
if data_type == 'bool':
output = json.dumps(output)
if kwargs.get('skip_quote') is True:
output = str(output)
else:
output = quote(str(output), safe='')
except SerializationError:
raise TypeError("{} must be type {}.".format(name, data_type))
else:
return output
|
python
|
def url(self, name, data, data_type, **kwargs):
"""Serialize data intended for a URL path.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
"""
if self.client_side_validation:
data = self.validate(data, name, required=True, **kwargs)
try:
output = self.serialize_data(data, data_type, **kwargs)
if data_type == 'bool':
output = json.dumps(output)
if kwargs.get('skip_quote') is True:
output = str(output)
else:
output = quote(str(output), safe='')
except SerializationError:
raise TypeError("{} must be type {}.".format(name, data_type))
else:
return output
|
[
"def",
"url",
"(",
"self",
",",
"name",
",",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"client_side_validation",
":",
"data",
"=",
"self",
".",
"validate",
"(",
"data",
",",
"name",
",",
"required",
"=",
"True",
",",
"*",
"*",
"kwargs",
")",
"try",
":",
"output",
"=",
"self",
".",
"serialize_data",
"(",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
"if",
"data_type",
"==",
"'bool'",
":",
"output",
"=",
"json",
".",
"dumps",
"(",
"output",
")",
"if",
"kwargs",
".",
"get",
"(",
"'skip_quote'",
")",
"is",
"True",
":",
"output",
"=",
"str",
"(",
"output",
")",
"else",
":",
"output",
"=",
"quote",
"(",
"str",
"(",
"output",
")",
",",
"safe",
"=",
"''",
")",
"except",
"SerializationError",
":",
"raise",
"TypeError",
"(",
"\"{} must be type {}.\"",
".",
"format",
"(",
"name",
",",
"data_type",
")",
")",
"else",
":",
"return",
"output"
] |
Serialize data intended for a URL path.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
|
[
"Serialize",
"data",
"intended",
"for",
"a",
"URL",
"path",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L582-L605
|
10,851
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.header
|
def header(self, name, data, data_type, **kwargs):
"""Serialize data intended for a request header.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
"""
if self.client_side_validation:
data = self.validate(data, name, required=True, **kwargs)
try:
if data_type in ['[str]']:
data = ["" if d is None else d for d in data]
output = self.serialize_data(data, data_type, **kwargs)
if data_type == 'bool':
output = json.dumps(output)
except SerializationError:
raise TypeError("{} must be type {}.".format(name, data_type))
else:
return str(output)
|
python
|
def header(self, name, data, data_type, **kwargs):
"""Serialize data intended for a request header.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
"""
if self.client_side_validation:
data = self.validate(data, name, required=True, **kwargs)
try:
if data_type in ['[str]']:
data = ["" if d is None else d for d in data]
output = self.serialize_data(data, data_type, **kwargs)
if data_type == 'bool':
output = json.dumps(output)
except SerializationError:
raise TypeError("{} must be type {}.".format(name, data_type))
else:
return str(output)
|
[
"def",
"header",
"(",
"self",
",",
"name",
",",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"client_side_validation",
":",
"data",
"=",
"self",
".",
"validate",
"(",
"data",
",",
"name",
",",
"required",
"=",
"True",
",",
"*",
"*",
"kwargs",
")",
"try",
":",
"if",
"data_type",
"in",
"[",
"'[str]'",
"]",
":",
"data",
"=",
"[",
"\"\"",
"if",
"d",
"is",
"None",
"else",
"d",
"for",
"d",
"in",
"data",
"]",
"output",
"=",
"self",
".",
"serialize_data",
"(",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
"if",
"data_type",
"==",
"'bool'",
":",
"output",
"=",
"json",
".",
"dumps",
"(",
"output",
")",
"except",
"SerializationError",
":",
"raise",
"TypeError",
"(",
"\"{} must be type {}.\"",
".",
"format",
"(",
"name",
",",
"data_type",
")",
")",
"else",
":",
"return",
"str",
"(",
"output",
")"
] |
Serialize data intended for a request header.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
|
[
"Serialize",
"data",
"intended",
"for",
"a",
"request",
"header",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L634-L655
|
10,852
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.validate
|
def validate(cls, data, name, **kwargs):
"""Validate that a piece of data meets certain conditions"""
required = kwargs.get('required', False)
if required and data is None:
raise ValidationError("required", name, True)
elif data is None:
return
elif kwargs.get('readonly'):
return
try:
for key, value in kwargs.items():
validator = cls.validation.get(key, lambda x, y: False)
if validator(data, value):
raise ValidationError(key, name, value)
except TypeError:
raise ValidationError("unknown", name, "unknown")
else:
return data
|
python
|
def validate(cls, data, name, **kwargs):
"""Validate that a piece of data meets certain conditions"""
required = kwargs.get('required', False)
if required and data is None:
raise ValidationError("required", name, True)
elif data is None:
return
elif kwargs.get('readonly'):
return
try:
for key, value in kwargs.items():
validator = cls.validation.get(key, lambda x, y: False)
if validator(data, value):
raise ValidationError(key, name, value)
except TypeError:
raise ValidationError("unknown", name, "unknown")
else:
return data
|
[
"def",
"validate",
"(",
"cls",
",",
"data",
",",
"name",
",",
"*",
"*",
"kwargs",
")",
":",
"required",
"=",
"kwargs",
".",
"get",
"(",
"'required'",
",",
"False",
")",
"if",
"required",
"and",
"data",
"is",
"None",
":",
"raise",
"ValidationError",
"(",
"\"required\"",
",",
"name",
",",
"True",
")",
"elif",
"data",
"is",
"None",
":",
"return",
"elif",
"kwargs",
".",
"get",
"(",
"'readonly'",
")",
":",
"return",
"try",
":",
"for",
"key",
",",
"value",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"validator",
"=",
"cls",
".",
"validation",
".",
"get",
"(",
"key",
",",
"lambda",
"x",
",",
"y",
":",
"False",
")",
"if",
"validator",
"(",
"data",
",",
"value",
")",
":",
"raise",
"ValidationError",
"(",
"key",
",",
"name",
",",
"value",
")",
"except",
"TypeError",
":",
"raise",
"ValidationError",
"(",
"\"unknown\"",
",",
"name",
",",
"\"unknown\"",
")",
"else",
":",
"return",
"data"
] |
Validate that a piece of data meets certain conditions
|
[
"Validate",
"that",
"a",
"piece",
"of",
"data",
"meets",
"certain",
"conditions"
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L658-L676
|
10,853
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_data
|
def serialize_data(self, data, data_type, **kwargs):
"""Serialize generic data according to supplied data type.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:param bool required: Whether it's essential that the data not be
empty or None
:raises: AttributeError if required data is None.
:raises: ValueError if data is None
:raises: SerializationError if serialization fails.
"""
if data is None:
raise ValueError("No value for given attribute")
try:
if data_type in self.basic_types.values():
return self.serialize_basic(data, data_type, **kwargs)
elif data_type in self.serialize_type:
return self.serialize_type[data_type](data, **kwargs)
# If dependencies is empty, try with current data class
# It has to be a subclass of Enum anyway
enum_type = self.dependencies.get(data_type, data.__class__)
if issubclass(enum_type, Enum):
return Serializer.serialize_enum(data, enum_obj=enum_type)
iter_type = data_type[0] + data_type[-1]
if iter_type in self.serialize_type:
return self.serialize_type[iter_type](
data, data_type[1:-1], **kwargs)
except (ValueError, TypeError) as err:
msg = "Unable to serialize value: {!r} as type: {!r}."
raise_with_traceback(
SerializationError, msg.format(data, data_type), err)
else:
return self._serialize(data, **kwargs)
|
python
|
def serialize_data(self, data, data_type, **kwargs):
"""Serialize generic data according to supplied data type.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:param bool required: Whether it's essential that the data not be
empty or None
:raises: AttributeError if required data is None.
:raises: ValueError if data is None
:raises: SerializationError if serialization fails.
"""
if data is None:
raise ValueError("No value for given attribute")
try:
if data_type in self.basic_types.values():
return self.serialize_basic(data, data_type, **kwargs)
elif data_type in self.serialize_type:
return self.serialize_type[data_type](data, **kwargs)
# If dependencies is empty, try with current data class
# It has to be a subclass of Enum anyway
enum_type = self.dependencies.get(data_type, data.__class__)
if issubclass(enum_type, Enum):
return Serializer.serialize_enum(data, enum_obj=enum_type)
iter_type = data_type[0] + data_type[-1]
if iter_type in self.serialize_type:
return self.serialize_type[iter_type](
data, data_type[1:-1], **kwargs)
except (ValueError, TypeError) as err:
msg = "Unable to serialize value: {!r} as type: {!r}."
raise_with_traceback(
SerializationError, msg.format(data, data_type), err)
else:
return self._serialize(data, **kwargs)
|
[
"def",
"serialize_data",
"(",
"self",
",",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"data",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"No value for given attribute\"",
")",
"try",
":",
"if",
"data_type",
"in",
"self",
".",
"basic_types",
".",
"values",
"(",
")",
":",
"return",
"self",
".",
"serialize_basic",
"(",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
"elif",
"data_type",
"in",
"self",
".",
"serialize_type",
":",
"return",
"self",
".",
"serialize_type",
"[",
"data_type",
"]",
"(",
"data",
",",
"*",
"*",
"kwargs",
")",
"# If dependencies is empty, try with current data class",
"# It has to be a subclass of Enum anyway",
"enum_type",
"=",
"self",
".",
"dependencies",
".",
"get",
"(",
"data_type",
",",
"data",
".",
"__class__",
")",
"if",
"issubclass",
"(",
"enum_type",
",",
"Enum",
")",
":",
"return",
"Serializer",
".",
"serialize_enum",
"(",
"data",
",",
"enum_obj",
"=",
"enum_type",
")",
"iter_type",
"=",
"data_type",
"[",
"0",
"]",
"+",
"data_type",
"[",
"-",
"1",
"]",
"if",
"iter_type",
"in",
"self",
".",
"serialize_type",
":",
"return",
"self",
".",
"serialize_type",
"[",
"iter_type",
"]",
"(",
"data",
",",
"data_type",
"[",
"1",
":",
"-",
"1",
"]",
",",
"*",
"*",
"kwargs",
")",
"except",
"(",
"ValueError",
",",
"TypeError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Unable to serialize value: {!r} as type: {!r}.\"",
"raise_with_traceback",
"(",
"SerializationError",
",",
"msg",
".",
"format",
"(",
"data",
",",
"data_type",
")",
",",
"err",
")",
"else",
":",
"return",
"self",
".",
"_serialize",
"(",
"data",
",",
"*",
"*",
"kwargs",
")"
] |
Serialize generic data according to supplied data type.
:param data: The data to be serialized.
:param str data_type: The type to be serialized from.
:param bool required: Whether it's essential that the data not be
empty or None
:raises: AttributeError if required data is None.
:raises: ValueError if data is None
:raises: SerializationError if serialization fails.
|
[
"Serialize",
"generic",
"data",
"according",
"to",
"supplied",
"data",
"type",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L678-L715
|
10,854
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_basic
|
def serialize_basic(self, data, data_type, **kwargs):
"""Serialize basic builting data type.
Serializes objects to str, int, float or bool.
Possible kwargs:
- is_xml bool : If set, adapt basic serializers without the need for basic_types_serializers
- basic_types_serializers dict[str, callable] : If set, use the callable as serializer
:param data: Object to be serialized.
:param str data_type: Type of object in the iterable.
"""
custom_serializer = self._get_custom_serializers(data_type, **kwargs)
if custom_serializer:
return custom_serializer(data)
if data_type == 'str':
return self.serialize_unicode(data)
return eval(data_type)(data)
|
python
|
def serialize_basic(self, data, data_type, **kwargs):
"""Serialize basic builting data type.
Serializes objects to str, int, float or bool.
Possible kwargs:
- is_xml bool : If set, adapt basic serializers without the need for basic_types_serializers
- basic_types_serializers dict[str, callable] : If set, use the callable as serializer
:param data: Object to be serialized.
:param str data_type: Type of object in the iterable.
"""
custom_serializer = self._get_custom_serializers(data_type, **kwargs)
if custom_serializer:
return custom_serializer(data)
if data_type == 'str':
return self.serialize_unicode(data)
return eval(data_type)(data)
|
[
"def",
"serialize_basic",
"(",
"self",
",",
"data",
",",
"data_type",
",",
"*",
"*",
"kwargs",
")",
":",
"custom_serializer",
"=",
"self",
".",
"_get_custom_serializers",
"(",
"data_type",
",",
"*",
"*",
"kwargs",
")",
"if",
"custom_serializer",
":",
"return",
"custom_serializer",
"(",
"data",
")",
"if",
"data_type",
"==",
"'str'",
":",
"return",
"self",
".",
"serialize_unicode",
"(",
"data",
")",
"return",
"eval",
"(",
"data_type",
")",
"(",
"data",
")"
] |
Serialize basic builting data type.
Serializes objects to str, int, float or bool.
Possible kwargs:
- is_xml bool : If set, adapt basic serializers without the need for basic_types_serializers
- basic_types_serializers dict[str, callable] : If set, use the callable as serializer
:param data: Object to be serialized.
:param str data_type: Type of object in the iterable.
|
[
"Serialize",
"basic",
"builting",
"data",
"type",
".",
"Serializes",
"objects",
"to",
"str",
"int",
"float",
"or",
"bool",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L724-L740
|
10,855
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_unicode
|
def serialize_unicode(self, data):
"""Special handling for serializing unicode strings in Py2.
Encode to UTF-8 if unicode, otherwise handle as a str.
:param data: Object to be serialized.
:rtype: str
"""
try:
return data.value
except AttributeError:
pass
try:
if isinstance(data, unicode):
return data.encode(encoding='utf-8')
except NameError:
return str(data)
else:
return str(data)
|
python
|
def serialize_unicode(self, data):
"""Special handling for serializing unicode strings in Py2.
Encode to UTF-8 if unicode, otherwise handle as a str.
:param data: Object to be serialized.
:rtype: str
"""
try:
return data.value
except AttributeError:
pass
try:
if isinstance(data, unicode):
return data.encode(encoding='utf-8')
except NameError:
return str(data)
else:
return str(data)
|
[
"def",
"serialize_unicode",
"(",
"self",
",",
"data",
")",
":",
"try",
":",
"return",
"data",
".",
"value",
"except",
"AttributeError",
":",
"pass",
"try",
":",
"if",
"isinstance",
"(",
"data",
",",
"unicode",
")",
":",
"return",
"data",
".",
"encode",
"(",
"encoding",
"=",
"'utf-8'",
")",
"except",
"NameError",
":",
"return",
"str",
"(",
"data",
")",
"else",
":",
"return",
"str",
"(",
"data",
")"
] |
Special handling for serializing unicode strings in Py2.
Encode to UTF-8 if unicode, otherwise handle as a str.
:param data: Object to be serialized.
:rtype: str
|
[
"Special",
"handling",
"for",
"serializing",
"unicode",
"strings",
"in",
"Py2",
".",
"Encode",
"to",
"UTF",
"-",
"8",
"if",
"unicode",
"otherwise",
"handle",
"as",
"a",
"str",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L742-L759
|
10,856
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_iter
|
def serialize_iter(self, data, iter_type, div=None, **kwargs):
"""Serialize iterable.
Supported kwargs:
serialization_ctxt dict : The current entry of _attribute_map, or same format. serialization_ctxt['type'] should be same as data_type.
:param list attr: Object to be serialized.
:param str iter_type: Type of object in the iterable.
:param bool required: Whether the objects in the iterable must
not be None or empty.
:param str div: If set, this str will be used to combine the elements
in the iterable into a combined string. Default is 'None'.
:rtype: list, str
"""
if isinstance(data, str):
raise SerializationError("Refuse str type as a valid iter type.")
serialization_ctxt = kwargs.get("serialization_ctxt", {})
serialized = []
for d in data:
try:
serialized.append(self.serialize_data(d, iter_type, **kwargs))
except ValueError:
serialized.append(None)
if div:
serialized = ['' if s is None else str(s) for s in serialized]
serialized = div.join(serialized)
if 'xml' in serialization_ctxt:
# XML serialization is more complicated
xml_desc = serialization_ctxt['xml']
xml_name = xml_desc['name']
# Create a wrap node if necessary (use the fact that Element and list have "append")
is_wrapped = "wrapped" in xml_desc and xml_desc["wrapped"]
node_name = xml_desc.get("itemsName", xml_name)
if is_wrapped:
final_result = _create_xml_node(
xml_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
else:
final_result = []
# All list elements to "local_node"
for el in serialized:
if isinstance(el, ET.Element):
el_node = el
else:
el_node = _create_xml_node(
node_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
if el is not None: # Otherwise it writes "None" :-p
el_node.text = str(el)
final_result.append(el_node)
return final_result
return serialized
|
python
|
def serialize_iter(self, data, iter_type, div=None, **kwargs):
"""Serialize iterable.
Supported kwargs:
serialization_ctxt dict : The current entry of _attribute_map, or same format. serialization_ctxt['type'] should be same as data_type.
:param list attr: Object to be serialized.
:param str iter_type: Type of object in the iterable.
:param bool required: Whether the objects in the iterable must
not be None or empty.
:param str div: If set, this str will be used to combine the elements
in the iterable into a combined string. Default is 'None'.
:rtype: list, str
"""
if isinstance(data, str):
raise SerializationError("Refuse str type as a valid iter type.")
serialization_ctxt = kwargs.get("serialization_ctxt", {})
serialized = []
for d in data:
try:
serialized.append(self.serialize_data(d, iter_type, **kwargs))
except ValueError:
serialized.append(None)
if div:
serialized = ['' if s is None else str(s) for s in serialized]
serialized = div.join(serialized)
if 'xml' in serialization_ctxt:
# XML serialization is more complicated
xml_desc = serialization_ctxt['xml']
xml_name = xml_desc['name']
# Create a wrap node if necessary (use the fact that Element and list have "append")
is_wrapped = "wrapped" in xml_desc and xml_desc["wrapped"]
node_name = xml_desc.get("itemsName", xml_name)
if is_wrapped:
final_result = _create_xml_node(
xml_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
else:
final_result = []
# All list elements to "local_node"
for el in serialized:
if isinstance(el, ET.Element):
el_node = el
else:
el_node = _create_xml_node(
node_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
if el is not None: # Otherwise it writes "None" :-p
el_node.text = str(el)
final_result.append(el_node)
return final_result
return serialized
|
[
"def",
"serialize_iter",
"(",
"self",
",",
"data",
",",
"iter_type",
",",
"div",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"str",
")",
":",
"raise",
"SerializationError",
"(",
"\"Refuse str type as a valid iter type.\"",
")",
"serialization_ctxt",
"=",
"kwargs",
".",
"get",
"(",
"\"serialization_ctxt\"",
",",
"{",
"}",
")",
"serialized",
"=",
"[",
"]",
"for",
"d",
"in",
"data",
":",
"try",
":",
"serialized",
".",
"append",
"(",
"self",
".",
"serialize_data",
"(",
"d",
",",
"iter_type",
",",
"*",
"*",
"kwargs",
")",
")",
"except",
"ValueError",
":",
"serialized",
".",
"append",
"(",
"None",
")",
"if",
"div",
":",
"serialized",
"=",
"[",
"''",
"if",
"s",
"is",
"None",
"else",
"str",
"(",
"s",
")",
"for",
"s",
"in",
"serialized",
"]",
"serialized",
"=",
"div",
".",
"join",
"(",
"serialized",
")",
"if",
"'xml'",
"in",
"serialization_ctxt",
":",
"# XML serialization is more complicated",
"xml_desc",
"=",
"serialization_ctxt",
"[",
"'xml'",
"]",
"xml_name",
"=",
"xml_desc",
"[",
"'name'",
"]",
"# Create a wrap node if necessary (use the fact that Element and list have \"append\")",
"is_wrapped",
"=",
"\"wrapped\"",
"in",
"xml_desc",
"and",
"xml_desc",
"[",
"\"wrapped\"",
"]",
"node_name",
"=",
"xml_desc",
".",
"get",
"(",
"\"itemsName\"",
",",
"xml_name",
")",
"if",
"is_wrapped",
":",
"final_result",
"=",
"_create_xml_node",
"(",
"xml_name",
",",
"xml_desc",
".",
"get",
"(",
"'prefix'",
",",
"None",
")",
",",
"xml_desc",
".",
"get",
"(",
"'ns'",
",",
"None",
")",
")",
"else",
":",
"final_result",
"=",
"[",
"]",
"# All list elements to \"local_node\"",
"for",
"el",
"in",
"serialized",
":",
"if",
"isinstance",
"(",
"el",
",",
"ET",
".",
"Element",
")",
":",
"el_node",
"=",
"el",
"else",
":",
"el_node",
"=",
"_create_xml_node",
"(",
"node_name",
",",
"xml_desc",
".",
"get",
"(",
"'prefix'",
",",
"None",
")",
",",
"xml_desc",
".",
"get",
"(",
"'ns'",
",",
"None",
")",
")",
"if",
"el",
"is",
"not",
"None",
":",
"# Otherwise it writes \"None\" :-p",
"el_node",
".",
"text",
"=",
"str",
"(",
"el",
")",
"final_result",
".",
"append",
"(",
"el_node",
")",
"return",
"final_result",
"return",
"serialized"
] |
Serialize iterable.
Supported kwargs:
serialization_ctxt dict : The current entry of _attribute_map, or same format. serialization_ctxt['type'] should be same as data_type.
:param list attr: Object to be serialized.
:param str iter_type: Type of object in the iterable.
:param bool required: Whether the objects in the iterable must
not be None or empty.
:param str div: If set, this str will be used to combine the elements
in the iterable into a combined string. Default is 'None'.
:rtype: list, str
|
[
"Serialize",
"iterable",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L761-L821
|
10,857
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_dict
|
def serialize_dict(self, attr, dict_type, **kwargs):
"""Serialize a dictionary of objects.
:param dict attr: Object to be serialized.
:param str dict_type: Type of object in the dictionary.
:param bool required: Whether the objects in the dictionary must
not be None or empty.
:rtype: dict
"""
serialization_ctxt = kwargs.get("serialization_ctxt", {})
serialized = {}
for key, value in attr.items():
try:
serialized[self.serialize_unicode(key)] = self.serialize_data(
value, dict_type, **kwargs)
except ValueError:
serialized[self.serialize_unicode(key)] = None
if 'xml' in serialization_ctxt:
# XML serialization is more complicated
xml_desc = serialization_ctxt['xml']
xml_name = xml_desc['name']
final_result = _create_xml_node(
xml_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
for key, value in serialized.items():
ET.SubElement(final_result, key).text = value
return final_result
return serialized
|
python
|
def serialize_dict(self, attr, dict_type, **kwargs):
"""Serialize a dictionary of objects.
:param dict attr: Object to be serialized.
:param str dict_type: Type of object in the dictionary.
:param bool required: Whether the objects in the dictionary must
not be None or empty.
:rtype: dict
"""
serialization_ctxt = kwargs.get("serialization_ctxt", {})
serialized = {}
for key, value in attr.items():
try:
serialized[self.serialize_unicode(key)] = self.serialize_data(
value, dict_type, **kwargs)
except ValueError:
serialized[self.serialize_unicode(key)] = None
if 'xml' in serialization_ctxt:
# XML serialization is more complicated
xml_desc = serialization_ctxt['xml']
xml_name = xml_desc['name']
final_result = _create_xml_node(
xml_name,
xml_desc.get('prefix', None),
xml_desc.get('ns', None)
)
for key, value in serialized.items():
ET.SubElement(final_result, key).text = value
return final_result
return serialized
|
[
"def",
"serialize_dict",
"(",
"self",
",",
"attr",
",",
"dict_type",
",",
"*",
"*",
"kwargs",
")",
":",
"serialization_ctxt",
"=",
"kwargs",
".",
"get",
"(",
"\"serialization_ctxt\"",
",",
"{",
"}",
")",
"serialized",
"=",
"{",
"}",
"for",
"key",
",",
"value",
"in",
"attr",
".",
"items",
"(",
")",
":",
"try",
":",
"serialized",
"[",
"self",
".",
"serialize_unicode",
"(",
"key",
")",
"]",
"=",
"self",
".",
"serialize_data",
"(",
"value",
",",
"dict_type",
",",
"*",
"*",
"kwargs",
")",
"except",
"ValueError",
":",
"serialized",
"[",
"self",
".",
"serialize_unicode",
"(",
"key",
")",
"]",
"=",
"None",
"if",
"'xml'",
"in",
"serialization_ctxt",
":",
"# XML serialization is more complicated",
"xml_desc",
"=",
"serialization_ctxt",
"[",
"'xml'",
"]",
"xml_name",
"=",
"xml_desc",
"[",
"'name'",
"]",
"final_result",
"=",
"_create_xml_node",
"(",
"xml_name",
",",
"xml_desc",
".",
"get",
"(",
"'prefix'",
",",
"None",
")",
",",
"xml_desc",
".",
"get",
"(",
"'ns'",
",",
"None",
")",
")",
"for",
"key",
",",
"value",
"in",
"serialized",
".",
"items",
"(",
")",
":",
"ET",
".",
"SubElement",
"(",
"final_result",
",",
"key",
")",
".",
"text",
"=",
"value",
"return",
"final_result",
"return",
"serialized"
] |
Serialize a dictionary of objects.
:param dict attr: Object to be serialized.
:param str dict_type: Type of object in the dictionary.
:param bool required: Whether the objects in the dictionary must
not be None or empty.
:rtype: dict
|
[
"Serialize",
"a",
"dictionary",
"of",
"objects",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L823-L855
|
10,858
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_base64
|
def serialize_base64(attr, **kwargs):
"""Serialize str into base-64 string.
:param attr: Object to be serialized.
:rtype: str
"""
encoded = b64encode(attr).decode('ascii')
return encoded.strip('=').replace('+', '-').replace('/', '_')
|
python
|
def serialize_base64(attr, **kwargs):
"""Serialize str into base-64 string.
:param attr: Object to be serialized.
:rtype: str
"""
encoded = b64encode(attr).decode('ascii')
return encoded.strip('=').replace('+', '-').replace('/', '_')
|
[
"def",
"serialize_base64",
"(",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"encoded",
"=",
"b64encode",
"(",
"attr",
")",
".",
"decode",
"(",
"'ascii'",
")",
"return",
"encoded",
".",
"strip",
"(",
"'='",
")",
".",
"replace",
"(",
"'+'",
",",
"'-'",
")",
".",
"replace",
"(",
"'/'",
",",
"'_'",
")"
] |
Serialize str into base-64 string.
:param attr: Object to be serialized.
:rtype: str
|
[
"Serialize",
"str",
"into",
"base",
"-",
"64",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L927-L934
|
10,859
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_date
|
def serialize_date(attr, **kwargs):
"""Serialize Date object into ISO-8601 formatted string.
:param Date attr: Object to be serialized.
:rtype: str
"""
if isinstance(attr, str):
attr = isodate.parse_date(attr)
t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day)
return t
|
python
|
def serialize_date(attr, **kwargs):
"""Serialize Date object into ISO-8601 formatted string.
:param Date attr: Object to be serialized.
:rtype: str
"""
if isinstance(attr, str):
attr = isodate.parse_date(attr)
t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day)
return t
|
[
"def",
"serialize_date",
"(",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"str",
")",
":",
"attr",
"=",
"isodate",
".",
"parse_date",
"(",
"attr",
")",
"t",
"=",
"\"{:04}-{:02}-{:02}\"",
".",
"format",
"(",
"attr",
".",
"year",
",",
"attr",
".",
"month",
",",
"attr",
".",
"day",
")",
"return",
"t"
] |
Serialize Date object into ISO-8601 formatted string.
:param Date attr: Object to be serialized.
:rtype: str
|
[
"Serialize",
"Date",
"object",
"into",
"ISO",
"-",
"8601",
"formatted",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L955-L964
|
10,860
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_duration
|
def serialize_duration(attr, **kwargs):
"""Serialize TimeDelta object into ISO-8601 formatted string.
:param TimeDelta attr: Object to be serialized.
:rtype: str
"""
if isinstance(attr, str):
attr = isodate.parse_duration(attr)
return isodate.duration_isoformat(attr)
|
python
|
def serialize_duration(attr, **kwargs):
"""Serialize TimeDelta object into ISO-8601 formatted string.
:param TimeDelta attr: Object to be serialized.
:rtype: str
"""
if isinstance(attr, str):
attr = isodate.parse_duration(attr)
return isodate.duration_isoformat(attr)
|
[
"def",
"serialize_duration",
"(",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"str",
")",
":",
"attr",
"=",
"isodate",
".",
"parse_duration",
"(",
"attr",
")",
"return",
"isodate",
".",
"duration_isoformat",
"(",
"attr",
")"
] |
Serialize TimeDelta object into ISO-8601 formatted string.
:param TimeDelta attr: Object to be serialized.
:rtype: str
|
[
"Serialize",
"TimeDelta",
"object",
"into",
"ISO",
"-",
"8601",
"formatted",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L967-L975
|
10,861
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_rfc
|
def serialize_rfc(attr, **kwargs):
"""Serialize Datetime object into RFC-1123 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: TypeError if format invalid.
"""
try:
if not attr.tzinfo:
_LOGGER.warning(
"Datetime with no tzinfo will be considered UTC.")
utc = attr.utctimetuple()
except AttributeError:
raise TypeError("RFC1123 object must be valid Datetime object.")
return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
Serializer.days[utc.tm_wday], utc.tm_mday,
Serializer.months[utc.tm_mon], utc.tm_year,
utc.tm_hour, utc.tm_min, utc.tm_sec)
|
python
|
def serialize_rfc(attr, **kwargs):
"""Serialize Datetime object into RFC-1123 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: TypeError if format invalid.
"""
try:
if not attr.tzinfo:
_LOGGER.warning(
"Datetime with no tzinfo will be considered UTC.")
utc = attr.utctimetuple()
except AttributeError:
raise TypeError("RFC1123 object must be valid Datetime object.")
return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
Serializer.days[utc.tm_wday], utc.tm_mday,
Serializer.months[utc.tm_mon], utc.tm_year,
utc.tm_hour, utc.tm_min, utc.tm_sec)
|
[
"def",
"serialize_rfc",
"(",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"attr",
".",
"tzinfo",
":",
"_LOGGER",
".",
"warning",
"(",
"\"Datetime with no tzinfo will be considered UTC.\"",
")",
"utc",
"=",
"attr",
".",
"utctimetuple",
"(",
")",
"except",
"AttributeError",
":",
"raise",
"TypeError",
"(",
"\"RFC1123 object must be valid Datetime object.\"",
")",
"return",
"\"{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT\"",
".",
"format",
"(",
"Serializer",
".",
"days",
"[",
"utc",
".",
"tm_wday",
"]",
",",
"utc",
".",
"tm_mday",
",",
"Serializer",
".",
"months",
"[",
"utc",
".",
"tm_mon",
"]",
",",
"utc",
".",
"tm_year",
",",
"utc",
".",
"tm_hour",
",",
"utc",
".",
"tm_min",
",",
"utc",
".",
"tm_sec",
")"
] |
Serialize Datetime object into RFC-1123 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: TypeError if format invalid.
|
[
"Serialize",
"Datetime",
"object",
"into",
"RFC",
"-",
"1123",
"formatted",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L978-L996
|
10,862
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Serializer.serialize_iso
|
def serialize_iso(attr, **kwargs):
"""Serialize Datetime object into ISO-8601 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: SerializationError if format invalid.
"""
if isinstance(attr, str):
attr = isodate.parse_datetime(attr)
try:
if not attr.tzinfo:
_LOGGER.warning(
"Datetime with no tzinfo will be considered UTC.")
utc = attr.utctimetuple()
if utc.tm_year > 9999 or utc.tm_year < 1:
raise OverflowError("Hit max or min date")
microseconds = str(attr.microsecond).rjust(6,'0').rstrip('0').ljust(3, '0')
if microseconds:
microseconds = '.'+microseconds
date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format(
utc.tm_year, utc.tm_mon, utc.tm_mday,
utc.tm_hour, utc.tm_min, utc.tm_sec)
return date + microseconds + 'Z'
except (ValueError, OverflowError) as err:
msg = "Unable to serialize datetime object."
raise_with_traceback(SerializationError, msg, err)
except AttributeError as err:
msg = "ISO-8601 object must be valid Datetime object."
raise_with_traceback(TypeError, msg, err)
|
python
|
def serialize_iso(attr, **kwargs):
"""Serialize Datetime object into ISO-8601 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: SerializationError if format invalid.
"""
if isinstance(attr, str):
attr = isodate.parse_datetime(attr)
try:
if not attr.tzinfo:
_LOGGER.warning(
"Datetime with no tzinfo will be considered UTC.")
utc = attr.utctimetuple()
if utc.tm_year > 9999 or utc.tm_year < 1:
raise OverflowError("Hit max or min date")
microseconds = str(attr.microsecond).rjust(6,'0').rstrip('0').ljust(3, '0')
if microseconds:
microseconds = '.'+microseconds
date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format(
utc.tm_year, utc.tm_mon, utc.tm_mday,
utc.tm_hour, utc.tm_min, utc.tm_sec)
return date + microseconds + 'Z'
except (ValueError, OverflowError) as err:
msg = "Unable to serialize datetime object."
raise_with_traceback(SerializationError, msg, err)
except AttributeError as err:
msg = "ISO-8601 object must be valid Datetime object."
raise_with_traceback(TypeError, msg, err)
|
[
"def",
"serialize_iso",
"(",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"str",
")",
":",
"attr",
"=",
"isodate",
".",
"parse_datetime",
"(",
"attr",
")",
"try",
":",
"if",
"not",
"attr",
".",
"tzinfo",
":",
"_LOGGER",
".",
"warning",
"(",
"\"Datetime with no tzinfo will be considered UTC.\"",
")",
"utc",
"=",
"attr",
".",
"utctimetuple",
"(",
")",
"if",
"utc",
".",
"tm_year",
">",
"9999",
"or",
"utc",
".",
"tm_year",
"<",
"1",
":",
"raise",
"OverflowError",
"(",
"\"Hit max or min date\"",
")",
"microseconds",
"=",
"str",
"(",
"attr",
".",
"microsecond",
")",
".",
"rjust",
"(",
"6",
",",
"'0'",
")",
".",
"rstrip",
"(",
"'0'",
")",
".",
"ljust",
"(",
"3",
",",
"'0'",
")",
"if",
"microseconds",
":",
"microseconds",
"=",
"'.'",
"+",
"microseconds",
"date",
"=",
"\"{:04}-{:02}-{:02}T{:02}:{:02}:{:02}\"",
".",
"format",
"(",
"utc",
".",
"tm_year",
",",
"utc",
".",
"tm_mon",
",",
"utc",
".",
"tm_mday",
",",
"utc",
".",
"tm_hour",
",",
"utc",
".",
"tm_min",
",",
"utc",
".",
"tm_sec",
")",
"return",
"date",
"+",
"microseconds",
"+",
"'Z'",
"except",
"(",
"ValueError",
",",
"OverflowError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Unable to serialize datetime object.\"",
"raise_with_traceback",
"(",
"SerializationError",
",",
"msg",
",",
"err",
")",
"except",
"AttributeError",
"as",
"err",
":",
"msg",
"=",
"\"ISO-8601 object must be valid Datetime object.\"",
"raise_with_traceback",
"(",
"TypeError",
",",
"msg",
",",
"err",
")"
] |
Serialize Datetime object into ISO-8601 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: SerializationError if format invalid.
|
[
"Serialize",
"Datetime",
"object",
"into",
"ISO",
"-",
"8601",
"formatted",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L999-L1028
|
10,863
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer._deserialize
|
def _deserialize(self, target_obj, data):
"""Call the deserializer on a model.
Data needs to be already deserialized as JSON or XML ElementTree
:param str target_obj: Target data type to deserialize to.
:param object data: Object to deserialize.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
"""
# This is already a model, go recursive just in case
if hasattr(data, "_attribute_map"):
constants = [name for name, config in getattr(data, '_validation', {}).items()
if config.get('constant')]
try:
for attr, mapconfig in data._attribute_map.items():
if attr in constants:
continue
value = getattr(data, attr)
if value is None:
continue
local_type = mapconfig['type']
internal_data_type = local_type.strip('[]{}')
if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum):
continue
setattr(
data,
attr,
self._deserialize(local_type, value)
)
return data
except AttributeError:
return
response, class_name = self._classify_target(target_obj, data)
if isinstance(response, basestring):
return self.deserialize_data(data, response)
elif isinstance(response, type) and issubclass(response, Enum):
return self.deserialize_enum(data, response)
if data is None:
return data
try:
attributes = response._attribute_map
d_attrs = {}
for attr, attr_desc in attributes.items():
# Check empty string. If it's not empty, someone has a real "additionalProperties"...
if attr == "additional_properties" and attr_desc["key"] == '':
continue
raw_value = None
# Enhance attr_desc with some dynamic data
attr_desc = attr_desc.copy() # Do a copy, do not change the real one
internal_data_type = attr_desc["type"].strip('[]{}')
if internal_data_type in self.dependencies:
attr_desc["internalType"] = self.dependencies[internal_data_type]
for key_extractor in self.key_extractors:
found_value = key_extractor(attr, attr_desc, data)
if found_value is not None:
if raw_value is not None and raw_value != found_value:
raise KeyError('Use twice the key: "{}"'.format(attr))
raw_value = found_value
value = self.deserialize_data(raw_value, attr_desc['type'])
d_attrs[attr] = value
except (AttributeError, TypeError, KeyError) as err:
msg = "Unable to deserialize to object: " + class_name
raise_with_traceback(DeserializationError, msg, err)
else:
additional_properties = self._build_additional_properties(attributes, data)
return self._instantiate_model(response, d_attrs, additional_properties)
|
python
|
def _deserialize(self, target_obj, data):
"""Call the deserializer on a model.
Data needs to be already deserialized as JSON or XML ElementTree
:param str target_obj: Target data type to deserialize to.
:param object data: Object to deserialize.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
"""
# This is already a model, go recursive just in case
if hasattr(data, "_attribute_map"):
constants = [name for name, config in getattr(data, '_validation', {}).items()
if config.get('constant')]
try:
for attr, mapconfig in data._attribute_map.items():
if attr in constants:
continue
value = getattr(data, attr)
if value is None:
continue
local_type = mapconfig['type']
internal_data_type = local_type.strip('[]{}')
if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum):
continue
setattr(
data,
attr,
self._deserialize(local_type, value)
)
return data
except AttributeError:
return
response, class_name = self._classify_target(target_obj, data)
if isinstance(response, basestring):
return self.deserialize_data(data, response)
elif isinstance(response, type) and issubclass(response, Enum):
return self.deserialize_enum(data, response)
if data is None:
return data
try:
attributes = response._attribute_map
d_attrs = {}
for attr, attr_desc in attributes.items():
# Check empty string. If it's not empty, someone has a real "additionalProperties"...
if attr == "additional_properties" and attr_desc["key"] == '':
continue
raw_value = None
# Enhance attr_desc with some dynamic data
attr_desc = attr_desc.copy() # Do a copy, do not change the real one
internal_data_type = attr_desc["type"].strip('[]{}')
if internal_data_type in self.dependencies:
attr_desc["internalType"] = self.dependencies[internal_data_type]
for key_extractor in self.key_extractors:
found_value = key_extractor(attr, attr_desc, data)
if found_value is not None:
if raw_value is not None and raw_value != found_value:
raise KeyError('Use twice the key: "{}"'.format(attr))
raw_value = found_value
value = self.deserialize_data(raw_value, attr_desc['type'])
d_attrs[attr] = value
except (AttributeError, TypeError, KeyError) as err:
msg = "Unable to deserialize to object: " + class_name
raise_with_traceback(DeserializationError, msg, err)
else:
additional_properties = self._build_additional_properties(attributes, data)
return self._instantiate_model(response, d_attrs, additional_properties)
|
[
"def",
"_deserialize",
"(",
"self",
",",
"target_obj",
",",
"data",
")",
":",
"# This is already a model, go recursive just in case",
"if",
"hasattr",
"(",
"data",
",",
"\"_attribute_map\"",
")",
":",
"constants",
"=",
"[",
"name",
"for",
"name",
",",
"config",
"in",
"getattr",
"(",
"data",
",",
"'_validation'",
",",
"{",
"}",
")",
".",
"items",
"(",
")",
"if",
"config",
".",
"get",
"(",
"'constant'",
")",
"]",
"try",
":",
"for",
"attr",
",",
"mapconfig",
"in",
"data",
".",
"_attribute_map",
".",
"items",
"(",
")",
":",
"if",
"attr",
"in",
"constants",
":",
"continue",
"value",
"=",
"getattr",
"(",
"data",
",",
"attr",
")",
"if",
"value",
"is",
"None",
":",
"continue",
"local_type",
"=",
"mapconfig",
"[",
"'type'",
"]",
"internal_data_type",
"=",
"local_type",
".",
"strip",
"(",
"'[]{}'",
")",
"if",
"internal_data_type",
"not",
"in",
"self",
".",
"dependencies",
"or",
"isinstance",
"(",
"internal_data_type",
",",
"Enum",
")",
":",
"continue",
"setattr",
"(",
"data",
",",
"attr",
",",
"self",
".",
"_deserialize",
"(",
"local_type",
",",
"value",
")",
")",
"return",
"data",
"except",
"AttributeError",
":",
"return",
"response",
",",
"class_name",
"=",
"self",
".",
"_classify_target",
"(",
"target_obj",
",",
"data",
")",
"if",
"isinstance",
"(",
"response",
",",
"basestring",
")",
":",
"return",
"self",
".",
"deserialize_data",
"(",
"data",
",",
"response",
")",
"elif",
"isinstance",
"(",
"response",
",",
"type",
")",
"and",
"issubclass",
"(",
"response",
",",
"Enum",
")",
":",
"return",
"self",
".",
"deserialize_enum",
"(",
"data",
",",
"response",
")",
"if",
"data",
"is",
"None",
":",
"return",
"data",
"try",
":",
"attributes",
"=",
"response",
".",
"_attribute_map",
"d_attrs",
"=",
"{",
"}",
"for",
"attr",
",",
"attr_desc",
"in",
"attributes",
".",
"items",
"(",
")",
":",
"# Check empty string. If it's not empty, someone has a real \"additionalProperties\"...",
"if",
"attr",
"==",
"\"additional_properties\"",
"and",
"attr_desc",
"[",
"\"key\"",
"]",
"==",
"''",
":",
"continue",
"raw_value",
"=",
"None",
"# Enhance attr_desc with some dynamic data",
"attr_desc",
"=",
"attr_desc",
".",
"copy",
"(",
")",
"# Do a copy, do not change the real one",
"internal_data_type",
"=",
"attr_desc",
"[",
"\"type\"",
"]",
".",
"strip",
"(",
"'[]{}'",
")",
"if",
"internal_data_type",
"in",
"self",
".",
"dependencies",
":",
"attr_desc",
"[",
"\"internalType\"",
"]",
"=",
"self",
".",
"dependencies",
"[",
"internal_data_type",
"]",
"for",
"key_extractor",
"in",
"self",
".",
"key_extractors",
":",
"found_value",
"=",
"key_extractor",
"(",
"attr",
",",
"attr_desc",
",",
"data",
")",
"if",
"found_value",
"is",
"not",
"None",
":",
"if",
"raw_value",
"is",
"not",
"None",
"and",
"raw_value",
"!=",
"found_value",
":",
"raise",
"KeyError",
"(",
"'Use twice the key: \"{}\"'",
".",
"format",
"(",
"attr",
")",
")",
"raw_value",
"=",
"found_value",
"value",
"=",
"self",
".",
"deserialize_data",
"(",
"raw_value",
",",
"attr_desc",
"[",
"'type'",
"]",
")",
"d_attrs",
"[",
"attr",
"]",
"=",
"value",
"except",
"(",
"AttributeError",
",",
"TypeError",
",",
"KeyError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Unable to deserialize to object: \"",
"+",
"class_name",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")",
"else",
":",
"additional_properties",
"=",
"self",
".",
"_build_additional_properties",
"(",
"attributes",
",",
"data",
")",
"return",
"self",
".",
"_instantiate_model",
"(",
"response",
",",
"d_attrs",
",",
"additional_properties",
")"
] |
Call the deserializer on a model.
Data needs to be already deserialized as JSON or XML ElementTree
:param str target_obj: Target data type to deserialize to.
:param object data: Object to deserialize.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
|
[
"Call",
"the",
"deserializer",
"on",
"a",
"model",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1230-L1301
|
10,864
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer._classify_target
|
def _classify_target(self, target, data):
"""Check to see whether the deserialization target object can
be classified into a subclass.
Once classification has been determined, initialize object.
:param str target: The target object type to deserialize to.
:param str/dict data: The response data to deseralize.
"""
if target is None:
return None, None
if isinstance(target, basestring):
try:
target = self.dependencies[target]
except KeyError:
return target, target
try:
target = target._classify(data, self.dependencies)
except AttributeError:
pass # Target is not a Model, no classify
return target, target.__class__.__name__
|
python
|
def _classify_target(self, target, data):
"""Check to see whether the deserialization target object can
be classified into a subclass.
Once classification has been determined, initialize object.
:param str target: The target object type to deserialize to.
:param str/dict data: The response data to deseralize.
"""
if target is None:
return None, None
if isinstance(target, basestring):
try:
target = self.dependencies[target]
except KeyError:
return target, target
try:
target = target._classify(data, self.dependencies)
except AttributeError:
pass # Target is not a Model, no classify
return target, target.__class__.__name__
|
[
"def",
"_classify_target",
"(",
"self",
",",
"target",
",",
"data",
")",
":",
"if",
"target",
"is",
"None",
":",
"return",
"None",
",",
"None",
"if",
"isinstance",
"(",
"target",
",",
"basestring",
")",
":",
"try",
":",
"target",
"=",
"self",
".",
"dependencies",
"[",
"target",
"]",
"except",
"KeyError",
":",
"return",
"target",
",",
"target",
"try",
":",
"target",
"=",
"target",
".",
"_classify",
"(",
"data",
",",
"self",
".",
"dependencies",
")",
"except",
"AttributeError",
":",
"pass",
"# Target is not a Model, no classify",
"return",
"target",
",",
"target",
".",
"__class__",
".",
"__name__"
] |
Check to see whether the deserialization target object can
be classified into a subclass.
Once classification has been determined, initialize object.
:param str target: The target object type to deserialize to.
:param str/dict data: The response data to deseralize.
|
[
"Check",
"to",
"see",
"whether",
"the",
"deserialization",
"target",
"object",
"can",
"be",
"classified",
"into",
"a",
"subclass",
".",
"Once",
"classification",
"has",
"been",
"determined",
"initialize",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1315-L1336
|
10,865
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer._unpack_content
|
def _unpack_content(raw_data, content_type=None):
"""Extract the correct structure for deserialization.
If raw_data is a PipelineResponse, try to extract the result of RawDeserializer.
if we can't, raise. Your Pipeline should have a RawDeserializer.
If not a pipeline response and raw_data is bytes or string, use content-type
to decode it. If no content-type, try JSON.
If raw_data is something else, bypass all logic and return it directly.
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
"""
# This avoids a circular dependency. We might want to consider RawDesializer is more generic
# than the pipeline concept, and put it in a toolbox, used both here and in pipeline. TBD.
from .pipeline.universal import RawDeserializer
# Assume this is enough to detect a Pipeline Response without importing it
context = getattr(raw_data, "context", {})
if context:
if RawDeserializer.CONTEXT_NAME in context:
return context[RawDeserializer.CONTEXT_NAME]
raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize")
#Assume this is enough to recognize universal_http.ClientResponse without importing it
if hasattr(raw_data, "body"):
return RawDeserializer.deserialize_from_http_generics(
raw_data.text(),
raw_data.headers
)
# Assume this enough to recognize requests.Response without importing it.
if hasattr(raw_data, '_content_consumed'):
return RawDeserializer.deserialize_from_http_generics(
raw_data.text,
raw_data.headers
)
if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, 'read'):
return RawDeserializer.deserialize_from_text(raw_data, content_type)
return raw_data
|
python
|
def _unpack_content(raw_data, content_type=None):
"""Extract the correct structure for deserialization.
If raw_data is a PipelineResponse, try to extract the result of RawDeserializer.
if we can't, raise. Your Pipeline should have a RawDeserializer.
If not a pipeline response and raw_data is bytes or string, use content-type
to decode it. If no content-type, try JSON.
If raw_data is something else, bypass all logic and return it directly.
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
"""
# This avoids a circular dependency. We might want to consider RawDesializer is more generic
# than the pipeline concept, and put it in a toolbox, used both here and in pipeline. TBD.
from .pipeline.universal import RawDeserializer
# Assume this is enough to detect a Pipeline Response without importing it
context = getattr(raw_data, "context", {})
if context:
if RawDeserializer.CONTEXT_NAME in context:
return context[RawDeserializer.CONTEXT_NAME]
raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize")
#Assume this is enough to recognize universal_http.ClientResponse without importing it
if hasattr(raw_data, "body"):
return RawDeserializer.deserialize_from_http_generics(
raw_data.text(),
raw_data.headers
)
# Assume this enough to recognize requests.Response without importing it.
if hasattr(raw_data, '_content_consumed'):
return RawDeserializer.deserialize_from_http_generics(
raw_data.text,
raw_data.headers
)
if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, 'read'):
return RawDeserializer.deserialize_from_text(raw_data, content_type)
return raw_data
|
[
"def",
"_unpack_content",
"(",
"raw_data",
",",
"content_type",
"=",
"None",
")",
":",
"# This avoids a circular dependency. We might want to consider RawDesializer is more generic",
"# than the pipeline concept, and put it in a toolbox, used both here and in pipeline. TBD.",
"from",
".",
"pipeline",
".",
"universal",
"import",
"RawDeserializer",
"# Assume this is enough to detect a Pipeline Response without importing it",
"context",
"=",
"getattr",
"(",
"raw_data",
",",
"\"context\"",
",",
"{",
"}",
")",
"if",
"context",
":",
"if",
"RawDeserializer",
".",
"CONTEXT_NAME",
"in",
"context",
":",
"return",
"context",
"[",
"RawDeserializer",
".",
"CONTEXT_NAME",
"]",
"raise",
"ValueError",
"(",
"\"This pipeline didn't have the RawDeserializer policy; can't deserialize\"",
")",
"#Assume this is enough to recognize universal_http.ClientResponse without importing it",
"if",
"hasattr",
"(",
"raw_data",
",",
"\"body\"",
")",
":",
"return",
"RawDeserializer",
".",
"deserialize_from_http_generics",
"(",
"raw_data",
".",
"text",
"(",
")",
",",
"raw_data",
".",
"headers",
")",
"# Assume this enough to recognize requests.Response without importing it.",
"if",
"hasattr",
"(",
"raw_data",
",",
"'_content_consumed'",
")",
":",
"return",
"RawDeserializer",
".",
"deserialize_from_http_generics",
"(",
"raw_data",
".",
"text",
",",
"raw_data",
".",
"headers",
")",
"if",
"isinstance",
"(",
"raw_data",
",",
"(",
"basestring",
",",
"bytes",
")",
")",
"or",
"hasattr",
"(",
"raw_data",
",",
"'read'",
")",
":",
"return",
"RawDeserializer",
".",
"deserialize_from_text",
"(",
"raw_data",
",",
"content_type",
")",
"return",
"raw_data"
] |
Extract the correct structure for deserialization.
If raw_data is a PipelineResponse, try to extract the result of RawDeserializer.
if we can't, raise. Your Pipeline should have a RawDeserializer.
If not a pipeline response and raw_data is bytes or string, use content-type
to decode it. If no content-type, try JSON.
If raw_data is something else, bypass all logic and return it directly.
:param raw_data: Data to be processed.
:param content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
|
[
"Extract",
"the",
"correct",
"structure",
"for",
"deserialization",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1339-L1382
|
10,866
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer._instantiate_model
|
def _instantiate_model(self, response, attrs, additional_properties=None):
"""Instantiate a response model passing in deserialized args.
:param response: The response model class.
:param d_attrs: The deserialized response attributes.
"""
if callable(response):
subtype = getattr(response, '_subtype_map', {})
try:
readonly = [k for k, v in response._validation.items()
if v.get('readonly')]
const = [k for k, v in response._validation.items()
if v.get('constant')]
kwargs = {k: v for k, v in attrs.items()
if k not in subtype and k not in readonly + const}
response_obj = response(**kwargs)
for attr in readonly:
setattr(response_obj, attr, attrs.get(attr))
if additional_properties:
response_obj.additional_properties = additional_properties
return response_obj
except TypeError as err:
msg = "Unable to deserialize {} into model {}. ".format(
kwargs, response)
raise DeserializationError(msg + str(err))
else:
try:
for attr, value in attrs.items():
setattr(response, attr, value)
return response
except Exception as exp:
msg = "Unable to populate response model. "
msg += "Type: {}, Error: {}".format(type(response), exp)
raise DeserializationError(msg)
|
python
|
def _instantiate_model(self, response, attrs, additional_properties=None):
"""Instantiate a response model passing in deserialized args.
:param response: The response model class.
:param d_attrs: The deserialized response attributes.
"""
if callable(response):
subtype = getattr(response, '_subtype_map', {})
try:
readonly = [k for k, v in response._validation.items()
if v.get('readonly')]
const = [k for k, v in response._validation.items()
if v.get('constant')]
kwargs = {k: v for k, v in attrs.items()
if k not in subtype and k not in readonly + const}
response_obj = response(**kwargs)
for attr in readonly:
setattr(response_obj, attr, attrs.get(attr))
if additional_properties:
response_obj.additional_properties = additional_properties
return response_obj
except TypeError as err:
msg = "Unable to deserialize {} into model {}. ".format(
kwargs, response)
raise DeserializationError(msg + str(err))
else:
try:
for attr, value in attrs.items():
setattr(response, attr, value)
return response
except Exception as exp:
msg = "Unable to populate response model. "
msg += "Type: {}, Error: {}".format(type(response), exp)
raise DeserializationError(msg)
|
[
"def",
"_instantiate_model",
"(",
"self",
",",
"response",
",",
"attrs",
",",
"additional_properties",
"=",
"None",
")",
":",
"if",
"callable",
"(",
"response",
")",
":",
"subtype",
"=",
"getattr",
"(",
"response",
",",
"'_subtype_map'",
",",
"{",
"}",
")",
"try",
":",
"readonly",
"=",
"[",
"k",
"for",
"k",
",",
"v",
"in",
"response",
".",
"_validation",
".",
"items",
"(",
")",
"if",
"v",
".",
"get",
"(",
"'readonly'",
")",
"]",
"const",
"=",
"[",
"k",
"for",
"k",
",",
"v",
"in",
"response",
".",
"_validation",
".",
"items",
"(",
")",
"if",
"v",
".",
"get",
"(",
"'constant'",
")",
"]",
"kwargs",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"attrs",
".",
"items",
"(",
")",
"if",
"k",
"not",
"in",
"subtype",
"and",
"k",
"not",
"in",
"readonly",
"+",
"const",
"}",
"response_obj",
"=",
"response",
"(",
"*",
"*",
"kwargs",
")",
"for",
"attr",
"in",
"readonly",
":",
"setattr",
"(",
"response_obj",
",",
"attr",
",",
"attrs",
".",
"get",
"(",
"attr",
")",
")",
"if",
"additional_properties",
":",
"response_obj",
".",
"additional_properties",
"=",
"additional_properties",
"return",
"response_obj",
"except",
"TypeError",
"as",
"err",
":",
"msg",
"=",
"\"Unable to deserialize {} into model {}. \"",
".",
"format",
"(",
"kwargs",
",",
"response",
")",
"raise",
"DeserializationError",
"(",
"msg",
"+",
"str",
"(",
"err",
")",
")",
"else",
":",
"try",
":",
"for",
"attr",
",",
"value",
"in",
"attrs",
".",
"items",
"(",
")",
":",
"setattr",
"(",
"response",
",",
"attr",
",",
"value",
")",
"return",
"response",
"except",
"Exception",
"as",
"exp",
":",
"msg",
"=",
"\"Unable to populate response model. \"",
"msg",
"+=",
"\"Type: {}, Error: {}\"",
".",
"format",
"(",
"type",
"(",
"response",
")",
",",
"exp",
")",
"raise",
"DeserializationError",
"(",
"msg",
")"
] |
Instantiate a response model passing in deserialized args.
:param response: The response model class.
:param d_attrs: The deserialized response attributes.
|
[
"Instantiate",
"a",
"response",
"model",
"passing",
"in",
"deserialized",
"args",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1384-L1417
|
10,867
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_data
|
def deserialize_data(self, data, data_type):
"""Process data for deserialization according to data type.
:param str data: The response string to be deserialized.
:param str data_type: The type to deserialize to.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
"""
if data is None:
return data
try:
if not data_type:
return data
if data_type in self.basic_types.values():
return self.deserialize_basic(data, data_type)
if data_type in self.deserialize_type:
if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
return data
is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
return None
data_val = self.deserialize_type[data_type](data)
return data_val
iter_type = data_type[0] + data_type[-1]
if iter_type in self.deserialize_type:
return self.deserialize_type[iter_type](data, data_type[1:-1])
obj_type = self.dependencies[data_type]
if issubclass(obj_type, Enum):
if isinstance(data, ET.Element):
data = data.text
return self.deserialize_enum(data, obj_type)
except (ValueError, TypeError, AttributeError) as err:
msg = "Unable to deserialize response data."
msg += " Data: {}, {}".format(data, data_type)
raise_with_traceback(DeserializationError, msg, err)
else:
return self._deserialize(obj_type, data)
|
python
|
def deserialize_data(self, data, data_type):
"""Process data for deserialization according to data type.
:param str data: The response string to be deserialized.
:param str data_type: The type to deserialize to.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
"""
if data is None:
return data
try:
if not data_type:
return data
if data_type in self.basic_types.values():
return self.deserialize_basic(data, data_type)
if data_type in self.deserialize_type:
if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
return data
is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
return None
data_val = self.deserialize_type[data_type](data)
return data_val
iter_type = data_type[0] + data_type[-1]
if iter_type in self.deserialize_type:
return self.deserialize_type[iter_type](data, data_type[1:-1])
obj_type = self.dependencies[data_type]
if issubclass(obj_type, Enum):
if isinstance(data, ET.Element):
data = data.text
return self.deserialize_enum(data, obj_type)
except (ValueError, TypeError, AttributeError) as err:
msg = "Unable to deserialize response data."
msg += " Data: {}, {}".format(data, data_type)
raise_with_traceback(DeserializationError, msg, err)
else:
return self._deserialize(obj_type, data)
|
[
"def",
"deserialize_data",
"(",
"self",
",",
"data",
",",
"data_type",
")",
":",
"if",
"data",
"is",
"None",
":",
"return",
"data",
"try",
":",
"if",
"not",
"data_type",
":",
"return",
"data",
"if",
"data_type",
"in",
"self",
".",
"basic_types",
".",
"values",
"(",
")",
":",
"return",
"self",
".",
"deserialize_basic",
"(",
"data",
",",
"data_type",
")",
"if",
"data_type",
"in",
"self",
".",
"deserialize_type",
":",
"if",
"isinstance",
"(",
"data",
",",
"self",
".",
"deserialize_expected_types",
".",
"get",
"(",
"data_type",
",",
"tuple",
"(",
")",
")",
")",
":",
"return",
"data",
"is_a_text_parsing_type",
"=",
"lambda",
"x",
":",
"x",
"not",
"in",
"[",
"\"object\"",
",",
"\"[]\"",
",",
"r\"{}\"",
"]",
"if",
"isinstance",
"(",
"data",
",",
"ET",
".",
"Element",
")",
"and",
"is_a_text_parsing_type",
"(",
"data_type",
")",
"and",
"not",
"data",
".",
"text",
":",
"return",
"None",
"data_val",
"=",
"self",
".",
"deserialize_type",
"[",
"data_type",
"]",
"(",
"data",
")",
"return",
"data_val",
"iter_type",
"=",
"data_type",
"[",
"0",
"]",
"+",
"data_type",
"[",
"-",
"1",
"]",
"if",
"iter_type",
"in",
"self",
".",
"deserialize_type",
":",
"return",
"self",
".",
"deserialize_type",
"[",
"iter_type",
"]",
"(",
"data",
",",
"data_type",
"[",
"1",
":",
"-",
"1",
"]",
")",
"obj_type",
"=",
"self",
".",
"dependencies",
"[",
"data_type",
"]",
"if",
"issubclass",
"(",
"obj_type",
",",
"Enum",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"ET",
".",
"Element",
")",
":",
"data",
"=",
"data",
".",
"text",
"return",
"self",
".",
"deserialize_enum",
"(",
"data",
",",
"obj_type",
")",
"except",
"(",
"ValueError",
",",
"TypeError",
",",
"AttributeError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Unable to deserialize response data.\"",
"msg",
"+=",
"\" Data: {}, {}\"",
".",
"format",
"(",
"data",
",",
"data_type",
")",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")",
"else",
":",
"return",
"self",
".",
"_deserialize",
"(",
"obj_type",
",",
"data",
")"
] |
Process data for deserialization according to data type.
:param str data: The response string to be deserialized.
:param str data_type: The type to deserialize to.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
|
[
"Process",
"data",
"for",
"deserialization",
"according",
"to",
"data",
"type",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1419-L1460
|
10,868
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_iter
|
def deserialize_iter(self, attr, iter_type):
"""Deserialize an iterable.
:param list attr: Iterable to be deserialized.
:param str iter_type: The type of object in the iterable.
:rtype: list
"""
if attr is None:
return None
if isinstance(attr, ET.Element): # If I receive an element here, get the children
attr = list(attr)
if not isinstance(attr, (list, set)):
raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(
iter_type,
type(attr)
))
return [self.deserialize_data(a, iter_type) for a in attr]
|
python
|
def deserialize_iter(self, attr, iter_type):
"""Deserialize an iterable.
:param list attr: Iterable to be deserialized.
:param str iter_type: The type of object in the iterable.
:rtype: list
"""
if attr is None:
return None
if isinstance(attr, ET.Element): # If I receive an element here, get the children
attr = list(attr)
if not isinstance(attr, (list, set)):
raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(
iter_type,
type(attr)
))
return [self.deserialize_data(a, iter_type) for a in attr]
|
[
"def",
"deserialize_iter",
"(",
"self",
",",
"attr",
",",
"iter_type",
")",
":",
"if",
"attr",
"is",
"None",
":",
"return",
"None",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"# If I receive an element here, get the children",
"attr",
"=",
"list",
"(",
"attr",
")",
"if",
"not",
"isinstance",
"(",
"attr",
",",
"(",
"list",
",",
"set",
")",
")",
":",
"raise",
"DeserializationError",
"(",
"\"Cannot deserialize as [{}] an object of type {}\"",
".",
"format",
"(",
"iter_type",
",",
"type",
"(",
"attr",
")",
")",
")",
"return",
"[",
"self",
".",
"deserialize_data",
"(",
"a",
",",
"iter_type",
")",
"for",
"a",
"in",
"attr",
"]"
] |
Deserialize an iterable.
:param list attr: Iterable to be deserialized.
:param str iter_type: The type of object in the iterable.
:rtype: list
|
[
"Deserialize",
"an",
"iterable",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1462-L1478
|
10,869
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_dict
|
def deserialize_dict(self, attr, dict_type):
"""Deserialize a dictionary.
:param dict/list attr: Dictionary to be deserialized. Also accepts
a list of key, value pairs.
:param str dict_type: The object type of the items in the dictionary.
:rtype: dict
"""
if isinstance(attr, list):
return {x['key']: self.deserialize_data(x['value'], dict_type) for x in attr}
if isinstance(attr, ET.Element):
# Transform <Key>value</Key> into {"Key": "value"}
attr = {el.tag: el.text for el in attr}
return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
|
python
|
def deserialize_dict(self, attr, dict_type):
"""Deserialize a dictionary.
:param dict/list attr: Dictionary to be deserialized. Also accepts
a list of key, value pairs.
:param str dict_type: The object type of the items in the dictionary.
:rtype: dict
"""
if isinstance(attr, list):
return {x['key']: self.deserialize_data(x['value'], dict_type) for x in attr}
if isinstance(attr, ET.Element):
# Transform <Key>value</Key> into {"Key": "value"}
attr = {el.tag: el.text for el in attr}
return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
|
[
"def",
"deserialize_dict",
"(",
"self",
",",
"attr",
",",
"dict_type",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"list",
")",
":",
"return",
"{",
"x",
"[",
"'key'",
"]",
":",
"self",
".",
"deserialize_data",
"(",
"x",
"[",
"'value'",
"]",
",",
"dict_type",
")",
"for",
"x",
"in",
"attr",
"}",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"# Transform <Key>value</Key> into {\"Key\": \"value\"}",
"attr",
"=",
"{",
"el",
".",
"tag",
":",
"el",
".",
"text",
"for",
"el",
"in",
"attr",
"}",
"return",
"{",
"k",
":",
"self",
".",
"deserialize_data",
"(",
"v",
",",
"dict_type",
")",
"for",
"k",
",",
"v",
"in",
"attr",
".",
"items",
"(",
")",
"}"
] |
Deserialize a dictionary.
:param dict/list attr: Dictionary to be deserialized. Also accepts
a list of key, value pairs.
:param str dict_type: The object type of the items in the dictionary.
:rtype: dict
|
[
"Deserialize",
"a",
"dictionary",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1480-L1494
|
10,870
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_object
|
def deserialize_object(self, attr, **kwargs):
"""Deserialize a generic object.
This will be handled as a dictionary.
:param dict attr: Dictionary to be deserialized.
:rtype: dict
:raises: TypeError if non-builtin datatype encountered.
"""
if attr is None:
return None
if isinstance(attr, ET.Element):
# Do no recurse on XML, just return the tree as-is
return attr
if isinstance(attr, basestring):
return self.deserialize_basic(attr, 'str')
obj_type = type(attr)
if obj_type in self.basic_types:
return self.deserialize_basic(attr, self.basic_types[obj_type])
if obj_type is _long_type:
return self.deserialize_long(attr)
if obj_type == dict:
deserialized = {}
for key, value in attr.items():
try:
deserialized[key] = self.deserialize_object(
value, **kwargs)
except ValueError:
deserialized[key] = None
return deserialized
if obj_type == list:
deserialized = []
for obj in attr:
try:
deserialized.append(self.deserialize_object(
obj, **kwargs))
except ValueError:
pass
return deserialized
else:
error = "Cannot deserialize generic object with type: "
raise TypeError(error + str(obj_type))
|
python
|
def deserialize_object(self, attr, **kwargs):
"""Deserialize a generic object.
This will be handled as a dictionary.
:param dict attr: Dictionary to be deserialized.
:rtype: dict
:raises: TypeError if non-builtin datatype encountered.
"""
if attr is None:
return None
if isinstance(attr, ET.Element):
# Do no recurse on XML, just return the tree as-is
return attr
if isinstance(attr, basestring):
return self.deserialize_basic(attr, 'str')
obj_type = type(attr)
if obj_type in self.basic_types:
return self.deserialize_basic(attr, self.basic_types[obj_type])
if obj_type is _long_type:
return self.deserialize_long(attr)
if obj_type == dict:
deserialized = {}
for key, value in attr.items():
try:
deserialized[key] = self.deserialize_object(
value, **kwargs)
except ValueError:
deserialized[key] = None
return deserialized
if obj_type == list:
deserialized = []
for obj in attr:
try:
deserialized.append(self.deserialize_object(
obj, **kwargs))
except ValueError:
pass
return deserialized
else:
error = "Cannot deserialize generic object with type: "
raise TypeError(error + str(obj_type))
|
[
"def",
"deserialize_object",
"(",
"self",
",",
"attr",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"attr",
"is",
"None",
":",
"return",
"None",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"# Do no recurse on XML, just return the tree as-is",
"return",
"attr",
"if",
"isinstance",
"(",
"attr",
",",
"basestring",
")",
":",
"return",
"self",
".",
"deserialize_basic",
"(",
"attr",
",",
"'str'",
")",
"obj_type",
"=",
"type",
"(",
"attr",
")",
"if",
"obj_type",
"in",
"self",
".",
"basic_types",
":",
"return",
"self",
".",
"deserialize_basic",
"(",
"attr",
",",
"self",
".",
"basic_types",
"[",
"obj_type",
"]",
")",
"if",
"obj_type",
"is",
"_long_type",
":",
"return",
"self",
".",
"deserialize_long",
"(",
"attr",
")",
"if",
"obj_type",
"==",
"dict",
":",
"deserialized",
"=",
"{",
"}",
"for",
"key",
",",
"value",
"in",
"attr",
".",
"items",
"(",
")",
":",
"try",
":",
"deserialized",
"[",
"key",
"]",
"=",
"self",
".",
"deserialize_object",
"(",
"value",
",",
"*",
"*",
"kwargs",
")",
"except",
"ValueError",
":",
"deserialized",
"[",
"key",
"]",
"=",
"None",
"return",
"deserialized",
"if",
"obj_type",
"==",
"list",
":",
"deserialized",
"=",
"[",
"]",
"for",
"obj",
"in",
"attr",
":",
"try",
":",
"deserialized",
".",
"append",
"(",
"self",
".",
"deserialize_object",
"(",
"obj",
",",
"*",
"*",
"kwargs",
")",
")",
"except",
"ValueError",
":",
"pass",
"return",
"deserialized",
"else",
":",
"error",
"=",
"\"Cannot deserialize generic object with type: \"",
"raise",
"TypeError",
"(",
"error",
"+",
"str",
"(",
"obj_type",
")",
")"
] |
Deserialize a generic object.
This will be handled as a dictionary.
:param dict attr: Dictionary to be deserialized.
:rtype: dict
:raises: TypeError if non-builtin datatype encountered.
|
[
"Deserialize",
"a",
"generic",
"object",
".",
"This",
"will",
"be",
"handled",
"as",
"a",
"dictionary",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1496-L1539
|
10,871
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_basic
|
def deserialize_basic(self, attr, data_type):
"""Deserialize baisc builtin data type from string.
Will attempt to convert to str, int, float and bool.
This function will also accept '1', '0', 'true' and 'false' as
valid bool values.
:param str attr: response string to be deserialized.
:param str data_type: deserialization data type.
:rtype: str, int, float or bool
:raises: TypeError if string format is not valid.
"""
# If we're here, data is supposed to be a basic type.
# If it's still an XML node, take the text
if isinstance(attr, ET.Element):
attr = attr.text
if not attr:
if data_type == "str":
# None or '', node <a/> is empty string.
return ''
else:
# None or '', node <a/> with a strong type is None.
# Don't try to model "empty bool" or "empty int"
return None
if data_type == 'bool':
if attr in [True, False, 1, 0]:
return bool(attr)
elif isinstance(attr, basestring):
if attr.lower() in ['true', '1']:
return True
elif attr.lower() in ['false', '0']:
return False
raise TypeError("Invalid boolean value: {}".format(attr))
if data_type == 'str':
return self.deserialize_unicode(attr)
return eval(data_type)(attr)
|
python
|
def deserialize_basic(self, attr, data_type):
"""Deserialize baisc builtin data type from string.
Will attempt to convert to str, int, float and bool.
This function will also accept '1', '0', 'true' and 'false' as
valid bool values.
:param str attr: response string to be deserialized.
:param str data_type: deserialization data type.
:rtype: str, int, float or bool
:raises: TypeError if string format is not valid.
"""
# If we're here, data is supposed to be a basic type.
# If it's still an XML node, take the text
if isinstance(attr, ET.Element):
attr = attr.text
if not attr:
if data_type == "str":
# None or '', node <a/> is empty string.
return ''
else:
# None or '', node <a/> with a strong type is None.
# Don't try to model "empty bool" or "empty int"
return None
if data_type == 'bool':
if attr in [True, False, 1, 0]:
return bool(attr)
elif isinstance(attr, basestring):
if attr.lower() in ['true', '1']:
return True
elif attr.lower() in ['false', '0']:
return False
raise TypeError("Invalid boolean value: {}".format(attr))
if data_type == 'str':
return self.deserialize_unicode(attr)
return eval(data_type)(attr)
|
[
"def",
"deserialize_basic",
"(",
"self",
",",
"attr",
",",
"data_type",
")",
":",
"# If we're here, data is supposed to be a basic type.",
"# If it's still an XML node, take the text",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"if",
"not",
"attr",
":",
"if",
"data_type",
"==",
"\"str\"",
":",
"# None or '', node <a/> is empty string.",
"return",
"''",
"else",
":",
"# None or '', node <a/> with a strong type is None.",
"# Don't try to model \"empty bool\" or \"empty int\"",
"return",
"None",
"if",
"data_type",
"==",
"'bool'",
":",
"if",
"attr",
"in",
"[",
"True",
",",
"False",
",",
"1",
",",
"0",
"]",
":",
"return",
"bool",
"(",
"attr",
")",
"elif",
"isinstance",
"(",
"attr",
",",
"basestring",
")",
":",
"if",
"attr",
".",
"lower",
"(",
")",
"in",
"[",
"'true'",
",",
"'1'",
"]",
":",
"return",
"True",
"elif",
"attr",
".",
"lower",
"(",
")",
"in",
"[",
"'false'",
",",
"'0'",
"]",
":",
"return",
"False",
"raise",
"TypeError",
"(",
"\"Invalid boolean value: {}\"",
".",
"format",
"(",
"attr",
")",
")",
"if",
"data_type",
"==",
"'str'",
":",
"return",
"self",
".",
"deserialize_unicode",
"(",
"attr",
")",
"return",
"eval",
"(",
"data_type",
")",
"(",
"attr",
")"
] |
Deserialize baisc builtin data type from string.
Will attempt to convert to str, int, float and bool.
This function will also accept '1', '0', 'true' and 'false' as
valid bool values.
:param str attr: response string to be deserialized.
:param str data_type: deserialization data type.
:rtype: str, int, float or bool
:raises: TypeError if string format is not valid.
|
[
"Deserialize",
"baisc",
"builtin",
"data",
"type",
"from",
"string",
".",
"Will",
"attempt",
"to",
"convert",
"to",
"str",
"int",
"float",
"and",
"bool",
".",
"This",
"function",
"will",
"also",
"accept",
"1",
"0",
"true",
"and",
"false",
"as",
"valid",
"bool",
"values",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1541-L1577
|
10,872
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_unicode
|
def deserialize_unicode(data):
"""Preserve unicode objects in Python 2, otherwise return data
as a string.
:param str data: response string to be deserialized.
:rtype: str or unicode
"""
# We might be here because we have an enum modeled as string,
# and we try to deserialize a partial dict with enum inside
if isinstance(data, Enum):
return data
# Consider this is real string
try:
if isinstance(data, unicode):
return data
except NameError:
return str(data)
else:
return str(data)
|
python
|
def deserialize_unicode(data):
"""Preserve unicode objects in Python 2, otherwise return data
as a string.
:param str data: response string to be deserialized.
:rtype: str or unicode
"""
# We might be here because we have an enum modeled as string,
# and we try to deserialize a partial dict with enum inside
if isinstance(data, Enum):
return data
# Consider this is real string
try:
if isinstance(data, unicode):
return data
except NameError:
return str(data)
else:
return str(data)
|
[
"def",
"deserialize_unicode",
"(",
"data",
")",
":",
"# We might be here because we have an enum modeled as string,",
"# and we try to deserialize a partial dict with enum inside",
"if",
"isinstance",
"(",
"data",
",",
"Enum",
")",
":",
"return",
"data",
"# Consider this is real string",
"try",
":",
"if",
"isinstance",
"(",
"data",
",",
"unicode",
")",
":",
"return",
"data",
"except",
"NameError",
":",
"return",
"str",
"(",
"data",
")",
"else",
":",
"return",
"str",
"(",
"data",
")"
] |
Preserve unicode objects in Python 2, otherwise return data
as a string.
:param str data: response string to be deserialized.
:rtype: str or unicode
|
[
"Preserve",
"unicode",
"objects",
"in",
"Python",
"2",
"otherwise",
"return",
"data",
"as",
"a",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1580-L1599
|
10,873
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_enum
|
def deserialize_enum(data, enum_obj):
"""Deserialize string into enum object.
:param str data: response string to be deserialized.
:param Enum enum_obj: Enum object to deserialize to.
:rtype: Enum
:raises: DeserializationError if string is not valid enum value.
"""
if isinstance(data, enum_obj):
return data
if isinstance(data, Enum):
data = data.value
if isinstance(data, int):
# Workaround. We might consider remove it in the future.
# https://github.com/Azure/azure-rest-api-specs/issues/141
try:
return list(enum_obj.__members__.values())[data]
except IndexError:
error = "{!r} is not a valid index for enum {!r}"
raise DeserializationError(error.format(data, enum_obj))
try:
return enum_obj(str(data))
except ValueError:
for enum_value in enum_obj:
if enum_value.value.lower() == str(data).lower():
return enum_value
# We don't fail anymore for unknown value, we deserialize as a string
_LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj)
return Deserializer.deserialize_unicode(data)
|
python
|
def deserialize_enum(data, enum_obj):
"""Deserialize string into enum object.
:param str data: response string to be deserialized.
:param Enum enum_obj: Enum object to deserialize to.
:rtype: Enum
:raises: DeserializationError if string is not valid enum value.
"""
if isinstance(data, enum_obj):
return data
if isinstance(data, Enum):
data = data.value
if isinstance(data, int):
# Workaround. We might consider remove it in the future.
# https://github.com/Azure/azure-rest-api-specs/issues/141
try:
return list(enum_obj.__members__.values())[data]
except IndexError:
error = "{!r} is not a valid index for enum {!r}"
raise DeserializationError(error.format(data, enum_obj))
try:
return enum_obj(str(data))
except ValueError:
for enum_value in enum_obj:
if enum_value.value.lower() == str(data).lower():
return enum_value
# We don't fail anymore for unknown value, we deserialize as a string
_LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj)
return Deserializer.deserialize_unicode(data)
|
[
"def",
"deserialize_enum",
"(",
"data",
",",
"enum_obj",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"enum_obj",
")",
":",
"return",
"data",
"if",
"isinstance",
"(",
"data",
",",
"Enum",
")",
":",
"data",
"=",
"data",
".",
"value",
"if",
"isinstance",
"(",
"data",
",",
"int",
")",
":",
"# Workaround. We might consider remove it in the future.",
"# https://github.com/Azure/azure-rest-api-specs/issues/141",
"try",
":",
"return",
"list",
"(",
"enum_obj",
".",
"__members__",
".",
"values",
"(",
")",
")",
"[",
"data",
"]",
"except",
"IndexError",
":",
"error",
"=",
"\"{!r} is not a valid index for enum {!r}\"",
"raise",
"DeserializationError",
"(",
"error",
".",
"format",
"(",
"data",
",",
"enum_obj",
")",
")",
"try",
":",
"return",
"enum_obj",
"(",
"str",
"(",
"data",
")",
")",
"except",
"ValueError",
":",
"for",
"enum_value",
"in",
"enum_obj",
":",
"if",
"enum_value",
".",
"value",
".",
"lower",
"(",
")",
"==",
"str",
"(",
"data",
")",
".",
"lower",
"(",
")",
":",
"return",
"enum_value",
"# We don't fail anymore for unknown value, we deserialize as a string",
"_LOGGER",
".",
"warning",
"(",
"\"Deserializer is not able to find %s as valid enum in %s\"",
",",
"data",
",",
"enum_obj",
")",
"return",
"Deserializer",
".",
"deserialize_unicode",
"(",
"data",
")"
] |
Deserialize string into enum object.
:param str data: response string to be deserialized.
:param Enum enum_obj: Enum object to deserialize to.
:rtype: Enum
:raises: DeserializationError if string is not valid enum value.
|
[
"Deserialize",
"string",
"into",
"enum",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1602-L1630
|
10,874
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_bytearray
|
def deserialize_bytearray(attr):
"""Deserialize string into bytearray.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
return bytearray(b64decode(attr))
|
python
|
def deserialize_bytearray(attr):
"""Deserialize string into bytearray.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
return bytearray(b64decode(attr))
|
[
"def",
"deserialize_bytearray",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"return",
"bytearray",
"(",
"b64decode",
"(",
"attr",
")",
")"
] |
Deserialize string into bytearray.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
|
[
"Deserialize",
"string",
"into",
"bytearray",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1633-L1642
|
10,875
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_base64
|
def deserialize_base64(attr):
"""Deserialize base64 encoded string into string.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
padding = '=' * (3 - (len(attr) + 3) % 4)
attr = attr + padding
encoded = attr.replace('-', '+').replace('_', '/')
return b64decode(encoded)
|
python
|
def deserialize_base64(attr):
"""Deserialize base64 encoded string into string.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
padding = '=' * (3 - (len(attr) + 3) % 4)
attr = attr + padding
encoded = attr.replace('-', '+').replace('_', '/')
return b64decode(encoded)
|
[
"def",
"deserialize_base64",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"padding",
"=",
"'='",
"*",
"(",
"3",
"-",
"(",
"len",
"(",
"attr",
")",
"+",
"3",
")",
"%",
"4",
")",
"attr",
"=",
"attr",
"+",
"padding",
"encoded",
"=",
"attr",
".",
"replace",
"(",
"'-'",
",",
"'+'",
")",
".",
"replace",
"(",
"'_'",
",",
"'/'",
")",
"return",
"b64decode",
"(",
"encoded",
")"
] |
Deserialize base64 encoded string into string.
:param str attr: response string to be deserialized.
:rtype: bytearray
:raises: TypeError if string format invalid.
|
[
"Deserialize",
"base64",
"encoded",
"string",
"into",
"string",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1645-L1657
|
10,876
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_decimal
|
def deserialize_decimal(attr):
"""Deserialize string into Decimal object.
:param str attr: response string to be deserialized.
:rtype: Decimal
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
return decimal.Decimal(attr)
except decimal.DecimalException as err:
msg = "Invalid decimal {}".format(attr)
raise_with_traceback(DeserializationError, msg, err)
|
python
|
def deserialize_decimal(attr):
"""Deserialize string into Decimal object.
:param str attr: response string to be deserialized.
:rtype: Decimal
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
return decimal.Decimal(attr)
except decimal.DecimalException as err:
msg = "Invalid decimal {}".format(attr)
raise_with_traceback(DeserializationError, msg, err)
|
[
"def",
"deserialize_decimal",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"try",
":",
"return",
"decimal",
".",
"Decimal",
"(",
"attr",
")",
"except",
"decimal",
".",
"DecimalException",
"as",
"err",
":",
"msg",
"=",
"\"Invalid decimal {}\"",
".",
"format",
"(",
"attr",
")",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")"
] |
Deserialize string into Decimal object.
:param str attr: response string to be deserialized.
:rtype: Decimal
:raises: DeserializationError if string format invalid.
|
[
"Deserialize",
"string",
"into",
"Decimal",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1660-L1673
|
10,877
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_duration
|
def deserialize_duration(attr):
"""Deserialize ISO-8601 formatted string into TimeDelta object.
:param str attr: response string to be deserialized.
:rtype: TimeDelta
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
duration = isodate.parse_duration(attr)
except(ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize duration object."
raise_with_traceback(DeserializationError, msg, err)
else:
return duration
|
python
|
def deserialize_duration(attr):
"""Deserialize ISO-8601 formatted string into TimeDelta object.
:param str attr: response string to be deserialized.
:rtype: TimeDelta
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
duration = isodate.parse_duration(attr)
except(ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize duration object."
raise_with_traceback(DeserializationError, msg, err)
else:
return duration
|
[
"def",
"deserialize_duration",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"try",
":",
"duration",
"=",
"isodate",
".",
"parse_duration",
"(",
"attr",
")",
"except",
"(",
"ValueError",
",",
"OverflowError",
",",
"AttributeError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Cannot deserialize duration object.\"",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")",
"else",
":",
"return",
"duration"
] |
Deserialize ISO-8601 formatted string into TimeDelta object.
:param str attr: response string to be deserialized.
:rtype: TimeDelta
:raises: DeserializationError if string format invalid.
|
[
"Deserialize",
"ISO",
"-",
"8601",
"formatted",
"string",
"into",
"TimeDelta",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1688-L1703
|
10,878
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_date
|
def deserialize_date(attr):
"""Deserialize ISO-8601 formatted string into Date object.
:param str attr: response string to be deserialized.
:rtype: Date
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
if re.search(r"[^\W\d_]", attr, re.I + re.U):
raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
# This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
|
python
|
def deserialize_date(attr):
"""Deserialize ISO-8601 formatted string into Date object.
:param str attr: response string to be deserialized.
:rtype: Date
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
if re.search(r"[^\W\d_]", attr, re.I + re.U):
raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
# This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
|
[
"def",
"deserialize_date",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"if",
"re",
".",
"search",
"(",
"r\"[^\\W\\d_]\"",
",",
"attr",
",",
"re",
".",
"I",
"+",
"re",
".",
"U",
")",
":",
"raise",
"DeserializationError",
"(",
"\"Date must have only digits and -. Received: %s\"",
"%",
"attr",
")",
"# This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.",
"return",
"isodate",
".",
"parse_date",
"(",
"attr",
",",
"defaultmonth",
"=",
"None",
",",
"defaultday",
"=",
"None",
")"
] |
Deserialize ISO-8601 formatted string into Date object.
:param str attr: response string to be deserialized.
:rtype: Date
:raises: DeserializationError if string format invalid.
|
[
"Deserialize",
"ISO",
"-",
"8601",
"formatted",
"string",
"into",
"Date",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1706-L1718
|
10,879
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_rfc
|
def deserialize_rfc(attr):
"""Deserialize RFC-1123 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
date_obj = datetime.datetime.strptime(
attr, "%a, %d %b %Y %H:%M:%S %Z")
if not date_obj.tzinfo:
date_obj = date_obj.replace(tzinfo=TZ_UTC)
except ValueError as err:
msg = "Cannot deserialize to rfc datetime object."
raise_with_traceback(DeserializationError, msg, err)
else:
return date_obj
|
python
|
def deserialize_rfc(attr):
"""Deserialize RFC-1123 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
date_obj = datetime.datetime.strptime(
attr, "%a, %d %b %Y %H:%M:%S %Z")
if not date_obj.tzinfo:
date_obj = date_obj.replace(tzinfo=TZ_UTC)
except ValueError as err:
msg = "Cannot deserialize to rfc datetime object."
raise_with_traceback(DeserializationError, msg, err)
else:
return date_obj
|
[
"def",
"deserialize_rfc",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"try",
":",
"date_obj",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"attr",
",",
"\"%a, %d %b %Y %H:%M:%S %Z\"",
")",
"if",
"not",
"date_obj",
".",
"tzinfo",
":",
"date_obj",
"=",
"date_obj",
".",
"replace",
"(",
"tzinfo",
"=",
"TZ_UTC",
")",
"except",
"ValueError",
"as",
"err",
":",
"msg",
"=",
"\"Cannot deserialize to rfc datetime object.\"",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")",
"else",
":",
"return",
"date_obj"
] |
Deserialize RFC-1123 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
|
[
"Deserialize",
"RFC",
"-",
"1123",
"formatted",
"string",
"into",
"Datetime",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1721-L1739
|
10,880
|
Azure/msrest-for-python
|
msrest/serialization.py
|
Deserializer.deserialize_iso
|
def deserialize_iso(attr):
"""Deserialize ISO-8601 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
attr = attr.upper()
match = Deserializer.valid_date.match(attr)
if not match:
raise ValueError("Invalid datetime string: " + attr)
check_decimal = attr.split('.')
if len(check_decimal) > 1:
decimal_str = ""
for digit in check_decimal[1]:
if digit.isdigit():
decimal_str += digit
else:
break
if len(decimal_str) > 6:
attr = attr.replace(decimal_str, decimal_str[0:6])
date_obj = isodate.parse_datetime(attr)
test_utc = date_obj.utctimetuple()
if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
raise OverflowError("Hit max or min date")
except(ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize datetime object."
raise_with_traceback(DeserializationError, msg, err)
else:
return date_obj
|
python
|
def deserialize_iso(attr):
"""Deserialize ISO-8601 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
attr = attr.upper()
match = Deserializer.valid_date.match(attr)
if not match:
raise ValueError("Invalid datetime string: " + attr)
check_decimal = attr.split('.')
if len(check_decimal) > 1:
decimal_str = ""
for digit in check_decimal[1]:
if digit.isdigit():
decimal_str += digit
else:
break
if len(decimal_str) > 6:
attr = attr.replace(decimal_str, decimal_str[0:6])
date_obj = isodate.parse_datetime(attr)
test_utc = date_obj.utctimetuple()
if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
raise OverflowError("Hit max or min date")
except(ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize datetime object."
raise_with_traceback(DeserializationError, msg, err)
else:
return date_obj
|
[
"def",
"deserialize_iso",
"(",
"attr",
")",
":",
"if",
"isinstance",
"(",
"attr",
",",
"ET",
".",
"Element",
")",
":",
"attr",
"=",
"attr",
".",
"text",
"try",
":",
"attr",
"=",
"attr",
".",
"upper",
"(",
")",
"match",
"=",
"Deserializer",
".",
"valid_date",
".",
"match",
"(",
"attr",
")",
"if",
"not",
"match",
":",
"raise",
"ValueError",
"(",
"\"Invalid datetime string: \"",
"+",
"attr",
")",
"check_decimal",
"=",
"attr",
".",
"split",
"(",
"'.'",
")",
"if",
"len",
"(",
"check_decimal",
")",
">",
"1",
":",
"decimal_str",
"=",
"\"\"",
"for",
"digit",
"in",
"check_decimal",
"[",
"1",
"]",
":",
"if",
"digit",
".",
"isdigit",
"(",
")",
":",
"decimal_str",
"+=",
"digit",
"else",
":",
"break",
"if",
"len",
"(",
"decimal_str",
")",
">",
"6",
":",
"attr",
"=",
"attr",
".",
"replace",
"(",
"decimal_str",
",",
"decimal_str",
"[",
"0",
":",
"6",
"]",
")",
"date_obj",
"=",
"isodate",
".",
"parse_datetime",
"(",
"attr",
")",
"test_utc",
"=",
"date_obj",
".",
"utctimetuple",
"(",
")",
"if",
"test_utc",
".",
"tm_year",
">",
"9999",
"or",
"test_utc",
".",
"tm_year",
"<",
"1",
":",
"raise",
"OverflowError",
"(",
"\"Hit max or min date\"",
")",
"except",
"(",
"ValueError",
",",
"OverflowError",
",",
"AttributeError",
")",
"as",
"err",
":",
"msg",
"=",
"\"Cannot deserialize datetime object.\"",
"raise_with_traceback",
"(",
"DeserializationError",
",",
"msg",
",",
"err",
")",
"else",
":",
"return",
"date_obj"
] |
Deserialize ISO-8601 formatted string into Datetime object.
:param str attr: response string to be deserialized.
:rtype: Datetime
:raises: DeserializationError if string format invalid.
|
[
"Deserialize",
"ISO",
"-",
"8601",
"formatted",
"string",
"into",
"Datetime",
"object",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/serialization.py#L1742-L1776
|
10,881
|
Azure/msrest-for-python
|
msrest/paging.py
|
Paged.raw
|
def raw(self):
# type: () -> ClientRawResponse
"""Get current page as ClientRawResponse.
:rtype: ClientRawResponse
"""
raw = ClientRawResponse(self.current_page, self._response)
if self._raw_headers:
raw.add_headers(self._raw_headers)
return raw
|
python
|
def raw(self):
# type: () -> ClientRawResponse
"""Get current page as ClientRawResponse.
:rtype: ClientRawResponse
"""
raw = ClientRawResponse(self.current_page, self._response)
if self._raw_headers:
raw.add_headers(self._raw_headers)
return raw
|
[
"def",
"raw",
"(",
"self",
")",
":",
"# type: () -> ClientRawResponse",
"raw",
"=",
"ClientRawResponse",
"(",
"self",
".",
"current_page",
",",
"self",
".",
"_response",
")",
"if",
"self",
".",
"_raw_headers",
":",
"raw",
".",
"add_headers",
"(",
"self",
".",
"_raw_headers",
")",
"return",
"raw"
] |
Get current page as ClientRawResponse.
:rtype: ClientRawResponse
|
[
"Get",
"current",
"page",
"as",
"ClientRawResponse",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/paging.py#L85-L94
|
10,882
|
Azure/msrest-for-python
|
msrest/paging.py
|
Paged.advance_page
|
def advance_page(self):
# type: () -> List[Model]
"""Force moving the cursor to the next azure call.
This method is for advanced usage, iterator protocol is prefered.
:raises: StopIteration if no further page
:return: The current page list
:rtype: list
"""
if self.next_link is None:
raise StopIteration("End of paging")
self._current_page_iter_index = 0
self._response = self._get_next(self.next_link)
self._derserializer(self, self._response)
return self.current_page
|
python
|
def advance_page(self):
# type: () -> List[Model]
"""Force moving the cursor to the next azure call.
This method is for advanced usage, iterator protocol is prefered.
:raises: StopIteration if no further page
:return: The current page list
:rtype: list
"""
if self.next_link is None:
raise StopIteration("End of paging")
self._current_page_iter_index = 0
self._response = self._get_next(self.next_link)
self._derserializer(self, self._response)
return self.current_page
|
[
"def",
"advance_page",
"(",
"self",
")",
":",
"# type: () -> List[Model]",
"if",
"self",
".",
"next_link",
"is",
"None",
":",
"raise",
"StopIteration",
"(",
"\"End of paging\"",
")",
"self",
".",
"_current_page_iter_index",
"=",
"0",
"self",
".",
"_response",
"=",
"self",
".",
"_get_next",
"(",
"self",
".",
"next_link",
")",
"self",
".",
"_derserializer",
"(",
"self",
",",
"self",
".",
"_response",
")",
"return",
"self",
".",
"current_page"
] |
Force moving the cursor to the next azure call.
This method is for advanced usage, iterator protocol is prefered.
:raises: StopIteration if no further page
:return: The current page list
:rtype: list
|
[
"Force",
"moving",
"the",
"cursor",
"to",
"the",
"next",
"azure",
"call",
"."
] |
0732bc90bdb290e5f58c675ffdd7dbfa9acefc93
|
https://github.com/Azure/msrest-for-python/blob/0732bc90bdb290e5f58c675ffdd7dbfa9acefc93/msrest/paging.py#L116-L131
|
10,883
|
soravux/scoop
|
scoop/shared.py
|
_ensureAtomicity
|
def _ensureAtomicity(fn):
"""Ensure atomicity of passed elements on the whole worker pool"""
@ensureScoopStartedProperly
def wrapper(*args, **kwargs):
"""setConst(**kwargs)
Set a constant that will be shared to every workers.
This call blocks until the constant has propagated to at least one
worker.
:param \*\*kwargs: One or more combination(s) key=value. Key being the
variable name and value the object to share.
:returns: None.
Usage: setConst(name=value)
"""
# Note that the docstring is the one of setConst.
# This is because of the documentation framework (sphinx) limitations.
from . import _control
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
for key, value in kwargs.items():
# Object name existence check
if key in itertools.chain(*(elem.keys() for elem in elements.values())):
raise TypeError("This constant already exists: {0}.".format(key))
# Retry element propagation until it is returned
while all(key in elements.get(scoop.worker, []) for key in kwargs.keys()) is not True:
scoop.logger.debug("Sending global variables {0}...".format(
list(kwargs.keys())
))
# Call the function
fn(*args, **kwargs)
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
# TODO: Make previous blocking instead of sleep
time.sleep(0.1)
# Atomicity check
elementNames = list(itertools.chain(*(elem.keys() for elem in elements.values())))
if len(elementNames) != len(set(elementNames)):
raise TypeError("This constant already exists: {0}.".format(key))
return wrapper
|
python
|
def _ensureAtomicity(fn):
"""Ensure atomicity of passed elements on the whole worker pool"""
@ensureScoopStartedProperly
def wrapper(*args, **kwargs):
"""setConst(**kwargs)
Set a constant that will be shared to every workers.
This call blocks until the constant has propagated to at least one
worker.
:param \*\*kwargs: One or more combination(s) key=value. Key being the
variable name and value the object to share.
:returns: None.
Usage: setConst(name=value)
"""
# Note that the docstring is the one of setConst.
# This is because of the documentation framework (sphinx) limitations.
from . import _control
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
for key, value in kwargs.items():
# Object name existence check
if key in itertools.chain(*(elem.keys() for elem in elements.values())):
raise TypeError("This constant already exists: {0}.".format(key))
# Retry element propagation until it is returned
while all(key in elements.get(scoop.worker, []) for key in kwargs.keys()) is not True:
scoop.logger.debug("Sending global variables {0}...".format(
list(kwargs.keys())
))
# Call the function
fn(*args, **kwargs)
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
# TODO: Make previous blocking instead of sleep
time.sleep(0.1)
# Atomicity check
elementNames = list(itertools.chain(*(elem.keys() for elem in elements.values())))
if len(elementNames) != len(set(elementNames)):
raise TypeError("This constant already exists: {0}.".format(key))
return wrapper
|
[
"def",
"_ensureAtomicity",
"(",
"fn",
")",
":",
"@",
"ensureScoopStartedProperly",
"def",
"wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"setConst(**kwargs)\n Set a constant that will be shared to every workers.\n This call blocks until the constant has propagated to at least one\n worker.\n\n :param \\*\\*kwargs: One or more combination(s) key=value. Key being the\n variable name and value the object to share.\n\n :returns: None.\n\n Usage: setConst(name=value)\n \"\"\"",
"# Note that the docstring is the one of setConst.",
"# This is because of the documentation framework (sphinx) limitations.",
"from",
".",
"import",
"_control",
"# Enforce retrieval of currently awaiting constants",
"_control",
".",
"execQueue",
".",
"socket",
".",
"pumpInfoSocket",
"(",
")",
"for",
"key",
",",
"value",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"# Object name existence check",
"if",
"key",
"in",
"itertools",
".",
"chain",
"(",
"*",
"(",
"elem",
".",
"keys",
"(",
")",
"for",
"elem",
"in",
"elements",
".",
"values",
"(",
")",
")",
")",
":",
"raise",
"TypeError",
"(",
"\"This constant already exists: {0}.\"",
".",
"format",
"(",
"key",
")",
")",
"# Retry element propagation until it is returned",
"while",
"all",
"(",
"key",
"in",
"elements",
".",
"get",
"(",
"scoop",
".",
"worker",
",",
"[",
"]",
")",
"for",
"key",
"in",
"kwargs",
".",
"keys",
"(",
")",
")",
"is",
"not",
"True",
":",
"scoop",
".",
"logger",
".",
"debug",
"(",
"\"Sending global variables {0}...\"",
".",
"format",
"(",
"list",
"(",
"kwargs",
".",
"keys",
"(",
")",
")",
")",
")",
"# Call the function",
"fn",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Enforce retrieval of currently awaiting constants",
"_control",
".",
"execQueue",
".",
"socket",
".",
"pumpInfoSocket",
"(",
")",
"# TODO: Make previous blocking instead of sleep",
"time",
".",
"sleep",
"(",
"0.1",
")",
"# Atomicity check",
"elementNames",
"=",
"list",
"(",
"itertools",
".",
"chain",
"(",
"*",
"(",
"elem",
".",
"keys",
"(",
")",
"for",
"elem",
"in",
"elements",
".",
"values",
"(",
")",
")",
")",
")",
"if",
"len",
"(",
"elementNames",
")",
"!=",
"len",
"(",
"set",
"(",
"elementNames",
")",
")",
":",
"raise",
"TypeError",
"(",
"\"This constant already exists: {0}.\"",
".",
"format",
"(",
"key",
")",
")",
"return",
"wrapper"
] |
Ensure atomicity of passed elements on the whole worker pool
|
[
"Ensure",
"atomicity",
"of",
"passed",
"elements",
"on",
"the",
"whole",
"worker",
"pool"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/shared.py#L32-L80
|
10,884
|
soravux/scoop
|
scoop/shared.py
|
getConst
|
def getConst(name, timeout=0.1):
"""Get a shared constant.
:param name: The name of the shared variable to retrieve.
:param timeout: The maximum time to wait in seconds for the propagation of
the constant.
:returns: The shared object.
Usage: value = getConst('name')
"""
from . import _control
import time
timeStamp = time.time()
while True:
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
# Constants concatenation
constants = dict(reduce(
lambda x, y: x + list(y.items()),
elements.values(),
[]
))
timeoutHappened = time.time() - timeStamp > timeout
if constants.get(name) is not None or timeoutHappened:
return constants.get(name)
time.sleep(0.01)
|
python
|
def getConst(name, timeout=0.1):
"""Get a shared constant.
:param name: The name of the shared variable to retrieve.
:param timeout: The maximum time to wait in seconds for the propagation of
the constant.
:returns: The shared object.
Usage: value = getConst('name')
"""
from . import _control
import time
timeStamp = time.time()
while True:
# Enforce retrieval of currently awaiting constants
_control.execQueue.socket.pumpInfoSocket()
# Constants concatenation
constants = dict(reduce(
lambda x, y: x + list(y.items()),
elements.values(),
[]
))
timeoutHappened = time.time() - timeStamp > timeout
if constants.get(name) is not None or timeoutHappened:
return constants.get(name)
time.sleep(0.01)
|
[
"def",
"getConst",
"(",
"name",
",",
"timeout",
"=",
"0.1",
")",
":",
"from",
".",
"import",
"_control",
"import",
"time",
"timeStamp",
"=",
"time",
".",
"time",
"(",
")",
"while",
"True",
":",
"# Enforce retrieval of currently awaiting constants",
"_control",
".",
"execQueue",
".",
"socket",
".",
"pumpInfoSocket",
"(",
")",
"# Constants concatenation",
"constants",
"=",
"dict",
"(",
"reduce",
"(",
"lambda",
"x",
",",
"y",
":",
"x",
"+",
"list",
"(",
"y",
".",
"items",
"(",
")",
")",
",",
"elements",
".",
"values",
"(",
")",
",",
"[",
"]",
")",
")",
"timeoutHappened",
"=",
"time",
".",
"time",
"(",
")",
"-",
"timeStamp",
">",
"timeout",
"if",
"constants",
".",
"get",
"(",
"name",
")",
"is",
"not",
"None",
"or",
"timeoutHappened",
":",
"return",
"constants",
".",
"get",
"(",
"name",
")",
"time",
".",
"sleep",
"(",
"0.01",
")"
] |
Get a shared constant.
:param name: The name of the shared variable to retrieve.
:param timeout: The maximum time to wait in seconds for the propagation of
the constant.
:returns: The shared object.
Usage: value = getConst('name')
|
[
"Get",
"a",
"shared",
"constant",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/shared.py#L109-L137
|
10,885
|
soravux/scoop
|
scoop/launch/__main__.py
|
launchBootstraps
|
def launchBootstraps():
"""Launch the bootstrap instances in separate subprocesses"""
global processes
worker_amount, verbosity, args = getArgs()
was_origin = False
if verbosity >= 1:
sys.stderr.write("Launching {0} worker(s) using {1}.\n".format(
worker_amount,
os.environ['SHELL'] if 'SHELL' in os.environ else "an unknown shell",
)
)
sys.stderr.flush()
processes = []
for _ in range(worker_amount):
command = [sys.executable, "-m", BOOTSTRAP_MODULE] + args
if verbosity >= 3:
sys.stderr.write("Executing '{0}'...\n".format(command))
sys.stderr.flush()
processes.append(Popen(command))
# Only have a single origin
try:
args.remove("--origin")
except ValueError:
pass
else:
was_origin = True
if was_origin:
# Only wait on the origin, this will return and notify the launcher
# the the job has finished and start the cleanup phase
try:
processes[0].wait()
except KeyboardInterrupt:
pass
else:
for p in processes:
p.wait()
|
python
|
def launchBootstraps():
"""Launch the bootstrap instances in separate subprocesses"""
global processes
worker_amount, verbosity, args = getArgs()
was_origin = False
if verbosity >= 1:
sys.stderr.write("Launching {0} worker(s) using {1}.\n".format(
worker_amount,
os.environ['SHELL'] if 'SHELL' in os.environ else "an unknown shell",
)
)
sys.stderr.flush()
processes = []
for _ in range(worker_amount):
command = [sys.executable, "-m", BOOTSTRAP_MODULE] + args
if verbosity >= 3:
sys.stderr.write("Executing '{0}'...\n".format(command))
sys.stderr.flush()
processes.append(Popen(command))
# Only have a single origin
try:
args.remove("--origin")
except ValueError:
pass
else:
was_origin = True
if was_origin:
# Only wait on the origin, this will return and notify the launcher
# the the job has finished and start the cleanup phase
try:
processes[0].wait()
except KeyboardInterrupt:
pass
else:
for p in processes:
p.wait()
|
[
"def",
"launchBootstraps",
"(",
")",
":",
"global",
"processes",
"worker_amount",
",",
"verbosity",
",",
"args",
"=",
"getArgs",
"(",
")",
"was_origin",
"=",
"False",
"if",
"verbosity",
">=",
"1",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"Launching {0} worker(s) using {1}.\\n\"",
".",
"format",
"(",
"worker_amount",
",",
"os",
".",
"environ",
"[",
"'SHELL'",
"]",
"if",
"'SHELL'",
"in",
"os",
".",
"environ",
"else",
"\"an unknown shell\"",
",",
")",
")",
"sys",
".",
"stderr",
".",
"flush",
"(",
")",
"processes",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"worker_amount",
")",
":",
"command",
"=",
"[",
"sys",
".",
"executable",
",",
"\"-m\"",
",",
"BOOTSTRAP_MODULE",
"]",
"+",
"args",
"if",
"verbosity",
">=",
"3",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"Executing '{0}'...\\n\"",
".",
"format",
"(",
"command",
")",
")",
"sys",
".",
"stderr",
".",
"flush",
"(",
")",
"processes",
".",
"append",
"(",
"Popen",
"(",
"command",
")",
")",
"# Only have a single origin",
"try",
":",
"args",
".",
"remove",
"(",
"\"--origin\"",
")",
"except",
"ValueError",
":",
"pass",
"else",
":",
"was_origin",
"=",
"True",
"if",
"was_origin",
":",
"# Only wait on the origin, this will return and notify the launcher",
"# the the job has finished and start the cleanup phase",
"try",
":",
"processes",
"[",
"0",
"]",
".",
"wait",
"(",
")",
"except",
"KeyboardInterrupt",
":",
"pass",
"else",
":",
"for",
"p",
"in",
"processes",
":",
"p",
".",
"wait",
"(",
")"
] |
Launch the bootstrap instances in separate subprocesses
|
[
"Launch",
"the",
"bootstrap",
"instances",
"in",
"separate",
"subprocesses"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/__main__.py#L66-L105
|
10,886
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
BaseConfigurator.resolve
|
def resolve(self, s):
"""
Resolve strings to objects using standard import and attribute
syntax.
"""
name = s.split('.')
used = name.pop(0)
try:
found = self.importer(used)
for frag in name:
used += '.' + frag
try:
found = getattr(found, frag)
except AttributeError:
self.importer(used)
found = getattr(found, frag)
return found
except ImportError:
e, tb = sys.exc_info()[1:]
v = ValueError('Cannot resolve %r: %s' % (s, e))
v.__cause__, v.__traceback__ = e, tb
raise v
|
python
|
def resolve(self, s):
"""
Resolve strings to objects using standard import and attribute
syntax.
"""
name = s.split('.')
used = name.pop(0)
try:
found = self.importer(used)
for frag in name:
used += '.' + frag
try:
found = getattr(found, frag)
except AttributeError:
self.importer(used)
found = getattr(found, frag)
return found
except ImportError:
e, tb = sys.exc_info()[1:]
v = ValueError('Cannot resolve %r: %s' % (s, e))
v.__cause__, v.__traceback__ = e, tb
raise v
|
[
"def",
"resolve",
"(",
"self",
",",
"s",
")",
":",
"name",
"=",
"s",
".",
"split",
"(",
"'.'",
")",
"used",
"=",
"name",
".",
"pop",
"(",
"0",
")",
"try",
":",
"found",
"=",
"self",
".",
"importer",
"(",
"used",
")",
"for",
"frag",
"in",
"name",
":",
"used",
"+=",
"'.'",
"+",
"frag",
"try",
":",
"found",
"=",
"getattr",
"(",
"found",
",",
"frag",
")",
"except",
"AttributeError",
":",
"self",
".",
"importer",
"(",
"used",
")",
"found",
"=",
"getattr",
"(",
"found",
",",
"frag",
")",
"return",
"found",
"except",
"ImportError",
":",
"e",
",",
"tb",
"=",
"sys",
".",
"exc_info",
"(",
")",
"[",
"1",
":",
"]",
"v",
"=",
"ValueError",
"(",
"'Cannot resolve %r: %s'",
"%",
"(",
"s",
",",
"e",
")",
")",
"v",
".",
"__cause__",
",",
"v",
".",
"__traceback__",
"=",
"e",
",",
"tb",
"raise",
"v"
] |
Resolve strings to objects using standard import and attribute
syntax.
|
[
"Resolve",
"strings",
"to",
"objects",
"using",
"standard",
"import",
"and",
"attribute",
"syntax",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L153-L174
|
10,887
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
BaseConfigurator.as_tuple
|
def as_tuple(self, value):
"""Utility function which converts lists to tuples."""
if isinstance(value, list):
value = tuple(value)
return value
|
python
|
def as_tuple(self, value):
"""Utility function which converts lists to tuples."""
if isinstance(value, list):
value = tuple(value)
return value
|
[
"def",
"as_tuple",
"(",
"self",
",",
"value",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"list",
")",
":",
"value",
"=",
"tuple",
"(",
"value",
")",
"return",
"value"
] |
Utility function which converts lists to tuples.
|
[
"Utility",
"function",
"which",
"converts",
"lists",
"to",
"tuples",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L256-L260
|
10,888
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
DictConfigurator.configure_formatter
|
def configure_formatter(self, config):
"""Configure a formatter from a dictionary."""
if '()' in config:
factory = config['()'] # for use in exception handler
try:
result = self.configure_custom(config)
except TypeError, te:
if "'format'" not in str(te):
raise
#Name of parameter changed from fmt to format.
#Retry with old name.
#This is so that code can be used with older Python versions
#(e.g. by Django)
config['fmt'] = config.pop('format')
config['()'] = factory
result = self.configure_custom(config)
else:
fmt = config.get('format', None)
dfmt = config.get('datefmt', None)
result = logging.Formatter(fmt, dfmt)
return result
|
python
|
def configure_formatter(self, config):
"""Configure a formatter from a dictionary."""
if '()' in config:
factory = config['()'] # for use in exception handler
try:
result = self.configure_custom(config)
except TypeError, te:
if "'format'" not in str(te):
raise
#Name of parameter changed from fmt to format.
#Retry with old name.
#This is so that code can be used with older Python versions
#(e.g. by Django)
config['fmt'] = config.pop('format')
config['()'] = factory
result = self.configure_custom(config)
else:
fmt = config.get('format', None)
dfmt = config.get('datefmt', None)
result = logging.Formatter(fmt, dfmt)
return result
|
[
"def",
"configure_formatter",
"(",
"self",
",",
"config",
")",
":",
"if",
"'()'",
"in",
"config",
":",
"factory",
"=",
"config",
"[",
"'()'",
"]",
"# for use in exception handler",
"try",
":",
"result",
"=",
"self",
".",
"configure_custom",
"(",
"config",
")",
"except",
"TypeError",
",",
"te",
":",
"if",
"\"'format'\"",
"not",
"in",
"str",
"(",
"te",
")",
":",
"raise",
"#Name of parameter changed from fmt to format.",
"#Retry with old name.",
"#This is so that code can be used with older Python versions",
"#(e.g. by Django)",
"config",
"[",
"'fmt'",
"]",
"=",
"config",
".",
"pop",
"(",
"'format'",
")",
"config",
"[",
"'()'",
"]",
"=",
"factory",
"result",
"=",
"self",
".",
"configure_custom",
"(",
"config",
")",
"else",
":",
"fmt",
"=",
"config",
".",
"get",
"(",
"'format'",
",",
"None",
")",
"dfmt",
"=",
"config",
".",
"get",
"(",
"'datefmt'",
",",
"None",
")",
"result",
"=",
"logging",
".",
"Formatter",
"(",
"fmt",
",",
"dfmt",
")",
"return",
"result"
] |
Configure a formatter from a dictionary.
|
[
"Configure",
"a",
"formatter",
"from",
"a",
"dictionary",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L414-L434
|
10,889
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
DictConfigurator.configure_filter
|
def configure_filter(self, config):
"""Configure a filter from a dictionary."""
if '()' in config:
result = self.configure_custom(config)
else:
name = config.get('name', '')
result = logging.Filter(name)
return result
|
python
|
def configure_filter(self, config):
"""Configure a filter from a dictionary."""
if '()' in config:
result = self.configure_custom(config)
else:
name = config.get('name', '')
result = logging.Filter(name)
return result
|
[
"def",
"configure_filter",
"(",
"self",
",",
"config",
")",
":",
"if",
"'()'",
"in",
"config",
":",
"result",
"=",
"self",
".",
"configure_custom",
"(",
"config",
")",
"else",
":",
"name",
"=",
"config",
".",
"get",
"(",
"'name'",
",",
"''",
")",
"result",
"=",
"logging",
".",
"Filter",
"(",
"name",
")",
"return",
"result"
] |
Configure a filter from a dictionary.
|
[
"Configure",
"a",
"filter",
"from",
"a",
"dictionary",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L436-L443
|
10,890
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
DictConfigurator.configure_logger
|
def configure_logger(self, name, config, incremental=False):
"""Configure a non-root logger from a dictionary."""
logger = logging.getLogger(name)
self.common_logger_config(logger, config, incremental)
propagate = config.get('propagate', None)
if propagate is not None:
logger.propagate = propagate
|
python
|
def configure_logger(self, name, config, incremental=False):
"""Configure a non-root logger from a dictionary."""
logger = logging.getLogger(name)
self.common_logger_config(logger, config, incremental)
propagate = config.get('propagate', None)
if propagate is not None:
logger.propagate = propagate
|
[
"def",
"configure_logger",
"(",
"self",
",",
"name",
",",
"config",
",",
"incremental",
"=",
"False",
")",
":",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"name",
")",
"self",
".",
"common_logger_config",
"(",
"logger",
",",
"config",
",",
"incremental",
")",
"propagate",
"=",
"config",
".",
"get",
"(",
"'propagate'",
",",
"None",
")",
"if",
"propagate",
"is",
"not",
"None",
":",
"logger",
".",
"propagate",
"=",
"propagate"
] |
Configure a non-root logger from a dictionary.
|
[
"Configure",
"a",
"non",
"-",
"root",
"logger",
"from",
"a",
"dictionary",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L532-L538
|
10,891
|
soravux/scoop
|
scoop/backports/dictconfig.py
|
DictConfigurator.configure_root
|
def configure_root(self, config, incremental=False):
"""Configure a root logger from a dictionary."""
root = logging.getLogger()
self.common_logger_config(root, config, incremental)
|
python
|
def configure_root(self, config, incremental=False):
"""Configure a root logger from a dictionary."""
root = logging.getLogger()
self.common_logger_config(root, config, incremental)
|
[
"def",
"configure_root",
"(",
"self",
",",
"config",
",",
"incremental",
"=",
"False",
")",
":",
"root",
"=",
"logging",
".",
"getLogger",
"(",
")",
"self",
".",
"common_logger_config",
"(",
"root",
",",
"config",
",",
"incremental",
")"
] |
Configure a root logger from a dictionary.
|
[
"Configure",
"a",
"root",
"logger",
"from",
"a",
"dictionary",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/dictconfig.py#L540-L543
|
10,892
|
soravux/scoop
|
examples/image_resize.py
|
sliceImage
|
def sliceImage(image, divWidth, divHeight):
"""Divide the received image in multiple tiles"""
w, h = image.size
tiles = []
for y in range(0, h - 1 , h/divHeight):
my = min(y + h/divHeight, h)
for x in range(0, w - 1, w/divWidth):
mx = min(x + w/divWidth, w)
tiles.append(image.crop((x, y, mx, my)))
return tiles
|
python
|
def sliceImage(image, divWidth, divHeight):
"""Divide the received image in multiple tiles"""
w, h = image.size
tiles = []
for y in range(0, h - 1 , h/divHeight):
my = min(y + h/divHeight, h)
for x in range(0, w - 1, w/divWidth):
mx = min(x + w/divWidth, w)
tiles.append(image.crop((x, y, mx, my)))
return tiles
|
[
"def",
"sliceImage",
"(",
"image",
",",
"divWidth",
",",
"divHeight",
")",
":",
"w",
",",
"h",
"=",
"image",
".",
"size",
"tiles",
"=",
"[",
"]",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"h",
"-",
"1",
",",
"h",
"/",
"divHeight",
")",
":",
"my",
"=",
"min",
"(",
"y",
"+",
"h",
"/",
"divHeight",
",",
"h",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"w",
"-",
"1",
",",
"w",
"/",
"divWidth",
")",
":",
"mx",
"=",
"min",
"(",
"x",
"+",
"w",
"/",
"divWidth",
",",
"w",
")",
"tiles",
".",
"append",
"(",
"image",
".",
"crop",
"(",
"(",
"x",
",",
"y",
",",
"mx",
",",
"my",
")",
")",
")",
"return",
"tiles"
] |
Divide the received image in multiple tiles
|
[
"Divide",
"the",
"received",
"image",
"in",
"multiple",
"tiles"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/image_resize.py#L49-L58
|
10,893
|
soravux/scoop
|
examples/image_resize.py
|
resizeTile
|
def resizeTile(index, size):
"""Apply Antialiasing resizing to tile"""
resized = tiles[index].resize(size, Image.ANTIALIAS)
return sImage(resized.tostring(), resized.size, resized.mode)
|
python
|
def resizeTile(index, size):
"""Apply Antialiasing resizing to tile"""
resized = tiles[index].resize(size, Image.ANTIALIAS)
return sImage(resized.tostring(), resized.size, resized.mode)
|
[
"def",
"resizeTile",
"(",
"index",
",",
"size",
")",
":",
"resized",
"=",
"tiles",
"[",
"index",
"]",
".",
"resize",
"(",
"size",
",",
"Image",
".",
"ANTIALIAS",
")",
"return",
"sImage",
"(",
"resized",
".",
"tostring",
"(",
")",
",",
"resized",
".",
"size",
",",
"resized",
".",
"mode",
")"
] |
Apply Antialiasing resizing to tile
|
[
"Apply",
"Antialiasing",
"resizing",
"to",
"tile"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/image_resize.py#L61-L64
|
10,894
|
soravux/scoop
|
scoop/utils.py
|
initLogging
|
def initLogging(verbosity=0, name="SCOOP"):
"""Creates a logger."""
global loggingConfig
verbose_levels = {
-2: "CRITICAL",
-1: "ERROR",
0: "WARNING",
1: "INFO",
2: "DEBUG",
3: "DEBUG",
4: "NOSET",
}
log_handlers = {
"console":
{
"class": "logging.StreamHandler",
"formatter": "{name}Formatter".format(name=name),
"stream": "ext://sys.stderr",
},
}
loggingConfig.update({
"{name}Logger".format(name=name):
{
"handlers": ["console"],
"level": verbose_levels[verbosity],
},
})
dict_log_config = {
"version": 1,
"handlers": log_handlers,
"loggers": loggingConfig,
"formatters":
{
"{name}Formatter".format(name=name):
{
"format": "[%(asctime)-15s] %(module)-9s "
"%(levelname)-7s %(message)s",
},
},
}
dictConfig(dict_log_config)
return logging.getLogger("{name}Logger".format(name=name))
|
python
|
def initLogging(verbosity=0, name="SCOOP"):
"""Creates a logger."""
global loggingConfig
verbose_levels = {
-2: "CRITICAL",
-1: "ERROR",
0: "WARNING",
1: "INFO",
2: "DEBUG",
3: "DEBUG",
4: "NOSET",
}
log_handlers = {
"console":
{
"class": "logging.StreamHandler",
"formatter": "{name}Formatter".format(name=name),
"stream": "ext://sys.stderr",
},
}
loggingConfig.update({
"{name}Logger".format(name=name):
{
"handlers": ["console"],
"level": verbose_levels[verbosity],
},
})
dict_log_config = {
"version": 1,
"handlers": log_handlers,
"loggers": loggingConfig,
"formatters":
{
"{name}Formatter".format(name=name):
{
"format": "[%(asctime)-15s] %(module)-9s "
"%(levelname)-7s %(message)s",
},
},
}
dictConfig(dict_log_config)
return logging.getLogger("{name}Logger".format(name=name))
|
[
"def",
"initLogging",
"(",
"verbosity",
"=",
"0",
",",
"name",
"=",
"\"SCOOP\"",
")",
":",
"global",
"loggingConfig",
"verbose_levels",
"=",
"{",
"-",
"2",
":",
"\"CRITICAL\"",
",",
"-",
"1",
":",
"\"ERROR\"",
",",
"0",
":",
"\"WARNING\"",
",",
"1",
":",
"\"INFO\"",
",",
"2",
":",
"\"DEBUG\"",
",",
"3",
":",
"\"DEBUG\"",
",",
"4",
":",
"\"NOSET\"",
",",
"}",
"log_handlers",
"=",
"{",
"\"console\"",
":",
"{",
"\"class\"",
":",
"\"logging.StreamHandler\"",
",",
"\"formatter\"",
":",
"\"{name}Formatter\"",
".",
"format",
"(",
"name",
"=",
"name",
")",
",",
"\"stream\"",
":",
"\"ext://sys.stderr\"",
",",
"}",
",",
"}",
"loggingConfig",
".",
"update",
"(",
"{",
"\"{name}Logger\"",
".",
"format",
"(",
"name",
"=",
"name",
")",
":",
"{",
"\"handlers\"",
":",
"[",
"\"console\"",
"]",
",",
"\"level\"",
":",
"verbose_levels",
"[",
"verbosity",
"]",
",",
"}",
",",
"}",
")",
"dict_log_config",
"=",
"{",
"\"version\"",
":",
"1",
",",
"\"handlers\"",
":",
"log_handlers",
",",
"\"loggers\"",
":",
"loggingConfig",
",",
"\"formatters\"",
":",
"{",
"\"{name}Formatter\"",
".",
"format",
"(",
"name",
"=",
"name",
")",
":",
"{",
"\"format\"",
":",
"\"[%(asctime)-15s] %(module)-9s \"",
"\"%(levelname)-7s %(message)s\"",
",",
"}",
",",
"}",
",",
"}",
"dictConfig",
"(",
"dict_log_config",
")",
"return",
"logging",
".",
"getLogger",
"(",
"\"{name}Logger\"",
".",
"format",
"(",
"name",
"=",
"name",
")",
")"
] |
Creates a logger.
|
[
"Creates",
"a",
"logger",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L54-L96
|
10,895
|
soravux/scoop
|
scoop/utils.py
|
externalHostname
|
def externalHostname(hosts):
"""Ensure external hostname is routable."""
hostname = hosts[0][0]
if hostname in localHostnames and len(hosts) > 1:
hostname = socket.getfqdn().split(".")[0]
try:
socket.getaddrinfo(hostname, None)
except socket.gaierror:
raise Exception("\nThe first host (containing a broker) is not"
" routable.\nMake sure the address is correct.")
return hostname
|
python
|
def externalHostname(hosts):
"""Ensure external hostname is routable."""
hostname = hosts[0][0]
if hostname in localHostnames and len(hosts) > 1:
hostname = socket.getfqdn().split(".")[0]
try:
socket.getaddrinfo(hostname, None)
except socket.gaierror:
raise Exception("\nThe first host (containing a broker) is not"
" routable.\nMake sure the address is correct.")
return hostname
|
[
"def",
"externalHostname",
"(",
"hosts",
")",
":",
"hostname",
"=",
"hosts",
"[",
"0",
"]",
"[",
"0",
"]",
"if",
"hostname",
"in",
"localHostnames",
"and",
"len",
"(",
"hosts",
")",
">",
"1",
":",
"hostname",
"=",
"socket",
".",
"getfqdn",
"(",
")",
".",
"split",
"(",
"\".\"",
")",
"[",
"0",
"]",
"try",
":",
"socket",
".",
"getaddrinfo",
"(",
"hostname",
",",
"None",
")",
"except",
"socket",
".",
"gaierror",
":",
"raise",
"Exception",
"(",
"\"\\nThe first host (containing a broker) is not\"",
"\" routable.\\nMake sure the address is correct.\"",
")",
"return",
"hostname"
] |
Ensure external hostname is routable.
|
[
"Ensure",
"external",
"hostname",
"is",
"routable",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L99-L109
|
10,896
|
soravux/scoop
|
scoop/utils.py
|
getHosts
|
def getHosts(filename=None, hostlist=None):
"""Return a list of hosts depending on the environment"""
if filename:
return getHostsFromFile(filename)
elif hostlist:
return getHostsFromList(hostlist)
elif getEnv() == "SLURM":
return getHostsFromSLURM()
elif getEnv() == "PBS":
return getHostsFromPBS()
elif getEnv() == "SGE":
return getHostsFromSGE()
else:
return getDefaultHosts()
|
python
|
def getHosts(filename=None, hostlist=None):
"""Return a list of hosts depending on the environment"""
if filename:
return getHostsFromFile(filename)
elif hostlist:
return getHostsFromList(hostlist)
elif getEnv() == "SLURM":
return getHostsFromSLURM()
elif getEnv() == "PBS":
return getHostsFromPBS()
elif getEnv() == "SGE":
return getHostsFromSGE()
else:
return getDefaultHosts()
|
[
"def",
"getHosts",
"(",
"filename",
"=",
"None",
",",
"hostlist",
"=",
"None",
")",
":",
"if",
"filename",
":",
"return",
"getHostsFromFile",
"(",
"filename",
")",
"elif",
"hostlist",
":",
"return",
"getHostsFromList",
"(",
"hostlist",
")",
"elif",
"getEnv",
"(",
")",
"==",
"\"SLURM\"",
":",
"return",
"getHostsFromSLURM",
"(",
")",
"elif",
"getEnv",
"(",
")",
"==",
"\"PBS\"",
":",
"return",
"getHostsFromPBS",
"(",
")",
"elif",
"getEnv",
"(",
")",
"==",
"\"SGE\"",
":",
"return",
"getHostsFromSGE",
"(",
")",
"else",
":",
"return",
"getDefaultHosts",
"(",
")"
] |
Return a list of hosts depending on the environment
|
[
"Return",
"a",
"list",
"of",
"hosts",
"depending",
"on",
"the",
"environment"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L144-L157
|
10,897
|
soravux/scoop
|
scoop/utils.py
|
getHostsFromFile
|
def getHostsFromFile(filename):
"""Parse a file to return a list of hosts."""
valid_hostname = r"^[^ /\t=\n]+"
workers = r"\d+"
hostname_re = re.compile(valid_hostname)
worker_re = re.compile(workers)
hosts = []
with open(filename) as f:
for line in f:
# check to see if it is a SLURM grouping instead of a
# regular list of hosts
if re.search('[\[\]]', line):
hosts = hosts + parseSLURM(line.strip())
else:
host = hostname_re.search(line.strip())
if host:
hostname = host.group()
n = worker_re.search(line[host.end():])
if n:
n = n.group()
else:
# Automatically assign based on CPU count
n = 0
hosts.append((hostname, int(n)))
return hosts
|
python
|
def getHostsFromFile(filename):
"""Parse a file to return a list of hosts."""
valid_hostname = r"^[^ /\t=\n]+"
workers = r"\d+"
hostname_re = re.compile(valid_hostname)
worker_re = re.compile(workers)
hosts = []
with open(filename) as f:
for line in f:
# check to see if it is a SLURM grouping instead of a
# regular list of hosts
if re.search('[\[\]]', line):
hosts = hosts + parseSLURM(line.strip())
else:
host = hostname_re.search(line.strip())
if host:
hostname = host.group()
n = worker_re.search(line[host.end():])
if n:
n = n.group()
else:
# Automatically assign based on CPU count
n = 0
hosts.append((hostname, int(n)))
return hosts
|
[
"def",
"getHostsFromFile",
"(",
"filename",
")",
":",
"valid_hostname",
"=",
"r\"^[^ /\\t=\\n]+\"",
"workers",
"=",
"r\"\\d+\"",
"hostname_re",
"=",
"re",
".",
"compile",
"(",
"valid_hostname",
")",
"worker_re",
"=",
"re",
".",
"compile",
"(",
"workers",
")",
"hosts",
"=",
"[",
"]",
"with",
"open",
"(",
"filename",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"# check to see if it is a SLURM grouping instead of a",
"# regular list of hosts",
"if",
"re",
".",
"search",
"(",
"'[\\[\\]]'",
",",
"line",
")",
":",
"hosts",
"=",
"hosts",
"+",
"parseSLURM",
"(",
"line",
".",
"strip",
"(",
")",
")",
"else",
":",
"host",
"=",
"hostname_re",
".",
"search",
"(",
"line",
".",
"strip",
"(",
")",
")",
"if",
"host",
":",
"hostname",
"=",
"host",
".",
"group",
"(",
")",
"n",
"=",
"worker_re",
".",
"search",
"(",
"line",
"[",
"host",
".",
"end",
"(",
")",
":",
"]",
")",
"if",
"n",
":",
"n",
"=",
"n",
".",
"group",
"(",
")",
"else",
":",
"# Automatically assign based on CPU count",
"n",
"=",
"0",
"hosts",
".",
"append",
"(",
"(",
"hostname",
",",
"int",
"(",
"n",
")",
")",
")",
"return",
"hosts"
] |
Parse a file to return a list of hosts.
|
[
"Parse",
"a",
"file",
"to",
"return",
"a",
"list",
"of",
"hosts",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L160-L184
|
10,898
|
soravux/scoop
|
scoop/utils.py
|
getHostsFromList
|
def getHostsFromList(hostlist):
"""Return the hosts from the command line"""
# check to see if it is a SLURM grouping instead of a
# regular list of hosts
if any(re.search('[\[\]]', x) for x in hostlist):
return parseSLURM(str(hostlist))
# Counter would be more efficient but:
# 1. Won't be Python 2.6 compatible
# 2. Won't be ordered
hostlist = groupTogether(hostlist)
retVal = []
for key, group in groupby(hostlist):
retVal.append((key, len(list(group))))
return retVal
|
python
|
def getHostsFromList(hostlist):
"""Return the hosts from the command line"""
# check to see if it is a SLURM grouping instead of a
# regular list of hosts
if any(re.search('[\[\]]', x) for x in hostlist):
return parseSLURM(str(hostlist))
# Counter would be more efficient but:
# 1. Won't be Python 2.6 compatible
# 2. Won't be ordered
hostlist = groupTogether(hostlist)
retVal = []
for key, group in groupby(hostlist):
retVal.append((key, len(list(group))))
return retVal
|
[
"def",
"getHostsFromList",
"(",
"hostlist",
")",
":",
"# check to see if it is a SLURM grouping instead of a",
"# regular list of hosts",
"if",
"any",
"(",
"re",
".",
"search",
"(",
"'[\\[\\]]'",
",",
"x",
")",
"for",
"x",
"in",
"hostlist",
")",
":",
"return",
"parseSLURM",
"(",
"str",
"(",
"hostlist",
")",
")",
"# Counter would be more efficient but:",
"# 1. Won't be Python 2.6 compatible",
"# 2. Won't be ordered",
"hostlist",
"=",
"groupTogether",
"(",
"hostlist",
")",
"retVal",
"=",
"[",
"]",
"for",
"key",
",",
"group",
"in",
"groupby",
"(",
"hostlist",
")",
":",
"retVal",
".",
"append",
"(",
"(",
"key",
",",
"len",
"(",
"list",
"(",
"group",
")",
")",
")",
")",
"return",
"retVal"
] |
Return the hosts from the command line
|
[
"Return",
"the",
"hosts",
"from",
"the",
"command",
"line"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L187-L201
|
10,899
|
soravux/scoop
|
scoop/utils.py
|
parseSLURM
|
def parseSLURM(string):
"""Return a host list from a SLURM string"""
# Use scontrol utility to get the hosts list
import subprocess, os
hostsstr = subprocess.check_output(["scontrol", "show", "hostnames", string])
if sys.version_info.major > 2:
hostsstr = hostsstr.decode()
# Split using endline
hosts = hostsstr.split(os.linesep)
# Take out last empty host
hosts = filter(None, hosts)
# Create the desired pair of host and number of hosts
hosts = [(host, 1) for host in hosts]
return hosts
|
python
|
def parseSLURM(string):
"""Return a host list from a SLURM string"""
# Use scontrol utility to get the hosts list
import subprocess, os
hostsstr = subprocess.check_output(["scontrol", "show", "hostnames", string])
if sys.version_info.major > 2:
hostsstr = hostsstr.decode()
# Split using endline
hosts = hostsstr.split(os.linesep)
# Take out last empty host
hosts = filter(None, hosts)
# Create the desired pair of host and number of hosts
hosts = [(host, 1) for host in hosts]
return hosts
|
[
"def",
"parseSLURM",
"(",
"string",
")",
":",
"# Use scontrol utility to get the hosts list",
"import",
"subprocess",
",",
"os",
"hostsstr",
"=",
"subprocess",
".",
"check_output",
"(",
"[",
"\"scontrol\"",
",",
"\"show\"",
",",
"\"hostnames\"",
",",
"string",
"]",
")",
"if",
"sys",
".",
"version_info",
".",
"major",
">",
"2",
":",
"hostsstr",
"=",
"hostsstr",
".",
"decode",
"(",
")",
"# Split using endline",
"hosts",
"=",
"hostsstr",
".",
"split",
"(",
"os",
".",
"linesep",
")",
"# Take out last empty host",
"hosts",
"=",
"filter",
"(",
"None",
",",
"hosts",
")",
"# Create the desired pair of host and number of hosts",
"hosts",
"=",
"[",
"(",
"host",
",",
"1",
")",
"for",
"host",
"in",
"hosts",
"]",
"return",
"hosts"
] |
Return a host list from a SLURM string
|
[
"Return",
"a",
"host",
"list",
"from",
"a",
"SLURM",
"string"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L204-L217
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.